diff --git "a/python_ab_val.jsonl" "b/python_ab_val.jsonl" --- "a/python_ab_val.jsonl" +++ "b/python_ab_val.jsonl" @@ -1,1234 +1,1234 @@ -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_4 = str(var_4)\n if var_4[0] == var_4[-1] and var_4[1] == var_4[-2]:\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_6 in range(var_1, var_2 + 1):\n var_3 = str(var_6)\n var_5 = True\n for var_7 in range(len(var_3) // 2):\n if var_3[var_7] != var_3[-var_7 - 1] and var_5:\n var_5 = not var_5\n if var_5:\n var_4 += 1\nprint(var_4)\n```", "output": "SLOWER 1.6437", "pair_id": "python_p03416_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 3.1246} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n if list(str(var_4)) == list(reversed(str(var_4))):\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\ndef func_1():\n var_1, var_2 = list(map(int, input().rstrip().split()))\n var_3 = 0\n for var_4 in range(var_1, var_2 + 1):\n var_5 = str(var_4)\n if var_5 == var_5[::-1]:\n var_3 += 1\n print(var_3)\n\n\nif __name__ == \"__main__\":\n func_1()\n```", "output": "FASTER 2.1464", "pair_id": "python_p03416_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 4.4271} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().strip().split(\" \")))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n if str(var_4) == str(var_4)[::-1]:\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n if list(str(var_4)) == list(reversed(str(var_4))):\n var_3 += 1\nprint(var_3)\n```", "output": "SLOWER 1.0931", "pair_id": "python_p03416_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 2.1333} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\n\nvar_5 = sys.stdin.readline\n\n\ndef func_1():\n var_3 = var_5().rstrip()\n var_11 = [\"dream\", \"dreamer\", \"erase\", \"eraser\"]\n var_9 = \"YES\"\n var_7 = var_3\n var_6 = var_3\n while True:\n for var_4 in range(4):\n var_10 = var_11[var_4]\n var_2 = len(var_10)\n var_1 = len(var_6)\n if var_2 <= var_1:\n var_8 = var_6[var_1 - var_2 :]\n if var_8 == var_10:\n var_6 = var_6[: var_1 - var_2]\n if var_6 == \"\":\n break\n elif var_6 == var_7:\n var_9 = \"NO\"\n break\n else:\n var_7 = var_6\n print(var_9)\n\n\nfunc_1()\n```\n\n=== Code B (Modified) ===\n```python\nvar_1 = (\n input()\n .replace(\"eraser\", \" \")\n .replace(\"erase\", \" \")\n .replace(\"dreamer\", \" \")\n .replace(\"dream\", \" \")\n .replace(\" \", \"\")\n)\nif var_1:\n print(\"NO\")\nelse:\n print(\"YES\")\n```", "output": "FASTER 1.396", "pair_id": "python_p03854_forward", "problem_id": "p03854", "language": "python", "direction": "forward", "speedup_ratio": 2.6318} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_6 = str(var_4)\n var_5 = var_6[::-1]\n if var_6 == var_5:\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_3 in range(var_1, var_2 + 1):\n var_5 = list(str(var_3))\n var_6 = list(reversed(var_5))\n if var_5 == var_6:\n var_4 += 1\nprint(var_4)\n```", "output": "SLOWER 1.0582", "pair_id": "python_p03416_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 2.0824} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_6, var_5 = list(map(int, input().split()))\nvar_8 = [[] for _ in range(var_6)]\nfor var_2 in range(var_5):\n var_10, var_11 = input().split()\n var_8[int(var_10) - 1].append(var_11)\n\nvar_1, var_7 = 0, 0\nfor var_3 in range(var_6):\n var_9 = var_8[var_3]\n if \"AC\" in var_9:\n var_1 += 1\n for var_4 in var_9:\n if var_4 == \"WA\":\n var_7 += 1\n else:\n break\nprint((var_1, var_7))\n```\n\n=== Code B (Modified) ===\n```python\nvar_2, var_1 = list(map(int, input().split()))\nvar_6 = {}\nvar_3 = {}\nfor var_4 in range(var_1):\n var_5, var_7 = input().split()\n var_5 = int(var_5)\n if not var_5 in var_6:\n var_6[var_5] = 0\n var_3[var_5] = 0\n if var_7 == \"WA\" and var_3[var_5] == 0:\n var_6[var_5] += 1\n elif var_7 == \"AC\" and var_3[var_5] == 0:\n var_3[var_5] += 1\nfor var_4 in var_6:\n if var_6[var_4] != 0 and var_3[var_4] == 0:\n var_6[var_4] = 0\nprint((sum(var_3.values()), sum(var_6.values())))\n```", "output": "FASTER 4.403", "pair_id": "python_p02802_forward", "problem_id": "p02802", "language": "python", "direction": "forward", "speedup_ratio": 21.1554} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\ndef func_1():\n var_1, var_2 = list(map(int, input().split()))\n var_3 = 0\n for var_4 in range(var_1, var_2 + 1):\n\n if (var_4 % 10) == (var_4 // 10000 % 10) and (var_4 // 10 % 10) == (\n var_4 // 1000 % 10\n ):\n var_3 += 1\n print(var_3)\n\n\nif __name__ == \"__main__\":\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\n\n\ndef func_1(var_5, var_6):\n var_4 = 0\n for var_3 in range(var_5, var_6 + 1):\n if str(var_3) == str(var_3)[::-1]:\n var_4 += 1\n return var_4\n\n\nprint((func_1(var_1, var_2)))\n```", "output": "SLOWER 1.3404", "pair_id": "python_p03416_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 2.5323} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_5 = input()[::-1]\nvar_2 = [0] * 2019\nvar_2[0] = 1\nvar_4 = 0\nvar_6 = 1\nvar_1 = 0\nfor var_3 in var_5:\n var_4 = (var_4 + int(var_3) * var_6) % 2019\n var_6 = var_6 * 10 % 2019\n var_2[var_4] += 1\nfor var_3 in var_2:\n var_1 += var_3 * (var_3 - 1) // 2\nprint(var_1)\n```\n\n=== Code B (Modified) ===\n```python\nimport numpy as np\n\nvar_7 = input()[::-1]\nvar_6 = len(var_7)\nvar_1 = np.zeros(var_6, dtype=int)\nvar_4 = np.zeros(var_6, dtype=int)\nvar_2 = np.zeros(2019, dtype=int)\nvar_8 = 10\nvar_1[0] = int(var_7[0])\nvar_4[0] = var_1[0]\nvar_2[var_4[0]] += 1\nfor var_5 in range(1, var_6):\n var_1[var_5] = int(var_7[var_5]) * var_8 % 2019\n var_4[var_5] = (var_4[var_5 - 1] + var_1[var_5]) % 2019\n var_2[var_4[var_5]] += 1\n var_8 = var_8 * 10 % 2019\nvar_3 = var_2[np.nonzero(var_2)]\nprint(\n (\n int(\n sum([var_3[var_5] * (var_3[var_5] - 1) for var_5 in range(var_3.shape[0])])\n / 2\n )\n + var_2[0]\n )\n)\n```", "output": "FASTER 1.2996", "pair_id": "python_p02702_forward", "problem_id": "p02702", "language": "python", "direction": "forward", "speedup_ratio": 2.4616} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nfrom collections import Counter, defaultdict, deque\nfrom heapq import heappop, heappush, heapify\nimport sys, bisect, math, itertools, fractions, pprint\n\nsys.setrecursionlimit(10**8)\nvar_6 = 10**9 + 7\nvar_1 = float(\"inf\")\n\n\ndef func_1():\n return int(sys.stdin.readline())\n\n\ndef func_2():\n return list(map(int, sys.stdin.readline().split()))\n\n\nvar_7, var_9 = func_2()\nvar_13 = [func_2() for _ in range(var_7)]\nvar_13.sort(key=lambda var_14: var_14[1], reverse=True)\nvar_8 = 0\nvar_10 = min(var_7, 5)\nfor var_3 in range(var_10):\n var_2 = [[0] * (var_9 + 5) for _ in range(var_7 + 5)]\n for var_4 in range(var_7):\n var_12, var_11 = var_13[var_4]\n for var_5 in range(var_9):\n if var_5 < var_12 or var_3 == var_4:\n var_2[var_4 + 1][var_5] = var_2[var_4][var_5]\n else:\n var_2[var_4 + 1][var_5] = max(\n var_2[var_4][var_5], var_2[var_4][var_5 - var_12] + var_11\n )\n\n var_8 = max(var_2[var_7][var_9 - 1] + var_13[var_3][1], var_8)\nprint(var_8)\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\n\nvar_9 = sys.stdin.readline\nfrom operator import itemgetter\n\nvar_3, var_4 = list(map(int, var_9().split()))\nvar_1 = [list(map(int, var_9().split())) for _ in range(var_3)]\nvar_1.sort(key=itemgetter(0))\nvar_8 = [[0 for _ in range(var_3 + 1)] for _ in range(var_4 + 1)]\n\nvar_2 = []\nfor var_10 in range(var_3):\n var_5, var_7 = var_1[var_10]\n for var_11 in range(var_4):\n if var_5 > var_11:\n var_8[var_11][var_10 + 1] = var_8[var_11][var_10]\n else:\n if var_7 + var_8[var_11 - var_5][var_10] >= var_8[var_11][var_10]:\n var_8[var_11][var_10 + 1] = var_8[var_11 - var_5][var_10] + var_7\n else:\n var_8[var_11][var_10 + 1] = var_8[var_11][var_10]\n var_2.append(var_8[var_4 - 1][var_10] + var_7)\nvar_6 = max(var_2)\nprint(var_6)\n```", "output": "FASTER 1.6625", "pair_id": "python_p02863_forward", "problem_id": "p02863", "language": "python", "direction": "forward", "speedup_ratio": 3.1657} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_6, var_7 = list(map(int, input().split()))\nvar_1 = [list(map(int, input().split())) for _ in range(var_6)]\nvar_1.sort()\nvar_3 = [(6007) * [0] for _ in range(var_6 + 1)]\nvar_3[0][0] = 0\nvar_2 = 0\nfor var_4 in range(var_6):\n for var_5 in range(6007):\n var_3[var_4 + 1][var_5] = max(var_3[var_4 + 1][var_5], var_3[var_4][var_5])\n if var_5 < var_7:\n var_3[var_4 + 1][var_5 + var_1[var_4][0]] = max(\n var_3[var_4][var_5] + var_1[var_4][1],\n var_3[var_4][var_5 + var_1[var_4][0]],\n )\n var_2 = max(var_2, var_3[var_4 + 1][var_5])\nprint(var_2)\n```\n\n=== Code B (Modified) ===\n```python\nvar_8, var_9 = list(map(int, input().split()))\nvar_5 = [[0] * (var_9 + 3001) for _ in range(var_8 + 1)]\nvar_3 = 0\nvar_2 = [list(map(int, input().split())) for _ in range(var_8)]\nvar_2.sort()\nfor var_6 in range(1, var_8 + 1):\n var_1, var_4 = var_2[var_6 - 1]\n for var_7 in range(var_9):\n var_5[var_6][var_7] = max(var_5[var_6 - 1][var_7], var_5[var_6][var_7])\n var_5[var_6][var_7 + var_1] = var_5[var_6 - 1][var_7] + var_4\n var_3 = max(var_5[var_6][var_7], var_5[var_6][var_7 + var_1], var_3)\nprint(var_3)\n```", "output": "FASTER 5.2101", "pair_id": "python_p02863_forward", "problem_id": "p02863", "language": "python", "direction": "forward", "speedup_ratio": 37.0168} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_5 in range(10):\n for var_6 in range(10):\n for var_7 in range(10):\n var_3 = 10000 * var_5 + 1000 * var_6 + 100 * var_7 + 10 * var_6 + var_5\n if var_1 <= var_3 <= var_2:\n var_4 += 1\nprint(var_4)\n```\n\n=== Code B (Modified) ===\n```python\nvar_10 = []\nvar_10 = input().rstrip().split(\" \")\nvar_1 = int(var_10[0])\nvar_3 = int(var_10[1])\nvar_2 = 0\nvar_6 = var_1\nwhile var_6 <= var_3:\n var_4 = var_6 // 10000\n var_5 = (var_6 - var_4 * 10000) // 1000\n var_7 = var_6 // 100\n var_8 = (var_6 - var_7 * 100) // 10\n var_9 = var_6 % 10\n if (var_4 == var_9) and (var_5 == var_8):\n var_2 += 1\n var_6 += 1\nprint(var_2)\n```", "output": "SLOWER 4.6346", "pair_id": "python_p03416_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 24.8395} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_3 = list(map(int, input().split()))\nvar_2 = 0\nfor var_5 in range(var_3 + 1)[var_1:]:\n if len(str(var_5)) % 2 == 0:\n var_6 = list(str(var_5))[: len(str(var_5)) // 2]\n var_7 = list(reversed(list(str(var_5))[len(str(var_5)) // 2 :]))\n if var_6 == var_7:\n var_2 += 1\n else:\n var_8 = list(str(var_5))[: len(str(var_5)) // 2 + 1]\n var_4 = list(reversed(list(str(var_5))[len(str(var_5)) // 2 :]))\n if var_8 == var_4:\n var_2 += 1\nprint(var_2)\n```\n\n=== Code B (Modified) ===\n```python\nvar_4, var_3 = list(map(int, input().split()))\nvar_1 = 0\nfor var_2 in range(var_4, var_3 + 1):\n if str(var_2)[0] + str(var_2)[1] == str(var_2)[-1] + str(var_2)[-2]:\n var_1 += 1\nprint(var_1)\n```", "output": "FASTER 1.1334", "pair_id": "python_p03416_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 2.1938} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_8, var_9 = list(map(int, input().split()))\nvar_5 = [[0] * (var_9 + 3001) for _ in range(var_8 + 1)]\nvar_3 = 0\nvar_2 = [list(map(int, input().split())) for _ in range(var_8)]\nvar_2.sort()\nfor var_6 in range(1, var_8 + 1):\n var_1, var_4 = var_2[var_6 - 1]\n for var_7 in range(var_9):\n var_5[var_6][var_7] = max(var_5[var_6 - 1][var_7], var_5[var_6][var_7])\n var_5[var_6][var_7 + var_1] = var_5[var_6 - 1][var_7] + var_4\n var_3 = max(var_5[var_6][var_7], var_5[var_6][var_7 + var_1], var_3)\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\n\nsys.setrecursionlimit(2147483647)\nvar_2 = float(\"inf\")\nvar_3 = 10**9 + 7\nvar_10 = lambda: sys.stdin.readline().rstrip()\n\n\ndef func_1():\n var_11, var_4 = list(map(int, var_10().split()))\n var_1 = [tuple(map(int, var_10().split())) for _ in range(var_11)]\n var_1.sort()\n var_8 = [0] * var_4\n var_6 = -var_2\n for var_9 in range(var_11):\n var_5, var_7 = var_1[var_9]\n var_12 = var_8[:]\n for var_13 in range(var_4):\n if var_13 + var_5 < var_4:\n var_12[var_13 + var_5] = max(\n var_12[var_13 + var_5], var_8[var_13] + var_7\n )\n else:\n var_6 = max(var_6, var_8[var_13] + var_7)\n var_8 = var_12\n print((max(var_6, max(var_8))))\n\n\nfunc_1()\n```", "output": "FASTER 1.5497", "pair_id": "python_p02863_forward", "problem_id": "p02863", "language": "python", "direction": "forward", "speedup_ratio": 2.9276} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = [\n var_3 for var_3 in map(str, list(range(var_1, var_2 + 1))) if var_3 == var_3[::-1]\n]\nprint((len(var_4)))\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_3 in range(var_1, var_2 + 1):\n var_5 = list(str(var_3))\n var_6 = list(reversed(var_5))\n if var_5 == var_6:\n var_4 += 1\nprint(var_4)\n```", "output": "SLOWER 2.0072", "pair_id": "python_p03416_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 4.02} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\nimport math\nfrom collections import defaultdict\nfrom bisect import bisect_left, bisect_right\n\nsys.setrecursionlimit(10**7)\n\n\ndef func_4():\n return sys.stdin.readline()[:-1]\n\n\nvar_4 = 10**9 + 7\n\n\ndef func_1():\n return int(eval(func_4()))\n\n\ndef func_2():\n return list(map(int, func_4().split()))\n\n\ndef func_3(var_6, var_3):\n if var_6 <= 0:\n return [[] for _ in range(var_3)]\n elif var_3 == 1:\n return [func_1() for _ in range(var_6)]\n else:\n var_5 = [func_2() for _ in range(var_6)]\n return list(map(list, list(zip(*var_5))))\n\n\nvar_1, var_2 = list(map(str, func_4().split()))\nvar_1 = int(var_1)\nvar_2 = 100 * int(var_2[0]) + 10 * int(var_2[2]) + int(var_2[3])\nprint((var_1 * var_2 // 100))\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(str, input().split()))\nvar_1 = int(var_1)\nvar_2 = int(float(var_2) * 1000)\nprint((var_1 * var_2 // 1000))\n```", "output": "FASTER 2.3246", "pair_id": "python_p02659_forward", "problem_id": "p02659", "language": "python", "direction": "forward", "speedup_ratio": 5.0091} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport bisect, copy, heapq, math, sys\nfrom collections import *\nfrom functools import lru_cache\nfrom itertools import accumulate, combinations, permutations, product\n\n\ndef func_2():\n return sys.stdin.readline()[:-1]\n\n\ndef func_4(var_8):\n return [0] + list(accumulate(var_8))\n\n\ndef func_1(var_1, var_4):\n return -(-var_1 // var_4)\n\n\nsys.setrecursionlimit(5000000)\nvar_9 = pow(10, 9) + 7\nvar_2 = [chr(ord(\"a\") + var_6) for var_6 in range(26)]\nvar_5 = [[1, 0], [0, 1], [-1, 0], [0, -1]]\nvar_11 = int(eval(func_2()))\n\n\ndef func_3(var_10):\n if var_10 == 1:\n return False\n for var_7 in range(2, int(math.sqrt(var_10)) + 1):\n if var_10 % var_7 == 0:\n return False\n return True\n\n\nvar_3 = var_11\nwhile not func_3(var_3):\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_4 = int(eval(input()))\nvar_1 = 0\nif var_4 == 2:\n print((2))\nelse:\n for var_2 in range(var_4, 10**6):\n for var_3 in range(2, var_2 // 2 + 2):\n if var_2 % var_3 == 0:\n break\n else:\n var_1 = var_2\n break\n print(var_1)\n```", "output": "FASTER 1.4219", "pair_id": "python_p02819_forward", "problem_id": "p02819", "language": "python", "direction": "forward", "speedup_ratio": 2.6793} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\ndef func_1():\n from sys import setrecursionlimit, stdin\n from os import environ\n from collections import defaultdict, deque, Counter\n from math import ceil, floor, gcd\n from itertools import accumulate, combinations, combinations_with_replacement\n\n setrecursionlimit(10**6)\n var_7 = (\n (lambda *var_11: print(*var_11))\n if \"TERM_PROGRAM\" in environ\n else lambda *var_12: 0\n )\n var_8 = lambda: stdin.readline().rstrip()\n var_3 = lambda: list(map(int, var_8().split()))\n var_1 = lambda: int(var_8())\n var_4 = 10**9 + 7\n var_2 = 10**9 + 10\n var_9, var_10 = var_8().split()\n var_5 = int(var_9)\n var_10 = var_10.split(\".\")\n var_6 = int(var_10[0]) * 100\n if len(var_10) == 2:\n var_6 += int(var_10[1])\n print(var_5 * var_6 // 100)\n\n\nfunc_1()\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = input().split()\nvar_1 = int(var_1)\nvar_3, var_4 = list(map(int, var_2.split(\".\")))\nvar_5 = var_1 * (var_3 * 100 + var_4)\nprint((int(var_5 // 100)))\n```", "output": "FASTER 1.9258", "pair_id": "python_p02659_forward", "problem_id": "p02659", "language": "python", "direction": "forward", "speedup_ratio": 3.7995} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_4, var_3 = list(map(int, input().split()))\nvar_1 = 0\nfor var_2 in range(var_4, var_3 + 1):\n if str(var_2)[0] + str(var_2)[1] == str(var_2)[-1] + str(var_2)[-2]:\n var_1 += 1\nprint(var_1)\n```\n\n=== Code B (Modified) ===\n```python\nfrom sys import stdin\n\nvar_6 = lambda: list(map(int, stdin.readline().split()))\nvar_5 = lambda: list(map(int, stdin.readline().split()))\nvar_1, var_3 = var_6()\nvar_2 = 0\nfor var_4 in range(var_1, var_3 + 1):\n var_7 = str(var_4)\n if var_7 == var_7[::-1]:\n var_2 += 1\nprint(var_2)\n```", "output": "FASTER 1.3227", "pair_id": "python_p03416_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 2.5013} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\ndef func_1():\n var_2 = int(eval(input()))\n var_1 = [int(var_6) for var_6 in input().split()]\n var_4 = 3**var_2\n var_5 = len([var_3 for var_3 in var_1 if var_3 % 2 == 0])\n var_4 -= 2**var_5\n print(var_4)\n\n\nif __name__ == \"__main__\":\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nimport math\nimport string\n\n\ndef func_5():\n return list(map(int, input().split()))\n\n\ndef func_4(var_7, var_8):\n return math.factorial(var_7) // (\n math.factorial(var_7 - var_8) * math.factorial(var_8)\n )\n\n\ndef func_3(var_10):\n var_9 = []\n for var_5 in var_10:\n if not (var_5 in var_9):\n var_9.append(var_5)\n return len(var_10) != len(var_9)\n\n\ndef func_1(var_7):\n func_1 = []\n for var_4 in range(1, var_7 + 1):\n if var_7 % var_4 == 0:\n func_1.append(var_4)\n return func_1\n\n\nvar_2 = [-1, -1, -1, 0, 0, 1, 1, 1]\nvar_3 = [-1, 0, 1, -1, 1, -1, 0, 1]\nvar_7 = int(eval(input()))\nvar_1 = func_5()\n\n\ndef func_2(var_6):\n if len(var_6) == var_7:\n for var_4 in range(len(var_6)):\n if var_6[var_4] % 2 == 0:\n return 1\n return 0\n return (\n func_2(var_6 + [var_1[len(var_6)]])\n + func_2(var_6 + [var_1[len(var_6)] - 1])\n + func_2(var_6 + [var_1[len(var_6)] + 1])\n )\n\n\nprint((func_2([])))\n```", "output": "SLOWER 7.1332", "pair_id": "python_p03568_reversed", "problem_id": "p03568", "language": "python", "direction": "reversed", "speedup_ratio": 140.3806} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_7 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_3 = True\n var_8 = str(var_4)\n var_6 = len(var_8)\n for var_5 in range(var_6 // 2 + 1):\n if var_8[var_5] != var_8[-var_5 - 1]:\n var_3 = False\n break\n if var_3:\n var_7 += 1\nprint(var_7)\n```\n\n=== Code B (Modified) ===\n```python\nvar_4 = {}\nvar_5 = 0\nfor var_6 in range(10000, 100000):\n var_3 = list(str(var_6))\n if var_3 == list(reversed(var_3)):\n var_5 += 1\n var_4[var_6] = var_5\nvar_1, var_2 = list(map(int, input().split()))\nprint((var_4[var_2] - var_4[var_1 - 1] if var_1 > 10000 else var_4[var_2]))\n```", "output": "SLOWER 2.4485", "pair_id": "python_p03416_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 5.4585} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_6, var_7 = list(map(int, input().split()))\nvar_1 = [list(map(int, input().split())) for _ in range(var_6)]\nvar_1.sort()\nvar_3 = [(6007) * [0] for _ in range(var_6 + 1)]\nvar_3[0][0] = 0\nvar_2 = 0\nfor var_4 in range(var_6):\n for var_5 in range(6007):\n var_3[var_4 + 1][var_5] = max(var_3[var_4 + 1][var_5], var_3[var_4][var_5])\n if var_5 < var_7:\n var_3[var_4 + 1][var_5 + var_1[var_4][0]] = max(\n var_3[var_4][var_5] + var_1[var_4][1],\n var_3[var_4][var_5 + var_1[var_4][0]],\n )\n var_2 = max(var_2, var_3[var_4 + 1][var_5])\nprint(var_2)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_6 = sorted([list(map(int, input().split())) for var_5 in range(var_1)])\n\nvar_4 = [[0] * (var_2 + 1) for var_5 in range(var_1 + 1)]\n\nfor var_5 in range(var_1):\n var_9, var_8 = var_6[var_5]\n for var_7 in range(var_2 + 1):\n if var_7 + var_9 <= var_2:\n var_4[var_5 + 1][var_7 + var_9] = max(\n var_4[var_5 + 1][var_7 + var_9], var_4[var_5][var_7] + var_8\n )\n var_4[var_5 + 1][var_7] = max(var_4[var_5][var_7], var_4[var_5 + 1][var_7])\nvar_3 = 0\nfor var_5, (var_9, var_8) in enumerate(var_6):\n for var_7 in range(var_2):\n var_3 = max(var_3, var_4[var_5][var_7] + var_8)\nprint(var_3)\n```", "output": "FASTER 4.9584", "pair_id": "python_p02863_forward", "problem_id": "p02863", "language": "python", "direction": "forward", "speedup_ratio": 31.0909} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nfrom math import floor\n\nvar_1, var_2 = list(map(int, input().split()))\n\n\nfor var_3 in range(1010):\n if (floor(var_3 * 0.08) == var_1) and (floor(var_3 * 0.1) == var_2):\n\n print(var_3)\n quit()\n\n\nprint((-1))\n```\n\n=== Code B (Modified) ===\n```python\nimport math\n\nvar_1, var_4 = (int(var_10) for var_10 in input().split())\nvar_2 = math.ceil(var_1 / 0.08)\nvar_3 = math.ceil((var_1 + 1) / 0.08)\n\"\"\"\"\"\"\nvar_5 = math.ceil(var_4 / 0.1)\nvar_6 = math.ceil((var_4 + 1) / 0.1)\n\"\"\"\"\"\"\nvar_7 = list(range(var_2, var_3))\nvar_8 = list(range(var_5, var_6))\nvar_9 = set(var_7) & set(var_8)\nif len(var_9) == 0:\n print((-1))\nelse:\n print((min(var_9)))\n```", "output": "FASTER 1.1204", "pair_id": "python_p02755_forward", "problem_id": "p02755", "language": "python", "direction": "forward", "speedup_ratio": 2.1741} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nfrom sys import stdin\n\nvar_6 = lambda: list(map(int, stdin.readline().split()))\nvar_5 = lambda: list(map(int, stdin.readline().split()))\nvar_1, var_3 = var_6()\nvar_2 = 0\nfor var_4 in range(var_1, var_3 + 1):\n var_7 = str(var_4)\n if var_7 == var_7[::-1]:\n var_2 += 1\nprint(var_2)\n```\n\n=== Code B (Modified) ===\n```python\ndef func_1():\n var_1, var_2 = list(map(int, input().split()))\n var_3 = 0\n for var_4 in range(var_1, var_2 + 1):\n\n if (var_4 % 10) == (var_4 // 10000 % 10) and (var_4 // 10 % 10) == (\n var_4 // 1000 % 10\n ):\n var_3 += 1\n print(var_3)\n\n\nif __name__ == \"__main__\":\n func_1()\n```", "output": "FASTER 1.6824", "pair_id": "python_p03416_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 3.2097} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = list(reversed(list(str(var_4))))\n if var_5 == list(str(var_4)):\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_4 = str(var_4)\n if var_4 == var_4[::-1]:\n var_3 += 1\nprint(var_3)\n```", "output": "FASTER 1.5099", "pair_id": "python_p03416_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 2.848} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_7 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_3 = True\n var_8 = str(var_4)\n var_6 = len(var_8)\n for var_5 in range(var_6 // 2 + 1):\n if var_8[var_5] != var_8[-var_5 - 1]:\n var_3 = False\n break\n if var_3:\n var_7 += 1\nprint(var_7)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1 = list(map(int, input().split()))\nvar_2 = 0\nfor var_3 in range(var_1[0], var_1[1] + 1):\n var_4 = str(var_3)\n if var_4[0] == var_4[4] and var_4[1] == var_4[3]:\n var_2 += 1\nprint(var_2)\n```", "output": "FASTER 1.4139", "pair_id": "python_p03416_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 2.6646} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_5 in range(10):\n for var_6 in range(10):\n for var_7 in range(10):\n var_3 = 10000 * var_5 + 1000 * var_6 + 100 * var_7 + 10 * var_6 + var_5\n if var_1 <= var_3 <= var_2:\n var_4 += 1\nprint(var_4)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1 = list(map(int, input().split()))\nvar_2 = 0\nfor var_3 in range(var_1[0], var_1[1] + 1):\n var_4 = str(var_3)\n if var_4[0] == var_4[4] and var_4[1] == var_4[3]:\n var_2 += 1\nprint(var_2)\n```", "output": "SLOWER 3.5367", "pair_id": "python_p03416_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 11.6056} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nfrom decimal import Decimal\nimport math\n\nvar_1, var_2 = list(map(str, input().split()))\nvar_1 = int(var_1)\nvar_2 = Decimal(var_2)\nvar_3 = math.floor(var_1 * var_2)\nprint((int(var_3)))\n```\n\n=== Code B (Modified) ===\n```python\ndef func_1():\n from sys import setrecursionlimit, stdin\n from os import environ\n from collections import defaultdict, deque, Counter\n from math import ceil, floor, gcd\n from itertools import accumulate, combinations, combinations_with_replacement\n\n setrecursionlimit(10**6)\n var_7 = (\n (lambda *var_11: print(*var_11))\n if \"TERM_PROGRAM\" in environ\n else lambda *var_12: 0\n )\n var_8 = lambda: stdin.readline().rstrip()\n var_3 = lambda: list(map(int, var_8().split()))\n var_1 = lambda: int(var_8())\n var_4 = 10**9 + 7\n var_2 = 10**9 + 10\n var_9, var_10 = var_8().split()\n var_5 = int(var_9)\n var_6 = int(float(var_10) * 100 + 0.5)\n print(var_5 * var_6 // 100)\n\n\nfunc_1()\n```", "output": "SLOWER 1.6812", "pair_id": "python_p02659_reversed", "problem_id": "p02659", "language": "python", "direction": "reversed", "speedup_ratio": 3.207} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_4 = int(eval(input()))\nvar_1 = list(map(int, input().split()))\nvar_3 = 1\nfor var_2 in var_1:\n var_3 *= 2 if var_2 % 2 == 0 else 1\nprint((3**var_4 - var_3))\n```\n\n=== Code B (Modified) ===\n```python\nimport numpy as np\nfrom itertools import product\n\nvar_6 = int(eval(input()))\nvar_2 = list(map(int, input().split()))\nvar_2 = np.array(var_2)\nvar_5 = [-1, 0, 1]\nvar_3 = 0\nfor var_7 in product(var_5, repeat=var_6):\n var_7 = np.array(var_7)\n var_1 = var_2 + var_7\n var_4 = var_1.cumprod()\n if var_4[-1] % 2 == 0:\n var_3 += 1\nprint(var_3)\n```", "output": "SLOWER 10.1485", "pair_id": "python_p03568_reversed", "problem_id": "p03568", "language": "python", "direction": "reversed", "speedup_ratio": 1134.9796} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2, var_3 = list(map(int, input().split()))\nvar_4 = list(map(int, input().split()))\nvar_6 = list(map(int, input().split()))\nvar_5 = min(var_4) + min(var_6)\nfor var_7 in range(var_3):\n var_9, var_10, var_11 = list(map(int, input().split()))\n var_8 = var_4[var_9 - 1] + var_6[var_10 - 1] - var_11\n var_5 = var_8 if var_8 < var_5 else var_5\nprint(var_5)\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\nfrom collections import Counter\n\n\ndef func_10():\n return sys.stdin.readline().strip()\n\n\ndef func_11(var_12, var_13, var_14):\n return [[var_14] * var_13 for var_17 in range(var_12)]\n\n\ndef func_12(var_12, var_13, var_14, var_15):\n return [[[var_15] * var_14 for var_18 in range(var_13)] for var_17 in range(var_12)]\n\n\ndef func_13(var_12, var_13, var_14, var_15, var_16):\n return [\n [[[var_16] * var_15 for var_18 in range(var_14)] for var_18 in range(var_13)]\n for var_17 in range(var_12)\n ]\n\n\ndef func_8(var_22, var_23=1):\n return int(-(-var_22 // var_23))\n\n\ndef func_1():\n return int(eval(func_10()))\n\n\ndef func_3():\n return list(map(int, func_10().split()))\n\n\ndef func_2(var_11=None):\n return list(func_3()) if var_11 is None else [func_1() for var_17 in range(var_11)]\n\n\ndef func_7():\n print(\"Yes\")\n\n\ndef func_5():\n print(\"No\")\n\n\ndef func_6():\n print(\"YES\")\n\n\ndef func_4():\n print(\"NO\")\n\n\nsys.setrecursionlimit(10**9)\nvar_5 = 10**18\nvar_10 = 10**9 + 7\n\n\ndef func_9(var_1, var_2):\n \"\"\"\"\"\"\n import numpy as np\n from numpy.fft import rfft, irfft\n\n var_8 = max(var_1)\n var_9 = max(var_2)\n var_3 = [0] * (var_8 + 1)\n var_4 = [0] * (var_9 + 1)\n for var_12 in var_1:\n var_3[var_12] += 1\n for var_13 in var_2:\n var_4[var_13] += 1\n\n var_6 = 1\n var_19 = 0\n while var_6 <= var_8 + var_9:\n var_19 += 1\n var_6 = 2**var_19\n\n var_21 = irfft(rfft(var_3, var_6) * rfft(var_4, var_6), var_6)\n\n var_21 = np.rint(var_21).astype(np.int64)\n return var_21\n\n\nvar_11, var_7, var_6 = func_3()\nvar_1 = func_2()\nvar_2 = func_2()\nvar_21 = list(func_9(var_1, var_2))\nvar_20 = var_5\nfor var_17, var_12 in enumerate(var_21):\n if var_12 != 0:\n var_20 = var_17\n break\nfor _ in range(var_6):\n var_22, var_23, var_14 = func_3()\n var_22 -= 1\n var_23 -= 1\n var_20 = min(var_20, var_1[var_22] + var_2[var_23] - var_14)\nprint(var_20)\n```", "output": "SLOWER 3.1814", "pair_id": "python_p02748_reversed", "problem_id": "p02748", "language": "python", "direction": "reversed", "speedup_ratio": 9.0716} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = input().split()\nvar_1 = int(var_1)\nvar_2 = int(var_2)\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = list(str(var_4))\n if (var_5[0] == var_5[4]) and (var_5[1] == var_5[3]):\n var_3 = var_3 + 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().rstrip().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = list(map(int, list(str(var_4))))\n if var_5[0] == var_5[4] and var_5[1] == var_5[3]:\n var_3 += 1\nprint(var_3)\n```", "output": "SLOWER 1.2787", "pair_id": "python_p03416_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 2.4262} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_5 in range(10):\n for var_6 in range(10):\n for var_7 in range(10):\n var_3 = 10000 * var_5 + 1000 * var_6 + 100 * var_7 + 10 * var_6 + var_5\n if var_1 <= var_3 <= var_2:\n var_4 += 1\nprint(var_4)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = str(var_4)\n if var_5 == var_5[::-1]:\n var_3 += 1\nprint(var_3)\n```", "output": "SLOWER 3.8211", "pair_id": "python_p03416_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 14.1339} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = list(reversed(list(str(var_4))))\n if var_5 == list(str(var_4)):\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nfrom sys import stdin\n\nvar_6 = lambda: list(map(int, stdin.readline().split()))\nvar_5 = lambda: list(map(int, stdin.readline().split()))\nvar_1, var_3 = var_6()\nvar_2 = 0\nfor var_4 in range(var_1, var_3 + 1):\n var_7 = str(var_4)\n if var_7 == var_7[::-1]:\n var_2 += 1\nprint(var_2)\n```", "output": "FASTER 1.6385", "pair_id": "python_p03416_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 3.1135} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1 = int(eval(input()))\nvar_3 = 0\nfor var_2 in range(1000001):\n var_3 += 7 * pow(10, var_2, var_1)\n var_3 %= var_1\n if var_3 == 0:\n print((var_2 + 1))\n break\nelse:\n print((-1))\n```\n\n=== Code B (Modified) ===\n```python\ndef func_1(*var_2: str) -> str:\n var_3 = int(var_2[0])\n var_4 = 1\n var_1 = 7 % var_3\n while var_1:\n var_1 = (var_1 * 10 + 7) % var_3\n var_4 += 1\n if var_3 < var_4:\n var_4 = -1\n break\n return str(var_4)\n\n\nif __name__ == \"__main__\":\n print((func_1(*(open(0).read().splitlines()))))\n```", "output": "FASTER 3.1368", "pair_id": "python_p02596_forward", "problem_id": "p02596", "language": "python", "direction": "forward", "speedup_ratio": 8.7958} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\nfrom operator import itemgetter\nfrom heapq import heapify, heappop, heappush\n\nvar_1 = int(10e15)\nvar_2 = -var_1\nvar_11 = 1000000007\nsys.setrecursionlimit(1000000)\n\n\ndef func_2():\n return list(map(int, input().split()))\n\n\ndef func_4():\n return input().split()\n\n\ndef func_1():\n return int(sys.stdin.readline())\n\n\ndef func_3():\n return eval(input())\n\n\nvar_3, var_4 = func_2()\nvar_5 = [func_2() for var_9 in range(var_3)]\nvar_5.sort(key=itemgetter(0))\n\nvar_8 = [[0] * (var_4 + 1 + 3000 + 1) for _ in range(var_3 + 1)]\nvar_6 = 0\nfor var_9 in range(var_3):\n for var_10 in range(var_4 + 1 + 3000 + 1):\n var_12, var_7 = var_5[var_9]\n if 0 <= var_10 - var_12 < var_4:\n var_8[var_9 + 1][var_10] = max(\n var_8[var_9][var_10], var_8[var_9][var_10 - var_12] + var_7\n )\n else:\n var_8[var_9 + 1][var_10] = var_8[var_9][var_10]\n var_6 = max(var_6, var_8[var_9 + 1][var_10])\nprint(var_6)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_6 = sorted([list(map(int, input().split())) for var_5 in range(var_1)])\n\nvar_4 = [[0] * (var_2 + 1) for var_5 in range(var_1 + 1)]\n\nfor var_5 in range(var_1):\n var_9, var_8 = var_6[var_5]\n for var_7 in range(var_2 + 1):\n if var_7 + var_9 <= var_2:\n var_4[var_5 + 1][var_7 + var_9] = max(\n var_4[var_5 + 1][var_7 + var_9], var_4[var_5][var_7] + var_8\n )\n var_4[var_5 + 1][var_7] = max(var_4[var_5][var_7], var_4[var_5 + 1][var_7])\nvar_3 = 0\nfor var_5, (var_9, var_8) in enumerate(var_6):\n var_3 = max(var_3, var_4[var_5][var_2 - 1] + var_8)\nprint(var_3)\n```", "output": "FASTER 4.4103", "pair_id": "python_p02863_forward", "problem_id": "p02863", "language": "python", "direction": "forward", "speedup_ratio": 21.263} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport bisect, copy, heapq, math, sys\nfrom collections import *\nfrom functools import lru_cache\nfrom itertools import accumulate, combinations, permutations, product\n\n\ndef func_2():\n return sys.stdin.readline()[:-1]\n\n\ndef func_4(var_8):\n return [0] + list(accumulate(var_8))\n\n\ndef func_1(var_1, var_4):\n return -(-var_1 // var_4)\n\n\nsys.setrecursionlimit(5000000)\nvar_9 = pow(10, 9) + 7\nvar_2 = [chr(ord(\"a\") + var_6) for var_6 in range(26)]\nvar_5 = [[1, 0], [0, 1], [-1, 0], [0, -1]]\nvar_11 = int(eval(func_2()))\n\n\ndef func_3(var_10):\n if var_10 == 1:\n return False\n for var_7 in range(2, int(math.sqrt(var_10)) + 1):\n if var_10 % var_7 == 0:\n return False\n return True\n\n\nvar_3 = var_11\nwhile not func_3(var_3):\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\ndef func_1(var_3):\n var_4 = int(var_3)\n for var_1 in range(var_4, 2 * var_4):\n for var_2 in range(2, int(var_1**0.5)):\n if var_1 % var_2 == 0:\n break\n else:\n return str(var_1)\n\n\nif __name__ == \"__main__\":\n import sys\n\n print((func_1(sys.stdin.read().strip())))\n```", "output": "FASTER 1.4975", "pair_id": "python_p02819_forward", "problem_id": "p02819", "language": "python", "direction": "forward", "speedup_ratio": 2.8236} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n if str(var_4) == \"\".join(reversed(str(var_4))):\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_3 = list(map(int, input().split()))\nvar_2 = 0\nfor var_5 in range(var_3 + 1)[var_1:]:\n if len(str(var_5)) % 2 == 0:\n var_6 = list(str(var_5))[: len(str(var_5)) // 2]\n var_7 = list(reversed(list(str(var_5))[len(str(var_5)) // 2 :]))\n if var_6 == var_7:\n var_2 += 1\n else:\n var_8 = list(str(var_5))[: len(str(var_5)) // 2 + 1]\n var_4 = list(reversed(list(str(var_5))[len(str(var_5)) // 2 :]))\n if var_8 == var_4:\n var_2 += 1\nprint(var_2)\n```", "output": "SLOWER 1.3983", "pair_id": "python_p03416_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 2.6359} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_3 = int(input())\nvar_6 = list(map(int, input().split()))\nvar_7 = list(map(int, input().split()))\nvar_1 = [abs(var_4 - var_5) for var_4, var_5 in zip(var_6, var_7)]\nvar_2 = lambda var_3: sum([var_4**var_3 for var_4 in var_1]) ** (1 / var_3)\nprint(var_2(1), var_2(2), var_2(3), max(var_1), sep=\"\\n\")\n```\n\n=== Code B (Modified) ===\n```python\nvar_5 = int(eval(input()))\nvar_7 = list(map(int, input().split()))\nvar_8 = list(map(int, input().split()))\nvar_6 = [[0 for var_2 in range(6)] for var_3 in range(var_5 + 1)]\nvar_1 = abs(var_7[0] - var_8[0])\nvar_6[0][3] = var_6[0][0] = var_1\nvar_6[0][4] = var_6[0][1] = var_1**2\nvar_6[0][5] = var_6[0][2] = var_1**3\nvar_4 = var_1\nfor var_2 in range(1, var_5, 1):\n var_1 = abs(var_7[var_2] - var_8[var_2])\n var_6[var_2][0] = var_1\n var_6[var_2][1] = var_1**2\n var_6[var_2][2] = var_6[var_2][1] * var_1\n var_6[var_2][3] = var_6[var_2 - 1][3] + var_6[var_2][0]\n var_6[var_2][4] = var_6[var_2 - 1][4] + var_6[var_2][1]\n var_6[var_2][5] = var_6[var_2 - 1][5] + var_6[var_2][2]\n if var_1 > var_4:\n var_4 = var_1\nprint((var_6[var_5 - 1][3]))\nprint((var_6[var_5 - 1][4] ** (1 / 2)))\nprint((var_6[var_5 - 1][5] ** (1 / 3)))\nprint(var_4)\n```", "output": "SLOWER 1.2213", "pair_id": "python_p02382_reversed", "problem_id": "p02382", "language": "python", "direction": "reversed", "speedup_ratio": 2.3316} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = list(str(var_4))\n if var_5 == list(reversed(var_5)):\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_5 in range(var_1, var_2 + 1):\n var_3 = str(var_5)\n if var_3[0] == var_3[-1] and var_3[1] == var_3[-2]:\n var_4 += 1\nprint(var_4)\n```", "output": "FASTER 1.3238", "pair_id": "python_p03416_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 2.5032} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_5 in range(var_1, var_2 + 1):\n var_3 = str(var_5)\n if var_3[0] == var_3[-1] and var_3[1] == var_3[-2]:\n var_4 += 1\nprint(var_4)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\n\n\ndef func_1(var_5):\n var_4 = 0\n for var_3 in range(1, var_5 + 1):\n if str(var_3) == str(var_3)[::-1]:\n var_4 += 1\n return var_4\n\n\nprint((func_1(var_2) - func_1(var_1 - 1)))\n```", "output": "SLOWER 1.6822", "pair_id": "python_p03416_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 3.2092} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\ndef func_1():\n var_2, var_3, *var_1 = list(map(int, open(0).read().split()))\n var_4 = [0] * (var_3 + max(var_1[::2]))\n for var_7, var_6 in sorted(zip(*[iter(var_1)] * 2)):\n for var_5 in reversed(list(range(var_3))):\n var_4[var_5 + var_7] = max(var_4[var_5 + var_7], var_4[var_5] + var_6)\n print((max(var_4)))\n\n\nfunc_1()\n```\n\n=== Code B (Modified) ===\n```python\nfrom sys import stdin\n\n\ndef func_1():\n\n var_9 = stdin.readline\n var_8, var_10 = list(map(int, var_9().split()))\n var_7 = [list(map(int, var_9().split())) for _ in range(var_8)]\n var_7.sort()\n var_1 = [0] * var_8\n var_2 = [0] * var_8\n for var_4 in range(var_8):\n var_1[var_4], var_2[var_4] = var_7[var_4][0], var_7[var_4][1]\n\n var_5 = -(10**9)\n var_3 = [[var_5] * (var_10 + 1) for _ in range(var_8 + 1)]\n var_3[0][0] = 0\n for var_4 in range(var_8):\n for var_6 in range(var_10 + 1):\n\n if var_6 != var_10:\n var_3[var_4 + 1][min(var_10, var_6 + var_1[var_4])] = max(\n var_3[var_4 + 1][min(var_10, var_6 + var_1[var_4])],\n var_3[var_4][var_6] + var_2[var_4],\n )\n\n var_3[var_4 + 1][var_6] = max(var_3[var_4 + 1][var_6], var_3[var_4][var_6])\n print((max(var_3[var_8])))\n\n\nif __name__ == \"__main__\":\n func_1()\n```", "output": "SLOWER 1.1965", "pair_id": "python_p02863_reversed", "problem_id": "p02863", "language": "python", "direction": "reversed", "speedup_ratio": 2.2918} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport bisect\nimport sys\n\nsys.setrecursionlimit(10**6)\nvar_16 = sys.stdout.write\nvar_7 = lambda *var_14: print(*var_14) if var_1 else 0\nvar_1 = True\n\n\ndef func_1(var_9=sys.stdin.readline):\n var_11 = lambda: var_9().rstrip()\n var_3 = lambda: list(map(int, var_11().split()))\n var_2 = lambda: int(var_11())\n var_4 = lambda var_17: [var_3() for _ in range(var_17)]\n var_13, var_15 = var_3()\n var_5 = var_4(var_13)\n var_5.sort()\n var_8 = [[0] * var_15 for _ in range(var_13 + 1)]\n for var_10 in range(1, var_13 + 1):\n for var_12 in range(1, var_15):\n if var_12 < var_5[var_10 - 1][0]:\n var_8[var_10][var_12] = var_8[var_10 - 1][var_12]\n else:\n var_8[var_10][var_12] = max(\n var_8[var_10 - 1][var_12],\n var_8[var_10 - 1][var_12 - var_5[var_10 - 1][0]]\n + var_5[var_10 - 1][1],\n )\n var_6 = 0\n for var_10 in range(var_13):\n var_6 = max(var_6, var_8[var_10][var_15 - 1] + var_5[var_10][1])\n print(var_6)\n\n\nif __name__ == \"__main__\":\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nvar_6, var_7 = list(map(int, input().split()))\nvar_1 = [list(map(int, input().split())) for _ in range(var_6)]\nvar_1.sort()\nvar_3 = [(6007) * [0] for _ in range(var_6 + 1)]\nvar_3[0][0] = 0\nvar_2 = 0\nfor var_4 in range(var_6):\n for var_5 in range(6007):\n var_3[var_4 + 1][var_5] = max(var_3[var_4 + 1][var_5], var_3[var_4][var_5])\n if var_5 < var_7:\n var_3[var_4 + 1][var_5 + var_1[var_4][0]] = max(\n var_3[var_4][var_5] + var_1[var_4][1],\n var_3[var_4][var_5 + var_1[var_4][0]],\n )\n var_2 = max(var_2, var_3[var_4 + 1][var_5])\nprint(var_2)\n```", "output": "SLOWER 6.1246", "pair_id": "python_p02863_reversed", "problem_id": "p02863", "language": "python", "direction": "reversed", "speedup_ratio": 69.7734} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\ndef func_1():\n var_2 = int(eval(input()))\n var_1 = [int(var_6) for var_6 in input().split()]\n var_4 = 3**var_2\n var_5 = len([var_3 for var_3 in var_1 if var_3 % 2 == 0])\n var_4 -= 2**var_5\n print(var_4)\n\n\nif __name__ == \"__main__\":\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nimport math\nimport string\n\n\ndef func_4():\n return list(map(int, input().split()))\n\n\ndef func_3(var_6, var_7):\n return math.factorial(var_6) // (\n math.factorial(var_6 - var_7) * math.factorial(var_7)\n )\n\n\ndef func_2(var_9):\n var_8 = []\n for var_5 in var_9:\n if not (var_5 in var_8):\n var_8.append(var_5)\n return len(var_9) != len(var_8)\n\n\ndef func_1(var_6):\n func_1 = []\n for var_4 in range(1, var_6 + 1):\n if var_6 % var_4 == 0:\n func_1.append(var_4)\n return func_1\n\n\nvar_2 = [-1, -1, -1, 0, 0, 1, 1, 1]\nvar_3 = [-1, 0, 1, -1, 1, -1, 0, 1]\nvar_6 = int(eval(input()))\nvar_1 = func_4()\nvar_10 = 1\nfor var_4 in range(len(var_1)):\n if var_1[var_4] % 2 == 0:\n var_10 *= 2\n else:\n var_10 *= 1\nprint((3 ** len(var_1) - var_10))\n```", "output": "SLOWER 1.1807", "pair_id": "python_p03568_reversed", "problem_id": "p03568", "language": "python", "direction": "reversed", "speedup_ratio": 2.2669} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\nimport math\nfrom collections import defaultdict\nfrom bisect import bisect_left, bisect_right\n\nsys.setrecursionlimit(10**7)\n\n\ndef func_4():\n return sys.stdin.readline()[:-1]\n\n\nvar_4 = 10**9 + 7\n\n\ndef func_1():\n return int(eval(func_4()))\n\n\ndef func_2():\n return list(map(int, func_4().split()))\n\n\ndef func_3(var_6, var_3):\n if var_6 <= 0:\n return [[] for _ in range(var_3)]\n elif var_3 == 1:\n return [func_1() for _ in range(var_6)]\n else:\n var_5 = [func_2() for _ in range(var_6)]\n return list(map(list, list(zip(*var_5))))\n\n\nvar_1, var_2 = list(map(str, func_4().split()))\nvar_1 = int(var_1)\nvar_2 = 100 * int(var_2[0]) + 10 * int(var_2[2]) + int(var_2[3])\nprint((var_1 * var_2 // 100))\n```\n\n=== Code B (Modified) ===\n```python\nimport math\n\nvar_1, var_2 = input().split()\nvar_1 = int(var_1)\nvar_3 = int(var_2[0] + var_2[2] + var_2[3])\nprint((var_1 * var_3 // 100))\n```", "output": "FASTER 2.3564", "pair_id": "python_p02659_forward", "problem_id": "p02659", "language": "python", "direction": "forward", "speedup_ratio": 5.1208} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = [0] * (var_2 + 1)\nfor var_3 in range(1, var_2 + 1):\n if str(var_3) == str(var_3)[::-1]:\n var_4[var_3] = var_4[var_3 - 1] + 1\n else:\n var_4[var_3] = var_4[var_3 - 1]\nprint((var_4[var_2] - var_4[var_1 - 1]))\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_5 in range(var_1, var_2 + 1):\n var_3 = str(var_5)\n if var_3[0] == var_3[-1] and var_3[1] == var_3[-2]:\n var_4 += 1\nprint(var_4)\n```", "output": "FASTER 2.0339", "pair_id": "python_p03416_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 4.095} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_4 = {}\nvar_5 = 0\nfor var_6 in range(10000, 100000):\n var_3 = list(str(var_6))\n if var_3 == list(reversed(var_3)):\n var_5 += 1\n var_4[var_6] = var_5\nvar_1, var_2 = list(map(int, input().split()))\nprint((var_4[var_2] - var_4[var_1 - 1] if var_1 > 10000 else var_4[var_2]))\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n if list(str(var_4)) == list(reversed(str(var_4))):\n var_3 += 1\nprint(var_3)\n```", "output": "FASTER 2.1733", "pair_id": "python_p03416_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 4.5104} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_4 = {}\nvar_5 = 0\nfor var_6 in range(10000, 100000):\n var_3 = list(str(var_6))\n if var_3 == list(reversed(var_3)):\n var_5 += 1\n var_4[var_6] = var_5\nvar_1, var_2 = list(map(int, input().split()))\nprint((var_4[var_2] - var_4[var_1 - 1] if var_1 > 10000 else var_4[var_2]))\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_6 in range(var_1, var_2 + 1):\n var_3 = str(var_6)\n var_5 = True\n for var_7 in range(len(var_3) // 2):\n if var_3[var_7] != var_3[-var_7 - 1] and var_5:\n var_5 = not var_5\n if var_5:\n var_4 += 1\nprint(var_4)\n```", "output": "FASTER 2.1137", "pair_id": "python_p03416_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 4.3279} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n if str(var_4) == \"\".join(reversed(str(var_4))):\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_5 in range(10):\n for var_6 in range(10):\n for var_7 in range(10):\n var_3 = 10000 * var_5 + 1000 * var_6 + 100 * var_7 + 10 * var_6 + var_5\n if var_1 <= var_3 <= var_2:\n var_4 += 1\nprint(var_4)\n```", "output": "FASTER 4.9018", "pair_id": "python_p03416_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 29.8943} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_6 = str(var_4)\n var_5 = var_6[::-1]\n if var_6 == var_5:\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\ndef func_1():\n var_1, var_2 = list(map(int, input().split()))\n var_3 = 0\n for var_4 in range(var_1, var_2 + 1):\n\n if (var_4 % 10) == (var_4 // 10000 % 10) and (var_4 // 10 % 10) == (\n var_4 // 1000 % 10\n ):\n var_3 += 1\n print(var_3)\n\n\nif __name__ == \"__main__\":\n func_1()\n```", "output": "FASTER 1.9144", "pair_id": "python_p03416_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 3.7697} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\ndef func_1():\n var_1, var_2 = list(map(int, input().split()))\n var_3 = 0\n for var_4 in range(var_1, var_2 + 1):\n\n if (var_4 % 10) == (var_4 // 10000 % 10) and (var_4 // 10 % 10) == (\n var_4 // 1000 % 10\n ):\n var_3 += 1\n print(var_3)\n\n\nif __name__ == \"__main__\":\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nvar_10 = []\nvar_10 = input().rstrip().split(\" \")\nvar_1 = int(var_10[0])\nvar_3 = int(var_10[1])\nvar_2 = 0\nvar_6 = var_1\nwhile var_6 <= var_3:\n var_4 = var_6 // 10000\n var_5 = (var_6 - var_4 * 10000) // 1000\n var_7 = var_6 // 100\n var_8 = (var_6 - var_7 * 100) // 10\n var_9 = var_6 % 10\n if (var_4 == var_9) and (var_5 == var_8):\n var_2 += 1\n var_6 += 1\nprint(var_2)\n```", "output": "SLOWER 2.4731", "pair_id": "python_p03416_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 5.5522} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport itertools\n\nvar_6 = int(eval(input()))\nvar_2 = [[]] * var_6\nfor var_4 in range(var_6):\n var_3 = list(map(int, input().split()))\n\n var_2[var_4] = var_3\nvar_8 = [[]] * var_6\nfor var_4 in range(var_6):\n var_9 = list(map(int, input().split()))\n var_8[var_4] = var_9\nvar_10 = -(10**11)\nfor var_1 in itertools.product([0, 1], repeat=10):\n if sum(var_1) == 0:\n continue\n var_11 = 0\n for var_7 in range(var_6):\n var_5 = 0\n for var_4 in range(10):\n if var_2[var_7][var_4] == 1 and var_1[var_4] == 1:\n var_5 += 1\n var_11 = var_11 + var_8[var_7][var_5]\n var_10 = max(var_10, var_11)\nprint(var_10)\n```\n\n=== Code B (Modified) ===\n```python\nfrom sys import stdin\n\n\ndef func_1():\n\n var_11 = stdin.readline\n var_2 = int(var_11())\n var_1 = []\n for var_6 in range(var_2):\n var_5 = int(\"\".join(var_11().strip().split(\" \")), 2)\n var_1.append(var_5)\n var_3 = []\n for var_6 in range(var_2):\n var_10 = list(map(int, var_11().split()))\n var_3.append(var_10)\n var_8 = float(\"-inf\")\n for var_9 in range(1, 1 << 10):\n var_12 = 0\n for var_7 in range(var_2):\n var_4 = bin(var_9 & var_1[var_7]).count(\"1\")\n var_12 += var_3[var_7][var_4]\n var_8 = max(var_12, var_8)\n print(var_8)\n\n\nif __name__ == \"__main__\":\n func_1()\n```", "output": "FASTER 2.8495", "pair_id": "python_p03503_forward", "problem_id": "p03503", "language": "python", "direction": "forward", "speedup_ratio": 7.2074} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_4, var_3 = list(map(int, input().split()))\nvar_1 = 0\nfor var_2 in range(var_4, var_3 + 1):\n if str(var_2)[0] + str(var_2)[1] == str(var_2)[-1] + str(var_2)[-2]:\n var_1 += 1\nprint(var_1)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_5 in range(var_1, var_2 + 1):\n var_3 = str(var_5)\n if var_3[0] == var_3[-1] and var_3[1] == var_3[-2]:\n var_4 += 1\nprint(var_4)\n```", "output": "FASTER 1.4327", "pair_id": "python_p03416_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 2.6995} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nfrom math import floor\n\nvar_1, var_2 = list(map(int, input().split()))\n\n\nfor var_3 in range(1010):\n if (floor(var_3 * 0.08) == var_1) and (floor(var_3 * 0.1) == var_2):\n\n print(var_3)\n quit()\n\n\nprint((-1))\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_2 = var_2 / 0.1\nvar_3 = [var_4 + var_2 for var_4 in range(10)]\nfor var_4 in var_3:\n if int(var_4 * 0.08) == var_1:\n print((int(var_4)))\n exit()\nprint(\"-1\")\n```", "output": "FASTER 1.8373", "pair_id": "python_p02755_forward", "problem_id": "p02755", "language": "python", "direction": "forward", "speedup_ratio": 3.5734} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_11 = int(eval(input()))\nvar_12 = {var_8: [] for var_8 in range(1, var_11 + 1)}\nvar_19 = [False for var_8 in range(var_11 + 1)]\nvar_16 = []\nfor _ in range(var_11 - 1):\n var_2, var_3 = list(map(int, input().split()))\n var_12[var_2].append(var_3)\n var_12[var_3].append(var_2)\n var_16.append((var_2, var_3))\nvar_9 = var_16[0][0]\nvar_19[var_9] = True\nvar_6 = []\nvar_7 = []\nvar_14 = {var_8: {} for var_8 in range(1, var_11 + 1)}\nvar_10 = [0 for var_8 in range(var_11 + 1)]\n\nvar_4 = 1\nfor var_5 in var_12[var_9]:\n var_19[var_5] = True\n var_14[var_9][var_5] = var_4\n var_14[var_5][var_9] = var_4\n var_10[var_5] = var_4\n var_4 += 1\n var_6.append(var_5)\nwhile var_6:\n for var_15 in var_6:\n var_13 = 1\n for var_5 in var_12[var_15]:\n if var_19[var_5] == False:\n var_19[var_5] = True\n if var_13 != var_10[var_15]:\n var_14[var_15][var_5] = var_13\n var_14[var_5][var_15] = var_13\n var_10[var_5] = var_13\n var_13 += 1\n var_7.append(var_5)\n else:\n var_13 += 1\n var_14[var_15][var_5] = var_13\n var_14[var_5][var_15] = var_13\n var_10[var_5] = var_13\n var_13 += 1\n var_7.append(var_5)\n if var_7:\n var_6 = var_7\n var_7 = []\n else:\n var_6 = []\n var_7 = []\nvar_1 = 0\nfor var_8 in range(1, var_11 + 1):\n var_1 = max(var_1, len(var_12[var_8]))\nprint(var_1)\nfor var_8 in range(var_11 - 1):\n var_17, var_18 = var_16[var_8][0], var_16[var_8][1]\n print((var_14[var_17][var_18]))\n```\n\n=== Code B (Modified) ===\n```python\nvar_8 = int(eval(input()))\nvar_6 = []\nfor var_7 in range(var_8 - 1):\n var_1, var_3 = list(map(int, input().split()))\n var_6.append([var_1 - 1, var_3 - 1, var_7])\nvar_6.sort()\nvar_12 = [0] * (var_8)\nvar_2 = [0] * (var_8 - 1)\nvar_9 = 1\nvar_10 = 0\nfor var_5 in var_6:\n _from, var_11, var_7 = var_5\n if _from != var_10:\n var_9 = 1\n if var_12[_from] == var_9:\n var_9 += 1\n var_2[var_7] = var_9\n var_12[var_11] = var_9\n var_9 += 1\n var_10 = _from\nprint((max(var_2)))\nfor var_4 in var_2:\n print(var_4)\n```", "output": "FASTER 1.2591", "pair_id": "python_p02850_forward", "problem_id": "p02850", "language": "python", "direction": "forward", "speedup_ratio": 2.3934} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport bisect\n\nvar_9, var_4, var_1 = list(map(int, input().split()))\nvar_5 = [None] * var_9\nfor var_7 in range(var_9):\n var_11, var_6 = list(map(int, input().split()))\n var_5[var_7] = (var_11, var_6)\nvar_5.sort()\nvar_11 = [int(var_5[var_7][0]) for var_7 in range(var_9)]\nvar_6 = [int(var_5[var_7][1]) for var_7 in range(var_9)]\nvar_2 = 0\nvar_3 = [0] * var_9\nfor var_7 in range(var_9):\n if var_7 != 0:\n var_3[var_7] += var_3[var_7 - 1]\n if var_3[var_7] >= var_6[var_7]:\n continue\n var_10 = (var_6[var_7] - var_3[var_7] - 1) // var_1 + 1\n var_2 += var_10\n var_3[var_7] += var_10 * var_1\n var_8 = bisect.bisect_right(var_11, var_11[var_7] + 2 * var_4)\n if var_8 == var_9:\n continue\n var_3[var_8] -= var_10 * var_1\nprint(var_2)\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\n\nsys.setrecursionlimit(500000)\n\n\ndef func_2():\n return sys.stdin.readline()[:-1]\n\n\nclass Class_1:\n def __init__(self, var_12):\n self.n = var_12\n self.N0 = 1 << var_12.bit_length()\n self.data = [0] * (self.N0 * 2)\n\n def func_5(self, var_11, var_13, var_16):\n var_11 += self.N0\n var_13 += self.N0\n while var_11 < var_13:\n if var_11 & 1:\n self.data[var_11] = self.data[var_11] + var_16\n var_11 += 1\n if var_13 & 1:\n self.data[var_13 - 1] = self.data[var_13 - 1] + var_16\n var_13 -= 1\n var_11 //= 2\n var_13 //= 2\n\n def func_4(self, var_8):\n var_8 += len(self.data) // 2\n var_14 = self.data[var_8]\n while var_8 > 0:\n var_8 //= 2\n var_14 = var_14 + self.data[var_8]\n return var_14\n\n\ndef func_3():\n var_3, var_2, var_1 = list(map(int, func_2().split()))\n var_6 = []\n for var_8 in range(var_3):\n var_17, var_7 = list(map(int, func_2().split()))\n if var_7 % var_1 == 0:\n var_6.append([var_17, var_7 // var_1])\n else:\n var_6.append([var_17, var_7 // var_1 + 1])\n var_6.sort(key=lambda var_17: var_17[0])\n\n def func_1(var_9):\n var_17 = var_6[var_9][0]\n if var_6[var_3 - 1][0] <= var_17 + 2 * var_2:\n return var_3 - 1\n var_11 = var_9\n var_13 = var_3 - 1\n while var_13 - var_11 > 1:\n if var_6[(var_13 + var_11) // 2][0] <= var_17 + 2 * var_2:\n var_11 = (var_13 + var_11) // 2\n else:\n var_13 = (var_13 + var_11) // 2\n return var_11\n\n var_4 = Class_1(var_3)\n for var_8 in range(var_3):\n var_4.update(var_8, var_8 + 1, var_6[var_8][1])\n var_5 = 0\n for var_8 in range(var_3):\n var_15 = var_4.query(var_8)\n if var_15 > 0:\n var_5 += var_15\n var_10 = func_1(var_8)\n var_4.update(var_8, var_10 + 1, -var_15)\n print(var_5)\n\n\nif __name__ == \"__main__\":\n func_3()\n```", "output": "SLOWER 1.0618", "pair_id": "python_p02788_reversed", "problem_id": "p02788", "language": "python", "direction": "reversed", "speedup_ratio": 2.0876} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\nfrom collections import Counter\n\n\ndef func_10():\n return sys.stdin.readline().strip()\n\n\ndef func_11(var_12, var_13, var_14):\n return [[var_14] * var_13 for var_17 in range(var_12)]\n\n\ndef func_12(var_12, var_13, var_14, var_15):\n return [[[var_15] * var_14 for var_18 in range(var_13)] for var_17 in range(var_12)]\n\n\ndef func_13(var_12, var_13, var_14, var_15, var_16):\n return [\n [[[var_16] * var_15 for var_18 in range(var_14)] for var_18 in range(var_13)]\n for var_17 in range(var_12)\n ]\n\n\ndef func_8(var_22, var_23=1):\n return int(-(-var_22 // var_23))\n\n\ndef func_1():\n return int(eval(func_10()))\n\n\ndef func_3():\n return list(map(int, func_10().split()))\n\n\ndef func_2(var_11=None):\n return list(func_3()) if var_11 is None else [func_1() for var_17 in range(var_11)]\n\n\ndef func_7():\n print(\"Yes\")\n\n\ndef func_5():\n print(\"No\")\n\n\ndef func_6():\n print(\"YES\")\n\n\ndef func_4():\n print(\"NO\")\n\n\nsys.setrecursionlimit(10**9)\nvar_5 = 10**18\nvar_10 = 10**9 + 7\n\n\ndef func_9(var_1, var_2):\n \"\"\"\"\"\"\n import numpy as np\n from numpy.fft import rfft, irfft\n\n var_8 = max(var_1)\n var_9 = max(var_2)\n var_3 = [0] * (var_8 + 1)\n var_4 = [0] * (var_9 + 1)\n for var_12 in var_1:\n var_3[var_12] += 1\n for var_13 in var_2:\n var_4[var_13] += 1\n\n var_6 = 1\n var_19 = 0\n while var_6 <= var_8 + var_9:\n var_19 += 1\n var_6 = 2**var_19\n\n var_21 = irfft(rfft(var_3, var_6) * rfft(var_4, var_6), var_6)\n\n var_21 = np.rint(var_21).astype(np.int64)\n return var_21\n\n\nvar_11, var_7, var_6 = func_3()\nvar_1 = func_2()\nvar_2 = func_2()\nvar_21 = list(func_9(var_1, var_2))\nvar_20 = var_5\nfor var_17, var_12 in enumerate(var_21):\n if var_12 != 0:\n var_20 = var_17\n break\nfor _ in range(var_6):\n var_22, var_23, var_14 = func_3()\n var_22 -= 1\n var_23 -= 1\n var_20 = min(var_20, var_1[var_22] + var_2[var_23] - var_14)\nprint(var_20)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2, var_3 = list(map(int, input().split()))\nvar_4 = list(map(int, input().split()))\nvar_6 = list(map(int, input().split()))\nvar_5 = min(var_4) + min(var_6)\nfor var_7 in range(var_3):\n var_9, var_10, var_11 = list(map(int, input().split()))\n var_8 = var_4[var_9 - 1] + var_6[var_10 - 1] - var_11\n var_5 = var_8 if var_8 < var_5 else var_5\nprint(var_5)\n```", "output": "FASTER 3.1814", "pair_id": "python_p02748_forward", "problem_id": "p02748", "language": "python", "direction": "forward", "speedup_ratio": 9.0716} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = [0] * (var_2 + 1)\nfor var_3 in range(1, var_2 + 1):\n if str(var_3) == str(var_3)[::-1]:\n var_4[var_3] = var_4[var_3 - 1] + 1\n else:\n var_4[var_3] = var_4[var_3 - 1]\nprint((var_4[var_2] - var_4[var_1 - 1]))\n```\n\n=== Code B (Modified) ===\n```python\ndef func_1():\n var_1, var_2 = list(map(int, input().split()))\n var_3 = 0\n for var_4 in range(var_1, var_2 + 1):\n\n if (var_4 % 10) == (var_4 // 10000 % 10) and (var_4 // 10 % 10) == (\n var_4 // 1000 % 10\n ):\n var_3 += 1\n print(var_3)\n\n\nif __name__ == \"__main__\":\n func_1()\n```", "output": "FASTER 3.6063", "pair_id": "python_p03416_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 12.1789} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_4 = str(var_4)\n if var_4[0] == var_4[-1] and var_4[1] == var_4[-2]:\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = [0] * (var_2 + 1)\nfor var_3 in range(1, var_2 + 1):\n if str(var_3) == str(var_3)[::-1]:\n var_4[var_3] = var_4[var_3 - 1] + 1\n else:\n var_4[var_3] = var_4[var_3 - 1]\nprint((var_4[var_2] - var_4[var_1 - 1]))\n```", "output": "SLOWER 2.126", "pair_id": "python_p03416_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 4.365} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\n\nsys.setrecursionlimit(2147483647)\nvar_2 = float(\"inf\")\nvar_3 = 10**9 + 7\nvar_10 = lambda: sys.stdin.readline().rstrip()\n\n\ndef func_1():\n var_11, var_4 = list(map(int, var_10().split()))\n var_1 = [tuple(map(int, var_10().split())) for _ in range(var_11)]\n var_1.sort()\n var_8 = [0] * var_4\n var_6 = -var_2\n for var_9 in range(var_11):\n var_5, var_7 = var_1[var_9]\n var_12 = var_8[:]\n for var_13 in range(var_4):\n if var_13 + var_5 < var_4:\n var_12[var_13 + var_5] = max(\n var_12[var_13 + var_5], var_8[var_13] + var_7\n )\n else:\n var_6 = max(var_6, var_8[var_13] + var_7)\n var_8 = var_12\n print((max(var_6, max(var_8))))\n\n\nfunc_1()\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_6 = sorted([list(map(int, input().split())) for var_5 in range(var_1)])\n\nvar_4 = [[0] * (var_2 + 1) for var_5 in range(var_1 + 1)]\n\nfor var_5 in range(var_1):\n var_9, var_8 = var_6[var_5]\n for var_7 in range(var_2 + 1):\n if var_7 + var_9 <= var_2:\n var_4[var_5 + 1][var_7 + var_9] = max(\n var_4[var_5 + 1][var_7 + var_9], var_4[var_5][var_7] + var_8\n )\n var_4[var_5 + 1][var_7] = max(var_4[var_5][var_7], var_4[var_5 + 1][var_7])\nvar_3 = 0\nfor var_5, (var_9, var_8) in enumerate(var_6):\n for var_7 in range(var_2):\n var_3 = max(var_3, var_4[var_5][var_7] + var_8)\nprint(var_3)\n```", "output": "SLOWER 1.8014", "pair_id": "python_p02863_reversed", "problem_id": "p02863", "language": "python", "direction": "reversed", "speedup_ratio": 3.4856} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_5 in range(var_1, var_2 + 1):\n var_3 = str(var_5)\n if var_3[0] == var_3[-1] and var_3[1] == var_3[-2]:\n var_4 += 1\nprint(var_4)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_8 in range(var_1, var_2 + 1):\n var_7 = str(var_8)\n var_6 = len(var_7)\n var_4 = True\n for var_5 in range(var_6 // 2):\n if var_7[var_5] != var_7[var_6 - 1 - var_5]:\n var_4 = False\n break\n if var_4:\n var_3 += 1\nprint(var_3)\n```", "output": "SLOWER 1.2178", "pair_id": "python_p03416_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 2.3259} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\ndef func_1():\n var_1, var_2 = list(map(int, input().rstrip().split()))\n var_3 = 0\n for var_4 in range(var_1, var_2 + 1):\n var_5 = str(var_4)\n if var_5 == var_5[::-1]:\n var_3 += 1\n print(var_3)\n\n\nif __name__ == \"__main__\":\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\n\n\ndef func_1(var_5):\n var_4 = 0\n for var_3 in range(1, var_5 + 1):\n if str(var_3) == str(var_3)[::-1]:\n var_4 += 1\n return var_4\n\n\nprint((func_1(var_2) - func_1(var_1 - 1)))\n```", "output": "SLOWER 2.3366", "pair_id": "python_p03416_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 5.0511} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport bisect, copy, heapq, math, sys\nfrom collections import *\nfrom functools import lru_cache\nfrom itertools import accumulate, combinations, permutations, product\n\n\ndef func_2():\n return sys.stdin.readline()[:-1]\n\n\ndef func_4(var_8):\n return [0] + list(accumulate(var_8))\n\n\ndef func_1(var_1, var_4):\n return -(-var_1 // var_4)\n\n\nsys.setrecursionlimit(5000000)\nvar_9 = pow(10, 9) + 7\nvar_2 = [chr(ord(\"a\") + var_6) for var_6 in range(26)]\nvar_5 = [[1, 0], [0, 1], [-1, 0], [0, -1]]\nvar_11 = int(eval(func_2()))\n\n\ndef func_3(var_10):\n if var_10 == 1:\n return False\n for var_7 in range(2, int(math.sqrt(var_10)) + 1):\n if var_10 % var_7 == 0:\n return False\n return True\n\n\nvar_3 = var_11\nwhile not func_3(var_3):\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nimport numpy as np\nfrom bisect import bisect_left\n\n\ndef func_1():\n var_4 = []\n var_1 = np.ones(10**5 + 10)\n var_1[0] = var_1[1] = 0\n for var_3, var_2 in enumerate(var_1):\n if var_2:\n var_4.append(var_3)\n var_1[2 * var_3 : 10**5 + 10 : var_3] = 0\n return var_4\n\n\ndef func_2(var_6):\n var_7 = int(var_6)\n var_5 = func_1()\n return str(var_5[bisect_left(var_5, var_7)])\n\n\nif __name__ == \"__main__\":\n import sys\n\n print((func_2(sys.stdin.read().strip())))\n```", "output": "SLOWER 6.3202", "pair_id": "python_p02819_reversed", "problem_id": "p02819", "language": "python", "direction": "reversed", "speedup_ratio": 79.9029} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = list(str(var_4))\n if var_5 == list(reversed(var_5)):\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_4 = str(var_4)\n if var_4 == var_4[::-1]:\n var_3 += 1\nprint(var_3)\n```", "output": "FASTER 1.0852", "pair_id": "python_p03416_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 2.1216} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\ndef func_1():\n from sys import setrecursionlimit, stdin\n from os import environ\n from collections import defaultdict, deque, Counter\n from math import ceil, floor, gcd\n from itertools import accumulate, combinations, combinations_with_replacement\n\n setrecursionlimit(10**6)\n var_7 = (\n (lambda *var_11: print(*var_11))\n if \"TERM_PROGRAM\" in environ\n else lambda *var_12: 0\n )\n var_8 = lambda: stdin.readline().rstrip()\n var_3 = lambda: list(map(int, var_8().split()))\n var_1 = lambda: int(var_8())\n var_4 = 10**9 + 7\n var_2 = 10**9 + 10\n var_9, var_10 = var_8().split()\n var_5 = int(var_9)\n var_6 = int(float(var_10) * 100 + 0.5)\n print(var_5 * var_6 // 100)\n\n\nfunc_1()\n```\n\n=== Code B (Modified) ===\n```python\nimport math\n\nvar_1, var_2 = input().split()\nvar_1 = int(var_1)\nvar_3 = int(var_2[0] + var_2[2] + var_2[3])\nprint((int(var_1 * var_3) // 100))\n```", "output": "FASTER 1.9827", "pair_id": "python_p02659_forward", "problem_id": "p02659", "language": "python", "direction": "forward", "speedup_ratio": 3.9522} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_4, var_3 = list(map(int, input().split()))\nvar_1 = 0\nfor var_2 in range(var_4, var_3 + 1):\n if str(var_2)[0] + str(var_2)[1] == str(var_2)[-1] + str(var_2)[-2]:\n var_1 += 1\nprint(var_1)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_4 = str(var_4)\n if var_4[0] == var_4[-1] and var_4[1] == var_4[-2]:\n var_3 += 1\nprint(var_3)\n```", "output": "FASTER 1.5248", "pair_id": "python_p03416_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 2.8775} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_11 = int(eval(input()))\nvar_12 = {var_8: [] for var_8 in range(1, var_11 + 1)}\nvar_19 = [False for var_8 in range(var_11 + 1)]\nvar_16 = []\nfor _ in range(var_11 - 1):\n var_2, var_3 = list(map(int, input().split()))\n var_12[var_2].append(var_3)\n var_12[var_3].append(var_2)\n var_16.append((var_2, var_3))\nvar_9 = var_16[0][0]\nvar_19[var_9] = True\nvar_6 = []\nvar_7 = []\nvar_14 = {var_8: {} for var_8 in range(1, var_11 + 1)}\nvar_10 = [0 for var_8 in range(var_11 + 1)]\n\nvar_4 = 1\nfor var_5 in var_12[var_9]:\n var_19[var_5] = True\n var_14[var_9][var_5] = var_4\n var_14[var_5][var_9] = var_4\n var_10[var_5] = var_4\n var_4 += 1\n var_6.append(var_5)\nwhile var_6:\n for var_15 in var_6:\n var_13 = 1\n for var_5 in var_12[var_15]:\n if var_19[var_5] == False:\n var_19[var_5] = True\n if var_13 != var_10[var_15]:\n var_14[var_15][var_5] = var_13\n var_14[var_5][var_15] = var_13\n var_10[var_5] = var_13\n var_13 += 1\n var_7.append(var_5)\n else:\n var_13 += 1\n var_14[var_15][var_5] = var_13\n var_14[var_5][var_15] = var_13\n var_10[var_5] = var_13\n var_13 += 1\n var_7.append(var_5)\n if var_7:\n var_6 = var_7\n var_7 = []\n else:\n var_6 = []\n var_7 = []\nvar_1 = 0\nfor var_8 in range(1, var_11 + 1):\n var_1 = max(var_1, len(var_12[var_8]))\nprint(var_1)\nfor var_8 in range(var_11 - 1):\n var_17, var_18 = var_16[var_8][0], var_16[var_8][1]\n print((var_14[var_17][var_18]))\n```\n\n=== Code B (Modified) ===\n```python\n\"\"\"\"\"\"\n\nfrom collections import deque\n\n\ndef func_1():\n var_5, *var_1 = list(map(int, open(0).read().split()))\n var_2 = var_1[1::2]\n var_4 = [[] for _ in range(var_5 + 1)]\n for var_7, var_8 in zip(*[iter(var_1)] * 2):\n var_4[var_7] += (var_8,)\n var_6 = deque([1])\n var_3 = [0] * (var_5 + 1)\n while var_6:\n var_11 = var_6.popleft()\n var_9 = 0\n for var_10 in var_4[var_11]:\n var_9 += 1 + (var_9 + 1 == var_3[var_11])\n var_3[var_10] = var_9\n var_6 += (var_10,)\n print((max(var_3)))\n for var_8 in var_2:\n print((var_3[var_8]))\n\n\nfunc_1()\n```", "output": "FASTER 1.0038", "pair_id": "python_p02850_forward", "problem_id": "p02850", "language": "python", "direction": "forward", "speedup_ratio": 2.0053} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_4 = {}\nvar_5 = 0\nfor var_6 in range(10000, 100000):\n var_3 = list(str(var_6))\n if var_3 == list(reversed(var_3)):\n var_5 += 1\n var_4[var_6] = var_5\nvar_1, var_2 = list(map(int, input().split()))\nprint((var_4[var_2] - var_4[var_1 - 1] if var_1 > 10000 else var_4[var_2]))\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_8 in range(var_1, var_2 + 1):\n var_7 = str(var_8)\n var_6 = len(var_7)\n var_4 = True\n for var_5 in range(var_6 // 2):\n if var_7[var_5] != var_7[var_6 - 1 - var_5]:\n var_4 = False\n break\n if var_4:\n var_3 += 1\nprint(var_3)\n```", "output": "FASTER 2.4474", "pair_id": "python_p03416_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 5.4542} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_2, var_3, *var_1 = list(map(int, open(0).read().split()))\nvar_4 = [0] * (var_3 + max(var_1[::2]))\nfor var_7, var_6 in sorted(zip(*[iter(var_1)] * 2)):\n for var_5 in reversed(list(range(var_3))):\n var_4[var_5 + var_7] = max(var_4[var_5 + var_7], var_4[var_5] + var_6)\nprint((max(var_4)))\n```\n\n=== Code B (Modified) ===\n```python\nfrom collections import Counter, defaultdict, deque\nfrom heapq import heappop, heappush, heapify\nimport sys, bisect, math, itertools, fractions, pprint\n\nsys.setrecursionlimit(10**8)\nvar_6 = 10**9 + 7\nvar_1 = float(\"inf\")\n\n\ndef func_1():\n return int(sys.stdin.readline())\n\n\ndef func_2():\n return list(map(int, sys.stdin.readline().split()))\n\n\nvar_8, var_11 = func_2()\nvar_17 = [func_2() for _ in range(var_8)]\nvar_10 = var_17[::-1]\nvar_14 = [[0] * var_11 for _ in range(var_8)]\nvar_3 = [[0] * var_11 for _ in range(var_8)]\nfor var_4 in range(var_8 - 1):\n var_16, var_15 = var_17[var_4]\n for var_5 in range(var_11):\n if var_5 < var_16:\n var_14[var_4 + 1][var_5] = var_14[var_4][var_5]\n else:\n var_14[var_4 + 1][var_5] = max(\n var_14[var_4][var_5], var_14[var_4][var_5 - var_16] + var_15\n )\nvar_9 = var_14[var_8 - 1][var_11 - 1] + var_17[var_8 - 1][1]\nfor var_4 in range(var_8 - 1):\n var_16, var_15 = var_10[var_4]\n for var_5 in range(var_11):\n if var_5 < var_16:\n var_3[var_4 + 1][var_5] = var_3[var_4][var_5]\n else:\n var_3[var_4 + 1][var_5] = max(\n var_3[var_4][var_5], var_3[var_4][var_5 - var_16] + var_15\n )\n var_9 = max(var_9, var_3[var_8 - 1][var_11 - 1] + var_17[0][1])\n\nfor var_4 in range(1, var_8 - 1):\n var_13 = var_4\n var_2 = var_8 - var_4 - 1\n var_7 = 0\n for var_5 in range(var_11):\n var_12 = var_14[var_13][var_5] + var_3[var_2][var_11 - 1 - var_5]\n var_7 = max(var_7, var_12)\n var_9 = max(var_9, var_7 + var_17[var_4][1])\nprint(var_9)\n```", "output": "SLOWER 1.5875", "pair_id": "python_p02863_reversed", "problem_id": "p02863", "language": "python", "direction": "reversed", "speedup_ratio": 3.0053} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n if str(var_4) == \"\".join(reversed(str(var_4))):\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = str(var_4)\n if var_5 == var_5[::-1]:\n var_3 += 1\nprint(var_3)\n```", "output": "FASTER 1.0807", "pair_id": "python_p03416_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 2.1151} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = input().split()\nvar_1 = int(var_1)\nvar_2 = int(var_2)\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = list(str(var_4))\n if (var_5[0] == var_5[4]) and (var_5[1] == var_5[3]):\n var_3 = var_3 + 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_3 = list(map(int, input().split()))\nvar_2 = 0\nfor var_5 in range(var_3 + 1)[var_1:]:\n if len(str(var_5)) % 2 == 0:\n var_6 = list(str(var_5))[: len(str(var_5)) // 2]\n var_7 = list(reversed(list(str(var_5))[len(str(var_5)) // 2 :]))\n if var_6 == var_7:\n var_2 += 1\n else:\n var_8 = list(str(var_5))[: len(str(var_5)) // 2 + 1]\n var_4 = list(reversed(list(str(var_5))[len(str(var_5)) // 2 :]))\n if var_8 == var_4:\n var_2 += 1\nprint(var_2)\n```", "output": "SLOWER 2.0702", "pair_id": "python_p03416_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 4.1995} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nfrom collections import Counter\n\nvar_1 = input()[::-1]\nvar_5 = [0]\nvar_4 = 0\nvar_6 = 2019\nfor var_7 in var_1:\n var_8 = int(var_7) * pow(10, var_4, var_6) % var_6\n var_8 = var_5[-1] + var_8\n var_5.append(var_8 % var_6)\n var_4 += 1\nvar_3 = Counter(var_5)\nvar_2 = sum(var_9 * (var_9 - 1) // 2 for var_9 in list(var_3.values()))\nprint(var_2)\n```\n\n=== Code B (Modified) ===\n```python\nvar_5 = input()[::-1]\nvar_2 = [0] * 2019\nvar_2[0] = 1\nvar_4 = 0\nvar_6 = 1\nvar_1 = 0\nfor var_3 in var_5:\n var_4 = (var_4 + int(var_3) * var_6) % 2019\n var_6 = var_6 * 10 % 2019\n var_2[var_4] += 1\nfor var_3 in var_2:\n var_1 += var_3 * (var_3 - 1) // 2\nprint(var_1)\n```", "output": "SLOWER 1.9367", "pair_id": "python_p02702_reversed", "problem_id": "p02702", "language": "python", "direction": "reversed", "speedup_ratio": 3.8282} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\n\nvar_7 = sys.stdin.readline\nfrom itertools import combinations\n\n\ndef func_3(var_10):\n for _ in range(var_10):\n yield list(map(int, var_7().split()))\n\n\ndef func_1(var_9, var_5, var_11):\n var_3 = len([0 for var_8 in var_9 if var_5[var_8] == 1])\n return var_11[var_3]\n\n\ndef func_2():\n var_10 = int(eval(var_7()))\n var_1 = list(func_3(var_10))\n var_2 = list(func_3(var_10))\n for var_6 in range(1, 11):\n for var_4 in combinations(list(range(10)), var_6):\n yield sum(\n func_1(var_4, var_5, var_11) for var_5, var_11 in zip(var_1, var_2)\n )\n\n\nprint((max(func_2())))\n```\n\n=== Code B (Modified) ===\n```python\nimport itertools\n\nvar_6 = int(eval(input()))\nvar_2 = [[]] * var_6\nfor var_4 in range(var_6):\n var_3 = list(map(int, input().split()))\n\n var_2[var_4] = var_3\nvar_8 = [[]] * var_6\nfor var_4 in range(var_6):\n var_9 = list(map(int, input().split()))\n var_8[var_4] = var_9\nvar_10 = -(10**11)\nfor var_1 in itertools.product([0, 1], repeat=10):\n if sum(var_1) == 0:\n continue\n var_11 = 0\n for var_7 in range(var_6):\n var_5 = 0\n for var_4 in range(10):\n if var_2[var_7][var_4] == 1 and var_1[var_4] == 1:\n var_5 += 1\n var_11 = var_11 + var_8[var_7][var_5]\n var_10 = max(var_10, var_11)\nprint(var_10)\n```", "output": "SLOWER 1.5941", "pair_id": "python_p03503_reversed", "problem_id": "p03503", "language": "python", "direction": "reversed", "speedup_ratio": 3.019} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\ndef func_1():\n var_1, var_2 = list(map(int, input().rstrip().split()))\n var_3 = 0\n for var_4 in range(var_1, var_2 + 1):\n var_5 = str(var_4)\n if var_5 == var_5[::-1]:\n var_3 += 1\n print(var_3)\n\n\nif __name__ == \"__main__\":\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = list(str(var_4))\n if var_5 == list(reversed(var_5)):\n var_3 += 1\nprint(var_3)\n```", "output": "SLOWER 1.9782", "pair_id": "python_p03416_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 3.9399} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\n\nsys.setrecursionlimit(2147483647)\nvar_2 = float(\"inf\")\nvar_3 = 10**9 + 7\nvar_10 = lambda: sys.stdin.readline().rstrip()\n\n\ndef func_1():\n var_11, var_4 = list(map(int, var_10().split()))\n var_1 = [tuple(map(int, var_10().split())) for _ in range(var_11)]\n var_1.sort()\n var_8 = [0] * var_4\n var_6 = -var_2\n for var_9 in range(var_11):\n var_5, var_7 = var_1[var_9]\n var_12 = var_8[:]\n for var_13 in range(var_4):\n if var_13 + var_5 < var_4:\n var_12[var_13 + var_5] = max(\n var_12[var_13 + var_5], var_8[var_13] + var_7\n )\n else:\n var_6 = max(var_6, var_8[var_13] + var_7)\n var_8 = var_12\n print((max(var_6, max(var_8))))\n\n\nfunc_1()\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\n\nvar_10 = sys.stdin.readline\nvar_2, var_3 = list(map(int, var_10().split()))\nvar_1 = [list(map(int, var_10().split())) for _ in range(var_2)]\nvar_8 = [[0 for _ in range(var_2 + 1)] for _ in range(var_3 + 1)]\n\nvar_13 = [[0 for _ in range(var_2 + 1)] for _ in range(var_3 + 1)]\nfor var_11 in range(var_2):\n var_4, var_6 = var_1[var_11]\n for var_15 in range(var_3):\n if var_4 > var_15:\n var_8[var_15][var_11 + 1] = var_8[var_15][var_11]\n var_13[var_15][var_11 + 1] = var_15\n else:\n if var_6 + var_8[var_15 - var_4][var_11] >= var_8[var_15][var_11]:\n var_8[var_15][var_11 + 1] = var_8[var_15 - var_4][var_11] + var_6\n var_13[var_15][var_11 + 1] = var_15 - var_4\n else:\n var_8[var_15][var_11 + 1] = var_8[var_15][var_11]\n var_13[var_15][var_11 + 1] = var_15\nvar_5 = var_8[var_3 - 1][var_2]\nvar_14 = [False] * var_2\nvar_7 = var_3 - 1\nfor var_9 in reversed(list(range(var_2))):\n if var_13[var_7][var_9 + 1] == var_7 - var_1[var_9][0]:\n var_14[var_9] = True\n var_7 = var_13[var_7][var_9 + 1]\nvar_12 = 0\nfor var_9 in range(var_2):\n if not var_14[var_9] and var_1[var_9][1] > var_12:\n var_12 = var_1[var_9][1]\nprint((var_5 + var_12))\n```", "output": "SLOWER 1.5241", "pair_id": "python_p02863_reversed", "problem_id": "p02863", "language": "python", "direction": "reversed", "speedup_ratio": 2.8761} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nfrom sys import stdin\n\n\ndef func_1():\n\n var_11 = stdin.readline\n var_2 = int(var_11())\n var_1 = []\n for var_6 in range(var_2):\n var_5 = int(\"\".join(var_11().strip().split(\" \")), 2)\n var_1.append(var_5)\n var_3 = []\n for var_6 in range(var_2):\n var_10 = list(map(int, var_11().split()))\n var_3.append(var_10)\n var_8 = float(\"-inf\")\n for var_9 in range(1, 1 << 10):\n var_12 = 0\n for var_7 in range(var_2):\n var_4 = bin(var_9 & var_1[var_7]).count(\"1\")\n var_12 += var_3[var_7][var_4]\n var_8 = max(var_12, var_8)\n print(var_8)\n\n\nif __name__ == \"__main__\":\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\n\nvar_7 = sys.stdin.readline\nfrom itertools import combinations\n\n\ndef func_3(var_10):\n for _ in range(var_10):\n yield list(map(int, var_7().split()))\n\n\ndef func_1(var_9, var_5, var_11):\n var_3 = sum(1 if var_5[var_8] == 1 else 0 for var_8 in var_9)\n return var_11[var_3]\n\n\ndef func_2():\n var_10 = int(eval(var_7()))\n var_1 = list(func_3(var_10))\n var_2 = list(func_3(var_10))\n for var_6 in range(1, 11):\n for var_4 in combinations(list(range(10)), var_6):\n yield sum(\n func_1(var_4, var_5, var_11) for var_5, var_11 in zip(var_1, var_2)\n )\n\n\nprint((max(func_2())))\n```", "output": "SLOWER 1.801", "pair_id": "python_p03503_reversed", "problem_id": "p03503", "language": "python", "direction": "reversed", "speedup_ratio": 3.4845} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = [\n var_3 for var_3 in map(str, list(range(var_1, var_2 + 1))) if var_3 == var_3[::-1]\n]\nprint((len(var_4)))\n```\n\n=== Code B (Modified) ===\n```python\nvar_10 = []\nvar_10 = input().rstrip().split(\" \")\nvar_1 = int(var_10[0])\nvar_3 = int(var_10[1])\nvar_2 = 0\nvar_6 = var_1\nwhile var_6 <= var_3:\n var_4 = var_6 // 10000\n var_5 = (var_6 - var_4 * 10000) // 1000\n var_7 = var_6 // 100\n var_8 = (var_6 - var_7 * 100) // 10\n var_9 = var_6 % 10\n if (var_4 == var_9) and (var_5 == var_8):\n var_2 += 1\n var_6 += 1\nprint(var_2)\n```", "output": "SLOWER 1.5076", "pair_id": "python_p03416_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 2.8433} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\ndef func_1():\n var_1, var_2 = list(map(int, input().split()))\n var_3 = 0\n for var_4 in range(var_1, var_2 + 1):\n\n if (var_4 % 10) == (var_4 // 10000 % 10) and (var_4 // 10 % 10) == (\n var_4 // 1000 % 10\n ):\n var_3 += 1\n print(var_3)\n\n\nif __name__ == \"__main__\":\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_3 in range(var_1, var_2 + 1):\n var_5 = list(str(var_3))\n var_6 = list(reversed(var_5))\n if var_5 == var_6:\n var_4 += 1\nprint(var_4)\n```", "output": "SLOWER 2.9727", "pair_id": "python_p03416_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 7.85} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\nimport math\nfrom collections import defaultdict\nfrom bisect import bisect_left, bisect_right\n\nsys.setrecursionlimit(10**7)\n\n\ndef func_4():\n return sys.stdin.readline()[:-1]\n\n\nvar_4 = 10**9 + 7\n\n\ndef func_1():\n return int(eval(func_4()))\n\n\ndef func_2():\n return list(map(int, func_4().split()))\n\n\ndef func_3(var_6, var_3):\n if var_6 <= 0:\n return [[] for _ in range(var_3)]\n elif var_3 == 1:\n return [func_1() for _ in range(var_6)]\n else:\n var_5 = [func_2() for _ in range(var_6)]\n return list(map(list, list(zip(*var_5))))\n\n\nfrom decimal import getcontext, Decimal\n\ngetcontext().prec = 28\nvar_1, var_2 = list(map(str, func_4().split()))\nvar_1 = int(var_1)\nvar_2 = Decimal(var_2)\nprint((int(var_1 * var_2)))\n```\n\n=== Code B (Modified) ===\n```python\nfrom fractions import Fraction\n\nvar_1, var_2 = input().split()\n\n\nfrom decimal import *\n\nvar_4 = var_3(var_1)\nvar_6 = var_3(var_2)\nvar_7().prec = 28\nvar_5 = var_4 * var_6\nprint((int(var_5)))\n```", "output": "FASTER 1.9011", "pair_id": "python_p02659_forward", "problem_id": "p02659", "language": "python", "direction": "forward", "speedup_ratio": 3.7349} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().strip().split(\" \")))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n if str(var_4) == str(var_4)[::-1]:\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_5 in range(10):\n for var_6 in range(10):\n for var_7 in range(10):\n var_3 = 10000 * var_5 + 1000 * var_6 + 100 * var_7 + 10 * var_6 + var_5\n if var_1 <= var_3 <= var_2:\n var_4 += 1\nprint(var_4)\n```", "output": "FASTER 4.1328", "pair_id": "python_p03416_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 17.5431} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_4 = {}\nvar_5 = 0\nfor var_6 in range(10000, 100000):\n var_3 = list(str(var_6))\n if var_3 == list(reversed(var_3)):\n var_5 += 1\n var_4[var_6] = var_5\nvar_1, var_2 = list(map(int, input().split()))\nprint((var_4[var_2] - var_4[var_1 - 1] if var_1 > 10000 else var_4[var_2]))\n```\n\n=== Code B (Modified) ===\n```python\nvar_10 = []\nvar_10 = input().rstrip().split(\" \")\nvar_1 = int(var_10[0])\nvar_3 = int(var_10[1])\nvar_2 = 0\nvar_6 = var_1\nwhile var_6 <= var_3:\n var_4 = var_6 // 10000\n var_5 = (var_6 - var_4 * 10000) // 1000\n var_7 = var_6 // 100\n var_8 = (var_6 - var_7 * 100) // 10\n var_9 = var_6 % 10\n if (var_4 == var_9) and (var_5 == var_8):\n var_2 += 1\n var_6 += 1\nprint(var_2)\n```", "output": "FASTER 2.7646", "pair_id": "python_p03416_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 6.7956} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\n\n\ndef func_1(var_5, var_6):\n var_4 = 0\n for var_3 in range(var_5, var_6 + 1):\n if str(var_3) == str(var_3)[::-1]:\n var_4 += 1\n return var_4\n\n\nprint((func_1(var_1, var_2)))\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_8 in range(var_1, var_2 + 1):\n var_7 = str(var_8)\n var_6 = len(var_7)\n var_4 = True\n for var_5 in range(var_6 // 2):\n if var_7[var_5] != var_7[var_6 - 1 - var_5]:\n var_4 = False\n break\n if var_4:\n var_3 += 1\nprint(var_3)\n```", "output": "SLOWER 1.4499", "pair_id": "python_p03416_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 2.7318} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n if list(str(var_4)) == list(reversed(str(var_4))):\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = str(var_4)\n if var_5 == var_5[::-1]:\n var_3 += 1\nprint(var_3)\n```", "output": "FASTER 1.4048", "pair_id": "python_p03416_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 2.6479} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_4 = {}\nvar_5 = 0\nfor var_6 in range(10000, 100000):\n var_3 = list(str(var_6))\n if var_3 == list(reversed(var_3)):\n var_5 += 1\n var_4[var_6] = var_5\nvar_1, var_2 = list(map(int, input().split()))\nprint((var_4[var_2] - var_4[var_1 - 1] if var_1 > 10000 else var_4[var_2]))\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_4 = str(var_4)\n if var_4[0] == var_4[-1] and var_4[1] == var_4[-2]:\n var_3 += 1\nprint(var_3)\n```", "output": "FASTER 3.7573", "pair_id": "python_p03416_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 13.5227} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_2 = int(eval(input()))\nvar_1 = list(map(int, input().split()))\nvar_4 = 1\nfor var_3 in range(var_2):\n if var_1[var_3] % 2 == 0:\n var_4 *= 2\nprint((3**var_2 - var_4))\n```\n\n=== Code B (Modified) ===\n```python\nfrom itertools import product\n\nvar_6 = int(eval(input()))\nvar_1 = list(map(int, input().split()))\nvar_5 = 0\nfor var_2 in product((-1, 0, 1), repeat=var_6):\n var_7 = 1\n for var_3, var_4 in zip(var_1, var_2):\n var_7 *= var_3 + var_4\n if var_7 % 2 == 0:\n var_5 += 1\nprint(var_5)\n```", "output": "SLOWER 10.0467", "pair_id": "python_p03568_reversed", "problem_id": "p03568", "language": "python", "direction": "reversed", "speedup_ratio": 1057.6766} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_5 in range(var_1, var_2 + 1):\n var_3 = str(var_5)\n if var_3[0] == var_3[-1] and var_3[1] == var_3[-2]:\n var_4 += 1\nprint(var_4)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = [0] * (var_2 + 1)\nfor var_3 in range(1, var_2 + 1):\n if str(var_3) == str(var_3)[::-1]:\n var_4[var_3] = var_4[var_3 - 1] + 1\n else:\n var_4[var_3] = var_4[var_3 - 1]\nprint((var_4[var_2] - var_4[var_1 - 1]))\n```", "output": "SLOWER 2.0339", "pair_id": "python_p03416_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 4.095} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_7 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_3 = True\n var_8 = str(var_4)\n var_6 = len(var_8)\n for var_5 in range(var_6 // 2 + 1):\n if var_8[var_5] != var_8[-var_5 - 1]:\n var_3 = False\n break\n if var_3:\n var_7 += 1\nprint(var_7)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_3 = list(map(int, input().split()))\nvar_2 = 0\nfor var_5 in range(var_3 + 1)[var_1:]:\n if len(str(var_5)) % 2 == 0:\n var_6 = list(str(var_5))[: len(str(var_5)) // 2]\n var_7 = list(reversed(list(str(var_5))[len(str(var_5)) // 2 :]))\n if var_6 == var_7:\n var_2 += 1\n else:\n var_8 = list(str(var_5))[: len(str(var_5)) // 2 + 1]\n var_4 = list(reversed(list(str(var_5))[len(str(var_5)) // 2 :]))\n if var_8 == var_4:\n var_2 += 1\nprint(var_2)\n```", "output": "SLOWER 1.3494", "pair_id": "python_p03416_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 2.5481} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\n\nvar_7 = sys.stdin.readline\nfrom itertools import combinations\n\n\ndef func_3(var_10):\n for _ in range(var_10):\n yield list(map(int, var_7().split()))\n\n\ndef func_1(var_9, var_5, var_11):\n var_3 = sum(1 if var_5[var_8] == 1 else 0 for var_8 in var_9)\n return var_11[var_3]\n\n\ndef func_2():\n var_10 = int(eval(var_7()))\n var_1 = list(func_3(var_10))\n var_2 = list(func_3(var_10))\n for var_6 in range(1, 11):\n for var_4 in combinations(list(range(10)), var_6):\n yield sum(\n func_1(var_4, var_5, var_11) for var_5, var_11 in zip(var_1, var_2)\n )\n\n\nprint((max(func_2())))\n```\n\n=== Code B (Modified) ===\n```python\nvar_5 = 0\nif var_5 == 0:\n var_8 = int(eval(input()))\n var_2 = []\n for var_4 in range(var_8):\n var_3 = list(map(int, input().split()))\n var_2.append(var_3)\n var_9 = []\n for var_4 in range(var_8):\n var_10 = list(map(int, input().split()))\n var_9.append(var_10)\nelif var_5 == 1:\n var_8 = 1\n var_2 = [[1, 1, 0, 1, 0, 0, 0, 1, 0, 1]]\n var_9 = [[3, 4, 5, 6, 7, 8, 9, -2, -3, 4, -2]]\nelif var_5 == 2:\n var_8 = 2\n var_2 = [[1, 1, 1, 1, 1, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 1, 1, 1, 1, 1]]\n var_9 = [\n [0, -2, -2, -2, -2, -2, -1, -1, -1, -1, -1],\n [0, -2, -2, -2, -2, -2, -1, -1, -1, -1, -1],\n ]\nelif var_5 == 3:\n var_8 = 3\n var_2 = [\n [1, 1, 1, 1, 1, 1, 0, 0, 1, 1],\n [0, 1, 0, 1, 1, 1, 1, 0, 1, 0],\n [1, 0, 1, 1, 0, 1, 0, 1, 0, 1],\n ]\n var_9 = [\n [-8, 6, -2, -8, -8, 4, 8, 7, -6, 2, 2],\n [-9, 2, 0, 1, 7, -5, 0, -2, -6, 5, 5],\n [6, -6, 7, -9, 6, -5, 8, 0, -9, -7, -7],\n ]\nimport itertools\n\nvar_13 = -(10**11)\nfor var_4 in itertools.product([0, 1], repeat=10):\n var_11 = list(var_4)\n var_12 = 0\n if sum(var_11) != 0:\n for var_7 in range(var_8):\n var_1 = 0\n for var_6 in range(10):\n var_1 = var_1 + var_11[var_6] * var_2[var_7][var_6]\n var_12 = var_12 + var_9[var_7][var_1]\n\n var_13 = max(var_12, var_13)\nprint(var_13)\n```", "output": "SLOWER 1.4725", "pair_id": "python_p03503_reversed", "problem_id": "p03503", "language": "python", "direction": "reversed", "speedup_ratio": 2.775} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\ndef func_1():\n from sys import setrecursionlimit, stdin\n from os import environ\n from collections import defaultdict, deque, Counter\n from math import ceil, floor, gcd\n from itertools import accumulate, combinations, combinations_with_replacement\n\n setrecursionlimit(10**6)\n var_7 = (\n (lambda *var_11: print(*var_11))\n if \"TERM_PROGRAM\" in environ\n else lambda *var_12: 0\n )\n var_8 = lambda: stdin.readline().rstrip()\n var_3 = lambda: list(map(int, var_8().split()))\n var_1 = lambda: int(var_8())\n var_4 = 10**9 + 7\n var_2 = 10**9 + 10\n var_9, var_10 = var_8().split()\n var_5 = int(var_9)\n var_6 = int(float(var_10) * 100 + 0.5)\n print(var_5 * var_6 // 100)\n\n\nfunc_1()\n```\n\n=== Code B (Modified) ===\n```python\nfrom fractions import Fraction\n\nvar_1, var_2 = input().split()\n\n\nfrom decimal import *\n\nvar_4 = var_3(var_1)\nvar_6 = var_3(var_2)\nvar_7().prec = 28\nvar_5 = var_4 * var_6\nprint((int(var_5)))\n```", "output": "FASTER 1.6242", "pair_id": "python_p02659_forward", "problem_id": "p02659", "language": "python", "direction": "forward", "speedup_ratio": 3.0827} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = [\n var_3 for var_3 in map(str, list(range(var_1, var_2 + 1))) if var_3 == var_3[::-1]\n]\nprint((len(var_4)))\n```\n\n=== Code B (Modified) ===\n```python\nvar_4 = {}\nvar_5 = 0\nfor var_6 in range(10000, 100000):\n var_3 = list(str(var_6))\n if var_3 == list(reversed(var_3)):\n var_5 += 1\n var_4[var_6] = var_5\nvar_1, var_2 = list(map(int, input().split()))\nprint((var_4[var_2] - var_4[var_1 - 1] if var_1 > 10000 else var_4[var_2]))\n```", "output": "SLOWER 4.2722", "pair_id": "python_p03416_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 19.3219} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\ndef func_1():\n var_2 = int(eval(input()))\n var_1 = [int(var_6) for var_6 in input().split()]\n var_4 = 3**var_2\n var_5 = len([var_3 for var_3 in var_1 if var_3 % 2 == 0])\n var_4 -= 2**var_5\n print(var_4)\n\n\nif __name__ == \"__main__\":\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nimport numpy as np\nfrom itertools import product\n\nvar_6 = int(eval(input()))\nvar_2 = list(map(int, input().split()))\nvar_2 = np.array(var_2)\nvar_5 = [-1, 0, 1]\nvar_3 = 0\nfor var_7 in product(var_5, repeat=var_6):\n var_7 = np.array(var_7)\n var_1 = var_2 + var_7\n var_4 = var_1.cumprod()\n if var_4[-1] % 2 == 0:\n var_3 += 1\nprint(var_3)\n```", "output": "SLOWER 9.5157", "pair_id": "python_p03568_reversed", "problem_id": "p03568", "language": "python", "direction": "reversed", "speedup_ratio": 732.014} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = list(reversed(list(str(var_4))))\n if var_5 == list(str(var_4)):\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\n\n\ndef func_1(var_5, var_6):\n var_4 = 0\n for var_3 in range(var_5, var_6 + 1):\n if str(var_3) == str(var_3)[::-1]:\n var_4 += 1\n return var_4\n\n\nprint((func_1(var_1, var_2)))\n```", "output": "FASTER 1.9806", "pair_id": "python_p03416_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 3.9465} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = str(var_4)\n if var_5 == var_5[::-1]:\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = [0] * (var_2 + 1)\nfor var_3 in range(1, var_2 + 1):\n if str(var_3) == str(var_3)[::-1]:\n var_4[var_3] = var_4[var_3 - 1] + 1\n else:\n var_4[var_3] = var_4[var_3 - 1]\nprint((var_4[var_2] - var_4[var_1 - 1]))\n```", "output": "SLOWER 1.9467", "pair_id": "python_p03416_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 3.855} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_4 = str(var_4)\n if var_4 == var_4[::-1]:\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().rstrip().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = list(map(int, list(str(var_4))))\n if var_5[0] == var_5[4] and var_5[1] == var_5[3]:\n var_3 += 1\nprint(var_3)\n```", "output": "SLOWER 1.536", "pair_id": "python_p03416_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 2.8999} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nfor var_3 in range(1, 1009):\n if int(var_3 * 0.08) == var_1 and int(var_3 * 0.1) == var_2:\n print((int(var_3)))\n exit()\nprint(\"-1\")\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_2 = var_2 / 0.1\nvar_3 = [var_4 + var_2 for var_4 in range(10)]\nfor var_4 in var_3:\n if int(var_4 * 0.08) == var_1:\n print((int(var_4)))\n exit()\nprint(\"-1\")\n```", "output": "FASTER 1.9094", "pair_id": "python_p02755_forward", "problem_id": "p02755", "language": "python", "direction": "forward", "speedup_ratio": 3.7565} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nfrom collections import Counter, defaultdict, deque\nfrom heapq import heappop, heappush, heapify\nimport sys, bisect, math, itertools, fractions, pprint\n\nsys.setrecursionlimit(10**8)\nvar_6 = 10**9 + 7\nvar_1 = float(\"inf\")\n\n\ndef func_1():\n return int(sys.stdin.readline())\n\n\ndef func_2():\n return list(map(int, sys.stdin.readline().split()))\n\n\nvar_8, var_11 = func_2()\nvar_17 = [func_2() for _ in range(var_8)]\nvar_10 = var_17[::-1]\nvar_14 = [[0] * var_11 for _ in range(var_8)]\nvar_3 = [[0] * var_11 for _ in range(var_8)]\nfor var_4 in range(var_8 - 1):\n var_16, var_15 = var_17[var_4]\n for var_5 in range(var_11):\n if var_5 < var_16:\n var_14[var_4 + 1][var_5] = var_14[var_4][var_5]\n else:\n var_14[var_4 + 1][var_5] = max(\n var_14[var_4][var_5], var_14[var_4][var_5 - var_16] + var_15\n )\nvar_9 = var_14[var_8 - 1][var_11 - 1] + var_17[var_8 - 1][1]\nfor var_4 in range(var_8 - 1):\n var_16, var_15 = var_10[var_4]\n for var_5 in range(var_11):\n if var_5 < var_16:\n var_3[var_4 + 1][var_5] = var_3[var_4][var_5]\n else:\n var_3[var_4 + 1][var_5] = max(\n var_3[var_4][var_5], var_3[var_4][var_5 - var_16] + var_15\n )\n var_9 = max(var_9, var_3[var_8 - 1][var_11 - 1] + var_17[0][1])\n\nfor var_4 in range(1, var_8 - 1):\n var_13 = var_4\n var_2 = var_8 - var_4 - 1\n var_7 = 0\n for var_5 in range(var_11):\n var_12 = var_14[var_13][var_5] + var_3[var_2][var_11 - 1 - var_5]\n var_7 = max(var_7, var_12)\n var_9 = max(var_9, var_7 + var_17[var_4][1])\nprint(var_9)\n```\n\n=== Code B (Modified) ===\n```python\ndef func_1():\n var_2, var_3, *var_1 = list(map(int, open(0).read().split()))\n var_4 = [0] * (var_3 + max(var_1[::2]))\n for var_7, var_6 in sorted(zip(*[iter(var_1)] * 2)):\n for var_5 in reversed(list(range(var_3))):\n var_4[var_5 + var_7] = max(var_4[var_5 + var_7], var_4[var_5] + var_6)\n print((max(var_4)))\n\n\nfunc_1()\n```", "output": "FASTER 2.2995", "pair_id": "python_p02863_forward", "problem_id": "p02863", "language": "python", "direction": "forward", "speedup_ratio": 4.9229} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport bisect, copy, heapq, math, sys\nfrom collections import *\nfrom functools import lru_cache\nfrom itertools import accumulate, combinations, permutations, product\n\n\ndef func_2():\n return sys.stdin.readline()[:-1]\n\n\ndef func_4(var_8):\n return [0] + list(accumulate(var_8))\n\n\ndef func_1(var_1, var_4):\n return -(-var_1 // var_4)\n\n\nsys.setrecursionlimit(5000000)\nvar_9 = pow(10, 9) + 7\nvar_2 = [chr(ord(\"a\") + var_6) for var_6 in range(26)]\nvar_5 = [[1, 0], [0, 1], [-1, 0], [0, -1]]\nvar_11 = int(eval(func_2()))\n\n\ndef func_3(var_10):\n if var_10 == 1:\n return False\n for var_7 in range(2, int(math.sqrt(var_10)) + 1):\n if var_10 % var_7 == 0:\n return False\n return True\n\n\nvar_3 = var_11\nwhile not func_3(var_3):\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\n\n\ndef func_1():\n return sys.stdin.readline()[:-1]\n\n\nvar_3 = int(eval(func_1()))\nwhile 1:\n var_1 = 0\n for var_2 in range(2, int(var_3 ** (1 / 2))):\n if var_3 % var_2 == 0:\n var_1 = 1\n break\n if var_1 == 0:\n break\n var_3 += 1\nprint(var_3)\n```", "output": "FASTER 1.4121", "pair_id": "python_p02819_forward", "problem_id": "p02819", "language": "python", "direction": "forward", "speedup_ratio": 2.6613} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\nimport math\nfrom collections import defaultdict\nfrom bisect import bisect_left, bisect_right\n\nsys.setrecursionlimit(10**7)\n\n\ndef func_4():\n return sys.stdin.readline()[:-1]\n\n\nvar_4 = 10**9 + 7\n\n\ndef func_1():\n return int(eval(func_4()))\n\n\ndef func_2():\n return list(map(int, func_4().split()))\n\n\ndef func_3(var_6, var_3):\n if var_6 <= 0:\n return [[] for _ in range(var_3)]\n elif var_3 == 1:\n return [func_1() for _ in range(var_6)]\n else:\n var_5 = [func_2() for _ in range(var_6)]\n return list(map(list, list(zip(*var_5))))\n\n\nfrom decimal import getcontext, Decimal\n\ngetcontext().prec = 28\nvar_1, var_2 = list(map(str, func_4().split()))\nvar_1 = int(var_1)\nvar_2 = Decimal(var_2)\nprint((int(var_1 * var_2)))\n```\n\n=== Code B (Modified) ===\n```python\nimport math\nfrom decimal import Decimal\n\nvar_1, var_2 = list(map(Decimal, input().split()))\nprint((math.floor(var_1 * var_2)))\n```", "output": "FASTER 2.4359", "pair_id": "python_p02659_forward", "problem_id": "p02659", "language": "python", "direction": "forward", "speedup_ratio": 5.4109} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_3 in range(var_1, var_2 + 1):\n var_5 = list(str(var_3))\n var_6 = list(reversed(var_5))\n if var_5 == var_6:\n var_4 += 1\nprint(var_4)\n```\n\n=== Code B (Modified) ===\n```python\ndef func_1():\n var_1, var_2 = list(map(int, input().split()))\n var_3 = 0\n for var_4 in range(var_1, var_2 + 1):\n\n if (var_4 % 10) == (var_4 // 10000 % 10) and (var_4 // 10 % 10) == (\n var_4 // 1000 % 10\n ):\n var_3 += 1\n print(var_3)\n\n\nif __name__ == \"__main__\":\n func_1()\n```", "output": "FASTER 2.9727", "pair_id": "python_p03416_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 7.85} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport bisect\nimport sys\n\nsys.setrecursionlimit(10**6)\nvar_17 = sys.stdout.write\nvar_7 = lambda *var_15: print(*var_15) if var_1 else 0\nvar_1 = True\n\n\ndef func_1(var_10=sys.stdin.readline):\n var_12 = lambda: var_10().rstrip()\n var_3 = lambda: list(map(int, var_12().split()))\n var_2 = lambda: int(var_12())\n var_4 = lambda var_18: [var_3() for _ in range(var_18)]\n var_14, var_16 = var_3()\n var_5 = var_4(var_14)\n var_8 = [[0] * var_16 for _ in range(var_14)]\n for var_11 in range(1, var_14):\n for var_13 in range(1, var_16):\n if var_13 < var_5[var_11 - 1][0]:\n var_8[var_11][var_13] = var_8[var_11 - 1][var_13]\n else:\n var_8[var_11][var_13] = max(\n var_8[var_11 - 1][var_13],\n var_8[var_11 - 1][var_13 - var_5[var_11 - 1][0]]\n + var_5[var_11 - 1][1],\n )\n var_9 = [[0] * var_16 for _ in range(var_14)]\n for var_11 in range(1, var_14):\n for var_13 in range(1, var_16):\n if var_13 < var_5[var_14 - var_11][0]:\n var_9[var_11][var_13] = var_9[var_11 - 1][var_13]\n else:\n var_9[var_11][var_13] = max(\n var_9[var_11 - 1][var_13],\n var_9[var_11 - 1][var_13 - var_5[var_14 - var_11][0]]\n + var_5[var_14 - var_11][1],\n )\n var_6 = 0\n for var_11 in range(var_14):\n for var_13 in range(var_16 - 1):\n var_6 = max(\n var_6,\n var_8[var_11][var_13]\n + var_9[var_14 - var_11 - 1][var_16 - var_13 - 1]\n + var_5[var_11][1],\n )\n print(var_6)\n\n\nif __name__ == \"__main__\":\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\nfrom operator import itemgetter\nfrom heapq import heapify, heappop, heappush\n\nvar_1 = int(10e15)\nvar_2 = -var_1\nvar_11 = 1000000007\nsys.setrecursionlimit(1000000)\n\n\ndef func_2():\n return list(map(int, input().split()))\n\n\ndef func_4():\n return input().split()\n\n\ndef func_1():\n return int(sys.stdin.readline())\n\n\ndef func_3():\n return eval(input())\n\n\nvar_3, var_4 = func_2()\nvar_5 = [func_2() for var_9 in range(var_3)]\nvar_5.sort(key=itemgetter(0))\n\nvar_8 = [[0] * (var_4 + 1 + 3000 + 1) for _ in range(var_3 + 1)]\nvar_6 = 0\nfor var_9 in range(var_3):\n for var_10 in range(var_4 + 1 + 3000 + 1):\n var_12, var_7 = var_5[var_9]\n if 0 <= var_10 - var_12 < var_4:\n var_8[var_9 + 1][var_10] = max(\n var_8[var_9][var_10], var_8[var_9][var_10 - var_12] + var_7\n )\n else:\n var_8[var_9 + 1][var_10] = var_8[var_9][var_10]\n var_6 = max(var_6, var_8[var_9 + 1][var_10])\nprint(var_6)\n```", "output": "SLOWER 4.4124", "pair_id": "python_p02863_reversed", "problem_id": "p02863", "language": "python", "direction": "reversed", "speedup_ratio": 21.2943} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\n\n\ndef func_1():\n var_9 = int(sys.stdin.readline().rstrip())\n var_8 = list(map(int, sys.stdin.read().split()))\n var_2 = list(zip(var_8, var_8))\n var_7 = [[] for _ in range(var_9 + 1)]\n for var_1, var_3 in var_2:\n var_7[var_1].append(var_3)\n var_7[var_3].append(var_1)\n var_13 = 1\n var_11 = [None] * (var_9 + 1)\n\n var_5 = []\n var_14 = [var_13]\n\n while var_14:\n var_15 = var_14.pop()\n\n for var_16 in var_7[var_15]:\n if var_16 == var_11[var_15]:\n continue\n\n var_11[var_16] = var_15\n var_14.append(var_16)\n var_5.append(var_15)\n var_6 = [-1] * (var_9 + 1)\n for var_15 in var_5:\n var_10 = var_6[var_15]\n var_4 = 1\n for var_16 in var_7[var_15]:\n if var_16 == var_11[var_15]:\n continue\n if var_4 == var_10:\n var_4 += 1\n var_6[var_16] = var_4\n var_4 += 1\n var_12 = []\n for var_1, var_3 in var_2:\n if var_1 == var_11[var_3]:\n var_12.append(var_6[var_3])\n else:\n var_12.append(var_6[var_1])\n print((max(var_12)))\n print((\"\\n\".join(map(str, var_12))))\n\n\nif __name__ == \"__main__\":\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nimport copy\n\nvar_8 = int(eval(input()))\nvar_10 = set([var_6 for var_6 in range(1, 10**5)])\nvar_5 = []\nvar_11 = {}\nvar_9 = []\nfor var_6 in range(var_8 - 1):\n var_1, var_2 = list(map(int, input().split(\" \")))\n var_5.append([var_1, var_2])\n var_11.setdefault(var_1, []).append(var_2)\n var_9.append([])\nvar_9.append([])\nvar_9.append([])\nvar_7 = 0\nfor var_12 in range(1, var_8 + 1):\n var_14 = var_11.get(var_12, [])\n var_3 = 1\n for var_13 in var_14:\n if var_3 in var_9[var_12]:\n var_3 += 1\n else:\n pass\n var_9[var_13].append(var_3)\n if var_3 >= var_7:\n var_7 = var_3\n var_3 += 1\nprint(var_7)\nfor var_4 in var_5:\n print((var_9[var_4[1]][0]))\n```", "output": "SLOWER 4.1418", "pair_id": "python_p02850_reversed", "problem_id": "p02850", "language": "python", "direction": "reversed", "speedup_ratio": 17.653} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = [\n var_3 for var_3 in map(str, list(range(var_1, var_2 + 1))) if var_3 == var_3[::-1]\n]\nprint((len(var_4)))\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_8 in range(var_1, var_2 + 1):\n var_7 = str(var_8)\n var_6 = len(var_7)\n var_4 = True\n for var_5 in range(var_6 // 2):\n if var_7[var_5] != var_7[var_6 - 1 - var_5]:\n var_4 = False\n break\n if var_4:\n var_3 += 1\nprint(var_3)\n```", "output": "SLOWER 1.8248", "pair_id": "python_p03416_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 3.5426} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport math\nfrom decimal import Decimal\n\nvar_1, var_2 = list(map(Decimal, input().split()))\nprint((math.floor(var_1 * var_2)))\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\nimport math\nfrom collections import defaultdict\nfrom bisect import bisect_left, bisect_right\n\nsys.setrecursionlimit(10**7)\n\n\ndef func_4():\n return sys.stdin.readline()[:-1]\n\n\nvar_4 = 10**9 + 7\n\n\ndef func_1():\n return int(eval(func_4()))\n\n\ndef func_2():\n return list(map(int, func_4().split()))\n\n\ndef func_3(var_6, var_3):\n if var_6 <= 0:\n return [[] for _ in range(var_3)]\n elif var_3 == 1:\n return [func_1() for _ in range(var_6)]\n else:\n var_5 = [func_2() for _ in range(var_6)]\n return list(map(list, list(zip(*var_5))))\n\n\nvar_1, var_2 = list(map(str, func_4().split()))\nvar_1 = int(var_1)\nvar_2 = 100 * int(var_2[0]) + 10 * int(var_2[2]) + int(var_2[3])\nprint((var_1 * var_2 // 100))\n```", "output": "SLOWER 2.455", "pair_id": "python_p02659_reversed", "problem_id": "p02659", "language": "python", "direction": "reversed", "speedup_ratio": 5.4831} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_6 = input()[::-1]\nvar_5 = len(var_6)\nvar_1 = [0] * var_5\nvar_3 = [0] * var_5\nvar_2 = [0] * 2019\nvar_7 = 10\nvar_1[0] = int(var_6[0])\nvar_3[0] = var_1[0]\nvar_2[var_3[0]] += 1\nfor var_4 in range(1, var_5):\n var_1[var_4] = int(var_6[var_4]) * var_7 % 2019\n var_3[var_4] = (var_3[var_4 - 1] + var_1[var_4]) % 2019\n var_2[var_3[var_4]] += 1\n var_7 = var_7 * 10 % 2019\nprint(\n (\n int(sum([var_2[var_4] * (var_2[var_4] - 1) for var_4 in range(2019)]) / 2)\n + var_2[0]\n )\n)\n```\n\n=== Code B (Modified) ===\n```python\nfrom collections import Counter\n\nvar_1 = input()[::-1]\nvar_5 = [0]\nvar_4 = 0\nvar_6 = 2019\nfor var_7 in var_1:\n var_8 = int(var_7) * pow(10, var_4, var_6) % var_6\n var_8 = var_5[-1] + var_8\n var_5.append(var_8 % var_6)\n var_4 += 1\nvar_3 = Counter(var_5)\nvar_2 = sum(var_9 * (var_9 - 1) // 2 for var_9 in list(var_3.values()))\nprint(var_2)\n```", "output": "FASTER 1.6668", "pair_id": "python_p02702_forward", "problem_id": "p02702", "language": "python", "direction": "forward", "speedup_ratio": 3.175} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_5 in range(10):\n for var_6 in range(10):\n for var_7 in range(10):\n var_3 = 10000 * var_5 + 1000 * var_6 + 100 * var_7 + 10 * var_6 + var_5\n if var_1 <= var_3 <= var_2:\n var_4 += 1\nprint(var_4)\n```\n\n=== Code B (Modified) ===\n```python\nfrom sys import stdin\n\nvar_6 = lambda: list(map(int, stdin.readline().split()))\nvar_5 = lambda: list(map(int, stdin.readline().split()))\nvar_1, var_3 = var_6()\nvar_2 = 0\nfor var_4 in range(var_1, var_3 + 1):\n var_7 = str(var_4)\n if var_7 == var_7[::-1]:\n var_2 += 1\nprint(var_2)\n```", "output": "SLOWER 3.844", "pair_id": "python_p03416_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 14.3598} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_8 = int(eval(input()))\nvar_6 = []\nfor var_7 in range(var_8 - 1):\n var_1, var_3 = list(map(int, input().split()))\n var_6.append([var_1 - 1, var_3 - 1, var_7])\nvar_6.sort()\nvar_12 = [0] * (var_8)\nvar_2 = [0] * (var_8 - 1)\nvar_9 = 1\nvar_10 = 0\nfor var_5 in var_6:\n _from, var_11, var_7 = var_5\n if _from != var_10:\n var_9 = 1\n if var_12[_from] == var_9:\n var_9 += 1\n var_2[var_7] = var_9\n var_12[var_11] = var_9\n var_9 += 1\n var_10 = _from\nprint((max(var_2)))\nfor var_4 in var_2:\n print(var_4)\n```\n\n=== Code B (Modified) ===\n```python\nfrom collections import deque\n\n\ndef func_2(var_9, var_2, var_4):\n\n var_6 = {var_7: dict() for var_7 in range(var_9)}\n for var_7 in range(var_9 - 1):\n var_1, var_3 = var_2[var_7] - 1, var_4[var_7] - 1\n var_6[var_1][var_3] = -1\n var_6[var_3][var_1] = -1\n var_8 = max([len(var_6[var_1]) for var_1 in range(var_9)])\n var_14 = [-1] * var_9\n var_14[0] = var_8 - 1\n\n var_12 = deque([0])\n while len(var_12) > 0:\n var_10 = var_12.popleft()\n var_5 = var_14[var_10]\n for var_11 in list(var_6[var_10].keys()):\n if var_14[var_11] != -1:\n continue\n var_5 += 1\n var_5 %= var_8\n\n var_6[var_10][var_11] = var_5\n var_6[var_11][var_10] = var_5\n var_14[var_11] = var_5\n var_12.append(var_11)\n var_13 = [0] * (var_9 - 1)\n for var_7 in range(var_9 - 1):\n var_13[var_7] = var_6[var_2[var_7] - 1][var_4[var_7] - 1] + 1\n return var_8, var_13\n\n\ndef func_1():\n var_9 = int(eval(input()))\n var_2 = [0] * (var_9 - 1)\n var_4 = [0] * (var_9 - 1)\n for var_7 in range(var_9 - 1):\n var_1, var_3 = list(map(int, input().split()))\n var_2[var_7] = var_1\n var_4[var_7] = var_3\n var_8, var_13 = func_2(var_9, var_2, var_4)\n print(var_8)\n for var_7 in range(var_9 - 1):\n print((var_13[var_7]))\n\n\ndef func_3():\n print((func_2(3, [1, 2], [2, 3])))\n print((func_2(8, [1, 2, 2, 2, 4, 5, 6], [2, 3, 4, 5, 7, 6, 8])))\n\n\nif __name__ == \"__main__\":\n\n func_1()\n```", "output": "SLOWER 1.2239", "pair_id": "python_p02850_reversed", "problem_id": "p02850", "language": "python", "direction": "reversed", "speedup_ratio": 2.3358} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\ndef func_1():\n from sys import setrecursionlimit, stdin\n from os import environ\n from collections import defaultdict, deque, Counter\n from math import ceil, floor, gcd\n from itertools import accumulate, combinations, combinations_with_replacement\n\n setrecursionlimit(10**6)\n var_7 = (\n (lambda *var_11: print(*var_11))\n if \"TERM_PROGRAM\" in environ\n else lambda *var_12: 0\n )\n var_8 = lambda: stdin.readline().rstrip()\n var_3 = lambda: list(map(int, var_8().split()))\n var_1 = lambda: int(var_8())\n var_4 = 10**9 + 7\n var_2 = 10**9 + 10\n var_9, var_10 = var_8().split()\n var_5 = int(var_9)\n var_10 = var_10.split(\".\")\n var_6 = int(var_10[0]) * 100\n if len(var_10) == 2:\n var_6 += int(var_10[1])\n print(var_5 * var_6 // 100)\n\n\nfunc_1()\n```\n\n=== Code B (Modified) ===\n```python\ndef func_1():\n var_1, var_3 = input().split()\n var_1 = int(var_1)\n var_3 = int(float(var_3) * 100 + 0.5)\n var_2 = var_1 * var_3\n print((var_2 // 100))\n\n\nif __name__ == \"__main__\":\n func_1()\n```", "output": "FASTER 1.7187", "pair_id": "python_p02659_forward", "problem_id": "p02659", "language": "python", "direction": "forward", "speedup_ratio": 3.2915} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nfrom sys import stdin\n\n\ndef func_1():\n\n var_11 = stdin.readline\n var_2 = int(var_11())\n var_1 = []\n for var_6 in range(var_2):\n var_5 = int(\"\".join(var_11().strip().split(\" \")), 2)\n var_1.append(var_5)\n var_3 = []\n for var_6 in range(var_2):\n var_10 = list(map(int, var_11().split()))\n var_3.append(var_10)\n var_8 = float(\"-inf\")\n for var_9 in range(1, 1 << 10):\n var_12 = 0\n for var_7 in range(var_2):\n var_4 = bin(var_9 & var_1[var_7]).count(\"1\")\n var_12 += var_3[var_7][var_4]\n var_8 = max(var_12, var_8)\n print(var_8)\n\n\nif __name__ == \"__main__\":\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nimport itertools\n\nvar_6 = int(eval(input()))\nvar_2 = [[]] * var_6\nfor var_4 in range(var_6):\n var_3 = list(map(int, input().split()))\n\n var_2[var_4] = var_3\nvar_8 = [[]] * var_6\nfor var_4 in range(var_6):\n var_9 = list(map(int, input().split()))\n var_8[var_4] = var_9\nvar_10 = -(10**11)\nfor var_1 in itertools.product([0, 1], repeat=10):\n if sum(var_1) == 0:\n continue\n var_11 = 0\n for var_7 in range(var_6):\n var_5 = 0\n for var_4 in range(10):\n if var_2[var_7][var_4] == 1 and var_1[var_4] == 1:\n var_5 += 1\n var_11 = var_11 + var_8[var_7][var_5]\n var_10 = max(var_10, var_11)\nprint(var_10)\n```", "output": "SLOWER 2.8495", "pair_id": "python_p03503_reversed", "problem_id": "p03503", "language": "python", "direction": "reversed", "speedup_ratio": 7.2074} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\ndef func_1():\n var_2 = int(input())\n var_1 = [int(var_6) for var_6 in input().split()]\n if var_2 == 1:\n return print(1 if var_1[0] % 2 == 0 else 2)\n var_3 = 0\n var_5 = (-1, 0, 1)\n from itertools import product\n\n for var_6 in product(range(3), repeat=var_2):\n var_4 = 1\n for var_7 in range(var_2):\n var_4 *= var_1[var_7] + var_5[var_6[var_7]]\n if var_4 % 2 == 0:\n var_3 += 1\n print(var_3)\n\n\nif __name__ == \"__main__\":\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nvar_2 = int(eval(input()))\nvar_1 = list(map(int, input().split()))\nvar_4 = 1\nfor var_3 in range(var_2):\n if var_1[var_3] % 2 == 0:\n var_4 *= 2\nprint((3**var_2 - var_4))\n```", "output": "FASTER 8.5767", "pair_id": "python_p03568_forward", "problem_id": "p03568", "language": "python", "direction": "forward", "speedup_ratio": 381.8046} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\n\nvar_8 = sys.stdin.readline\n\n\ndef func_1():\n var_2 = int(eval(var_8()))\n var_1 = []\n for _ in range(var_2):\n var_1.append(list(map(int, var_8().split())))\n var_3 = []\n for _ in range(var_2):\n var_3.append(list(map(int, var_8().split())))\n var_4 = -(10**7) * var_2\n for var_7 in range(1, 1 << 10):\n var_11 = 0\n for var_10, var_6 in enumerate(var_1):\n var_5 = 0\n for var_9 in range(10):\n if (var_7 >> var_9) & 1 & var_6[var_9]:\n var_5 += 1\n var_11 += var_3[var_10][var_5]\n var_4 = max(var_4, var_11)\n print(var_4)\n\n\nif __name__ == \"__main__\":\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nfrom sys import stdin\n\n\ndef func_1():\n\n var_11 = stdin.readline\n var_2 = int(var_11())\n var_1 = []\n for var_6 in range(var_2):\n var_5 = int(\"\".join(var_11().strip().split(\" \")), 2)\n var_1.append(var_5)\n var_3 = []\n for var_6 in range(var_2):\n var_10 = list(map(int, var_11().split()))\n var_3.append(var_10)\n var_8 = float(\"-inf\")\n for var_9 in range(1, 1 << 10):\n var_12 = 0\n for var_7 in range(var_2):\n var_4 = bin(var_9 & var_1[var_7]).count(\"1\")\n var_12 += var_3[var_7][var_4]\n var_8 = max(var_12, var_8)\n print(var_8)\n\n\nif __name__ == \"__main__\":\n func_1()\n```", "output": "FASTER 1.9105", "pair_id": "python_p03503_forward", "problem_id": "p03503", "language": "python", "direction": "forward", "speedup_ratio": 3.7593} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_6 = input()[::-1]\nvar_5 = len(var_6)\nvar_1 = [0] * var_5\nvar_3 = [0] * var_5\nvar_2 = [0] * 2019\nvar_7 = 10\nvar_1[0] = int(var_6[0])\nvar_3[0] = var_1[0]\nvar_2[var_3[0]] += 1\nfor var_4 in range(1, var_5):\n var_1[var_4] = int(var_6[var_4]) * var_7 % 2019\n var_3[var_4] = (var_3[var_4 - 1] + var_1[var_4]) % 2019\n var_2[var_3[var_4]] += 1\n var_7 = var_7 * 10 % 2019\nprint(\n (\n int(sum([var_2[var_4] * (var_2[var_4] - 1) for var_4 in range(2019)]) / 2)\n + var_2[0]\n )\n)\n```\n\n=== Code B (Modified) ===\n```python\nvar_6 = 2019\nvar_1 = [0] * var_6\nvar_3 = 1\nvar_5 = var_4 = 0\nfor var_2 in input()[::-1]:\n var_1[var_4] += 1\n var_4 -= int(var_2) * var_3\n var_4 %= var_6\n var_5 += var_1[var_4]\n var_3 *= 10\n var_3 %= var_6\nprint(var_5)\n```", "output": "FASTER 2.581", "pair_id": "python_p02702_forward", "problem_id": "p02702", "language": "python", "direction": "forward", "speedup_ratio": 5.9835} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_6 = sorted([list(map(int, input().split())) for var_5 in range(var_1)])\n\nvar_4 = [[0] * (var_2 + 1) for var_5 in range(var_1 + 1)]\n\nfor var_5 in range(var_1):\n var_9, var_8 = var_6[var_5]\n for var_7 in range(var_2 + 1):\n if var_7 + var_9 <= var_2:\n var_4[var_5 + 1][var_7 + var_9] = max(\n var_4[var_5 + 1][var_7 + var_9], var_4[var_5][var_7] + var_8\n )\n var_4[var_5 + 1][var_7] = max(var_4[var_5][var_7], var_4[var_5 + 1][var_7])\nvar_3 = 0\nfor var_5, (var_9, var_8) in enumerate(var_6):\n for var_7 in range(var_2):\n var_3 = max(var_3, var_4[var_5][var_7] + var_8)\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_6, var_7 = list(map(int, input().split()))\nvar_1 = [list(map(int, input().split())) for _ in range(var_6)]\nvar_1.sort()\nvar_3 = [(6007) * [0] for _ in range(var_6 + 1)]\nvar_3[0][0] = 0\nvar_2 = 0\nfor var_4 in range(var_6):\n for var_5 in range(6007):\n var_3[var_4 + 1][var_5] = max(var_3[var_4 + 1][var_5], var_3[var_4][var_5])\n if var_5 < var_7:\n var_3[var_4 + 1][var_5 + var_1[var_4][0]] = max(\n var_3[var_4][var_5] + var_1[var_4][1],\n var_3[var_4][var_5 + var_1[var_4][0]],\n )\n var_2 = max(var_2, var_3[var_4 + 1][var_5])\nprint(var_2)\n```", "output": "SLOWER 4.9584", "pair_id": "python_p02863_reversed", "problem_id": "p02863", "language": "python", "direction": "reversed", "speedup_ratio": 31.0909} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\n\n\ndef func_1(var_5, var_6):\n var_4 = 0\n for var_3 in range(var_5, var_6 + 1):\n if str(var_3) == str(var_3)[::-1]:\n var_4 += 1\n return var_4\n\n\nprint((func_1(var_1, var_2)))\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = list(reversed(list(str(var_4))))\n if var_5 == list(str(var_4)):\n var_3 += 1\nprint(var_3)\n```", "output": "SLOWER 1.9806", "pair_id": "python_p03416_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 3.9465} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_6 = int(eval(input()))\nvar_2 = list(map(int, input().split()))\nfrom itertools import product\n\nvar_5 = [-1, 0, 1]\nvar_3 = 0\nfor var_7 in product(var_5, repeat=var_6):\n var_1 = []\n for var_4 in range(var_6):\n var_1.append(var_7[var_4] + var_2[var_4])\n if any(var_8 % 2 == 0 for var_8 in var_1):\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\ndef func_1():\n var_2 = int(input())\n var_1 = [int(var_6) for var_6 in input().split()]\n if var_2 == 1:\n return print(1 if var_1[0] % 2 == 0 else 2)\n var_3 = 0\n var_5 = (-1, 0, 1)\n from itertools import product\n\n for var_6 in product(range(3), repeat=var_2):\n var_4 = 1\n for var_7 in range(var_2):\n var_4 *= var_1[var_7] + var_5[var_6[var_7]]\n if var_4 % 2 == 0:\n var_3 += 1\n print(var_3)\n\n\nif __name__ == \"__main__\":\n func_1()\n```", "output": "FASTER 1.2741", "pair_id": "python_p03568_forward", "problem_id": "p03568", "language": "python", "direction": "forward", "speedup_ratio": 2.4185} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_3 = list(map(int, input().split()))\nvar_2 = -1\nfor var_4 in range(10, 12501):\n if int(var_4 * 0.08) == var_1 and int(var_4 * 0.1) == var_3:\n var_2 = var_4\n break\nprint(var_2)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nimport math\n\nif math.ceil((var_1 + 1) * 12.5) <= math.ceil(var_2 * 10) or math.ceil(\n var_1 * 12.5\n) >= math.ceil((var_2 + 1) * 10):\n print((-1))\nelse:\n print((max(math.ceil(var_1 * 12.5), math.ceil(var_2 * 10))))\n```", "output": "FASTER 5.3196", "pair_id": "python_p02755_forward", "problem_id": "p02755", "language": "python", "direction": "forward", "speedup_ratio": 39.9354} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_2, var_1 = [int(var_12) for var_12 in input().split()]\nvar_3 = []\nfor var_8 in range(var_1):\n var_5, var_6 = [int(var_12) for var_12 in input().split()]\n var_3.append((var_5, var_6))\nvar_3.sort()\nvar_9 = float(\"inf\")\nvar_4 = [var_9 for var_5 in range(var_2 + 1)]\nfor var_5, var_6 in var_3:\n var_4[var_5] = min(var_4[var_5], var_6)\nvar_3 = [\n (var_5, var_4[var_5]) for var_5 in range(1, var_2 + 1) if var_4[var_5] != var_9\n]\nvar_3.sort(key=lambda var_11: var_11[1])\nvar_7 = [True] * (var_2)\nvar_10 = None\nfor var_5, var_6 in var_3:\n if var_10 == None or var_10 < var_5:\n var_7[var_6 - 1] = False\n var_10 = var_6 - 1\nprint((sum(1 for var_6 in var_7 if not var_6)))\n```\n\n=== Code B (Modified) ===\n```python\nvar_6, var_5 = list(map(int, input().split(\" \")))\nvar_2 = [list(map(int, input().split(\" \"))) for _ in range(var_5)]\nvar_2.sort(key=lambda var_7: var_7[1])\nvar_4 = 0\nvar_7 = 0\nfor var_1, var_3 in var_2:\n if var_1 <= var_7 < var_3:\n continue\n var_7 = var_3 - 1\n var_4 += 1\nprint(var_4)\n```", "output": "FASTER 1.0353", "pair_id": "python_p03295_forward", "problem_id": "p03295", "language": "python", "direction": "forward", "speedup_ratio": 2.0495} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1 = list(map(int, input().split()))\nvar_2 = 0\nfor var_3 in range(var_1[0], var_1[1] + 1):\n var_4 = str(var_3)\n if var_4[0] == var_4[4] and var_4[1] == var_4[3]:\n var_2 += 1\nprint(var_2)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().rstrip().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = list(map(int, list(str(var_4))))\n if var_5[0] == var_5[4] and var_5[1] == var_5[3]:\n var_3 += 1\nprint(var_3)\n```", "output": "SLOWER 1.9718", "pair_id": "python_p03416_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 3.9226} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\nfrom collections import deque\n\nvar_13 = sys.stdin.readline\nvar_2 = int(eval(var_13()))\nvar_5 = [[] for _ in range(var_2)]\nvar_3 = [-1] * var_2\nfor var_12 in range(var_2 - 1):\n var_6, var_8 = list(map(int, var_13().split()))\n var_5[var_6 - 1].append((var_12, var_8 - 1))\n\n\nvar_4 = deque([(0, -1)])\nvar_1 = [-1] * (var_2 - 1)\nvar_11 = 0\nwhile var_4:\n var_14, var_10 = var_4.pop()\n var_9 = 1\n for var_12, var_15 in var_5[var_14]:\n if var_9 == var_10:\n var_9 += 1\n var_1[var_12] = var_9\n var_4.appendleft((var_15, var_9))\n var_9 += 1\n var_11 = max(var_11, var_9 - 1)\nprint(var_11)\nfor var_7 in var_1:\n print(var_7)\n```\n\n=== Code B (Modified) ===\n```python\nimport copy\n\nvar_8 = int(eval(input()))\nvar_10 = set([var_6 for var_6 in range(1, 10**5)])\nvar_5 = []\nvar_11 = {}\nvar_9 = []\nfor var_6 in range(var_8 - 1):\n var_1, var_2 = list(map(int, input().split(\" \")))\n var_5.append([var_1, var_2])\n var_11.setdefault(var_1, []).append(var_2)\n var_9.append([])\nvar_9.append([])\nvar_9.append([])\nvar_7 = 0\nfor var_12 in range(1, var_8 + 1):\n var_14 = var_11.get(var_12, [])\n var_3 = 1\n for var_13 in var_14:\n if var_3 in var_9[var_12]:\n var_3 += 1\n else:\n pass\n var_9[var_13].append(var_3)\n if var_3 >= var_7:\n var_7 = var_3\n var_3 += 1\nprint(var_7)\nfor var_4 in var_5:\n print((var_9[var_4[1]][0]))\n```", "output": "SLOWER 4.6753", "pair_id": "python_p02850_reversed", "problem_id": "p02850", "language": "python", "direction": "reversed", "speedup_ratio": 25.551} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\ndef func_1():\n var_1, var_2 = list(map(int, input().split()))\n var_3 = 0\n for var_4 in range(var_1, var_2 + 1):\n\n if (var_4 % 10) == (var_4 // 10000 % 10) and (var_4 // 10 % 10) == (\n var_4 // 1000 % 10\n ):\n var_3 += 1\n print(var_3)\n\n\nif __name__ == \"__main__\":\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nvar_1 = list(map(int, input().split()))\nvar_2 = 0\nfor var_3 in range(var_1[0], var_1[1] + 1):\n var_4 = str(var_3)\n if var_4[0] == var_4[4] and var_4[1] == var_4[3]:\n var_2 += 1\nprint(var_2)\n```", "output": "SLOWER 1.3752", "pair_id": "python_p03416_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 2.5941} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\nimport itertools\n\n\ndef func_2(var_4):\n return bin(eval(\"0b\" + str(var_4)))\n\n\ndef func_1():\n var_4 = int(sys.stdin.readline().rstrip())\n var_9 = [\n func_2(\"\".join(str(var_10) for var_10 in sys.stdin.readline().split()))\n for _ in range(var_4)\n ]\n var_8 = [\n [int(var_10) for var_10 in sys.stdin.readline().split()] for _ in range(var_4)\n ]\n var_3 = -(10**10)\n for var_6 in itertools.product(\"01\", repeat=10):\n var_6 = func_2(\"\".join(var_6))\n if var_6 == \"0b0\":\n continue\n var_7 = 0\n for var_2 in range(var_4):\n var_1 = var_9[var_2]\n var_5 = bin(eval(var_1) & eval(var_6)).count(\"1\")\n var_7 += var_8[var_2][var_5]\n var_3 = max(var_3, var_7)\n print(var_3)\n\n\nif __name__ == \"__main__\":\n\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nvar_5 = 0\nif var_5 == 0:\n var_8 = int(eval(input()))\n var_2 = []\n for var_4 in range(var_8):\n var_3 = list(map(int, input().split()))\n var_2.append(var_3)\n var_9 = []\n for var_4 in range(var_8):\n var_10 = list(map(int, input().split()))\n var_9.append(var_10)\nelif var_5 == 1:\n var_8 = 1\n var_2 = [[1, 1, 0, 1, 0, 0, 0, 1, 0, 1]]\n var_9 = [[3, 4, 5, 6, 7, 8, 9, -2, -3, 4, -2]]\nelif var_5 == 2:\n var_8 = 2\n var_2 = [[1, 1, 1, 1, 1, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 1, 1, 1, 1, 1]]\n var_9 = [\n [0, -2, -2, -2, -2, -2, -1, -1, -1, -1, -1],\n [0, -2, -2, -2, -2, -2, -1, -1, -1, -1, -1],\n ]\nelif var_5 == 3:\n var_8 = 3\n var_2 = [\n [1, 1, 1, 1, 1, 1, 0, 0, 1, 1],\n [0, 1, 0, 1, 1, 1, 1, 0, 1, 0],\n [1, 0, 1, 1, 0, 1, 0, 1, 0, 1],\n ]\n var_9 = [\n [-8, 6, -2, -8, -8, 4, 8, 7, -6, 2, 2],\n [-9, 2, 0, 1, 7, -5, 0, -2, -6, 5, 5],\n [6, -6, 7, -9, 6, -5, 8, 0, -9, -7, -7],\n ]\nimport itertools\n\nvar_13 = -(10**11)\nfor var_4 in itertools.product([0, 1], repeat=10):\n var_11 = list(var_4)\n var_12 = 0\n if sum(var_11) != 0:\n for var_7 in range(var_8):\n var_1 = 0\n for var_6 in range(10):\n var_1 = var_1 + var_11[var_6] * var_2[var_7][var_6]\n var_12 = var_12 + var_9[var_7][var_1]\n\n var_13 = max(var_12, var_13)\nprint(var_13)\n```", "output": "FASTER 2.1766", "pair_id": "python_p03503_forward", "problem_id": "p03503", "language": "python", "direction": "forward", "speedup_ratio": 4.5208} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_6 in range(var_1, var_2 + 1):\n var_3 = str(var_6)\n var_5 = True\n for var_7 in range(len(var_3) // 2):\n if var_3[var_7] != var_3[-var_7 - 1] and var_5:\n var_5 = not var_5\n if var_5:\n var_4 += 1\nprint(var_4)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_6 = str(var_4)\n var_5 = var_6[::-1]\n if var_6 == var_5:\n var_3 += 1\nprint(var_3)\n```", "output": "FASTER 1.2096", "pair_id": "python_p03416_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 2.3127} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_6 = int(eval(input()))\nvar_2 = list(map(int, input().split()))\nfrom itertools import product\n\nvar_5 = [-1, 0, 1]\nvar_3 = 0\nfor var_7 in product(var_5, repeat=var_6):\n var_1 = []\n for var_4 in range(var_6):\n var_1.append(var_7[var_4] + var_2[var_4])\n if any(var_8 % 2 == 0 for var_8 in var_1):\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_2 = int(eval(input()))\nvar_1 = list(map(int, input().split()))\nvar_4 = 1\nfor var_3 in range(var_2):\n if var_1[var_3] % 2 == 0:\n var_4 *= 2\nprint((3**var_2 - var_4))\n```", "output": "FASTER 9.8508", "pair_id": "python_p03568_forward", "problem_id": "p03568", "language": "python", "direction": "forward", "speedup_ratio": 923.3817} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nfrom functools import *\n\n_, var_1 = open(0)\nprint(\n (\n \"YNeos\"[\n var_2(lambda var_3, var_4: var_3 ^ var_4, list(map(int, var_1.split())))\n > 0 :: 2\n ]\n )\n)\n```\n\n=== Code B (Modified) ===\n```python\nfrom collections import Counter\n\nvar_4 = int(eval(input()))\nvar_1 = list(map(int, input().split()))\nvar_2 = Counter(var_1)\nvar_3 = list(var_2)\nif sum(var_1) == 0:\n print(\"Yes\")\nelif len(var_1) % 3 != 0:\n print(\"No\")\nelif len(var_2) > 3 or len(var_2) <= 1:\n print(\"No\")\nelif len(var_2) == 3:\n if (\n var_2[var_3[0]] == var_4 // 3\n and var_2[var_3[1]] == var_4 // 3\n and var_2[var_3[2]] == var_4 // 3\n ):\n if var_3[0] ^ var_3[1] ^ var_3[2] == 0:\n print(\"Yes\")\n else:\n print(\"No\")\n else:\n print(\"No\")\nelse:\n var_3.sort()\n if var_3[0] == 0 and var_2[var_3[0]] == var_4 // 3:\n print(\"Yes\")\n else:\n print(\"No\")\n```", "output": "SLOWER 1.3002", "pair_id": "python_p02975_reversed", "problem_id": "p02975", "language": "python", "direction": "reversed", "speedup_ratio": 2.4627} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\ndef func_1():\n var_1, var_2 = list(map(int, input().rstrip().split()))\n var_3 = 0\n for var_4 in range(var_1, var_2 + 1):\n var_5 = str(var_4)\n if var_5 == var_5[::-1]:\n var_3 += 1\n print(var_3)\n\n\nif __name__ == \"__main__\":\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_3 = list(map(int, input().split()))\nvar_2 = 0\nfor var_5 in range(var_3 + 1)[var_1:]:\n if len(str(var_5)) % 2 == 0:\n var_6 = list(str(var_5))[: len(str(var_5)) // 2]\n var_7 = list(reversed(list(str(var_5))[len(str(var_5)) // 2 :]))\n if var_6 == var_7:\n var_2 += 1\n else:\n var_8 = list(str(var_5))[: len(str(var_5)) // 2 + 1]\n var_4 = list(reversed(list(str(var_5))[len(str(var_5)) // 2 :]))\n if var_8 == var_4:\n var_2 += 1\nprint(var_2)\n```", "output": "SLOWER 3.2205", "pair_id": "python_p03416_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 9.3213} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\ndef func_1():\n from sys import setrecursionlimit, stdin\n from os import environ\n from collections import defaultdict, deque, Counter\n from math import ceil, floor, gcd\n from itertools import accumulate, combinations, combinations_with_replacement\n\n setrecursionlimit(10**6)\n var_7 = (\n (lambda *var_11: print(*var_11))\n if \"TERM_PROGRAM\" in environ\n else lambda *var_12: 0\n )\n var_8 = lambda: stdin.readline().rstrip()\n var_3 = lambda: list(map(int, var_8().split()))\n var_1 = lambda: int(var_8())\n var_4 = 10**9 + 7\n var_2 = 10**9 + 10\n var_9, var_10 = var_8().split()\n var_5 = int(var_9)\n var_10 = var_10.split(\".\")\n var_6 = int(var_10[0]) * 100\n if len(var_10) == 2:\n var_6 += int(var_10[1])\n print(var_5 * var_6 // 100)\n\n\nfunc_1()\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\n\nvar_3 = sys.stdin.readline\nvar_1, var_2 = var_3().split()\nvar_1 = int(var_1)\nvar_2 = int(float(var_2) * 100 + 0.5)\nprint((var_1 * var_2 // 100))\n```", "output": "FASTER 2.1571", "pair_id": "python_p02659_forward", "problem_id": "p02659", "language": "python", "direction": "forward", "speedup_ratio": 4.4601} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\ndef func_1():\n var_1, var_3 = input().split()\n var_1 = int(var_1)\n var_3 = int(float(var_3) * 100 + 0.5)\n var_2 = var_1 * var_3\n print((var_2 // 100))\n\n\nif __name__ == \"__main__\":\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\nimport math\nfrom collections import defaultdict\nfrom bisect import bisect_left, bisect_right\n\nsys.setrecursionlimit(10**7)\n\n\ndef func_4():\n return sys.stdin.readline()[:-1]\n\n\nvar_4 = 10**9 + 7\n\n\ndef func_1():\n return int(eval(func_4()))\n\n\ndef func_2():\n return list(map(int, func_4().split()))\n\n\ndef func_3(var_6, var_3):\n if var_6 <= 0:\n return [[] for _ in range(var_3)]\n elif var_3 == 1:\n return [func_1() for _ in range(var_6)]\n else:\n var_5 = [func_2() for _ in range(var_6)]\n return list(map(list, list(zip(*var_5))))\n\n\nfrom decimal import getcontext, Decimal\n\ngetcontext().prec = 28\nvar_1, var_2 = list(map(str, func_4().split()))\nvar_1 = int(var_1)\nvar_2 = Decimal(var_2)\nprint((int(var_1 * var_2)))\n```", "output": "SLOWER 1.8519", "pair_id": "python_p02659_reversed", "problem_id": "p02659", "language": "python", "direction": "reversed", "speedup_ratio": 3.6097} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_11 = int(eval(input()))\nvar_12 = {var_8: [] for var_8 in range(1, var_11 + 1)}\nvar_19 = [False for var_8 in range(var_11 + 1)]\nvar_16 = []\nfor _ in range(var_11 - 1):\n var_2, var_3 = list(map(int, input().split()))\n var_12[var_2].append(var_3)\n var_12[var_3].append(var_2)\n var_16.append((var_2, var_3))\nvar_9 = var_16[0][0]\nvar_19[var_9] = True\nvar_6 = []\nvar_7 = []\nvar_14 = {var_8: {} for var_8 in range(1, var_11 + 1)}\nvar_10 = [0 for var_8 in range(var_11 + 1)]\n\nvar_4 = 1\nfor var_5 in var_12[var_9]:\n var_19[var_5] = True\n var_14[var_9][var_5] = var_4\n var_14[var_5][var_9] = var_4\n var_10[var_5] = var_4\n var_4 += 1\n var_6.append(var_5)\nwhile var_6:\n for var_15 in var_6:\n var_13 = 1\n for var_5 in var_12[var_15]:\n if var_19[var_5] == False:\n var_19[var_5] = True\n if var_13 != var_10[var_15]:\n var_14[var_15][var_5] = var_13\n var_14[var_5][var_15] = var_13\n var_10[var_5] = var_13\n var_13 += 1\n var_7.append(var_5)\n else:\n var_13 += 1\n var_14[var_15][var_5] = var_13\n var_14[var_5][var_15] = var_13\n var_10[var_5] = var_13\n var_13 += 1\n var_7.append(var_5)\n if var_7:\n var_6 = var_7\n var_7 = []\n else:\n var_6 = []\n var_7 = []\nvar_1 = 0\nfor var_8 in range(1, var_11 + 1):\n var_1 = max(var_1, len(var_12[var_8]))\nprint(var_1)\nfor var_8 in range(var_11 - 1):\n var_17, var_18 = var_16[var_8][0], var_16[var_8][1]\n print((var_14[var_17][var_18]))\n```\n\n=== Code B (Modified) ===\n```python\nimport copy\n\nvar_8 = int(eval(input()))\nvar_10 = set([var_6 for var_6 in range(1, 10**5)])\nvar_5 = []\nvar_11 = {}\nvar_9 = []\nfor var_6 in range(var_8 - 1):\n var_1, var_2 = list(map(int, input().split(\" \")))\n var_5.append([var_1, var_2])\n var_11.setdefault(var_1, []).append(var_2)\n var_9.append([])\nvar_9.append([])\nvar_9.append([])\nvar_7 = 0\nfor var_12 in range(1, var_8 + 1):\n var_14 = var_11.get(var_12, [])\n var_3 = 1\n for var_13 in var_14:\n if var_3 in var_9[var_12]:\n var_3 += 1\n else:\n pass\n var_9[var_13].append(var_3)\n if var_3 >= var_7:\n var_7 = var_3\n var_3 += 1\nprint(var_7)\nfor var_4 in var_5:\n print((var_9[var_4[1]][0]))\n```", "output": "SLOWER 3.6078", "pair_id": "python_p02850_reversed", "problem_id": "p02850", "language": "python", "direction": "reversed", "speedup_ratio": 12.1912} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nfrom collections import Counter, defaultdict, deque\nfrom heapq import heappop, heappush, heapify\nimport sys, bisect, math, itertools, fractions, pprint\n\nsys.setrecursionlimit(10**8)\nvar_6 = 10**9 + 7\nvar_1 = float(\"inf\")\n\n\ndef func_1():\n return int(sys.stdin.readline())\n\n\ndef func_2():\n return list(map(int, sys.stdin.readline().split()))\n\n\nvar_7, var_9 = func_2()\nvar_13 = [func_2() for _ in range(var_7)]\nvar_13.sort(key=lambda var_14: var_14[1], reverse=True)\nvar_8 = 0\nvar_10 = min(var_7, 5)\nfor var_3 in range(var_10):\n var_2 = [[0] * (var_9 + 5) for _ in range(var_7 + 5)]\n for var_4 in range(var_7):\n var_12, var_11 = var_13[var_4]\n for var_5 in range(var_9):\n if var_5 < var_12 or var_3 == var_4:\n var_2[var_4 + 1][var_5] = var_2[var_4][var_5]\n else:\n var_2[var_4 + 1][var_5] = max(\n var_2[var_4][var_5], var_2[var_4][var_5 - var_12] + var_11\n )\n\n var_8 = max(var_2[var_7][var_9 - 1] + var_13[var_3][1], var_8)\nprint(var_8)\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\n\nsys.setrecursionlimit(2147483647)\nvar_2 = float(\"inf\")\nvar_3 = 10**9 + 7\nvar_10 = lambda: sys.stdin.readline().rstrip()\n\n\ndef func_1():\n var_11, var_4 = list(map(int, var_10().split()))\n var_1 = [tuple(map(int, var_10().split())) for _ in range(var_11)]\n var_1.sort()\n var_8 = [0] * var_4\n var_6 = -var_2\n for var_9 in range(var_11):\n var_5, var_7 = var_1[var_9]\n var_12 = var_8[:]\n for var_13 in range(var_4):\n if var_13 + var_5 < var_4:\n var_12[var_13 + var_5] = max(\n var_12[var_13 + var_5], var_8[var_13] + var_7\n )\n else:\n var_6 = max(var_6, var_8[var_13] + var_7)\n var_8 = var_12\n print((max(var_6, max(var_8))))\n\n\nfunc_1()\n```", "output": "FASTER 2.6786", "pair_id": "python_p02863_forward", "problem_id": "p02863", "language": "python", "direction": "forward", "speedup_ratio": 6.4023} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = str(var_4)\n if var_5 == var_5[::-1]:\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_3 = list(map(int, input().split()))\nvar_2 = 0\nfor var_5 in range(var_3 + 1)[var_1:]:\n if len(str(var_5)) % 2 == 0:\n var_6 = list(str(var_5))[: len(str(var_5)) // 2]\n var_7 = list(reversed(list(str(var_5))[len(str(var_5)) // 2 :]))\n if var_6 == var_7:\n var_2 += 1\n else:\n var_8 = list(str(var_5))[: len(str(var_5)) // 2 + 1]\n var_4 = list(reversed(list(str(var_5))[len(str(var_5)) // 2 :]))\n if var_8 == var_4:\n var_2 += 1\nprint(var_2)\n```", "output": "SLOWER 2.479", "pair_id": "python_p03416_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 5.5752} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\n\nvar_8 = sys.stdin.readline\n\n\ndef func_1():\n var_2 = int(eval(var_8()))\n var_1 = [int(var_8().replace(\" \", \"\"), 2) for _ in range(var_2)]\n var_3 = [list(map(int, var_8().split())) for _ in range(var_2)]\n var_4 = -(10**7) * var_2\n for var_7 in range(1, 1 << 10):\n var_10 = 0\n for var_9, var_6 in enumerate(var_1):\n var_5 = bin(var_7 & var_6).count(\"1\")\n var_10 += var_3[var_9][var_5]\n var_4 = max(var_4, var_10)\n print(var_4)\n\n\nif __name__ == \"__main__\":\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\n\nvar_8 = sys.stdin.readline\n\n\ndef func_1():\n var_2 = int(eval(var_8()))\n var_1 = []\n for _ in range(var_2):\n var_1.append(list(map(int, var_8().split())))\n var_3 = []\n for _ in range(var_2):\n var_3.append(list(map(int, var_8().split())))\n var_4 = -(10**7) * var_2\n for var_7 in range(1, 1 << 10):\n var_11 = 0\n for var_10, var_6 in enumerate(var_1):\n var_5 = 0\n for var_9 in range(10):\n if (var_7 >> var_9) & 1 & var_6[var_9]:\n var_5 += 1\n var_11 += var_3[var_10][var_5]\n var_4 = max(var_4, var_11)\n print(var_4)\n\n\nif __name__ == \"__main__\":\n func_1()\n```", "output": "SLOWER 1.7721", "pair_id": "python_p03503_reversed", "problem_id": "p03503", "language": "python", "direction": "reversed", "speedup_ratio": 3.4156} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_6 = 2019\nvar_1 = [0] * var_6\nvar_3 = 1\nvar_5 = var_4 = 0\nfor var_2 in input()[::-1]:\n var_1[var_4] += 1\n var_4 -= int(var_2) * var_3\n var_4 %= var_6\n var_5 += var_1[var_4]\n var_3 *= 10\n var_3 %= var_6\nprint(var_5)\n```\n\n=== Code B (Modified) ===\n```python\nimport numpy as np\n\nvar_7 = input()[::-1]\nvar_6 = len(var_7)\nvar_1 = np.zeros(var_6, dtype=int)\nvar_4 = np.zeros(var_6, dtype=int)\nvar_2 = np.zeros(2019, dtype=int)\nvar_8 = 10\nvar_1[0] = int(var_7[0])\nvar_4[0] = var_1[0]\nvar_2[var_4[0]] += 1\nfor var_5 in range(1, var_6):\n var_1[var_5] = int(var_7[var_5]) * var_8 % 2019\n var_4[var_5] = (var_4[var_5 - 1] + var_1[var_5]) % 2019\n var_2[var_4[var_5]] += 1\n var_8 = var_8 * 10 % 2019\nvar_3 = var_2[np.nonzero(var_2)]\nprint(\n (\n int(\n sum([var_3[var_5] * (var_3[var_5] - 1) for var_5 in range(var_3.shape[0])])\n / 2\n )\n + var_2[0]\n )\n)\n```", "output": "SLOWER 1.5513", "pair_id": "python_p02702_reversed", "problem_id": "p02702", "language": "python", "direction": "reversed", "speedup_ratio": 2.9308} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_4 = int(eval(input()))\nvar_1 = list(map(int, input().split()))\nvar_3 = 1\nfor var_2 in var_1:\n var_3 *= 2 if var_2 % 2 == 0 else 1\nprint((3**var_4 - var_3))\n```\n\n=== Code B (Modified) ===\n```python\nvar_6 = int(eval(input()))\nvar_2 = list(map(int, input().split()))\nfrom itertools import product\n\nvar_5 = [-1, 0, 1]\nvar_3 = 0\nfor var_7 in product(var_5, repeat=var_6):\n var_1 = []\n for var_4 in range(var_6):\n var_1.append(var_7[var_4] + var_2[var_4])\n if any(var_8 % 2 == 0 for var_8 in var_1):\n var_3 += 1\nprint(var_3)\n```", "output": "SLOWER 9.9565", "pair_id": "python_p03568_reversed", "problem_id": "p03568", "language": "python", "direction": "reversed", "speedup_ratio": 993.5967} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = str(var_4)\n if var_5[0] == var_5[4] and var_5[1] == var_5[3]:\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = [0] * (var_2 + 1)\nfor var_3 in range(1, var_2 + 1):\n if str(var_3) == str(var_3)[::-1]:\n var_4[var_3] = var_4[var_3 - 1] + 1\n else:\n var_4[var_3] = var_4[var_3 - 1]\nprint((var_4[var_2] - var_4[var_1 - 1]))\n```", "output": "SLOWER 2.2084", "pair_id": "python_p03416_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 4.6217} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nfrom fractions import Fraction\n\nvar_1, var_2 = input().split()\n\n\nfrom decimal import *\n\nvar_4 = var_3(var_1)\nvar_6 = var_3(var_2)\nvar_7().prec = 28\nvar_5 = var_4 * var_6\nprint((int(var_5)))\n```\n\n=== Code B (Modified) ===\n```python\ndef func_1():\n from sys import setrecursionlimit, stdin\n from os import environ\n from collections import defaultdict, deque, Counter\n from math import ceil, floor, gcd\n from itertools import accumulate, combinations, combinations_with_replacement\n\n setrecursionlimit(10**6)\n var_7 = (\n (lambda *var_11: print(*var_11))\n if \"TERM_PROGRAM\" in environ\n else lambda *var_12: 0\n )\n var_8 = lambda: stdin.readline().rstrip()\n var_3 = lambda: list(map(int, var_8().split()))\n var_1 = lambda: int(var_8())\n var_4 = 10**9 + 7\n var_2 = 10**9 + 10\n var_9, var_10 = var_8().split()\n var_5 = int(var_9)\n var_6 = int(float(var_10) * 100 + 0.5)\n print(var_5 * var_6 // 100)\n\n\nfunc_1()\n```", "output": "SLOWER 1.6242", "pair_id": "python_p02659_reversed", "problem_id": "p02659", "language": "python", "direction": "reversed", "speedup_ratio": 3.0827} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\ndef func_1():\n var_1, var_2 = list(map(int, input().split()))\n var_3 = 0\n for var_4 in range(var_1, var_2 + 1):\n\n if (var_4 % 10) == (var_4 // 10000 % 10) and (var_4 // 10 % 10) == (\n var_4 // 1000 % 10\n ):\n var_3 += 1\n print(var_3)\n\n\nif __name__ == \"__main__\":\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n if list(str(var_4)) == list(reversed(str(var_4))):\n var_3 += 1\nprint(var_3)\n```", "output": "SLOWER 3.0644", "pair_id": "python_p03416_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 8.3652} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_6 = sorted([list(map(int, input().split())) for var_5 in range(var_1)])\n\nvar_4 = [[0] * (var_2 + 1) for var_5 in range(var_1 + 1)]\n\nfor var_5 in range(var_1):\n var_9, var_8 = var_6[var_5]\n for var_7 in range(var_2 + 1):\n if var_7 + var_9 <= var_2:\n var_4[var_5 + 1][var_7 + var_9] = max(\n var_4[var_5 + 1][var_7 + var_9], var_4[var_5][var_7] + var_8\n )\n var_4[var_5 + 1][var_7] = max(var_4[var_5][var_7], var_4[var_5 + 1][var_7])\nvar_3 = 0\nfor var_5, (var_9, var_8) in enumerate(var_6):\n var_3 = max(var_3, var_4[var_5][var_2 - 1] + var_8)\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\nfrom operator import itemgetter\nfrom heapq import heapify, heappop, heappush\n\nvar_1 = int(10e15)\nvar_2 = -var_1\nvar_11 = 1000000007\nsys.setrecursionlimit(1000000)\n\n\ndef func_2():\n return list(map(int, input().split()))\n\n\ndef func_4():\n return input().split()\n\n\ndef func_1():\n return int(sys.stdin.readline())\n\n\ndef func_3():\n return eval(input())\n\n\nvar_3, var_4 = func_2()\nvar_5 = [func_2() for var_9 in range(var_3)]\nvar_5.sort(key=itemgetter(0))\n\nvar_8 = [[0] * (var_4 + 1 + 3000 + 1) for _ in range(var_3 + 1)]\nvar_6 = 0\nfor var_9 in range(var_3):\n for var_10 in range(var_4 + 1 + 3000 + 1):\n var_12, var_7 = var_5[var_9]\n if 0 <= var_10 - var_12 < var_4:\n var_8[var_9 + 1][var_10] = max(\n var_8[var_9][var_10], var_8[var_9][var_10 - var_12] + var_7\n )\n else:\n var_8[var_9 + 1][var_10] = var_8[var_9][var_10]\n var_6 = max(var_6, var_8[var_9 + 1][var_10])\nprint(var_6)\n```", "output": "SLOWER 4.4103", "pair_id": "python_p02863_reversed", "problem_id": "p02863", "language": "python", "direction": "reversed", "speedup_ratio": 21.263} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\ndef func_1():\n var_1, var_3 = input().split()\n var_1 = int(var_1)\n var_3 = int(float(var_3) * 100 + 0.5)\n var_2 = var_1 * var_3\n print((var_2 // 100))\n\n\nif __name__ == \"__main__\":\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\ndef func_1():\n from sys import setrecursionlimit, stdin\n from os import environ\n from collections import defaultdict, deque, Counter\n from math import ceil, floor, gcd\n from itertools import accumulate, combinations, combinations_with_replacement\n\n setrecursionlimit(10**6)\n var_7 = (\n (lambda *var_11: print(*var_11))\n if \"TERM_PROGRAM\" in environ\n else lambda *var_12: 0\n )\n var_8 = lambda: stdin.readline().rstrip()\n var_3 = lambda: list(map(int, var_8().split()))\n var_1 = lambda: int(var_8())\n var_4 = 10**9 + 7\n var_2 = 10**9 + 10\n var_9, var_10 = var_8().split()\n var_5 = int(var_9)\n var_10 = var_10.split(\".\")\n var_6 = int(var_10[0]) * 100\n if len(var_10) == 2:\n var_6 += int(var_10[1])\n print(var_5 * var_6 // 100)\n\n\nfunc_1()\n```", "output": "SLOWER 1.7187", "pair_id": "python_p02659_reversed", "problem_id": "p02659", "language": "python", "direction": "reversed", "speedup_ratio": 3.2915} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n if str(var_4) == \"\".join(reversed(str(var_4))):\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1 = list(map(int, input().split()))\nvar_2 = 0\nfor var_3 in range(var_1[0], var_1[1] + 1):\n var_4 = str(var_3)\n if var_4[0] == var_4[4] and var_4[1] == var_4[3]:\n var_2 += 1\nprint(var_2)\n```", "output": "FASTER 1.365", "pair_id": "python_p03416_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 2.5758} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().strip().split(\" \")))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n if str(var_4) == str(var_4)[::-1]:\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_4, var_3 = list(map(int, input().split()))\nvar_1 = 0\nfor var_2 in range(var_4, var_3 + 1):\n if str(var_2)[0] + str(var_2)[1] == str(var_2)[-1] + str(var_2)[-2]:\n var_1 += 1\nprint(var_1)\n```", "output": "SLOWER 1.0338", "pair_id": "python_p03416_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 2.0474} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_4, var_3 = list(map(int, input().split()))\nvar_1 = 0\nfor var_2 in range(var_4, var_3 + 1):\n if str(var_2)[0] + str(var_2)[1] == str(var_2)[-1] + str(var_2)[-2]:\n var_1 += 1\nprint(var_1)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_3 = list(map(int, input().split()))\nvar_2 = 0\nfor var_5 in range(var_3 + 1)[var_1:]:\n if len(str(var_5)) % 2 == 0:\n var_6 = list(str(var_5))[: len(str(var_5)) // 2]\n var_7 = list(reversed(list(str(var_5))[len(str(var_5)) // 2 :]))\n if var_6 == var_7:\n var_2 += 1\n else:\n var_8 = list(str(var_5))[: len(str(var_5)) // 2 + 1]\n var_4 = list(reversed(list(str(var_5))[len(str(var_5)) // 2 :]))\n if var_8 == var_4:\n var_2 += 1\nprint(var_2)\n```", "output": "SLOWER 1.1334", "pair_id": "python_p03416_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 2.1938} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\nfrom collections import deque\n\nvar_13 = sys.stdin.readline\nvar_2 = int(eval(var_13()))\nvar_5 = [[] for _ in range(var_2)]\nvar_3 = [-1] * var_2\nfor var_12 in range(var_2 - 1):\n var_6, var_8 = list(map(int, var_13().split()))\n var_5[var_6 - 1].append((var_12, var_8 - 1))\n\n\nvar_4 = deque([(0, -1)])\nvar_1 = [-1] * (var_2 - 1)\nvar_11 = 0\nwhile var_4:\n var_14, var_10 = var_4.pop()\n var_9 = 1\n for var_12, var_15 in var_5[var_14]:\n if var_9 == var_10:\n var_9 += 1\n var_1[var_12] = var_9\n var_4.appendleft((var_15, var_9))\n var_9 += 1\n var_11 = max(var_11, var_9 - 1)\nprint(var_11)\nfor var_7 in var_1:\n print(var_7)\n```\n\n=== Code B (Modified) ===\n```python\nvar_11 = int(eval(input()))\nvar_12 = {var_8: [] for var_8 in range(1, var_11 + 1)}\nvar_19 = [False for var_8 in range(var_11 + 1)]\nvar_16 = []\nfor _ in range(var_11 - 1):\n var_2, var_3 = list(map(int, input().split()))\n var_12[var_2].append(var_3)\n var_12[var_3].append(var_2)\n var_16.append((var_2, var_3))\nvar_9 = var_16[0][0]\nvar_19[var_9] = True\nvar_6 = []\nvar_7 = []\nvar_14 = {var_8: {} for var_8 in range(1, var_11 + 1)}\nvar_10 = [0 for var_8 in range(var_11 + 1)]\n\nvar_4 = 1\nfor var_5 in var_12[var_9]:\n var_19[var_5] = True\n var_14[var_9][var_5] = var_4\n var_14[var_5][var_9] = var_4\n var_10[var_5] = var_4\n var_4 += 1\n var_6.append(var_5)\nwhile var_6:\n for var_15 in var_6:\n var_13 = 1\n for var_5 in var_12[var_15]:\n if var_19[var_5] == False:\n var_19[var_5] = True\n if var_13 != var_10[var_15]:\n var_14[var_15][var_5] = var_13\n var_14[var_5][var_15] = var_13\n var_10[var_5] = var_13\n var_13 += 1\n var_7.append(var_5)\n else:\n var_13 += 1\n var_14[var_15][var_5] = var_13\n var_14[var_5][var_15] = var_13\n var_10[var_5] = var_13\n var_13 += 1\n var_7.append(var_5)\n if var_7:\n var_6 = var_7\n var_7 = []\n else:\n var_6 = []\n var_7 = []\nvar_1 = 0\nfor var_8 in range(1, var_11 + 1):\n var_1 = max(var_1, len(var_12[var_8]))\nprint(var_1)\nfor var_8 in range(var_11 - 1):\n var_17, var_18 = var_16[var_8][0], var_16[var_8][1]\n print((var_14[var_17][var_18]))\n```", "output": "SLOWER 1.0676", "pair_id": "python_p02850_reversed", "problem_id": "p02850", "language": "python", "direction": "reversed", "speedup_ratio": 2.0959} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_4 = {}\nvar_5 = 0\nfor var_6 in range(10000, 100000):\n var_3 = list(str(var_6))\n if var_3 == list(reversed(var_3)):\n var_5 += 1\n var_4[var_6] = var_5\nvar_1, var_2 = list(map(int, input().split()))\nprint((var_4[var_2] - var_4[var_1 - 1] if var_1 > 10000 else var_4[var_2]))\n```\n\n=== Code B (Modified) ===\n```python\ndef func_1():\n var_1, var_2 = list(map(int, input().rstrip().split()))\n var_3 = 0\n for var_4 in range(var_1, var_2 + 1):\n var_5 = str(var_4)\n if var_5 == var_5[::-1]:\n var_3 += 1\n print(var_3)\n\n\nif __name__ == \"__main__\":\n func_1()\n```", "output": "FASTER 4.3196", "pair_id": "python_p03416_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 19.9676} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_7 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_3 = True\n var_8 = str(var_4)\n var_6 = len(var_8)\n for var_5 in range(var_6 // 2 + 1):\n if var_8[var_5] != var_8[-var_5 - 1]:\n var_3 = False\n break\n if var_3:\n var_7 += 1\nprint(var_7)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = [\n var_3 for var_3 in map(str, list(range(var_1, var_2 + 1))) if var_3 == var_3[::-1]\n]\nprint((len(var_4)))\n```", "output": "FASTER 1.8237", "pair_id": "python_p03416_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 3.5398} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_6 in range(var_1, var_2 + 1):\n var_3 = str(var_6)\n var_5 = True\n for var_7 in range(len(var_3) // 2):\n if var_3[var_7] != var_3[-var_7 - 1] and var_5:\n var_5 = not var_5\n if var_5:\n var_4 += 1\nprint(var_4)\n```\n\n=== Code B (Modified) ===\n```python\ndef func_1():\n var_1, var_2 = list(map(int, input().rstrip().split()))\n var_3 = 0\n for var_4 in range(var_1, var_2 + 1):\n var_5 = str(var_4)\n if var_5 == var_5[::-1]:\n var_3 += 1\n print(var_3)\n\n\nif __name__ == \"__main__\":\n func_1()\n```", "output": "FASTER 2.2059", "pair_id": "python_p03416_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 4.6137} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().rstrip().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = list(map(int, list(str(var_4))))\n if var_5[0] == var_5[4] and var_5[1] == var_5[3]:\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_5 in range(var_1, var_2 + 1):\n var_3 = str(var_5)\n if var_3[0] == var_3[-1] and var_3[1] == var_3[-2]:\n var_4 += 1\nprint(var_4)\n```", "output": "FASTER 1.7746", "pair_id": "python_p03416_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 3.4214} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\n\nsys.setrecursionlimit(2147483647)\nvar_2 = float(\"inf\")\nvar_3 = 10**9 + 7\nvar_10 = lambda: sys.stdin.readline().rstrip()\n\n\ndef func_1():\n var_11, var_4 = list(map(int, var_10().split()))\n var_1 = [tuple(map(int, var_10().split())) for _ in range(var_11)]\n var_1.sort()\n var_8 = [0] * var_4\n var_6 = -var_2\n for var_9 in range(var_11):\n var_5, var_7 = var_1[var_9]\n var_12 = var_8[:]\n for var_13 in range(var_4):\n if var_13 + var_5 < var_4:\n var_12[var_13 + var_5] = max(\n var_12[var_13 + var_5], var_8[var_13] + var_7\n )\n else:\n var_6 = max(var_6, var_8[var_13] + var_7)\n var_8 = var_12\n print((max(var_6, max(var_8))))\n\n\nfunc_1()\n```\n\n=== Code B (Modified) ===\n```python\nfrom collections import Counter, defaultdict, deque\nfrom heapq import heappop, heappush, heapify\nimport sys, bisect, math, itertools, fractions, pprint\n\nsys.setrecursionlimit(10**8)\nvar_6 = 10**9 + 7\nvar_1 = float(\"inf\")\n\n\ndef func_1():\n return int(sys.stdin.readline())\n\n\ndef func_2():\n return list(map(int, sys.stdin.readline().split()))\n\n\nvar_7, var_9 = func_2()\nvar_13 = [func_2() for _ in range(var_7)]\nvar_13.sort(key=lambda var_14: var_14[1], reverse=True)\nvar_8 = 0\nvar_10 = min(var_7, 5)\nfor var_3 in range(var_10):\n var_2 = [[0] * (var_9 + 5) for _ in range(var_7 + 5)]\n for var_4 in range(var_7):\n var_12, var_11 = var_13[var_4]\n for var_5 in range(var_9):\n if var_5 < var_12 or var_3 == var_4:\n var_2[var_4 + 1][var_5] = var_2[var_4][var_5]\n else:\n var_2[var_4 + 1][var_5] = max(\n var_2[var_4][var_5], var_2[var_4][var_5 - var_12] + var_11\n )\n\n var_8 = max(var_2[var_7][var_9 - 1] + var_13[var_3][1], var_8)\nprint(var_8)\n```", "output": "SLOWER 2.6786", "pair_id": "python_p02863_reversed", "problem_id": "p02863", "language": "python", "direction": "reversed", "speedup_ratio": 6.4023} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\n\nvar_10 = sys.stdin.readline\nvar_2, var_3 = list(map(int, var_10().split()))\nvar_1 = [list(map(int, var_10().split())) for _ in range(var_2)]\nvar_8 = [[0 for _ in range(var_2 + 1)] for _ in range(var_3 + 1)]\n\nvar_13 = [[0 for _ in range(var_2 + 1)] for _ in range(var_3 + 1)]\nfor var_11 in range(var_2):\n var_4, var_6 = var_1[var_11]\n for var_15 in range(var_3):\n if var_4 > var_15:\n var_8[var_15][var_11 + 1] = var_8[var_15][var_11]\n var_13[var_15][var_11 + 1] = var_15\n else:\n if var_6 + var_8[var_15 - var_4][var_11] >= var_8[var_15][var_11]:\n var_8[var_15][var_11 + 1] = var_8[var_15 - var_4][var_11] + var_6\n var_13[var_15][var_11 + 1] = var_15 - var_4\n else:\n var_8[var_15][var_11 + 1] = var_8[var_15][var_11]\n var_13[var_15][var_11 + 1] = var_15\nvar_5 = var_8[var_3 - 1][var_2]\nvar_14 = [False] * var_2\nvar_7 = var_3 - 1\nfor var_9 in reversed(list(range(var_2))):\n if var_13[var_7][var_9 + 1] == var_7 - var_1[var_9][0]:\n var_14[var_9] = True\n var_7 = var_13[var_7][var_9 + 1]\nvar_12 = 0\nfor var_9 in range(var_2):\n if not var_14[var_9] and var_1[var_9][1] > var_12:\n var_12 = var_1[var_9][1]\nprint((var_5 + var_12))\n```\n\n=== Code B (Modified) ===\n```python\nvar_6, var_7 = list(map(int, input().split()))\nvar_1 = [list(map(int, input().split())) for _ in range(var_6)]\nvar_1.sort()\nvar_3 = [(6007) * [0] for _ in range(var_6 + 1)]\nvar_3[0][0] = 0\nvar_2 = 0\nfor var_4 in range(var_6):\n for var_5 in range(6007):\n var_3[var_4 + 1][var_5] = max(var_3[var_4 + 1][var_5], var_3[var_4][var_5])\n if var_5 < var_7:\n var_3[var_4 + 1][var_5 + var_1[var_4][0]] = max(\n var_3[var_4][var_5] + var_1[var_4][1],\n var_3[var_4][var_5 + var_1[var_4][0]],\n )\n var_2 = max(var_2, var_3[var_4 + 1][var_5])\nprint(var_2)\n```", "output": "SLOWER 5.2357", "pair_id": "python_p02863_reversed", "problem_id": "p02863", "language": "python", "direction": "reversed", "speedup_ratio": 37.6794} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nfrom collections import Counter, defaultdict, deque\nfrom heapq import heappop, heappush, heapify\nimport sys, bisect, math, itertools, fractions, pprint\n\nsys.setrecursionlimit(10**8)\nvar_6 = 10**9 + 7\nvar_1 = float(\"inf\")\n\n\ndef func_1():\n return int(sys.stdin.readline())\n\n\ndef func_2():\n return list(map(int, sys.stdin.readline().split()))\n\n\nvar_7, var_9 = func_2()\nvar_13 = [func_2() for _ in range(var_7)]\nvar_13.sort(key=lambda var_14: var_14[1], reverse=True)\nvar_8 = 0\nvar_10 = min(var_7, 5)\nfor var_3 in range(var_10):\n var_2 = [[0] * (var_9 + 5) for _ in range(var_7 + 5)]\n for var_4 in range(var_7):\n var_12, var_11 = var_13[var_4]\n for var_5 in range(var_9):\n if var_5 < var_12 or var_3 == var_4:\n var_2[var_4 + 1][var_5] = var_2[var_4][var_5]\n else:\n var_2[var_4 + 1][var_5] = max(\n var_2[var_4][var_5], var_2[var_4][var_5 - var_12] + var_11\n )\n\n var_8 = max(var_2[var_7][var_9 - 1] + var_13[var_3][1], var_8)\nprint(var_8)\n```\n\n=== Code B (Modified) ===\n```python\ndef func_1():\n var_2, var_3, *var_1 = list(map(int, open(0).read().split()))\n var_4 = [0] * (var_3 + max(var_1[::2]))\n for var_7, var_6 in sorted(zip(*[iter(var_1)] * 2)):\n for var_5 in reversed(list(range(var_3))):\n var_4[var_5 + var_7] = max(var_4[var_5 + var_7], var_4[var_5] + var_6)\n print((max(var_4)))\n\n\nfunc_1()\n```", "output": "FASTER 2.938", "pair_id": "python_p02863_forward", "problem_id": "p02863", "language": "python", "direction": "forward", "speedup_ratio": 7.6633} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\ndef func_1():\n from sys import setrecursionlimit, stdin\n from os import environ\n from collections import defaultdict, deque, Counter\n from math import ceil, floor, gcd\n from itertools import accumulate, combinations, combinations_with_replacement\n\n setrecursionlimit(10**6)\n var_7 = (\n (lambda *var_11: print(*var_11))\n if \"TERM_PROGRAM\" in environ\n else lambda *var_12: 0\n )\n var_8 = lambda: stdin.readline().rstrip()\n var_3 = lambda: list(map(int, var_8().split()))\n var_1 = lambda: int(var_8())\n var_4 = 10**9 + 7\n var_2 = 10**9 + 10\n var_9, var_10 = var_8().split()\n var_5 = int(var_9)\n var_6 = int(float(var_10) * 100 + 0.5)\n print(var_5 * var_6 // 100)\n\n\nfunc_1()\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\n\nvar_3 = sys.stdin.readline\nvar_1, var_2 = var_3().split()\nvar_1 = int(var_1)\nvar_2 = int(float(var_2) * 100 + 0.5)\nprint((var_1 * var_2 // 100))\n```", "output": "FASTER 2.0133", "pair_id": "python_p02659_forward", "problem_id": "p02659", "language": "python", "direction": "forward", "speedup_ratio": 4.0371} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_6, var_7 = list(map(int, input().split()))\nvar_1 = [list(map(int, input().split())) for _ in range(var_6)]\nvar_1.sort()\nvar_3 = [(6007) * [0] for _ in range(var_6 + 1)]\nvar_3[0][0] = 0\nvar_2 = 0\nfor var_4 in range(var_6):\n for var_5 in range(6007):\n var_3[var_4 + 1][var_5] = max(var_3[var_4 + 1][var_5], var_3[var_4][var_5])\n if var_5 < var_7:\n var_3[var_4 + 1][var_5 + var_1[var_4][0]] = max(\n var_3[var_4][var_5] + var_1[var_4][1],\n var_3[var_4][var_5 + var_1[var_4][0]],\n )\n var_2 = max(var_2, var_3[var_4 + 1][var_5])\nprint(var_2)\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\n\nvar_10 = sys.stdin.readline\nvar_2, var_3 = list(map(int, var_10().split()))\nvar_1 = [list(map(int, var_10().split())) for _ in range(var_2)]\nvar_8 = [[0 for _ in range(var_2 + 1)] for _ in range(var_3 + 1)]\n\nvar_13 = [[0 for _ in range(var_2 + 1)] for _ in range(var_3 + 1)]\nfor var_11 in range(var_2):\n var_4, var_6 = var_1[var_11]\n for var_15 in range(var_3):\n if var_4 > var_15:\n var_8[var_15][var_11 + 1] = var_8[var_15][var_11]\n var_13[var_15][var_11 + 1] = var_15\n else:\n if var_6 + var_8[var_15 - var_4][var_11] >= var_8[var_15][var_11]:\n var_8[var_15][var_11 + 1] = var_8[var_15 - var_4][var_11] + var_6\n var_13[var_15][var_11 + 1] = var_15 - var_4\n else:\n var_8[var_15][var_11 + 1] = var_8[var_15][var_11]\n var_13[var_15][var_11 + 1] = var_15\nvar_5 = var_8[var_3 - 1][var_2]\nvar_14 = [False] * var_2\nvar_7 = var_3 - 1\nfor var_9 in reversed(list(range(var_2))):\n if var_13[var_7][var_9 + 1] == var_7 - var_1[var_9][0]:\n var_14[var_9] = True\n var_7 = var_13[var_7][var_9 + 1]\nvar_12 = 0\nfor var_9 in range(var_2):\n if not var_14[var_9] and var_1[var_9][1] > var_12:\n var_12 = var_1[var_9][1]\nprint((var_5 + var_12))\n```", "output": "FASTER 5.2357", "pair_id": "python_p02863_forward", "problem_id": "p02863", "language": "python", "direction": "forward", "speedup_ratio": 37.6794} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\nfrom collections import Counter\n\n\ndef func_9():\n return sys.stdin.readline().strip()\n\n\ndef func_10(var_8, var_9, var_10):\n return [[var_10] * var_9 for var_13 in range(var_8)]\n\n\ndef func_11(var_8, var_9, var_10, var_11):\n return [[[var_11] * var_10 for var_14 in range(var_9)] for var_13 in range(var_8)]\n\n\ndef func_12(var_8, var_9, var_10, var_11, var_12):\n return [\n [[[var_12] * var_11 for var_14 in range(var_10)] for var_14 in range(var_9)]\n for var_13 in range(var_8)\n ]\n\n\ndef func_8(var_16, var_17=1):\n return int(-(-var_16 // var_17))\n\n\ndef func_1():\n return int(eval(func_9()))\n\n\ndef func_3():\n return list(map(int, func_9().split()))\n\n\ndef func_2(var_7=None):\n return list(func_3()) if var_7 is None else [func_1() for var_13 in range(var_7)]\n\n\ndef func_7():\n print(\"Yes\")\n\n\ndef func_5():\n print(\"No\")\n\n\ndef func_6():\n print(\"YES\")\n\n\ndef func_4():\n print(\"NO\")\n\n\nsys.setrecursionlimit(10**9)\nvar_3 = 10**18\nvar_6 = 10**9 + 7\nvar_7, var_5, var_4 = func_3()\nvar_1 = func_2()\nvar_2 = func_2()\nvar_15 = min(var_1) + min(var_2)\nfor _ in range(var_4):\n var_16, var_17, var_10 = func_3()\n var_16 -= 1\n var_17 -= 1\n var_15 = min(var_15, var_1[var_16] + var_2[var_17] - var_10)\nprint(var_15)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2, var_3 = list(map(int, input().split()))\nvar_4 = list(map(int, input().split()))\nvar_6 = list(map(int, input().split()))\nvar_5 = min(var_4) + min(var_6)\nfor var_7 in range(var_3):\n var_9, var_10, var_11 = list(map(int, input().split()))\n var_8 = var_4[var_9 - 1] + var_6[var_10 - 1] - var_11\n var_5 = var_8 if var_8 < var_5 else var_5\nprint(var_5)\n```", "output": "FASTER 1.8148", "pair_id": "python_p02748_forward", "problem_id": "p02748", "language": "python", "direction": "forward", "speedup_ratio": 3.5181} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\n\nvar_8 = sys.stdin.readline\n\n\ndef func_1():\n var_2 = int(eval(var_8()))\n var_1 = [int(var_8().replace(\" \", \"\"), 2) for _ in range(var_2)]\n var_3 = [list(map(int, var_8().split())) for _ in range(var_2)]\n var_4 = -(10**7) * var_2\n for var_7 in range(1, 1 << 10):\n var_10 = 0\n for var_9, var_6 in enumerate(var_1):\n var_5 = bin(var_7 & var_6).count(\"1\")\n var_10 += var_3[var_9][var_5]\n var_4 = max(var_4, var_10)\n print(var_4)\n\n\nif __name__ == \"__main__\":\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\nimport numpy as np\n\nvar_6 = int(eval(input()))\n\nvar_1 = [input().replace(\" \", \"\") for var_4 in range(var_6)]\n\nvar_7 = [list(map(int, input().split())) for var_4 in range(var_6)]\nvar_11 = -999999999999999\nfor var_4 in range(1, 1024):\n var_3 = format(var_4, \"010b\")\n var_9 = 0\n for var_2, var_8 in zip(var_1, var_7):\n var_10 = 0\n for var_5 in range(10):\n if var_2[var_5] == \"1\" and var_3[var_5] == \"1\":\n var_10 += 1\n var_9 += var_8[var_10]\n if var_9 > var_11:\n if var_9 == 0:\n print((str(var_4)))\n break\n var_11 = var_9\nprint(var_11)\n```", "output": "SLOWER 2.2365", "pair_id": "python_p03503_reversed", "problem_id": "p03503", "language": "python", "direction": "reversed", "speedup_ratio": 4.7126} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\ndef func_1():\n from sys import setrecursionlimit, stdin\n from os import environ\n from collections import defaultdict, deque, Counter\n from math import ceil, floor, gcd\n from itertools import accumulate, combinations, combinations_with_replacement\n\n setrecursionlimit(10**6)\n var_7 = (\n (lambda *var_11: print(*var_11))\n if \"TERM_PROGRAM\" in environ\n else lambda *var_12: 0\n )\n var_8 = lambda: stdin.readline().rstrip()\n var_3 = lambda: list(map(int, var_8().split()))\n var_1 = lambda: int(var_8())\n var_4 = 10**9 + 7\n var_2 = 10**9 + 10\n var_9, var_10 = var_8().split()\n var_5 = int(var_9)\n var_6 = int(float(var_10) * 100 + 0.5)\n print(var_5 * var_6 // 100)\n\n\nfunc_1()\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = input().split()\nprint((int(var_1) * int(var_2[:-3] + var_2[-2:]) // 100))\n```", "output": "FASTER 2.4305", "pair_id": "python_p02659_forward", "problem_id": "p02659", "language": "python", "direction": "forward", "speedup_ratio": 5.3907} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport math\nimport string\n\n\ndef func_4():\n return list(map(int, input().split()))\n\n\ndef func_3(var_6, var_7):\n return math.factorial(var_6) // (\n math.factorial(var_6 - var_7) * math.factorial(var_7)\n )\n\n\ndef func_2(var_9):\n var_8 = []\n for var_5 in var_9:\n if not (var_5 in var_8):\n var_8.append(var_5)\n return len(var_9) != len(var_8)\n\n\ndef func_1(var_6):\n func_1 = []\n for var_4 in range(1, var_6 + 1):\n if var_6 % var_4 == 0:\n func_1.append(var_4)\n return func_1\n\n\nvar_2 = [-1, -1, -1, 0, 0, 1, 1, 1]\nvar_3 = [-1, 0, 1, -1, 1, -1, 0, 1]\nvar_6 = int(eval(input()))\nvar_1 = func_4()\nvar_10 = 1\nfor var_4 in range(len(var_1)):\n if var_1[var_4] % 2 == 0:\n var_10 *= 2\n else:\n var_10 *= 1\nprint((3 ** len(var_1) - var_10))\n```\n\n=== Code B (Modified) ===\n```python\ndef func_1():\n var_2 = int(eval(input()))\n var_1 = [int(var_6) for var_6 in input().split()]\n var_4 = 3**var_2\n var_5 = len([var_3 for var_3 in var_1 if var_3 % 2 == 0])\n var_4 -= 2**var_5\n print(var_4)\n\n\nif __name__ == \"__main__\":\n func_1()\n```", "output": "FASTER 1.1807", "pair_id": "python_p03568_forward", "problem_id": "p03568", "language": "python", "direction": "forward", "speedup_ratio": 2.2669} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_6 = 2019\nvar_1 = [0] * var_6\nvar_3 = 1\nvar_5 = var_4 = 0\nfor var_2 in input()[::-1]:\n var_1[var_4] += 1\n var_4 -= int(var_2) * var_3\n var_4 %= var_6\n var_5 += var_1[var_4]\n var_3 *= 10\n var_3 %= var_6\nprint(var_5)\n```\n\n=== Code B (Modified) ===\n```python\nvar_6 = input()[::-1]\nvar_4 = len(var_6)\nvar_2 = [0] * 2019\nvar_2[0] = 1\nvar_7 = 1\nvar_5 = 0\nvar_1 = 0\nfor var_3 in range(var_4):\n var_5 = (var_5 + int(var_6[var_3]) * var_7) % 2019\n var_7 = var_7 * 10 % 2019\n var_2[var_5] += 1\nfor var_3 in var_2:\n var_1 += var_3 * (var_3 - 1) // 2\nprint(var_1)\n```", "output": "SLOWER 2.8807", "pair_id": "python_p02702_reversed", "problem_id": "p02702", "language": "python", "direction": "reversed", "speedup_ratio": 7.3649} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_6 = input()[::-1]\nvar_4 = len(var_6)\nvar_2 = [0] * 2019\nvar_2[0] = 1\nvar_7 = 1\nvar_5 = 0\nvar_1 = 0\nfor var_3 in range(var_4):\n var_5 = (var_5 + int(var_6[var_3]) * var_7) % 2019\n var_7 = var_7 * 10 % 2019\n var_2[var_5] += 1\nfor var_3 in var_2:\n var_1 += var_3 * (var_3 - 1) // 2\nprint(var_1)\n```\n\n=== Code B (Modified) ===\n```python\nimport numpy as np\n\nvar_7 = input()[::-1]\nvar_6 = len(var_7)\nvar_1 = np.zeros(var_6, dtype=int)\nvar_4 = np.zeros(var_6, dtype=int)\nvar_2 = np.zeros(2019, dtype=int)\nvar_8 = 10\nvar_1[0] = int(var_7[0])\nvar_4[0] = var_1[0]\nvar_2[var_4[0]] += 1\nfor var_5 in range(1, var_6):\n var_1[var_5] = int(var_7[var_5]) * var_8 % 2019\n var_4[var_5] = (var_4[var_5 - 1] + var_1[var_5]) % 2019\n var_2[var_4[var_5]] += 1\n var_8 = var_8 * 10 % 2019\nvar_3 = var_2[np.nonzero(var_2)]\nprint(\n (\n int(\n sum([var_3[var_5] * (var_3[var_5] - 1) for var_5 in range(var_3.shape[0])])\n / 2\n )\n + var_2[0]\n )\n)\n```", "output": "FASTER 1.3294", "pair_id": "python_p02702_forward", "problem_id": "p02702", "language": "python", "direction": "forward", "speedup_ratio": 2.5129} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\ndef func_1(var_1):\n var_2 = 0\n var_4 = 1\n for var_3 in range(1_000_001):\n var_2 += 7 * var_4\n var_2 %= var_1\n if var_2 == 0:\n return var_3 + 1\n var_4 *= 10\n var_4 %= var_1\n else:\n return -1\n\n\nprint((func_1(int(eval(input())))))\n```\n\n=== Code B (Modified) ===\n```python\nvar_1 = int(eval(input()))\nvar_3 = 0\nfor var_2 in range(1000001):\n var_3 += 7 * pow(10, var_2, var_1)\n var_3 %= var_1\n if var_3 == 0:\n print((var_2 + 1))\n break\nelse:\n print((-1))\n```", "output": "SLOWER 2.9835", "pair_id": "python_p02596_reversed", "problem_id": "p02596", "language": "python", "direction": "reversed", "speedup_ratio": 7.9088} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\n\n\ndef func_6():\n return sys.stdin.readline()[:-1]\n\n\ndef func_2():\n return int(eval(func_6()))\n\n\ndef func_3():\n return list(map(int, func_6().split()))\n\n\ndef func_1():\n return list(func_3())\n\n\nvar_10, var_11 = func_3()\nvar_5 = [0] + func_1()\nvar_3 = [func_1() + [var_6] for var_6 in range(var_11)]\nvar_3.sort(key=lambda var_15: var_15[1])\nvar_4 = [0] * (var_11)\nvar_9 = [0 for var_6 in range(var_10 + 1)]\nvar_2 = 2\nwhile var_2 <= var_10:\n var_2 *= 2\nvar_1 = [0] * (var_2 + 1)\n\n\ndef func_4(var_6, var_15):\n while var_6 <= var_2:\n var_1[var_6] += var_15\n var_6 += var_6 & -var_6\n\n\ndef func_5(var_6):\n var_13 = 0\n while var_6:\n var_13 += var_1[var_6]\n var_6 -= var_6 & -var_6\n return var_13\n\n\ndef func_7(var_8, var_12):\n return func_5(var_12) - func_5(var_8 - 1)\n\n\nvar_7 = 1\nfor var_8, var_12, var_6 in var_3:\n while var_7 <= var_12:\n var_14 = var_5[var_7]\n if var_9[var_14]:\n func_4(var_9[var_14], -1)\n func_4(var_7, 1)\n var_9[var_14] = var_7\n var_7 += 1\n var_4[var_6] = func_7(var_8, var_12)\nfor var_6 in var_4:\n print(var_6)\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\n\nvar_20 = sys.stdin.read\nvar_21 = sys.stdin.readline\nvar_22 = sys.stdin.readlines\nsys.setrecursionlimit(10**9)\nvar_2 = 1 << 60\nvar_5 = 1000000007\n\n\nvar_4 = 1000001\n\n\nclass Class_1:\n def __init__(self, var_13, var_19, var_12):\n self.l = var_13\n self.r = var_19\n self.idx = var_12\n\n\ndef func_4(var_12, var_24, var_10, var_15):\n while var_12 <= var_15:\n var_10[var_12] += var_24\n var_12 += var_12 & -var_12\n\n\ndef func_3(var_12, var_10, var_15):\n var_23 = 0\n while var_12:\n var_23 += var_10[var_12]\n var_12 -= var_12 & -var_12\n return var_23\n\n\ndef func_1(var_9, var_15, var_17, var_16):\n\n var_10 = [0] * (var_15 + 1)\n\n var_14 = [-1] * var_4\n\n var_8 = [0] * var_16\n var_18 = 0\n for var_11 in range(var_15):\n\n if var_14[var_9[var_11]] != -1:\n func_4(var_14[var_9[var_11]] + 1, -1, var_10, var_15)\n\n var_14[var_9[var_11]] = var_11\n func_4(var_11 + 1, 1, var_10, var_15)\n\n while var_18 < var_16 and var_17[var_18].r == var_11:\n var_8[var_17[var_18].idx] = func_3(\n var_17[var_18].r + 1, var_10, var_15\n ) - func_3(var_17[var_18].l, var_10, var_15)\n var_18 += 1\n\n for var_11 in range(var_16):\n print((var_8[var_11]))\n\n\ndef func_2():\n var_6, var_7 = list(map(int, var_21().split()))\n var_1 = list(map(int, var_21().split()))\n (*var_3,) = list(map(int, var_20().split()))\n var_17 = [0] * var_7\n for var_11, (var_13, var_19) in enumerate(zip(*[iter(var_3)] * 2)):\n var_17[var_11] = Class_1(var_13 - 1, var_19 - 1, var_11)\n var_17.sort(key=lambda var_25: var_25.r)\n func_1(var_1, var_6, var_17, var_7)\n return\n\n\nif __name__ == \"__main__\":\n func_2()\n```", "output": "SLOWER 2.4053", "pair_id": "python_p02599_reversed", "problem_id": "p02599", "language": "python", "direction": "reversed", "speedup_ratio": 5.2974} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nfrom collections import Counter, defaultdict, deque\nfrom heapq import heappop, heappush, heapify\nimport sys, bisect, math, itertools, fractions, pprint\n\nsys.setrecursionlimit(10**8)\nvar_6 = 10**9 + 7\nvar_1 = float(\"inf\")\n\n\ndef func_1():\n return int(sys.stdin.readline())\n\n\ndef func_2():\n return list(map(int, sys.stdin.readline().split()))\n\n\nvar_7, var_9 = func_2()\nvar_13 = [func_2() for _ in range(var_7)]\nvar_13.sort(key=lambda var_14: var_14[1], reverse=True)\nvar_8 = 0\nvar_10 = min(var_7, 5)\nfor var_3 in range(var_10):\n var_2 = [[0] * (var_9 + 5) for _ in range(var_7 + 5)]\n for var_4 in range(var_7):\n var_12, var_11 = var_13[var_4]\n for var_5 in range(var_9):\n if var_5 < var_12 or var_3 == var_4:\n var_2[var_4 + 1][var_5] = var_2[var_4][var_5]\n else:\n var_2[var_4 + 1][var_5] = max(\n var_2[var_4][var_5], var_2[var_4][var_5 - var_12] + var_11\n )\n\n var_8 = max(var_2[var_7][var_9 - 1] + var_13[var_3][1], var_8)\nprint(var_8)\n```\n\n=== Code B (Modified) ===\n```python\nfrom sys import stdin\n\n\ndef func_1():\n\n var_9 = stdin.readline\n var_8, var_10 = list(map(int, var_9().split()))\n var_7 = [list(map(int, var_9().split())) for _ in range(var_8)]\n var_7.sort()\n var_1 = [0] * var_8\n var_2 = [0] * var_8\n for var_4 in range(var_8):\n var_1[var_4], var_2[var_4] = var_7[var_4][0], var_7[var_4][1]\n\n var_5 = -(10**9)\n var_3 = [[var_5] * (var_10 + 1) for _ in range(var_8 + 1)]\n var_3[0][0] = 0\n for var_4 in range(var_8):\n for var_6 in range(var_10 + 1):\n\n if var_6 != var_10:\n var_3[var_4 + 1][min(var_10, var_6 + var_1[var_4])] = max(\n var_3[var_4 + 1][min(var_10, var_6 + var_1[var_4])],\n var_3[var_4][var_6] + var_2[var_4],\n )\n\n var_3[var_4 + 1][var_6] = max(var_3[var_4 + 1][var_6], var_3[var_4][var_6])\n print((max(var_3[var_8])))\n\n\nif __name__ == \"__main__\":\n func_1()\n```", "output": "FASTER 1.7415", "pair_id": "python_p02863_forward", "problem_id": "p02863", "language": "python", "direction": "forward", "speedup_ratio": 3.3438} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nfrom sys import stdin\n\n\ndef func_1():\n\n var_9 = stdin.readline\n var_8, var_10 = list(map(int, var_9().split()))\n var_7 = [list(map(int, var_9().split())) for _ in range(var_8)]\n var_7.sort()\n var_1 = [0] * var_8\n var_2 = [0] * var_8\n for var_4 in range(var_8):\n var_1[var_4], var_2[var_4] = var_7[var_4][0], var_7[var_4][1]\n\n var_5 = -float(\"inf\")\n var_3 = [[var_5] * (var_10 + 1) for _ in range(var_8 + 1)]\n var_3[0][0] = 0\n for var_4 in range(var_8):\n for var_6 in range(var_10 + 1):\n\n if var_6 != var_10:\n var_3[var_4 + 1][min(var_10, var_6 + var_1[var_4])] = max(\n var_3[var_4 + 1][min(var_10, var_6 + var_1[var_4])],\n var_3[var_4][var_6] + var_2[var_4],\n )\n\n var_3[var_4 + 1][var_6] = max(var_3[var_4 + 1][var_6], var_3[var_4][var_6])\n print((max(var_3[var_8])))\n\n\nif __name__ == \"__main__\":\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\ndef func_1():\n var_2, var_3, *var_1 = list(map(int, open(0).read().split()))\n var_4 = [0] * (var_3 + max(var_1[::2]))\n for var_7, var_6 in sorted(zip(*[iter(var_1)] * 2)):\n for var_5 in reversed(list(range(var_3))):\n var_4[var_5 + var_7] = max(var_4[var_5 + var_7], var_4[var_5] + var_6)\n print((max(var_4)))\n\n\nfunc_1()\n```", "output": "FASTER 1.2195", "pair_id": "python_p02863_forward", "problem_id": "p02863", "language": "python", "direction": "forward", "speedup_ratio": 2.3287} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\ndef func_1():\n var_1, var_2 = list(map(int, input().split()))\n var_3 = 0\n for var_4 in range(var_1, var_2 + 1):\n\n if (var_4 % 10) == (var_4 // 10000 % 10) and (var_4 // 10 % 10) == (\n var_4 // 1000 % 10\n ):\n var_3 += 1\n print(var_3)\n\n\nif __name__ == \"__main__\":\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nvar_4, var_3 = list(map(int, input().split()))\nvar_1 = 0\nfor var_2 in range(var_4, var_3 + 1):\n if str(var_2)[0] + str(var_2)[1] == str(var_2)[-1] + str(var_2)[-2]:\n var_1 += 1\nprint(var_1)\n```", "output": "SLOWER 3.0051", "pair_id": "python_p03416_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 8.0286} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_2 = var_2 / 0.1\nvar_3 = [var_4 + var_2 for var_4 in range(10)]\nfor var_4 in var_3:\n if int(var_4 * 0.08) == var_1:\n print((int(var_4)))\n exit()\nprint(\"-1\")\n```\n\n=== Code B (Modified) ===\n```python\nfrom math import floor\n\nvar_1, var_2 = list(map(int, input().split()))\n\n\nfor var_3 in range(1010):\n if (floor(var_3 * 0.08) == var_1) and (floor(var_3 * 0.1) == var_2):\n\n print(var_3)\n quit()\n\n\nprint((-1))\n```", "output": "SLOWER 1.8373", "pair_id": "python_p02755_reversed", "problem_id": "p02755", "language": "python", "direction": "reversed", "speedup_ratio": 3.5734} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_6 = sorted([list(map(int, input().split())) for var_5 in range(var_1)])\n\nvar_4 = [[0] * (var_2 + 1) for var_5 in range(var_1 + 1)]\n\nfor var_5 in range(var_1):\n var_9, var_8 = var_6[var_5]\n for var_7 in range(var_2 + 1):\n if var_7 + var_9 <= var_2:\n var_4[var_5 + 1][var_7 + var_9] = max(\n var_4[var_5 + 1][var_7 + var_9], var_4[var_5][var_7] + var_8\n )\n var_4[var_5 + 1][var_7] = max(var_4[var_5][var_7], var_4[var_5 + 1][var_7])\nvar_3 = 0\nfor var_5, (var_9, var_8) in enumerate(var_6):\n for var_7 in range(var_2):\n var_3 = max(var_3, var_4[var_5][var_7] + var_8)\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\nfrom operator import itemgetter\nfrom heapq import heapify, heappop, heappush\n\nvar_1 = int(10e15)\nvar_2 = -var_1\nvar_11 = 1000000007\nsys.setrecursionlimit(1000000)\n\n\ndef func_2():\n return list(map(int, input().split()))\n\n\ndef func_4():\n return input().split()\n\n\ndef func_1():\n return int(sys.stdin.readline())\n\n\ndef func_3():\n return eval(input())\n\n\nvar_3, var_4 = func_2()\nvar_5 = [func_2() for var_9 in range(var_3)]\nvar_5.sort(key=itemgetter(0))\n\nvar_8 = [[0] * (var_4 + 1 + 3000 + 1) for _ in range(var_3 + 1)]\nvar_6 = 0\nfor var_9 in range(var_3):\n for var_10 in range(var_4 + 1 + 3000 + 1):\n var_12, var_7 = var_5[var_9]\n if 0 <= var_10 - var_12 < var_4:\n var_8[var_9 + 1][var_10] = max(\n var_8[var_9][var_10], var_8[var_9][var_10 - var_12] + var_7\n )\n else:\n var_8[var_9 + 1][var_10] = var_8[var_9][var_10]\n var_6 = max(var_6, var_8[var_9 + 1][var_10])\nprint(var_6)\n```", "output": "SLOWER 4.0536", "pair_id": "python_p02863_reversed", "problem_id": "p02863", "language": "python", "direction": "reversed", "speedup_ratio": 16.6053} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = str(var_4)\n if var_5[0] == var_5[4] and var_5[1] == var_5[3]:\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = list(reversed(list(str(var_4))))\n if var_5 == list(str(var_4)):\n var_3 += 1\nprint(var_3)\n```", "output": "SLOWER 1.9231", "pair_id": "python_p03416_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 3.7924} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport decimal\n\nvar_1, var_2 = (decimal.Decimal(var_3) for var_3 in input().split())\nprint((int(var_1 * var_2)))\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\nimport math\nfrom collections import defaultdict\nfrom bisect import bisect_left, bisect_right\n\nsys.setrecursionlimit(10**7)\n\n\ndef func_4():\n return sys.stdin.readline()[:-1]\n\n\nvar_4 = 10**9 + 7\n\n\ndef func_1():\n return int(eval(func_4()))\n\n\ndef func_2():\n return list(map(int, func_4().split()))\n\n\ndef func_3(var_6, var_3):\n if var_6 <= 0:\n return [[] for _ in range(var_3)]\n elif var_3 == 1:\n return [func_1() for _ in range(var_6)]\n else:\n var_5 = [func_2() for _ in range(var_6)]\n return list(map(list, list(zip(*var_5))))\n\n\nfrom decimal import getcontext, Decimal\n\ngetcontext().prec = 28\nvar_1, var_2 = list(map(str, func_4().split()))\nvar_1 = int(var_1)\nvar_2 = Decimal(var_2)\nprint((int(var_1 * var_2)))\n```", "output": "SLOWER 2.232", "pair_id": "python_p02659_reversed", "problem_id": "p02659", "language": "python", "direction": "reversed", "speedup_ratio": 4.6978} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport copy\n\nvar_8 = int(eval(input()))\nvar_10 = set([var_6 for var_6 in range(1, 10**5)])\nvar_5 = []\nvar_11 = {}\nvar_9 = []\nfor var_6 in range(var_8 - 1):\n var_1, var_2 = list(map(int, input().split(\" \")))\n var_5.append([var_1, var_2])\n var_11.setdefault(var_1, []).append(var_2)\n var_9.append([])\nvar_9.append([])\nvar_9.append([])\nvar_7 = 0\nfor var_12 in range(1, var_8 + 1):\n var_14 = var_11.get(var_12, [])\n var_3 = 1\n for var_13 in var_14:\n if var_3 in var_9[var_12]:\n var_3 += 1\n else:\n pass\n var_9[var_13].append(var_3)\n if var_3 >= var_7:\n var_7 = var_3\n var_3 += 1\nprint(var_7)\nfor var_4 in var_5:\n print((var_9[var_4[1]][0]))\n```\n\n=== Code B (Modified) ===\n```python\nfrom collections import deque\n\nvar_9 = deque()\nvar_11 = deque()\nvar_4 = int(eval(input()))\nvar_12 = [[] for var_13 in range(var_4 + 1)]\nvar_2 = []\nfor _ in range(var_4 - 1):\n var_5, var_6 = list(map(int, input().split()))\n var_12[var_5].append(var_6)\n var_12[var_6].append(var_5)\n var_2.append((var_5, var_6))\n\nvar_3 = 0\nvar_9.append(1)\nvar_17 = [False for var_13 in range(var_4 + 1)]\nvar_8 = [-1 for var_13 in range(var_4 + 1)]\nvar_17[1] = True\nvar_8[1] = -1\nvar_10 = {}\nwhile var_9:\n while var_9:\n var_18 = var_9.popleft()\n var_15 = var_8[var_18]\n var_7 = 1\n for var_14 in var_12[var_18]:\n if var_17[var_14] == False:\n var_17[var_14] = True\n var_11.append(var_14)\n if var_7 != var_15:\n var_8[var_14] = var_7\n var_10[(var_18, var_14)] = var_7\n elif var_7 == var_15:\n var_7 += 1\n var_8[var_14] = var_7\n var_10[(var_18, var_14)] = var_7\n var_7 += 1\n if var_11:\n var_9 = var_11\n var_11 = deque()\nvar_1 = max(var_8)\nprint(var_1)\nfor var_16 in var_2:\n var_5, var_6 = var_16\n if (var_5, var_6) in list(var_10.keys()):\n print((var_10[var_16]))\n else:\n print((var_10[(var_6, var_5)]))\n```", "output": "FASTER 3.8829", "pair_id": "python_p02850_forward", "problem_id": "p02850", "language": "python", "direction": "forward", "speedup_ratio": 14.7526} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1 = [int(eval(input())) for _ in range(int(eval(input())))]\nprint((sum(var_1) - int(max(var_1) / 2)))\n```\n\n=== Code B (Modified) ===\n```python\nimport copy\nimport random\nimport bisect\nimport fractions\nimport math\nimport sys\nimport collections\nfrom decimal import Decimal\n\nvar_5 = 10**9 + 7\nsys.setrecursionlimit(var_5)\nvar_3 = collections.deque()\n\n\ndef func_1():\n return list(map(int, sys.stdin.readline().split()))\n\n\nvar_1 = int(eval(input()))\nvar_6 = [0 for var_4 in range(var_1)]\nfor var_4 in range(var_1):\n var_6[var_4] = int(eval(input()))\nvar_6.sort()\nvar_2 = sum(var_6)\nvar_2 -= var_6[-1] // 2\nprint(var_2)\n```", "output": "SLOWER 1.0343", "pair_id": "python_p03207_reversed", "problem_id": "p03207", "language": "python", "direction": "reversed", "speedup_ratio": 2.0481} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n if str(var_4) == \"\".join(reversed(str(var_4))):\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = str(var_4)\n if var_5[0] == var_5[4] and var_5[1] == var_5[3]:\n var_3 += 1\nprint(var_3)\n```", "output": "FASTER 1.3424", "pair_id": "python_p03416_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 2.5357} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nfrom collections import deque\n\nvar_4, *var_2 = list(map(int, open(0).read().split()))\nvar_3 = [set() for _ in range(var_4 + 1)]\nfor var_9, (var_6, var_7) in enumerate(zip(*[iter(var_2)] * 2)):\n var_3[var_6].add((var_7, var_9))\n var_3[var_7].add((var_6, var_9))\nvar_1 = [0] * (var_4 - 1)\nvar_5 = deque([1])\nwhile var_5:\n var_10, var_12 = divmod(var_5.popleft(), var_4 + 1)\n var_8 = 0\n for var_11, var_9 in var_3[var_12]:\n var_3[var_11].remove((var_12, var_9))\n var_8 += 1 + (var_8 + 1 == var_10)\n var_5.append(var_8 * (var_4 + 1) + var_11)\n var_1[var_9] = var_8\nprint((max(var_1)))\nprint((\"\\n\".join(map(str, var_1))))\n```\n\n=== Code B (Modified) ===\n```python\nimport copy\n\nvar_8 = int(eval(input()))\nvar_10 = set([var_6 for var_6 in range(1, 10**5)])\nvar_5 = []\nvar_11 = {}\nvar_9 = []\nfor var_6 in range(var_8 - 1):\n var_1, var_2 = list(map(int, input().split(\" \")))\n var_5.append([var_1, var_2])\n var_11.setdefault(var_1, []).append(var_2)\n var_9.append([])\nvar_9.append([])\nvar_9.append([])\nvar_7 = 0\nfor var_12 in range(1, var_8 + 1):\n var_14 = var_11.get(var_12, [])\n var_3 = 1\n for var_13 in var_14:\n if var_3 in var_9[var_12]:\n var_3 += 1\n else:\n pass\n var_9[var_13].append(var_3)\n if var_3 >= var_7:\n var_7 = var_3\n var_3 += 1\nprint(var_7)\nfor var_4 in var_5:\n print((var_9[var_4[1]][0]))\n```", "output": "SLOWER 4.4548", "pair_id": "python_p02850_reversed", "problem_id": "p02850", "language": "python", "direction": "reversed", "speedup_ratio": 21.93} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport math\nimport string\n\n\ndef func_4():\n return list(map(int, input().split()))\n\n\ndef func_3(var_6, var_7):\n return math.factorial(var_6) // (\n math.factorial(var_6 - var_7) * math.factorial(var_7)\n )\n\n\ndef func_2(var_9):\n var_8 = []\n for var_5 in var_9:\n if not (var_5 in var_8):\n var_8.append(var_5)\n return len(var_9) != len(var_8)\n\n\ndef func_1(var_6):\n func_1 = []\n for var_4 in range(1, var_6 + 1):\n if var_6 % var_4 == 0:\n func_1.append(var_4)\n return func_1\n\n\nvar_2 = [-1, -1, -1, 0, 0, 1, 1, 1]\nvar_3 = [-1, 0, 1, -1, 1, -1, 0, 1]\nvar_6 = int(eval(input()))\nvar_1 = func_4()\nvar_10 = 1\nfor var_4 in range(len(var_1)):\n if var_1[var_4] % 2 == 0:\n var_10 *= 2\n else:\n var_10 *= 1\nprint((3 ** len(var_1) - var_10))\n```\n\n=== Code B (Modified) ===\n```python\nvar_6 = int(eval(input()))\nvar_2 = list(map(int, input().split()))\nfrom itertools import product\n\nvar_5 = [-1, 0, 1]\nvar_3 = 0\nfor var_7 in product(var_5, repeat=var_6):\n var_1 = []\n for var_4 in range(var_6):\n var_1.append(var_7[var_4] + var_2[var_4])\n if any(var_8 % 2 == 0 for var_8 in var_1):\n var_3 += 1\nprint(var_3)\n```", "output": "SLOWER 8.1431", "pair_id": "python_p03568_reversed", "problem_id": "p03568", "language": "python", "direction": "reversed", "speedup_ratio": 282.6949} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\nimport math\nfrom collections import defaultdict\nfrom bisect import bisect_left, bisect_right\n\nsys.setrecursionlimit(10**7)\n\n\ndef func_4():\n return sys.stdin.readline()[:-1]\n\n\nvar_4 = 10**9 + 7\n\n\ndef func_1():\n return int(eval(func_4()))\n\n\ndef func_2():\n return list(map(int, func_4().split()))\n\n\ndef func_3(var_6, var_3):\n if var_6 <= 0:\n return [[] for _ in range(var_3)]\n elif var_3 == 1:\n return [func_1() for _ in range(var_6)]\n else:\n var_5 = [func_2() for _ in range(var_6)]\n return list(map(list, list(zip(*var_5))))\n\n\nfrom decimal import getcontext, Decimal\n\ngetcontext().prec = 28\nvar_1, var_2 = list(map(str, func_4().split()))\nvar_1 = int(var_1)\nvar_2 = Decimal(var_2)\nprint((int(var_1 * var_2)))\n```\n\n=== Code B (Modified) ===\n```python\nimport math\n\nvar_1, var_2 = input().split()\nvar_1 = int(var_1)\nvar_3 = int(var_2[0] + var_2[2] + var_2[3])\nprint((var_1 * var_3 // 100))\n```", "output": "FASTER 2.3373", "pair_id": "python_p02659_forward", "problem_id": "p02659", "language": "python", "direction": "forward", "speedup_ratio": 5.0534} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_5 in range(10):\n for var_6 in range(10):\n for var_7 in range(10):\n var_3 = 10000 * var_5 + 1000 * var_6 + 100 * var_7 + 10 * var_6 + var_5\n if var_1 <= var_3 <= var_2:\n var_4 += 1\nprint(var_4)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = [0] * (var_2 + 1)\nfor var_3 in range(1, var_2 + 1):\n if str(var_3) == str(var_3)[::-1]:\n var_4[var_3] = var_4[var_3 - 1] + 1\n else:\n var_4[var_3] = var_4[var_3 - 1]\nprint((var_4[var_2] - var_4[var_1 - 1]))\n```", "output": "SLOWER 5.7678", "pair_id": "python_p03416_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 54.4866} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\n\nvar_5 = sys.stdin.readline\nif __name__ == \"__main__\":\n var_1, var_3 = var_5().split()\n var_2 = int(var_1)\n var_4 = round(float(var_3) * 100)\n print((var_2 * var_4 // 100))\n```\n\n=== Code B (Modified) ===\n```python\ndef func_1():\n from sys import setrecursionlimit, stdin\n from os import environ\n from collections import defaultdict, deque, Counter\n from math import ceil, floor, gcd\n from itertools import accumulate, combinations, combinations_with_replacement\n\n setrecursionlimit(10**6)\n var_7 = (\n (lambda *var_11: print(*var_11))\n if \"TERM_PROGRAM\" in environ\n else lambda *var_12: 0\n )\n var_8 = lambda: stdin.readline().rstrip()\n var_3 = lambda: list(map(int, var_8().split()))\n var_1 = lambda: int(var_8())\n var_4 = 10**9 + 7\n var_2 = 10**9 + 10\n var_9, var_10 = var_8().split()\n var_5 = int(var_9)\n var_10 = var_10.split(\".\")\n var_6 = int(var_10[0]) * 100\n if len(var_10) == 2:\n var_6 += int(var_10[1])\n print(var_5 * var_6 // 100)\n\n\nfunc_1()\n```", "output": "SLOWER 1.8866", "pair_id": "python_p02659_reversed", "problem_id": "p02659", "language": "python", "direction": "reversed", "speedup_ratio": 3.6977} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport copy\n\nvar_8 = int(eval(input()))\nvar_10 = set([var_6 for var_6 in range(1, 10**5)])\nvar_5 = []\nvar_11 = {}\nvar_9 = []\nfor var_6 in range(var_8 - 1):\n var_1, var_2 = list(map(int, input().split(\" \")))\n var_5.append([var_1, var_2])\n var_11.setdefault(var_1, []).append(var_2)\n var_9.append([])\nvar_9.append([])\nvar_9.append([])\nvar_7 = 0\nfor var_12 in range(1, var_8 + 1):\n var_14 = var_11.get(var_12, [])\n var_3 = 1\n for var_13 in var_14:\n if var_3 in var_9[var_12]:\n var_3 += 1\n else:\n pass\n var_9[var_13].append(var_3)\n if var_3 >= var_7:\n var_7 = var_3\n var_3 += 1\nprint(var_7)\nfor var_4 in var_5:\n print((var_9[var_4[1]][0]))\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\n\n\ndef func_1():\n var_8 = int(sys.stdin.readline().rstrip())\n var_7 = list(map(int, sys.stdin.read().split()))\n var_2 = list(zip(var_7, var_7))\n var_6 = [[] for _ in range(var_8 + 1)]\n for var_1, var_3 in var_2:\n var_6[var_1].append(var_3)\n var_6[var_3].append(var_1)\n var_13 = 1\n var_11 = [0] * (var_8 + 1)\n var_10 = []\n var_14 = [var_13]\n while var_14:\n var_15 = var_14.pop()\n var_10.append(var_15)\n for var_16 in var_6[var_15]:\n if var_16 == var_11[var_15]:\n continue\n var_11[var_16] = var_15\n var_14.append(var_16)\n var_5 = [-1] * (var_8 + 1)\n for var_15 in var_10:\n var_9 = var_5[var_15]\n var_4 = 1\n for var_16 in var_6[var_15]:\n if var_16 == var_11[var_15]:\n continue\n if var_4 == var_9:\n var_4 += 1\n var_5[var_16] = var_4\n var_4 += 1\n var_12 = []\n for var_1, var_3 in var_2:\n if var_11[var_1] == var_3:\n var_12.append(var_5[var_1])\n else:\n var_12.append(var_5[var_3])\n print((max(var_12)))\n print((\"\\n\".join(map(str, var_12))))\n\n\nif __name__ == \"__main__\":\n func_1()\n```", "output": "FASTER 4.1752", "pair_id": "python_p02850_forward", "problem_id": "p02850", "language": "python", "direction": "forward", "speedup_ratio": 18.0665} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_3 = list(map(int, input().split()))\nvar_2 = 0\nfor var_5 in range(var_3 + 1)[var_1:]:\n if len(str(var_5)) % 2 == 0:\n var_6 = list(str(var_5))[: len(str(var_5)) // 2]\n var_7 = list(reversed(list(str(var_5))[len(str(var_5)) // 2 :]))\n if var_6 == var_7:\n var_2 += 1\n else:\n var_8 = list(str(var_5))[: len(str(var_5)) // 2 + 1]\n var_4 = list(reversed(list(str(var_5))[len(str(var_5)) // 2 :]))\n if var_8 == var_4:\n var_2 += 1\nprint(var_2)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n if str(var_4) == \"\".join(reversed(str(var_4))):\n var_3 += 1\nprint(var_3)\n```", "output": "FASTER 1.3983", "pair_id": "python_p03416_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 2.6359} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_6 = int(eval(input()))\nimport sys\n\nsys.setrecursionlimit(10**6)\nvar_11 = [[] for _ in range(var_6)]\nfor var_4 in range(var_6 - 1):\n var_1, var_2 = list(map(int, input().split()))\n var_11[var_1 - 1].append((var_2 - 1, var_4))\n var_11[var_2 - 1].append((var_1 - 1, var_4))\nvar_5 = [0] * (var_6 - 1)\n\n\ndef func_1(var_8, var_10, var_9):\n var_3 = 1\n for var_7, var_4 in var_11[var_8]:\n if var_7 == var_9:\n continue\n if var_3 == var_10:\n var_3 += 1\n var_5[var_4] = var_3\n func_1(var_7, var_3, var_8)\n var_3 += 1\n\n\nfunc_1(0, -1, -1)\nprint((max(var_5)))\nfor var_4 in var_5:\n print(var_4)\n```\n\n=== Code B (Modified) ===\n```python\nimport copy\n\nvar_8 = int(eval(input()))\nvar_10 = set([var_6 for var_6 in range(1, 10**5)])\nvar_5 = []\nvar_11 = {}\nvar_9 = []\nfor var_6 in range(var_8 - 1):\n var_1, var_2 = list(map(int, input().split(\" \")))\n var_5.append([var_1, var_2])\n var_11.setdefault(var_1, []).append(var_2)\n var_9.append([])\nvar_9.append([])\nvar_9.append([])\nvar_7 = 0\nfor var_12 in range(1, var_8 + 1):\n var_14 = var_11.get(var_12, [])\n var_3 = 1\n for var_13 in var_14:\n if var_3 in var_9[var_12]:\n var_3 += 1\n else:\n pass\n var_9[var_13].append(var_3)\n if var_3 >= var_7:\n var_7 = var_3\n var_3 += 1\nprint(var_7)\nfor var_4 in var_5:\n print((var_9[var_4[1]][0]))\n```", "output": "SLOWER 4.64", "pair_id": "python_p02850_reversed", "problem_id": "p02850", "language": "python", "direction": "reversed", "speedup_ratio": 24.934} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nfrom sys import stdin\n\n\ndef func_1():\n\n var_11 = stdin.readline\n var_2 = int(var_11())\n var_1 = []\n for var_6 in range(var_2):\n var_5 = int(\"\".join(var_11().strip().split(\" \")), 2)\n var_1.append(var_5)\n var_3 = []\n for var_6 in range(var_2):\n var_10 = list(map(int, var_11().split()))\n var_3.append(var_10)\n var_8 = float(\"-inf\")\n for var_9 in range(1, 1 << 10):\n var_12 = 0\n for var_7 in range(var_2):\n var_4 = bin(var_9 & var_1[var_7]).count(\"1\")\n var_12 += var_3[var_7][var_4]\n var_8 = max(var_12, var_8)\n print(var_8)\n\n\nif __name__ == \"__main__\":\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\n\nvar_8 = sys.stdin.readline\n\n\ndef func_1():\n var_2 = int(eval(var_8()))\n var_1 = []\n for _ in range(var_2):\n var_1.append(list(map(int, var_8().split())))\n var_3 = []\n for _ in range(var_2):\n var_3.append(list(map(int, var_8().split())))\n var_4 = -(10**7) * var_2\n for var_7 in range(1, 1 << 10):\n var_11 = 0\n for var_10, var_6 in enumerate(var_1):\n var_5 = 0\n for var_9 in range(10):\n if (var_7 >> var_9) & 1 & var_6[var_9]:\n var_5 += 1\n var_11 += var_3[var_10][var_5]\n var_4 = max(var_4, var_11)\n print(var_4)\n\n\nif __name__ == \"__main__\":\n func_1()\n```", "output": "SLOWER 1.9105", "pair_id": "python_p03503_reversed", "problem_id": "p03503", "language": "python", "direction": "reversed", "speedup_ratio": 3.7593} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().rstrip().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = list(map(int, list(str(var_4))))\n if var_5[0] == var_5[4] and var_5[1] == var_5[3]:\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_4 = str(var_4)\n if var_4[0] == var_4[-1] and var_4[1] == var_4[-2]:\n var_3 += 1\nprint(var_3)\n```", "output": "FASTER 1.8667", "pair_id": "python_p03416_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 3.6471} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\nfrom collections import Counter\n\n\ndef func_9():\n return sys.stdin.readline().strip()\n\n\ndef func_10(var_8, var_9, var_10):\n return [[var_10] * var_9 for var_13 in range(var_8)]\n\n\ndef func_11(var_8, var_9, var_10, var_11):\n return [[[var_11] * var_10 for var_14 in range(var_9)] for var_13 in range(var_8)]\n\n\ndef func_12(var_8, var_9, var_10, var_11, var_12):\n return [\n [[[var_12] * var_11 for var_14 in range(var_10)] for var_14 in range(var_9)]\n for var_13 in range(var_8)\n ]\n\n\ndef func_8(var_16, var_17=1):\n return int(-(-var_16 // var_17))\n\n\ndef func_1():\n return int(eval(func_9()))\n\n\ndef func_3():\n return list(map(int, func_9().split()))\n\n\ndef func_2(var_7=None):\n return list(func_3()) if var_7 is None else [func_1() for var_13 in range(var_7)]\n\n\ndef func_7():\n print(\"Yes\")\n\n\ndef func_5():\n print(\"No\")\n\n\ndef func_6():\n print(\"YES\")\n\n\ndef func_4():\n print(\"NO\")\n\n\nsys.setrecursionlimit(10**9)\nvar_3 = 10**18\nvar_6 = 10**9 + 7\nvar_7, var_5, var_4 = func_3()\nvar_1 = func_2()\nvar_2 = func_2()\nvar_15 = min(var_1) + min(var_2)\nfor _ in range(var_4):\n var_16, var_17, var_10 = func_3()\n var_16 -= 1\n var_17 -= 1\n var_15 = min(var_15, var_1[var_16] + var_2[var_17] - var_10)\nprint(var_15)\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\nfrom collections import Counter\n\n\ndef func_10():\n return sys.stdin.readline().strip()\n\n\ndef func_11(var_12, var_13, var_14):\n return [[var_14] * var_13 for var_17 in range(var_12)]\n\n\ndef func_12(var_12, var_13, var_14, var_15):\n return [[[var_15] * var_14 for var_18 in range(var_13)] for var_17 in range(var_12)]\n\n\ndef func_13(var_12, var_13, var_14, var_15, var_16):\n return [\n [[[var_16] * var_15 for var_18 in range(var_14)] for var_18 in range(var_13)]\n for var_17 in range(var_12)\n ]\n\n\ndef func_8(var_22, var_23=1):\n return int(-(-var_22 // var_23))\n\n\ndef func_1():\n return int(eval(func_10()))\n\n\ndef func_3():\n return list(map(int, func_10().split()))\n\n\ndef func_2(var_11=None):\n return list(func_3()) if var_11 is None else [func_1() for var_17 in range(var_11)]\n\n\ndef func_7():\n print(\"Yes\")\n\n\ndef func_5():\n print(\"No\")\n\n\ndef func_6():\n print(\"YES\")\n\n\ndef func_4():\n print(\"NO\")\n\n\nsys.setrecursionlimit(10**9)\nvar_5 = 10**18\nvar_10 = 10**9 + 7\n\n\ndef func_9(var_1, var_2):\n \"\"\"\"\"\"\n import numpy as np\n from numpy.fft import rfft, irfft\n\n var_8 = max(var_1)\n var_9 = max(var_2)\n var_3 = [0] * (var_8 + 1)\n var_4 = [0] * (var_9 + 1)\n for var_12 in var_1:\n var_3[var_12] += 1\n for var_13 in var_2:\n var_4[var_13] += 1\n\n var_6 = 1\n var_19 = 0\n while var_6 <= var_8 + var_9:\n var_19 += 1\n var_6 = 2**var_19\n\n var_21 = irfft(rfft(var_3, var_6) * rfft(var_4, var_6), var_6)\n\n var_21 = np.rint(var_21).astype(np.int64)\n return var_21\n\n\nvar_11, var_7, var_6 = func_3()\nvar_1 = func_2()\nvar_2 = func_2()\nvar_21 = list(func_9(var_1, var_2))\nvar_20 = var_5\nfor var_17, var_12 in enumerate(var_21):\n if var_12 != 0:\n var_20 = var_17\n break\nfor _ in range(var_6):\n var_22, var_23, var_14 = func_3()\n var_22 -= 1\n var_23 -= 1\n var_20 = min(var_20, var_1[var_22] + var_2[var_23] - var_14)\nprint(var_20)\n```", "output": "SLOWER 1.3665", "pair_id": "python_p02748_reversed", "problem_id": "p02748", "language": "python", "direction": "reversed", "speedup_ratio": 2.5785} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = input().split()\nvar_1 = int(var_1)\nvar_2 = int(var_2.replace(\".\", \"\"))\nprint((var_1 * var_2 // 100))\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\nimport math\nfrom collections import defaultdict\nfrom bisect import bisect_left, bisect_right\n\nsys.setrecursionlimit(10**7)\n\n\ndef func_4():\n return sys.stdin.readline()[:-1]\n\n\nvar_4 = 10**9 + 7\n\n\ndef func_1():\n return int(eval(func_4()))\n\n\ndef func_2():\n return list(map(int, func_4().split()))\n\n\ndef func_3(var_6, var_3):\n if var_6 <= 0:\n return [[] for _ in range(var_3)]\n elif var_3 == 1:\n return [func_1() for _ in range(var_6)]\n else:\n var_5 = [func_2() for _ in range(var_6)]\n return list(map(list, list(zip(*var_5))))\n\n\nvar_1, var_2 = list(map(str, func_4().split()))\nvar_1 = int(var_1)\nvar_2 = 100 * int(var_2[0]) + 10 * int(var_2[2]) + int(var_2[3])\nprint((var_1 * var_2 // 100))\n```", "output": "SLOWER 2.5828", "pair_id": "python_p02659_reversed", "problem_id": "p02659", "language": "python", "direction": "reversed", "speedup_ratio": 5.9911} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().strip().split(\" \")))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n if str(var_4) == str(var_4)[::-1]:\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = [\n var_3 for var_3 in map(str, list(range(var_1, var_2 + 1))) if var_3 == var_3[::-1]\n]\nprint((len(var_4)))\n```", "output": "FASTER 1.0058", "pair_id": "python_p03416_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 2.0081} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_5 = int(eval(input()))\nvar_7 = list(map(int, input().split()))\nvar_8 = list(map(int, input().split()))\nvar_6 = [[0 for var_2 in range(6)] for var_3 in range(var_5 + 1)]\nvar_1 = abs(var_7[0] - var_8[0])\nvar_6[0][3] = var_6[0][0] = var_1\nvar_6[0][4] = var_6[0][1] = var_1**2\nvar_6[0][5] = var_6[0][2] = var_1**3\nvar_4 = var_1\nfor var_2 in range(1, var_5, 1):\n var_1 = abs(var_7[var_2] - var_8[var_2])\n var_6[var_2][0] = var_1\n var_6[var_2][1] = var_1**2\n var_6[var_2][2] = var_6[var_2][1] * var_1\n var_6[var_2][3] = var_6[var_2 - 1][3] + var_6[var_2][0]\n var_6[var_2][4] = var_6[var_2 - 1][4] + var_6[var_2][1]\n var_6[var_2][5] = var_6[var_2 - 1][5] + var_6[var_2][2]\n if var_1 > var_4:\n var_4 = var_1\nprint((var_6[var_5 - 1][3]))\nprint((var_6[var_5 - 1][4] ** (1 / 2)))\nprint((var_6[var_5 - 1][5] ** (1 / 3)))\nprint(var_4)\n```\n\n=== Code B (Modified) ===\n```python\nvar_3 = int(input())\nvar_6 = list(map(int, input().split()))\nvar_7 = list(map(int, input().split()))\nvar_1 = [abs(var_4 - var_5) for var_4, var_5 in zip(var_6, var_7)]\nvar_2 = lambda var_3: sum([var_4**var_3 for var_4 in var_1]) ** (1 / var_3)\nprint(var_2(1), var_2(2), var_2(3), max(var_1), sep=\"\\n\")\n```", "output": "FASTER 1.2213", "pair_id": "python_p02382_forward", "problem_id": "p02382", "language": "python", "direction": "forward", "speedup_ratio": 2.3316} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_6 = str(var_4)\n var_5 = var_6[::-1]\n if var_6 == var_5:\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_4 = {}\nvar_5 = 0\nfor var_6 in range(10000, 100000):\n var_3 = list(str(var_6))\n if var_3 == list(reversed(var_3)):\n var_5 += 1\n var_4[var_6] = var_5\nvar_1, var_2 = list(map(int, input().split()))\nprint((var_4[var_2] - var_4[var_1 - 1] if var_1 > 10000 else var_4[var_2]))\n```", "output": "SLOWER 3.3232", "pair_id": "python_p03416_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 10.0089} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_10 = []\nvar_10 = input().rstrip().split(\" \")\nvar_1 = int(var_10[0])\nvar_3 = int(var_10[1])\nvar_2 = 0\nvar_6 = var_1\nwhile var_6 <= var_3:\n var_4 = var_6 // 10000\n var_5 = (var_6 - var_4 * 10000) // 1000\n var_7 = var_6 // 100\n var_8 = (var_6 - var_7 * 100) // 10\n var_9 = var_6 % 10\n if (var_4 == var_9) and (var_5 == var_8):\n var_2 += 1\n var_6 += 1\nprint(var_2)\n```\n\n=== Code B (Modified) ===\n```python\ndef func_1():\n var_1, var_2 = list(map(int, input().rstrip().split()))\n var_3 = 0\n for var_4 in range(var_1, var_2 + 1):\n var_5 = str(var_4)\n if var_5 == var_5[::-1]:\n var_3 += 1\n print(var_3)\n\n\nif __name__ == \"__main__\":\n func_1()\n```", "output": "FASTER 1.555", "pair_id": "python_p03416_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 2.9383} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\n\n\ndef func_1(var_5, var_6):\n var_4 = 0\n for var_3 in range(var_5, var_6 + 1):\n if str(var_3) == str(var_3)[::-1]:\n var_4 += 1\n return var_4\n\n\nprint((func_1(var_1, var_2)))\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = list(str(var_4))\n if var_5 == list(reversed(var_5)):\n var_3 += 1\nprint(var_3)\n```", "output": "SLOWER 1.5558", "pair_id": "python_p03416_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 2.94} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_7 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_3 = True\n var_8 = str(var_4)\n var_6 = len(var_8)\n for var_5 in range(var_6 // 2 + 1):\n if var_8[var_5] != var_8[-var_5 - 1]:\n var_3 = False\n break\n if var_3:\n var_7 += 1\nprint(var_7)\n```\n\n=== Code B (Modified) ===\n```python\ndef func_1():\n var_1, var_2 = list(map(int, input().split()))\n var_3 = 0\n for var_4 in range(var_1, var_2 + 1):\n\n if (var_4 % 10) == (var_4 // 10000 % 10) and (var_4 // 10 % 10) == (\n var_4 // 1000 % 10\n ):\n var_3 += 1\n print(var_3)\n\n\nif __name__ == \"__main__\":\n func_1()\n```", "output": "FASTER 2.7891", "pair_id": "python_p03416_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 6.9122} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\nimport math\nfrom collections import defaultdict\nfrom bisect import bisect_left, bisect_right\n\nsys.setrecursionlimit(10**7)\n\n\ndef func_4():\n return sys.stdin.readline()[:-1]\n\n\nvar_4 = 10**9 + 7\n\n\ndef func_1():\n return int(eval(func_4()))\n\n\ndef func_2():\n return list(map(int, func_4().split()))\n\n\ndef func_3(var_6, var_3):\n if var_6 <= 0:\n return [[] for _ in range(var_3)]\n elif var_3 == 1:\n return [func_1() for _ in range(var_6)]\n else:\n var_5 = [func_2() for _ in range(var_6)]\n return list(map(list, list(zip(*var_5))))\n\n\nfrom decimal import getcontext, Decimal\n\ngetcontext().prec = 28\nvar_1, var_2 = list(map(str, func_4().split()))\nvar_1 = int(var_1)\nvar_2 = Decimal(var_2)\nprint((int(var_1 * var_2)))\n```\n\n=== Code B (Modified) ===\n```python\nfrom decimal import Decimal\nimport math\n\nvar_1, var_2 = list(map(str, input().split()))\nvar_1 = int(var_1)\nvar_2 = Decimal(var_2)\nvar_3 = math.floor(var_1 * var_2)\nprint((int(var_3)))\n```", "output": "FASTER 1.9581", "pair_id": "python_p02659_forward", "problem_id": "p02659", "language": "python", "direction": "forward", "speedup_ratio": 3.8855} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().rstrip().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = list(map(int, list(str(var_4))))\n if var_5[0] == var_5[4] and var_5[1] == var_5[3]:\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1 = list(map(int, input().split()))\nvar_2 = 0\nfor var_3 in range(var_1[0], var_1[1] + 1):\n var_4 = str(var_3)\n if var_4[0] == var_4[4] and var_4[1] == var_4[3]:\n var_2 += 1\nprint(var_2)\n```", "output": "FASTER 1.9718", "pair_id": "python_p03416_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 3.9226} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n if list(str(var_4)) == list(reversed(str(var_4))):\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_5 in range(10):\n for var_6 in range(10):\n for var_7 in range(10):\n var_3 = 10000 * var_5 + 1000 * var_6 + 100 * var_7 + 10 * var_6 + var_5\n if var_1 <= var_3 <= var_2:\n var_4 += 1\nprint(var_4)\n```", "output": "FASTER 5.2259", "pair_id": "python_p03416_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 37.4247} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\n\n\ndef func_1(var_5, var_6):\n var_4 = 0\n for var_3 in range(var_5, var_6 + 1):\n if str(var_3) == str(var_3)[::-1]:\n var_4 += 1\n return var_4\n\n\nprint((func_1(var_1, var_2)))\n```\n\n=== Code B (Modified) ===\n```python\nvar_10 = []\nvar_10 = input().rstrip().split(\" \")\nvar_1 = int(var_10[0])\nvar_3 = int(var_10[1])\nvar_2 = 0\nvar_6 = var_1\nwhile var_6 <= var_3:\n var_4 = var_6 // 10000\n var_5 = (var_6 - var_4 * 10000) // 1000\n var_7 = var_6 // 100\n var_8 = (var_6 - var_7 * 100) // 10\n var_9 = var_6 % 10\n if (var_4 == var_9) and (var_5 == var_8):\n var_2 += 1\n var_6 += 1\nprint(var_2)\n```", "output": "SLOWER 1.1326", "pair_id": "python_p03416_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 2.1926} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\ndef func_1():\n var_1, var_2 = list(map(int, input().split()))\n var_3 = 0\n for var_4 in range(var_1, var_2 + 1):\n\n if (var_4 % 10) == (var_4 // 10000 % 10) and (var_4 // 10 % 10) == (\n var_4 // 1000 % 10\n ):\n var_3 += 1\n print(var_3)\n\n\nif __name__ == \"__main__\":\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_5 in range(10):\n for var_6 in range(10):\n for var_7 in range(10):\n var_3 = 10000 * var_5 + 1000 * var_6 + 100 * var_7 + 10 * var_6 + var_5\n if var_1 <= var_3 <= var_2:\n var_4 += 1\nprint(var_4)\n```", "output": "FASTER 2.1615", "pair_id": "python_p03416_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 4.4738} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = [\n var_3 for var_3 in map(str, list(range(var_1, var_2 + 1))) if var_3 == var_3[::-1]\n]\nprint((len(var_4)))\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_5 in range(10):\n for var_6 in range(10):\n for var_7 in range(10):\n var_3 = 10000 * var_5 + 1000 * var_6 + 100 * var_7 + 10 * var_6 + var_5\n if var_1 <= var_3 <= var_2:\n var_4 += 1\nprint(var_4)\n```", "output": "FASTER 3.127", "pair_id": "python_p03416_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 8.7361} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\nimport itertools\n\n\ndef func_2(var_4):\n return eval(\"0b\" + var_4)\n\n\ndef func_1():\n var_4 = int(sys.stdin.readline().rstrip())\n var_9 = [\n func_2(\"\".join(str(var_10) for var_10 in sys.stdin.readline().split()))\n for _ in range(var_4)\n ]\n var_8 = [\n [int(var_10) for var_10 in sys.stdin.readline().split()] for _ in range(var_4)\n ]\n var_3 = -(10**10)\n for var_6 in itertools.product(\"01\", repeat=10):\n var_6 = func_2(\"\".join(var_6))\n if var_6 == 0:\n continue\n var_7 = 0\n for var_2 in range(var_4):\n var_1 = var_9[var_2]\n var_5 = bin(var_1 & var_6).count(\"1\")\n var_7 += var_8[var_2][var_5]\n var_3 = max(var_3, var_7)\n print(var_3)\n\n\nif __name__ == \"__main__\":\n\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\n\nvar_7 = sys.stdin.readline\nfrom itertools import combinations\n\n\ndef func_3(var_10):\n for _ in range(var_10):\n yield list(map(int, var_7().split()))\n\n\ndef func_1(var_9, var_5, var_11):\n var_3 = len([0 for var_8 in var_9 if var_5[var_8] == 1])\n return var_11[var_3]\n\n\ndef func_2():\n var_10 = int(eval(var_7()))\n var_1 = list(func_3(var_10))\n var_2 = list(func_3(var_10))\n for var_6 in range(1, 11):\n for var_4 in combinations(list(range(10)), var_6):\n yield sum(\n func_1(var_4, var_5, var_11) for var_5, var_11 in zip(var_1, var_2)\n )\n\n\nprint((max(func_2())))\n```", "output": "FASTER 2.0211", "pair_id": "python_p03503_forward", "problem_id": "p03503", "language": "python", "direction": "forward", "speedup_ratio": 4.0589} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_10 = []\nvar_10 = input().rstrip().split(\" \")\nvar_1 = int(var_10[0])\nvar_3 = int(var_10[1])\nvar_2 = 0\nvar_6 = var_1\nwhile var_6 <= var_3:\n var_4 = var_6 // 10000\n var_5 = (var_6 - var_4 * 10000) // 1000\n var_7 = var_6 // 100\n var_8 = (var_6 - var_7 * 100) // 10\n var_9 = var_6 % 10\n if (var_4 == var_9) and (var_5 == var_8):\n var_2 += 1\n var_6 += 1\nprint(var_2)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = [0] * (var_2 + 1)\nfor var_3 in range(1, var_2 + 1):\n if str(var_3) == str(var_3)[::-1]:\n var_4[var_3] = var_4[var_3 - 1] + 1\n else:\n var_4[var_3] = var_4[var_3 - 1]\nprint((var_4[var_2] - var_4[var_1 - 1]))\n```", "output": "SLOWER 1.1332", "pair_id": "python_p03416_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 2.1935} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_2 = int(eval(input()))\nvar_1 = list(map(int, input().split()))\nvar_4 = 1\nfor var_3 in range(var_2):\n if var_1[var_3] % 2 == 0:\n var_4 *= 2\nprint((3**var_2 - var_4))\n```\n\n=== Code B (Modified) ===\n```python\ndef func_1():\n var_2 = int(input())\n var_1 = [int(var_6) for var_6 in input().split()]\n if var_2 == 1:\n return print(1 if var_1[0] % 2 == 0 else 2)\n var_3 = 0\n var_5 = (-1, 0, 1)\n from itertools import product\n\n for var_6 in product(range(3), repeat=var_2):\n var_4 = 1\n for var_7 in range(var_2):\n var_4 *= var_1[var_7] + var_5[var_6[var_7]]\n if var_4 % 2 == 0:\n var_3 += 1\n print(var_3)\n\n\nif __name__ == \"__main__\":\n func_1()\n```", "output": "SLOWER 8.5767", "pair_id": "python_p03568_reversed", "problem_id": "p03568", "language": "python", "direction": "reversed", "speedup_ratio": 381.8046} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\n\nvar_8 = sys.stdin.readline\nvar_9 = int(eval(var_8()))\nvar_6 = []\nfor var_7 in range(var_9 - 1):\n var_1, var_3 = list(map(int, var_8().split()))\n var_6.append([var_1 - 1, var_3 - 1, var_7])\nvar_6.sort()\nvar_13 = [0] * (var_9)\nvar_2 = [0] * (var_9 - 1)\nvar_10 = 1\nvar_11 = 0\nfor var_5 in var_6:\n _from, var_12, var_7 = var_5\n if _from != var_11:\n var_10 = 1\n if var_13[_from] == var_10:\n var_10 += 1\n var_2[var_7] = var_10\n var_13[var_12] = var_10\n var_10 += 1\n var_11 = _from\nprint((max(var_2)))\nfor var_4 in var_2:\n print(var_4)\n```\n\n=== Code B (Modified) ===\n```python\nfrom collections import deque\n\n\ndef func_2(var_9, var_2, var_4):\n\n var_6 = {var_7: dict() for var_7 in range(var_9)}\n for var_7 in range(var_9 - 1):\n var_1, var_3 = var_2[var_7] - 1, var_4[var_7] - 1\n var_6[var_1][var_3] = -1\n var_6[var_3][var_1] = -1\n var_8 = max([len(var_6[var_1]) for var_1 in range(var_9)])\n var_14 = [-1] * var_9\n var_14[0] = var_8 - 1\n\n var_12 = deque([0])\n while len(var_12) > 0:\n var_10 = var_12.popleft()\n var_5 = var_14[var_10]\n for var_11 in list(var_6[var_10].keys()):\n if var_14[var_11] != -1:\n continue\n var_5 += 1\n var_5 %= var_8\n\n var_6[var_10][var_11] = var_5\n var_6[var_11][var_10] = var_5\n var_14[var_11] = var_5\n var_12.append(var_11)\n var_13 = [0] * (var_9 - 1)\n for var_7 in range(var_9 - 1):\n var_13[var_7] = var_6[var_2[var_7] - 1][var_4[var_7] - 1] + 1\n return var_8, var_13\n\n\ndef func_1():\n var_9 = int(eval(input()))\n var_2 = [0] * (var_9 - 1)\n var_4 = [0] * (var_9 - 1)\n for var_7 in range(var_9 - 1):\n var_1, var_3 = list(map(int, input().split()))\n var_2[var_7] = var_1\n var_4[var_7] = var_3\n var_8, var_13 = func_2(var_9, var_2, var_4)\n print(var_8)\n for var_7 in range(var_9 - 1):\n print((var_13[var_7]))\n\n\ndef func_3():\n print((func_2(3, [1, 2], [2, 3])))\n print((func_2(8, [1, 2, 2, 2, 4, 5, 6], [2, 3, 4, 5, 7, 6, 8])))\n\n\nif __name__ == \"__main__\":\n\n func_1()\n```", "output": "SLOWER 1.2025", "pair_id": "python_p02850_reversed", "problem_id": "p02850", "language": "python", "direction": "reversed", "speedup_ratio": 2.3014} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\nimport numpy as np\n\nvar_5 = sys.stdin.readline\n\nvar_7 = int(eval(var_5()))\n\nvar_1 = [var_5().replace(\" \", \"\") for var_4 in range(var_7)]\n\nvar_8 = [list(map(int, var_5().split())) for var_4 in range(var_7)]\n\n\nvar_12 = -999999999999999\n\nfor var_4 in range(1, 1024):\n\n var_3 = format(var_4, \"010b\")\n\n var_10 = 0\n for var_2, var_9 in zip(var_1, var_8):\n\n var_11 = 0\n for var_6 in range(10):\n\n if var_2[var_6] == \"1\" and var_3[var_6] == \"1\":\n\n var_11 += 1\n\n var_10 += var_9[var_11]\n if var_10 > var_12:\n\n var_12 = var_10\nprint(var_12)\n```\n\n=== Code B (Modified) ===\n```python\nfrom sys import stdin\n\n\ndef func_1():\n\n var_11 = stdin.readline\n var_2 = int(var_11())\n var_1 = []\n for var_6 in range(var_2):\n var_5 = int(\"\".join(var_11().strip().split(\" \")), 2)\n var_1.append(var_5)\n var_3 = []\n for var_6 in range(var_2):\n var_10 = list(map(int, var_11().split()))\n var_3.append(var_10)\n var_8 = float(\"-inf\")\n for var_9 in range(1, 1 << 10):\n var_12 = 0\n for var_7 in range(var_2):\n var_4 = bin(var_9 & var_1[var_7]).count(\"1\")\n var_12 += var_3[var_7][var_4]\n var_8 = max(var_12, var_8)\n print(var_8)\n\n\nif __name__ == \"__main__\":\n func_1()\n```", "output": "FASTER 2.8805", "pair_id": "python_p03503_forward", "problem_id": "p03503", "language": "python", "direction": "forward", "speedup_ratio": 7.3642} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\nfrom collections import Counter\n\n\ndef func_10():\n return sys.stdin.readline().strip()\n\n\ndef func_11(var_12, var_13, var_14):\n return [[var_14] * var_13 for var_17 in range(var_12)]\n\n\ndef func_12(var_12, var_13, var_14, var_15):\n return [[[var_15] * var_14 for var_18 in range(var_13)] for var_17 in range(var_12)]\n\n\ndef func_13(var_12, var_13, var_14, var_15, var_16):\n return [\n [[[var_16] * var_15 for var_18 in range(var_14)] for var_18 in range(var_13)]\n for var_17 in range(var_12)\n ]\n\n\ndef func_8(var_22, var_23=1):\n return int(-(-var_22 // var_23))\n\n\ndef func_1():\n return int(eval(func_10()))\n\n\ndef func_3():\n return list(map(int, func_10().split()))\n\n\ndef func_2(var_11=None):\n return list(func_3()) if var_11 is None else [func_1() for var_17 in range(var_11)]\n\n\ndef func_7():\n print(\"Yes\")\n\n\ndef func_5():\n print(\"No\")\n\n\ndef func_6():\n print(\"YES\")\n\n\ndef func_4():\n print(\"NO\")\n\n\nsys.setrecursionlimit(10**9)\nvar_5 = 10**18\nvar_10 = 10**9 + 7\n\n\ndef func_9(var_1, var_2):\n \"\"\"\"\"\"\n import numpy as np\n from numpy.fft import rfft, irfft\n\n var_8 = max(var_1)\n var_9 = max(var_2)\n var_3 = [0] * (var_8 + 1)\n var_4 = [0] * (var_9 + 1)\n for var_12 in var_1:\n var_3[var_12] += 1\n for var_13 in var_2:\n var_4[var_13] += 1\n\n var_6 = 1\n var_19 = 0\n while var_6 <= var_8 + var_9:\n var_19 += 1\n var_6 = 2**var_19\n\n var_21 = irfft(rfft(var_3, var_6) * rfft(var_4, var_6), var_6)\n\n var_21 = np.rint(var_21).astype(np.int64)\n return var_21\n\n\nvar_11, var_7, var_6 = func_3()\nvar_1 = func_2()\nvar_2 = func_2()\nvar_21 = list(func_9(var_1, var_2))\nvar_20 = var_5\nfor var_17, var_12 in enumerate(var_21):\n if var_12 != 0:\n var_20 = var_17\n break\nfor _ in range(var_6):\n var_22, var_23, var_14 = func_3()\n var_22 -= 1\n var_23 -= 1\n var_20 = min(var_20, var_1[var_22] + var_2[var_23] - var_14)\nprint(var_20)\n```\n\n=== Code B (Modified) ===\n```python\ndef func_1():\n return list(map(int, input().split()))\n\n\nimport numpy as np\n\nvar_1, var_2, var_3 = func_1()\nvar_4 = np.array(list(func_1()))\nvar_6 = np.array(list(func_1()))\nvar_9 = min(var_4) + min(var_6)\nvar_5 = float(\"inf\")\nfor var_8 in range(var_3):\n var_11, var_12, var_7 = func_1()\n var_10 = var_4[var_11 - 1] + var_6[var_12 - 1] - var_7\n var_5 = min(var_5, var_10)\nprint((min(var_5, var_9)))\n```", "output": "FASTER 2.9536", "pair_id": "python_p02748_forward", "problem_id": "p02748", "language": "python", "direction": "forward", "speedup_ratio": 7.7468} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_2, var_1 = list(map(int, input().split()))\nvar_6 = {}\nvar_3 = {}\nfor var_4 in range(var_1):\n var_5, var_7 = input().split()\n var_5 = int(var_5)\n if not var_5 in var_6:\n var_6[var_5] = 0\n var_3[var_5] = 0\n if var_7 == \"WA\" and var_3[var_5] == 0:\n var_6[var_5] += 1\n elif var_7 == \"AC\" and var_3[var_5] == 0:\n var_3[var_5] += 1\nfor var_4 in var_6:\n if var_6[var_4] != 0 and var_3[var_4] == 0:\n var_6[var_4] = 0\nprint((sum(var_3.values()), sum(var_6.values())))\n```\n\n=== Code B (Modified) ===\n```python\nvar_7, var_6 = list(map(int, input().split()))\nvar_5 = [tuple(input().split()) for _ in range(var_6)]\nvar_9 = [[] for _ in range(var_7)]\nfor var_2 in range(var_6):\n var_9[int(var_5[var_2][0]) - 1].append(var_5[var_2][1])\nvar_1, var_8 = 0, 0\nfor var_3 in range(var_7):\n if \"AC\" in var_9[var_3]:\n var_1 += 1\n for var_4 in range(len(var_9[var_3])):\n if var_9[var_3][var_4] == \"WA\":\n var_8 += 1\n else:\n break\nprint((var_1, var_8))\n```", "output": "SLOWER 4.1714", "pair_id": "python_p02802_reversed", "problem_id": "p02802", "language": "python", "direction": "reversed", "speedup_ratio": 18.0189} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\n\n\ndef func_1(var_5, var_6):\n var_4 = 0\n for var_3 in range(var_5, var_6 + 1):\n if str(var_3) == str(var_3)[::-1]:\n var_4 += 1\n return var_4\n\n\nprint((func_1(var_1, var_2)))\n```\n\n=== Code B (Modified) ===\n```python\nvar_4 = {}\nvar_5 = 0\nfor var_6 in range(10000, 100000):\n var_3 = list(str(var_6))\n if var_3 == list(reversed(var_3)):\n var_5 += 1\n var_4[var_6] = var_5\nvar_1, var_2 = list(map(int, input().split()))\nprint((var_4[var_2] - var_4[var_1 - 1] if var_1 > 10000 else var_4[var_2]))\n```", "output": "SLOWER 3.8972", "pair_id": "python_p03416_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 14.8999} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\ndef func_1():\n var_1, var_2 = list(map(int, input().rstrip().split()))\n var_3 = 0\n for var_4 in range(var_1, var_2 + 1):\n var_5 = str(var_4)\n if var_5 == var_5[::-1]:\n var_3 += 1\n print(var_3)\n\n\nif __name__ == \"__main__\":\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nvar_4 = {}\nvar_5 = 0\nfor var_6 in range(10000, 100000):\n var_3 = list(str(var_6))\n if var_3 == list(reversed(var_3)):\n var_5 += 1\n var_4[var_6] = var_5\nvar_1, var_2 = list(map(int, input().split()))\nprint((var_4[var_2] - var_4[var_1 - 1] if var_1 > 10000 else var_4[var_2]))\n```", "output": "SLOWER 4.3196", "pair_id": "python_p03416_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 19.9676} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\n\nvar_20 = sys.stdin.read\nvar_21 = sys.stdin.readline\nvar_22 = sys.stdin.readlines\nsys.setrecursionlimit(10**9)\nvar_2 = 1 << 60\nvar_5 = 1000000007\n\n\nvar_4 = 1000001\n\n\nclass Class_1:\n def __init__(self, var_13, var_19, var_12):\n self.l = var_13\n self.r = var_19\n self.idx = var_12\n\n\ndef func_4(var_12, var_24, var_10, var_15):\n while var_12 <= var_15:\n var_10[var_12] += var_24\n var_12 += var_12 & -var_12\n\n\ndef func_3(var_12, var_10, var_15):\n var_23 = 0\n while var_12:\n var_23 += var_10[var_12]\n var_12 -= var_12 & -var_12\n return var_23\n\n\ndef func_1(var_9, var_15, var_17, var_16):\n\n var_10 = [0] * (var_15 + 1)\n\n var_14 = [-1] * var_4\n\n var_8 = [0] * var_16\n var_18 = 0\n for var_11 in range(var_15):\n\n if var_14[var_9[var_11]] != -1:\n func_4(var_14[var_9[var_11]] + 1, -1, var_10, var_15)\n\n var_14[var_9[var_11]] = var_11\n func_4(var_11 + 1, 1, var_10, var_15)\n\n while var_18 < var_16 and var_17[var_18].r == var_11:\n var_8[var_17[var_18].idx] = func_3(\n var_17[var_18].r + 1, var_10, var_15\n ) - func_3(var_17[var_18].l, var_10, var_15)\n var_18 += 1\n\n for var_11 in range(var_16):\n print((var_8[var_11]))\n\n\ndef func_2():\n var_6, var_7 = list(map(int, var_21().split()))\n var_1 = list(map(int, var_21().split()))\n (*var_3,) = list(map(int, var_20().split()))\n var_17 = [0] * var_7\n for var_11, (var_13, var_19) in enumerate(zip(*[iter(var_3)] * 2)):\n var_17[var_11] = Class_1(var_13 - 1, var_19 - 1, var_11)\n var_17.sort(key=lambda var_25: var_25.r)\n func_1(var_1, var_6, var_17, var_7)\n return\n\n\nif __name__ == \"__main__\":\n func_2()\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\n\n\nclass Class_1:\n \"\"\"\"\"\"\n\n def __init__(self, var_1):\n self.__n = len(var_1)\n self.__node = [0] * (self.__n + 1)\n self.__data = [0] * (self.__n + 1)\n var_7 = [0] * (self.__n + 1)\n for var_11 in range(1, self.__n + 1):\n var_7[var_11] = var_7[var_11 - 1] + var_1[var_11 - 1]\n self.__data[var_11] = var_1[var_11 - 1]\n self.__node[var_11] = var_7[var_11] - var_7[var_11 - (var_11 & -var_11)]\n\n def func_1(self, var_11, var_22):\n self.__data[var_11] += var_22\n while var_11 <= self.__n:\n self.__node[var_11] += var_22\n var_11 += var_11 & -var_11\n\n def func_4(self, var_11):\n \"\"\"\"\"\"\n var_19 = 0\n while var_11 > 0:\n var_19 += self.__node[var_11]\n var_11 -= var_11 & -var_11\n return var_19\n\n def func_2(self, var_11, var_12):\n \"\"\"\"\"\"\n if var_11 == var_12:\n return self.__data[var_11]\n else:\n return self.sum(var_12) - self.sum(var_11 - 1)\n\n\ndef func_3():\n var_4, var_6 = map(int, input().split())\n var_3 = list(map(int, input().split()))\n var_5 = [[] for _ in range(var_4)]\n for var_11, var_9 in enumerate(var_3):\n var_5[var_9 - 1].append(var_11)\n var_18 = [0] * var_4\n for var_14 in var_5:\n if len(var_14):\n var_18[var_14.pop()] = 1\n var_2 = Class_1(var_18)\n var_16 = [[] for _ in range(var_4)]\n for var_11, var_20 in enumerate(sys.stdin.readlines()):\n var_13, var_17 = map(int, var_20.split())\n var_16[var_17 - 1].append((var_13 - 1, var_11))\n var_8 = [None] * var_6\n var_10 = var_4 - 1\n for var_17, var_15 in enumerate(reversed(var_16)):\n var_17 = (var_4 - 1) - var_17\n while var_15:\n var_13, var_11 = var_15.pop()\n while var_17 < var_10:\n var_9 = var_3[var_10] - 1\n var_14 = var_5[var_9]\n if len(var_14):\n var_2.add(var_14.pop() + 1, 1)\n var_10 -= 1\n var_21 = var_2.get(var_13 + 1, var_17 + 1)\n var_8[var_11] = var_21\n print(*var_8, sep=\"\\n\")\n\n\nif __name__ == \"__main__\":\n func_3()\n```", "output": "FASTER 1.8099", "pair_id": "python_p02599_forward", "problem_id": "p02599", "language": "python", "direction": "forward", "speedup_ratio": 3.5063} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_4 = int(eval(input()))\nvar_2 = list(map(int, input().split()))\n\n\ndef func_1(var_1, var_8, var_3):\n if var_8 == var_4:\n var_9 = 1\n for var_5 in var_3:\n var_9 *= var_5\n return 1 if var_9 % 2 == 0 else 0\n var_6 = var_3.copy()\n var_6.append(var_1[var_8] - 1)\n var_5 = var_3.copy()\n var_5.append(var_1[var_8])\n var_7 = var_3.copy()\n var_7.append(var_1[var_8] + 1)\n return (\n func_1(var_1, var_8 + 1, var_6)\n + func_1(var_1, var_8 + 1, var_5)\n + func_1(var_1, var_8 + 1, var_7)\n )\n\n\nprint((func_1(var_2, 0, [])))\n```\n\n=== Code B (Modified) ===\n```python\nimport math\nimport string\n\n\ndef func_4():\n return list(map(int, input().split()))\n\n\ndef func_3(var_6, var_7):\n return math.factorial(var_6) // (\n math.factorial(var_6 - var_7) * math.factorial(var_7)\n )\n\n\ndef func_2(var_9):\n var_8 = []\n for var_5 in var_9:\n if not (var_5 in var_8):\n var_8.append(var_5)\n return len(var_9) != len(var_8)\n\n\ndef func_1(var_6):\n func_1 = []\n for var_4 in range(1, var_6 + 1):\n if var_6 % var_4 == 0:\n func_1.append(var_4)\n return func_1\n\n\nvar_2 = [-1, -1, -1, 0, 0, 1, 1, 1]\nvar_3 = [-1, 0, 1, -1, 1, -1, 0, 1]\nvar_6 = int(eval(input()))\nvar_1 = func_4()\nvar_10 = 1\nfor var_4 in range(len(var_1)):\n if var_1[var_4] % 2 == 0:\n var_10 *= 2\n else:\n var_10 *= 1\nprint((3 ** len(var_1) - var_10))\n```", "output": "FASTER 6.5932", "pair_id": "python_p03568_forward", "problem_id": "p03568", "language": "python", "direction": "forward", "speedup_ratio": 96.5479} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = list(reversed(list(str(var_4))))\n if var_5 == list(str(var_4)):\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_6 = str(var_4)\n var_5 = var_6[::-1]\n if var_6 == var_5:\n var_3 += 1\nprint(var_3)\n```", "output": "FASTER 1.4065", "pair_id": "python_p03416_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 2.651} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = str(var_4)\n if var_5 == var_5[::-1]:\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_3 in range(var_1, var_2 + 1):\n var_5 = list(str(var_3))\n var_6 = list(reversed(var_5))\n if var_5 == var_6:\n var_4 += 1\nprint(var_4)\n```", "output": "SLOWER 1.3131", "pair_id": "python_p03416_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 2.4848} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\nimport numpy as np\n\nvar_5 = sys.stdin.readline\n\nvar_7 = int(eval(var_5()))\n\nvar_1 = [var_5().replace(\" \", \"\") for var_4 in range(var_7)]\n\nvar_8 = [list(map(int, var_5().split())) for var_4 in range(var_7)]\n\n\nvar_12 = -999999999999999\n\nfor var_4 in range(1, 1024):\n\n var_3 = format(var_4, \"010b\")\n\n var_10 = 0\n for var_2, var_9 in zip(var_1, var_8):\n\n var_11 = 0\n for var_6 in range(10):\n\n if var_2[var_6] == \"1\" and var_3[var_6] == \"1\":\n\n var_11 += 1\n\n var_10 += var_9[var_11]\n if var_10 > var_12:\n\n var_12 = var_10\nprint(var_12)\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\n\nvar_8 = sys.stdin.readline\n\n\ndef func_1():\n var_2 = int(eval(var_8()))\n var_1 = [int(var_8().replace(\" \", \"\"), 2) for _ in range(var_2)]\n var_3 = [list(map(int, var_8().split())) for _ in range(var_2)]\n var_4 = -(10**7) * var_2\n for var_7 in range(1, 1 << 10):\n var_10 = 0\n for var_9, var_6 in enumerate(var_1):\n var_5 = bin(var_7 & var_6).count(\"1\")\n var_10 += var_3[var_9][var_5]\n var_4 = max(var_4, var_10)\n print(var_4)\n\n\nif __name__ == \"__main__\":\n func_1()\n```", "output": "FASTER 2.7422", "pair_id": "python_p03503_forward", "problem_id": "p03503", "language": "python", "direction": "forward", "speedup_ratio": 6.6909} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_6, var_7 = list(map(int, input().split()))\nvar_1 = [list(map(int, input().split())) for _ in range(var_6)]\nvar_1.sort()\nvar_3 = [(6007) * [0] for _ in range(var_6 + 1)]\nvar_3[0][0] = 0\nvar_2 = 0\nfor var_4 in range(var_6):\n for var_5 in range(6007):\n var_3[var_4 + 1][var_5] = max(var_3[var_4 + 1][var_5], var_3[var_4][var_5])\n if var_5 < var_7:\n var_3[var_4 + 1][var_5 + var_1[var_4][0]] = max(\n var_3[var_4][var_5] + var_1[var_4][1],\n var_3[var_4][var_5 + var_1[var_4][0]],\n )\n var_2 = max(var_2, var_3[var_4 + 1][var_5])\nprint(var_2)\n```\n\n=== Code B (Modified) ===\n```python\nimport bisect\nimport sys\n\nsys.setrecursionlimit(10**6)\nvar_16 = sys.stdout.write\nvar_7 = lambda *var_14: print(*var_14) if var_1 else 0\nvar_1 = True\n\n\ndef func_1(var_9=sys.stdin.readline):\n var_11 = lambda: var_9().rstrip()\n var_3 = lambda: list(map(int, var_11().split()))\n var_2 = lambda: int(var_11())\n var_4 = lambda var_17: [var_3() for _ in range(var_17)]\n var_13, var_15 = var_3()\n var_5 = var_4(var_13)\n var_5.sort()\n var_8 = [[0] * var_15 for _ in range(var_13 + 1)]\n for var_10 in range(1, var_13 + 1):\n for var_12 in range(1, var_15):\n if var_12 < var_5[var_10 - 1][0]:\n var_8[var_10][var_12] = var_8[var_10 - 1][var_12]\n else:\n var_8[var_10][var_12] = max(\n var_8[var_10 - 1][var_12],\n var_8[var_10 - 1][var_12 - var_5[var_10 - 1][0]]\n + var_5[var_10 - 1][1],\n )\n var_6 = 0\n for var_10 in range(var_13):\n var_6 = max(var_6, var_8[var_10][var_15 - 1] + var_5[var_10][1])\n print(var_6)\n\n\nif __name__ == \"__main__\":\n func_1()\n```", "output": "FASTER 6.1246", "pair_id": "python_p02863_forward", "problem_id": "p02863", "language": "python", "direction": "forward", "speedup_ratio": 69.7734} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nfrom collections import Counter\n\nvar_4 = int(eval(input()))\nvar_1 = list(map(int, input().split()))\nvar_2 = Counter(var_1)\nvar_3 = list(var_2)\nif sum(var_1) == 0:\n print(\"Yes\")\nelif len(var_1) % 3 != 0:\n print(\"No\")\nelif len(var_2) > 3 or len(var_2) <= 1:\n print(\"No\")\nelif len(var_2) == 3:\n if (\n var_2[var_3[0]] == var_4 // 3\n and var_2[var_3[1]] == var_4 // 3\n and var_2[var_3[2]] == var_4 // 3\n ):\n if var_3[0] ^ var_3[1] ^ var_3[2] == 0:\n print(\"Yes\")\n else:\n print(\"No\")\n else:\n print(\"No\")\nelse:\n var_3.sort()\n if var_3[0] == 0 and var_2[var_3[0]] == var_4 // 3:\n print(\"Yes\")\n else:\n print(\"No\")\n```\n\n=== Code B (Modified) ===\n```python\nfrom functools import *\n\n_, var_1 = open(0)\nprint(\n (\n \"YNeos\"[\n var_2(lambda var_3, var_4: var_3 ^ var_4, list(map(int, var_1.split())))\n > 0 :: 2\n ]\n )\n)\n```", "output": "FASTER 1.3002", "pair_id": "python_p02975_forward", "problem_id": "p02975", "language": "python", "direction": "forward", "speedup_ratio": 2.4627} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\n\nvar_5 = sys.stdin.readline\nif __name__ == \"__main__\":\n var_1, var_3 = var_5().split()\n var_2 = int(var_1)\n var_4 = round(float(var_3) * 100)\n print((var_2 * var_4 // 100))\n```\n\n=== Code B (Modified) ===\n```python\ndef func_1():\n from sys import setrecursionlimit, stdin\n from os import environ\n from collections import defaultdict, deque, Counter\n from math import ceil, floor, gcd\n from itertools import accumulate, combinations, combinations_with_replacement\n\n setrecursionlimit(10**6)\n var_7 = (\n (lambda *var_11: print(*var_11))\n if \"TERM_PROGRAM\" in environ\n else lambda *var_12: 0\n )\n var_8 = lambda: stdin.readline().rstrip()\n var_3 = lambda: list(map(int, var_8().split()))\n var_1 = lambda: int(var_8())\n var_4 = 10**9 + 7\n var_2 = 10**9 + 10\n var_9, var_10 = var_8().split()\n var_5 = int(var_9)\n var_6 = int(float(var_10) * 100 + 0.5)\n print(var_5 * var_6 // 100)\n\n\nfunc_1()\n```", "output": "SLOWER 1.7429", "pair_id": "python_p02659_reversed", "problem_id": "p02659", "language": "python", "direction": "reversed", "speedup_ratio": 3.347} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\n\nvar_3 = sys.stdin.readline\nif __name__ == \"__main__\":\n var_1, var_2 = var_3().split()\n print((int(var_1) * round(float(var_2) * 100) // 100))\n```\n\n=== Code B (Modified) ===\n```python\ndef func_1():\n from sys import setrecursionlimit, stdin\n from os import environ\n from collections import defaultdict, deque, Counter\n from math import ceil, floor, gcd\n from itertools import accumulate, combinations, combinations_with_replacement\n\n setrecursionlimit(10**6)\n var_7 = (\n (lambda *var_11: print(*var_11))\n if \"TERM_PROGRAM\" in environ\n else lambda *var_12: 0\n )\n var_8 = lambda: stdin.readline().rstrip()\n var_3 = lambda: list(map(int, var_8().split()))\n var_1 = lambda: int(var_8())\n var_4 = 10**9 + 7\n var_2 = 10**9 + 10\n var_9, var_10 = var_8().split()\n var_5 = int(var_9)\n var_10 = var_10.split(\".\")\n var_6 = int(var_10[0]) * 100\n if len(var_10) == 2:\n var_6 += int(var_10[1])\n print(var_5 * var_6 // 100)\n\n\nfunc_1()\n```", "output": "SLOWER 2.1103", "pair_id": "python_p02659_reversed", "problem_id": "p02659", "language": "python", "direction": "reversed", "speedup_ratio": 4.3177} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\nfrom operator import itemgetter\nfrom heapq import heapify, heappop, heappush\n\nvar_1 = int(10e15)\nvar_2 = -var_1\nvar_11 = 1000000007\nsys.setrecursionlimit(1000000)\n\n\ndef func_2():\n return list(map(int, input().split()))\n\n\ndef func_4():\n return input().split()\n\n\ndef func_1():\n return int(sys.stdin.readline())\n\n\ndef func_3():\n return eval(input())\n\n\nvar_3, var_4 = func_2()\nvar_5 = [func_2() for var_9 in range(var_3)]\nvar_5.sort(key=itemgetter(0))\n\nvar_8 = [[0] * (var_4 + 1 + 3000 + 1) for _ in range(var_3 + 1)]\nvar_6 = 0\nfor var_9 in range(var_3):\n for var_10 in range(var_4 + 1 + 3000 + 1):\n var_12, var_7 = var_5[var_9]\n if 0 <= var_10 - var_12 < var_4:\n var_8[var_9 + 1][var_10] = max(\n var_8[var_9][var_10], var_8[var_9][var_10 - var_12] + var_7\n )\n else:\n var_8[var_9 + 1][var_10] = var_8[var_9][var_10]\n var_6 = max(var_6, var_8[var_9 + 1][var_10])\nprint(var_6)\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\nfrom collections import deque\n\nvar_1 = int(10e10)\nvar_2 = -var_1\nvar_12 = 1000000007\nsys.setrecursionlimit(1000000)\n\n\ndef func_2():\n return list(map(int, input().split()))\n\n\ndef func_4():\n return input().split()\n\n\ndef func_1():\n return int(sys.stdin.readline())\n\n\ndef func_3():\n return eval(input())\n\n\nvar_3, var_4 = func_2()\nvar_6 = [func_2() for var_10 in range(var_3)]\nvar_6.sort()\nvar_7 = 0\nvar_9 = [[0] * var_4 for var_10 in range(var_3 + 1)]\nfor var_10 in range(1, var_3 + 1):\n var_5, var_8 = var_6[var_10 - 1]\n for var_11 in range(var_4):\n if 0 <= var_11 - var_5 < var_4:\n var_9[var_10][var_11] = max(\n var_9[var_10 - 1][var_11], var_9[var_10 - 1][var_11 - var_5] + var_8\n )\n else:\n var_9[var_10][var_11] = var_9[var_10 - 1][var_11]\n else:\n var_7 = max(var_7, var_9[var_10 - 1][-1] + var_8)\nprint(var_7)\n```", "output": "FASTER 4.73", "pair_id": "python_p02863_forward", "problem_id": "p02863", "language": "python", "direction": "forward", "speedup_ratio": 26.5378} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nfrom collections import deque\n\nvar_9 = deque()\nvar_11 = deque()\nvar_4 = int(eval(input()))\nvar_12 = [[] for var_13 in range(var_4 + 1)]\nvar_2 = []\nfor _ in range(var_4 - 1):\n var_5, var_6 = list(map(int, input().split()))\n var_12[var_5].append(var_6)\n var_12[var_6].append(var_5)\n var_2.append((var_5, var_6))\n\nvar_3 = 0\nvar_9.append(1)\nvar_17 = [False for var_13 in range(var_4 + 1)]\nvar_8 = [-1 for var_13 in range(var_4 + 1)]\nvar_17[1] = True\nvar_8[1] = -1\nvar_10 = {}\nwhile var_9:\n while var_9:\n var_18 = var_9.popleft()\n var_15 = var_8[var_18]\n var_7 = 1\n for var_14 in var_12[var_18]:\n if var_17[var_14] == False:\n var_17[var_14] = True\n var_11.append(var_14)\n if var_7 != var_15:\n var_8[var_14] = var_7\n var_10[(var_18, var_14)] = var_7\n elif var_7 == var_15:\n var_7 += 1\n var_8[var_14] = var_7\n var_10[(var_18, var_14)] = var_7\n var_7 += 1\n if var_11:\n var_9 = var_11\n var_11 = deque()\nvar_1 = max(var_8)\nprint(var_1)\nfor var_16 in var_2:\n var_5, var_6 = var_16\n if (var_5, var_6) in list(var_10.keys()):\n print((var_10[var_16]))\n else:\n print((var_10[(var_6, var_5)]))\n```\n\n=== Code B (Modified) ===\n```python\nimport copy\n\nvar_8 = int(eval(input()))\nvar_10 = set([var_6 for var_6 in range(1, 10**5)])\nvar_5 = []\nvar_11 = {}\nvar_9 = []\nfor var_6 in range(var_8 - 1):\n var_1, var_2 = list(map(int, input().split(\" \")))\n var_5.append([var_1, var_2])\n var_11.setdefault(var_1, []).append(var_2)\n var_9.append([])\nvar_9.append([])\nvar_9.append([])\nvar_7 = 0\nfor var_12 in range(1, var_8 + 1):\n var_14 = var_11.get(var_12, [])\n var_3 = 1\n for var_13 in var_14:\n if var_3 in var_9[var_12]:\n var_3 += 1\n else:\n pass\n var_9[var_13].append(var_3)\n if var_3 >= var_7:\n var_7 = var_3\n var_3 += 1\nprint(var_7)\nfor var_4 in var_5:\n print((var_9[var_4[1]][0]))\n```", "output": "SLOWER 3.8829", "pair_id": "python_p02850_reversed", "problem_id": "p02850", "language": "python", "direction": "reversed", "speedup_ratio": 14.7526} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_4 = str(var_4)\n if var_4[0] == var_4[-1] and var_4[1] == var_4[-2]:\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\n\n\ndef func_1(var_5):\n var_4 = 0\n for var_3 in range(1, var_5 + 1):\n if str(var_3) == str(var_3)[::-1]:\n var_4 += 1\n return var_4\n\n\nprint((func_1(var_2) - func_1(var_1 - 1)))\n```", "output": "SLOWER 1.7743", "pair_id": "python_p03416_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 3.4208} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport copy\nimport random\nimport bisect\nimport fractions\nimport math\nimport sys\nimport collections\nfrom decimal import Decimal\n\nvar_5 = 10**9 + 7\nsys.setrecursionlimit(var_5)\nvar_3 = collections.deque()\n\n\ndef func_1():\n return list(map(int, sys.stdin.readline().split()))\n\n\nvar_1 = int(eval(input()))\nvar_6 = [0 for var_4 in range(var_1)]\nfor var_4 in range(var_1):\n var_6[var_4] = int(eval(input()))\nvar_6.sort()\nvar_2 = sum(var_6)\nvar_2 -= var_6[-1] // 2\nprint(var_2)\n```\n\n=== Code B (Modified) ===\n```python\nvar_2 = int(eval(input()))\nvar_3 = [int(eval(input())) for var_1 in range(var_2)]\nprint((sum(var_3) - max(var_3) // 2))\n```", "output": "FASTER 1.0159", "pair_id": "python_p03207_forward", "problem_id": "p03207", "language": "python", "direction": "forward", "speedup_ratio": 2.0221} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_6 in range(var_1, var_2 + 1):\n var_3 = str(var_6)\n var_5 = True\n for var_7 in range(len(var_3) // 2):\n if var_3[var_7] != var_3[-var_7 - 1] and var_5:\n var_5 = not var_5\n if var_5:\n var_4 += 1\nprint(var_4)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1 = list(map(int, input().split()))\nvar_2 = 0\nfor var_3 in range(var_1[0], var_1[1] + 1):\n var_4 = str(var_3)\n if var_4[0] == var_4[4] and var_4[1] == var_4[3]:\n var_2 += 1\nprint(var_2)\n```", "output": "FASTER 1.7488", "pair_id": "python_p03416_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 3.3607} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_3 in range(var_1, var_2 + 1):\n var_5 = list(str(var_3))\n var_6 = list(reversed(var_5))\n if var_5 == var_6:\n var_4 += 1\nprint(var_4)\n```\n\n=== Code B (Modified) ===\n```python\nfrom sys import stdin\n\nvar_6 = lambda: list(map(int, stdin.readline().split()))\nvar_5 = lambda: list(map(int, stdin.readline().split()))\nvar_1, var_3 = var_6()\nvar_2 = 0\nfor var_4 in range(var_1, var_3 + 1):\n var_7 = str(var_4)\n if var_7 == var_7[::-1]:\n var_2 += 1\nprint(var_2)\n```", "output": "FASTER 1.2902", "pair_id": "python_p03416_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 2.4457} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\n\nvar_7 = sys.stdin.readline\nfrom itertools import combinations\n\n\ndef func_3(var_10):\n for _ in range(var_10):\n yield list(map(int, var_7().split()))\n\n\ndef func_1(var_9, var_5, var_11):\n var_3 = len([0 for var_8 in var_9 if var_5[var_8] == 1])\n return var_11[var_3]\n\n\ndef func_2():\n var_10 = int(eval(var_7()))\n var_1 = list(func_3(var_10))\n var_2 = list(func_3(var_10))\n for var_6 in range(1, 11):\n for var_4 in combinations(list(range(10)), var_6):\n yield sum(\n func_1(var_4, var_5, var_11) for var_5, var_11 in zip(var_1, var_2)\n )\n\n\nprint((max(func_2())))\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\nimport numpy as np\n\nvar_6 = int(eval(input()))\n\nvar_1 = [input().replace(\" \", \"\") for var_4 in range(var_6)]\n\nvar_7 = [list(map(int, input().split())) for var_4 in range(var_6)]\nvar_11 = -999999999999999\nfor var_4 in range(1, 1024):\n var_3 = format(var_4, \"010b\")\n var_9 = 0\n for var_2, var_8 in zip(var_1, var_7):\n var_10 = 0\n for var_5 in range(10):\n if var_2[var_5] == \"1\" and var_3[var_5] == \"1\":\n var_10 += 1\n var_9 += var_8[var_10]\n if var_9 > var_11:\n if var_9 == 0:\n print((str(var_4)))\n break\n var_11 = var_9\nprint(var_11)\n```", "output": "SLOWER 1.1194", "pair_id": "python_p03503_reversed", "problem_id": "p03503", "language": "python", "direction": "reversed", "speedup_ratio": 2.1726} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_4 = str(var_4)\n if var_4 == var_4[::-1]:\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\ndef func_1():\n var_1, var_2 = list(map(int, input().split()))\n var_3 = 0\n for var_4 in range(var_1, var_2 + 1):\n\n if (var_4 % 10) == (var_4 // 10000 % 10) and (var_4 // 10 % 10) == (\n var_4 // 1000 % 10\n ):\n var_3 += 1\n print(var_3)\n\n\nif __name__ == \"__main__\":\n func_1()\n```", "output": "FASTER 1.8111", "pair_id": "python_p03416_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 3.509} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\n\nvar_10 = sys.stdin.readline\nvar_4 = int(eval(var_10()))\nvar_9 = [[] for _ in range(var_4)]\nvar_3 = []\nfor _ in range(var_4 - 1):\n var_5, var_6 = list(map(int, var_10().split()))\n var_9[var_5 - 1].append(var_6 - 1)\n var_9[var_6 - 1].append(var_5 - 1)\n var_3.append((var_5 - 1, var_6 - 1))\nvar_1 = 0\nfor var_11 in range(var_4):\n var_1 = max(var_1, len(var_9[var_11]))\nvar_2 = dict()\nvar_8 = [-1] * var_4\nvar_14 = [0]\nvar_8[0] = var_1 + 1\nwhile var_14:\n var_15 = []\n for var_13 in var_14:\n var_7 = var_8[var_13]\n var_16 = 0\n for var_12 in var_9[var_13]:\n if var_8[var_12] == -1:\n if var_16 == var_7:\n var_16 += 1\n var_8[var_12] = var_16\n var_2[(var_13, var_12)] = var_16\n var_2[(var_12, var_13)] = var_16\n var_16 += 1\n var_15.append(var_12)\n var_14 = var_15\nprint(var_1)\nfor var_5, var_6 in var_3:\n print((var_2[(var_5, var_6)] + 1))\n```\n\n=== Code B (Modified) ===\n```python\nimport copy\n\nvar_8 = int(eval(input()))\nvar_10 = set([var_6 for var_6 in range(1, 10**5)])\nvar_5 = []\nvar_11 = {}\nvar_9 = []\nfor var_6 in range(var_8 - 1):\n var_1, var_2 = list(map(int, input().split(\" \")))\n var_5.append([var_1, var_2])\n var_11.setdefault(var_1, []).append(var_2)\n var_9.append([])\nvar_9.append([])\nvar_9.append([])\nvar_7 = 0\nfor var_12 in range(1, var_8 + 1):\n var_14 = var_11.get(var_12, [])\n var_3 = 1\n for var_13 in var_14:\n if var_3 in var_9[var_12]:\n var_3 += 1\n else:\n pass\n var_9[var_13].append(var_3)\n if var_3 >= var_7:\n var_7 = var_3\n var_3 += 1\nprint(var_7)\nfor var_4 in var_5:\n print((var_9[var_4[1]][0]))\n```", "output": "SLOWER 4.2291", "pair_id": "python_p02850_reversed", "problem_id": "p02850", "language": "python", "direction": "reversed", "speedup_ratio": 18.7534} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nfrom sys import stdin\n\n\ndef func_1():\n\n var_9 = stdin.readline\n var_8, var_10 = list(map(int, var_9().split()))\n var_7 = [list(map(int, var_9().split())) for _ in range(var_8)]\n var_7.sort()\n var_1 = [0] * var_8\n var_2 = [0] * var_8\n for var_4 in range(var_8):\n var_1[var_4], var_2[var_4] = var_7[var_4][0], var_7[var_4][1]\n\n var_5 = -(10**9)\n var_3 = [[var_5] * (var_10 + 1) for _ in range(var_8 + 1)]\n var_3[0][0] = 0\n for var_4 in range(var_8):\n for var_6 in range(var_10 + 1):\n\n if var_6 != var_10:\n var_3[var_4 + 1][min(var_10, var_6 + var_1[var_4])] = max(\n var_3[var_4 + 1][min(var_10, var_6 + var_1[var_4])],\n var_3[var_4][var_6] + var_2[var_4],\n )\n\n var_3[var_4 + 1][var_6] = max(var_3[var_4 + 1][var_6], var_3[var_4][var_6])\n print((max(var_3[var_8])))\n\n\nif __name__ == \"__main__\":\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\nfrom operator import itemgetter\nfrom heapq import heapify, heappop, heappush\n\nvar_1 = int(10e15)\nvar_2 = -var_1\nvar_11 = 1000000007\nsys.setrecursionlimit(1000000)\n\n\ndef func_2():\n return list(map(int, input().split()))\n\n\ndef func_4():\n return input().split()\n\n\ndef func_1():\n return int(sys.stdin.readline())\n\n\ndef func_3():\n return eval(input())\n\n\nvar_3, var_4 = func_2()\nvar_5 = [func_2() for var_9 in range(var_3)]\nvar_5.sort(key=itemgetter(0))\n\nvar_8 = [[0] * (var_4 + 1 + 3000 + 1) for _ in range(var_3 + 1)]\nvar_6 = 0\nfor var_9 in range(var_3):\n for var_10 in range(var_4 + 1 + 3000 + 1):\n var_12, var_7 = var_5[var_9]\n if 0 <= var_10 - var_12 < var_4:\n var_8[var_9 + 1][var_10] = max(\n var_8[var_9][var_10], var_8[var_9][var_10 - var_12] + var_7\n )\n else:\n var_8[var_9 + 1][var_10] = var_8[var_9][var_10]\n var_6 = max(var_6, var_8[var_9 + 1][var_10])\nprint(var_6)\n```", "output": "SLOWER 4.9179", "pair_id": "python_p02863_reversed", "problem_id": "p02863", "language": "python", "direction": "reversed", "speedup_ratio": 30.2293} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\ndef func_1():\n var_2, var_3, *var_1 = list(map(int, open(0).read().split()))\n var_4 = [0] * (var_3 + max(var_1[::2]))\n for var_7, var_6 in sorted(zip(*[iter(var_1)] * 2)):\n for var_5 in reversed(list(range(var_3))):\n var_4[var_5 + var_7] = max(var_4[var_5 + var_7], var_4[var_5] + var_6)\n print((max(var_4)))\n\n\nfunc_1()\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_6 = sorted([list(map(int, input().split())) for var_5 in range(var_1)])\n\nvar_4 = [[0] * (var_2 + 1) for var_5 in range(var_1 + 1)]\n\nfor var_5 in range(var_1):\n var_9, var_8 = var_6[var_5]\n for var_7 in range(var_2 + 1):\n if var_7 + var_9 <= var_2:\n var_4[var_5 + 1][var_7 + var_9] = max(\n var_4[var_5 + 1][var_7 + var_9], var_4[var_5][var_7] + var_8\n )\n var_4[var_5 + 1][var_7] = max(var_4[var_5][var_7], var_4[var_5 + 1][var_7])\nvar_3 = 0\nfor var_5, (var_9, var_8) in enumerate(var_6):\n for var_7 in range(var_2):\n var_3 = max(var_3, var_4[var_5][var_7] + var_8)\nprint(var_3)\n```", "output": "SLOWER 2.0608", "pair_id": "python_p02863_reversed", "problem_id": "p02863", "language": "python", "direction": "reversed", "speedup_ratio": 4.1721} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_4 = str(var_4)\n if var_4[0] == var_4[-1] and var_4[1] == var_4[-2]:\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_5 in range(10):\n for var_6 in range(10):\n for var_7 in range(10):\n var_3 = 10000 * var_5 + 1000 * var_6 + 100 * var_7 + 10 * var_6 + var_5\n if var_1 <= var_3 <= var_2:\n var_4 += 1\nprint(var_4)\n```", "output": "FASTER 3.6418", "pair_id": "python_p03416_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 12.4826} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_6 = input()[::-1]\nvar_4 = len(var_6)\nvar_2 = [0] * 2019\nvar_2[0] = 1\nvar_7 = 1\nvar_5 = 0\nvar_1 = 0\nfor var_3 in range(var_4):\n var_5 = (var_5 + int(var_6[var_3]) * var_7) % 2019\n var_7 = var_7 * 10 % 2019\n var_2[var_5] += 1\nfor var_3 in var_2:\n var_1 += var_3 * (var_3 - 1) // 2\nprint(var_1)\n```\n\n=== Code B (Modified) ===\n```python\nfrom collections import Counter\n\nvar_1 = input()[::-1]\nvar_5 = [0]\nvar_4 = 0\nvar_6 = 2019\nfor var_7 in var_1:\n var_8 = int(var_7) * pow(10, var_4, var_6) % var_6\n var_8 = var_5[-1] + var_8\n var_5.append(var_8 % var_6)\n var_4 += 1\nvar_3 = Counter(var_5)\nvar_2 = sum(var_9 * (var_9 - 1) // 2 for var_9 in list(var_3.values()))\nprint(var_2)\n```", "output": "FASTER 1.9664", "pair_id": "python_p02702_forward", "problem_id": "p02702", "language": "python", "direction": "forward", "speedup_ratio": 3.908} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n if str(var_4) == \"\".join(reversed(str(var_4))):\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\ndef func_1():\n var_1, var_2 = list(map(int, input().rstrip().split()))\n var_3 = 0\n for var_4 in range(var_1, var_2 + 1):\n var_5 = str(var_4)\n if var_5 == var_5[::-1]:\n var_3 += 1\n print(var_3)\n\n\nif __name__ == \"__main__\":\n func_1()\n```", "output": "FASTER 1.8222", "pair_id": "python_p03416_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 3.5363} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = str(var_4)\n if var_5 == var_5[::-1]:\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_6 in range(var_1, var_2 + 1):\n var_3 = str(var_6)\n var_5 = True\n for var_7 in range(len(var_3) // 2):\n if var_3[var_7] != var_3[-var_7 - 1] and var_5:\n var_5 = not var_5\n if var_5:\n var_4 += 1\nprint(var_4)\n```", "output": "SLOWER 1.4644", "pair_id": "python_p03416_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 2.7595} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().strip().split(\" \")))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n if str(var_4) == str(var_4)[::-1]:\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().rstrip().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = list(map(int, list(str(var_4))))\n if var_5[0] == var_5[4] and var_5[1] == var_5[3]:\n var_3 += 1\nprint(var_3)\n```", "output": "SLOWER 1.3757", "pair_id": "python_p03416_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 2.595} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\nfrom operator import itemgetter\nfrom heapq import heapify, heappop, heappush\n\nvar_1 = int(10e15)\nvar_2 = -var_1\nvar_11 = 1000000007\nsys.setrecursionlimit(1000000)\n\n\ndef func_2():\n return list(map(int, input().split()))\n\n\ndef func_4():\n return input().split()\n\n\ndef func_1():\n return int(sys.stdin.readline())\n\n\ndef func_3():\n return eval(input())\n\n\nvar_3, var_4 = func_2()\nvar_5 = [func_2() for var_9 in range(var_3)]\nvar_5.sort(key=itemgetter(0))\n\nvar_8 = [[0] * (var_4 + 1 + 3000 + 1) for _ in range(var_3 + 1)]\nvar_6 = 0\nfor var_9 in range(var_3):\n for var_10 in range(var_4 + 1 + 3000 + 1):\n var_12, var_7 = var_5[var_9]\n if 0 <= var_10 - var_12 < var_4:\n var_8[var_9 + 1][var_10] = max(\n var_8[var_9][var_10], var_8[var_9][var_10 - var_12] + var_7\n )\n else:\n var_8[var_9 + 1][var_10] = var_8[var_9][var_10]\n var_6 = max(var_6, var_8[var_9 + 1][var_10])\nprint(var_6)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_6 = sorted([list(map(int, input().split())) for var_5 in range(var_1)])\n\nvar_4 = [[0] * (var_2 + 1) for var_5 in range(var_1 + 1)]\n\nfor var_5 in range(var_1):\n var_9, var_8 = var_6[var_5]\n for var_7 in range(var_2 + 1):\n if var_7 + var_9 <= var_2:\n var_4[var_5 + 1][var_7 + var_9] = max(\n var_4[var_5 + 1][var_7 + var_9], var_4[var_5][var_7] + var_8\n )\n var_4[var_5 + 1][var_7] = max(var_4[var_5][var_7], var_4[var_5 + 1][var_7])\nvar_3 = 0\nfor var_5, (var_9, var_8) in enumerate(var_6):\n for var_7 in range(var_2):\n var_3 = max(var_3, var_4[var_5][var_7] + var_8)\nprint(var_3)\n```", "output": "FASTER 4.0536", "pair_id": "python_p02863_forward", "problem_id": "p02863", "language": "python", "direction": "forward", "speedup_ratio": 16.6053} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_11 = int(eval(input()))\nvar_12 = {var_8: [] for var_8 in range(1, var_11 + 1)}\nvar_19 = [False for var_8 in range(var_11 + 1)]\nvar_16 = []\nfor _ in range(var_11 - 1):\n var_2, var_3 = list(map(int, input().split()))\n var_12[var_2].append(var_3)\n var_12[var_3].append(var_2)\n var_16.append((var_2, var_3))\nvar_9 = var_16[0][0]\nvar_19[var_9] = True\nvar_6 = []\nvar_7 = []\nvar_14 = {var_8: {} for var_8 in range(1, var_11 + 1)}\nvar_10 = [0 for var_8 in range(var_11 + 1)]\n\nvar_4 = 1\nfor var_5 in var_12[var_9]:\n var_19[var_5] = True\n var_14[var_9][var_5] = var_4\n var_14[var_5][var_9] = var_4\n var_10[var_5] = var_4\n var_4 += 1\n var_6.append(var_5)\nwhile var_6:\n for var_15 in var_6:\n var_13 = 1\n for var_5 in var_12[var_15]:\n if var_19[var_5] == False:\n var_19[var_5] = True\n if var_13 != var_10[var_15]:\n var_14[var_15][var_5] = var_13\n var_14[var_5][var_15] = var_13\n var_10[var_5] = var_13\n var_13 += 1\n var_7.append(var_5)\n else:\n var_13 += 1\n var_14[var_15][var_5] = var_13\n var_14[var_5][var_15] = var_13\n var_10[var_5] = var_13\n var_13 += 1\n var_7.append(var_5)\n if var_7:\n var_6 = var_7\n var_7 = []\n else:\n var_6 = []\n var_7 = []\nvar_1 = 0\nfor var_8 in range(1, var_11 + 1):\n var_1 = max(var_1, len(var_12[var_8]))\nprint(var_1)\nfor var_8 in range(var_11 - 1):\n var_17, var_18 = var_16[var_8][0], var_16[var_8][1]\n print((var_14[var_17][var_18]))\n```\n\n=== Code B (Modified) ===\n```python\nvar_6 = int(eval(input()))\nimport sys\n\nsys.setrecursionlimit(10**6)\nvar_11 = [[] for _ in range(var_6)]\nfor var_4 in range(var_6 - 1):\n var_1, var_2 = list(map(int, input().split()))\n var_11[var_1 - 1].append((var_2 - 1, var_4))\n var_11[var_2 - 1].append((var_1 - 1, var_4))\nvar_5 = [0] * (var_6 - 1)\n\n\ndef func_1(var_8, var_10, var_9):\n var_3 = 1\n for var_7, var_4 in var_11[var_8]:\n if var_7 == var_9:\n continue\n if var_3 == var_10:\n var_3 += 1\n var_5[var_4] = var_3\n func_1(var_7, var_3, var_8)\n var_3 += 1\n\n\nfunc_1(0, -1, -1)\nprint((max(var_5)))\nfor var_4 in var_5:\n print(var_4)\n```", "output": "FASTER 1.0322", "pair_id": "python_p02850_forward", "problem_id": "p02850", "language": "python", "direction": "forward", "speedup_ratio": 2.0452} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().rstrip().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = list(map(int, list(str(var_4))))\n if var_5[0] == var_5[4] and var_5[1] == var_5[3]:\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\n\n\ndef func_1(var_5, var_6):\n var_4 = 0\n for var_3 in range(var_5, var_6 + 1):\n if str(var_3) == str(var_3)[::-1]:\n var_4 += 1\n return var_4\n\n\nprint((func_1(var_1, var_2)))\n```", "output": "FASTER 2.0067", "pair_id": "python_p03416_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 4.0185} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport copy\n\nvar_8 = int(eval(input()))\nvar_10 = set([var_6 for var_6 in range(1, 10**5)])\nvar_5 = []\nvar_11 = {}\nvar_9 = []\nfor var_6 in range(var_8 - 1):\n var_1, var_2 = list(map(int, input().split(\" \")))\n var_5.append([var_1, var_2])\n var_11.setdefault(var_1, []).append(var_2)\n var_9.append([])\nvar_9.append([])\nvar_9.append([])\nvar_7 = 0\nfor var_12 in range(1, var_8 + 1):\n var_14 = var_11.get(var_12, [])\n var_3 = 1\n for var_13 in var_14:\n if var_3 in var_9[var_12]:\n var_3 += 1\n else:\n pass\n var_9[var_13].append(var_3)\n if var_3 >= var_7:\n var_7 = var_3\n var_3 += 1\nprint(var_7)\nfor var_4 in var_5:\n print((var_9[var_4[1]][0]))\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\n\nsys.setrecursionlimit(500000)\nvar_4 = int(eval(input()))\nvar_2 = [[] for _ in range(var_4 + 1)]\nfor var_9 in range(var_4 - 1):\n var_5, var_6 = list(map(int, input().split()))\n var_2[var_5].append((var_6, var_9))\n var_2[var_6].append((var_5, var_9))\nvar_3 = max(len(var_8) for var_8 in var_2)\nprint(var_3)\nvar_1 = [-1] * (var_4 - 1)\n\n\ndef func_1(var_14=1, var_11=0, var_12=-1):\n var_7 = 1\n for var_13, var_10 in var_2[var_14]:\n if var_13 != var_11:\n if var_7 == var_12:\n var_7 += 1\n var_1[var_10] = var_7\n\n func_1(var_13, var_14, var_7)\n var_7 += 1\n\n\nfunc_1()\nprint((\"\\n\".join(map(str, var_1))))\n```", "output": "FASTER 4.54", "pair_id": "python_p02850_forward", "problem_id": "p02850", "language": "python", "direction": "forward", "speedup_ratio": 23.264} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nfrom sys import stdin\n\n\ndef func_1():\n\n var_11 = stdin.readline\n var_2 = int(var_11())\n var_1 = []\n for var_6 in range(var_2):\n var_5 = int(\"\".join(var_11().strip().split(\" \")), 2)\n var_1.append(var_5)\n var_3 = []\n for var_6 in range(var_2):\n var_10 = list(map(int, var_11().split()))\n var_3.append(var_10)\n var_8 = float(\"-inf\")\n for var_9 in range(1, 1 << 10):\n var_12 = 0\n for var_7 in range(var_2):\n var_4 = bin(var_9 & var_1[var_7]).count(\"1\")\n var_12 += var_3[var_7][var_4]\n var_8 = max(var_12, var_8)\n print(var_8)\n\n\nif __name__ == \"__main__\":\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\nimport itertools\n\n\ndef func_2(var_4):\n return eval(\"0b\" + var_4)\n\n\ndef func_1():\n var_4 = int(sys.stdin.readline().rstrip())\n var_9 = [\n func_2(\"\".join(str(var_10) for var_10 in sys.stdin.readline().split()))\n for _ in range(var_4)\n ]\n var_8 = [\n [int(var_10) for var_10 in sys.stdin.readline().split()] for _ in range(var_4)\n ]\n var_3 = -(10**10)\n for var_6 in itertools.product(\"01\", repeat=10):\n var_6 = func_2(\"\".join(var_6))\n if var_6 == 0:\n continue\n var_7 = 0\n for var_2 in range(var_4):\n var_1 = var_9[var_2]\n var_5 = bin(var_1 & var_6).count(\"1\")\n var_7 += var_8[var_2][var_5]\n var_3 = max(var_3, var_7)\n print(var_3)\n\n\nif __name__ == \"__main__\":\n\n func_1()\n```", "output": "SLOWER 3.2765", "pair_id": "python_p03503_reversed", "problem_id": "p03503", "language": "python", "direction": "reversed", "speedup_ratio": 9.6901} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_5 = 0\nif var_5 == 0:\n var_8 = int(eval(input()))\n var_2 = []\n for var_4 in range(var_8):\n var_3 = list(map(int, input().split()))\n var_2.append(var_3)\n var_9 = []\n for var_4 in range(var_8):\n var_10 = list(map(int, input().split()))\n var_9.append(var_10)\nelif var_5 == 1:\n var_8 = 1\n var_2 = [[1, 1, 0, 1, 0, 0, 0, 1, 0, 1]]\n var_9 = [[3, 4, 5, 6, 7, 8, 9, -2, -3, 4, -2]]\nelif var_5 == 2:\n var_8 = 2\n var_2 = [[1, 1, 1, 1, 1, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 1, 1, 1, 1, 1]]\n var_9 = [\n [0, -2, -2, -2, -2, -2, -1, -1, -1, -1, -1],\n [0, -2, -2, -2, -2, -2, -1, -1, -1, -1, -1],\n ]\nelif var_5 == 3:\n var_8 = 3\n var_2 = [\n [1, 1, 1, 1, 1, 1, 0, 0, 1, 1],\n [0, 1, 0, 1, 1, 1, 1, 0, 1, 0],\n [1, 0, 1, 1, 0, 1, 0, 1, 0, 1],\n ]\n var_9 = [\n [-8, 6, -2, -8, -8, 4, 8, 7, -6, 2, 2],\n [-9, 2, 0, 1, 7, -5, 0, -2, -6, 5, 5],\n [6, -6, 7, -9, 6, -5, 8, 0, -9, -7, -7],\n ]\nimport itertools\n\nvar_13 = -(10**11)\nfor var_4 in itertools.product([0, 1], repeat=10):\n var_11 = list(var_4)\n var_12 = 0\n if sum(var_11) != 0:\n for var_7 in range(var_8):\n var_1 = 0\n for var_6 in range(10):\n var_1 = var_1 + var_11[var_6] * var_2[var_7][var_6]\n var_12 = var_12 + var_9[var_7][var_1]\n\n var_13 = max(var_12, var_13)\nprint(var_13)\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\n\nvar_8 = sys.stdin.readline\n\n\ndef func_1():\n var_2 = int(eval(var_8()))\n var_1 = []\n for _ in range(var_2):\n var_1.append(list(map(int, var_8().split())))\n var_3 = []\n for _ in range(var_2):\n var_3.append(list(map(int, var_8().split())))\n var_4 = -(10**7) * var_2\n for var_7 in range(1, 1 << 10):\n var_11 = 0\n for var_10, var_6 in enumerate(var_1):\n var_5 = 0\n for var_9 in range(10):\n if (var_7 >> var_9) & 1 & var_6[var_9]:\n var_5 += 1\n var_11 += var_3[var_10][var_5]\n var_4 = max(var_4, var_11)\n print(var_4)\n\n\nif __name__ == \"__main__\":\n func_1()\n```", "output": "FASTER 1.363", "pair_id": "python_p03503_forward", "problem_id": "p03503", "language": "python", "direction": "forward", "speedup_ratio": 2.5722} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = input().split()\nvar_1 = int(var_1)\nvar_2 = int(var_2.replace(\".\", \"\"))\nprint((var_1 * var_2 // 100))\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\nimport math\nfrom collections import defaultdict\nfrom bisect import bisect_left, bisect_right\n\nsys.setrecursionlimit(10**7)\n\n\ndef func_4():\n return sys.stdin.readline()[:-1]\n\n\nvar_4 = 10**9 + 7\n\n\ndef func_1():\n return int(eval(func_4()))\n\n\ndef func_2():\n return list(map(int, func_4().split()))\n\n\ndef func_3(var_6, var_3):\n if var_6 <= 0:\n return [[] for _ in range(var_3)]\n elif var_3 == 1:\n return [func_1() for _ in range(var_6)]\n else:\n var_5 = [func_2() for _ in range(var_6)]\n return list(map(list, list(zip(*var_5))))\n\n\nfrom decimal import getcontext, Decimal\n\ngetcontext().prec = 28\nvar_1, var_2 = list(map(str, func_4().split()))\nvar_1 = int(var_1)\nvar_2 = Decimal(var_2)\nprint((int(var_1 * var_2)))\n```", "output": "SLOWER 2.5637", "pair_id": "python_p02659_reversed", "problem_id": "p02659", "language": "python", "direction": "reversed", "speedup_ratio": 5.9123} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().strip().split(\" \")))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n if str(var_4) == str(var_4)[::-1]:\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_4 = {}\nvar_5 = 0\nfor var_6 in range(10000, 100000):\n var_3 = list(str(var_6))\n if var_3 == list(reversed(var_3)):\n var_5 += 1\n var_4[var_6] = var_5\nvar_1, var_2 = list(map(int, input().split()))\nprint((var_4[var_2] - var_4[var_1 - 1] if var_1 > 10000 else var_4[var_2]))\n```", "output": "SLOWER 3.2663", "pair_id": "python_p03416_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 9.622} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nfrom sys import stdin\n\nvar_6 = lambda: list(map(int, stdin.readline().split()))\nvar_5 = lambda: list(map(int, stdin.readline().split()))\nvar_1, var_3 = var_6()\nvar_2 = 0\nfor var_4 in range(var_1, var_3 + 1):\n var_7 = str(var_4)\n if var_7 == var_7[::-1]:\n var_2 += 1\nprint(var_2)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = list(str(var_4))\n if var_5 == list(reversed(var_5)):\n var_3 += 1\nprint(var_3)\n```", "output": "SLOWER 1.2138", "pair_id": "python_p03416_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 2.3194} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport copy\n\nvar_8 = int(eval(input()))\nvar_10 = set([var_6 for var_6 in range(1, 10**5)])\nvar_5 = []\nvar_11 = {}\nvar_9 = []\nfor var_6 in range(var_8 - 1):\n var_1, var_2 = list(map(int, input().split(\" \")))\n var_5.append([var_1, var_2])\n var_11.setdefault(var_1, []).append(var_2)\n var_9.append([])\nvar_9.append([])\nvar_9.append([])\nvar_7 = 0\nfor var_12 in range(1, var_8 + 1):\n var_14 = var_11.get(var_12, [])\n var_3 = 1\n for var_13 in var_14:\n if var_3 in var_9[var_12]:\n var_3 += 1\n else:\n pass\n var_9[var_13].append(var_3)\n if var_3 >= var_7:\n var_7 = var_3\n var_3 += 1\nprint(var_7)\nfor var_4 in var_5:\n print((var_9[var_4[1]][0]))\n```\n\n=== Code B (Modified) ===\n```python\n\"\"\"\"\"\"\n\nfrom collections import deque\n\n\ndef func_1():\n var_5, *var_1 = list(map(int, open(0).read().split()))\n var_2 = var_1[1::2]\n var_4 = [[] for _ in range(var_5 + 1)]\n for var_7, var_8 in zip(*[iter(var_1)] * 2):\n var_4[var_7].append(var_8)\n var_6 = deque([1])\n var_3 = [0] * (var_5 + 1)\n while var_6:\n var_11 = var_6.popleft()\n var_9 = 0\n for var_10 in var_4[var_11]:\n var_9 += 1 + (var_9 + 1 == var_3[var_11])\n var_3[var_10] = var_9\n var_6.append(var_10)\n print((max(var_3)))\n for var_8 in var_2:\n print((var_3[var_8]))\n\n\nfunc_1()\n```", "output": "FASTER 4.6186", "pair_id": "python_p02850_forward", "problem_id": "p02850", "language": "python", "direction": "forward", "speedup_ratio": 24.5662} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nfrom itertools import product\n\nvar_6 = int(eval(input()))\nvar_1 = list(map(int, input().split()))\nvar_5 = 0\nfor var_2 in product((-1, 0, 1), repeat=var_6):\n var_7 = 1\n for var_3, var_4 in zip(var_1, var_2):\n var_7 *= var_3 + var_4\n if var_7 % 2 == 0:\n var_5 += 1\nprint(var_5)\n```\n\n=== Code B (Modified) ===\n```python\nvar_4 = int(eval(input()))\nvar_2 = list(map(int, input().split()))\n\n\ndef func_1(var_1, var_8, var_3):\n if var_8 == var_4:\n var_9 = 1\n for var_5 in var_3:\n var_9 *= var_5\n return 1 if var_9 % 2 == 0 else 0\n var_6 = var_3.copy()\n var_6.append(var_1[var_8] - 1)\n var_5 = var_3.copy()\n var_5.append(var_1[var_8])\n var_7 = var_3.copy()\n var_7.append(var_1[var_8] + 1)\n return (\n func_1(var_1, var_8 + 1, var_6)\n + func_1(var_1, var_8 + 1, var_5)\n + func_1(var_1, var_8 + 1, var_7)\n )\n\n\nprint((func_1(var_2, 0, [])))\n```", "output": "FASTER 1.7458", "pair_id": "python_p03568_forward", "problem_id": "p03568", "language": "python", "direction": "forward", "speedup_ratio": 3.3539} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2, var_3 = list(map(int, input().split()))\nvar_4 = list(map(int, input().split()))\nvar_6 = list(map(int, input().split()))\nvar_5 = min(var_4) + min(var_6)\nfor var_7 in range(var_3):\n var_9, var_10, var_11 = list(map(int, input().split()))\n var_8 = var_4[var_9 - 1] + var_6[var_10 - 1] - var_11\n var_5 = var_8 if var_8 < var_5 else var_5\nprint(var_5)\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\nfrom collections import Counter\n\n\ndef func_9():\n return sys.stdin.readline().strip()\n\n\ndef func_10(var_8, var_9, var_10):\n return [[var_10] * var_9 for var_13 in range(var_8)]\n\n\ndef func_11(var_8, var_9, var_10, var_11):\n return [[[var_11] * var_10 for var_14 in range(var_9)] for var_13 in range(var_8)]\n\n\ndef func_12(var_8, var_9, var_10, var_11, var_12):\n return [\n [[[var_12] * var_11 for var_14 in range(var_10)] for var_14 in range(var_9)]\n for var_13 in range(var_8)\n ]\n\n\ndef func_8(var_16, var_17=1):\n return int(-(-var_16 // var_17))\n\n\ndef func_1():\n return int(eval(func_9()))\n\n\ndef func_3():\n return list(map(int, func_9().split()))\n\n\ndef func_2(var_7=None):\n return list(func_3()) if var_7 is None else [func_1() for var_13 in range(var_7)]\n\n\ndef func_7():\n print(\"Yes\")\n\n\ndef func_5():\n print(\"No\")\n\n\ndef func_6():\n print(\"YES\")\n\n\ndef func_4():\n print(\"NO\")\n\n\nsys.setrecursionlimit(10**9)\nvar_3 = 10**18\nvar_6 = 10**9 + 7\nvar_7, var_5, var_4 = func_3()\nvar_1 = func_2()\nvar_2 = func_2()\nvar_15 = min(var_1) + min(var_2)\nfor _ in range(var_4):\n var_16, var_17, var_10 = func_3()\n var_16 -= 1\n var_17 -= 1\n var_15 = min(var_15, var_1[var_16] + var_2[var_17] - var_10)\nprint(var_15)\n```", "output": "SLOWER 1.8148", "pair_id": "python_p02748_reversed", "problem_id": "p02748", "language": "python", "direction": "reversed", "speedup_ratio": 3.5181} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport copy\n\nvar_8 = int(eval(input()))\nvar_10 = set([var_6 for var_6 in range(1, 10**5)])\nvar_5 = []\nvar_11 = {}\nvar_9 = []\nfor var_6 in range(var_8 - 1):\n var_1, var_2 = list(map(int, input().split(\" \")))\n var_5.append([var_1, var_2])\n var_11.setdefault(var_1, []).append(var_2)\n var_9.append([])\nvar_9.append([])\nvar_9.append([])\nvar_7 = 0\nfor var_12 in range(1, var_8 + 1):\n var_14 = var_11.get(var_12, [])\n var_3 = 1\n for var_13 in var_14:\n if var_3 in var_9[var_12]:\n var_3 += 1\n else:\n pass\n var_9[var_13].append(var_3)\n if var_3 >= var_7:\n var_7 = var_3\n var_3 += 1\nprint(var_7)\nfor var_4 in var_5:\n print((var_9[var_4[1]][0]))\n```\n\n=== Code B (Modified) ===\n```python\nvar_8 = int(eval(input()))\nvar_6 = []\nfor var_7 in range(var_8 - 1):\n var_1, var_3 = list(map(int, input().split()))\n var_6.append([var_1 - 1, var_3 - 1, var_7])\nvar_6.sort()\nvar_12 = [0] * (var_8)\nvar_2 = [0] * (var_8 - 1)\nvar_9 = 1\nvar_10 = 0\nfor var_5 in var_6:\n _from, var_11, var_7 = var_5\n if _from != var_10:\n var_9 = 1\n if var_12[_from] == var_9:\n var_9 += 1\n var_2[var_7] = var_9\n var_12[var_11] = var_9\n var_9 += 1\n var_10 = _from\nprint((max(var_2)))\nfor var_4 in var_2:\n print(var_4)\n```", "output": "FASTER 4.8668", "pair_id": "python_p02850_forward", "problem_id": "p02850", "language": "python", "direction": "forward", "speedup_ratio": 29.178} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_4 = int(eval(input()))\nvar_2 = list(map(int, input().split()))\n\n\ndef func_1(var_1, var_8, var_3):\n if var_8 == var_4:\n var_9 = 1\n for var_5 in var_3:\n var_9 *= var_5\n return 1 if var_9 % 2 == 0 else 0\n var_6 = var_3.copy()\n var_6.append(var_1[var_8] - 1)\n var_5 = var_3.copy()\n var_5.append(var_1[var_8])\n var_7 = var_3.copy()\n var_7.append(var_1[var_8] + 1)\n return (\n func_1(var_1, var_8 + 1, var_6)\n + func_1(var_1, var_8 + 1, var_5)\n + func_1(var_1, var_8 + 1, var_7)\n )\n\n\nprint((func_1(var_2, 0, [])))\n```\n\n=== Code B (Modified) ===\n```python\nvar_2 = int(eval(input()))\nvar_1 = list(map(int, input().split()))\nvar_4 = 1\nfor var_3 in range(var_2):\n if var_1[var_3] % 2 == 0:\n var_4 *= 2\nprint((3**var_2 - var_4))\n```", "output": "FASTER 8.3009", "pair_id": "python_p03568_forward", "problem_id": "p03568", "language": "python", "direction": "forward", "speedup_ratio": 315.3596} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\n\n\ndef func_1(var_5):\n var_4 = 0\n for var_3 in range(1, var_5 + 1):\n if str(var_3) == str(var_3)[::-1]:\n var_4 += 1\n return var_4\n\n\nprint((func_1(var_2) - func_1(var_1 - 1)))\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = [\n var_3 for var_3 in map(str, list(range(var_1, var_2 + 1))) if var_3 == var_3[::-1]\n]\nprint((len(var_4)))\n```", "output": "FASTER 2.2892", "pair_id": "python_p03416_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 4.8878} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nfrom functools import reduce\nfrom itertools import product\n\nvar_2 = int(eval(input()))\n(*var_1,) = list(map(int, input().split()))\nvar_4 = 0\nfor var_7 in product([-1, 0, 1], repeat=var_2):\n var_6 = reduce(\n lambda var_8, var_9: var_8 * var_9,\n [var_3 + var_7[var_5] for var_5, var_3 in enumerate(var_1)],\n )\n if var_6 % 2 == 0:\n var_4 += 1\nprint(var_4)\n```\n\n=== Code B (Modified) ===\n```python\nvar_4 = int(eval(input()))\nvar_2 = list(map(int, input().split()))\n\n\ndef func_1(var_1, var_8, var_3):\n if var_8 == var_4:\n var_9 = 1\n for var_5 in var_3:\n var_9 *= var_5\n return 1 if var_9 % 2 == 0 else 0\n var_6 = var_3.copy()\n var_6.append(var_1[var_8] - 1)\n var_5 = var_3.copy()\n var_5.append(var_1[var_8])\n var_7 = var_3.copy()\n var_7.append(var_1[var_8] + 1)\n return (\n func_1(var_1, var_8 + 1, var_6)\n + func_1(var_1, var_8 + 1, var_5)\n + func_1(var_1, var_8 + 1, var_7)\n )\n\n\nprint((func_1(var_2, 0, [])))\n```", "output": "FASTER 1.4753", "pair_id": "python_p03568_forward", "problem_id": "p03568", "language": "python", "direction": "forward", "speedup_ratio": 2.7805} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\ndef func_1():\n var_2 = int(eval(input()))\n var_1 = [int(var_6) for var_6 in input().split()]\n var_4 = 3**var_2\n var_5 = len([var_3 for var_3 in var_1 if var_3 % 2 == 0])\n var_4 -= 2**var_5\n print(var_4)\n\n\nif __name__ == \"__main__\":\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nvar_4 = int(eval(input()))\nvar_2 = list(map(int, input().split()))\n\n\ndef func_1(var_1, var_8, var_3):\n if var_8 == var_4:\n var_9 = 1\n for var_5 in var_3:\n var_9 *= var_5\n return 1 if var_9 % 2 == 0 else 0\n var_6 = var_3.copy()\n var_6.append(var_1[var_8] - 1)\n var_5 = var_3.copy()\n var_5.append(var_1[var_8])\n var_7 = var_3.copy()\n var_7.append(var_1[var_8] + 1)\n return (\n func_1(var_1, var_8 + 1, var_6)\n + func_1(var_1, var_8 + 1, var_5)\n + func_1(var_1, var_8 + 1, var_7)\n )\n\n\nprint((func_1(var_2, 0, [])))\n```", "output": "SLOWER 7.7739", "pair_id": "python_p03568_reversed", "problem_id": "p03568", "language": "python", "direction": "reversed", "speedup_ratio": 218.8599} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\ndef func_1():\n var_1, var_2 = list(map(int, input().split()))\n var_3 = 0\n for var_4 in range(var_1, var_2 + 1):\n\n if (var_4 % 10) == (var_4 // 10000 % 10) and (var_4 // 10 % 10) == (\n var_4 // 1000 % 10\n ):\n var_3 += 1\n print(var_3)\n\n\nif __name__ == \"__main__\":\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = list(str(var_4))\n if var_5 == list(reversed(var_5)):\n var_3 += 1\nprint(var_3)\n```", "output": "SLOWER 2.8962", "pair_id": "python_p03416_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 7.4448} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_10 = []\nvar_10 = input().rstrip().split(\" \")\nvar_1 = int(var_10[0])\nvar_3 = int(var_10[1])\nvar_2 = 0\nvar_6 = var_1\nwhile var_6 <= var_3:\n var_4 = var_6 // 10000\n var_5 = (var_6 - var_4 * 10000) // 1000\n var_7 = var_6 // 100\n var_8 = (var_6 - var_7 * 100) // 10\n var_9 = var_6 % 10\n if (var_4 == var_9) and (var_5 == var_8):\n var_2 += 1\n var_6 += 1\nprint(var_2)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1 = list(map(int, input().split()))\nvar_2 = 0\nfor var_3 in range(var_1[0], var_1[1] + 1):\n var_4 = str(var_3)\n if var_4[0] == var_4[4] and var_4[1] == var_4[3]:\n var_2 += 1\nprint(var_2)\n```", "output": "FASTER 1.0978", "pair_id": "python_p03416_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 2.1403} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\n\n\ndef func_1(var_5, var_6):\n var_4 = 0\n for var_3 in range(var_5, var_6 + 1):\n if str(var_3) == str(var_3)[::-1]:\n var_4 += 1\n return var_4\n\n\nprint((func_1(var_1, var_2)))\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = [0] * (var_2 + 1)\nfor var_3 in range(1, var_2 + 1):\n if str(var_3) == str(var_3)[::-1]:\n var_4[var_3] = var_4[var_3 - 1] + 1\n else:\n var_4[var_3] = var_4[var_3 - 1]\nprint((var_4[var_2] - var_4[var_1 - 1]))\n```", "output": "SLOWER 2.2659", "pair_id": "python_p03416_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 4.8095} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_10 = []\nvar_10 = input().rstrip().split(\" \")\nvar_1 = int(var_10[0])\nvar_3 = int(var_10[1])\nvar_2 = 0\nvar_6 = var_1\nwhile var_6 <= var_3:\n var_4 = var_6 // 10000\n var_5 = (var_6 - var_4 * 10000) // 1000\n var_7 = var_6 // 100\n var_8 = (var_6 - var_7 * 100) // 10\n var_9 = var_6 % 10\n if (var_4 == var_9) and (var_5 == var_8):\n var_2 += 1\n var_6 += 1\nprint(var_2)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = [\n var_3 for var_3 in map(str, list(range(var_1, var_2 + 1))) if var_3 == var_3[::-1]\n]\nprint((len(var_4)))\n```", "output": "FASTER 1.5076", "pair_id": "python_p03416_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 2.8433} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_5 in range(10):\n for var_6 in range(10):\n for var_7 in range(10):\n var_3 = 10000 * var_5 + 1000 * var_6 + 100 * var_7 + 10 * var_6 + var_5\n if var_1 <= var_3 <= var_2:\n var_4 += 1\nprint(var_4)\n```\n\n=== Code B (Modified) ===\n```python\ndef func_1():\n var_1, var_2 = list(map(int, input().rstrip().split()))\n var_3 = 0\n for var_4 in range(var_1, var_2 + 1):\n var_5 = str(var_4)\n if var_5 == var_5[::-1]:\n var_3 += 1\n print(var_3)\n\n\nif __name__ == \"__main__\":\n func_1()\n```", "output": "SLOWER 3.0796", "pair_id": "python_p03416_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 8.4536} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n if list(str(var_4)) == list(reversed(str(var_4))):\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\ndef func_1():\n var_1, var_2 = list(map(int, input().split()))\n var_3 = 0\n for var_4 in range(var_1, var_2 + 1):\n\n if (var_4 % 10) == (var_4 // 10000 % 10) and (var_4 // 10 % 10) == (\n var_4 // 1000 % 10\n ):\n var_3 += 1\n print(var_3)\n\n\nif __name__ == \"__main__\":\n func_1()\n```", "output": "FASTER 3.0644", "pair_id": "python_p03416_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 8.3652} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_5 in range(var_1, var_2 + 1):\n var_3 = str(var_5)\n if var_3[0] == var_3[-1] and var_3[1] == var_3[-2]:\n var_4 += 1\nprint(var_4)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_5 in range(10):\n for var_6 in range(10):\n for var_7 in range(10):\n var_3 = 10000 * var_5 + 1000 * var_6 + 100 * var_7 + 10 * var_6 + var_5\n if var_1 <= var_3 <= var_2:\n var_4 += 1\nprint(var_4)\n```", "output": "FASTER 3.734", "pair_id": "python_p03416_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 13.3058} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().strip().split(\" \")))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n if str(var_4) == str(var_4)[::-1]:\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\n\n\ndef func_1(var_5):\n var_4 = 0\n for var_3 in range(1, var_5 + 1):\n if str(var_3) == str(var_3)[::-1]:\n var_4 += 1\n return var_4\n\n\nprint((func_1(var_2) - func_1(var_1 - 1)))\n```", "output": "SLOWER 1.2833", "pair_id": "python_p03416_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 2.434} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_5 in range(10):\n for var_6 in range(10):\n for var_7 in range(10):\n var_3 = 10000 * var_5 + 1000 * var_6 + 100 * var_7 + 10 * var_6 + var_5\n if var_1 <= var_3 <= var_2:\n var_4 += 1\nprint(var_4)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = input().split()\nvar_1 = int(var_1)\nvar_2 = int(var_2)\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = list(str(var_4))\n if (var_5[0] == var_5[4]) and (var_5[1] == var_5[3]):\n var_3 = var_3 + 1\nprint(var_3)\n```", "output": "SLOWER 4.2299", "pair_id": "python_p03416_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 18.7637} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_6 = str(var_4)\n var_5 = var_6[::-1]\n if var_6 == var_5:\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = list(reversed(list(str(var_4))))\n if var_5 == list(str(var_4)):\n var_3 += 1\nprint(var_3)\n```", "output": "SLOWER 1.4065", "pair_id": "python_p03416_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 2.651} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_6 = str(var_4)\n var_5 = var_6[::-1]\n if var_6 == var_5:\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_3 = list(map(int, input().split()))\nvar_2 = 0\nfor var_5 in range(var_3 + 1)[var_1:]:\n if len(str(var_5)) % 2 == 0:\n var_6 = list(str(var_5))[: len(str(var_5)) // 2]\n var_7 = list(reversed(list(str(var_5))[len(str(var_5)) // 2 :]))\n if var_6 == var_7:\n var_2 += 1\n else:\n var_8 = list(str(var_5))[: len(str(var_5)) // 2 + 1]\n var_4 = list(reversed(list(str(var_5))[len(str(var_5)) // 2 :]))\n if var_8 == var_4:\n var_2 += 1\nprint(var_2)\n```", "output": "SLOWER 2.2242", "pair_id": "python_p03416_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 4.6724} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_4 = {}\nvar_5 = 0\nfor var_6 in range(10000, 100000):\n var_3 = list(str(var_6))\n if var_3 == list(reversed(var_3)):\n var_5 += 1\n var_4[var_6] = var_5\nvar_1, var_2 = list(map(int, input().split()))\nprint((var_4[var_2] - var_4[var_1 - 1] if var_1 > 10000 else var_4[var_2]))\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().rstrip().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = list(map(int, list(str(var_4))))\n if var_5[0] == var_5[4] and var_5[1] == var_5[3]:\n var_3 += 1\nprint(var_3)\n```", "output": "FASTER 1.8906", "pair_id": "python_p03416_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 3.7079} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\nfrom collections import deque\nimport numpy as np\n\n\ndef func_1():\n var_7 = int(sys.stdin.readline().rstrip())\n var_3 = np.array(sys.stdin.read().split(), dtype=np.int64).reshape(-1, 2)\n var_1 = [[] for _ in range(var_7 + 1)]\n for var_2, var_4 in var_3:\n var_1[var_2].append(var_4)\n var_1[var_4].append(var_2)\n var_9 = np.zeros(var_7 + 1, dtype=np.int64)\n var_6 = np.zeros(var_7 + 1, dtype=np.int64)\n var_10 = deque([1])\n while var_10:\n var_11 = var_10.popleft()\n var_8 = var_6[var_11]\n var_5 = 1\n for var_12 in var_1[var_11]:\n if var_12 == var_9[var_11]:\n continue\n var_9[var_12] = var_11\n if var_5 == var_8:\n var_5 += 1\n var_6[var_12] = var_5\n var_10.append(var_12)\n var_5 += 1\n print((np.amax(var_6)))\n for var_2, var_4 in var_3:\n if var_2 == var_9[var_4]:\n print((var_6[var_4]))\n else:\n print((var_6[var_2]))\n\n\nif __name__ == \"__main__\":\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nimport copy\n\nvar_8 = int(eval(input()))\nvar_10 = set([var_6 for var_6 in range(1, 10**5)])\nvar_5 = []\nvar_11 = {}\nvar_9 = []\nfor var_6 in range(var_8 - 1):\n var_1, var_2 = list(map(int, input().split(\" \")))\n var_5.append([var_1, var_2])\n var_11.setdefault(var_1, []).append(var_2)\n var_9.append([])\nvar_9.append([])\nvar_9.append([])\nvar_7 = 0\nfor var_12 in range(1, var_8 + 1):\n var_14 = var_11.get(var_12, [])\n var_3 = 1\n for var_13 in var_14:\n if var_3 in var_9[var_12]:\n var_3 += 1\n else:\n pass\n var_9[var_13].append(var_3)\n if var_3 >= var_7:\n var_7 = var_3\n var_3 += 1\nprint(var_7)\nfor var_4 in var_5:\n print((var_9[var_4[1]][0]))\n```", "output": "SLOWER 4.2049", "pair_id": "python_p02850_reversed", "problem_id": "p02850", "language": "python", "direction": "reversed", "speedup_ratio": 18.4421} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nfrom sys import stdin\n\nvar_6 = lambda: list(map(int, stdin.readline().split()))\nvar_5 = lambda: list(map(int, stdin.readline().split()))\nvar_1, var_3 = var_6()\nvar_2 = 0\nfor var_4 in range(var_1, var_3 + 1):\n var_7 = str(var_4)\n if var_7 == var_7[::-1]:\n var_2 += 1\nprint(var_2)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n if str(var_4) == \"\".join(reversed(str(var_4))):\n var_3 += 1\nprint(var_3)\n```", "output": "SLOWER 1.0578", "pair_id": "python_p03416_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 2.0818} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\n\nvar_8 = sys.stdin.readline\n\n\ndef func_1():\n var_2 = int(eval(var_8()))\n var_1 = [int(var_8().replace(\" \", \"\"), 2) for _ in range(var_2)]\n var_3 = [list(map(int, var_8().split())) for _ in range(var_2)]\n var_4 = -(10**7) * var_2\n for var_7 in range(1, 1 << 10):\n var_10 = 0\n for var_9, var_6 in enumerate(var_1):\n var_5 = bin(var_7 & var_6).count(\"1\")\n var_10 += var_3[var_9][var_5]\n var_4 = max(var_4, var_10)\n print(var_4)\n\n\nif __name__ == \"__main__\":\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nvar_8 = int(eval(input()))\nvar_4 = []\nfor var_5 in range(var_8):\n var_11 = 0\n var_9 = list(map(int, input().split()))\n for var_6 in range(10):\n var_11 += var_9[var_6] << var_6\n var_4.append(var_11)\nvar_10 = []\nfor var_5 in range(var_8):\n var_10.append(list(map(int, input().split())))\nvar_1 = -(10**12)\nfor var_5 in range(1, 1 << 10):\n var_11 = 0\n for var_6 in range(var_8):\n var_3 = var_4[var_6] & var_5\n var_2 = 0\n for var_7 in range(10):\n if (var_3 >> var_7) % 2:\n var_2 += 1\n var_11 += var_10[var_6][var_2]\n var_1 = max(var_1, var_11)\nprint(var_1)\n```", "output": "SLOWER 2.5749", "pair_id": "python_p03503_reversed", "problem_id": "p03503", "language": "python", "direction": "reversed", "speedup_ratio": 5.9584} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\ndef func_1():\n var_1, var_2 = list(map(int, input().split()))\n var_3 = 0\n for var_4 in range(var_1, var_2 + 1):\n\n if (var_4 % 10) == (var_4 // 10000 % 10) and (var_4 // 10 % 10) == (\n var_4 // 1000 % 10\n ):\n var_3 += 1\n print(var_3)\n\n\nif __name__ == \"__main__\":\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().rstrip().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = list(map(int, list(str(var_4))))\n if var_5[0] == var_5[4] and var_5[1] == var_5[3]:\n var_3 += 1\nprint(var_3)\n```", "output": "SLOWER 3.3471", "pair_id": "python_p03416_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 10.1758} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_5 in range(var_1, var_2 + 1):\n var_3 = str(var_5)\n if var_3[0] == var_3[-1] and var_3[1] == var_3[-2]:\n var_4 += 1\nprint(var_4)\n```\n\n=== Code B (Modified) ===\n```python\nvar_4, var_3 = list(map(int, input().split()))\nvar_1 = 0\nfor var_2 in range(var_4, var_3 + 1):\n if str(var_2)[0] + str(var_2)[1] == str(var_2)[-1] + str(var_2)[-2]:\n var_1 += 1\nprint(var_1)\n```", "output": "SLOWER 1.4327", "pair_id": "python_p03416_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 2.6995} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport numpy as np\n\nvar_7 = input()[::-1]\nvar_6 = len(var_7)\nvar_1 = np.zeros(var_6, dtype=int)\nvar_4 = np.zeros(var_6, dtype=int)\nvar_2 = np.zeros(2019, dtype=int)\nvar_8 = 10\nvar_1[0] = int(var_7[0])\nvar_4[0] = var_1[0]\nvar_2[var_4[0]] += 1\nfor var_5 in range(1, var_6):\n var_1[var_5] = int(var_7[var_5]) * var_8 % 2019\n var_4[var_5] = (var_4[var_5 - 1] + var_1[var_5]) % 2019\n var_2[var_4[var_5]] += 1\n var_8 = var_8 * 10 % 2019\nvar_3 = var_2[np.nonzero(var_2)]\nprint(\n (\n int(\n sum([var_3[var_5] * (var_3[var_5] - 1) for var_5 in range(var_3.shape[0])])\n / 2\n )\n + var_2[0]\n )\n)\n```\n\n=== Code B (Modified) ===\n```python\nvar_6 = 2019\nvar_1 = [0] * var_6\nvar_3 = 1\nvar_5 = var_4 = 0\nfor var_2 in input()[::-1]:\n var_1[var_4] += 1\n var_4 -= int(var_2) * var_3\n var_4 %= var_6\n var_5 += var_1[var_4]\n var_3 *= 10\n var_3 %= var_6\nprint(var_5)\n```", "output": "FASTER 1.5513", "pair_id": "python_p02702_forward", "problem_id": "p02702", "language": "python", "direction": "forward", "speedup_ratio": 2.9308} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_4 = int(eval(input()))\nvar_2 = list(map(int, input().split()))\n\n\ndef func_1(var_1, var_8, var_3):\n if var_8 == var_4:\n var_9 = 1\n for var_5 in var_3:\n var_9 *= var_5\n return 1 if var_9 % 2 == 0 else 0\n var_6 = var_3.copy()\n var_6.append(var_1[var_8] - 1)\n var_5 = var_3.copy()\n var_5.append(var_1[var_8])\n var_7 = var_3.copy()\n var_7.append(var_1[var_8] + 1)\n return (\n func_1(var_1, var_8 + 1, var_6)\n + func_1(var_1, var_8 + 1, var_5)\n + func_1(var_1, var_8 + 1, var_7)\n )\n\n\nprint((func_1(var_2, 0, [])))\n```\n\n=== Code B (Modified) ===\n```python\nvar_6 = int(eval(input()))\nvar_2 = list(map(int, input().split()))\nfrom itertools import product\n\nvar_5 = [-1, 0, 1]\nvar_3 = 0\nfor var_7 in product(var_5, repeat=var_6):\n var_1 = []\n for var_4 in range(var_6):\n var_1.append(var_7[var_4] + var_2[var_4])\n if any(var_8 % 2 == 0 for var_8 in var_1):\n var_3 += 1\nprint(var_3)\n```", "output": "SLOWER 1.5499", "pair_id": "python_p03568_reversed", "problem_id": "p03568", "language": "python", "direction": "reversed", "speedup_ratio": 2.928} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nfrom collections import defaultdict\n\nvar_8 = int(eval(input()))\nvar_1 = tuple(map(int, input().split()))\nvar_3 = True\nif var_8 % 3 == 0:\n var_5 = defaultdict(int)\n for var_2 in var_1:\n var_5[var_2] += 1\n var_7 = var_8 // 3\n var_10 = []\n for var_9, var_4 in list(var_5.items()):\n if var_4 % var_7 != 0:\n var_3 = False\n break\n else:\n for _ in range(var_4 // var_7):\n var_10.append(var_9)\n else:\n if any(\n var_10[(0 + var_6) % 3] ^ var_10[(1 + var_6) % 3] != var_10[(2 + var_6) % 3]\n for var_6 in range(3)\n ):\n var_3 = False\nelse:\n if any(var_2 != 0 for var_2 in var_1):\n var_3 = False\nprint((\"Yes\" if var_3 else \"No\"))\n```\n\n=== Code B (Modified) ===\n```python\nfrom functools import *\n\n_, var_1 = open(0)\nprint(\n (\n \"YNeos\"[\n var_2(lambda var_3, var_4: var_3 ^ var_4, list(map(int, var_1.split())))\n > 0 :: 2\n ]\n )\n)\n```", "output": "FASTER 1.1419", "pair_id": "python_p02975_forward", "problem_id": "p02975", "language": "python", "direction": "forward", "speedup_ratio": 2.2067} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_2, var_1 = list(map(int, input().split()))\nvar_3 = 0\nvar_8 = 0\nvar_4 = [0] * (var_2 + 1)\nvar_9 = [0] * (var_2 + 1)\nfor var_5 in range(var_1):\n var_6, var_7 = input().split()\n var_6 = int(var_6)\n if var_7 == \"AC\":\n if var_4[var_6] == 0:\n var_3 += 1\n var_8 += var_9[var_6]\n var_4[var_6] = 1\n else:\n var_9[var_6] += 1\nprint((var_3, var_8))\n```\n\n=== Code B (Modified) ===\n```python\nfrom sys import stdin\n\nvar_5 = stdin.readline\nvar_2, var_1 = list(map(int, var_5().split()))\nvar_3 = [False] * var_2\nvar_8 = [0] * var_2\nvar_9 = 0\nfor var_4 in range(var_1):\n var_6, var_7 = var_5().split()\n var_6 = int(var_6) - 1\n if var_3[var_6] is False and var_7 == \"AC\":\n var_9 += var_8[var_6]\n var_3[var_6] = True\n elif var_7 == \"WA\":\n var_8[var_6] += 1\nprint((var_3.count(True), var_9))\n```", "output": "SLOWER 1.4288", "pair_id": "python_p02802_reversed", "problem_id": "p02802", "language": "python", "direction": "reversed", "speedup_ratio": 2.6922} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\ndef func_1():\n var_2, var_3, *var_1 = list(map(int, open(0).read().split()))\n var_4 = [0] * (var_3 + max(var_1[::2]))\n for var_7, var_6 in sorted(zip(*[iter(var_1)] * 2)):\n for var_5 in reversed(list(range(var_3))):\n var_4[var_5 + var_7] = max(var_4[var_5 + var_7], var_4[var_5] + var_6)\n print((max(var_4)))\n\n\nfunc_1()\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\n\nvar_10 = sys.stdin.readline\nvar_2, var_3 = list(map(int, var_10().split()))\nvar_1 = [list(map(int, var_10().split())) for _ in range(var_2)]\nvar_8 = [[0 for _ in range(var_2 + 1)] for _ in range(var_3 + 1)]\n\nvar_13 = [[0 for _ in range(var_2 + 1)] for _ in range(var_3 + 1)]\nfor var_11 in range(var_2):\n var_4, var_6 = var_1[var_11]\n for var_15 in range(var_3):\n if var_4 > var_15:\n var_8[var_15][var_11 + 1] = var_8[var_15][var_11]\n var_13[var_15][var_11 + 1] = var_15\n else:\n if var_6 + var_8[var_15 - var_4][var_11] >= var_8[var_15][var_11]:\n var_8[var_15][var_11 + 1] = var_8[var_15 - var_4][var_11] + var_6\n var_13[var_15][var_11 + 1] = var_15 - var_4\n else:\n var_8[var_15][var_11 + 1] = var_8[var_15][var_11]\n var_13[var_15][var_11 + 1] = var_15\nvar_5 = var_8[var_3 - 1][var_2]\nvar_14 = [False] * var_2\nvar_7 = var_3 - 1\nfor var_9 in reversed(list(range(var_2))):\n if var_13[var_7][var_9 + 1] == var_7 - var_1[var_9][0]:\n var_14[var_9] = True\n var_7 = var_13[var_7][var_9 + 1]\nvar_12 = 0\nfor var_9 in range(var_2):\n if not var_14[var_9] and var_1[var_9][1] > var_12:\n var_12 = var_1[var_9][1]\nprint((var_5 + var_12))\n```", "output": "SLOWER 1.7835", "pair_id": "python_p02863_reversed", "problem_id": "p02863", "language": "python", "direction": "reversed", "speedup_ratio": 3.4426} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_3 = list(map(int, input().split()))\nvar_2 = 0\nfor var_5 in range(var_3 + 1)[var_1:]:\n if len(str(var_5)) % 2 == 0:\n var_6 = list(str(var_5))[: len(str(var_5)) // 2]\n var_7 = list(reversed(list(str(var_5))[len(str(var_5)) // 2 :]))\n if var_6 == var_7:\n var_2 += 1\n else:\n var_8 = list(str(var_5))[: len(str(var_5)) // 2 + 1]\n var_4 = list(reversed(list(str(var_5))[len(str(var_5)) // 2 :]))\n if var_8 == var_4:\n var_2 += 1\nprint(var_2)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_6 = str(var_4)\n var_5 = var_6[::-1]\n if var_6 == var_5:\n var_3 += 1\nprint(var_3)\n```", "output": "FASTER 2.2242", "pair_id": "python_p03416_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 4.6724} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n if str(var_4) == \"\".join(reversed(str(var_4))):\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_4 = str(var_4)\n if var_4[0] == var_4[-1] and var_4[1] == var_4[-2]:\n var_3 += 1\nprint(var_3)\n```", "output": "FASTER 1.26", "pair_id": "python_p03416_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 2.3949} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().rstrip().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = list(map(int, list(str(var_4))))\n if var_5[0] == var_5[4] and var_5[1] == var_5[3]:\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().strip().split(\" \")))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n if str(var_4) == str(var_4)[::-1]:\n var_3 += 1\nprint(var_3)\n```", "output": "FASTER 1.3757", "pair_id": "python_p03416_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 2.595} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nfrom collections import Counter, defaultdict, deque\nfrom heapq import heappop, heappush, heapify\nimport sys, bisect, math, itertools, fractions, pprint\n\nsys.setrecursionlimit(10**8)\nvar_6 = 10**9 + 7\nvar_1 = float(\"inf\")\n\n\ndef func_1():\n return int(sys.stdin.readline())\n\n\ndef func_2():\n return list(map(int, sys.stdin.readline().split()))\n\n\nvar_8, var_11 = func_2()\nvar_17 = [func_2() for _ in range(var_8)]\nvar_10 = var_17[::-1]\nvar_14 = [[0] * var_11 for _ in range(var_8)]\nvar_3 = [[0] * var_11 for _ in range(var_8)]\nfor var_4 in range(var_8 - 1):\n var_16, var_15 = var_17[var_4]\n for var_5 in range(var_11):\n if var_5 < var_16:\n var_14[var_4 + 1][var_5] = var_14[var_4][var_5]\n else:\n var_14[var_4 + 1][var_5] = max(\n var_14[var_4][var_5], var_14[var_4][var_5 - var_16] + var_15\n )\nvar_9 = var_14[var_8 - 1][var_11 - 1] + var_17[var_8 - 1][1]\nfor var_4 in range(var_8 - 1):\n var_16, var_15 = var_10[var_4]\n for var_5 in range(var_11):\n if var_5 < var_16:\n var_3[var_4 + 1][var_5] = var_3[var_4][var_5]\n else:\n var_3[var_4 + 1][var_5] = max(\n var_3[var_4][var_5], var_3[var_4][var_5 - var_16] + var_15\n )\n var_9 = max(var_9, var_3[var_8 - 1][var_11 - 1] + var_17[0][1])\n\nfor var_4 in range(1, var_8 - 1):\n var_13 = var_4\n var_2 = var_8 - var_4 - 1\n var_7 = 0\n for var_5 in range(var_11):\n var_12 = var_14[var_13][var_5] + var_3[var_2][var_11 - 1 - var_5]\n var_7 = max(var_7, var_12)\n var_9 = max(var_9, var_7 + var_17[var_4][1])\nprint(var_9)\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\nfrom operator import itemgetter\nfrom heapq import heapify, heappop, heappush\n\nvar_1 = int(10e15)\nvar_2 = -var_1\nvar_11 = 1000000007\nsys.setrecursionlimit(1000000)\n\n\ndef func_2():\n return list(map(int, input().split()))\n\n\ndef func_4():\n return input().split()\n\n\ndef func_1():\n return int(sys.stdin.readline())\n\n\ndef func_3():\n return eval(input())\n\n\nvar_3, var_4 = func_2()\nvar_5 = [func_2() for var_9 in range(var_3)]\nvar_5.sort(key=itemgetter(0))\n\nvar_8 = [[0] * (var_4 + 1 + 3000 + 1) for _ in range(var_3 + 1)]\nvar_6 = 0\nfor var_9 in range(var_3):\n for var_10 in range(var_4 + 1 + 3000 + 1):\n var_12, var_7 = var_5[var_9]\n if 0 <= var_10 - var_12 < var_4:\n var_8[var_9 + 1][var_10] = max(\n var_8[var_9][var_10], var_8[var_9][var_10 - var_12] + var_7\n )\n else:\n var_8[var_9 + 1][var_10] = var_8[var_9][var_10]\n var_6 = max(var_6, var_8[var_9 + 1][var_10])\nprint(var_6)\n```", "output": "SLOWER 3.8148", "pair_id": "python_p02863_reversed", "problem_id": "p02863", "language": "python", "direction": "reversed", "speedup_ratio": 14.0727} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nfrom collections import Counter, defaultdict, deque\nfrom heapq import heappop, heappush, heapify\nimport sys, bisect, math, itertools, fractions, pprint\n\nsys.setrecursionlimit(10**8)\nvar_6 = 10**9 + 7\nvar_1 = float(\"inf\")\n\n\ndef func_1():\n return int(sys.stdin.readline())\n\n\ndef func_2():\n return list(map(int, sys.stdin.readline().split()))\n\n\nvar_7, var_9 = func_2()\nvar_13 = [func_2() for _ in range(var_7)]\nvar_13.sort(key=lambda var_14: var_14[1], reverse=True)\nvar_8 = 0\nvar_10 = min(var_7, 5)\nfor var_3 in range(var_10):\n var_2 = [[0] * (var_9 + 5) for _ in range(var_7 + 5)]\n for var_4 in range(var_7):\n var_12, var_11 = var_13[var_4]\n for var_5 in range(var_9):\n if var_5 < var_12 or var_3 == var_4:\n var_2[var_4 + 1][var_5] = var_2[var_4][var_5]\n else:\n var_2[var_4 + 1][var_5] = max(\n var_2[var_4][var_5], var_2[var_4][var_5 - var_12] + var_11\n )\n\n var_8 = max(var_2[var_7][var_9 - 1] + var_13[var_3][1], var_8)\nprint(var_8)\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\nfrom collections import deque\n\nvar_1 = int(10e10)\nvar_2 = -var_1\nvar_12 = 1000000007\nsys.setrecursionlimit(1000000)\n\n\ndef func_2():\n return list(map(int, input().split()))\n\n\ndef func_4():\n return input().split()\n\n\ndef func_1():\n return int(sys.stdin.readline())\n\n\ndef func_3():\n return eval(input())\n\n\nvar_3, var_4 = func_2()\nvar_6 = [func_2() for var_10 in range(var_3)]\nvar_6.sort()\nvar_7 = 0\nvar_9 = [[0] * var_4 for var_10 in range(var_3 + 1)]\nfor var_10 in range(1, var_3 + 1):\n var_5, var_8 = var_6[var_10 - 1]\n for var_11 in range(var_4):\n if 0 <= var_11 - var_5 < var_4:\n var_9[var_10][var_11] = max(\n var_9[var_10 - 1][var_11], var_9[var_10 - 1][var_11 - var_5] + var_8\n )\n else:\n var_9[var_10][var_11] = var_9[var_10 - 1][var_11]\n else:\n var_7 = max(var_7, var_9[var_10 - 1][-1] + var_8)\nprint(var_7)\n```", "output": "FASTER 1.5536", "pair_id": "python_p02863_forward", "problem_id": "p02863", "language": "python", "direction": "forward", "speedup_ratio": 2.9355} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = [0] * (var_2 + 1)\nfor var_3 in range(1, var_2 + 1):\n if str(var_3) == str(var_3)[::-1]:\n var_4[var_3] = var_4[var_3 - 1] + 1\n else:\n var_4[var_3] = var_4[var_3 - 1]\nprint((var_4[var_2] - var_4[var_1 - 1]))\n```\n\n=== Code B (Modified) ===\n```python\nvar_1 = list(map(int, input().split()))\nvar_2 = 0\nfor var_3 in range(var_1[0], var_1[1] + 1):\n var_4 = str(var_3)\n if var_4[0] == var_4[4] and var_4[1] == var_4[3]:\n var_2 += 1\nprint(var_2)\n```", "output": "FASTER 2.2311", "pair_id": "python_p03416_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 4.6949} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\nimport math\nfrom collections import defaultdict\nfrom bisect import bisect_left, bisect_right\n\nsys.setrecursionlimit(10**7)\n\n\ndef func_4():\n return sys.stdin.readline()[:-1]\n\n\nvar_4 = 10**9 + 7\n\n\ndef func_1():\n return int(eval(func_4()))\n\n\ndef func_2():\n return list(map(int, func_4().split()))\n\n\ndef func_3(var_6, var_3):\n if var_6 <= 0:\n return [[] for _ in range(var_3)]\n elif var_3 == 1:\n return [func_1() for _ in range(var_6)]\n else:\n var_5 = [func_2() for _ in range(var_6)]\n return list(map(list, list(zip(*var_5))))\n\n\nfrom decimal import getcontext, Decimal\n\ngetcontext().prec = 28\nvar_1, var_2 = list(map(str, func_4().split()))\nvar_1 = int(var_1)\nvar_2 = Decimal(var_2)\nprint((int(var_1 * var_2)))\n```\n\n=== Code B (Modified) ===\n```python\nimport decimal\n\n\ndef func_1():\n var_1, var_2 = list(map(decimal.Decimal, input().split()))\n print((var_1 * var_2 // 1))\n\n\nif __name__ == \"__main__\":\n func_1()\n```", "output": "FASTER 2.0487", "pair_id": "python_p02659_forward", "problem_id": "p02659", "language": "python", "direction": "forward", "speedup_ratio": 4.1373} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_8 = int(eval(input()))\nvar_4 = []\nfor var_5 in range(var_8):\n var_11 = 0\n var_9 = list(map(int, input().split()))\n for var_6 in range(10):\n var_11 += var_9[var_6] << var_6\n var_4.append(var_11)\nvar_10 = []\nfor var_5 in range(var_8):\n var_10.append(list(map(int, input().split())))\nvar_1 = -(10**12)\nfor var_5 in range(1, 1 << 10):\n var_11 = 0\n for var_6 in range(var_8):\n var_3 = list(bin(var_4[var_6] & var_5)[2:])\n var_2 = 0\n for var_7 in var_3:\n if var_7 == \"1\":\n var_2 += 1\n var_11 += var_10[var_6][var_2]\n var_1 = max(var_1, var_11)\nprint(var_1)\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\nimport itertools\n\n\ndef func_2(var_4):\n return bin(eval(\"0b\" + str(var_4)))\n\n\ndef func_1():\n var_4 = int(sys.stdin.readline().rstrip())\n var_9 = [\n func_2(\"\".join(str(var_10) for var_10 in sys.stdin.readline().split()))\n for _ in range(var_4)\n ]\n var_8 = [\n [int(var_10) for var_10 in sys.stdin.readline().split()] for _ in range(var_4)\n ]\n var_3 = -(10**10)\n for var_6 in itertools.product(\"01\", repeat=10):\n var_6 = func_2(\"\".join(var_6))\n if var_6 == \"0b0\":\n continue\n var_7 = 0\n for var_2 in range(var_4):\n var_1 = var_9[var_2]\n var_5 = bin(eval(var_1) & eval(var_6)).count(\"1\")\n var_7 += var_8[var_2][var_5]\n var_3 = max(var_3, var_7)\n print(var_3)\n\n\nif __name__ == \"__main__\":\n\n func_1()\n```", "output": "SLOWER 3.1052", "pair_id": "python_p03503_reversed", "problem_id": "p03503", "language": "python", "direction": "reversed", "speedup_ratio": 8.605} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_8 in range(var_1, var_2 + 1):\n var_7 = str(var_8)\n var_6 = len(var_7)\n var_4 = True\n for var_5 in range(var_6 // 2):\n if var_7[var_5] != var_7[var_6 - 1 - var_5]:\n var_4 = False\n break\n if var_4:\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_4 = {}\nvar_5 = 0\nfor var_6 in range(10000, 100000):\n var_3 = list(str(var_6))\n if var_3 == list(reversed(var_3)):\n var_5 += 1\n var_4[var_6] = var_5\nvar_1, var_2 = list(map(int, input().split()))\nprint((var_4[var_2] - var_4[var_1 - 1] if var_1 > 10000 else var_4[var_2]))\n```", "output": "SLOWER 2.4474", "pair_id": "python_p03416_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 5.4542} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\nfrom collections import deque\n\nvar_1 = int(10e10)\nvar_2 = -var_1\nvar_12 = 1000000007\nsys.setrecursionlimit(1000000)\n\n\ndef func_2():\n return list(map(int, input().split()))\n\n\ndef func_4():\n return input().split()\n\n\ndef func_1():\n return int(sys.stdin.readline())\n\n\ndef func_3():\n return eval(input())\n\n\nvar_3, var_4 = func_2()\nvar_6 = [func_2() for var_10 in range(var_3)]\nvar_6.sort()\nvar_7 = 0\nvar_9 = [[0] * var_4 for var_10 in range(var_3 + 1)]\nfor var_10 in range(1, var_3 + 1):\n var_5, var_8 = var_6[var_10 - 1]\n for var_11 in range(var_4):\n if 0 <= var_11 - var_5 < var_4:\n var_9[var_10][var_11] = max(\n var_9[var_10 - 1][var_11], var_9[var_10 - 1][var_11 - var_5] + var_8\n )\n else:\n var_9[var_10][var_11] = var_9[var_10 - 1][var_11]\n else:\n var_7 = max(var_7, var_9[var_10 - 1][-1] + var_8)\nprint(var_7)\n```\n\n=== Code B (Modified) ===\n```python\nvar_6, var_7 = list(map(int, input().split()))\nvar_1 = [list(map(int, input().split())) for _ in range(var_6)]\nvar_1.sort()\nvar_3 = [(6007) * [0] for _ in range(var_6 + 1)]\nvar_3[0][0] = 0\nvar_2 = 0\nfor var_4 in range(var_6):\n for var_5 in range(6007):\n var_3[var_4 + 1][var_5] = max(var_3[var_4 + 1][var_5], var_3[var_4][var_5])\n if var_5 < var_7:\n var_3[var_4 + 1][var_5 + var_1[var_4][0]] = max(\n var_3[var_4][var_5] + var_1[var_4][1],\n var_3[var_4][var_5 + var_1[var_4][0]],\n )\n var_2 = max(var_2, var_3[var_4 + 1][var_5])\nprint(var_2)\n```", "output": "SLOWER 5.6348", "pair_id": "python_p02863_reversed", "problem_id": "p02863", "language": "python", "direction": "reversed", "speedup_ratio": 49.688} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport decimal\n\nvar_1, var_2 = (decimal.Decimal(var_3) for var_3 in input().split())\nprint((int(var_1 * var_2)))\n```\n\n=== Code B (Modified) ===\n```python\ndef func_1():\n from sys import setrecursionlimit, stdin\n from os import environ\n from collections import defaultdict, deque, Counter\n from math import ceil, floor, gcd\n from itertools import accumulate, combinations, combinations_with_replacement\n\n setrecursionlimit(10**6)\n var_7 = (\n (lambda *var_11: print(*var_11))\n if \"TERM_PROGRAM\" in environ\n else lambda *var_12: 0\n )\n var_8 = lambda: stdin.readline().rstrip()\n var_3 = lambda: list(map(int, var_8().split()))\n var_1 = lambda: int(var_8())\n var_4 = 10**9 + 7\n var_2 = 10**9 + 10\n var_9, var_10 = var_8().split()\n var_5 = int(var_9)\n var_10 = var_10.split(\".\")\n var_6 = int(var_10[0]) * 100\n if len(var_10) == 2:\n var_6 += int(var_10[1])\n print(var_5 * var_6 // 100)\n\n\nfunc_1()\n```", "output": "SLOWER 2.0989", "pair_id": "python_p02659_reversed", "problem_id": "p02659", "language": "python", "direction": "reversed", "speedup_ratio": 4.2837} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = str(var_4)\n if var_5 == var_5[::-1]:\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = list(str(var_4))\n if var_5 == list(reversed(var_5)):\n var_3 += 1\nprint(var_3)\n```", "output": "SLOWER 1.2366", "pair_id": "python_p03416_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 2.3565} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\n\n\ndef func_1():\n var_8 = int(sys.stdin.readline().rstrip())\n var_7 = list(map(int, sys.stdin.read().split()))\n var_2 = list(zip(var_7, var_7))\n var_6 = [[] for _ in range(var_8 + 1)]\n for var_1, var_3 in var_2:\n var_6[var_1].append(var_3)\n var_6[var_3].append(var_1)\n var_13 = 1\n var_11 = [0] * (var_8 + 1)\n var_10 = []\n var_14 = [var_13]\n while var_14:\n var_15 = var_14.pop()\n var_10.append(var_15)\n for var_16 in var_6[var_15]:\n if var_16 == var_11[var_15]:\n continue\n var_11[var_16] = var_15\n var_14.append(var_16)\n var_5 = [-1] * (var_8 + 1)\n for var_15 in var_10:\n var_9 = var_5[var_15]\n var_4 = 1\n for var_16 in var_6[var_15]:\n if var_16 == var_11[var_15]:\n continue\n if var_4 == var_9:\n var_4 += 1\n var_5[var_16] = var_4\n var_4 += 1\n var_12 = []\n for var_1, var_3 in var_2:\n if var_11[var_1] == var_3:\n var_12.append(var_5[var_1])\n else:\n var_12.append(var_5[var_3])\n print((max(var_12)))\n print((\"\\n\".join(map(str, var_12))))\n\n\nif __name__ == \"__main__\":\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nimport copy\n\nvar_8 = int(eval(input()))\nvar_10 = set([var_6 for var_6 in range(1, 10**5)])\nvar_5 = []\nvar_11 = {}\nvar_9 = []\nfor var_6 in range(var_8 - 1):\n var_1, var_2 = list(map(int, input().split(\" \")))\n var_5.append([var_1, var_2])\n var_11.setdefault(var_1, []).append(var_2)\n var_9.append([])\nvar_9.append([])\nvar_9.append([])\nvar_7 = 0\nfor var_12 in range(1, var_8 + 1):\n var_14 = var_11.get(var_12, [])\n var_3 = 1\n for var_13 in var_14:\n if var_3 in var_9[var_12]:\n var_3 += 1\n else:\n pass\n var_9[var_13].append(var_3)\n if var_3 >= var_7:\n var_7 = var_3\n var_3 += 1\nprint(var_7)\nfor var_4 in var_5:\n print((var_9[var_4[1]][0]))\n```", "output": "SLOWER 4.1752", "pair_id": "python_p02850_reversed", "problem_id": "p02850", "language": "python", "direction": "reversed", "speedup_ratio": 18.0665} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nfor var_3 in range(1, 1009):\n if int(var_3 * 0.08) == var_1 and int(var_3 * 0.1) == var_2:\n print((int(var_3)))\n exit()\nprint(\"-1\")\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nimport math\n\nif math.ceil((var_1 + 1) * 12.5) <= math.ceil(var_2 * 10) or math.ceil(\n var_1 * 12.5\n) >= math.ceil((var_2 + 1) * 10):\n print((-1))\nelse:\n print((max(math.ceil(var_1 * 12.5), math.ceil(var_2 * 10))))\n```", "output": "FASTER 1.923", "pair_id": "python_p02755_forward", "problem_id": "p02755", "language": "python", "direction": "forward", "speedup_ratio": 3.792} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\n\nvar_17 = sys.stdin.read\nvar_18 = sys.stdin.readline\nvar_19 = sys.stdin.readlines\nsys.setrecursionlimit(10**9)\nvar_2 = 1 << 60\nvar_4 = 1000000007\n\n\nclass Class_1:\n def __init__(self, var_12):\n self.n = var_12\n self.data = [0] * (var_12 + 1)\n\n def func_1(self, var_10, var_20=1):\n var_10 += 1\n while var_10 <= self.n:\n self.data[var_10] += var_20\n var_10 += var_10 & -var_10\n\n def func_2(self, var_10):\n var_10 += 1\n var_20 = 0\n while var_10 > 0:\n var_20 += self.data[var_10]\n var_10 -= var_10 & -var_10\n return var_20\n\n def func_3(self, var_11, var_16):\n return self.get_sum(var_16 - 1) - self.get_sum(var_11 - 1)\n\n\ndef func_4():\n var_5, var_6 = map(int, var_18().split())\n var_1 = list(map(int, var_18().split()))\n var_3 = map(int, var_17().split())\n var_13 = [-1] * (var_5 + 1)\n var_14 = [[] for _ in range(var_5)]\n for var_10, var_9 in enumerate(var_1):\n if var_13[var_9] != -1:\n var_14[var_13[var_9]].append(var_10)\n var_13[var_9] = var_10\n var_15 = [[] for _ in range(var_5 + 1)]\n for var_10, (var_11, var_16) in enumerate(zip(*[iter(var_3)] * 2)):\n var_11 -= 1\n var_16 -= 1\n var_15[var_11].append((var_16, var_10))\n var_7 = [0] * var_6\n var_8 = Class_1(var_5)\n for var_11 in range(var_5 - 1, -1, -1):\n for var_16 in var_14[var_11]:\n var_8.add(var_16)\n for var_16, var_10 in var_15[var_11]:\n var_7[var_10] = (var_16 - var_11 + 1) - var_8.get_sum(var_16)\n print(*var_7, sep=\"\\n\")\n return\n\n\nif __name__ == \"__main__\":\n func_4()\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\n\nvar_20 = sys.stdin.read\nvar_21 = sys.stdin.readline\nvar_22 = sys.stdin.readlines\nsys.setrecursionlimit(10**9)\nvar_2 = 1 << 60\nvar_5 = 1000000007\n\n\nvar_4 = 1000001\n\n\nclass Class_1:\n def __init__(self, var_13, var_19, var_12):\n self.l = var_13\n self.r = var_19\n self.idx = var_12\n\n\ndef func_4(var_12, var_24, var_10, var_15):\n while var_12 <= var_15:\n var_10[var_12] += var_24\n var_12 += var_12 & -var_12\n\n\ndef func_3(var_12, var_10, var_15):\n var_23 = 0\n while var_12:\n var_23 += var_10[var_12]\n var_12 -= var_12 & -var_12\n return var_23\n\n\ndef func_1(var_9, var_15, var_17, var_16):\n\n var_10 = [0] * (var_15 + 1)\n\n var_14 = [-1] * var_4\n\n var_8 = [0] * var_16\n var_18 = 0\n for var_11 in range(var_15):\n\n if var_14[var_9[var_11]] != -1:\n func_4(var_14[var_9[var_11]] + 1, -1, var_10, var_15)\n\n var_14[var_9[var_11]] = var_11\n func_4(var_11 + 1, 1, var_10, var_15)\n\n while var_18 < var_16 and var_17[var_18].r == var_11:\n var_8[var_17[var_18].idx] = func_3(\n var_17[var_18].r + 1, var_10, var_15\n ) - func_3(var_17[var_18].l, var_10, var_15)\n var_18 += 1\n\n for var_11 in range(var_16):\n print((var_8[var_11]))\n\n\ndef func_2():\n var_6, var_7 = list(map(int, var_21().split()))\n var_1 = list(map(int, var_21().split()))\n (*var_3,) = list(map(int, var_20().split()))\n var_17 = [0] * var_7\n for var_11, (var_13, var_19) in enumerate(zip(*[iter(var_3)] * 2)):\n var_17[var_11] = Class_1(var_13 - 1, var_19 - 1, var_11)\n var_17.sort(key=lambda var_25: var_25.r)\n func_1(var_1, var_6, var_17, var_7)\n return\n\n\nif __name__ == \"__main__\":\n func_2()\n```", "output": "SLOWER 2.1032", "pair_id": "python_p02599_reversed", "problem_id": "p02599", "language": "python", "direction": "reversed", "speedup_ratio": 4.2966} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_8 = int(eval(input()))\nvar_4 = []\nfor var_5 in range(var_8):\n var_11 = 0\n var_9 = list(map(int, input().split()))\n for var_6 in range(10):\n var_11 += var_9[var_6] << var_6\n var_4.append(var_11)\nvar_10 = []\nfor var_5 in range(var_8):\n var_10.append(list(map(int, input().split())))\nvar_1 = -(10**12)\nfor var_5 in range(1, 1 << 10):\n var_11 = 0\n for var_6 in range(var_8):\n var_3 = list(bin(var_4[var_6] & var_5)[2:])\n var_2 = 0\n for var_7 in var_3:\n if var_7 == \"1\":\n var_2 += 1\n var_11 += var_10[var_6][var_2]\n var_1 = max(var_1, var_11)\nprint(var_1)\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\n\nvar_8 = sys.stdin.readline\n\n\ndef func_1():\n var_2 = int(eval(var_8()))\n var_1 = [int(var_8().replace(\" \", \"\"), 2) for _ in range(var_2)]\n var_3 = [list(map(int, var_8().split())) for _ in range(var_2)]\n var_4 = -(10**7) * var_2\n for var_7 in range(1, 1 << 10):\n var_10 = 0\n for var_9, var_6 in enumerate(var_1):\n var_5 = bin(var_7 & var_6).count(\"1\")\n var_10 += var_3[var_9][var_5]\n var_4 = max(var_4, var_10)\n print(var_4)\n\n\nif __name__ == \"__main__\":\n func_1()\n```", "output": "FASTER 2.2065", "pair_id": "python_p03503_forward", "problem_id": "p03503", "language": "python", "direction": "forward", "speedup_ratio": 4.6157} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_3 = list(map(int, input().split()))\nvar_2 = -1\nfor var_4 in range(10, 12501):\n if int(var_4 * 0.08) == var_1 and int(var_4 * 0.1) == var_3:\n var_2 = var_4\n break\nprint(var_2)\n```\n\n=== Code B (Modified) ===\n```python\nimport math\n\n\ndef func_1():\n var_1, var_2 = list(map(int, input().split()))\n\n var_5 = max(math.ceil(var_1 / 0.08), math.ceil(var_2 / 0.1))\n\n var_4 = min((math.ceil((var_1 + 1) / 0.08), math.ceil((var_2 + 1) / 0.1)))\n\n for var_3 in range(var_5, var_4 + 1):\n if (math.floor(var_3 * 0.08) == var_1) and (math.floor(var_3 * 0.1) == var_2):\n print(var_3)\n quit()\n\n print((-1))\n\n\nif __name__ == \"__main__\":\n func_1()\n```", "output": "FASTER 4.5761", "pair_id": "python_p02755_forward", "problem_id": "p02755", "language": "python", "direction": "forward", "speedup_ratio": 23.8532} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\nfrom collections import deque\n\nvar_1 = int(10e10)\nvar_2 = -var_1\nvar_12 = 1000000007\nsys.setrecursionlimit(1000000)\n\n\ndef func_2():\n return list(map(int, input().split()))\n\n\ndef func_4():\n return input().split()\n\n\ndef func_1():\n return int(sys.stdin.readline())\n\n\ndef func_3():\n return eval(input())\n\n\nvar_3, var_4 = func_2()\nvar_6 = [func_2() for var_10 in range(var_3)]\nvar_6.sort()\nvar_7 = 0\nvar_9 = [[0] * var_4 for var_10 in range(var_3 + 1)]\nfor var_10 in range(1, var_3 + 1):\n var_5, var_8 = var_6[var_10 - 1]\n for var_11 in range(var_4):\n if 0 <= var_11 - var_5 < var_4:\n var_9[var_10][var_11] = max(\n var_9[var_10 - 1][var_11], var_9[var_10 - 1][var_11 - var_5] + var_8\n )\n else:\n var_9[var_10][var_11] = var_9[var_10 - 1][var_11]\n else:\n var_7 = max(var_7, var_9[var_10 - 1][-1] + var_8)\nprint(var_7)\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\nfrom operator import itemgetter\nfrom heapq import heapify, heappop, heappush\n\nvar_1 = int(10e15)\nvar_2 = -var_1\nvar_11 = 1000000007\nsys.setrecursionlimit(1000000)\n\n\ndef func_2():\n return list(map(int, input().split()))\n\n\ndef func_4():\n return input().split()\n\n\ndef func_1():\n return int(sys.stdin.readline())\n\n\ndef func_3():\n return eval(input())\n\n\nvar_3, var_4 = func_2()\nvar_5 = [func_2() for var_9 in range(var_3)]\nvar_5.sort(key=itemgetter(0))\n\nvar_8 = [[0] * (var_4 + 1 + 3000 + 1) for _ in range(var_3 + 1)]\nvar_6 = 0\nfor var_9 in range(var_3):\n for var_10 in range(var_4 + 1 + 3000 + 1):\n var_12, var_7 = var_5[var_9]\n if 0 <= var_10 - var_12 < var_4:\n var_8[var_9 + 1][var_10] = max(\n var_8[var_9][var_10], var_8[var_9][var_10 - var_12] + var_7\n )\n else:\n var_8[var_9 + 1][var_10] = var_8[var_9][var_10]\n var_6 = max(var_6, var_8[var_9 + 1][var_10])\nprint(var_6)\n```", "output": "SLOWER 4.73", "pair_id": "python_p02863_reversed", "problem_id": "p02863", "language": "python", "direction": "reversed", "speedup_ratio": 26.5378} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\nimport itertools\n\n\ndef func_2(var_4):\n return eval(\"0b\" + var_4)\n\n\ndef func_1():\n var_4 = int(sys.stdin.readline().rstrip())\n var_9 = [\n func_2(\"\".join(str(var_10) for var_10 in sys.stdin.readline().split()))\n for _ in range(var_4)\n ]\n var_8 = [\n [int(var_10) for var_10 in sys.stdin.readline().split()] for _ in range(var_4)\n ]\n var_3 = -(10**10)\n for var_6 in itertools.product(\"01\", repeat=10):\n var_6 = func_2(\"\".join(var_6))\n if var_6 == 0:\n continue\n var_7 = 0\n for var_2 in range(var_4):\n var_1 = var_9[var_2]\n var_5 = bin(var_1 & var_6).count(\"1\")\n var_7 += var_8[var_2][var_5]\n var_3 = max(var_3, var_7)\n print(var_3)\n\n\nif __name__ == \"__main__\":\n\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nfrom sys import stdin\n\n\ndef func_1():\n\n var_11 = stdin.readline\n var_2 = int(var_11())\n var_1 = []\n for var_6 in range(var_2):\n var_5 = int(\"\".join(var_11().strip().split(\" \")), 2)\n var_1.append(var_5)\n var_3 = []\n for var_6 in range(var_2):\n var_10 = list(map(int, var_11().split()))\n var_3.append(var_10)\n var_8 = float(\"-inf\")\n for var_9 in range(1, 1 << 10):\n var_12 = 0\n for var_7 in range(var_2):\n var_4 = bin(var_9 & var_1[var_7]).count(\"1\")\n var_12 += var_3[var_7][var_4]\n var_8 = max(var_12, var_8)\n print(var_8)\n\n\nif __name__ == \"__main__\":\n func_1()\n```", "output": "FASTER 3.2765", "pair_id": "python_p03503_forward", "problem_id": "p03503", "language": "python", "direction": "forward", "speedup_ratio": 9.6901} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport math\nimport string\n\n\ndef func_5():\n return list(map(int, input().split()))\n\n\ndef func_4(var_7, var_8):\n return math.factorial(var_7) // (\n math.factorial(var_7 - var_8) * math.factorial(var_8)\n )\n\n\ndef func_3(var_10):\n var_9 = []\n for var_5 in var_10:\n if not (var_5 in var_9):\n var_9.append(var_5)\n return len(var_10) != len(var_9)\n\n\ndef func_1(var_7):\n func_1 = []\n for var_4 in range(1, var_7 + 1):\n if var_7 % var_4 == 0:\n func_1.append(var_4)\n return func_1\n\n\nvar_2 = [-1, -1, -1, 0, 0, 1, 1, 1]\nvar_3 = [-1, 0, 1, -1, 1, -1, 0, 1]\nvar_7 = int(eval(input()))\nvar_1 = func_5()\n\n\ndef func_2(var_6):\n if len(var_6) == var_7:\n for var_4 in range(len(var_6)):\n if var_6[var_4] % 2 == 0:\n return 1\n return 0\n return (\n func_2(var_6 + [var_1[len(var_6)]])\n + func_2(var_6 + [var_1[len(var_6)] - 1])\n + func_2(var_6 + [var_1[len(var_6)] + 1])\n )\n\n\nprint((func_2([])))\n```\n\n=== Code B (Modified) ===\n```python\ndef func_1():\n var_2 = int(eval(input()))\n var_1 = [int(var_6) for var_6 in input().split()]\n var_4 = 3**var_2\n var_5 = len([var_3 for var_3 in var_1 if var_3 % 2 == 0])\n var_4 -= 2**var_5\n print(var_4)\n\n\nif __name__ == \"__main__\":\n func_1()\n```", "output": "FASTER 7.1332", "pair_id": "python_p03568_forward", "problem_id": "p03568", "language": "python", "direction": "forward", "speedup_ratio": 140.3806} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_4, var_3 = list(map(int, input().split()))\nvar_1 = 0\nfor var_2 in range(var_4, var_3 + 1):\n if str(var_2)[0] + str(var_2)[1] == str(var_2)[-1] + str(var_2)[-2]:\n var_1 += 1\nprint(var_1)\n```\n\n=== Code B (Modified) ===\n```python\ndef func_1():\n var_1, var_2 = list(map(int, input().rstrip().split()))\n var_3 = 0\n for var_4 in range(var_1, var_2 + 1):\n var_5 = str(var_4)\n if var_5 == var_5[::-1]:\n var_3 += 1\n print(var_3)\n\n\nif __name__ == \"__main__\":\n func_1()\n```", "output": "FASTER 2.0871", "pair_id": "python_p03416_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 4.2489} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_2 = int(eval(input()))\n(*var_1,) = list(map(int, input().split()))\nvar_5 = 0\nfor var_3 in var_1:\n if var_3 % 2 == 0:\n var_5 += 1\nvar_4 = 3**var_2 - 2**var_5\nprint(var_4)\n```\n\n=== Code B (Modified) ===\n```python\nimport numpy as np\nfrom itertools import product\n\nvar_6 = int(eval(input()))\nvar_2 = list(map(int, input().split()))\nvar_2 = np.array(var_2)\nvar_5 = [-1, 0, 1]\nvar_3 = 0\nfor var_7 in product(var_5, repeat=var_6):\n var_7 = np.array(var_7)\n var_1 = var_2 + var_7\n var_4 = var_1.cumprod()\n if var_4[-1] % 2 == 0:\n var_3 += 1\nprint(var_3)\n```", "output": "SLOWER 10.028", "pair_id": "python_p03568_reversed", "problem_id": "p03568", "language": "python", "direction": "reversed", "speedup_ratio": 1044.0343} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nfrom functools import reduce\nfrom itertools import product\n\nvar_2 = int(eval(input()))\n(*var_1,) = list(map(int, input().split()))\nvar_4 = 0\nfor var_7 in product([-1, 0, 1], repeat=var_2):\n var_6 = reduce(\n lambda var_8, var_9: var_8 * var_9,\n [var_3 + var_7[var_5] for var_5, var_3 in enumerate(var_1)],\n )\n if var_6 % 2 == 0:\n var_4 += 1\nprint(var_4)\n```\n\n=== Code B (Modified) ===\n```python\nvar_2 = int(eval(input()))\nvar_1 = list(map(int, input().split()))\nvar_4 = 1\nfor var_3 in range(var_2):\n if var_1[var_3] % 2 == 0:\n var_4 *= 2\nprint((3**var_2 - var_4))\n```", "output": "FASTER 9.7762", "pair_id": "python_p03568_forward", "problem_id": "p03568", "language": "python", "direction": "forward", "speedup_ratio": 876.8612} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\n\nvar_12 = sys.stdin.readline\nvar_2 = int(eval(var_12()))\nvar_9 = [[] for _ in range(var_2)]\nvar_1 = {}\nfor var_10 in range(var_2 - 1):\n var_4, var_6 = list(map(int, var_12().split()))\n var_9[var_4 - 1].append(var_6 - 1)\n var_9[var_6 - 1].append(var_4 - 1)\n var_1[(var_4 - 1) * var_2 + var_6 - 1] = var_10\n var_1[(var_6 - 1) * var_2 + var_4 - 1] = var_10\nvar_15 = [0]\nvar_8 = [False] * var_2\nvar_8[0] = True\nvar_3 = [None] * var_2\nvar_3[0] = 0\nvar_5 = [None] * (var_2 - 1)\nwhile var_15:\n var_16 = []\n for var_14 in var_15:\n var_7 = var_3[var_14]\n var_17 = 1\n for var_13 in var_9[var_14]:\n if not var_8[var_13]:\n var_8[var_13] = True\n var_16.append(var_13)\n var_11 = var_1[var_14 * var_2 + var_13]\n if var_17 == var_7:\n var_17 += 1\n var_5[var_11] = var_17\n var_3[var_13] = var_17\n var_17 += 1\n var_15 = var_16\nprint((max(var_5)))\nfor var_4 in var_5:\n print(var_4)\n```\n\n=== Code B (Modified) ===\n```python\nimport copy\n\nvar_8 = int(eval(input()))\nvar_10 = set([var_6 for var_6 in range(1, 10**5)])\nvar_5 = []\nvar_11 = {}\nvar_9 = []\nfor var_6 in range(var_8 - 1):\n var_1, var_2 = list(map(int, input().split(\" \")))\n var_5.append([var_1, var_2])\n var_11.setdefault(var_1, []).append(var_2)\n var_9.append([])\nvar_9.append([])\nvar_9.append([])\nvar_7 = 0\nfor var_12 in range(1, var_8 + 1):\n var_14 = var_11.get(var_12, [])\n var_3 = 1\n for var_13 in var_14:\n if var_3 in var_9[var_12]:\n var_3 += 1\n else:\n pass\n var_9[var_13].append(var_3)\n if var_3 >= var_7:\n var_7 = var_3\n var_3 += 1\nprint(var_7)\nfor var_4 in var_5:\n print((var_9[var_4[1]][0]))\n```", "output": "SLOWER 4.2702", "pair_id": "python_p02850_reversed", "problem_id": "p02850", "language": "python", "direction": "reversed", "speedup_ratio": 19.2961} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n if list(str(var_4)) == list(reversed(str(var_4))):\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_4 = str(var_4)\n if var_4[0] == var_4[-1] and var_4[1] == var_4[-2]:\n var_3 += 1\nprint(var_3)\n```", "output": "FASTER 1.584", "pair_id": "python_p03416_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 2.9981} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\n\nvar_7 = sys.stdin.readline\nfrom itertools import combinations\n\n\ndef func_3(var_10):\n for _ in range(var_10):\n yield list(map(int, var_7().split()))\n\n\ndef func_1(var_9, var_5, var_11):\n var_3 = len([0 for var_8 in var_9 if var_5[var_8] == 1])\n return var_11[var_3]\n\n\ndef func_2():\n var_10 = int(eval(var_7()))\n var_1 = list(func_3(var_10))\n var_2 = list(func_3(var_10))\n for var_6 in range(1, 11):\n for var_4 in combinations(list(range(10)), var_6):\n yield sum(\n func_1(var_4, var_5, var_11) for var_5, var_11 in zip(var_1, var_2)\n )\n\n\nprint((max(func_2())))\n```\n\n=== Code B (Modified) ===\n```python\nvar_8 = int(eval(input()))\nvar_4 = []\nfor var_5 in range(var_8):\n var_11 = 0\n var_9 = list(map(int, input().split()))\n for var_6 in range(10):\n var_11 += var_9[var_6] << var_6\n var_4.append(var_11)\nvar_10 = []\nfor var_5 in range(var_8):\n var_10.append(list(map(int, input().split())))\nvar_1 = -(10**12)\nfor var_5 in range(1, 1 << 10):\n var_11 = 0\n for var_6 in range(var_8):\n var_3 = list(bin(var_4[var_6] & var_5)[2:])\n var_2 = 0\n for var_7 in var_3:\n if var_7 == \"1\":\n var_2 += 1\n var_11 += var_10[var_6][var_2]\n var_1 = max(var_1, var_11)\nprint(var_1)\n```", "output": "SLOWER 1.0894", "pair_id": "python_p03503_reversed", "problem_id": "p03503", "language": "python", "direction": "reversed", "speedup_ratio": 2.1279} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_4 = str(var_4)\n if var_4[0] == var_4[-1] and var_4[1] == var_4[-2]:\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().rstrip().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = list(map(int, list(str(var_4))))\n if var_5[0] == var_5[4] and var_5[1] == var_5[3]:\n var_3 += 1\nprint(var_3)\n```", "output": "SLOWER 1.8667", "pair_id": "python_p03416_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 3.6471} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\n\nvar_7 = sys.stdin.readline\nfrom itertools import combinations\n\n\ndef func_3(var_10):\n for _ in range(var_10):\n yield list(map(int, var_7().split()))\n\n\ndef func_1(var_9, var_5, var_11):\n var_3 = sum(1 if var_5[var_8] == 1 else 0 for var_8 in var_9)\n return var_11[var_3]\n\n\ndef func_2():\n var_10 = int(eval(var_7()))\n var_1 = list(func_3(var_10))\n var_2 = list(func_3(var_10))\n for var_6 in range(1, 11):\n for var_4 in combinations(list(range(10)), var_6):\n yield sum(\n func_1(var_4, var_5, var_11) for var_5, var_11 in zip(var_1, var_2)\n )\n\n\nprint((max(func_2())))\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\nimport numpy as np\n\nvar_5 = sys.stdin.readline\n\nvar_7 = int(eval(var_5()))\n\nvar_1 = [var_5().replace(\" \", \"\") for var_4 in range(var_7)]\n\nvar_8 = [list(map(int, var_5().split())) for var_4 in range(var_7)]\n\n\nvar_12 = -999999999999999\n\nfor var_4 in range(1, 1024):\n\n var_3 = format(var_4, \"010b\")\n\n var_10 = 0\n for var_2, var_9 in zip(var_1, var_8):\n\n var_11 = 0\n for var_6 in range(10):\n\n if var_2[var_6] == \"1\" and var_3[var_6] == \"1\":\n\n var_11 += 1\n\n var_10 += var_9[var_11]\n if var_10 > var_12:\n\n var_12 = var_10\nprint(var_12)\n```", "output": "SLOWER 1.0796", "pair_id": "python_p03503_reversed", "problem_id": "p03503", "language": "python", "direction": "reversed", "speedup_ratio": 2.1134} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_6 in range(var_1, var_2 + 1):\n var_3 = str(var_6)\n var_5 = True\n for var_7 in range(len(var_3) // 2):\n if var_3[var_7] != var_3[-var_7 - 1] and var_5:\n var_5 = not var_5\n if var_5:\n var_4 += 1\nprint(var_4)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_5 in range(var_1, var_2 + 1):\n var_3 = str(var_5)\n if var_3[0] == var_3[-1] and var_3[1] == var_3[-2]:\n var_4 += 1\nprint(var_4)\n```", "output": "FASTER 1.5515", "pair_id": "python_p03416_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 2.9313} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_6 = sorted([list(map(int, input().split())) for var_5 in range(var_1)])\n\nvar_4 = [[0] * (var_2 + 1) for var_5 in range(var_1 + 1)]\n\nfor var_5 in range(var_1):\n var_9, var_8 = var_6[var_5]\n for var_7 in range(var_2 + 1):\n if var_7 + var_9 <= var_2:\n var_4[var_5 + 1][var_7 + var_9] = max(\n var_4[var_5 + 1][var_7 + var_9], var_4[var_5][var_7] + var_8\n )\n var_4[var_5 + 1][var_7] = max(var_4[var_5][var_7], var_4[var_5 + 1][var_7])\nvar_3 = 0\nfor var_5, (var_9, var_8) in enumerate(var_6):\n for var_7 in range(var_2):\n var_3 = max(var_3, var_4[var_5][var_7] + var_8)\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\ndef func_1():\n var_2, var_3, *var_1 = list(map(int, open(0).read().split()))\n var_4 = [0] * (var_3 + max(var_1[::2]))\n for var_7, var_6 in sorted(zip(*[iter(var_1)] * 2)):\n for var_5 in reversed(list(range(var_3))):\n var_4[var_5 + var_7] = max(var_4[var_5 + var_7], var_4[var_5] + var_6)\n print((max(var_4)))\n\n\nfunc_1()\n```", "output": "FASTER 2.0608", "pair_id": "python_p02863_forward", "problem_id": "p02863", "language": "python", "direction": "forward", "speedup_ratio": 4.1721} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_8 = int(eval(input()))\nvar_6 = []\nfor var_7 in range(var_8 - 1):\n var_1, var_3 = list(map(int, input().split()))\n var_6.append([var_1 - 1, var_3 - 1, var_7])\nvar_6.sort()\nvar_12 = [0] * (var_8)\nvar_2 = [0] * (var_8 - 1)\nvar_9 = 1\nvar_10 = 0\nfor var_5 in var_6:\n _from, var_11, var_7 = var_5\n if _from != var_10:\n var_9 = 1\n if var_12[_from] == var_9:\n var_9 += 1\n var_2[var_7] = var_9\n var_12[var_11] = var_9\n var_9 += 1\n var_10 = _from\nprint((max(var_2)))\nfor var_4 in var_2:\n print(var_4)\n```\n\n=== Code B (Modified) ===\n```python\nimport copy\n\nvar_8 = int(eval(input()))\nvar_10 = set([var_6 for var_6 in range(1, 10**5)])\nvar_5 = []\nvar_11 = {}\nvar_9 = []\nfor var_6 in range(var_8 - 1):\n var_1, var_2 = list(map(int, input().split(\" \")))\n var_5.append([var_1, var_2])\n var_11.setdefault(var_1, []).append(var_2)\n var_9.append([])\nvar_9.append([])\nvar_9.append([])\nvar_7 = 0\nfor var_12 in range(1, var_8 + 1):\n var_14 = var_11.get(var_12, [])\n var_3 = 1\n for var_13 in var_14:\n if var_3 in var_9[var_12]:\n var_3 += 1\n else:\n pass\n var_9[var_13].append(var_3)\n if var_3 >= var_7:\n var_7 = var_3\n var_3 += 1\nprint(var_7)\nfor var_4 in var_5:\n print((var_9[var_4[1]][0]))\n```", "output": "SLOWER 4.8668", "pair_id": "python_p02850_reversed", "problem_id": "p02850", "language": "python", "direction": "reversed", "speedup_ratio": 29.178} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\nimport numpy as np\n\nvar_5 = sys.stdin.readline\n\nvar_7 = int(eval(var_5()))\n\nvar_1 = [var_5().replace(\" \", \"\") for var_4 in range(var_7)]\n\nvar_8 = [list(map(int, var_5().split())) for var_4 in range(var_7)]\n\n\nvar_12 = -999999999999999\n\nfor var_4 in range(1, 1024):\n\n var_3 = format(var_4, \"010b\")\n\n var_10 = 0\n for var_2, var_9 in zip(var_1, var_8):\n\n var_11 = 0\n for var_6 in range(10):\n\n if var_2[var_6] == \"1\" and var_3[var_6] == \"1\":\n\n var_11 += 1\n\n var_10 += var_9[var_11]\n if var_10 > var_12:\n\n var_12 = var_10\nprint(var_12)\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\nimport itertools\n\n\ndef func_2(var_4):\n return bin(eval(\"0b\" + str(var_4)))\n\n\ndef func_1():\n var_4 = int(sys.stdin.readline().rstrip())\n var_9 = [\n func_2(\"\".join(str(var_10) for var_10 in sys.stdin.readline().split()))\n for _ in range(var_4)\n ]\n var_8 = [\n [int(var_10) for var_10 in sys.stdin.readline().split()] for _ in range(var_4)\n ]\n var_3 = -(10**10)\n for var_6 in itertools.product(\"01\", repeat=10):\n var_6 = func_2(\"\".join(var_6))\n if var_6 == \"0b0\":\n continue\n var_7 = 0\n for var_2 in range(var_4):\n var_1 = var_9[var_2]\n var_5 = bin(eval(var_1) & eval(var_6)).count(\"1\")\n var_7 += var_8[var_2][var_5]\n var_3 = max(var_3, var_7)\n print(var_3)\n\n\nif __name__ == \"__main__\":\n\n func_1()\n```", "output": "SLOWER 2.5695", "pair_id": "python_p03503_reversed", "problem_id": "p03503", "language": "python", "direction": "reversed", "speedup_ratio": 5.9361} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\n\nvar_9 = sys.stdin.readline\nfrom operator import itemgetter\n\nvar_3, var_4 = list(map(int, var_9().split()))\nvar_1 = [list(map(int, var_9().split())) for _ in range(var_3)]\nvar_1.sort(key=itemgetter(0))\nvar_8 = [[0 for _ in range(var_3 + 1)] for _ in range(var_4 + 1)]\n\nvar_2 = []\nfor var_10 in range(var_3):\n var_5, var_7 = var_1[var_10]\n for var_11 in range(var_4):\n if var_5 > var_11:\n var_8[var_11][var_10 + 1] = var_8[var_11][var_10]\n else:\n if var_7 + var_8[var_11 - var_5][var_10] >= var_8[var_11][var_10]:\n var_8[var_11][var_10 + 1] = var_8[var_11 - var_5][var_10] + var_7\n else:\n var_8[var_11][var_10 + 1] = var_8[var_11][var_10]\n var_2.append(var_8[var_4 - 1][var_10] + var_7)\nvar_6 = max(var_2)\nprint(var_6)\n```\n\n=== Code B (Modified) ===\n```python\nvar_6, var_7 = list(map(int, input().split()))\nvar_1 = [list(map(int, input().split())) for _ in range(var_6)]\nvar_1.sort()\nvar_3 = [(6007) * [0] for _ in range(var_6 + 1)]\nvar_3[0][0] = 0\nvar_2 = 0\nfor var_4 in range(var_6):\n for var_5 in range(6007):\n var_3[var_4 + 1][var_5] = max(var_3[var_4 + 1][var_5], var_3[var_4][var_5])\n if var_5 < var_7:\n var_3[var_4 + 1][var_5 + var_1[var_4][0]] = max(\n var_3[var_4][var_5] + var_1[var_4][1],\n var_3[var_4][var_5 + var_1[var_4][0]],\n )\n var_2 = max(var_2, var_3[var_4 + 1][var_5])\nprint(var_2)\n```", "output": "SLOWER 5.7437", "pair_id": "python_p02863_reversed", "problem_id": "p02863", "language": "python", "direction": "reversed", "speedup_ratio": 53.5847} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_6 = input()[::-1]\nvar_4 = len(var_6)\nvar_2 = [0] * 2019\nvar_2[0] = 1\nvar_7 = 1\nvar_5 = 0\nvar_1 = 0\nfor var_3 in range(var_4):\n var_5 = (var_5 + int(var_6[var_3]) * var_7) % 2019\n var_7 = var_7 * 10 % 2019\n var_2[var_5] += 1\nfor var_3 in var_2:\n var_1 += var_3 * (var_3 - 1) // 2\nprint(var_1)\n```\n\n=== Code B (Modified) ===\n```python\nvar_6 = 2019\nvar_1 = [0] * var_6\nvar_3 = 1\nvar_5 = var_4 = 0\nfor var_2 in input()[::-1]:\n var_1[var_4] += 1\n var_4 -= int(var_2) * var_3\n var_4 %= var_6\n var_5 += var_1[var_4]\n var_3 *= 10\n var_3 %= var_6\nprint(var_5)\n```", "output": "FASTER 2.8807", "pair_id": "python_p02702_forward", "problem_id": "p02702", "language": "python", "direction": "forward", "speedup_ratio": 7.3649} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_3, var_8 = list(map(int, input().split()))\nvar_2 = list(map(int, input().split()))\nvar_4 = list(map(int, input().split()))\nvar_7 = min(var_2) + min(var_4)\nvar_9 = [0] * var_8\nvar_10 = [0] * var_8\nvar_5 = [0] * var_8\nfor var_6 in range(var_8):\n var_9[var_6], var_10[var_6], var_5[var_6] = list(map(int, input().split()))\n var_9[var_6] -= 1\n var_10[var_6] -= 1\nfor var_6 in range(var_8):\n var_7 = min(var_7, var_2[var_9[var_6]] + var_4[var_10[var_6]] - var_5[var_6])\nprint(var_7)\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\nfrom collections import Counter\n\n\ndef func_10():\n return sys.stdin.readline().strip()\n\n\ndef func_11(var_12, var_13, var_14):\n return [[var_14] * var_13 for var_17 in range(var_12)]\n\n\ndef func_12(var_12, var_13, var_14, var_15):\n return [[[var_15] * var_14 for var_18 in range(var_13)] for var_17 in range(var_12)]\n\n\ndef func_13(var_12, var_13, var_14, var_15, var_16):\n return [\n [[[var_16] * var_15 for var_18 in range(var_14)] for var_18 in range(var_13)]\n for var_17 in range(var_12)\n ]\n\n\ndef func_8(var_22, var_23=1):\n return int(-(-var_22 // var_23))\n\n\ndef func_1():\n return int(eval(func_10()))\n\n\ndef func_3():\n return list(map(int, func_10().split()))\n\n\ndef func_2(var_11=None):\n return list(func_3()) if var_11 is None else [func_1() for var_17 in range(var_11)]\n\n\ndef func_7():\n print(\"Yes\")\n\n\ndef func_5():\n print(\"No\")\n\n\ndef func_6():\n print(\"YES\")\n\n\ndef func_4():\n print(\"NO\")\n\n\nsys.setrecursionlimit(10**9)\nvar_5 = 10**18\nvar_10 = 10**9 + 7\n\n\ndef func_9(var_1, var_2):\n \"\"\"\"\"\"\n import numpy as np\n from numpy.fft import rfft, irfft\n\n var_8 = max(var_1)\n var_9 = max(var_2)\n var_3 = [0] * (var_8 + 1)\n var_4 = [0] * (var_9 + 1)\n for var_12 in var_1:\n var_3[var_12] += 1\n for var_13 in var_2:\n var_4[var_13] += 1\n\n var_6 = 1\n var_19 = 0\n while var_6 <= var_8 + var_9:\n var_19 += 1\n var_6 = 2**var_19\n\n var_21 = irfft(rfft(var_3, var_6) * rfft(var_4, var_6), var_6)\n\n var_21 = np.rint(var_21).astype(np.int64)\n return var_21\n\n\nvar_11, var_7, var_6 = func_3()\nvar_1 = func_2()\nvar_2 = func_2()\nvar_21 = list(func_9(var_1, var_2))\nvar_20 = var_5\nfor var_17, var_12 in enumerate(var_21):\n if var_12 != 0:\n var_20 = var_17\n break\nfor _ in range(var_6):\n var_22, var_23, var_14 = func_3()\n var_22 -= 1\n var_23 -= 1\n var_20 = min(var_20, var_1[var_22] + var_2[var_23] - var_14)\nprint(var_20)\n```", "output": "SLOWER 2.762", "pair_id": "python_p02748_reversed", "problem_id": "p02748", "language": "python", "direction": "reversed", "speedup_ratio": 6.7835} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\nfrom collections import Counter\n\n\ndef func_10():\n return sys.stdin.readline().strip()\n\n\ndef func_11(var_12, var_13, var_14):\n return [[var_14] * var_13 for var_17 in range(var_12)]\n\n\ndef func_12(var_12, var_13, var_14, var_15):\n return [[[var_15] * var_14 for var_18 in range(var_13)] for var_17 in range(var_12)]\n\n\ndef func_13(var_12, var_13, var_14, var_15, var_16):\n return [\n [[[var_16] * var_15 for var_18 in range(var_14)] for var_18 in range(var_13)]\n for var_17 in range(var_12)\n ]\n\n\ndef func_8(var_22, var_23=1):\n return int(-(-var_22 // var_23))\n\n\ndef func_1():\n return int(eval(func_10()))\n\n\ndef func_3():\n return list(map(int, func_10().split()))\n\n\ndef func_2(var_11=None):\n return list(func_3()) if var_11 is None else [func_1() for var_17 in range(var_11)]\n\n\ndef func_7():\n print(\"Yes\")\n\n\ndef func_5():\n print(\"No\")\n\n\ndef func_6():\n print(\"YES\")\n\n\ndef func_4():\n print(\"NO\")\n\n\nsys.setrecursionlimit(10**9)\nvar_5 = 10**18\nvar_10 = 10**9 + 7\n\n\ndef func_9(var_1, var_2):\n \"\"\"\"\"\"\n import numpy as np\n from numpy.fft import rfft, irfft\n\n var_8 = max(var_1)\n var_9 = max(var_2)\n var_3 = [0] * (var_8 + 1)\n var_4 = [0] * (var_9 + 1)\n for var_12 in var_1:\n var_3[var_12] += 1\n for var_13 in var_2:\n var_4[var_13] += 1\n\n var_6 = 1\n var_19 = 0\n while var_6 <= var_8 + var_9:\n var_19 += 1\n var_6 = 2**var_19\n\n var_21 = irfft(rfft(var_3, var_6) * rfft(var_4, var_6), var_6)\n\n var_21 = np.rint(var_21).astype(np.int64)\n return var_21\n\n\nvar_11, var_7, var_6 = func_3()\nvar_1 = func_2()\nvar_2 = func_2()\nvar_21 = list(func_9(var_1, var_2))\nvar_20 = var_5\nfor var_17, var_12 in enumerate(var_21):\n if var_12 != 0:\n var_20 = var_17\n break\nfor _ in range(var_6):\n var_22, var_23, var_14 = func_3()\n var_22 -= 1\n var_23 -= 1\n var_20 = min(var_20, var_1[var_22] + var_2[var_23] - var_14)\nprint(var_20)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2, var_3 = list(map(int, input().split()))\nvar_4 = list(map(int, input().split()))\nvar_6 = list(map(int, input().split()))\nvar_5 = min(var_4) + min(var_6)\nfor var_8 in range(var_3):\n var_7 = list(map(int, input().split()))\n var_9 = var_4[var_7[0] - 1] + var_6[var_7[1] - 1] - var_7[2]\n var_5 = min(var_9, var_5)\nprint(var_5)\n```", "output": "FASTER 3.1615", "pair_id": "python_p02748_forward", "problem_id": "p02748", "language": "python", "direction": "forward", "speedup_ratio": 8.9474} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_5 in range(10):\n for var_6 in range(10):\n for var_7 in range(10):\n var_3 = 10000 * var_5 + 1000 * var_6 + 100 * var_7 + 10 * var_6 + var_5\n if var_1 <= var_3 <= var_2:\n var_4 += 1\nprint(var_4)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = list(str(var_4))\n if var_5 == list(reversed(var_5)):\n var_3 += 1\nprint(var_3)\n```", "output": "SLOWER 5.0577", "pair_id": "python_p03416_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 33.3066} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1 = list(map(int, input().split()))\nvar_2 = 0\nfor var_3 in range(var_1[0], var_1[1] + 1):\n var_4 = str(var_3)\n if var_4[0] == var_4[4] and var_4[1] == var_4[3]:\n var_2 += 1\nprint(var_2)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_3 in range(var_1, var_2 + 1):\n var_5 = list(str(var_3))\n var_6 = list(reversed(var_5))\n if var_5 == var_6:\n var_4 += 1\nprint(var_4)\n```", "output": "SLOWER 1.5975", "pair_id": "python_p03416_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 3.0261} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_5 in range(10):\n for var_6 in range(10):\n for var_7 in range(10):\n var_3 = 10000 * var_5 + 1000 * var_6 + 100 * var_7 + 10 * var_6 + var_5\n if var_1 <= var_3 <= var_2:\n var_4 += 1\nprint(var_4)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_8 in range(var_1, var_2 + 1):\n var_7 = str(var_8)\n var_6 = len(var_7)\n var_4 = True\n for var_5 in range(var_6 // 2):\n if var_7[var_5] != var_7[var_6 - 1 - var_5]:\n var_4 = False\n break\n if var_4:\n var_3 += 1\nprint(var_3)\n```", "output": "SLOWER 4.9518", "pair_id": "python_p03416_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 30.9483} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_4 = {}\nvar_5 = 0\nfor var_6 in range(10000, 100000):\n var_3 = list(str(var_6))\n if var_3 == list(reversed(var_3)):\n var_5 += 1\n var_4[var_6] = var_5\nvar_1, var_2 = list(map(int, input().split()))\nprint((var_4[var_2] - var_4[var_1 - 1] if var_1 > 10000 else var_4[var_2]))\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = [\n var_3 for var_3 in map(str, list(range(var_1, var_2 + 1))) if var_3 == var_3[::-1]\n]\nprint((len(var_4)))\n```", "output": "FASTER 4.2722", "pair_id": "python_p03416_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 19.3219} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nfrom collections import Counter\n\nvar_4 = int(eval(input()))\nvar_1 = list(map(int, input().split()))\nvar_2 = Counter(var_1)\nvar_3 = list(var_2.keys())\nvar_5 = list(var_2.values())\nif (\n len(var_2) == 3\n and var_3[0] ^ var_3[1] ^ var_3[2] == 0\n and var_5[0] == var_5[1] == var_5[2]\n):\n print(\"Yes\")\nelif (\n len(var_2) == 2\n and 0 in var_3\n and (var_5[0] == var_5[1] * 2 or var_5[1] == var_5[0] * 2)\n):\n print(\"Yes\")\nelif len(var_2) == 1 and 0 in var_3:\n print(\"Yes\")\nelse:\n print(\"No\")\n```\n\n=== Code B (Modified) ===\n```python\n_, var_1 = open(0)\nvar_1, *var_2 = list(map(int, var_1.split()))\nfor var_2 in var_2:\n var_1 ^= var_2\nprint((\"YNeos\"[var_1 > 0 :: 2]))\n```", "output": "FASTER 1.0753", "pair_id": "python_p02975_forward", "problem_id": "p02975", "language": "python", "direction": "forward", "speedup_ratio": 2.1071} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\nimport math\nfrom collections import defaultdict\nfrom bisect import bisect_left, bisect_right\n\nsys.setrecursionlimit(10**7)\n\n\ndef func_4():\n return sys.stdin.readline()[:-1]\n\n\nvar_4 = 10**9 + 7\n\n\ndef func_1():\n return int(eval(func_4()))\n\n\ndef func_2():\n return list(map(int, func_4().split()))\n\n\ndef func_3(var_6, var_3):\n if var_6 <= 0:\n return [[] for _ in range(var_3)]\n elif var_3 == 1:\n return [func_1() for _ in range(var_6)]\n else:\n var_5 = [func_2() for _ in range(var_6)]\n return list(map(list, list(zip(*var_5))))\n\n\nvar_1, var_2 = list(map(str, func_4().split()))\nvar_1 = int(var_1)\nvar_2 = 100 * int(var_2[0]) + 10 * int(var_2[2]) + int(var_2[3])\nprint((var_1 * var_2 // 100))\n```\n\n=== Code B (Modified) ===\n```python\nfrom fractions import Fraction\n\nvar_1, var_2 = input().split()\n\n\nfrom decimal import *\n\nvar_4 = var_3(var_1)\nvar_6 = var_3(var_2)\nvar_7().prec = 28\nvar_5 = var_4 * var_6\nprint((int(var_5)))\n```", "output": "FASTER 1.9202", "pair_id": "python_p02659_forward", "problem_id": "p02659", "language": "python", "direction": "forward", "speedup_ratio": 3.7848} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_3 = list(map(int, input().split()))\nvar_2 = 0\nfor var_5 in range(var_3 + 1)[var_1:]:\n if len(str(var_5)) % 2 == 0:\n var_6 = list(str(var_5))[: len(str(var_5)) // 2]\n var_7 = list(reversed(list(str(var_5))[len(str(var_5)) // 2 :]))\n if var_6 == var_7:\n var_2 += 1\n else:\n var_8 = list(str(var_5))[: len(str(var_5)) // 2 + 1]\n var_4 = list(reversed(list(str(var_5))[len(str(var_5)) // 2 :]))\n if var_8 == var_4:\n var_2 += 1\nprint(var_2)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_6 in range(var_1, var_2 + 1):\n var_3 = str(var_6)\n var_5 = True\n for var_7 in range(len(var_3) // 2):\n if var_3[var_7] != var_3[-var_7 - 1] and var_5:\n var_5 = not var_5\n if var_5:\n var_4 += 1\nprint(var_4)\n```", "output": "FASTER 1.0146", "pair_id": "python_p03416_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 2.0203} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1 = list(map(int, input().split()))\nvar_2 = 0\nfor var_3 in range(var_1[0], var_1[1] + 1):\n var_4 = str(var_3)\n if var_4[0] == var_4[4] and var_4[1] == var_4[3]:\n var_2 += 1\nprint(var_2)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_3 = list(map(int, input().split()))\nvar_2 = 0\nfor var_5 in range(var_3 + 1)[var_1:]:\n if len(str(var_5)) % 2 == 0:\n var_6 = list(str(var_5))[: len(str(var_5)) // 2]\n var_7 = list(reversed(list(str(var_5))[len(str(var_5)) // 2 :]))\n if var_6 == var_7:\n var_2 += 1\n else:\n var_8 = list(str(var_5))[: len(str(var_5)) // 2 + 1]\n var_4 = list(reversed(list(str(var_5))[len(str(var_5)) // 2 :]))\n if var_8 == var_4:\n var_2 += 1\nprint(var_2)\n```", "output": "SLOWER 2.7633", "pair_id": "python_p03416_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 6.7897} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\n\nvar_8 = sys.stdin.readline\n\n\ndef func_1():\n var_2 = int(eval(var_8()))\n var_1 = []\n for _ in range(var_2):\n var_1.append(list(map(int, var_8().split())))\n var_3 = []\n for _ in range(var_2):\n var_3.append(list(map(int, var_8().split())))\n var_4 = -(10**7) * var_2\n for var_7 in range(1, 1 << 10):\n var_11 = 0\n for var_10, var_6 in enumerate(var_1):\n var_5 = 0\n for var_9 in range(10):\n if (var_7 >> var_9) & 1 & var_6[var_9]:\n var_5 += 1\n var_11 += var_3[var_10][var_5]\n var_4 = max(var_4, var_11)\n print(var_4)\n\n\nif __name__ == \"__main__\":\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\n\nvar_8 = sys.stdin.readline\n\n\ndef func_1():\n var_2 = int(eval(var_8()))\n var_1 = [int(var_8().replace(\" \", \"\"), 2) for _ in range(var_2)]\n var_3 = [list(map(int, var_8().split())) for _ in range(var_2)]\n var_4 = -(10**7) * var_2\n for var_7 in range(1, 1 << 10):\n var_10 = 0\n for var_9, var_6 in enumerate(var_1):\n var_5 = bin(var_7 & var_6).count(\"1\")\n var_10 += var_3[var_9][var_5]\n var_4 = max(var_4, var_10)\n print(var_4)\n\n\nif __name__ == \"__main__\":\n func_1()\n```", "output": "FASTER 1.7721", "pair_id": "python_p03503_forward", "problem_id": "p03503", "language": "python", "direction": "forward", "speedup_ratio": 3.4156} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nfrom sys import stdin\n\nvar_6 = lambda: list(map(int, stdin.readline().split()))\nvar_5 = lambda: list(map(int, stdin.readline().split()))\nvar_1, var_3 = var_6()\nvar_2 = 0\nfor var_4 in range(var_1, var_3 + 1):\n var_7 = str(var_4)\n if var_7 == var_7[::-1]:\n var_2 += 1\nprint(var_2)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().rstrip().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = list(map(int, list(str(var_4))))\n if var_5[0] == var_5[4] and var_5[1] == var_5[3]:\n var_3 += 1\nprint(var_3)\n```", "output": "SLOWER 1.6646", "pair_id": "python_p03416_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 3.1703} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_6 in range(var_1, var_2 + 1):\n var_3 = str(var_6)\n var_5 = True\n for var_7 in range(len(var_3) // 2):\n if var_3[var_7] != var_3[-var_7 - 1] and var_5:\n var_5 = not var_5\n if var_5:\n var_4 += 1\nprint(var_4)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\n\n\ndef func_1(var_5, var_6):\n var_4 = 0\n for var_3 in range(var_5, var_6 + 1):\n if str(var_3) == str(var_3)[::-1]:\n var_4 += 1\n return var_4\n\n\nprint((func_1(var_1, var_2)))\n```", "output": "FASTER 1.7836", "pair_id": "python_p03416_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 3.4428} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\n\n\ndef func_1(var_5):\n var_4 = 0\n for var_3 in range(1, var_5 + 1):\n if str(var_3) == str(var_3)[::-1]:\n var_4 += 1\n return var_4\n\n\nprint((func_1(var_2) - func_1(var_1 - 1)))\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().strip().split(\" \")))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n if str(var_4) == str(var_4)[::-1]:\n var_3 += 1\nprint(var_3)\n```", "output": "FASTER 1.2833", "pair_id": "python_p03416_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 2.434} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = [0] * (var_2 + 1)\nfor var_3 in range(1, var_2 + 1):\n if str(var_3) == str(var_3)[::-1]:\n var_4[var_3] = var_4[var_3 - 1] + 1\n else:\n var_4[var_3] = var_4[var_3 - 1]\nprint((var_4[var_2] - var_4[var_1 - 1]))\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = [\n var_3 for var_3 in map(str, list(range(var_1, var_2 + 1))) if var_3 == var_3[::-1]\n]\nprint((len(var_4)))\n```", "output": "FASTER 2.6408", "pair_id": "python_p03416_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 6.2369} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\ndef func_1():\n from collections import Counter\n\n var_4 = int(eval(input()))\n (*var_1,) = list(map(int, input().split()))\n if var_4 % 3 == 0:\n var_2 = Counter(var_1)\n if len(var_2) == 1:\n print((\"Yes\" if 0 in var_2 else \"No\"))\n return\n elif len(var_2) == 2:\n print((\"Yes\" if var_2[0] == var_4 // 3 else \"No\"))\n return\n elif len(var_2) == 3:\n var_7 = 0\n var_5 = None\n for var_3, var_6 in list(var_2.items()):\n if var_5 is None:\n var_5 = var_6\n elif var_5 != var_6:\n print(\"No\")\n return\n var_7 ^= var_3\n print((\"Yes\" if var_7 == 0 else \"No\"))\n return\n else:\n print(\"No\")\n return\n else:\n print((\"Yes\" if all([var_7 == 0 for var_7 in var_1]) else \"No\"))\n return\n\n\nif __name__ == \"__main__\":\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nfrom functools import *\n\n_, var_1 = open(0)\nprint(\n (\n \"YNeos\"[\n var_2(lambda var_3, var_4: var_3 ^ var_4, list(map(int, var_1.split())))\n > 0 :: 2\n ]\n )\n)\n```", "output": "FASTER 1.4188", "pair_id": "python_p02975_forward", "problem_id": "p02975", "language": "python", "direction": "forward", "speedup_ratio": 2.6736} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nfrom sys import stdin\n\n\ndef func_1():\n\n var_9 = stdin.readline\n var_8, var_10 = list(map(int, var_9().split()))\n var_7 = [list(map(int, var_9().split())) for _ in range(var_8)]\n var_7.sort()\n var_1 = [0] * var_8\n var_2 = [0] * var_8\n for var_4 in range(var_8):\n var_1[var_4], var_2[var_4] = var_7[var_4][0], var_7[var_4][1]\n\n var_5 = -(10**9)\n var_3 = [[var_5] * (var_10 + 1) for _ in range(var_8 + 1)]\n var_3[0][0] = 0\n for var_4 in range(var_8):\n for var_6 in range(var_10 + 1):\n\n if var_6 != var_10:\n var_3[var_4 + 1][min(var_10, var_6 + var_1[var_4])] = max(\n var_3[var_4 + 1][min(var_10, var_6 + var_1[var_4])],\n var_3[var_4][var_6] + var_2[var_4],\n )\n\n var_3[var_4 + 1][var_6] = max(var_3[var_4 + 1][var_6], var_3[var_4][var_6])\n print((max(var_3[var_8])))\n\n\nif __name__ == \"__main__\":\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nfrom collections import Counter, defaultdict, deque\nfrom heapq import heappop, heappush, heapify\nimport sys, bisect, math, itertools, fractions, pprint\n\nsys.setrecursionlimit(10**8)\nvar_6 = 10**9 + 7\nvar_1 = float(\"inf\")\n\n\ndef func_1():\n return int(sys.stdin.readline())\n\n\ndef func_2():\n return list(map(int, sys.stdin.readline().split()))\n\n\nvar_7, var_9 = func_2()\nvar_13 = [func_2() for _ in range(var_7)]\nvar_13.sort(key=lambda var_14: var_14[1], reverse=True)\nvar_8 = 0\nvar_10 = min(var_7, 5)\nfor var_3 in range(var_10):\n var_2 = [[0] * (var_9 + 5) for _ in range(var_7 + 5)]\n for var_4 in range(var_7):\n var_12, var_11 = var_13[var_4]\n for var_5 in range(var_9):\n if var_5 < var_12 or var_3 == var_4:\n var_2[var_4 + 1][var_5] = var_2[var_4][var_5]\n else:\n var_2[var_4 + 1][var_5] = max(\n var_2[var_4][var_5], var_2[var_4][var_5 - var_12] + var_11\n )\n\n var_8 = max(var_2[var_7][var_9 - 1] + var_13[var_3][1], var_8)\nprint(var_8)\n```", "output": "SLOWER 1.7415", "pair_id": "python_p02863_reversed", "problem_id": "p02863", "language": "python", "direction": "reversed", "speedup_ratio": 3.3438} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_6 = input()[::-1]\nvar_5 = len(var_6)\nvar_1 = [0] * var_5\nvar_3 = [0] * var_5\nvar_2 = [0] * 2019\nvar_7 = 10\nvar_1[0] = int(var_6[0])\nvar_3[0] = var_1[0]\nvar_2[var_3[0]] += 1\nfor var_4 in range(1, var_5):\n var_1[var_4] = int(var_6[var_4]) * var_7 % 2019\n var_3[var_4] = (var_3[var_4 - 1] + var_1[var_4]) % 2019\n var_2[var_3[var_4]] += 1\n var_7 = var_7 * 10 % 2019\nprint(\n (\n int(sum([var_2[var_4] * (var_2[var_4] - 1) for var_4 in range(2019)]) / 2)\n + var_2[0]\n )\n)\n```\n\n=== Code B (Modified) ===\n```python\nimport numpy as np\n\nvar_7 = input()[::-1]\nvar_6 = len(var_7)\nvar_1 = np.zeros(var_6, dtype=int)\nvar_4 = np.zeros(var_6, dtype=int)\nvar_2 = np.zeros(2019, dtype=int)\nvar_8 = 10\nvar_1[0] = int(var_7[0])\nvar_4[0] = var_1[0]\nvar_2[var_4[0]] += 1\nfor var_5 in range(1, var_6):\n var_1[var_5] = int(var_7[var_5]) * var_8 % 2019\n var_4[var_5] = (var_4[var_5 - 1] + var_1[var_5]) % 2019\n var_2[var_4[var_5]] += 1\n var_8 = var_8 * 10 % 2019\nvar_3 = var_2[np.nonzero(var_2)]\nprint(\n (\n int(\n sum([var_3[var_5] * (var_3[var_5] - 1) for var_5 in range(var_3.shape[0])])\n / 2\n )\n + var_2[0]\n )\n)\n```", "output": "FASTER 1.0297", "pair_id": "python_p02702_forward", "problem_id": "p02702", "language": "python", "direction": "forward", "speedup_ratio": 2.0416} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_4 = int(eval(input()))\nvar_2 = list(map(int, input().split()))\n\n\ndef func_1(var_1, var_8, var_3):\n if var_8 == var_4:\n var_9 = 1\n for var_5 in var_3:\n var_9 *= var_5\n return 1 if var_9 % 2 == 0 else 0\n var_6 = var_3.copy()\n var_6.append(var_1[var_8] - 1)\n var_5 = var_3.copy()\n var_5.append(var_1[var_8])\n var_7 = var_3.copy()\n var_7.append(var_1[var_8] + 1)\n return (\n func_1(var_1, var_8 + 1, var_6)\n + func_1(var_1, var_8 + 1, var_5)\n + func_1(var_1, var_8 + 1, var_7)\n )\n\n\nprint((func_1(var_2, 0, [])))\n```\n\n=== Code B (Modified) ===\n```python\nvar_2 = int(eval(input()))\n(*var_1,) = list(map(int, input().split()))\nvar_5 = 0\nfor var_3 in var_1:\n if var_3 % 2 == 0:\n var_5 += 1\nvar_4 = 3**var_2 - 2**var_5\nprint(var_4)\n```", "output": "FASTER 8.2861", "pair_id": "python_p03568_forward", "problem_id": "p03568", "language": "python", "direction": "forward", "speedup_ratio": 312.1488} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\n\n\ndef func_1(var_5, var_6):\n var_4 = 0\n for var_3 in range(var_5, var_6 + 1):\n if str(var_3) == str(var_3)[::-1]:\n var_4 += 1\n return var_4\n\n\nprint((func_1(var_1, var_2)))\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().rstrip().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = list(map(int, list(str(var_4))))\n if var_5[0] == var_5[4] and var_5[1] == var_5[3]:\n var_3 += 1\nprint(var_3)\n```", "output": "SLOWER 2.0067", "pair_id": "python_p03416_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 4.0185} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nfrom itertools import product\n\nvar_6 = int(eval(input()))\nvar_1 = list(map(int, input().split()))\nvar_5 = 0\nfor var_2 in product((-1, 0, 1), repeat=var_6):\n var_7 = 1\n for var_3, var_4 in zip(var_1, var_2):\n var_7 *= var_3 + var_4\n if var_7 % 2 == 0:\n var_5 += 1\nprint(var_5)\n```\n\n=== Code B (Modified) ===\n```python\nvar_4 = int(eval(input()))\nvar_1 = list(map(int, input().split()))\nvar_3 = 1\nfor var_2 in var_1:\n var_3 *= 2 if var_2 % 2 == 0 else 1\nprint((3**var_4 - var_3))\n```", "output": "FASTER 10.1524", "pair_id": "python_p03568_forward", "problem_id": "p03568", "language": "python", "direction": "forward", "speedup_ratio": 1138.1035} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\nfrom collections import deque\n\nvar_1 = int(10e10)\nvar_2 = -var_1\nvar_12 = 1000000007\nsys.setrecursionlimit(1000000)\n\n\ndef func_2():\n return list(map(int, input().split()))\n\n\ndef func_4():\n return input().split()\n\n\ndef func_1():\n return int(sys.stdin.readline())\n\n\ndef func_3():\n return eval(input())\n\n\nvar_3, var_4 = func_2()\nvar_6 = [func_2() for var_10 in range(var_3)]\nvar_6.sort()\nvar_7 = 0\nvar_9 = [[0] * var_4 for var_10 in range(var_3 + 1)]\nfor var_10 in range(1, var_3 + 1):\n var_5, var_8 = var_6[var_10 - 1]\n for var_11 in range(var_4):\n if 0 <= var_11 - var_5 < var_4:\n var_9[var_10][var_11] = max(\n var_9[var_10 - 1][var_11], var_9[var_10 - 1][var_11 - var_5] + var_8\n )\n else:\n var_9[var_10][var_11] = var_9[var_10 - 1][var_11]\n else:\n var_7 = max(var_7, var_9[var_10 - 1][-1] + var_8)\nprint(var_7)\n```\n\n=== Code B (Modified) ===\n```python\ndef func_1():\n var_2, var_3, *var_1 = list(map(int, open(0).read().split()))\n var_4 = [0] * (var_3 + max(var_1[::2]))\n for var_7, var_6 in sorted(zip(*[iter(var_1)] * 2)):\n for var_5 in reversed(list(range(var_3))):\n var_4[var_5 + var_7] = max(var_4[var_5 + var_7], var_4[var_5] + var_6)\n print((max(var_4)))\n\n\nfunc_1()\n```", "output": "FASTER 1.3844", "pair_id": "python_p02863_forward", "problem_id": "p02863", "language": "python", "direction": "forward", "speedup_ratio": 2.6106} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\ndef func_1():\n var_1, var_2 = list(map(int, input().rstrip().split()))\n var_3 = 0\n for var_4 in range(var_1, var_2 + 1):\n var_5 = str(var_4)\n if var_5 == var_5[::-1]:\n var_3 += 1\n print(var_3)\n\n\nif __name__ == \"__main__\":\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nvar_4, var_3 = list(map(int, input().split()))\nvar_1 = 0\nfor var_2 in range(var_4, var_3 + 1):\n if str(var_2)[0] + str(var_2)[1] == str(var_2)[-1] + str(var_2)[-2]:\n var_1 += 1\nprint(var_1)\n```", "output": "SLOWER 2.0871", "pair_id": "python_p03416_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 4.2489} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\nimport math\nfrom collections import defaultdict\nfrom bisect import bisect_left, bisect_right\n\nsys.setrecursionlimit(10**7)\n\n\ndef func_4():\n return sys.stdin.readline()[:-1]\n\n\nvar_4 = 10**9 + 7\n\n\ndef func_1():\n return int(eval(func_4()))\n\n\ndef func_2():\n return list(map(int, func_4().split()))\n\n\ndef func_3(var_6, var_3):\n if var_6 <= 0:\n return [[] for _ in range(var_3)]\n elif var_3 == 1:\n return [func_1() for _ in range(var_6)]\n else:\n var_5 = [func_2() for _ in range(var_6)]\n return list(map(list, list(zip(*var_5))))\n\n\nvar_1, var_2 = list(map(str, func_4().split()))\nvar_1 = int(var_1)\nvar_2 = 100 * int(var_2[0]) + 10 * int(var_2[2]) + int(var_2[3])\nprint((var_1 * var_2 // 100))\n```\n\n=== Code B (Modified) ===\n```python\nimport math\n\nvar_1, var_2 = input().split()\nvar_1 = int(var_1)\nvar_3 = int(var_2[0] + var_2[2] + var_2[3])\nprint((int(var_1 * var_3) // 100))\n```", "output": "FASTER 2.2787", "pair_id": "python_p02659_forward", "problem_id": "p02659", "language": "python", "direction": "forward", "speedup_ratio": 4.8523} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nfrom collections import Counter, defaultdict, deque\nfrom heapq import heappop, heappush, heapify\nimport sys, bisect, math, itertools, fractions, pprint\n\nsys.setrecursionlimit(10**8)\nvar_6 = 10**9 + 7\nvar_1 = float(\"inf\")\n\n\ndef func_1():\n return int(sys.stdin.readline())\n\n\ndef func_2():\n return list(map(int, sys.stdin.readline().split()))\n\n\nvar_8, var_11 = func_2()\nvar_17 = [func_2() for _ in range(var_8)]\nvar_10 = var_17[::-1]\nvar_14 = [[0] * var_11 for _ in range(var_8)]\nvar_3 = [[0] * var_11 for _ in range(var_8)]\nfor var_4 in range(var_8 - 1):\n var_16, var_15 = var_17[var_4]\n for var_5 in range(var_11):\n if var_5 < var_16:\n var_14[var_4 + 1][var_5] = var_14[var_4][var_5]\n else:\n var_14[var_4 + 1][var_5] = max(\n var_14[var_4][var_5], var_14[var_4][var_5 - var_16] + var_15\n )\nvar_9 = var_14[var_8 - 1][var_11 - 1] + var_17[var_8 - 1][1]\nfor var_4 in range(var_8 - 1):\n var_16, var_15 = var_10[var_4]\n for var_5 in range(var_11):\n if var_5 < var_16:\n var_3[var_4 + 1][var_5] = var_3[var_4][var_5]\n else:\n var_3[var_4 + 1][var_5] = max(\n var_3[var_4][var_5], var_3[var_4][var_5 - var_16] + var_15\n )\n var_9 = max(var_9, var_3[var_8 - 1][var_11 - 1] + var_17[0][1])\n\nfor var_4 in range(1, var_8 - 1):\n var_13 = var_4\n var_2 = var_8 - var_4 - 1\n var_7 = 0\n for var_5 in range(var_11):\n var_12 = var_14[var_13][var_5] + var_3[var_2][var_11 - 1 - var_5]\n var_7 = max(var_7, var_12)\n var_9 = max(var_9, var_7 + var_17[var_4][1])\nprint(var_9)\n```\n\n=== Code B (Modified) ===\n```python\nfrom sys import stdin\n\n\ndef func_1():\n\n var_9 = stdin.readline\n var_8, var_10 = list(map(int, var_9().split()))\n var_7 = [list(map(int, var_9().split())) for _ in range(var_8)]\n var_7.sort()\n var_1 = [0] * var_8\n var_2 = [0] * var_8\n for var_4 in range(var_8):\n var_1[var_4], var_2[var_4] = var_7[var_4][0], var_7[var_4][1]\n\n var_5 = -float(\"inf\")\n var_3 = [[var_5] * (var_10 + 1) for _ in range(var_8 + 1)]\n var_3[0][0] = 0\n for var_4 in range(var_8):\n for var_6 in range(var_10 + 1):\n\n if var_6 != var_10:\n var_3[var_4 + 1][min(var_10, var_6 + var_1[var_4])] = max(\n var_3[var_4 + 1][min(var_10, var_6 + var_1[var_4])],\n var_3[var_4][var_6] + var_2[var_4],\n )\n\n var_3[var_4 + 1][var_6] = max(var_3[var_4 + 1][var_6], var_3[var_4][var_6])\n print((max(var_3[var_8])))\n\n\nif __name__ == \"__main__\":\n func_1()\n```", "output": "FASTER 1.08", "pair_id": "python_p02863_forward", "problem_id": "p02863", "language": "python", "direction": "forward", "speedup_ratio": 2.114} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\n\nvar_2, var_1, *var_3 = sys.stdin.read().strip().split()\nvar_2 = int(var_2)\nvar_5 = [0] * var_2\nvar_10 = [0] * var_2\nfor var_6, var_8 in zip(*[iter(var_3)] * 2):\n var_6 = int(var_6) - 1\n if var_8 == \"AC\":\n var_5[var_6] = 1\n elif var_5[var_6] == 0:\n var_10[var_6] += 1\nvar_7 = sum([var_9 * var_4 for var_4, var_9 in zip(var_5, var_10)])\nprint((\"{} {}\".format(sum(var_5), var_7)))\n```\n\n=== Code B (Modified) ===\n```python\nvar_7, var_6 = list(map(int, input().split()))\nvar_5 = [tuple(input().split()) for _ in range(var_6)]\nvar_9 = [[] for _ in range(var_7)]\nfor var_2 in range(var_6):\n var_9[int(var_5[var_2][0]) - 1].append(var_5[var_2][1])\nvar_1, var_8 = 0, 0\nfor var_3 in range(var_7):\n if \"AC\" in var_9[var_3]:\n var_1 += 1\n for var_4 in range(len(var_9[var_3])):\n if var_9[var_3][var_4] == \"WA\":\n var_8 += 1\n else:\n break\nprint((var_1, var_8))\n```", "output": "SLOWER 1.5456", "pair_id": "python_p02802_reversed", "problem_id": "p02802", "language": "python", "direction": "reversed", "speedup_ratio": 2.9193} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_4 = str(var_4)\n if var_4 == var_4[::-1]:\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_4, var_3 = list(map(int, input().split()))\nvar_1 = 0\nfor var_2 in range(var_4, var_3 + 1):\n if str(var_2)[0] + str(var_2)[1] == str(var_2)[-1] + str(var_2)[-2]:\n var_1 += 1\nprint(var_1)\n```", "output": "SLOWER 1.1941", "pair_id": "python_p03416_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 2.288} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\n\nvar_7 = sys.stdin.readline\nfrom itertools import combinations\n\n\ndef func_3(var_10):\n for _ in range(var_10):\n yield list(map(int, var_7().split()))\n\n\ndef func_1(var_9, var_5, var_11):\n var_3 = len([0 for var_8 in var_9 if var_5[var_8] == 1])\n return var_11[var_3]\n\n\ndef func_2():\n var_10 = int(eval(var_7()))\n var_1 = list(func_3(var_10))\n var_2 = list(func_3(var_10))\n for var_6 in range(1, 11):\n for var_4 in combinations(list(range(10)), var_6):\n yield sum(\n func_1(var_4, var_5, var_11) for var_5, var_11 in zip(var_1, var_2)\n )\n\n\nprint((max(func_2())))\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\nimport itertools\n\n\ndef func_2(var_4):\n return bin(eval(\"0b\" + str(var_4)))\n\n\ndef func_1():\n var_4 = int(sys.stdin.readline().rstrip())\n var_9 = [\n func_2(\"\".join(str(var_10) for var_10 in sys.stdin.readline().split()))\n for _ in range(var_4)\n ]\n var_8 = [\n [int(var_10) for var_10 in sys.stdin.readline().split()] for _ in range(var_4)\n ]\n var_3 = -(10**10)\n for var_6 in itertools.product(\"01\", repeat=10):\n var_6 = func_2(\"\".join(var_6))\n if var_6 == \"0b0\":\n continue\n var_7 = 0\n for var_2 in range(var_4):\n var_1 = var_9[var_2]\n var_5 = bin(eval(var_1) & eval(var_6)).count(\"1\")\n var_7 += var_8[var_2][var_5]\n var_3 = max(var_3, var_7)\n print(var_3)\n\n\nif __name__ == \"__main__\":\n\n func_1()\n```", "output": "SLOWER 4.1946", "pair_id": "python_p03503_reversed", "problem_id": "p03503", "language": "python", "direction": "reversed", "speedup_ratio": 18.3107} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_8 in range(var_1, var_2 + 1):\n var_7 = str(var_8)\n var_6 = len(var_7)\n var_4 = True\n for var_5 in range(var_6 // 2):\n if var_7[var_5] != var_7[var_6 - 1 - var_5]:\n var_4 = False\n break\n if var_4:\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\n\n\ndef func_1(var_5, var_6):\n var_4 = 0\n for var_3 in range(var_5, var_6 + 1):\n if str(var_3) == str(var_3)[::-1]:\n var_4 += 1\n return var_4\n\n\nprint((func_1(var_1, var_2)))\n```", "output": "FASTER 1.4499", "pair_id": "python_p03416_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 2.7318} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_6, var_7 = list(map(int, input().split()))\nvar_1 = [list(map(int, input().split())) for _ in range(var_6)]\nvar_1.sort()\nvar_3 = [(6007) * [0] for _ in range(var_6 + 1)]\nvar_3[0][0] = 0\nvar_2 = 0\nfor var_4 in range(var_6):\n for var_5 in range(6007):\n var_3[var_4 + 1][var_5] = max(var_3[var_4 + 1][var_5], var_3[var_4][var_5])\n if var_5 < var_7:\n var_3[var_4 + 1][var_5 + var_1[var_4][0]] = max(\n var_3[var_4][var_5] + var_1[var_4][1],\n var_3[var_4][var_5 + var_1[var_4][0]],\n )\n var_2 = max(var_2, var_3[var_4 + 1][var_5])\nprint(var_2)\n```\n\n=== Code B (Modified) ===\n```python\nfrom sys import stdin\n\n\ndef func_1():\n\n var_9 = stdin.readline\n var_8, var_10 = list(map(int, var_9().split()))\n var_7 = [list(map(int, var_9().split())) for _ in range(var_8)]\n var_7.sort()\n var_1 = [0] * var_8\n var_2 = [0] * var_8\n for var_4 in range(var_8):\n var_1[var_4], var_2[var_4] = var_7[var_4][0], var_7[var_4][1]\n\n var_5 = -(10**9)\n var_3 = [[var_5] * (var_10 + 1) for _ in range(var_8 + 1)]\n var_3[0][0] = 0\n for var_4 in range(var_8):\n for var_6 in range(var_10 + 1):\n\n if var_6 != var_10:\n var_3[var_4 + 1][min(var_10, var_6 + var_1[var_4])] = max(\n var_3[var_4 + 1][min(var_10, var_6 + var_1[var_4])],\n var_3[var_4][var_6] + var_2[var_4],\n )\n\n var_3[var_4 + 1][var_6] = max(var_3[var_4 + 1][var_6], var_3[var_4][var_6])\n print((max(var_3[var_8])))\n\n\nif __name__ == \"__main__\":\n func_1()\n```", "output": "FASTER 5.8227", "pair_id": "python_p02863_forward", "problem_id": "p02863", "language": "python", "direction": "forward", "speedup_ratio": 56.5998} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nfrom math import floor\n\nvar_1, var_2 = list(map(int, input().split()))\n\n\nfor var_3 in range(1010):\n if (floor(var_3 * 0.08) == var_1) and (floor(var_3 * 0.1) == var_2):\n\n print(var_3)\n quit()\n\n\nprint((-1))\n```\n\n=== Code B (Modified) ===\n```python\nimport math\n\n\ndef func_1():\n var_1, var_2 = list(map(int, input().split()))\n\n var_5 = max(math.ceil(var_1 / 0.08), math.ceil(var_2 / 0.1))\n\n var_4 = min((math.ceil((var_1 + 1) / 0.08), math.ceil((var_2 + 1) / 0.1)))\n\n for var_3 in range(var_5, var_4 + 1):\n if (math.floor(var_3 * 0.08) == var_1) and (math.floor(var_3 * 0.1) == var_2):\n print(var_3)\n quit()\n\n print((-1))\n\n\nif __name__ == \"__main__\":\n func_1()\n```", "output": "FASTER 1.1074", "pair_id": "python_p02755_forward", "problem_id": "p02755", "language": "python", "direction": "forward", "speedup_ratio": 2.1545} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\n\nvar_3 = sys.stdin.readline\nvar_1, var_2 = var_3().split()\nvar_1 = int(var_1)\nvar_2 = int(float(var_2) * 100 + 0.5)\nprint((var_1 * var_2 // 100))\n```\n\n=== Code B (Modified) ===\n```python\ndef func_1():\n from sys import setrecursionlimit, stdin\n from os import environ\n from collections import defaultdict, deque, Counter\n from math import ceil, floor, gcd\n from itertools import accumulate, combinations, combinations_with_replacement\n\n setrecursionlimit(10**6)\n var_7 = (\n (lambda *var_11: print(*var_11))\n if \"TERM_PROGRAM\" in environ\n else lambda *var_12: 0\n )\n var_8 = lambda: stdin.readline().rstrip()\n var_3 = lambda: list(map(int, var_8().split()))\n var_1 = lambda: int(var_8())\n var_4 = 10**9 + 7\n var_2 = 10**9 + 10\n var_9, var_10 = var_8().split()\n var_5 = int(var_9)\n var_6 = int(float(var_10) * 100 + 0.5)\n print(var_5 * var_6 // 100)\n\n\nfunc_1()\n```", "output": "SLOWER 2.0133", "pair_id": "python_p02659_reversed", "problem_id": "p02659", "language": "python", "direction": "reversed", "speedup_ratio": 4.0371} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_4 = {}\nvar_5 = 0\nfor var_6 in range(10000, 100000):\n var_3 = list(str(var_6))\n if var_3 == list(reversed(var_3)):\n var_5 += 1\n var_4[var_6] = var_5\nvar_1, var_2 = list(map(int, input().split()))\nprint((var_4[var_2] - var_4[var_1 - 1] if var_1 > 10000 else var_4[var_2]))\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\n\n\ndef func_1(var_5, var_6):\n var_4 = 0\n for var_3 in range(var_5, var_6 + 1):\n if str(var_3) == str(var_3)[::-1]:\n var_4 += 1\n return var_4\n\n\nprint((func_1(var_1, var_2)))\n```", "output": "FASTER 3.8972", "pair_id": "python_p03416_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 14.8999} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = list(reversed(list(str(var_4))))\n if var_5 == list(str(var_4)):\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_4 = str(var_4)\n if var_4[0] == var_4[-1] and var_4[1] == var_4[-2]:\n var_3 += 1\nprint(var_3)\n```", "output": "FASTER 1.8406", "pair_id": "python_p03416_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 3.5817} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_5 in range(10):\n for var_6 in range(10):\n for var_7 in range(10):\n var_3 = 10000 * var_5 + 1000 * var_6 + 100 * var_7 + 10 * var_6 + var_5\n if var_1 <= var_3 <= var_2:\n var_4 += 1\nprint(var_4)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_4 = str(var_4)\n if var_4 == var_4[::-1]:\n var_3 += 1\nprint(var_3)\n```", "output": "SLOWER 3.9726", "pair_id": "python_p03416_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 15.6985} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_2, var_1 = list(map(int, input().split()))\nvar_6 = {}\nvar_3 = {}\nfor var_4 in range(var_1):\n var_5, var_7 = input().split()\n var_5 = int(var_5)\n if not var_5 in var_6:\n var_6[var_5] = 0\n var_3[var_5] = 0\n if var_7 == \"WA\" and var_3[var_5] == 0:\n var_6[var_5] += 1\n elif var_7 == \"AC\" and var_3[var_5] == 0:\n var_3[var_5] += 1\nfor var_4 in var_6:\n if var_6[var_4] != 0 and var_3[var_4] == 0:\n var_6[var_4] = 0\nprint((sum(var_3.values()), sum(var_6.values())))\n```\n\n=== Code B (Modified) ===\n```python\nfrom sys import stdin\n\nvar_5 = stdin.readline\nvar_2, var_1 = list(map(int, var_5().split()))\nvar_3 = [False] * var_2\nvar_8 = [0] * var_2\nvar_9 = 0\nfor var_4 in range(var_1):\n var_6, var_7 = var_5().split()\n var_6 = int(var_6) - 1\n if var_3[var_6] is False and var_7 == \"AC\":\n var_9 += var_8[var_6]\n var_3[var_6] = True\n elif var_7 == \"WA\":\n var_8[var_6] += 1\nprint((var_3.count(True), var_9))\n```", "output": "SLOWER 1.107", "pair_id": "python_p02802_reversed", "problem_id": "p02802", "language": "python", "direction": "reversed", "speedup_ratio": 2.154} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\n\n\ndef func_5():\n return sys.stdin.readline()[:-1]\n\n\ndef func_2():\n return int(eval(func_5()))\n\n\ndef func_3():\n return list(map(int, func_5().split()))\n\n\ndef func_1():\n return list(func_3())\n\n\nvar_11, var_12 = func_3()\nvar_5 = [0] + func_1()\nvar_2 = [func_1() + [var_6] for var_6 in range(var_12)]\nvar_2.sort(key=lambda var_17: var_17[1])\nvar_4 = [0] * (var_12)\nvar_10 = [0 for var_6 in range(var_11 + 1)]\nvar_1 = 2\nwhile var_1 <= var_11:\n var_1 *= 2\nvar_16 = [0] * (2 * var_1)\n\n\ndef func_7(var_8, var_17):\n var_8 += var_1 - 1\n var_16[var_8] = var_17\n while var_8 > 0:\n var_8 = (var_8 - 1) // 2\n var_16[var_8] = var_16[var_8 * 2 + 1] + var_16[var_8 * 2 + 2]\n\n\ndef func_4(var_8, var_17):\n var_8 += var_1 - 1\n while var_8 >= 0:\n var_16[var_8] += var_17\n var_8 = (var_8 - 1) // 2\n\n\ndef func_6(var_9, var_13):\n func_1 = var_9 + var_1 - 1\n var_3 = var_13 + var_1 - 1\n var_14 = 0\n while func_1 <= var_3:\n if var_3 & 1:\n var_14 += var_16[var_3]\n var_3 -= 2\n else:\n var_3 -= 1\n if func_1 & 1:\n func_1 -= 1\n else:\n var_14 += var_16[func_1]\n func_1 >>= 1\n var_3 >>= 1\n return var_14\n\n\nvar_7 = 1\nfor var_9, var_13, var_6 in var_2:\n while var_7 <= var_13:\n var_15 = var_5[var_7]\n func_4(var_10[var_15], -1)\n func_4(var_7, 1)\n var_10[var_15] = var_7\n var_7 += 1\n var_4[var_6] = func_6(var_9, var_13)\nfor var_6 in var_4:\n print(var_6)\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\n\nvar_20 = sys.stdin.read\nvar_21 = sys.stdin.readline\nvar_22 = sys.stdin.readlines\nsys.setrecursionlimit(10**9)\nvar_2 = 1 << 60\nvar_5 = 1000000007\n\n\nvar_4 = 1000001\n\n\nclass Class_1:\n def __init__(self, var_13, var_19, var_12):\n self.l = var_13\n self.r = var_19\n self.idx = var_12\n\n\ndef func_4(var_12, var_24, var_10, var_15):\n while var_12 <= var_15:\n var_10[var_12] += var_24\n var_12 += var_12 & -var_12\n\n\ndef func_3(var_12, var_10, var_15):\n var_23 = 0\n while var_12:\n var_23 += var_10[var_12]\n var_12 -= var_12 & -var_12\n return var_23\n\n\ndef func_1(var_9, var_15, var_17, var_16):\n\n var_10 = [0] * (var_15 + 1)\n\n var_14 = [-1] * var_4\n\n var_8 = [0] * var_16\n var_18 = 0\n for var_11 in range(var_15):\n\n if var_14[var_9[var_11]] != -1:\n func_4(var_14[var_9[var_11]] + 1, -1, var_10, var_15)\n\n var_14[var_9[var_11]] = var_11\n func_4(var_11 + 1, 1, var_10, var_15)\n\n while var_18 < var_16 and var_17[var_18].r == var_11:\n var_8[var_17[var_18].idx] = func_3(\n var_17[var_18].r + 1, var_10, var_15\n ) - func_3(var_17[var_18].l, var_10, var_15)\n var_18 += 1\n\n for var_11 in range(var_16):\n print((var_8[var_11]))\n\n\ndef func_2():\n var_6, var_7 = list(map(int, var_21().split()))\n var_1 = list(map(int, var_21().split()))\n (*var_3,) = list(map(int, var_20().split()))\n var_17 = [0] * var_7\n for var_11, (var_13, var_19) in enumerate(zip(*[iter(var_3)] * 2)):\n var_17[var_11] = Class_1(var_13 - 1, var_19 - 1, var_11)\n var_17.sort(key=lambda var_25: var_25.r)\n func_1(var_1, var_6, var_17, var_7)\n return\n\n\nif __name__ == \"__main__\":\n func_2()\n```", "output": "SLOWER 2.1494", "pair_id": "python_p02599_reversed", "problem_id": "p02599", "language": "python", "direction": "reversed", "speedup_ratio": 4.4365} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_3 = list(map(int, input().split()))\nvar_2 = 0\nfor var_5 in range(var_3 + 1)[var_1:]:\n if len(str(var_5)) % 2 == 0:\n var_6 = list(str(var_5))[: len(str(var_5)) // 2]\n var_7 = list(reversed(list(str(var_5))[len(str(var_5)) // 2 :]))\n if var_6 == var_7:\n var_2 += 1\n else:\n var_8 = list(str(var_5))[: len(str(var_5)) // 2 + 1]\n var_4 = list(reversed(list(str(var_5))[len(str(var_5)) // 2 :]))\n if var_8 == var_4:\n var_2 += 1\nprint(var_2)\n```\n\n=== Code B (Modified) ===\n```python\nvar_4 = {}\nvar_5 = 0\nfor var_6 in range(10000, 100000):\n var_3 = list(str(var_6))\n if var_3 == list(reversed(var_3)):\n var_5 += 1\n var_4[var_6] = var_5\nvar_1, var_2 = list(map(int, input().split()))\nprint((var_4[var_2] - var_4[var_1 - 1] if var_1 > 10000 else var_4[var_2]))\n```", "output": "SLOWER 1.0991", "pair_id": "python_p03416_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 2.1422} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\n\nvar_7 = sys.stdin.readline\nfrom itertools import combinations\n\n\ndef func_3(var_10):\n for _ in range(var_10):\n yield list(map(int, var_7().split()))\n\n\ndef func_1(var_9, var_5, var_11):\n var_3 = len([0 for var_8 in var_9 if var_5[var_8] == 1])\n return var_11[var_3]\n\n\ndef func_2():\n var_10 = int(eval(var_7()))\n var_1 = list(func_3(var_10))\n var_2 = list(func_3(var_10))\n for var_6 in range(1, 11):\n for var_4 in combinations(list(range(10)), var_6):\n yield sum(\n func_1(var_4, var_5, var_11) for var_5, var_11 in zip(var_1, var_2)\n )\n\n\nprint((max(func_2())))\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\n\nvar_8 = sys.stdin.readline\n\n\ndef func_1():\n var_2 = int(eval(var_8()))\n var_1 = [int(var_8().replace(\" \", \"\"), 2) for _ in range(var_2)]\n var_3 = [list(map(int, var_8().split())) for _ in range(var_2)]\n var_4 = -(10**7) * var_2\n for var_7 in range(1, 1 << 10):\n var_10 = 0\n for var_9, var_6 in enumerate(var_1):\n var_5 = bin(var_7 & var_6).count(\"1\")\n var_10 += var_3[var_9][var_5]\n var_4 = max(var_4, var_10)\n print(var_4)\n\n\nif __name__ == \"__main__\":\n func_1()\n```", "output": "FASTER 1.1171", "pair_id": "python_p03503_forward", "problem_id": "p03503", "language": "python", "direction": "forward", "speedup_ratio": 2.1691} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\n\n\ndef func_1(var_5):\n var_4 = 0\n for var_3 in range(1, var_5 + 1):\n if str(var_3) == str(var_3)[::-1]:\n var_4 += 1\n return var_4\n\n\nprint((func_1(var_2) - func_1(var_1 - 1)))\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\n\n\ndef func_1(var_5, var_6):\n var_4 = 0\n for var_3 in range(var_5, var_6 + 1):\n if str(var_3) == str(var_3)[::-1]:\n var_4 += 1\n return var_4\n\n\nprint((func_1(var_1, var_2)))\n```", "output": "FASTER 1.9143", "pair_id": "python_p03416_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 3.7692} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2, var_8 = list(map(int, input().split()))\nvar_4 = list(map(int, input().split()))\nvar_9 = list(map(int, input().split()))\nvar_10 = [list(map(int, input().split())) for var_6 in range(var_8)]\nvar_7 = 200001\nfor var_6 in range(var_8):\n var_5 = var_10[var_6][0] - 1\n var_3 = var_10[var_6][1] - 1\n if var_7 >= var_4[var_5] + var_9[var_3] - var_10[var_6][2]:\n var_7 = var_4[var_5] + var_9[var_3] - var_10[var_6][2]\nvar_4.sort()\nvar_9.sort()\nif var_7 >= (var_4[0] + var_9[0]):\n print((var_4[0] + var_9[0]))\nelse:\n print(var_7)\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\nfrom collections import Counter\n\n\ndef func_9():\n return sys.stdin.readline().strip()\n\n\ndef func_10(var_8, var_9, var_10):\n return [[var_10] * var_9 for var_13 in range(var_8)]\n\n\ndef func_11(var_8, var_9, var_10, var_11):\n return [[[var_11] * var_10 for var_14 in range(var_9)] for var_13 in range(var_8)]\n\n\ndef func_12(var_8, var_9, var_10, var_11, var_12):\n return [\n [[[var_12] * var_11 for var_14 in range(var_10)] for var_14 in range(var_9)]\n for var_13 in range(var_8)\n ]\n\n\ndef func_8(var_16, var_17=1):\n return int(-(-var_16 // var_17))\n\n\ndef func_1():\n return int(eval(func_9()))\n\n\ndef func_3():\n return list(map(int, func_9().split()))\n\n\ndef func_2(var_7=None):\n return list(func_3()) if var_7 is None else [func_1() for var_13 in range(var_7)]\n\n\ndef func_7():\n print(\"Yes\")\n\n\ndef func_5():\n print(\"No\")\n\n\ndef func_6():\n print(\"YES\")\n\n\ndef func_4():\n print(\"NO\")\n\n\nsys.setrecursionlimit(10**9)\nvar_3 = 10**18\nvar_6 = 10**9 + 7\nvar_7, var_5, var_4 = func_3()\nvar_1 = func_2()\nvar_2 = func_2()\nvar_15 = min(var_1) + min(var_2)\nfor _ in range(var_4):\n var_16, var_17, var_10 = func_3()\n var_16 -= 1\n var_17 -= 1\n var_15 = min(var_15, var_1[var_16] + var_2[var_17] - var_10)\nprint(var_15)\n```", "output": "SLOWER 1.1425", "pair_id": "python_p02748_reversed", "problem_id": "p02748", "language": "python", "direction": "reversed", "speedup_ratio": 2.2077} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport numpy as np\nfrom bisect import bisect_left\n\n\ndef func_1():\n var_4 = []\n var_1 = np.ones(10**5 + 10)\n var_1[0] = var_1[1] = 0\n for var_3, var_2 in enumerate(var_1):\n if var_2:\n var_4.append(var_3)\n var_1[2 * var_3 : 10**5 + 10 : var_3] = 0\n return var_4\n\n\ndef func_2(var_6):\n var_7 = int(var_6)\n var_5 = func_1()\n return str(var_5[bisect_left(var_5, var_7)])\n\n\nif __name__ == \"__main__\":\n import sys\n\n print((func_2(sys.stdin.read().strip())))\n```\n\n=== Code B (Modified) ===\n```python\ndef func_1(var_3):\n var_4 = int(var_3)\n for var_1 in range(var_4, 2 * var_4):\n for var_2 in range(2, int(var_1**0.5)):\n if var_1 % var_2 == 0:\n break\n else:\n return str(var_1)\n\n\nif __name__ == \"__main__\":\n import sys\n\n print((func_1(sys.stdin.read().strip())))\n```", "output": "FASTER 7.8177", "pair_id": "python_p02819_forward", "problem_id": "p02819", "language": "python", "direction": "forward", "speedup_ratio": 225.6147} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nimport math\n\nif math.ceil((var_1 + 1) * 12.5) <= math.ceil(var_2 * 10) or math.ceil(\n var_1 * 12.5\n) >= math.ceil((var_2 + 1) * 10):\n print((-1))\nelse:\n print((max(math.ceil(var_1 * 12.5), math.ceil(var_2 * 10))))\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nfor var_3 in range(1, 1009):\n if int(var_3 * 0.08) == var_1 and int(var_3 * 0.1) == var_2:\n print((int(var_3)))\n exit()\nprint(\"-1\")\n```", "output": "SLOWER 1.923", "pair_id": "python_p02755_reversed", "problem_id": "p02755", "language": "python", "direction": "reversed", "speedup_ratio": 3.792} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_3, var_1 = int(eval(input())), 0\nfor var_2 in list(map(int, input().split())):\n var_1 ^= var_2\nprint((\"Yes\" if var_1 == 0 else \"No\"))\n```\n\n=== Code B (Modified) ===\n```python\nvar_1 = lambda: list(map(int, input().split()))\nvar_6 = int(eval(input()))\nif var_6 % 3:\n var_3 = \"YNeos\"[any(var_1()) :: 2]\nelse:\n var_2 = sorted(var_1())\n var_5 = var_6 // 3\n if var_2[0] ^ var_2[var_5] ^ var_2[2 * var_5]:\n var_3 = \"No\"\n elif any(\n len(set(var_2[var_4 : var_4 + var_5])) > 1 for var_4 in range(0, var_6, var_5)\n ):\n var_3 = \"No\"\n else:\n var_3 = \"Yes\"\nprint(var_3)\n```", "output": "SLOWER 1.2261", "pair_id": "python_p02975_reversed", "problem_id": "p02975", "language": "python", "direction": "reversed", "speedup_ratio": 2.3393} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nfrom sys import stdin\n\nvar_6 = lambda: list(map(int, stdin.readline().split()))\nvar_5 = lambda: list(map(int, stdin.readline().split()))\nvar_1, var_3 = var_6()\nvar_2 = 0\nfor var_4 in range(var_1, var_3 + 1):\n var_7 = str(var_4)\n if var_7 == var_7[::-1]:\n var_2 += 1\nprint(var_2)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_6 in range(var_1, var_2 + 1):\n var_3 = str(var_6)\n var_5 = True\n for var_7 in range(len(var_3) // 2):\n if var_3[var_7] != var_3[-var_7 - 1] and var_5:\n var_5 = not var_5\n if var_5:\n var_4 += 1\nprint(var_4)\n```", "output": "SLOWER 1.4415", "pair_id": "python_p03416_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 2.7161} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(str, input().split()))\nvar_1 = int(var_1)\nvar_2 = int(float(var_2) * 1000)\nprint((var_1 * var_2 // 1000))\n```\n\n=== Code B (Modified) ===\n```python\ndef func_1():\n from sys import setrecursionlimit, stdin\n from os import environ\n from collections import defaultdict, deque, Counter\n from math import ceil, floor, gcd\n from itertools import accumulate, combinations, combinations_with_replacement\n\n setrecursionlimit(10**6)\n var_7 = (\n (lambda *var_11: print(*var_11))\n if \"TERM_PROGRAM\" in environ\n else lambda *var_12: 0\n )\n var_8 = lambda: stdin.readline().rstrip()\n var_3 = lambda: list(map(int, var_8().split()))\n var_1 = lambda: int(var_8())\n var_4 = 10**9 + 7\n var_2 = 10**9 + 10\n var_9, var_10 = var_8().split()\n var_5 = int(var_9)\n var_6 = int(float(var_10) * 100 + 0.5)\n print(var_5 * var_6 // 100)\n\n\nfunc_1()\n```", "output": "SLOWER 2.0285", "pair_id": "python_p02659_reversed", "problem_id": "p02659", "language": "python", "direction": "reversed", "speedup_ratio": 4.0799} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport numpy as np\n\nvar_7 = input()[::-1]\nvar_6 = len(var_7)\nvar_1 = np.zeros(var_6, dtype=int)\nvar_4 = np.zeros(var_6, dtype=int)\nvar_2 = np.zeros(2019, dtype=int)\nvar_8 = 10\nvar_1[0] = int(var_7[0])\nvar_4[0] = var_1[0]\nvar_2[var_4[0]] += 1\nfor var_5 in range(1, var_6):\n var_1[var_5] = int(var_7[var_5]) * var_8 % 2019\n var_4[var_5] = (var_4[var_5 - 1] + var_1[var_5]) % 2019\n var_2[var_4[var_5]] += 1\n var_8 = var_8 * 10 % 2019\nvar_3 = var_2[np.nonzero(var_2)]\nprint(\n (\n int(\n sum([var_3[var_5] * (var_3[var_5] - 1) for var_5 in range(var_3.shape[0])])\n / 2\n )\n + var_2[0]\n )\n)\n```\n\n=== Code B (Modified) ===\n```python\nvar_5 = input()[::-1]\nvar_2 = [0] * 2019\nvar_2[0] = 1\nvar_4 = 0\nvar_6 = 1\nvar_1 = 0\nfor var_3 in var_5:\n var_4 = (var_4 + int(var_3) * var_6) % 2019\n var_6 = var_6 * 10 % 2019\n var_2[var_4] += 1\nfor var_3 in var_2:\n var_1 += var_3 * (var_3 - 1) // 2\nprint(var_1)\n```", "output": "SLOWER 1.2996", "pair_id": "python_p02702_reversed", "problem_id": "p02702", "language": "python", "direction": "reversed", "speedup_ratio": 2.4616} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = str(var_4)\n if var_5[0] == var_5[4] and var_5[1] == var_5[3]:\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = list(str(var_4))\n if var_5 == list(reversed(var_5)):\n var_3 += 1\nprint(var_3)\n```", "output": "SLOWER 1.4984", "pair_id": "python_p03416_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 2.8252} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nfrom collections import deque\n\n\ndef func_2(var_9, var_2, var_4):\n\n var_6 = {var_7: dict() for var_7 in range(var_9)}\n for var_7 in range(var_9 - 1):\n var_1, var_3 = var_2[var_7] - 1, var_4[var_7] - 1\n var_6[var_1][var_3] = -1\n var_6[var_3][var_1] = -1\n var_8 = max([len(var_6[var_1]) for var_1 in range(var_9)])\n var_14 = [-1] * var_9\n var_14[0] = var_8 - 1\n\n var_12 = deque([0])\n while len(var_12) > 0:\n var_10 = var_12.popleft()\n var_5 = var_14[var_10]\n for var_11 in list(var_6[var_10].keys()):\n if var_14[var_11] != -1:\n continue\n var_5 += 1\n var_5 %= var_8\n\n var_6[var_10][var_11] = var_5\n var_6[var_11][var_10] = var_5\n var_14[var_11] = var_5\n var_12.append(var_11)\n var_13 = [0] * (var_9 - 1)\n for var_7 in range(var_9 - 1):\n var_13[var_7] = var_6[var_2[var_7] - 1][var_4[var_7] - 1] + 1\n return var_8, var_13\n\n\ndef func_1():\n var_9 = int(eval(input()))\n var_2 = [0] * (var_9 - 1)\n var_4 = [0] * (var_9 - 1)\n for var_7 in range(var_9 - 1):\n var_1, var_3 = list(map(int, input().split()))\n var_2[var_7] = var_1\n var_4[var_7] = var_3\n var_8, var_13 = func_2(var_9, var_2, var_4)\n print(var_8)\n for var_7 in range(var_9 - 1):\n print((var_13[var_7]))\n\n\ndef func_3():\n print((func_2(3, [1, 2], [2, 3])))\n print((func_2(8, [1, 2, 2, 2, 4, 5, 6], [2, 3, 4, 5, 7, 6, 8])))\n\n\nif __name__ == \"__main__\":\n\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nvar_8 = int(eval(input()))\nvar_5 = []\nvar_10 = {}\nvar_9 = [0, 0]\nfor var_6 in range(var_8 - 1):\n var_1, var_2 = list(map(int, input().split(\" \")))\n var_5.append([var_1, var_2])\n var_10.setdefault(var_1, []).append(var_2)\n var_9.append(0)\nvar_7 = 0\nfor var_11 in range(1, var_8 + 1):\n var_13 = var_10.get(var_11, [])\n var_3 = 1\n for var_12 in var_13:\n if var_3 == var_9[var_11]:\n var_3 += 1\n else:\n pass\n var_9[var_12] = var_3\n if var_3 >= var_7:\n var_7 = var_3\n var_3 += 1\nprint(var_7)\nfor var_4 in var_5:\n print((var_9[var_4[1]]))\n```", "output": "FASTER 1.1277", "pair_id": "python_p02850_forward", "problem_id": "p02850", "language": "python", "direction": "forward", "speedup_ratio": 2.1851} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_4 = str(var_4)\n if var_4[0] == var_4[-1] and var_4[1] == var_4[-2]:\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = list(reversed(list(str(var_4))))\n if var_5 == list(str(var_4)):\n var_3 += 1\nprint(var_3)\n```", "output": "SLOWER 1.8406", "pair_id": "python_p03416_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 3.5817} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1 = list(map(int, input().split()))\nvar_2 = 0\nfor var_3 in range(var_1[0], var_1[1] + 1):\n var_4 = str(var_3)\n if var_4[0] == var_4[4] and var_4[1] == var_4[3]:\n var_2 += 1\nprint(var_2)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n if str(var_4) == \"\".join(reversed(str(var_4))):\n var_3 += 1\nprint(var_3)\n```", "output": "SLOWER 1.365", "pair_id": "python_p03416_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 2.5758} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\ndef func_1():\n var_2, var_3, *var_1 = list(map(int, open(0).read().split()))\n var_4 = [0] * (var_3 + max(var_1[::2]))\n for var_7, var_6 in sorted(zip(*[iter(var_1)] * 2)):\n for var_5 in reversed(list(range(var_3))):\n var_4[var_5 + var_7] = max(var_4[var_5 + var_7], var_4[var_5] + var_6)\n print((max(var_4)))\n\n\nfunc_1()\n```\n\n=== Code B (Modified) ===\n```python\nfrom sys import stdin\n\n\ndef func_1():\n\n var_9 = stdin.readline\n var_8, var_10 = list(map(int, var_9().split()))\n var_7 = [list(map(int, var_9().split())) for _ in range(var_8)]\n var_7.sort()\n var_1 = [0] * var_8\n var_2 = [0] * var_8\n for var_4 in range(var_8):\n var_1[var_4], var_2[var_4] = var_7[var_4][0], var_7[var_4][1]\n\n var_5 = -float(\"inf\")\n var_3 = [[var_5] * (var_10 + 1) for _ in range(var_8 + 1)]\n var_3[0][0] = 0\n for var_4 in range(var_8):\n for var_6 in range(var_10 + 1):\n\n if var_6 != var_10:\n var_3[var_4 + 1][min(var_10, var_6 + var_1[var_4])] = max(\n var_3[var_4 + 1][min(var_10, var_6 + var_1[var_4])],\n var_3[var_4][var_6] + var_2[var_4],\n )\n\n var_3[var_4 + 1][var_6] = max(var_3[var_4 + 1][var_6], var_3[var_4][var_6])\n print((max(var_3[var_8])))\n\n\nif __name__ == \"__main__\":\n func_1()\n```", "output": "SLOWER 1.2195", "pair_id": "python_p02863_reversed", "problem_id": "p02863", "language": "python", "direction": "reversed", "speedup_ratio": 2.3287} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_2, var_3, *var_1 = list(map(int, open(0).read().split()))\nvar_4 = [0] * (var_3 + max(var_1[::2]))\nfor var_7, var_6 in sorted(zip(*[iter(var_1)] * 2)):\n for var_5 in reversed(list(range(var_3))):\n var_4[var_5 + var_7] = max(var_4[var_5 + var_7], var_4[var_5] + var_6)\nprint((max(var_4)))\n```\n\n=== Code B (Modified) ===\n```python\nvar_6, var_7 = list(map(int, input().split()))\nvar_1 = [list(map(int, input().split())) for _ in range(var_6)]\nvar_1.sort()\nvar_3 = [(6007) * [0] for _ in range(var_6 + 1)]\nvar_3[0][0] = 0\nvar_2 = 0\nfor var_4 in range(var_6):\n for var_5 in range(6007):\n var_3[var_4 + 1][var_5] = max(var_3[var_4 + 1][var_5], var_3[var_4][var_5])\n if var_5 < var_7:\n var_3[var_4 + 1][var_5 + var_1[var_4][0]] = max(\n var_3[var_4][var_5] + var_1[var_4][1],\n var_3[var_4][var_5 + var_1[var_4][0]],\n )\n var_2 = max(var_2, var_3[var_4 + 1][var_5])\nprint(var_2)\n```", "output": "SLOWER 6.3072", "pair_id": "python_p02863_reversed", "problem_id": "p02863", "language": "python", "direction": "reversed", "speedup_ratio": 79.1867} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1 = list(map(int, input().split()))\nvar_2 = 0\nfor var_3 in range(var_1[0], var_1[1] + 1):\n var_4 = str(var_3)\n if var_4[0] == var_4[4] and var_4[1] == var_4[3]:\n var_2 += 1\nprint(var_2)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = [0] * (var_2 + 1)\nfor var_3 in range(1, var_2 + 1):\n if str(var_3) == str(var_3)[::-1]:\n var_4[var_3] = var_4[var_3 - 1] + 1\n else:\n var_4[var_3] = var_4[var_3 - 1]\nprint((var_4[var_2] - var_4[var_1 - 1]))\n```", "output": "SLOWER 2.2311", "pair_id": "python_p03416_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 4.6949} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = input().split()\nvar_1 = int(var_1)\nvar_3, var_4 = list(map(int, var_2.split(\".\")))\nvar_5 = var_1 * (var_3 * 100 + var_4)\nprint((int(var_5 // 100)))\n```\n\n=== Code B (Modified) ===\n```python\ndef func_1():\n from sys import setrecursionlimit, stdin\n from os import environ\n from collections import defaultdict, deque, Counter\n from math import ceil, floor, gcd\n from itertools import accumulate, combinations, combinations_with_replacement\n\n setrecursionlimit(10**6)\n var_7 = (\n (lambda *var_11: print(*var_11))\n if \"TERM_PROGRAM\" in environ\n else lambda *var_12: 0\n )\n var_8 = lambda: stdin.readline().rstrip()\n var_3 = lambda: list(map(int, var_8().split()))\n var_1 = lambda: int(var_8())\n var_4 = 10**9 + 7\n var_2 = 10**9 + 10\n var_9, var_10 = var_8().split()\n var_5 = int(var_9)\n var_6 = int(float(var_10) * 100 + 0.5)\n print(var_5 * var_6 // 100)\n\n\nfunc_1()\n```", "output": "SLOWER 1.782", "pair_id": "python_p02659_reversed", "problem_id": "p02659", "language": "python", "direction": "reversed", "speedup_ratio": 3.4391} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_2 = int(eval(input()))\nvar_1 = list(map(int, input().split()))\nvar_4 = 1\nfor var_3 in range(var_2):\n if var_1[var_3] % 2 == 0:\n var_4 *= 2\nprint((3**var_2 - var_4))\n```\n\n=== Code B (Modified) ===\n```python\nfrom functools import reduce\nfrom itertools import product\n\nvar_2 = int(eval(input()))\n(*var_1,) = list(map(int, input().split()))\nvar_4 = 0\nfor var_7 in product([-1, 0, 1], repeat=var_2):\n var_6 = reduce(\n lambda var_8, var_9: var_8 * var_9,\n [var_3 + var_7[var_5] for var_5, var_3 in enumerate(var_1)],\n )\n if var_6 % 2 == 0:\n var_4 += 1\nprint(var_4)\n```", "output": "SLOWER 9.7762", "pair_id": "python_p03568_reversed", "problem_id": "p03568", "language": "python", "direction": "reversed", "speedup_ratio": 876.8612} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_3 = list(map(int, input().split()))\nvar_2 = 0\nfor var_5 in range(var_3 + 1)[var_1:]:\n if len(str(var_5)) % 2 == 0:\n var_6 = list(str(var_5))[: len(str(var_5)) // 2]\n var_7 = list(reversed(list(str(var_5))[len(str(var_5)) // 2 :]))\n if var_6 == var_7:\n var_2 += 1\n else:\n var_8 = list(str(var_5))[: len(str(var_5)) // 2 + 1]\n var_4 = list(reversed(list(str(var_5))[len(str(var_5)) // 2 :]))\n if var_8 == var_4:\n var_2 += 1\nprint(var_2)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = str(var_4)\n if var_5 == var_5[::-1]:\n var_3 += 1\nprint(var_3)\n```", "output": "FASTER 2.479", "pair_id": "python_p03416_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 5.5752} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\ndef func_1():\n var_1, var_2 = list(map(int, input().rstrip().split()))\n var_3 = 0\n for var_4 in range(var_1, var_2 + 1):\n var_5 = str(var_4)\n if var_5 == var_5[::-1]:\n var_3 += 1\n print(var_3)\n\n\nif __name__ == \"__main__\":\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().strip().split(\" \")))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n if str(var_4) == str(var_4)[::-1]:\n var_3 += 1\nprint(var_3)\n```", "output": "SLOWER 1.0533", "pair_id": "python_p03416_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 2.0752} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nfrom collections import Counter, defaultdict, deque\nfrom heapq import heappop, heappush, heapify\nimport sys, bisect, math, itertools, fractions, pprint\n\nsys.setrecursionlimit(10**8)\nvar_6 = 10**9 + 7\nvar_1 = float(\"inf\")\n\n\ndef func_1():\n return int(sys.stdin.readline())\n\n\ndef func_2():\n return list(map(int, sys.stdin.readline().split()))\n\n\nvar_7, var_9 = func_2()\nvar_13 = [func_2() for _ in range(var_7)]\nvar_13.sort(key=lambda var_14: var_14[1], reverse=True)\nvar_8 = 0\nvar_10 = min(var_7, 5)\nfor var_3 in range(var_10):\n var_2 = [[0] * (var_9 + 5) for _ in range(var_7 + 5)]\n for var_4 in range(var_7):\n var_12, var_11 = var_13[var_4]\n for var_5 in range(var_9):\n if var_5 < var_12 or var_3 == var_4:\n var_2[var_4 + 1][var_5] = var_2[var_4][var_5]\n else:\n var_2[var_4 + 1][var_5] = max(\n var_2[var_4][var_5], var_2[var_4][var_5 - var_12] + var_11\n )\n\n var_8 = max(var_2[var_7][var_9 - 1] + var_13[var_3][1], var_8)\nprint(var_8)\n```\n\n=== Code B (Modified) ===\n```python\nvar_8, var_9 = list(map(int, input().split()))\nvar_5 = [[0] * (var_9 + 3001) for _ in range(var_8 + 1)]\nvar_3 = 0\nvar_2 = [list(map(int, input().split())) for _ in range(var_8)]\nvar_2.sort()\nfor var_6 in range(1, var_8 + 1):\n var_1, var_4 = var_2[var_6 - 1]\n for var_7 in range(var_9):\n var_5[var_6][var_7] = max(var_5[var_6 - 1][var_7], var_5[var_6][var_7])\n var_5[var_6][var_7 + var_1] = var_5[var_6 - 1][var_7] + var_4\n var_3 = max(var_5[var_6][var_7], var_5[var_6][var_7 + var_1], var_3)\nprint(var_3)\n```", "output": "FASTER 1.1289", "pair_id": "python_p02863_forward", "problem_id": "p02863", "language": "python", "direction": "forward", "speedup_ratio": 2.1869} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = list(str(var_4))\n if var_5 == list(reversed(var_5)):\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\n\n\ndef func_1(var_5, var_6):\n var_4 = 0\n for var_3 in range(var_5, var_6 + 1):\n if str(var_3) == str(var_3)[::-1]:\n var_4 += 1\n return var_4\n\n\nprint((func_1(var_1, var_2)))\n```", "output": "FASTER 1.5558", "pair_id": "python_p03416_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 2.94} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_3 in range(var_1, var_2 + 1):\n var_5 = list(str(var_3))\n var_6 = list(reversed(var_5))\n if var_5 == var_6:\n var_4 += 1\nprint(var_4)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_4 = str(var_4)\n if var_4 == var_4[::-1]:\n var_3 += 1\nprint(var_3)\n```", "output": "FASTER 1.1616", "pair_id": "python_p03416_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 2.2371} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_7, var_6 = list(map(int, input().split()))\nvar_5 = [tuple(input().split()) for _ in range(var_6)]\nvar_9 = [[] for _ in range(var_7)]\nfor var_2 in range(var_6):\n var_9[int(var_5[var_2][0]) - 1].append(var_5[var_2][1])\nvar_1, var_8 = 0, 0\nfor var_3 in range(var_7):\n if \"AC\" in var_9[var_3]:\n var_1 += 1\n for var_4 in range(len(var_9[var_3])):\n if var_9[var_3][var_4] == \"WA\":\n var_8 += 1\n else:\n break\nprint((var_1, var_8))\n```\n\n=== Code B (Modified) ===\n```python\nfrom sys import stdin\n\nvar_5 = stdin.readline\nvar_2, var_1 = list(map(int, var_5().split()))\nvar_3 = [False] * var_2\nvar_8 = [0] * var_2\nvar_9 = 0\nfor var_4 in range(var_1):\n var_6, var_7 = var_5().split()\n var_6 = int(var_6) - 1\n if var_3[var_6] is False and var_7 == \"AC\":\n var_9 += var_8[var_6]\n var_3[var_6] = True\n elif var_7 == \"WA\":\n var_8[var_6] += 1\nprint((var_3.count(True), var_9))\n```", "output": "FASTER 3.0644", "pair_id": "python_p02802_forward", "problem_id": "p02802", "language": "python", "direction": "forward", "speedup_ratio": 8.3654} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\n\n\ndef func_1(var_5):\n var_4 = 0\n for var_3 in range(1, var_5 + 1):\n if str(var_3) == str(var_3)[::-1]:\n var_4 += 1\n return var_4\n\n\nprint((func_1(var_2) - func_1(var_1 - 1)))\n```\n\n=== Code B (Modified) ===\n```python\nfrom sys import stdin\n\nvar_6 = lambda: list(map(int, stdin.readline().split()))\nvar_5 = lambda: list(map(int, stdin.readline().split()))\nvar_1, var_3 = var_6()\nvar_2 = 0\nfor var_4 in range(var_1, var_3 + 1):\n var_7 = str(var_4)\n if var_7 == var_7[::-1]:\n var_2 += 1\nprint(var_2)\n```", "output": "FASTER 1.5722", "pair_id": "python_p03416_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 2.9736} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = list(reversed(list(str(var_4))))\n if var_5 == list(str(var_4)):\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_5 in range(var_1, var_2 + 1):\n var_3 = str(var_5)\n if var_3[0] == var_3[-1] and var_3[1] == var_3[-2]:\n var_4 += 1\nprint(var_4)\n```", "output": "FASTER 1.7485", "pair_id": "python_p03416_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 3.3602} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_5 = 0\nif var_5 == 0:\n var_8 = int(eval(input()))\n var_2 = []\n for var_4 in range(var_8):\n var_3 = list(map(int, input().split()))\n var_2.append(var_3)\n var_9 = []\n for var_4 in range(var_8):\n var_10 = list(map(int, input().split()))\n var_9.append(var_10)\nelif var_5 == 1:\n var_8 = 1\n var_2 = [[1, 1, 0, 1, 0, 0, 0, 1, 0, 1]]\n var_9 = [[3, 4, 5, 6, 7, 8, 9, -2, -3, 4, -2]]\nelif var_5 == 2:\n var_8 = 2\n var_2 = [[1, 1, 1, 1, 1, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 1, 1, 1, 1, 1]]\n var_9 = [\n [0, -2, -2, -2, -2, -2, -1, -1, -1, -1, -1],\n [0, -2, -2, -2, -2, -2, -1, -1, -1, -1, -1],\n ]\nelif var_5 == 3:\n var_8 = 3\n var_2 = [\n [1, 1, 1, 1, 1, 1, 0, 0, 1, 1],\n [0, 1, 0, 1, 1, 1, 1, 0, 1, 0],\n [1, 0, 1, 1, 0, 1, 0, 1, 0, 1],\n ]\n var_9 = [\n [-8, 6, -2, -8, -8, 4, 8, 7, -6, 2, 2],\n [-9, 2, 0, 1, 7, -5, 0, -2, -6, 5, 5],\n [6, -6, 7, -9, 6, -5, 8, 0, -9, -7, -7],\n ]\nimport itertools\n\nvar_13 = -(10**11)\nfor var_4 in itertools.product([0, 1], repeat=10):\n var_11 = list(var_4)\n var_12 = 0\n if sum(var_11) != 0:\n for var_7 in range(var_8):\n var_1 = 0\n for var_6 in range(10):\n var_1 = var_1 + var_11[var_6] * var_2[var_7][var_6]\n var_12 = var_12 + var_9[var_7][var_1]\n\n var_13 = max(var_12, var_13)\nprint(var_13)\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\nimport itertools\n\n\ndef func_2(var_4):\n return bin(eval(\"0b\" + str(var_4)))\n\n\ndef func_1():\n var_4 = int(sys.stdin.readline().rstrip())\n var_9 = [\n func_2(\"\".join(str(var_10) for var_10 in sys.stdin.readline().split()))\n for _ in range(var_4)\n ]\n var_8 = [\n [int(var_10) for var_10 in sys.stdin.readline().split()] for _ in range(var_4)\n ]\n var_3 = -(10**10)\n for var_6 in itertools.product(\"01\", repeat=10):\n var_6 = func_2(\"\".join(var_6))\n if var_6 == \"0b0\":\n continue\n var_7 = 0\n for var_2 in range(var_4):\n var_1 = var_9[var_2]\n var_5 = bin(eval(var_1) & eval(var_6)).count(\"1\")\n var_7 += var_8[var_2][var_5]\n var_3 = max(var_3, var_7)\n print(var_3)\n\n\nif __name__ == \"__main__\":\n\n func_1()\n```", "output": "SLOWER 2.1766", "pair_id": "python_p03503_reversed", "problem_id": "p03503", "language": "python", "direction": "reversed", "speedup_ratio": 4.5208} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport math\nimport string\n\n\ndef func_4():\n return list(map(int, input().split()))\n\n\ndef func_3(var_6, var_7):\n return math.factorial(var_6) // (\n math.factorial(var_6 - var_7) * math.factorial(var_7)\n )\n\n\ndef func_2(var_9):\n var_8 = []\n for var_5 in var_9:\n if not (var_5 in var_8):\n var_8.append(var_5)\n return len(var_9) != len(var_8)\n\n\ndef func_1(var_6):\n func_1 = []\n for var_4 in range(1, var_6 + 1):\n if var_6 % var_4 == 0:\n func_1.append(var_4)\n return func_1\n\n\nvar_2 = [-1, -1, -1, 0, 0, 1, 1, 1]\nvar_3 = [-1, 0, 1, -1, 1, -1, 0, 1]\nvar_6 = int(eval(input()))\nvar_1 = func_4()\nvar_10 = 1\nfor var_4 in range(len(var_1)):\n if var_1[var_4] % 2 == 0:\n var_10 *= 2\n else:\n var_10 *= 1\nprint((3 ** len(var_1) - var_10))\n```\n\n=== Code B (Modified) ===\n```python\nimport math\nimport string\n\n\ndef func_5():\n return list(map(int, input().split()))\n\n\ndef func_4(var_7, var_8):\n return math.factorial(var_7) // (\n math.factorial(var_7 - var_8) * math.factorial(var_8)\n )\n\n\ndef func_3(var_10):\n var_9 = []\n for var_5 in var_10:\n if not (var_5 in var_9):\n var_9.append(var_5)\n return len(var_10) != len(var_9)\n\n\ndef func_1(var_7):\n func_1 = []\n for var_4 in range(1, var_7 + 1):\n if var_7 % var_4 == 0:\n func_1.append(var_4)\n return func_1\n\n\nvar_2 = [-1, -1, -1, 0, 0, 1, 1, 1]\nvar_3 = [-1, 0, 1, -1, 1, -1, 0, 1]\nvar_7 = int(eval(input()))\nvar_1 = func_5()\n\n\ndef func_2(var_6):\n if len(var_6) == var_7:\n for var_4 in range(len(var_6)):\n if var_6[var_4] % 2 == 0:\n return 1\n return 0\n return (\n func_2(var_6 + [var_1[len(var_6)]])\n + func_2(var_6 + [var_1[len(var_6)] - 1])\n + func_2(var_6 + [var_1[len(var_6)] + 1])\n )\n\n\nprint((func_2([])))\n```", "output": "SLOWER 5.9525", "pair_id": "python_p03568_reversed", "problem_id": "p03568", "language": "python", "direction": "reversed", "speedup_ratio": 61.9275} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_5 in range(10):\n for var_6 in range(10):\n for var_7 in range(10):\n var_3 = 10000 * var_5 + 1000 * var_6 + 100 * var_7 + 10 * var_6 + var_5\n if var_1 <= var_3 <= var_2:\n var_4 += 1\nprint(var_4)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_4 = str(var_4)\n if var_4[0] == var_4[-1] and var_4[1] == var_4[-2]:\n var_3 += 1\nprint(var_3)\n```", "output": "SLOWER 3.6418", "pair_id": "python_p03416_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 12.4826} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_2, var_1 = list(map(int, input().split()))\nvar_3 = 0\nvar_8 = 0\nvar_4 = [0] * (var_2 + 1)\nvar_9 = [0] * (var_2 + 1)\nfor var_5 in range(var_1):\n var_6, var_7 = input().split()\n var_6 = int(var_6)\n if var_7 == \"AC\":\n if var_4[var_6] == 0:\n var_3 += 1\n var_8 += var_9[var_6]\n var_4[var_6] = 1\n else:\n var_9[var_6] += 1\nprint((var_3, var_8))\n```\n\n=== Code B (Modified) ===\n```python\nvar_6, var_5 = list(map(int, input().split()))\nvar_8 = [[] for _ in range(var_6)]\nfor var_2 in range(var_5):\n var_10, var_11 = input().split()\n var_8[int(var_10) - 1].append(var_11)\n\nvar_1, var_7 = 0, 0\nfor var_3 in range(var_6):\n var_9 = var_8[var_3]\n if \"AC\" in var_9:\n var_1 += 1\n for var_4 in var_9:\n if var_4 == \"WA\":\n var_7 += 1\n else:\n break\nprint((var_1, var_7))\n```", "output": "SLOWER 4.7247", "pair_id": "python_p02802_reversed", "problem_id": "p02802", "language": "python", "direction": "reversed", "speedup_ratio": 26.4418} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\nimport itertools\n\n\ndef func_2(var_4):\n return bin(eval(\"0b\" + str(var_4)))\n\n\ndef func_1():\n var_4 = int(sys.stdin.readline().rstrip())\n var_9 = [\n func_2(\"\".join(str(var_10) for var_10 in sys.stdin.readline().split()))\n for _ in range(var_4)\n ]\n var_8 = [\n [int(var_10) for var_10 in sys.stdin.readline().split()] for _ in range(var_4)\n ]\n var_3 = -(10**10)\n for var_6 in itertools.product(\"01\", repeat=10):\n var_6 = func_2(\"\".join(var_6))\n if var_6 == \"0b0\":\n continue\n var_7 = 0\n for var_2 in range(var_4):\n var_1 = var_9[var_2]\n var_5 = bin(eval(var_1) & eval(var_6)).count(\"1\")\n var_7 += var_8[var_2][var_5]\n var_3 = max(var_3, var_7)\n print(var_3)\n\n\nif __name__ == \"__main__\":\n\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\nimport numpy as np\n\nvar_6 = int(eval(input()))\n\nvar_1 = [input().replace(\" \", \"\") for var_4 in range(var_6)]\n\nvar_7 = [list(map(int, input().split())) for var_4 in range(var_6)]\nvar_11 = -999999999999999\nfor var_4 in range(1, 1024):\n var_3 = format(var_4, \"010b\")\n var_9 = 0\n for var_2, var_8 in zip(var_1, var_7):\n var_10 = 0\n for var_5 in range(10):\n if var_2[var_5] == \"1\" and var_3[var_5] == \"1\":\n var_10 += 1\n var_9 += var_8[var_10]\n if var_9 > var_11:\n if var_9 == 0:\n print((str(var_4)))\n break\n var_11 = var_9\nprint(var_11)\n```", "output": "FASTER 3.0752", "pair_id": "python_p03503_forward", "problem_id": "p03503", "language": "python", "direction": "forward", "speedup_ratio": 8.4281} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_4 = {}\nvar_5 = 0\nfor var_6 in range(10000, 100000):\n var_3 = list(str(var_6))\n if var_3 == list(reversed(var_3)):\n var_5 += 1\n var_4[var_6] = var_5\nvar_1, var_2 = list(map(int, input().split()))\nprint((var_4[var_2] - var_4[var_1 - 1] if var_1 > 10000 else var_4[var_2]))\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = str(var_4)\n if var_5 == var_5[::-1]:\n var_3 += 1\nprint(var_3)\n```", "output": "FASTER 3.5781", "pair_id": "python_p03416_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 11.9428} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = list(str(var_4))\n if var_5 == list(reversed(var_5)):\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\ndef func_1():\n var_1, var_2 = list(map(int, input().split()))\n var_3 = 0\n for var_4 in range(var_1, var_2 + 1):\n\n if (var_4 % 10) == (var_4 // 10000 % 10) and (var_4 // 10 % 10) == (\n var_4 // 1000 % 10\n ):\n var_3 += 1\n print(var_3)\n\n\nif __name__ == \"__main__\":\n func_1()\n```", "output": "FASTER 2.8962", "pair_id": "python_p03416_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 7.4448} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1 = list(map(int, input().split()))\nvar_2 = 0\nfor var_3 in range(var_1[0], var_1[1] + 1):\n var_4 = str(var_3)\n if var_4[0] == var_4[4] and var_4[1] == var_4[3]:\n var_2 += 1\nprint(var_2)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n if list(str(var_4)) == list(reversed(str(var_4))):\n var_3 += 1\nprint(var_3)\n```", "output": "SLOWER 1.6892", "pair_id": "python_p03416_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 3.2247} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_4, var_3 = list(map(int, input().split()))\nvar_1 = [tuple(map(int, input().split())) for _ in range(var_3)]\nvar_1.sort(key=lambda var_8: var_8[0])\nvar_7 = 1\nvar_2 = 10**9\nfor var_5, var_6 in var_1:\n if var_5 < var_2:\n var_2 = min(var_2, var_6)\n else:\n var_7 += 1\n var_2 = var_6\nprint(var_7)\n```\n\n=== Code B (Modified) ===\n```python\nvar_2, var_1 = [int(var_12) for var_12 in input().split()]\nvar_3 = []\nfor var_8 in range(var_1):\n var_5, var_6 = [int(var_12) for var_12 in input().split()]\n var_3.append((var_5, var_6))\nvar_3.sort()\nvar_9 = float(\"inf\")\nvar_4 = [var_9 for var_5 in range(var_2 + 1)]\nfor var_5, var_6 in var_3:\n var_4[var_5] = min(var_4[var_5], var_6)\nvar_3 = [\n (var_5, var_4[var_5]) for var_5 in range(1, var_2 + 1) if var_4[var_5] != var_9\n]\nvar_3.sort(key=lambda var_11: var_11[1])\nvar_7 = [True] * (var_2)\nvar_10 = None\nfor var_5, var_6 in var_3:\n if var_10 == None or var_10 < var_5:\n var_7[var_6 - 1] = False\n var_10 = var_6 - 1\nprint((sum(1 for var_6 in var_7 if not var_6)))\n```", "output": "SLOWER 1.0247", "pair_id": "python_p03295_reversed", "problem_id": "p03295", "language": "python", "direction": "reversed", "speedup_ratio": 2.0345} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = str(var_4)\n if var_5[0] == var_5[4] and var_5[1] == var_5[3]:\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().rstrip().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = list(map(int, list(str(var_4))))\n if var_5[0] == var_5[4] and var_5[1] == var_5[3]:\n var_3 += 1\nprint(var_3)\n```", "output": "SLOWER 1.9492", "pair_id": "python_p03416_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 3.8615} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\n\nvar_8 = sys.stdin.readline\n\n\ndef func_1():\n var_2 = int(eval(var_8()))\n var_1 = [int(var_8().replace(\" \", \"\"), 2) for _ in range(var_2)]\n var_3 = [list(map(int, var_8().split())) for _ in range(var_2)]\n var_4 = -(10**7) * var_2\n for var_7 in range(1, 1 << 10):\n var_10 = 0\n for var_9, var_6 in enumerate(var_1):\n var_5 = bin(var_7 & var_6).count(\"1\")\n var_10 += var_3[var_9][var_5]\n var_4 = max(var_4, var_10)\n print(var_4)\n\n\nif __name__ == \"__main__\":\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nimport itertools\n\nvar_6 = int(eval(input()))\nvar_2 = [[]] * var_6\nfor var_4 in range(var_6):\n var_3 = list(map(int, input().split()))\n\n var_2[var_4] = var_3\nvar_8 = [[]] * var_6\nfor var_4 in range(var_6):\n var_9 = list(map(int, input().split()))\n var_8[var_4] = var_9\nvar_10 = -(10**11)\nfor var_1 in itertools.product([0, 1], repeat=10):\n if sum(var_1) == 0:\n continue\n var_11 = 0\n for var_7 in range(var_6):\n var_5 = 0\n for var_4 in range(10):\n if var_2[var_7][var_4] == 1 and var_1[var_4] == 1:\n var_5 += 1\n var_11 = var_11 + var_8[var_7][var_5]\n var_10 = max(var_10, var_11)\nprint(var_10)\n```", "output": "SLOWER 2.7112", "pair_id": "python_p03503_reversed", "problem_id": "p03503", "language": "python", "direction": "reversed", "speedup_ratio": 6.5485} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\nimport math\nfrom collections import defaultdict\nfrom bisect import bisect_left, bisect_right\n\nsys.setrecursionlimit(10**7)\n\n\ndef func_4():\n return sys.stdin.readline()[:-1]\n\n\nvar_4 = 10**9 + 7\n\n\ndef func_1():\n return int(eval(func_4()))\n\n\ndef func_2():\n return list(map(int, func_4().split()))\n\n\ndef func_3(var_6, var_3):\n if var_6 <= 0:\n return [[] for _ in range(var_3)]\n elif var_3 == 1:\n return [func_1() for _ in range(var_6)]\n else:\n var_5 = [func_2() for _ in range(var_6)]\n return list(map(list, list(zip(*var_5))))\n\n\nfrom decimal import getcontext, Decimal\n\ngetcontext().prec = 28\nvar_1, var_2 = list(map(str, func_4().split()))\nvar_1 = int(var_1)\nvar_2 = Decimal(var_2)\nprint((int(var_1 * var_2)))\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = input().split()\nvar_1 = int(var_1)\nvar_2 = int(\"\".join(var_2.split(\".\")))\nprint(((var_1 * var_2) // 100))\n```", "output": "FASTER 2.485", "pair_id": "python_p02659_forward", "problem_id": "p02659", "language": "python", "direction": "forward", "speedup_ratio": 5.5983} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport itertools\n\nvar_6 = int(eval(input()))\nvar_2 = [[]] * var_6\nfor var_4 in range(var_6):\n var_3 = list(map(int, input().split()))\n\n var_2[var_4] = var_3\nvar_8 = [[]] * var_6\nfor var_4 in range(var_6):\n var_9 = list(map(int, input().split()))\n var_8[var_4] = var_9\nvar_10 = -(10**11)\nfor var_1 in itertools.product([0, 1], repeat=10):\n if sum(var_1) == 0:\n continue\n var_11 = 0\n for var_7 in range(var_6):\n var_5 = 0\n for var_4 in range(10):\n if var_2[var_7][var_4] == 1 and var_1[var_4] == 1:\n var_5 += 1\n var_11 = var_11 + var_8[var_7][var_5]\n var_10 = max(var_10, var_11)\nprint(var_10)\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\n\nvar_7 = sys.stdin.readline\nfrom itertools import combinations\n\n\ndef func_3(var_10):\n for _ in range(var_10):\n yield list(map(int, var_7().split()))\n\n\ndef func_1(var_9, var_5, var_11):\n var_3 = sum(1 if var_5[var_8] == 1 else 0 for var_8 in var_9)\n return var_11[var_3]\n\n\ndef func_2():\n var_10 = int(eval(var_7()))\n var_1 = list(func_3(var_10))\n var_2 = list(func_3(var_10))\n for var_6 in range(1, 11):\n for var_4 in combinations(list(range(10)), var_6):\n yield sum(\n func_1(var_4, var_5, var_11) for var_5, var_11 in zip(var_1, var_2)\n )\n\n\nprint((max(func_2())))\n```", "output": "FASTER 1.0485", "pair_id": "python_p03503_forward", "problem_id": "p03503", "language": "python", "direction": "forward", "speedup_ratio": 2.0684} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\ndef func_1():\n var_2 = int(eval(input()))\n var_1 = [int(var_6) for var_6 in input().split()]\n var_4 = 3**var_2\n var_5 = len([var_3 for var_3 in var_1 if var_3 % 2 == 0])\n var_4 -= 2**var_5\n print(var_4)\n\n\nif __name__ == \"__main__\":\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nfrom itertools import product\n\nvar_6 = int(eval(input()))\nvar_1 = list(map(int, input().split()))\nvar_5 = 0\nfor var_2 in product((-1, 0, 1), repeat=var_6):\n var_7 = 1\n for var_3, var_4 in zip(var_1, var_2):\n var_7 *= var_3 + var_4\n if var_7 % 2 == 0:\n var_5 += 1\nprint(var_5)\n```", "output": "SLOWER 9.5197", "pair_id": "python_p03568_reversed", "problem_id": "p03568", "language": "python", "direction": "reversed", "speedup_ratio": 734.0288} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\n\nvar_8 = sys.stdin.readline\n\n\ndef func_1():\n var_2 = int(eval(var_8()))\n var_1 = [int(var_8().replace(\" \", \"\"), 2) for _ in range(var_2)]\n var_3 = [list(map(int, var_8().split())) for _ in range(var_2)]\n var_4 = -(10**7) * var_2\n for var_7 in range(1, 1 << 10):\n var_10 = 0\n for var_9, var_6 in enumerate(var_1):\n var_5 = bin(var_7 & var_6).count(\"1\")\n var_10 += var_3[var_9][var_5]\n var_4 = max(var_4, var_10)\n print(var_4)\n\n\nif __name__ == \"__main__\":\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\nimport itertools\n\n\ndef func_2(var_4):\n return bin(eval(\"0b\" + str(var_4)))\n\n\ndef func_1():\n var_4 = int(sys.stdin.readline().rstrip())\n var_9 = [\n func_2(\"\".join(str(var_10) for var_10 in sys.stdin.readline().split()))\n for _ in range(var_4)\n ]\n var_8 = [\n [int(var_10) for var_10 in sys.stdin.readline().split()] for _ in range(var_4)\n ]\n var_3 = -(10**10)\n for var_6 in itertools.product(\"01\", repeat=10):\n var_6 = func_2(\"\".join(var_6))\n if var_6 == \"0b0\":\n continue\n var_7 = 0\n for var_2 in range(var_4):\n var_1 = var_9[var_2]\n var_5 = bin(eval(var_1) & eval(var_6)).count(\"1\")\n var_7 += var_8[var_2][var_5]\n var_3 = max(var_3, var_7)\n print(var_3)\n\n\nif __name__ == \"__main__\":\n\n func_1()\n```", "output": "SLOWER 5.3117", "pair_id": "python_p03503_reversed", "problem_id": "p03503", "language": "python", "direction": "reversed", "speedup_ratio": 39.7178} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nfrom functools import reduce\nfrom itertools import product\n\nvar_2 = int(eval(input()))\n(*var_1,) = list(map(int, input().split()))\nvar_4 = 0\nfor var_7 in product([-1, 0, 1], repeat=var_2):\n var_6 = reduce(\n lambda var_8, var_9: var_8 * var_9,\n [var_3 + var_7[var_5] for var_5, var_3 in enumerate(var_1)],\n )\n if var_6 % 2 == 0:\n var_4 += 1\nprint(var_4)\n```\n\n=== Code B (Modified) ===\n```python\nvar_2 = int(eval(input()))\n(*var_1,) = list(map(int, input().split()))\nvar_5 = 0\nfor var_3 in var_1:\n if var_3 % 2 == 0:\n var_5 += 1\nvar_4 = 3**var_2 - 2**var_5\nprint(var_4)\n```", "output": "FASTER 9.7614", "pair_id": "python_p03568_forward", "problem_id": "p03568", "language": "python", "direction": "forward", "speedup_ratio": 867.9334} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\nimport itertools\n\n\ndef func_2(var_4):\n return bin(eval(\"0b\" + str(var_4)))\n\n\ndef func_1():\n var_4 = int(sys.stdin.readline().rstrip())\n var_9 = [\n func_2(\"\".join(str(var_10) for var_10 in sys.stdin.readline().split()))\n for _ in range(var_4)\n ]\n var_8 = [\n [int(var_10) for var_10 in sys.stdin.readline().split()] for _ in range(var_4)\n ]\n var_3 = -(10**10)\n for var_6 in itertools.product(\"01\", repeat=10):\n var_6 = func_2(\"\".join(var_6))\n if var_6 == \"0b0\":\n continue\n var_7 = 0\n for var_2 in range(var_4):\n var_1 = var_9[var_2]\n var_5 = bin(eval(var_1) & eval(var_6)).count(\"1\")\n var_7 += var_8[var_2][var_5]\n var_3 = max(var_3, var_7)\n print(var_3)\n\n\nif __name__ == \"__main__\":\n\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nimport itertools\n\nvar_6 = int(eval(input()))\nvar_2 = [[]] * var_6\nfor var_4 in range(var_6):\n var_3 = list(map(int, input().split()))\n\n var_2[var_4] = var_3\nvar_8 = [[]] * var_6\nfor var_4 in range(var_6):\n var_9 = list(map(int, input().split()))\n var_8[var_4] = var_9\nvar_10 = -(10**11)\nfor var_1 in itertools.product([0, 1], repeat=10):\n if sum(var_1) == 0:\n continue\n var_11 = 0\n for var_7 in range(var_6):\n var_5 = 0\n for var_4 in range(10):\n if var_2[var_7][var_4] == 1 and var_1[var_4] == 1:\n var_5 += 1\n var_11 = var_11 + var_8[var_7][var_5]\n var_10 = max(var_10, var_11)\nprint(var_10)\n```", "output": "FASTER 2.6006", "pair_id": "python_p03503_forward", "problem_id": "p03503", "language": "python", "direction": "forward", "speedup_ratio": 6.0652} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_2, var_3, *var_1 = list(map(int, open(0).read().split()))\nvar_4 = [0] * (var_3 + max(var_1[::2]))\nfor var_7, var_6 in sorted(zip(*[iter(var_1)] * 2)):\n for var_5 in reversed(list(range(var_3))):\n var_4[var_5 + var_7] = max(var_4[var_5 + var_7], var_4[var_5] + var_6)\nprint((max(var_4)))\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\nfrom operator import itemgetter\nfrom heapq import heapify, heappop, heappush\n\nvar_1 = int(10e15)\nvar_2 = -var_1\nvar_11 = 1000000007\nsys.setrecursionlimit(1000000)\n\n\ndef func_2():\n return list(map(int, input().split()))\n\n\ndef func_4():\n return input().split()\n\n\ndef func_1():\n return int(sys.stdin.readline())\n\n\ndef func_3():\n return eval(input())\n\n\nvar_3, var_4 = func_2()\nvar_5 = [func_2() for var_9 in range(var_3)]\nvar_5.sort(key=itemgetter(0))\n\nvar_8 = [[0] * (var_4 + 1 + 3000 + 1) for _ in range(var_3 + 1)]\nvar_6 = 0\nfor var_9 in range(var_3):\n for var_10 in range(var_4 + 1 + 3000 + 1):\n var_12, var_7 = var_5[var_9]\n if 0 <= var_10 - var_12 < var_4:\n var_8[var_9 + 1][var_10] = max(\n var_8[var_9][var_10], var_8[var_9][var_10 - var_12] + var_7\n )\n else:\n var_8[var_9 + 1][var_10] = var_8[var_9][var_10]\n var_6 = max(var_6, var_8[var_9 + 1][var_10])\nprint(var_6)\n```", "output": "SLOWER 5.4023", "pair_id": "python_p02863_reversed", "problem_id": "p02863", "language": "python", "direction": "reversed", "speedup_ratio": 42.2927} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_2, var_1 = list(map(int, input().split()))\nvar_6 = {}\nvar_3 = {}\nfor var_4 in range(var_1):\n var_5, var_7 = input().split()\n var_5 = int(var_5)\n if not var_5 in var_6:\n var_6[var_5] = 0\n var_3[var_5] = 0\n if var_7 == \"WA\" and var_3[var_5] == 0:\n var_6[var_5] += 1\n elif var_7 == \"AC\" and var_3[var_5] == 0:\n var_3[var_5] += 1\nfor var_4 in var_6:\n if var_6[var_4] != 0 and var_3[var_4] == 0:\n var_6[var_4] = 0\nprint((sum(var_3.values()), sum(var_6.values())))\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\n\nvar_2, var_1, *var_3 = sys.stdin.read().strip().split()\nvar_2 = int(var_2)\nvar_5 = [0] * var_2\nvar_10 = [0] * var_2\nfor var_6, var_8 in zip(*[iter(var_3)] * 2):\n var_6 = int(var_6) - 1\n if var_8 == \"AC\":\n var_5[var_6] = 1\n elif var_5[var_6] == 0:\n var_10[var_6] += 1\nvar_7 = sum([var_9 * var_4 for var_4, var_9 in zip(var_5, var_10)])\nprint((\"{} {}\".format(sum(var_5), var_7)))\n```", "output": "SLOWER 2.6258", "pair_id": "python_p02802_reversed", "problem_id": "p02802", "language": "python", "direction": "reversed", "speedup_ratio": 6.1723} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_2 = var_2 / 0.1\nvar_3 = [var_4 + var_2 for var_4 in range(10)]\nfor var_4 in var_3:\n if int(var_4 * 0.08) == var_1:\n print((int(var_4)))\n exit()\nprint(\"-1\")\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nfor var_3 in range(1, 1009):\n if int(var_3 * 0.08) == var_1 and int(var_3 * 0.1) == var_2:\n print((int(var_3)))\n exit()\nprint(\"-1\")\n```", "output": "SLOWER 1.9094", "pair_id": "python_p02755_reversed", "problem_id": "p02755", "language": "python", "direction": "reversed", "speedup_ratio": 3.7565} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\n\nsys.setrecursionlimit(500000)\n\n\ndef func_2():\n return sys.stdin.readline()[:-1]\n\n\nclass Class_1:\n def __init__(self, var_12):\n self.n = var_12\n self.N0 = 1 << var_12.bit_length()\n self.data = [0] * (self.N0 * 2)\n\n def func_5(self, var_11, var_13, var_16):\n var_11 += self.N0\n var_13 += self.N0\n while var_11 < var_13:\n if var_11 & 1:\n self.data[var_11] = self.data[var_11] + var_16\n var_11 += 1\n if var_13 & 1:\n self.data[var_13 - 1] = self.data[var_13 - 1] + var_16\n var_13 -= 1\n var_11 //= 2\n var_13 //= 2\n\n def func_4(self, var_8):\n var_8 += len(self.data) // 2\n var_14 = self.data[var_8]\n while var_8 > 0:\n var_8 //= 2\n var_14 = var_14 + self.data[var_8]\n return var_14\n\n\ndef func_3():\n var_3, var_2, var_1 = list(map(int, func_2().split()))\n var_6 = []\n for var_8 in range(var_3):\n var_17, var_7 = list(map(int, func_2().split()))\n if var_7 % var_1 == 0:\n var_6.append([var_17, var_7 // var_1])\n else:\n var_6.append([var_17, var_7 // var_1 + 1])\n var_6.sort(key=lambda var_17: var_17[0])\n\n def func_1(var_9):\n var_17 = var_6[var_9][0]\n if var_6[var_3 - 1][0] <= var_17 + 2 * var_2:\n return var_3 - 1\n var_11 = var_9\n var_13 = var_3 - 1\n while var_13 - var_11 > 1:\n if var_6[(var_13 + var_11) // 2][0] <= var_17 + 2 * var_2:\n var_11 = (var_13 + var_11) // 2\n else:\n var_13 = (var_13 + var_11) // 2\n return var_11\n\n var_4 = Class_1(var_3)\n for var_8 in range(var_3):\n var_4.update(var_8, var_8 + 1, var_6[var_8][1])\n var_5 = 0\n for var_8 in range(var_3):\n var_15 = var_4.query(var_8)\n if var_15 > 0:\n var_5 += var_15\n var_10 = func_1(var_8)\n var_4.update(var_8, var_10 + 1, -var_15)\n print(var_5)\n\n\nif __name__ == \"__main__\":\n func_3()\n```\n\n=== Code B (Modified) ===\n```python\nimport bisect\n\nvar_9, var_4, var_1 = list(map(int, input().split()))\nvar_5 = [None] * var_9\nfor var_7 in range(var_9):\n var_11, var_6 = list(map(int, input().split()))\n var_5[var_7] = (var_11, var_6)\nvar_5.sort()\nvar_11 = [int(var_5[var_7][0]) for var_7 in range(var_9)]\nvar_6 = [int(var_5[var_7][1]) for var_7 in range(var_9)]\nvar_2 = 0\nvar_3 = [0] * var_9\nfor var_7 in range(var_9):\n if var_7 != 0:\n var_3[var_7] += var_3[var_7 - 1]\n if var_3[var_7] >= var_6[var_7]:\n continue\n var_10 = (var_6[var_7] - var_3[var_7] - 1) // var_1 + 1\n var_2 += var_10\n var_3[var_7] += var_10 * var_1\n var_8 = bisect.bisect_right(var_11, var_11[var_7] + 2 * var_4)\n if var_8 == var_9:\n continue\n var_3[var_8] -= var_10 * var_1\nprint(var_2)\n```", "output": "FASTER 1.0618", "pair_id": "python_p02788_forward", "problem_id": "p02788", "language": "python", "direction": "forward", "speedup_ratio": 2.0876} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_10 = []\nvar_10 = input().rstrip().split(\" \")\nvar_1 = int(var_10[0])\nvar_3 = int(var_10[1])\nvar_2 = 0\nvar_6 = var_1\nwhile var_6 <= var_3:\n var_4 = var_6 // 10000\n var_5 = (var_6 - var_4 * 10000) // 1000\n var_7 = var_6 // 100\n var_8 = (var_6 - var_7 * 100) // 10\n var_9 = var_6 % 10\n if (var_4 == var_9) and (var_5 == var_8):\n var_2 += 1\n var_6 += 1\nprint(var_2)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_5 in range(10):\n for var_6 in range(10):\n for var_7 in range(10):\n var_3 = 10000 * var_5 + 1000 * var_6 + 100 * var_7 + 10 * var_6 + var_5\n if var_1 <= var_3 <= var_2:\n var_4 += 1\nprint(var_4)\n```", "output": "FASTER 4.6346", "pair_id": "python_p03416_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 24.8395} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_2 = int(eval(input()))\n(*var_1,) = list(map(int, input().split()))\nvar_5 = 0\nfor var_3 in var_1:\n if var_3 % 2 == 0:\n var_5 += 1\nvar_4 = 3**var_2 - 2**var_5\nprint(var_4)\n```\n\n=== Code B (Modified) ===\n```python\nfrom itertools import product\n\nvar_6 = int(eval(input()))\nvar_1 = list(map(int, input().split()))\nvar_5 = 0\nfor var_2 in product((-1, 0, 1), repeat=var_6):\n var_7 = 1\n for var_3, var_4 in zip(var_1, var_2):\n var_7 *= var_3 + var_4\n if var_7 % 2 == 0:\n var_5 += 1\nprint(var_5)\n```", "output": "SLOWER 10.0319", "pair_id": "python_p03568_reversed", "problem_id": "p03568", "language": "python", "direction": "reversed", "speedup_ratio": 1046.9079} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\n\n\ndef func_1(var_5, var_6):\n var_4 = 0\n for var_3 in range(var_5, var_6 + 1):\n if str(var_3) == str(var_3)[::-1]:\n var_4 += 1\n return var_4\n\n\nprint((func_1(var_1, var_2)))\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n if str(var_4) == \"\".join(reversed(str(var_4))):\n var_3 += 1\nprint(var_3)\n```", "output": "SLOWER 1.3999", "pair_id": "python_p03416_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 2.6388} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nfrom collections import deque\n\n\ndef func_2(var_9, var_2, var_4):\n\n var_6 = {var_7: dict() for var_7 in range(var_9)}\n for var_7 in range(var_9 - 1):\n var_1, var_3 = var_2[var_7] - 1, var_4[var_7] - 1\n var_6[var_1][var_3] = -1\n var_6[var_3][var_1] = -1\n var_8 = max([len(var_6[var_1]) for var_1 in range(var_9)])\n var_14 = [-1] * var_9\n var_14[0] = var_8 - 1\n\n var_12 = deque([0])\n while len(var_12) > 0:\n var_10 = var_12.popleft()\n var_5 = var_14[var_10]\n for var_11 in list(var_6[var_10].keys()):\n if var_14[var_11] != -1:\n continue\n var_5 += 1\n var_5 %= var_8\n\n var_6[var_10][var_11] = var_5\n var_6[var_11][var_10] = var_5\n var_14[var_11] = var_5\n var_12.append(var_11)\n var_13 = [0] * (var_9 - 1)\n for var_7 in range(var_9 - 1):\n var_13[var_7] = var_6[var_2[var_7] - 1][var_4[var_7] - 1] + 1\n return var_8, var_13\n\n\ndef func_1():\n var_9 = int(eval(input()))\n var_2 = [0] * (var_9 - 1)\n var_4 = [0] * (var_9 - 1)\n for var_7 in range(var_9 - 1):\n var_1, var_3 = list(map(int, input().split()))\n var_2[var_7] = var_1\n var_4[var_7] = var_3\n var_8, var_13 = func_2(var_9, var_2, var_4)\n print(var_8)\n for var_7 in range(var_9 - 1):\n print((var_13[var_7]))\n\n\ndef func_3():\n print((func_2(3, [1, 2], [2, 3])))\n print((func_2(8, [1, 2, 2, 2, 4, 5, 6], [2, 3, 4, 5, 7, 6, 8])))\n\n\nif __name__ == \"__main__\":\n\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nvar_8 = int(eval(input()))\nvar_6 = []\nfor var_7 in range(var_8 - 1):\n var_1, var_3 = list(map(int, input().split()))\n var_6.append([var_1 - 1, var_3 - 1, var_7])\nvar_6.sort()\nvar_12 = [0] * (var_8)\nvar_2 = [0] * (var_8 - 1)\nvar_9 = 1\nvar_10 = 0\nfor var_5 in var_6:\n _from, var_11, var_7 = var_5\n if _from != var_10:\n var_9 = 1\n if var_12[_from] == var_9:\n var_9 += 1\n var_2[var_7] = var_9\n var_12[var_11] = var_9\n var_9 += 1\n var_10 = _from\nprint((max(var_2)))\nfor var_4 in var_2:\n print(var_4)\n```", "output": "FASTER 1.2239", "pair_id": "python_p02850_forward", "problem_id": "p02850", "language": "python", "direction": "forward", "speedup_ratio": 2.3358} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport math\nimport string\n\n\ndef func_4():\n return list(map(int, input().split()))\n\n\ndef func_3(var_6, var_7):\n return math.factorial(var_6) // (\n math.factorial(var_6 - var_7) * math.factorial(var_7)\n )\n\n\ndef func_2(var_9):\n var_8 = []\n for var_5 in var_9:\n if not (var_5 in var_8):\n var_8.append(var_5)\n return len(var_9) != len(var_8)\n\n\ndef func_1(var_6):\n func_1 = []\n for var_4 in range(1, var_6 + 1):\n if var_6 % var_4 == 0:\n func_1.append(var_4)\n return func_1\n\n\nvar_2 = [-1, -1, -1, 0, 0, 1, 1, 1]\nvar_3 = [-1, 0, 1, -1, 1, -1, 0, 1]\nvar_6 = int(eval(input()))\nvar_1 = func_4()\nvar_10 = 1\nfor var_4 in range(len(var_1)):\n if var_1[var_4] % 2 == 0:\n var_10 *= 2\n else:\n var_10 *= 1\nprint((3 ** len(var_1) - var_10))\n```\n\n=== Code B (Modified) ===\n```python\nvar_4 = int(eval(input()))\nvar_2 = list(map(int, input().split()))\n\n\ndef func_1(var_1, var_8, var_3):\n if var_8 == var_4:\n var_9 = 1\n for var_5 in var_3:\n var_9 *= var_5\n return 1 if var_9 % 2 == 0 else 0\n var_6 = var_3.copy()\n var_6.append(var_1[var_8] - 1)\n var_5 = var_3.copy()\n var_5.append(var_1[var_8])\n var_7 = var_3.copy()\n var_7.append(var_1[var_8] + 1)\n return (\n func_1(var_1, var_8 + 1, var_6)\n + func_1(var_1, var_8 + 1, var_5)\n + func_1(var_1, var_8 + 1, var_7)\n )\n\n\nprint((func_1(var_2, 0, [])))\n```", "output": "SLOWER 6.5932", "pair_id": "python_p03568_reversed", "problem_id": "p03568", "language": "python", "direction": "reversed", "speedup_ratio": 96.5479} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n if str(var_4) == \"\".join(reversed(str(var_4))):\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = [\n var_3 for var_3 in map(str, list(range(var_1, var_2 + 1))) if var_3 == var_3[::-1]\n]\nprint((len(var_4)))\n```", "output": "FASTER 1.7748", "pair_id": "python_p03416_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 3.4219} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\nfrom operator import itemgetter\nfrom heapq import heapify, heappop, heappush\n\nvar_1 = int(10e15)\nvar_2 = -var_1\nvar_11 = 1000000007\nsys.setrecursionlimit(1000000)\n\n\ndef func_2():\n return list(map(int, input().split()))\n\n\ndef func_4():\n return input().split()\n\n\ndef func_1():\n return int(sys.stdin.readline())\n\n\ndef func_3():\n return eval(input())\n\n\nvar_3, var_4 = func_2()\nvar_5 = [func_2() for var_9 in range(var_3)]\nvar_5.sort(key=itemgetter(0))\n\nvar_8 = [[0] * (var_4 + 1 + 3000 + 1) for _ in range(var_3 + 1)]\nvar_6 = 0\nfor var_9 in range(var_3):\n for var_10 in range(var_4 + 1 + 3000 + 1):\n var_12, var_7 = var_5[var_9]\n if 0 <= var_10 - var_12 < var_4:\n var_8[var_9 + 1][var_10] = max(\n var_8[var_9][var_10], var_8[var_9][var_10 - var_12] + var_7\n )\n else:\n var_8[var_9 + 1][var_10] = var_8[var_9][var_10]\n var_6 = max(var_6, var_8[var_9 + 1][var_10])\nprint(var_6)\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\n\nsys.setrecursionlimit(2147483647)\nvar_2 = float(\"inf\")\nvar_3 = 10**9 + 7\nvar_10 = lambda: sys.stdin.readline().rstrip()\n\n\ndef func_1():\n var_11, var_4 = list(map(int, var_10().split()))\n var_1 = [tuple(map(int, var_10().split())) for _ in range(var_11)]\n var_1.sort()\n var_8 = [0] * var_4\n var_6 = -var_2\n for var_9 in range(var_11):\n var_5, var_7 = var_1[var_9]\n var_12 = var_8[:]\n for var_13 in range(var_4):\n if var_13 + var_5 < var_4:\n var_12[var_13 + var_5] = max(\n var_12[var_13 + var_5], var_8[var_13] + var_7\n )\n else:\n var_6 = max(var_6, var_8[var_13] + var_7)\n var_8 = var_12\n print((max(var_6, max(var_8))))\n\n\nfunc_1()\n```", "output": "FASTER 5.855", "pair_id": "python_p02863_forward", "problem_id": "p02863", "language": "python", "direction": "forward", "speedup_ratio": 57.8788} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\nimport math\nfrom collections import defaultdict\nfrom bisect import bisect_left, bisect_right\n\nsys.setrecursionlimit(10**7)\n\n\ndef func_4():\n return sys.stdin.readline()[:-1]\n\n\nvar_4 = 10**9 + 7\n\n\ndef func_1():\n return int(eval(func_4()))\n\n\ndef func_2():\n return list(map(int, func_4().split()))\n\n\ndef func_3(var_6, var_3):\n if var_6 <= 0:\n return [[] for _ in range(var_3)]\n elif var_3 == 1:\n return [func_1() for _ in range(var_6)]\n else:\n var_5 = [func_2() for _ in range(var_6)]\n return list(map(list, list(zip(*var_5))))\n\n\nvar_1, var_2 = list(map(str, func_4().split()))\nvar_1 = int(var_1)\nvar_2 = 100 * int(var_2[0]) + 10 * int(var_2[2]) + int(var_2[3])\nprint((var_1 * var_2 // 100))\n```\n\n=== Code B (Modified) ===\n```python\nfrom decimal import Decimal\nimport math\n\nvar_1, var_2 = list(map(str, input().split()))\nvar_1 = int(var_1)\nvar_2 = Decimal(var_2)\nvar_3 = math.floor(var_1 * var_2)\nprint((int(var_3)))\n```", "output": "FASTER 1.9772", "pair_id": "python_p02659_forward", "problem_id": "p02659", "language": "python", "direction": "forward", "speedup_ratio": 3.9373} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_5 = int(eval(input()))\nvar_7 = list(map(int, input().split()))\nvar_8 = list(map(int, input().split()))\nvar_6 = [[0 for var_2 in range(6)] for var_3 in range(var_5 + 1)]\nvar_1 = abs(var_7[0] - var_8[0])\nvar_6[0][3] = var_6[0][0] = var_1\nvar_6[0][4] = var_6[0][1] = var_1**2\nvar_6[0][5] = var_6[0][2] = var_1**3\nvar_4 = var_1\nfor var_2 in range(1, var_5, 1):\n var_1 = abs(var_7[var_2] - var_8[var_2])\n var_6[var_2][0] = var_1\n var_6[var_2][1] = var_1**2\n var_6[var_2][2] = var_1**3\n var_6[var_2][3] = var_6[var_2 - 1][3] + var_6[var_2][0]\n var_6[var_2][4] = var_6[var_2 - 1][4] + var_6[var_2][1]\n var_6[var_2][5] = var_6[var_2 - 1][5] + var_6[var_2][2]\n if var_1 > var_4:\n var_4 = var_1\nprint((var_6[var_5 - 1][3]))\nprint((var_6[var_5 - 1][4] ** (1 / 2)))\nprint((var_6[var_5 - 1][5] ** (1 / 3)))\nprint(var_4)\n```\n\n=== Code B (Modified) ===\n```python\nvar_3 = int(input())\nvar_6 = list(map(int, input().split()))\nvar_7 = list(map(int, input().split()))\nvar_1 = [abs(var_4 - var_5) for var_4, var_5 in zip(var_6, var_7)]\nvar_2 = lambda var_3: sum([var_4**var_3 for var_4 in var_1]) ** (1 / var_3)\nprint(var_2(1), var_2(2), var_2(3), max(var_1), sep=\"\\n\")\n```", "output": "FASTER 1.2024", "pair_id": "python_p02382_forward", "problem_id": "p02382", "language": "python", "direction": "forward", "speedup_ratio": 2.3013} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\ndef func_1():\n var_2, var_3, *var_1 = list(map(int, open(0).read().split()))\n var_4 = [0] * (var_3 + max(var_1[::2]))\n for var_7, var_6 in sorted(zip(*[iter(var_1)] * 2)):\n for var_5 in reversed(list(range(var_3))):\n var_4[var_5 + var_7] = max(var_4[var_5 + var_7], var_4[var_5] + var_6)\n print((max(var_4)))\n\n\nfunc_1()\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_6 = sorted([list(map(int, input().split())) for var_5 in range(var_1)])\n\nvar_4 = [[0] * (var_2 + 1) for var_5 in range(var_1 + 1)]\n\nfor var_5 in range(var_1):\n var_9, var_8 = var_6[var_5]\n for var_7 in range(var_2 + 1):\n if var_7 + var_9 <= var_2:\n var_4[var_5 + 1][var_7 + var_9] = max(\n var_4[var_5 + 1][var_7 + var_9], var_4[var_5][var_7] + var_8\n )\n var_4[var_5 + 1][var_7] = max(var_4[var_5][var_7], var_4[var_5 + 1][var_7])\nvar_3 = 0\nfor var_5, (var_9, var_8) in enumerate(var_6):\n var_3 = max(var_3, var_4[var_5][var_2 - 1] + var_8)\nprint(var_3)\n```", "output": "SLOWER 1.7041", "pair_id": "python_p02863_reversed", "problem_id": "p02863", "language": "python", "direction": "reversed", "speedup_ratio": 3.2582} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_6 = str(var_4)\n var_5 = var_6[::-1]\n if var_6 == var_5:\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n if list(str(var_4)) == list(reversed(str(var_4))):\n var_3 += 1\nprint(var_3)\n```", "output": "SLOWER 1.15", "pair_id": "python_p03416_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 2.2191} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\nimport itertools\n\n\ndef func_2(var_4):\n return bin(eval(\"0b\" + str(var_4)))\n\n\ndef func_1():\n var_4 = int(sys.stdin.readline().rstrip())\n var_9 = [\n func_2(\"\".join(str(var_10) for var_10 in sys.stdin.readline().split()))\n for _ in range(var_4)\n ]\n var_8 = [\n [int(var_10) for var_10 in sys.stdin.readline().split()] for _ in range(var_4)\n ]\n var_3 = -(10**10)\n for var_6 in itertools.product(\"01\", repeat=10):\n var_6 = func_2(\"\".join(var_6))\n if var_6 == \"0b0\":\n continue\n var_7 = 0\n for var_2 in range(var_4):\n var_1 = var_9[var_2]\n var_5 = bin(eval(var_1) & eval(var_6)).count(\"1\")\n var_7 += var_8[var_2][var_5]\n var_3 = max(var_3, var_7)\n print(var_3)\n\n\nif __name__ == \"__main__\":\n\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\n\nvar_8 = sys.stdin.readline\n\n\ndef func_1():\n var_2 = int(eval(var_8()))\n var_1 = [int(var_8().replace(\" \", \"\"), 2) for _ in range(var_2)]\n var_3 = [list(map(int, var_8().split())) for _ in range(var_2)]\n var_4 = -(10**7) * var_2\n for var_7 in range(1, 1 << 10):\n var_10 = 0\n for var_9, var_6 in enumerate(var_1):\n var_5 = bin(var_7 & var_6).count(\"1\")\n var_10 += var_3[var_9][var_5]\n var_4 = max(var_4, var_10)\n print(var_4)\n\n\nif __name__ == \"__main__\":\n func_1()\n```", "output": "FASTER 5.3117", "pair_id": "python_p03503_forward", "problem_id": "p03503", "language": "python", "direction": "forward", "speedup_ratio": 39.7178} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_5, var_4 = map(int, input().split())\nvar_1 = [-1] * var_5\nfor var_3 in range(var_4):\n var_6, var_2 = map(int, input().split())\n if var_6 == 1 and var_2 == 0 and var_5 != 1:\n print(-1)\n exit()\n if var_1[var_6 - 1] == -1 or var_1[var_6 - 1] == var_2:\n var_1[var_6 - 1] = var_2\n else:\n print(-1)\n exit()\nif var_1[0] == -1 and var_5 != 1:\n var_1[0] = 1\nfor var_3 in range(var_5):\n if var_1[var_3] == -1:\n var_1[var_3] = 0\nprint(*var_1, sep=\"\")\n```\n\n=== Code B (Modified) ===\n```python\nimport bisect\nimport copy\nimport heapq\nimport math\nimport sys\nfrom collections import *\nfrom functools import lru_cache\nfrom itertools import accumulate, combinations, permutations, product\n\n\ndef func_1():\n return sys.stdin.readline()[:-1]\n\n\ndef func_2(var_5):\n return [0] + list(accumulate(var_5))\n\n\nsys.setrecursionlimit(500000)\nvar_7 = pow(10, 9) + 7\nvar_1 = [chr(ord(\"a\") + var_4) for var_4 in range(26)]\nvar_3 = [[1, 0], [0, 1], [-1, 0], [0, -1]]\nvar_8, var_6 = list(map(int, func_1().split()))\nvar_10 = [list(map(int, func_1().split())) for var_4 in range(var_6)]\nvar_5 = [-1] * var_8\nfor var_4 in range(var_6):\n var_9, var_2 = var_10[var_4]\n if var_5[var_9 - 1] == -1 or var_5[var_9 - 1] == var_2:\n var_5[var_9 - 1] = var_2\n else:\n print((-1))\n quit()\n\nfor var_4 in range(var_8):\n if var_4 == 0:\n if var_5[var_4] == 0 and var_8 != 1:\n print((-1))\n quit()\n elif var_5[var_4] == -1:\n if var_8 == 1:\n var_5[var_4] = 0\n else:\n var_5[var_4] = 1\n elif var_5[var_4] == -1:\n var_5[var_4] = 0\nprint((\"\".join(map(str, var_5))))\n```", "output": "SLOWER 1.1812", "pair_id": "python_p02761_reversed", "problem_id": "p02761", "language": "python", "direction": "reversed", "speedup_ratio": 2.2676} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_2, var_1 = list(map(int, input().split()))\nvar_6 = {}\nvar_3 = {}\nfor var_4 in range(var_1):\n var_5, var_7 = input().split()\n var_5 = int(var_5)\n if not var_5 in var_6:\n var_6[var_5] = 0\n var_3[var_5] = 0\n if var_7 == \"WA\" and var_3[var_5] == 0:\n var_6[var_5] += 1\n elif var_7 == \"AC\" and var_3[var_5] == 0:\n var_3[var_5] += 1\nfor var_4 in var_6:\n if var_6[var_4] != 0 and var_3[var_4] == 0:\n var_6[var_4] = 0\nprint((sum(var_3.values()), sum(var_6.values())))\n```\n\n=== Code B (Modified) ===\n```python\nvar_6, var_5 = list(map(int, input().split()))\nvar_8 = [[] for _ in range(var_6)]\nfor var_2 in range(var_5):\n var_10, var_11 = input().split()\n var_8[int(var_10) - 1].append(var_11)\n\nvar_1, var_7 = 0, 0\nfor var_3 in range(var_6):\n var_9 = var_8[var_3]\n if \"AC\" in var_9:\n var_1 += 1\n for var_4 in var_9:\n if var_4 == \"WA\":\n var_7 += 1\n else:\n break\nprint((var_1, var_7))\n```", "output": "SLOWER 4.403", "pair_id": "python_p02802_reversed", "problem_id": "p02802", "language": "python", "direction": "reversed", "speedup_ratio": 21.1554} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_5 in range(10):\n for var_6 in range(10):\n for var_7 in range(10):\n var_3 = 10000 * var_5 + 1000 * var_6 + 100 * var_7 + 10 * var_6 + var_5\n if var_1 <= var_3 <= var_2:\n var_4 += 1\nprint(var_4)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n if list(str(var_4)) == list(reversed(str(var_4))):\n var_3 += 1\nprint(var_3)\n```", "output": "SLOWER 5.2259", "pair_id": "python_p03416_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 37.4247} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\nimport itertools\n\n\ndef func_2(var_4):\n return eval(\"0b\" + var_4)\n\n\ndef func_1():\n var_4 = int(sys.stdin.readline().rstrip())\n var_9 = [\n func_2(\"\".join(str(var_10) for var_10 in sys.stdin.readline().split()))\n for _ in range(var_4)\n ]\n var_8 = [\n [int(var_10) for var_10 in sys.stdin.readline().split()] for _ in range(var_4)\n ]\n var_3 = -(10**10)\n for var_6 in itertools.product(\"01\", repeat=10):\n var_6 = func_2(\"\".join(var_6))\n if var_6 == 0:\n continue\n var_7 = 0\n for var_2 in range(var_4):\n var_1 = var_9[var_2]\n var_5 = bin(var_1 & var_6).count(\"1\")\n var_7 += var_8[var_2][var_5]\n var_3 = max(var_3, var_7)\n print(var_3)\n\n\nif __name__ == \"__main__\":\n\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\n\nvar_8 = sys.stdin.readline\n\n\ndef func_1():\n var_2 = int(eval(var_8()))\n var_1 = []\n for _ in range(var_2):\n var_1.append(list(map(int, var_8().split())))\n var_3 = []\n for _ in range(var_2):\n var_3.append(list(map(int, var_8().split())))\n var_4 = -(10**7) * var_2\n for var_7 in range(1, 1 << 10):\n var_11 = 0\n for var_10, var_6 in enumerate(var_1):\n var_5 = 0\n for var_9 in range(10):\n if (var_7 >> var_9) & 1 & var_6[var_9]:\n var_5 += 1\n var_11 += var_3[var_10][var_5]\n var_4 = max(var_4, var_11)\n print(var_4)\n\n\nif __name__ == \"__main__\":\n func_1()\n```", "output": "FASTER 1.366", "pair_id": "python_p03503_forward", "problem_id": "p03503", "language": "python", "direction": "forward", "speedup_ratio": 2.5776} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\n\n\ndef func_1(var_5):\n var_4 = 0\n for var_3 in range(1, var_5 + 1):\n if str(var_3) == str(var_3)[::-1]:\n var_4 += 1\n return var_4\n\n\nprint((func_1(var_2) - func_1(var_1 - 1)))\n```\n\n=== Code B (Modified) ===\n```python\ndef func_1():\n var_1, var_2 = list(map(int, input().rstrip().split()))\n var_3 = 0\n for var_4 in range(var_1, var_2 + 1):\n var_5 = str(var_4)\n if var_5 == var_5[::-1]:\n var_3 += 1\n print(var_3)\n\n\nif __name__ == \"__main__\":\n func_1()\n```", "output": "FASTER 2.3366", "pair_id": "python_p03416_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 5.0511} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport copy\n\nvar_8 = int(eval(input()))\nvar_10 = set([var_6 for var_6 in range(1, 10**5)])\nvar_5 = []\nvar_11 = {}\nvar_9 = []\nfor var_6 in range(var_8 - 1):\n var_1, var_2 = list(map(int, input().split(\" \")))\n var_5.append([var_1, var_2])\n var_11.setdefault(var_1, []).append(var_2)\n var_9.append([])\nvar_9.append([])\nvar_9.append([])\nvar_7 = 0\nfor var_12 in range(1, var_8 + 1):\n var_14 = var_11.get(var_12, [])\n var_3 = 1\n for var_13 in var_14:\n if var_3 in var_9[var_12]:\n var_3 += 1\n else:\n pass\n var_9[var_13].append(var_3)\n if var_3 >= var_7:\n var_7 = var_3\n var_3 += 1\nprint(var_7)\nfor var_4 in var_5:\n print((var_9[var_4[1]][0]))\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\n\nvar_8 = sys.stdin.readline\nvar_9 = int(eval(var_8()))\nvar_6 = []\nfor var_7 in range(var_9 - 1):\n var_1, var_3 = list(map(int, var_8().split()))\n var_6.append([var_1 - 1, var_3 - 1, var_7])\nvar_6.sort()\nvar_13 = [0] * (var_9)\nvar_2 = [0] * (var_9 - 1)\nvar_10 = 1\nvar_11 = 0\nfor var_5 in var_6:\n _from, var_12, var_7 = var_5\n if _from != var_11:\n var_10 = 1\n if var_13[_from] == var_10:\n var_10 += 1\n var_2[var_7] = var_10\n var_13[var_12] = var_10\n var_10 += 1\n var_11 = _from\nprint((max(var_2)))\nfor var_4 in var_2:\n print(var_4)\n```", "output": "FASTER 4.8454", "pair_id": "python_p02850_forward", "problem_id": "p02850", "language": "python", "direction": "forward", "speedup_ratio": 28.7486} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\nimport math\nfrom collections import defaultdict\nfrom bisect import bisect_left, bisect_right\n\nsys.setrecursionlimit(10**7)\n\n\ndef func_4():\n return sys.stdin.readline()[:-1]\n\n\nvar_4 = 10**9 + 7\n\n\ndef func_1():\n return int(eval(func_4()))\n\n\ndef func_2():\n return list(map(int, func_4().split()))\n\n\ndef func_3(var_6, var_3):\n if var_6 <= 0:\n return [[] for _ in range(var_3)]\n elif var_3 == 1:\n return [func_1() for _ in range(var_6)]\n else:\n var_5 = [func_2() for _ in range(var_6)]\n return list(map(list, list(zip(*var_5))))\n\n\nfrom decimal import getcontext, Decimal\n\ngetcontext().prec = 28\nvar_1, var_2 = list(map(str, func_4().split()))\nvar_1 = int(var_1)\nvar_2 = Decimal(var_2)\nprint((int(var_1 * var_2)))\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\n\nvar_3 = sys.stdin.readline\nif __name__ == \"__main__\":\n var_1, var_2 = var_3().split()\n print((int(var_1) * round(float(var_2) * 100) // 100))\n```", "output": "FASTER 2.2434", "pair_id": "python_p02659_forward", "problem_id": "p02659", "language": "python", "direction": "forward", "speedup_ratio": 4.7352} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\nfrom operator import itemgetter\nfrom heapq import heapify, heappop, heappush\n\nvar_1 = int(10e15)\nvar_2 = -var_1\nvar_11 = 1000000007\nsys.setrecursionlimit(1000000)\n\n\ndef func_2():\n return list(map(int, input().split()))\n\n\ndef func_4():\n return input().split()\n\n\ndef func_1():\n return int(sys.stdin.readline())\n\n\ndef func_3():\n return eval(input())\n\n\nvar_3, var_4 = func_2()\nvar_5 = [func_2() for var_9 in range(var_3)]\nvar_5.sort(key=itemgetter(0))\n\nvar_8 = [[0] * (var_4 + 1 + 3000 + 1) for _ in range(var_3 + 1)]\nvar_6 = 0\nfor var_9 in range(var_3):\n for var_10 in range(var_4 + 1 + 3000 + 1):\n var_12, var_7 = var_5[var_9]\n if 0 <= var_10 - var_12 < var_4:\n var_8[var_9 + 1][var_10] = max(\n var_8[var_9][var_10], var_8[var_9][var_10 - var_12] + var_7\n )\n else:\n var_8[var_9 + 1][var_10] = var_8[var_9][var_10]\n var_6 = max(var_6, var_8[var_9 + 1][var_10])\nprint(var_6)\n```\n\n=== Code B (Modified) ===\n```python\nvar_2, var_3, *var_1 = list(map(int, open(0).read().split()))\nvar_4 = [0] * (var_3 + max(var_1[::2]))\nfor var_7, var_6 in sorted(zip(*[iter(var_1)] * 2)):\n for var_5 in reversed(list(range(var_3))):\n var_4[var_5 + var_7] = max(var_4[var_5 + var_7], var_4[var_5] + var_6)\nprint((max(var_4)))\n```", "output": "FASTER 5.4023", "pair_id": "python_p02863_forward", "problem_id": "p02863", "language": "python", "direction": "forward", "speedup_ratio": 42.2927} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_6 = int(eval(input()))\nvar_2 = list(map(int, input().split()))\nfrom itertools import product\n\nvar_5 = [-1, 0, 1]\nvar_3 = 0\nfor var_7 in product(var_5, repeat=var_6):\n var_1 = []\n for var_4 in range(var_6):\n var_1.append(var_7[var_4] + var_2[var_4])\n if any(var_8 % 2 == 0 for var_8 in var_1):\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\ndef func_1():\n var_2 = int(eval(input()))\n var_1 = [int(var_6) for var_6 in input().split()]\n var_4 = 3**var_2\n var_5 = len([var_3 for var_3 in var_1 if var_3 % 2 == 0])\n var_4 -= 2**var_5\n print(var_4)\n\n\nif __name__ == \"__main__\":\n func_1()\n```", "output": "FASTER 9.3238", "pair_id": "python_p03568_forward", "problem_id": "p03568", "language": "python", "direction": "forward", "speedup_ratio": 640.828} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\ndef func_1():\n var_1, var_2 = list(map(int, input().split()))\n var_3 = 0\n for var_4 in range(var_1, var_2 + 1):\n\n if (var_4 % 10) == (var_4 // 10000 % 10) and (var_4 // 10 % 10) == (\n var_4 // 1000 % 10\n ):\n var_3 += 1\n print(var_3)\n\n\nif __name__ == \"__main__\":\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = [0] * (var_2 + 1)\nfor var_3 in range(1, var_2 + 1):\n if str(var_3) == str(var_3)[::-1]:\n var_4[var_3] = var_4[var_3 - 1] + 1\n else:\n var_4[var_3] = var_4[var_3 - 1]\nprint((var_4[var_2] - var_4[var_1 - 1]))\n```", "output": "SLOWER 3.6063", "pair_id": "python_p03416_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 12.1789} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_7 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_3 = True\n var_8 = str(var_4)\n var_6 = len(var_8)\n for var_5 in range(var_6 // 2 + 1):\n if var_8[var_5] != var_8[-var_5 - 1]:\n var_3 = False\n break\n if var_3:\n var_7 += 1\nprint(var_7)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = str(var_4)\n if var_5 == var_5[::-1]:\n var_3 += 1\nprint(var_3)\n```", "output": "FASTER 1.1295", "pair_id": "python_p03416_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 2.1879} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_3 = int(input())\nvar_6 = list(map(int, input().split()))\nvar_7 = list(map(int, input().split()))\nvar_1 = [abs(var_4 - var_5) for var_4, var_5 in zip(var_6, var_7)]\nvar_2 = lambda var_3: sum([var_4**var_3 for var_4 in var_1]) ** (1 / var_3)\nprint(var_2(1), var_2(2), var_2(3), max(var_1), sep=\"\\n\")\n```\n\n=== Code B (Modified) ===\n```python\nvar_5 = int(eval(input()))\nvar_7 = list(map(int, input().split()))\nvar_8 = list(map(int, input().split()))\nvar_6 = [[0 for var_2 in range(6)] for var_3 in range(var_5 + 1)]\nvar_1 = abs(var_7[0] - var_8[0])\nvar_6[0][3] = var_6[0][0] = var_1\nvar_6[0][4] = var_6[0][1] = var_1**2\nvar_6[0][5] = var_6[0][2] = var_1**3\nvar_4 = var_1\nfor var_2 in range(1, var_5, 1):\n var_1 = abs(var_7[var_2] - var_8[var_2])\n var_6[var_2][0] = var_1\n var_6[var_2][1] = var_1**2\n var_6[var_2][2] = var_1**3\n var_6[var_2][3] = var_6[var_2 - 1][3] + var_6[var_2][0]\n var_6[var_2][4] = var_6[var_2 - 1][4] + var_6[var_2][1]\n var_6[var_2][5] = var_6[var_2 - 1][5] + var_6[var_2][2]\n if var_1 > var_4:\n var_4 = var_1\nprint((var_6[var_5 - 1][3]))\nprint((var_6[var_5 - 1][4] ** (1 / 2)))\nprint((var_6[var_5 - 1][5] ** (1 / 3)))\nprint(var_4)\n```", "output": "SLOWER 1.2024", "pair_id": "python_p02382_reversed", "problem_id": "p02382", "language": "python", "direction": "reversed", "speedup_ratio": 2.3013} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_4 = str(var_4)\n if var_4 == var_4[::-1]:\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_3 = list(map(int, input().split()))\nvar_2 = 0\nfor var_5 in range(var_3 + 1)[var_1:]:\n if len(str(var_5)) % 2 == 0:\n var_6 = list(str(var_5))[: len(str(var_5)) // 2]\n var_7 = list(reversed(list(str(var_5))[len(str(var_5)) // 2 :]))\n if var_6 == var_7:\n var_2 += 1\n else:\n var_8 = list(str(var_5))[: len(str(var_5)) // 2 + 1]\n var_4 = list(reversed(list(str(var_5))[len(str(var_5)) // 2 :]))\n if var_8 == var_4:\n var_2 += 1\nprint(var_2)\n```", "output": "SLOWER 2.3275", "pair_id": "python_p03416_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 5.0195} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\nimport math\nfrom collections import defaultdict\nfrom bisect import bisect_left, bisect_right\n\nsys.setrecursionlimit(10**7)\n\n\ndef func_4():\n return sys.stdin.readline()[:-1]\n\n\nvar_4 = 10**9 + 7\n\n\ndef func_1():\n return int(eval(func_4()))\n\n\ndef func_2():\n return list(map(int, func_4().split()))\n\n\ndef func_3(var_6, var_3):\n if var_6 <= 0:\n return [[] for _ in range(var_3)]\n elif var_3 == 1:\n return [func_1() for _ in range(var_6)]\n else:\n var_5 = [func_2() for _ in range(var_6)]\n return list(map(list, list(zip(*var_5))))\n\n\nfrom decimal import getcontext, Decimal\n\ngetcontext().prec = 28\nvar_1, var_2 = list(map(str, func_4().split()))\nvar_1 = int(var_1)\nvar_2 = Decimal(var_2)\nprint((int(var_1 * var_2)))\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = input().split()\nvar_1 = int(var_1)\nvar_2 = int(var_2.replace(\".\", \"\"))\nprint((var_1 * var_2 // 100))\n```", "output": "FASTER 2.5637", "pair_id": "python_p02659_forward", "problem_id": "p02659", "language": "python", "direction": "forward", "speedup_ratio": 5.9123} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_3 = list(map(int, input().split()))\nvar_2 = 0\nfor var_5 in range(var_3 + 1)[var_1:]:\n if len(str(var_5)) % 2 == 0:\n var_6 = list(str(var_5))[: len(str(var_5)) // 2]\n var_7 = list(reversed(list(str(var_5))[len(str(var_5)) // 2 :]))\n if var_6 == var_7:\n var_2 += 1\n else:\n var_8 = list(str(var_5))[: len(str(var_5)) // 2 + 1]\n var_4 = list(reversed(list(str(var_5))[len(str(var_5)) // 2 :]))\n if var_8 == var_4:\n var_2 += 1\nprint(var_2)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_5 in range(10):\n for var_6 in range(10):\n for var_7 in range(10):\n var_3 = 10000 * var_5 + 1000 * var_6 + 100 * var_7 + 10 * var_6 + var_5\n if var_1 <= var_3 <= var_2:\n var_4 += 1\nprint(var_4)\n```", "output": "FASTER 6.3001", "pair_id": "python_p03416_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 78.7987} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport numpy as np\nfrom itertools import product\n\nvar_6 = int(eval(input()))\nvar_2 = list(map(int, input().split()))\nvar_2 = np.array(var_2)\nvar_5 = [-1, 0, 1]\nvar_3 = 0\nfor var_7 in product(var_5, repeat=var_6):\n var_7 = np.array(var_7)\n var_1 = var_2 + var_7\n var_4 = var_1.cumprod()\n if var_4[-1] % 2 == 0:\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nimport math\nimport string\n\n\ndef func_4():\n return list(map(int, input().split()))\n\n\ndef func_3(var_6, var_7):\n return math.factorial(var_6) // (\n math.factorial(var_6 - var_7) * math.factorial(var_7)\n )\n\n\ndef func_2(var_9):\n var_8 = []\n for var_5 in var_9:\n if not (var_5 in var_8):\n var_8.append(var_5)\n return len(var_9) != len(var_8)\n\n\ndef func_1(var_6):\n func_1 = []\n for var_4 in range(1, var_6 + 1):\n if var_6 % var_4 == 0:\n func_1.append(var_4)\n return func_1\n\n\nvar_2 = [-1, -1, -1, 0, 0, 1, 1, 1]\nvar_3 = [-1, 0, 1, -1, 1, -1, 0, 1]\nvar_6 = int(eval(input()))\nvar_1 = func_4()\nvar_10 = 1\nfor var_4 in range(len(var_1)):\n if var_1[var_4] % 2 == 0:\n var_10 *= 2\n else:\n var_10 *= 1\nprint((3 ** len(var_1) - var_10))\n```", "output": "FASTER 8.335", "pair_id": "python_p03568_forward", "problem_id": "p03568", "language": "python", "direction": "forward", "speedup_ratio": 322.9207} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_8 in range(var_1, var_2 + 1):\n var_7 = str(var_8)\n var_6 = len(var_7)\n var_4 = True\n for var_5 in range(var_6 // 2):\n if var_7[var_5] != var_7[var_6 - 1 - var_5]:\n var_4 = False\n break\n if var_4:\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_4 = str(var_4)\n if var_4[0] == var_4[-1] and var_4[1] == var_4[-2]:\n var_3 += 1\nprint(var_3)\n```", "output": "FASTER 1.3099", "pair_id": "python_p03416_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 2.4793} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\ndef func_1():\n from sys import setrecursionlimit, stdin\n from os import environ\n from collections import defaultdict, deque, Counter\n from math import ceil, floor, gcd\n from itertools import accumulate, combinations, combinations_with_replacement\n\n setrecursionlimit(10**6)\n var_7 = (\n (lambda *var_11: print(*var_11))\n if \"TERM_PROGRAM\" in environ\n else lambda *var_12: 0\n )\n var_8 = lambda: stdin.readline().rstrip()\n var_3 = lambda: list(map(int, var_8().split()))\n var_1 = lambda: int(var_8())\n var_4 = 10**9 + 7\n var_2 = 10**9 + 10\n var_9, var_10 = var_8().split()\n var_5 = int(var_9)\n var_6 = int(float(var_10) * 100 + 0.5)\n print(var_5 * var_6 // 100)\n\n\nfunc_1()\n```\n\n=== Code B (Modified) ===\n```python\nimport math\nfrom decimal import Decimal\n\nvar_1, var_2 = list(map(Decimal, input().split()))\nprint((math.floor(var_1 * var_2)))\n```", "output": "FASTER 2.159", "pair_id": "python_p02659_forward", "problem_id": "p02659", "language": "python", "direction": "forward", "speedup_ratio": 4.466} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nimport math\n\nif math.ceil((var_1 + 1) * 12.5) <= math.ceil(var_2 * 10) or math.ceil(\n var_1 * 12.5\n) >= math.ceil((var_2 + 1) * 10):\n print((-1))\nelse:\n print((max(math.ceil(var_1 * 12.5), math.ceil(var_2 * 10))))\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_3 = list(map(int, input().split()))\nvar_2 = -1\nfor var_4 in range(10, 12501):\n if int(var_4 * 0.08) == var_1 and int(var_4 * 0.1) == var_3:\n var_2 = var_4\n break\nprint(var_2)\n```", "output": "SLOWER 5.3196", "pair_id": "python_p02755_reversed", "problem_id": "p02755", "language": "python", "direction": "reversed", "speedup_ratio": 39.9354} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1 = list(map(int, input().split()))\nvar_2 = 0\nfor var_3 in range(var_1[0], var_1[1] + 1):\n var_4 = str(var_3)\n if var_4[0] == var_4[4] and var_4[1] == var_4[3]:\n var_2 += 1\nprint(var_2)\n```\n\n=== Code B (Modified) ===\n```python\ndef func_1():\n var_1, var_2 = list(map(int, input().split()))\n var_3 = 0\n for var_4 in range(var_1, var_2 + 1):\n\n if (var_4 % 10) == (var_4 // 10000 % 10) and (var_4 // 10 % 10) == (\n var_4 // 1000 % 10\n ):\n var_3 += 1\n print(var_3)\n\n\nif __name__ == \"__main__\":\n func_1()\n```", "output": "FASTER 1.3752", "pair_id": "python_p03416_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 2.5941} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_8 = int(eval(input()))\nvar_5 = []\nvar_10 = {}\nvar_9 = [0, 0]\nfor var_6 in range(var_8 - 1):\n var_1, var_2 = list(map(int, input().split(\" \")))\n var_5.append([var_1, var_2])\n var_10.setdefault(var_1, []).append(var_2)\n var_9.append(0)\nvar_7 = 0\nfor var_11 in range(1, var_8 + 1):\n var_13 = var_10.get(var_11, [])\n var_3 = 1\n for var_12 in var_13:\n if var_3 == var_9[var_11]:\n var_3 += 1\n else:\n pass\n var_9[var_12] = var_3\n if var_3 >= var_7:\n var_7 = var_3\n var_3 += 1\nprint(var_7)\nfor var_4 in var_5:\n print((var_9[var_4[1]]))\n```\n\n=== Code B (Modified) ===\n```python\nfrom collections import deque\n\n\ndef func_2(var_9, var_2, var_4):\n\n var_6 = {var_7: dict() for var_7 in range(var_9)}\n for var_7 in range(var_9 - 1):\n var_1, var_3 = var_2[var_7] - 1, var_4[var_7] - 1\n var_6[var_1][var_3] = -1\n var_6[var_3][var_1] = -1\n var_8 = max([len(var_6[var_1]) for var_1 in range(var_9)])\n var_14 = [-1] * var_9\n var_14[0] = var_8 - 1\n\n var_12 = deque([0])\n while len(var_12) > 0:\n var_10 = var_12.popleft()\n var_5 = var_14[var_10]\n for var_11 in list(var_6[var_10].keys()):\n if var_14[var_11] != -1:\n continue\n var_5 += 1\n var_5 %= var_8\n\n var_6[var_10][var_11] = var_5\n var_6[var_11][var_10] = var_5\n var_14[var_11] = var_5\n var_12.append(var_11)\n var_13 = [0] * (var_9 - 1)\n for var_7 in range(var_9 - 1):\n var_13[var_7] = var_6[var_2[var_7] - 1][var_4[var_7] - 1] + 1\n return var_8, var_13\n\n\ndef func_1():\n var_9 = int(eval(input()))\n var_2 = [0] * (var_9 - 1)\n var_4 = [0] * (var_9 - 1)\n for var_7 in range(var_9 - 1):\n var_1, var_3 = list(map(int, input().split()))\n var_2[var_7] = var_1\n var_4[var_7] = var_3\n var_8, var_13 = func_2(var_9, var_2, var_4)\n print(var_8)\n for var_7 in range(var_9 - 1):\n print((var_13[var_7]))\n\n\ndef func_3():\n print((func_2(3, [1, 2], [2, 3])))\n print((func_2(8, [1, 2, 2, 2, 4, 5, 6], [2, 3, 4, 5, 7, 6, 8])))\n\n\nif __name__ == \"__main__\":\n\n func_1()\n```", "output": "SLOWER 1.1277", "pair_id": "python_p02850_reversed", "problem_id": "p02850", "language": "python", "direction": "reversed", "speedup_ratio": 2.1851} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nfrom sys import stdin\n\n\ndef func_1():\n\n var_9 = stdin.readline\n var_8, var_10 = list(map(int, var_9().split()))\n var_7 = [list(map(int, var_9().split())) for _ in range(var_8)]\n var_7.sort()\n var_1 = [0] * var_8\n var_2 = [0] * var_8\n for var_4 in range(var_8):\n var_1[var_4], var_2[var_4] = var_7[var_4][0], var_7[var_4][1]\n\n var_5 = -(10**9)\n var_3 = [[var_5] * (var_10 + 1) for _ in range(var_8 + 1)]\n var_3[0][0] = 0\n for var_4 in range(var_8):\n for var_6 in range(var_10 + 1):\n\n if var_6 != var_10:\n var_3[var_4 + 1][min(var_10, var_6 + var_1[var_4])] = max(\n var_3[var_4 + 1][min(var_10, var_6 + var_1[var_4])],\n var_3[var_4][var_6] + var_2[var_4],\n )\n\n var_3[var_4 + 1][var_6] = max(var_3[var_4 + 1][var_6], var_3[var_4][var_6])\n print((max(var_3[var_8])))\n\n\nif __name__ == \"__main__\":\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nvar_6, var_7 = list(map(int, input().split()))\nvar_1 = [list(map(int, input().split())) for _ in range(var_6)]\nvar_1.sort()\nvar_3 = [(6007) * [0] for _ in range(var_6 + 1)]\nvar_3[0][0] = 0\nvar_2 = 0\nfor var_4 in range(var_6):\n for var_5 in range(6007):\n var_3[var_4 + 1][var_5] = max(var_3[var_4 + 1][var_5], var_3[var_4][var_5])\n if var_5 < var_7:\n var_3[var_4 + 1][var_5 + var_1[var_4][0]] = max(\n var_3[var_4][var_5] + var_1[var_4][1],\n var_3[var_4][var_5 + var_1[var_4][0]],\n )\n var_2 = max(var_2, var_3[var_4 + 1][var_5])\nprint(var_2)\n```", "output": "SLOWER 5.8227", "pair_id": "python_p02863_reversed", "problem_id": "p02863", "language": "python", "direction": "reversed", "speedup_ratio": 56.5998} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\nfrom collections import Counter\n\n\ndef func_9():\n return sys.stdin.readline().strip()\n\n\ndef func_10(var_8, var_9, var_10):\n return [[var_10] * var_9 for var_13 in range(var_8)]\n\n\ndef func_11(var_8, var_9, var_10, var_11):\n return [[[var_11] * var_10 for var_14 in range(var_9)] for var_13 in range(var_8)]\n\n\ndef func_12(var_8, var_9, var_10, var_11, var_12):\n return [\n [[[var_12] * var_11 for var_14 in range(var_10)] for var_14 in range(var_9)]\n for var_13 in range(var_8)\n ]\n\n\ndef func_8(var_16, var_17=1):\n return int(-(-var_16 // var_17))\n\n\ndef func_1():\n return int(eval(func_9()))\n\n\ndef func_3():\n return list(map(int, func_9().split()))\n\n\ndef func_2(var_7=None):\n return list(func_3()) if var_7 is None else [func_1() for var_13 in range(var_7)]\n\n\ndef func_7():\n print(\"Yes\")\n\n\ndef func_5():\n print(\"No\")\n\n\ndef func_6():\n print(\"YES\")\n\n\ndef func_4():\n print(\"NO\")\n\n\nsys.setrecursionlimit(10**9)\nvar_3 = 10**18\nvar_6 = 10**9 + 7\nvar_7, var_5, var_4 = func_3()\nvar_1 = func_2()\nvar_2 = func_2()\nvar_15 = min(var_1) + min(var_2)\nfor _ in range(var_4):\n var_16, var_17, var_10 = func_3()\n var_16 -= 1\n var_17 -= 1\n var_15 = min(var_15, var_1[var_16] + var_2[var_17] - var_10)\nprint(var_15)\n```\n\n=== Code B (Modified) ===\n```python\ndef func_1():\n return list(map(int, input().split()))\n\n\nimport numpy as np\n\nvar_1, var_2, var_3 = func_1()\nvar_4 = np.array(list(func_1()))\nvar_6 = np.array(list(func_1()))\nvar_9 = min(var_4) + min(var_6)\nvar_5 = float(\"inf\")\nfor var_8 in range(var_3):\n var_11, var_12, var_7 = func_1()\n var_10 = var_4[var_11 - 1] + var_6[var_12 - 1] - var_7\n var_5 = min(var_5, var_10)\nprint((min(var_5, var_9)))\n```", "output": "FASTER 1.587", "pair_id": "python_p02748_forward", "problem_id": "p02748", "language": "python", "direction": "forward", "speedup_ratio": 3.0043} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(str, input().split()))\nvar_1 = int(var_1)\nvar_2 = int(float(var_2) * 1000)\nprint((var_1 * var_2 // 1000))\n```\n\n=== Code B (Modified) ===\n```python\ndef func_1():\n from sys import setrecursionlimit, stdin\n from os import environ\n from collections import defaultdict, deque, Counter\n from math import ceil, floor, gcd\n from itertools import accumulate, combinations, combinations_with_replacement\n\n setrecursionlimit(10**6)\n var_7 = (\n (lambda *var_11: print(*var_11))\n if \"TERM_PROGRAM\" in environ\n else lambda *var_12: 0\n )\n var_8 = lambda: stdin.readline().rstrip()\n var_3 = lambda: list(map(int, var_8().split()))\n var_1 = lambda: int(var_8())\n var_4 = 10**9 + 7\n var_2 = 10**9 + 10\n var_9, var_10 = var_8().split()\n var_5 = int(var_9)\n var_10 = var_10.split(\".\")\n var_6 = int(var_10[0]) * 100\n if len(var_10) == 2:\n var_6 += int(var_10[1])\n print(var_5 * var_6 // 100)\n\n\nfunc_1()\n```", "output": "SLOWER 2.1723", "pair_id": "python_p02659_reversed", "problem_id": "p02659", "language": "python", "direction": "reversed", "speedup_ratio": 4.5074} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\n\nvar_7 = sys.stdin.readline\nfrom itertools import combinations\n\n\ndef func_3(var_10):\n for _ in range(var_10):\n yield list(map(int, var_7().split()))\n\n\ndef func_1(var_9, var_5, var_11):\n var_3 = len([0 for var_8 in var_9 if var_5[var_8] == 1])\n return var_11[var_3]\n\n\ndef func_2():\n var_10 = int(eval(var_7()))\n var_1 = list(func_3(var_10))\n var_2 = list(func_3(var_10))\n for var_6 in range(1, 11):\n for var_4 in combinations(list(range(10)), var_6):\n yield sum(\n func_1(var_4, var_5, var_11) for var_5, var_11 in zip(var_1, var_2)\n )\n\n\nprint((max(func_2())))\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\nimport itertools\n\n\ndef func_2(var_4):\n return eval(\"0b\" + var_4)\n\n\ndef func_1():\n var_4 = int(sys.stdin.readline().rstrip())\n var_9 = [\n func_2(\"\".join(str(var_10) for var_10 in sys.stdin.readline().split()))\n for _ in range(var_4)\n ]\n var_8 = [\n [int(var_10) for var_10 in sys.stdin.readline().split()] for _ in range(var_4)\n ]\n var_3 = -(10**10)\n for var_6 in itertools.product(\"01\", repeat=10):\n var_6 = func_2(\"\".join(var_6))\n if var_6 == 0:\n continue\n var_7 = 0\n for var_2 in range(var_4):\n var_1 = var_9[var_2]\n var_5 = bin(var_1 & var_6).count(\"1\")\n var_7 += var_8[var_2][var_5]\n var_3 = max(var_3, var_7)\n print(var_3)\n\n\nif __name__ == \"__main__\":\n\n func_1()\n```", "output": "SLOWER 2.0211", "pair_id": "python_p03503_reversed", "problem_id": "p03503", "language": "python", "direction": "reversed", "speedup_ratio": 4.0589} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport math\nimport string\n\n\ndef func_5():\n return list(map(int, input().split()))\n\n\ndef func_4(var_7, var_8):\n return math.factorial(var_7) // (\n math.factorial(var_7 - var_8) * math.factorial(var_8)\n )\n\n\ndef func_3(var_10):\n var_9 = []\n for var_5 in var_10:\n if not (var_5 in var_9):\n var_9.append(var_5)\n return len(var_10) != len(var_9)\n\n\ndef func_1(var_7):\n func_1 = []\n for var_4 in range(1, var_7 + 1):\n if var_7 % var_4 == 0:\n func_1.append(var_4)\n return func_1\n\n\nvar_2 = [-1, -1, -1, 0, 0, 1, 1, 1]\nvar_3 = [-1, 0, 1, -1, 1, -1, 0, 1]\nvar_7 = int(eval(input()))\nvar_1 = func_5()\n\n\ndef func_2(var_6):\n if len(var_6) == var_7:\n for var_4 in range(len(var_6)):\n if var_6[var_4] % 2 == 0:\n return 1\n return 0\n return (\n func_2(var_6 + [var_1[len(var_6)]])\n + func_2(var_6 + [var_1[len(var_6)] - 1])\n + func_2(var_6 + [var_1[len(var_6)] + 1])\n )\n\n\nprint((func_2([])))\n```\n\n=== Code B (Modified) ===\n```python\nfrom functools import reduce\nfrom itertools import product\n\nvar_2 = int(eval(input()))\n(*var_1,) = list(map(int, input().split()))\nvar_4 = 0\nfor var_7 in product([-1, 0, 1], repeat=var_2):\n var_6 = reduce(\n lambda var_8, var_9: var_8 * var_9,\n [var_3 + var_7[var_5] for var_5, var_3 in enumerate(var_1)],\n )\n if var_6 % 2 == 0:\n var_4 += 1\nprint(var_4)\n```", "output": "SLOWER 2.116", "pair_id": "python_p03568_reversed", "problem_id": "p03568", "language": "python", "direction": "reversed", "speedup_ratio": 4.3349} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n if list(str(var_4)) == list(reversed(str(var_4))):\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_4 = {}\nvar_5 = 0\nfor var_6 in range(10000, 100000):\n var_3 = list(str(var_6))\n if var_3 == list(reversed(var_3)):\n var_5 += 1\n var_4[var_6] = var_5\nvar_1, var_2 = list(map(int, input().split()))\nprint((var_4[var_2] - var_4[var_1 - 1] if var_1 > 10000 else var_4[var_2]))\n```", "output": "SLOWER 2.1733", "pair_id": "python_p03416_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 4.5104} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_10 = []\nvar_10 = input().rstrip().split(\" \")\nvar_1 = int(var_10[0])\nvar_3 = int(var_10[1])\nvar_2 = 0\nvar_6 = var_1\nwhile var_6 <= var_3:\n var_4 = var_6 // 10000\n var_5 = (var_6 - var_4 * 10000) // 1000\n var_7 = var_6 // 100\n var_8 = (var_6 - var_7 * 100) // 10\n var_9 = var_6 % 10\n if (var_4 == var_9) and (var_5 == var_8):\n var_2 += 1\n var_6 += 1\nprint(var_2)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\n\n\ndef func_1(var_5, var_6):\n var_4 = 0\n for var_3 in range(var_5, var_6 + 1):\n if str(var_3) == str(var_3)[::-1]:\n var_4 += 1\n return var_4\n\n\nprint((func_1(var_1, var_2)))\n```", "output": "FASTER 1.1326", "pair_id": "python_p03416_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 2.1926} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1 = list(map(int, input().split()))\nvar_2 = 0\nfor var_3 in range(var_1[0], var_1[1] + 1):\n var_4 = str(var_3)\n if var_4[0] == var_4[4] and var_4[1] == var_4[3]:\n var_2 += 1\nprint(var_2)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_7 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_3 = True\n var_8 = str(var_4)\n var_6 = len(var_8)\n for var_5 in range(var_6 // 2 + 1):\n if var_8[var_5] != var_8[-var_5 - 1]:\n var_3 = False\n break\n if var_3:\n var_7 += 1\nprint(var_7)\n```", "output": "SLOWER 1.4139", "pair_id": "python_p03416_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 2.6646} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_11 = int(eval(input()))\nvar_12 = {var_8: [] for var_8 in range(1, var_11 + 1)}\nvar_19 = [False for var_8 in range(var_11 + 1)]\nvar_16 = []\nfor _ in range(var_11 - 1):\n var_2, var_3 = list(map(int, input().split()))\n var_12[var_2].append(var_3)\n var_12[var_3].append(var_2)\n var_16.append((var_2, var_3))\nvar_9 = var_16[0][0]\nvar_19[var_9] = True\nvar_6 = []\nvar_7 = []\nvar_14 = {var_8: {} for var_8 in range(1, var_11 + 1)}\nvar_10 = [0 for var_8 in range(var_11 + 1)]\n\nvar_4 = 1\nfor var_5 in var_12[var_9]:\n var_19[var_5] = True\n var_14[var_9][var_5] = var_4\n var_14[var_5][var_9] = var_4\n var_10[var_5] = var_4\n var_4 += 1\n var_6.append(var_5)\nwhile var_6:\n for var_15 in var_6:\n var_13 = 1\n for var_5 in var_12[var_15]:\n if var_19[var_5] == False:\n var_19[var_5] = True\n if var_13 != var_10[var_15]:\n var_14[var_15][var_5] = var_13\n var_14[var_5][var_15] = var_13\n var_10[var_5] = var_13\n var_13 += 1\n var_7.append(var_5)\n else:\n var_13 += 1\n var_14[var_15][var_5] = var_13\n var_14[var_5][var_15] = var_13\n var_10[var_5] = var_13\n var_13 += 1\n var_7.append(var_5)\n if var_7:\n var_6 = var_7\n var_7 = []\n else:\n var_6 = []\n var_7 = []\nvar_1 = 0\nfor var_8 in range(1, var_11 + 1):\n var_1 = max(var_1, len(var_12[var_8]))\nprint(var_1)\nfor var_8 in range(var_11 - 1):\n var_17, var_18 = var_16[var_8][0], var_16[var_8][1]\n print((var_14[var_17][var_18]))\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\nfrom collections import deque\n\nvar_13 = sys.stdin.readline\nvar_2 = int(eval(var_13()))\nvar_5 = [[] for _ in range(var_2)]\nvar_3 = [-1] * var_2\nfor var_12 in range(var_2 - 1):\n var_6, var_8 = list(map(int, var_13().split()))\n var_5[var_6 - 1].append((var_12, var_8 - 1))\n\n\nvar_4 = deque([(0, -1)])\nvar_1 = [-1] * (var_2 - 1)\nvar_11 = 0\nwhile var_4:\n var_14, var_10 = var_4.pop()\n var_9 = 1\n for var_12, var_15 in var_5[var_14]:\n if var_9 == var_10:\n var_9 += 1\n var_1[var_12] = var_9\n var_4.appendleft((var_15, var_9))\n var_9 += 1\n var_11 = max(var_11, var_9 - 1)\nprint(var_11)\nfor var_7 in var_1:\n print(var_7)\n```", "output": "FASTER 1.0676", "pair_id": "python_p02850_forward", "problem_id": "p02850", "language": "python", "direction": "forward", "speedup_ratio": 2.0959} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = input().split()\nvar_1 = int(var_1)\nvar_3, var_4 = list(map(int, var_2.split(\".\")))\nvar_5 = var_1 * (var_3 * 100 + var_4)\nprint((int(var_5 // 100)))\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\nimport math\nfrom collections import defaultdict\nfrom bisect import bisect_left, bisect_right\n\nsys.setrecursionlimit(10**7)\n\n\ndef func_4():\n return sys.stdin.readline()[:-1]\n\n\nvar_4 = 10**9 + 7\n\n\ndef func_1():\n return int(eval(func_4()))\n\n\ndef func_2():\n return list(map(int, func_4().split()))\n\n\ndef func_3(var_6, var_3):\n if var_6 <= 0:\n return [[] for _ in range(var_3)]\n elif var_3 == 1:\n return [func_1() for _ in range(var_6)]\n else:\n var_5 = [func_2() for _ in range(var_6)]\n return list(map(list, list(zip(*var_5))))\n\n\nvar_1, var_2 = list(map(str, func_4().split()))\nvar_1 = int(var_1)\nvar_2 = 100 * int(var_2[0]) + 10 * int(var_2[2]) + int(var_2[3])\nprint((var_1 * var_2 // 100))\n```", "output": "SLOWER 2.0781", "pair_id": "python_p02659_reversed", "problem_id": "p02659", "language": "python", "direction": "reversed", "speedup_ratio": 4.2224} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\nfrom collections import Counter\n\n\ndef func_10():\n return sys.stdin.readline().strip()\n\n\ndef func_11(var_12, var_13, var_14):\n return [[var_14] * var_13 for var_17 in range(var_12)]\n\n\ndef func_12(var_12, var_13, var_14, var_15):\n return [[[var_15] * var_14 for var_18 in range(var_13)] for var_17 in range(var_12)]\n\n\ndef func_13(var_12, var_13, var_14, var_15, var_16):\n return [\n [[[var_16] * var_15 for var_18 in range(var_14)] for var_18 in range(var_13)]\n for var_17 in range(var_12)\n ]\n\n\ndef func_8(var_22, var_23=1):\n return int(-(-var_22 // var_23))\n\n\ndef func_1():\n return int(eval(func_10()))\n\n\ndef func_3():\n return list(map(int, func_10().split()))\n\n\ndef func_2(var_11=None):\n return list(func_3()) if var_11 is None else [func_1() for var_17 in range(var_11)]\n\n\ndef func_7():\n print(\"Yes\")\n\n\ndef func_5():\n print(\"No\")\n\n\ndef func_6():\n print(\"YES\")\n\n\ndef func_4():\n print(\"NO\")\n\n\nsys.setrecursionlimit(10**9)\nvar_5 = 10**18\nvar_10 = 10**9 + 7\n\n\ndef func_9(var_1, var_2):\n \"\"\"\"\"\"\n import numpy as np\n from numpy.fft import rfft, irfft\n\n var_8 = max(var_1)\n var_9 = max(var_2)\n var_3 = [0] * (var_8 + 1)\n var_4 = [0] * (var_9 + 1)\n for var_12 in var_1:\n var_3[var_12] += 1\n for var_13 in var_2:\n var_4[var_13] += 1\n\n var_6 = 1\n var_19 = 0\n while var_6 <= var_8 + var_9:\n var_19 += 1\n var_6 = 2**var_19\n\n var_21 = irfft(rfft(var_3, var_6) * rfft(var_4, var_6), var_6)\n\n var_21 = np.rint(var_21).astype(np.int64)\n return var_21\n\n\nvar_11, var_7, var_6 = func_3()\nvar_1 = func_2()\nvar_2 = func_2()\nvar_21 = list(func_9(var_1, var_2))\nvar_20 = var_5\nfor var_17, var_12 in enumerate(var_21):\n if var_12 != 0:\n var_20 = var_17\n break\nfor _ in range(var_6):\n var_22, var_23, var_14 = func_3()\n var_22 -= 1\n var_23 -= 1\n var_20 = min(var_20, var_1[var_22] + var_2[var_23] - var_14)\nprint(var_20)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2, var_8 = list(map(int, input().split()))\nvar_4 = list(map(int, input().split()))\nvar_9 = list(map(int, input().split()))\nvar_10 = [list(map(int, input().split())) for var_6 in range(var_8)]\nvar_7 = 200001\nfor var_6 in range(var_8):\n var_5 = var_10[var_6][0] - 1\n var_3 = var_10[var_6][1] - 1\n if var_7 >= var_4[var_5] + var_9[var_3] - var_10[var_6][2]:\n var_7 = var_4[var_5] + var_9[var_3] - var_10[var_6][2]\nvar_4.sort()\nvar_9.sort()\nif var_7 >= (var_4[0] + var_9[0]):\n print((var_4[0] + var_9[0]))\nelse:\n print(var_7)\n```", "output": "FASTER 2.5091", "pair_id": "python_p02748_forward", "problem_id": "p02748", "language": "python", "direction": "forward", "speedup_ratio": 5.6927} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_4 = str(var_4)\n if var_4 == var_4[::-1]:\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = list(reversed(list(str(var_4))))\n if var_5 == list(str(var_4)):\n var_3 += 1\nprint(var_3)\n```", "output": "SLOWER 1.5099", "pair_id": "python_p03416_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 2.848} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport decimal\n\nvar_1, var_2 = (decimal.Decimal(var_3) for var_3 in input().split())\nprint((int(var_1 * var_2)))\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\nimport math\nfrom collections import defaultdict\nfrom bisect import bisect_left, bisect_right\n\nsys.setrecursionlimit(10**7)\n\n\ndef func_4():\n return sys.stdin.readline()[:-1]\n\n\nvar_4 = 10**9 + 7\n\n\ndef func_1():\n return int(eval(func_4()))\n\n\ndef func_2():\n return list(map(int, func_4().split()))\n\n\ndef func_3(var_6, var_3):\n if var_6 <= 0:\n return [[] for _ in range(var_3)]\n elif var_3 == 1:\n return [func_1() for _ in range(var_6)]\n else:\n var_5 = [func_2() for _ in range(var_6)]\n return list(map(list, list(zip(*var_5))))\n\n\nvar_1, var_2 = list(map(str, func_4().split()))\nvar_1 = int(var_1)\nvar_2 = 100 * int(var_2[0]) + 10 * int(var_2[2]) + int(var_2[3])\nprint((var_1 * var_2 // 100))\n```", "output": "SLOWER 2.2511", "pair_id": "python_p02659_reversed", "problem_id": "p02659", "language": "python", "direction": "reversed", "speedup_ratio": 4.7605} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_5 in range(10):\n for var_6 in range(10):\n for var_7 in range(10):\n var_3 = 10000 * var_5 + 1000 * var_6 + 100 * var_7 + 10 * var_6 + var_5\n if var_1 <= var_3 <= var_2:\n var_4 += 1\nprint(var_4)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = list(reversed(list(str(var_4))))\n if var_5 == list(str(var_4)):\n var_3 += 1\nprint(var_3)\n```", "output": "SLOWER 5.4825", "pair_id": "python_p03416_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 44.7094} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = [0] * (var_2 + 1)\nfor var_3 in range(1, var_2 + 1):\n if str(var_3) == str(var_3)[::-1]:\n var_4[var_3] = var_4[var_3 - 1] + 1\n else:\n var_4[var_3] = var_4[var_3 - 1]\nprint((var_4[var_2] - var_4[var_1 - 1]))\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\n\n\ndef func_1(var_5, var_6):\n var_4 = 0\n for var_3 in range(var_5, var_6 + 1):\n if str(var_3) == str(var_3)[::-1]:\n var_4 += 1\n return var_4\n\n\nprint((func_1(var_1, var_2)))\n```", "output": "FASTER 2.2659", "pair_id": "python_p03416_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 4.8095} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_2 = int(eval(input()))\nvar_1 = list(map(int, input().split()))\nvar_4 = 1\nfor var_3 in range(var_2):\n if var_1[var_3] % 2 == 0:\n var_4 *= 2\nprint((3**var_2 - var_4))\n```\n\n=== Code B (Modified) ===\n```python\nvar_4 = int(eval(input()))\nvar_2 = list(map(int, input().split()))\n\n\ndef func_1(var_1, var_8, var_3):\n if var_8 == var_4:\n var_9 = 1\n for var_5 in var_3:\n var_9 *= var_5\n return 1 if var_9 % 2 == 0 else 0\n var_6 = var_3.copy()\n var_6.append(var_1[var_8] - 1)\n var_5 = var_3.copy()\n var_5.append(var_1[var_8])\n var_7 = var_3.copy()\n var_7.append(var_1[var_8] + 1)\n return (\n func_1(var_1, var_8 + 1, var_6)\n + func_1(var_1, var_8 + 1, var_5)\n + func_1(var_1, var_8 + 1, var_7)\n )\n\n\nprint((func_1(var_2, 0, [])))\n```", "output": "SLOWER 8.3009", "pair_id": "python_p03568_reversed", "problem_id": "p03568", "language": "python", "direction": "reversed", "speedup_ratio": 315.3596} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\n\n\ndef func_1(var_5):\n var_4 = 0\n for var_3 in range(1, var_5 + 1):\n if str(var_3) == str(var_3)[::-1]:\n var_4 += 1\n return var_4\n\n\nprint((func_1(var_2) - func_1(var_1 - 1)))\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_6 = str(var_4)\n var_5 = var_6[::-1]\n if var_6 == var_5:\n var_3 += 1\nprint(var_3)\n```", "output": "FASTER 1.3402", "pair_id": "python_p03416_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 2.5319} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = [\n var_3 for var_3 in map(str, list(range(var_1, var_2 + 1))) if var_3 == var_3[::-1]\n]\nprint((len(var_4)))\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_7 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_3 = True\n var_8 = str(var_4)\n var_6 = len(var_8)\n for var_5 in range(var_6 // 2 + 1):\n if var_8[var_5] != var_8[-var_5 - 1]:\n var_3 = False\n break\n if var_3:\n var_7 += 1\nprint(var_7)\n```", "output": "SLOWER 1.8237", "pair_id": "python_p03416_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 3.5398} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_3 in range(var_1, var_2 + 1):\n var_5 = list(str(var_3))\n var_6 = list(reversed(var_5))\n if var_5 == var_6:\n var_4 += 1\nprint(var_4)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = [\n var_3 for var_3 in map(str, list(range(var_1, var_2 + 1))) if var_3 == var_3[::-1]\n]\nprint((len(var_4)))\n```", "output": "FASTER 2.0072", "pair_id": "python_p03416_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 4.02} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport bisect\nimport copy\nimport heapq\nimport math\nimport sys\nfrom collections import *\nfrom functools import lru_cache\nfrom itertools import accumulate, combinations, permutations, product\n\n\ndef func_1():\n return sys.stdin.readline()[:-1]\n\n\ndef func_2(var_5):\n return [0] + list(accumulate(var_5))\n\n\nsys.setrecursionlimit(500000)\nvar_7 = pow(10, 9) + 7\nvar_1 = [chr(ord(\"a\") + var_4) for var_4 in range(26)]\nvar_3 = [[1, 0], [0, 1], [-1, 0], [0, -1]]\nvar_8, var_6 = list(map(int, func_1().split()))\nvar_10 = [list(map(int, func_1().split())) for var_4 in range(var_6)]\nvar_5 = [-1] * var_8\nfor var_4 in range(var_6):\n var_9, var_2 = var_10[var_4]\n if var_5[var_9 - 1] == -1 or var_5[var_9 - 1] == var_2:\n var_5[var_9 - 1] = var_2\n else:\n print((-1))\n quit()\n\nfor var_4 in range(var_8):\n if var_4 == 0:\n if var_5[var_4] == 0 and var_8 != 1:\n print((-1))\n quit()\n elif var_5[var_4] == -1:\n if var_8 == 1:\n var_5[var_4] = 0\n else:\n var_5[var_4] = 1\n elif var_5[var_4] == -1:\n var_5[var_4] = 0\nprint((\"\".join(map(str, var_5))))\n```\n\n=== Code B (Modified) ===\n```python\nvar_5, var_4 = map(int, input().split())\nvar_1 = [-1] * var_5\nfor var_3 in range(var_4):\n var_6, var_2 = map(int, input().split())\n if var_6 == 1 and var_2 == 0 and var_5 != 1:\n print(-1)\n exit()\n if var_1[var_6 - 1] == -1 or var_1[var_6 - 1] == var_2:\n var_1[var_6 - 1] = var_2\n else:\n print(-1)\n exit()\nif var_1[0] == -1 and var_5 != 1:\n var_1[0] = 1\nfor var_3 in range(var_5):\n if var_1[var_3] == -1:\n var_1[var_3] = 0\nprint(*var_1, sep=\"\")\n```", "output": "FASTER 1.1812", "pair_id": "python_p02761_forward", "problem_id": "p02761", "language": "python", "direction": "forward", "speedup_ratio": 2.2676} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n if list(str(var_4)) == list(reversed(str(var_4))):\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = str(var_4)\n if var_5[0] == var_5[4] and var_5[1] == var_5[3]:\n var_3 += 1\nprint(var_3)\n```", "output": "FASTER 1.6665", "pair_id": "python_p03416_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 3.1745} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = list(str(var_4))\n if var_5 == list(reversed(var_5)):\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nfrom sys import stdin\n\nvar_6 = lambda: list(map(int, stdin.readline().split()))\nvar_5 = lambda: list(map(int, stdin.readline().split()))\nvar_1, var_3 = var_6()\nvar_2 = 0\nfor var_4 in range(var_1, var_3 + 1):\n var_7 = str(var_4)\n if var_7 == var_7[::-1]:\n var_2 += 1\nprint(var_2)\n```", "output": "FASTER 1.2138", "pair_id": "python_p03416_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 2.3194} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\n\nvar_8 = sys.stdin.readline\n\n\ndef func_1():\n var_2 = int(eval(var_8()))\n var_1 = [int(var_8().replace(\" \", \"\"), 2) for _ in range(var_2)]\n var_3 = [list(map(int, var_8().split())) for _ in range(var_2)]\n var_4 = -(10**7) * var_2\n for var_7 in range(1, 1 << 10):\n var_10 = 0\n for var_9, var_6 in enumerate(var_1):\n var_5 = bin(var_7 & var_6).count(\"1\")\n var_10 += var_3[var_9][var_5]\n var_4 = max(var_4, var_10)\n print(var_4)\n\n\nif __name__ == \"__main__\":\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\nimport itertools\n\n\ndef func_2(var_4):\n return eval(\"0b\" + var_4)\n\n\ndef func_1():\n var_4 = int(sys.stdin.readline().rstrip())\n var_9 = [\n func_2(\"\".join(str(var_10) for var_10 in sys.stdin.readline().split()))\n for _ in range(var_4)\n ]\n var_8 = [\n [int(var_10) for var_10 in sys.stdin.readline().split()] for _ in range(var_4)\n ]\n var_3 = -(10**10)\n for var_6 in itertools.product(\"01\", repeat=10):\n var_6 = func_2(\"\".join(var_6))\n if var_6 == 0:\n continue\n var_7 = 0\n for var_2 in range(var_4):\n var_1 = var_9[var_2]\n var_5 = bin(var_1 & var_6).count(\"1\")\n var_7 += var_8[var_2][var_5]\n var_3 = max(var_3, var_7)\n print(var_3)\n\n\nif __name__ == \"__main__\":\n\n func_1()\n```", "output": "SLOWER 3.1382", "pair_id": "python_p03503_reversed", "problem_id": "p03503", "language": "python", "direction": "reversed", "speedup_ratio": 8.8042} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\nimport math\nfrom collections import defaultdict\nfrom bisect import bisect_left, bisect_right\n\nsys.setrecursionlimit(10**7)\n\n\ndef func_4():\n return sys.stdin.readline()[:-1]\n\n\nvar_4 = 10**9 + 7\n\n\ndef func_1():\n return int(eval(func_4()))\n\n\ndef func_2():\n return list(map(int, func_4().split()))\n\n\ndef func_3(var_6, var_3):\n if var_6 <= 0:\n return [[] for _ in range(var_3)]\n elif var_3 == 1:\n return [func_1() for _ in range(var_6)]\n else:\n var_5 = [func_2() for _ in range(var_6)]\n return list(map(list, list(zip(*var_5))))\n\n\nfrom decimal import getcontext, Decimal\n\ngetcontext().prec = 28\nvar_1, var_2 = list(map(str, func_4().split()))\nvar_1 = int(var_1)\nvar_2 = Decimal(var_2)\nprint((int(var_1 * var_2)))\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\n\nvar_5 = sys.stdin.readline\nif __name__ == \"__main__\":\n var_1, var_3 = var_5().split()\n var_2 = int(var_1)\n var_4 = round(float(var_3) * 100)\n print((var_2 * var_4 // 100))\n```", "output": "FASTER 2.0198", "pair_id": "python_p02659_forward", "problem_id": "p02659", "language": "python", "direction": "forward", "speedup_ratio": 4.0552} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nfrom itertools import product\n\nvar_6 = int(eval(input()))\nvar_1 = list(map(int, input().split()))\nvar_5 = 0\nfor var_2 in product((-1, 0, 1), repeat=var_6):\n var_7 = 1\n for var_3, var_4 in zip(var_1, var_2):\n var_7 *= var_3 + var_4\n if var_7 % 2 == 0:\n var_5 += 1\nprint(var_5)\n```\n\n=== Code B (Modified) ===\n```python\ndef func_1():\n var_2 = int(eval(input()))\n var_1 = [int(var_6) for var_6 in input().split()]\n var_4 = 3**var_2\n var_5 = len([var_3 for var_3 in var_1 if var_3 % 2 == 0])\n var_4 -= 2**var_5\n print(var_4)\n\n\nif __name__ == \"__main__\":\n func_1()\n```", "output": "FASTER 9.5197", "pair_id": "python_p03568_forward", "problem_id": "p03568", "language": "python", "direction": "forward", "speedup_ratio": 734.0288} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = [0] * (var_2 + 1)\nfor var_3 in range(1, var_2 + 1):\n if str(var_3) == str(var_3)[::-1]:\n var_4[var_3] = var_4[var_3 - 1] + 1\n else:\n var_4[var_3] = var_4[var_3 - 1]\nprint((var_4[var_2] - var_4[var_1 - 1]))\n```\n\n=== Code B (Modified) ===\n```python\nvar_10 = []\nvar_10 = input().rstrip().split(\" \")\nvar_1 = int(var_10[0])\nvar_3 = int(var_10[1])\nvar_2 = 0\nvar_6 = var_1\nwhile var_6 <= var_3:\n var_4 = var_6 // 10000\n var_5 = (var_6 - var_4 * 10000) // 1000\n var_7 = var_6 // 100\n var_8 = (var_6 - var_7 * 100) // 10\n var_9 = var_6 % 10\n if (var_4 == var_9) and (var_5 == var_8):\n var_2 += 1\n var_6 += 1\nprint(var_2)\n```", "output": "FASTER 1.1332", "pair_id": "python_p03416_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 2.1935} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_3 = list(map(int, input().split()))\nvar_2 = 0\nfor var_5 in range(var_3 + 1)[var_1:]:\n if len(str(var_5)) % 2 == 0:\n var_6 = list(str(var_5))[: len(str(var_5)) // 2]\n var_7 = list(reversed(list(str(var_5))[len(str(var_5)) // 2 :]))\n if var_6 == var_7:\n var_2 += 1\n else:\n var_8 = list(str(var_5))[: len(str(var_5)) // 2 + 1]\n var_4 = list(reversed(list(str(var_5))[len(str(var_5)) // 2 :]))\n if var_8 == var_4:\n var_2 += 1\nprint(var_2)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_4 = str(var_4)\n if var_4 == var_4[::-1]:\n var_3 += 1\nprint(var_3)\n```", "output": "FASTER 2.3275", "pair_id": "python_p03416_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 5.0195} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_5 in range(var_1, var_2 + 1):\n var_3 = str(var_5)\n if var_3[0] == var_3[-1] and var_3[1] == var_3[-2]:\n var_4 += 1\nprint(var_4)\n```\n\n=== Code B (Modified) ===\n```python\ndef func_1():\n var_1, var_2 = list(map(int, input().split()))\n var_3 = 0\n for var_4 in range(var_1, var_2 + 1):\n\n if (var_4 % 10) == (var_4 // 10000 % 10) and (var_4 // 10 % 10) == (\n var_4 // 1000 % 10\n ):\n var_3 += 1\n print(var_3)\n\n\nif __name__ == \"__main__\":\n func_1()\n```", "output": "FASTER 1.5725", "pair_id": "python_p03416_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 2.9741} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport copy\n\nvar_8 = int(eval(input()))\nvar_10 = set([var_6 for var_6 in range(1, 10**5)])\nvar_5 = []\nvar_11 = {}\nvar_9 = []\nfor var_6 in range(var_8 - 1):\n var_1, var_2 = list(map(int, input().split(\" \")))\n var_5.append([var_1, var_2])\n var_11.setdefault(var_1, []).append(var_2)\n var_9.append([])\nvar_9.append([])\nvar_9.append([])\nvar_7 = 0\nfor var_12 in range(1, var_8 + 1):\n var_14 = var_11.get(var_12, [])\n var_3 = 1\n for var_13 in var_14:\n if var_3 in var_9[var_12]:\n var_3 += 1\n else:\n pass\n var_9[var_13].append(var_3)\n if var_3 >= var_7:\n var_7 = var_3\n var_3 += 1\nprint(var_7)\nfor var_4 in var_5:\n print((var_9[var_4[1]][0]))\n```\n\n=== Code B (Modified) ===\n```python\nfrom collections import deque\n\n\ndef func_2(var_9, var_2, var_4):\n\n var_6 = {var_7: dict() for var_7 in range(var_9)}\n for var_7 in range(var_9 - 1):\n var_1, var_3 = var_2[var_7] - 1, var_4[var_7] - 1\n var_6[var_1][var_3] = -1\n var_6[var_3][var_1] = -1\n var_8 = max([len(var_6[var_1]) for var_1 in range(var_9)])\n var_14 = [-1] * var_9\n var_14[0] = var_8 - 1\n\n var_12 = deque([0])\n while len(var_12) > 0:\n var_10 = var_12.popleft()\n var_5 = var_14[var_10]\n for var_11 in list(var_6[var_10].keys()):\n if var_14[var_11] != -1:\n continue\n var_5 += 1\n var_5 %= var_8\n\n var_6[var_10][var_11] = var_5\n var_6[var_11][var_10] = var_5\n var_14[var_11] = var_5\n var_12.append(var_11)\n var_13 = [0] * (var_9 - 1)\n for var_7 in range(var_9 - 1):\n var_13[var_7] = var_6[var_2[var_7] - 1][var_4[var_7] - 1] + 1\n return var_8, var_13\n\n\ndef func_1():\n var_9 = int(eval(input()))\n var_2 = [0] * (var_9 - 1)\n var_4 = [0] * (var_9 - 1)\n for var_7 in range(var_9 - 1):\n var_1, var_3 = list(map(int, input().split()))\n var_2[var_7] = var_1\n var_4[var_7] = var_3\n var_8, var_13 = func_2(var_9, var_2, var_4)\n print(var_8)\n for var_7 in range(var_9 - 1):\n print((var_13[var_7]))\n\n\ndef func_3():\n print((func_2(3, [1, 2], [2, 3])))\n print((func_2(8, [1, 2, 2, 2, 4, 5, 6], [2, 3, 4, 5, 7, 6, 8])))\n\n\nif __name__ == \"__main__\":\n\n func_1()\n```", "output": "FASTER 3.6429", "pair_id": "python_p02850_forward", "problem_id": "p02850", "language": "python", "direction": "forward", "speedup_ratio": 12.4917} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_6 in range(var_1, var_2 + 1):\n var_3 = str(var_6)\n var_5 = True\n for var_7 in range(len(var_3) // 2):\n if var_3[var_7] != var_3[-var_7 - 1] and var_5:\n var_5 = not var_5\n if var_5:\n var_4 += 1\nprint(var_4)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = input().split()\nvar_1 = int(var_1)\nvar_2 = int(var_2)\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = list(str(var_4))\n if (var_5[0] == var_5[4]) and (var_5[1] == var_5[3]):\n var_3 = var_3 + 1\nprint(var_3)\n```", "output": "FASTER 1.0556", "pair_id": "python_p03416_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 2.0786} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = [0] * (var_2 + 1)\nfor var_3 in range(1, var_2 + 1):\n if str(var_3) == str(var_3)[::-1]:\n var_4[var_3] = var_4[var_3 - 1] + 1\n else:\n var_4[var_3] = var_4[var_3 - 1]\nprint((var_4[var_2] - var_4[var_1 - 1]))\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().strip().split(\" \")))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n if str(var_4) == str(var_4)[::-1]:\n var_3 += 1\nprint(var_3)\n```", "output": "FASTER 1.635", "pair_id": "python_p03416_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 3.1059} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_5 = 0\nif var_5 == 0:\n var_8 = int(eval(input()))\n var_2 = []\n for var_4 in range(var_8):\n var_3 = list(map(int, input().split()))\n var_2.append(var_3)\n var_9 = []\n for var_4 in range(var_8):\n var_10 = list(map(int, input().split()))\n var_9.append(var_10)\nelif var_5 == 1:\n var_8 = 1\n var_2 = [[1, 1, 0, 1, 0, 0, 0, 1, 0, 1]]\n var_9 = [[3, 4, 5, 6, 7, 8, 9, -2, -3, 4, -2]]\nelif var_5 == 2:\n var_8 = 2\n var_2 = [[1, 1, 1, 1, 1, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 1, 1, 1, 1, 1]]\n var_9 = [\n [0, -2, -2, -2, -2, -2, -1, -1, -1, -1, -1],\n [0, -2, -2, -2, -2, -2, -1, -1, -1, -1, -1],\n ]\nelif var_5 == 3:\n var_8 = 3\n var_2 = [\n [1, 1, 1, 1, 1, 1, 0, 0, 1, 1],\n [0, 1, 0, 1, 1, 1, 1, 0, 1, 0],\n [1, 0, 1, 1, 0, 1, 0, 1, 0, 1],\n ]\n var_9 = [\n [-8, 6, -2, -8, -8, 4, 8, 7, -6, 2, 2],\n [-9, 2, 0, 1, 7, -5, 0, -2, -6, 5, 5],\n [6, -6, 7, -9, 6, -5, 8, 0, -9, -7, -7],\n ]\nimport itertools\n\nvar_13 = -(10**11)\nfor var_4 in itertools.product([0, 1], repeat=10):\n var_11 = list(var_4)\n var_12 = 0\n if sum(var_11) != 0:\n for var_7 in range(var_8):\n var_1 = 0\n for var_6 in range(10):\n var_1 = var_1 + var_11[var_6] * var_2[var_7][var_6]\n var_12 = var_12 + var_9[var_7][var_1]\n\n var_13 = max(var_12, var_13)\nprint(var_13)\n```\n\n=== Code B (Modified) ===\n```python\nfrom sys import stdin\n\n\ndef func_1():\n\n var_13 = stdin.readline\n var_2 = int(var_13())\n var_1 = []\n for var_6 in range(var_2):\n var_5 = list(map(int, var_13().split()))\n var_1.append(var_5)\n var_3 = []\n for var_6 in range(var_2):\n var_12 = list(map(int, var_13().split()))\n var_3.append(var_12)\n var_9 = -float(\"inf\")\n for var_6 in range(1 << 10):\n if var_6 == 0:\n continue\n else:\n var_11 = []\n for var_7 in range(10):\n if (var_6 >> var_7) & 1:\n var_11.append(var_7)\n var_10 = [0] * 10\n for var_7 in var_11:\n var_10[var_7] = 1\n var_14 = 0\n for var_7 in range(var_2):\n var_4 = 0\n for var_8 in range(10):\n if var_10[var_8] == 1 and var_1[var_7][var_8] == 1:\n var_4 += 1\n var_14 += var_3[var_7][var_4]\n var_9 = max(var_14, var_9)\n print(var_9)\n\n\nif __name__ == \"__main__\":\n func_1()\n```", "output": "FASTER 1.1878", "pair_id": "python_p03503_forward", "problem_id": "p03503", "language": "python", "direction": "forward", "speedup_ratio": 2.2781} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\ndef func_1():\n var_1, var_2 = list(map(int, input().split()))\n var_3 = 0\n for var_4 in range(var_1, var_2 + 1):\n\n if (var_4 % 10) == (var_4 // 10000 % 10) and (var_4 // 10 % 10) == (\n var_4 // 1000 % 10\n ):\n var_3 += 1\n print(var_3)\n\n\nif __name__ == \"__main__\":\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nfrom sys import stdin\n\nvar_6 = lambda: list(map(int, stdin.readline().split()))\nvar_5 = lambda: list(map(int, stdin.readline().split()))\nvar_1, var_3 = var_6()\nvar_2 = 0\nfor var_4 in range(var_1, var_3 + 1):\n var_7 = str(var_4)\n if var_7 == var_7[::-1]:\n var_2 += 1\nprint(var_2)\n```", "output": "SLOWER 1.6824", "pair_id": "python_p03416_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 3.2097} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\n\n\ndef func_1(var_5):\n var_4 = 0\n for var_3 in range(1, var_5 + 1):\n if str(var_3) == str(var_3)[::-1]:\n var_4 += 1\n return var_4\n\n\nprint((func_1(var_2) - func_1(var_1 - 1)))\n```\n\n=== Code B (Modified) ===\n```python\ndef func_1():\n var_1, var_2 = list(map(int, input().split()))\n var_3 = 0\n for var_4 in range(var_1, var_2 + 1):\n\n if (var_4 % 10) == (var_4 // 10000 % 10) and (var_4 // 10 % 10) == (\n var_4 // 1000 % 10\n ):\n var_3 += 1\n print(var_3)\n\n\nif __name__ == \"__main__\":\n func_1()\n```", "output": "FASTER 3.2547", "pair_id": "python_p03416_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 9.5445} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\nimport numpy as np\n\nvar_5 = sys.stdin.readline\n\nvar_7 = int(eval(var_5()))\n\nvar_1 = [var_5().replace(\" \", \"\") for var_4 in range(var_7)]\n\nvar_8 = [list(map(int, var_5().split())) for var_4 in range(var_7)]\n\n\nvar_12 = -999999999999999\n\nfor var_4 in range(1, 1024):\n\n var_3 = format(var_4, \"010b\")\n\n var_10 = 0\n for var_2, var_9 in zip(var_1, var_8):\n\n var_11 = 0\n for var_6 in range(10):\n\n if var_2[var_6] == \"1\" and var_3[var_6] == \"1\":\n\n var_11 += 1\n\n var_10 += var_9[var_11]\n if var_10 > var_12:\n\n var_12 = var_10\nprint(var_12)\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\n\nvar_7 = sys.stdin.readline\nfrom itertools import combinations\n\n\ndef func_3(var_10):\n for _ in range(var_10):\n yield list(map(int, var_7().split()))\n\n\ndef func_1(var_9, var_5, var_11):\n var_3 = len([0 for var_8 in var_9 if var_5[var_8] == 1])\n return var_11[var_3]\n\n\ndef func_2():\n var_10 = int(eval(var_7()))\n var_1 = list(func_3(var_10))\n var_2 = list(func_3(var_10))\n for var_6 in range(1, 11):\n for var_4 in combinations(list(range(10)), var_6):\n yield sum(\n func_1(var_4, var_5, var_11) for var_5, var_11 in zip(var_1, var_2)\n )\n\n\nprint((max(func_2())))\n```", "output": "FASTER 1.6251", "pair_id": "python_p03503_forward", "problem_id": "p03503", "language": "python", "direction": "forward", "speedup_ratio": 3.0846} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().rstrip().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = list(map(int, list(str(var_4))))\n if var_5[0] == var_5[4] and var_5[1] == var_5[3]:\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\ndef func_1():\n var_1, var_2 = list(map(int, input().split()))\n var_3 = 0\n for var_4 in range(var_1, var_2 + 1):\n\n if (var_4 % 10) == (var_4 // 10000 % 10) and (var_4 // 10 % 10) == (\n var_4 // 1000 % 10\n ):\n var_3 += 1\n print(var_3)\n\n\nif __name__ == \"__main__\":\n func_1()\n```", "output": "FASTER 3.3471", "pair_id": "python_p03416_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 10.1758} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_3 = list(map(int, input().split()))\nvar_2 = 0\nfor var_5 in range(var_3 + 1)[var_1:]:\n if len(str(var_5)) % 2 == 0:\n var_6 = list(str(var_5))[: len(str(var_5)) // 2]\n var_7 = list(reversed(list(str(var_5))[len(str(var_5)) // 2 :]))\n if var_6 == var_7:\n var_2 += 1\n else:\n var_8 = list(str(var_5))[: len(str(var_5)) // 2 + 1]\n var_4 = list(reversed(list(str(var_5))[len(str(var_5)) // 2 :]))\n if var_8 == var_4:\n var_2 += 1\nprint(var_2)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_3 in range(var_1, var_2 + 1):\n var_5 = list(str(var_3))\n var_6 = list(reversed(var_5))\n if var_5 == var_6:\n var_4 += 1\nprint(var_4)\n```", "output": "FASTER 1.1659", "pair_id": "python_p03416_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 2.2437} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\ndef func_1():\n var_1, var_2 = list(map(int, input().split()))\n var_3 = 0\n for var_4 in range(var_1, var_2 + 1):\n\n if (var_4 % 10) == (var_4 // 10000 % 10) and (var_4 // 10 % 10) == (\n var_4 // 1000 % 10\n ):\n var_3 += 1\n print(var_3)\n\n\nif __name__ == \"__main__\":\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\n\n\ndef func_1(var_5):\n var_4 = 0\n for var_3 in range(1, var_5 + 1):\n if str(var_3) == str(var_3)[::-1]:\n var_4 += 1\n return var_4\n\n\nprint((func_1(var_2) - func_1(var_1 - 1)))\n```", "output": "SLOWER 3.2547", "pair_id": "python_p03416_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 9.5445} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_3 = list(map(int, input().split()))\nvar_2 = 0\nfor var_5 in range(var_3 + 1)[var_1:]:\n if len(str(var_5)) % 2 == 0:\n var_6 = list(str(var_5))[: len(str(var_5)) // 2]\n var_7 = list(reversed(list(str(var_5))[len(str(var_5)) // 2 :]))\n if var_6 == var_7:\n var_2 += 1\n else:\n var_8 = list(str(var_5))[: len(str(var_5)) // 2 + 1]\n var_4 = list(reversed(list(str(var_5))[len(str(var_5)) // 2 :]))\n if var_8 == var_4:\n var_2 += 1\nprint(var_2)\n```\n\n=== Code B (Modified) ===\n```python\ndef func_1():\n var_1, var_2 = list(map(int, input().rstrip().split()))\n var_3 = 0\n for var_4 in range(var_1, var_2 + 1):\n var_5 = str(var_4)\n if var_5 == var_5[::-1]:\n var_3 += 1\n print(var_3)\n\n\nif __name__ == \"__main__\":\n func_1()\n```", "output": "FASTER 3.2205", "pair_id": "python_p03416_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 9.3213} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport copy\n\nvar_8 = int(eval(input()))\nvar_10 = set([var_6 for var_6 in range(1, 10**5)])\nvar_5 = []\nvar_11 = {}\nvar_9 = []\nfor var_6 in range(var_8 - 1):\n var_1, var_2 = list(map(int, input().split(\" \")))\n var_5.append([var_1, var_2])\n var_11.setdefault(var_1, []).append(var_2)\n var_9.append([])\nvar_9.append([])\nvar_9.append([])\nvar_7 = 0\nfor var_12 in range(1, var_8 + 1):\n var_14 = var_11.get(var_12, [])\n var_3 = 1\n for var_13 in var_14:\n if var_3 in var_9[var_12]:\n var_3 += 1\n else:\n pass\n var_9[var_13].append(var_3)\n if var_3 >= var_7:\n var_7 = var_3\n var_3 += 1\nprint(var_7)\nfor var_4 in var_5:\n print((var_9[var_4[1]][0]))\n```\n\n=== Code B (Modified) ===\n```python\nvar_8 = int(eval(input()))\nvar_5 = []\nvar_10 = {}\nvar_9 = [0, 0]\nfor var_6 in range(var_8 - 1):\n var_1, var_2 = list(map(int, input().split(\" \")))\n var_5.append([var_1, var_2])\n var_10.setdefault(var_1, []).append(var_2)\n var_9.append(0)\nvar_7 = 0\nfor var_11 in range(1, var_8 + 1):\n var_13 = var_10.get(var_11, [])\n var_3 = 1\n for var_12 in var_13:\n if var_3 == var_9[var_11]:\n var_3 += 1\n else:\n pass\n var_9[var_12] = var_3\n if var_3 >= var_7:\n var_7 = var_3\n var_3 += 1\nprint(var_7)\nfor var_4 in var_5:\n print((var_9[var_4[1]]))\n```", "output": "FASTER 4.7706", "pair_id": "python_p02850_forward", "problem_id": "p02850", "language": "python", "direction": "forward", "speedup_ratio": 27.2957} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nfrom sys import stdin\n\nvar_6 = lambda: list(map(int, stdin.readline().split()))\nvar_5 = lambda: list(map(int, stdin.readline().split()))\nvar_1, var_3 = var_6()\nvar_2 = 0\nfor var_4 in range(var_1, var_3 + 1):\n var_7 = str(var_4)\n if var_7 == var_7[::-1]:\n var_2 += 1\nprint(var_2)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_7 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_3 = True\n var_8 = str(var_4)\n var_6 = len(var_8)\n for var_5 in range(var_6 // 2 + 1):\n if var_8[var_5] != var_8[-var_5 - 1]:\n var_3 = False\n break\n if var_3:\n var_7 += 1\nprint(var_7)\n```", "output": "SLOWER 1.1067", "pair_id": "python_p03416_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 2.1535} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\ndef func_1():\n from sys import setrecursionlimit, stdin\n from os import environ\n from collections import defaultdict, deque, Counter\n from math import ceil, floor, gcd\n from itertools import accumulate, combinations, combinations_with_replacement\n\n setrecursionlimit(10**6)\n var_7 = (\n (lambda *var_11: print(*var_11))\n if \"TERM_PROGRAM\" in environ\n else lambda *var_12: 0\n )\n var_8 = lambda: stdin.readline().rstrip()\n var_3 = lambda: list(map(int, var_8().split()))\n var_1 = lambda: int(var_8())\n var_4 = 10**9 + 7\n var_2 = 10**9 + 10\n var_9, var_10 = var_8().split()\n var_5 = int(var_9)\n var_6 = int(float(var_10) * 100 + 0.5)\n print(var_5 * var_6 // 100)\n\n\nfunc_1()\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = input().split()\nvar_1 = int(var_1)\nvar_2 = int(var_2.replace(\".\", \"\"))\nprint((var_1 * var_2 // 100))\n```", "output": "FASTER 2.2868", "pair_id": "python_p02659_forward", "problem_id": "p02659", "language": "python", "direction": "forward", "speedup_ratio": 4.8798} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_4, var_3 = list(map(int, input().split()))\nvar_1 = 0\nfor var_2 in range(var_4, var_3 + 1):\n if str(var_2)[0] + str(var_2)[1] == str(var_2)[-1] + str(var_2)[-2]:\n var_1 += 1\nprint(var_1)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_5 in range(10):\n for var_6 in range(10):\n for var_7 in range(10):\n var_3 = 10000 * var_5 + 1000 * var_6 + 100 * var_7 + 10 * var_6 + var_5\n if var_1 <= var_3 <= var_2:\n var_4 += 1\nprint(var_4)\n```", "output": "FASTER 5.1667", "pair_id": "python_p03416_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 35.9185} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\nfrom collections import Counter\n\n\ndef func_9():\n return sys.stdin.readline().strip()\n\n\ndef func_10(var_8, var_9, var_10):\n return [[var_10] * var_9 for var_13 in range(var_8)]\n\n\ndef func_11(var_8, var_9, var_10, var_11):\n return [[[var_11] * var_10 for var_14 in range(var_9)] for var_13 in range(var_8)]\n\n\ndef func_12(var_8, var_9, var_10, var_11, var_12):\n return [\n [[[var_12] * var_11 for var_14 in range(var_10)] for var_14 in range(var_9)]\n for var_13 in range(var_8)\n ]\n\n\ndef func_8(var_16, var_17=1):\n return int(-(-var_16 // var_17))\n\n\ndef func_1():\n return int(eval(func_9()))\n\n\ndef func_3():\n return list(map(int, func_9().split()))\n\n\ndef func_2(var_7=None):\n return list(func_3()) if var_7 is None else [func_1() for var_13 in range(var_7)]\n\n\ndef func_7():\n print(\"Yes\")\n\n\ndef func_5():\n print(\"No\")\n\n\ndef func_6():\n print(\"YES\")\n\n\ndef func_4():\n print(\"NO\")\n\n\nsys.setrecursionlimit(10**9)\nvar_3 = 10**18\nvar_6 = 10**9 + 7\nvar_7, var_5, var_4 = func_3()\nvar_1 = func_2()\nvar_2 = func_2()\nvar_15 = min(var_1) + min(var_2)\nfor _ in range(var_4):\n var_16, var_17, var_10 = func_3()\n var_16 -= 1\n var_17 -= 1\n var_15 = min(var_15, var_1[var_16] + var_2[var_17] - var_10)\nprint(var_15)\n```\n\n=== Code B (Modified) ===\n```python\ndef func_1():\n return list(map(int, input().split()))\n\n\nvar_1, var_2, var_3 = func_1()\nvar_4 = list(func_1())\nvar_6 = list(func_1())\nvar_5 = min(var_4) + min(var_6)\nfor _ in range(var_3):\n var_8, var_9, var_7 = func_1()\n var_5 = min(var_5, var_4[var_8 - 1] + var_6[var_9 - 1] - var_7)\nprint(var_5)\n```", "output": "FASTER 2.0028", "pair_id": "python_p02748_forward", "problem_id": "p02748", "language": "python", "direction": "forward", "speedup_ratio": 4.0077} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\ndef func_1():\n var_1, var_2 = list(map(int, input().split()))\n var_3 = 0\n for var_4 in range(var_1, var_2 + 1):\n\n if (var_4 % 10) == (var_4 // 10000 % 10) and (var_4 // 10 % 10) == (\n var_4 // 1000 % 10\n ):\n var_3 += 1\n print(var_3)\n\n\nif __name__ == \"__main__\":\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().strip().split(\" \")))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n if str(var_4) == str(var_4)[::-1]:\n var_3 += 1\nprint(var_3)\n```", "output": "SLOWER 1.9713", "pair_id": "python_p03416_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 3.9213} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\n\n\ndef func_1(var_5, var_6):\n var_4 = 0\n for var_3 in range(var_5, var_6 + 1):\n if str(var_3) == str(var_3)[::-1]:\n var_4 += 1\n return var_4\n\n\nprint((func_1(var_1, var_2)))\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_3 in range(var_1, var_2 + 1):\n var_5 = list(str(var_3))\n var_6 = list(reversed(var_5))\n if var_5 == var_6:\n var_4 += 1\nprint(var_4)\n```", "output": "SLOWER 1.6323", "pair_id": "python_p03416_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 3.1} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport decimal\n\nvar_1, var_2 = (decimal.Decimal(var_3) for var_3 in input().split())\nprint((int(var_1 * var_2)))\n```\n\n=== Code B (Modified) ===\n```python\ndef func_1():\n from sys import setrecursionlimit, stdin\n from os import environ\n from collections import defaultdict, deque, Counter\n from math import ceil, floor, gcd\n from itertools import accumulate, combinations, combinations_with_replacement\n\n setrecursionlimit(10**6)\n var_7 = (\n (lambda *var_11: print(*var_11))\n if \"TERM_PROGRAM\" in environ\n else lambda *var_12: 0\n )\n var_8 = lambda: stdin.readline().rstrip()\n var_3 = lambda: list(map(int, var_8().split()))\n var_1 = lambda: int(var_8())\n var_4 = 10**9 + 7\n var_2 = 10**9 + 10\n var_9, var_10 = var_8().split()\n var_5 = int(var_9)\n var_6 = int(float(var_10) * 100 + 0.5)\n print(var_5 * var_6 // 100)\n\n\nfunc_1()\n```", "output": "SLOWER 1.9551", "pair_id": "python_p02659_reversed", "problem_id": "p02659", "language": "python", "direction": "reversed", "speedup_ratio": 3.8775} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_4 = str(var_4)\n if var_4[0] == var_4[-1] and var_4[1] == var_4[-2]:\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\ndef func_1():\n var_1, var_2 = list(map(int, input().split()))\n var_3 = 0\n for var_4 in range(var_1, var_2 + 1):\n\n if (var_4 % 10) == (var_4 // 10000 % 10) and (var_4 // 10 % 10) == (\n var_4 // 1000 % 10\n ):\n var_3 += 1\n print(var_3)\n\n\nif __name__ == \"__main__\":\n func_1()\n```", "output": "FASTER 1.4803", "pair_id": "python_p03416_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 2.7901} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nfrom functools import reduce\nfrom itertools import product\n\nvar_2 = int(eval(input()))\n(*var_1,) = list(map(int, input().split()))\nvar_4 = 0\nfor var_7 in product([-1, 0, 1], repeat=var_2):\n var_6 = reduce(\n lambda var_8, var_9: var_8 * var_9,\n [var_3 + var_7[var_5] for var_5, var_3 in enumerate(var_1)],\n )\n if var_6 % 2 == 0:\n var_4 += 1\nprint(var_4)\n```\n\n=== Code B (Modified) ===\n```python\nimport math\nimport string\n\n\ndef func_4():\n return list(map(int, input().split()))\n\n\ndef func_3(var_6, var_7):\n return math.factorial(var_6) // (\n math.factorial(var_6 - var_7) * math.factorial(var_7)\n )\n\n\ndef func_2(var_9):\n var_8 = []\n for var_5 in var_9:\n if not (var_5 in var_8):\n var_8.append(var_5)\n return len(var_9) != len(var_8)\n\n\ndef func_1(var_6):\n func_1 = []\n for var_4 in range(1, var_6 + 1):\n if var_6 % var_4 == 0:\n func_1.append(var_4)\n return func_1\n\n\nvar_2 = [-1, -1, -1, 0, 0, 1, 1, 1]\nvar_3 = [-1, 0, 1, -1, 1, -1, 0, 1]\nvar_6 = int(eval(input()))\nvar_1 = func_4()\nvar_10 = 1\nfor var_4 in range(len(var_1)):\n if var_1[var_4] % 2 == 0:\n var_10 *= 2\n else:\n var_10 *= 1\nprint((3 ** len(var_1) - var_10))\n```", "output": "FASTER 8.0685", "pair_id": "python_p03568_forward", "problem_id": "p03568", "language": "python", "direction": "forward", "speedup_ratio": 268.4525} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1 = list(map(int, input().split()))\nvar_2 = 0\nfor var_3 in range(var_1[0], var_1[1] + 1):\n var_4 = str(var_3)\n if var_4[0] == var_4[4] and var_4[1] == var_4[3]:\n var_2 += 1\nprint(var_2)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_6 in range(var_1, var_2 + 1):\n var_3 = str(var_6)\n var_5 = True\n for var_7 in range(len(var_3) // 2):\n if var_3[var_7] != var_3[-var_7 - 1] and var_5:\n var_5 = not var_5\n if var_5:\n var_4 += 1\nprint(var_4)\n```", "output": "SLOWER 1.7488", "pair_id": "python_p03416_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 3.3607} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_8 in range(var_1, var_2 + 1):\n var_7 = str(var_8)\n var_6 = len(var_7)\n var_4 = True\n for var_5 in range(var_6 // 2):\n if var_7[var_5] != var_7[var_6 - 1 - var_5]:\n var_4 = False\n break\n if var_4:\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nfrom sys import stdin\n\nvar_6 = lambda: list(map(int, stdin.readline().split()))\nvar_5 = lambda: list(map(int, stdin.readline().split()))\nvar_1, var_3 = var_6()\nvar_2 = 0\nfor var_4 in range(var_1, var_3 + 1):\n var_7 = str(var_4)\n if var_7 == var_7[::-1]:\n var_2 += 1\nprint(var_2)\n```", "output": "FASTER 1.1078", "pair_id": "python_p03416_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 2.1552} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_3 in range(var_1, var_2 + 1):\n var_5 = list(str(var_3))\n var_6 = list(reversed(var_5))\n if var_5 == var_6:\n var_4 += 1\nprint(var_4)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_3 = list(map(int, input().split()))\nvar_2 = 0\nfor var_5 in range(var_3 + 1)[var_1:]:\n if len(str(var_5)) % 2 == 0:\n var_6 = list(str(var_5))[: len(str(var_5)) // 2]\n var_7 = list(reversed(list(str(var_5))[len(str(var_5)) // 2 :]))\n if var_6 == var_7:\n var_2 += 1\n else:\n var_8 = list(str(var_5))[: len(str(var_5)) // 2 + 1]\n var_4 = list(reversed(list(str(var_5))[len(str(var_5)) // 2 :]))\n if var_8 == var_4:\n var_2 += 1\nprint(var_2)\n```", "output": "SLOWER 1.1659", "pair_id": "python_p03416_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 2.2437} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\ndef func_1():\n from collections import Counter\n\n var_4 = int(eval(input()))\n (*var_1,) = list(map(int, input().split()))\n if var_4 % 3 == 0:\n var_2 = Counter(var_1)\n if len(var_2) == 1:\n print((\"Yes\" if 0 in var_2 else \"No\"))\n return\n elif len(var_2) == 2:\n print((\"Yes\" if var_2[0] == var_4 // 3 else \"No\"))\n return\n elif len(var_2) == 3:\n var_7 = 0\n var_5 = None\n for var_3, var_6 in list(var_2.items()):\n if var_5 is None:\n var_5 = var_6\n elif var_5 != var_6:\n print(\"No\")\n return\n var_7 ^= var_3\n print((\"Yes\" if var_7 == 0 else \"No\"))\n return\n else:\n print(\"No\")\n return\n else:\n print((\"Yes\" if all([var_7 == 0 for var_7 in var_1]) else \"No\"))\n return\n\n\nif __name__ == \"__main__\":\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\n_, var_1 = open(0)\nvar_1, *var_2 = list(map(int, var_1.split()))\nfor var_2 in var_2:\n var_1 ^= var_2\nprint((\"YNeos\"[var_1 > 0 :: 2]))\n```", "output": "FASTER 1.5263", "pair_id": "python_p02975_forward", "problem_id": "p02975", "language": "python", "direction": "forward", "speedup_ratio": 2.8805} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_4 = int(eval(input()))\nvar_1 = list(map(int, input().split()))\nvar_3 = 1\nfor var_2 in var_1:\n var_3 *= 2 if var_2 % 2 == 0 else 1\nprint((3**var_4 - var_3))\n```\n\n=== Code B (Modified) ===\n```python\ndef func_1():\n var_2 = int(input())\n var_1 = [int(var_6) for var_6 in input().split()]\n if var_2 == 1:\n return print(1 if var_1[0] % 2 == 0 else 2)\n var_3 = 0\n var_5 = (-1, 0, 1)\n from itertools import product\n\n for var_6 in product(range(3), repeat=var_2):\n var_4 = 1\n for var_7 in range(var_2):\n var_4 *= var_1[var_7] + var_5[var_6[var_7]]\n if var_4 % 2 == 0:\n var_3 += 1\n print(var_3)\n\n\nif __name__ == \"__main__\":\n func_1()\n```", "output": "SLOWER 8.6824", "pair_id": "python_p03568_reversed", "problem_id": "p03568", "language": "python", "direction": "reversed", "speedup_ratio": 410.8374} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\n\nvar_7 = sys.stdin.readline\nfrom itertools import combinations\n\n\ndef func_3(var_10):\n for _ in range(var_10):\n yield list(map(int, var_7().split()))\n\n\ndef func_1(var_9, var_5, var_11):\n var_3 = sum(1 if var_5[var_8] == 1 else 0 for var_8 in var_9)\n return var_11[var_3]\n\n\ndef func_2():\n var_10 = int(eval(var_7()))\n var_1 = list(func_3(var_10))\n var_2 = list(func_3(var_10))\n for var_6 in range(1, 11):\n for var_4 in combinations(list(range(10)), var_6):\n yield sum(\n func_1(var_4, var_5, var_11) for var_5, var_11 in zip(var_1, var_2)\n )\n\n\nprint((max(func_2())))\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\nimport itertools\n\n\ndef func_2(var_4):\n return bin(eval(\"0b\" + str(var_4)))\n\n\ndef func_1():\n var_4 = int(sys.stdin.readline().rstrip())\n var_9 = [\n func_2(\"\".join(str(var_10) for var_10 in sys.stdin.readline().split()))\n for _ in range(var_4)\n ]\n var_8 = [\n [int(var_10) for var_10 in sys.stdin.readline().split()] for _ in range(var_4)\n ]\n var_3 = -(10**10)\n for var_6 in itertools.product(\"01\", repeat=10):\n var_6 = func_2(\"\".join(var_6))\n if var_6 == \"0b0\":\n continue\n var_7 = 0\n for var_2 in range(var_4):\n var_1 = var_9[var_2]\n var_5 = bin(eval(var_1) & eval(var_6)).count(\"1\")\n var_7 += var_8[var_2][var_5]\n var_3 = max(var_3, var_7)\n print(var_3)\n\n\nif __name__ == \"__main__\":\n\n func_1()\n```", "output": "SLOWER 3.6491", "pair_id": "python_p03503_reversed", "problem_id": "p03503", "language": "python", "direction": "reversed", "speedup_ratio": 12.5454} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_2 = int(eval(input()))\n(*var_1,) = list(map(int, input().split()))\nvar_5 = 0\nfor var_3 in var_1:\n if var_3 % 2 == 0:\n var_5 += 1\nvar_4 = 3**var_2 - 2**var_5\nprint(var_4)\n```\n\n=== Code B (Modified) ===\n```python\nfrom functools import reduce\nfrom itertools import product\n\nvar_2 = int(eval(input()))\n(*var_1,) = list(map(int, input().split()))\nvar_4 = 0\nfor var_7 in product([-1, 0, 1], repeat=var_2):\n var_6 = reduce(\n lambda var_8, var_9: var_8 * var_9,\n [var_3 + var_7[var_5] for var_5, var_3 in enumerate(var_1)],\n )\n if var_6 % 2 == 0:\n var_4 += 1\nprint(var_4)\n```", "output": "SLOWER 9.7614", "pair_id": "python_p03568_reversed", "problem_id": "p03568", "language": "python", "direction": "reversed", "speedup_ratio": 867.9334} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = [0] * (var_2 + 1)\nfor var_3 in range(1, var_2 + 1):\n if str(var_3) == str(var_3)[::-1]:\n var_4[var_3] = var_4[var_3 - 1] + 1\n else:\n var_4[var_3] = var_4[var_3 - 1]\nprint((var_4[var_2] - var_4[var_1 - 1]))\n```\n\n=== Code B (Modified) ===\n```python\ndef func_1():\n var_1, var_2 = list(map(int, input().rstrip().split()))\n var_3 = 0\n for var_4 in range(var_1, var_2 + 1):\n var_5 = str(var_4)\n if var_5 == var_5[::-1]:\n var_3 += 1\n print(var_3)\n\n\nif __name__ == \"__main__\":\n func_1()\n```", "output": "FASTER 2.6882", "pair_id": "python_p03416_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 6.4453} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_4, var_3 = list(map(int, input().split()))\nvar_1 = 0\nfor var_2 in range(var_4, var_3 + 1):\n if str(var_2)[0] + str(var_2)[1] == str(var_2)[-1] + str(var_2)[-2]:\n var_1 += 1\nprint(var_1)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = str(var_4)\n if var_5[0] == var_5[4] and var_5[1] == var_5[3]:\n var_3 += 1\nprint(var_3)\n```", "output": "FASTER 1.6072", "pair_id": "python_p03416_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 3.0467} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = str(var_4)\n if var_5[0] == var_5[4] and var_5[1] == var_5[3]:\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_3 = list(map(int, input().split()))\nvar_2 = 0\nfor var_5 in range(var_3 + 1)[var_1:]:\n if len(str(var_5)) % 2 == 0:\n var_6 = list(str(var_5))[: len(str(var_5)) // 2]\n var_7 = list(reversed(list(str(var_5))[len(str(var_5)) // 2 :]))\n if var_6 == var_7:\n var_2 += 1\n else:\n var_8 = list(str(var_5))[: len(str(var_5)) // 2 + 1]\n var_4 = list(reversed(list(str(var_5))[len(str(var_5)) // 2 :]))\n if var_8 == var_4:\n var_2 += 1\nprint(var_2)\n```", "output": "SLOWER 2.7407", "pair_id": "python_p03416_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 6.6839} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\n\nsys.setrecursionlimit(500000)\n\n\ndef func_3():\n return sys.stdin.readline()[:-1]\n\n\nclass Class_1:\n def __init__(self, var_3):\n self.N = len(var_3)\n self.bit = [0] * self.N\n for var_11, var_14 in enumerate(var_3):\n self.add(var_11, var_14)\n\n def func_1(self, var_5, var_18):\n var_19 = var_5 + 1\n for var_11 in range(1000):\n self.bit[var_19 - 1] += var_18\n var_19 += var_19 & -var_19\n if var_19 > self.N:\n break\n\n def func_5(self, var_5):\n var_19 = var_5 + 1\n var_16 = 0\n for var_11 in range(1000):\n var_16 += self.bit[var_19 - 1]\n var_19 -= var_19 & -var_19\n if var_19 <= 0:\n break\n return var_16\n\n\ndef func_4():\n var_4, var_2, var_1 = list(map(int, func_3().split()))\n var_9 = []\n for var_11 in range(var_4):\n var_19, var_10 = list(map(int, func_3().split()))\n if var_10 % var_1 == 0:\n var_9.append([var_19, var_10 // var_1])\n else:\n var_9.append([var_19, var_10 // var_1 + 1])\n var_9.sort(key=lambda var_19: var_19[0])\n\n def func_2(var_12):\n var_19 = var_9[var_12][0]\n if var_9[var_4 - 1][0] <= var_19 + 2 * var_2:\n return var_4 - 1\n var_14 = var_12\n var_15 = var_4 - 1\n while var_15 - var_14 > 1:\n if var_9[(var_15 + var_14) // 2][0] <= var_19 + 2 * var_2:\n var_14 = (var_15 + var_14) // 2\n else:\n var_15 = (var_15 + var_14) // 2\n return var_14\n\n var_6 = Class_1([0] * var_4)\n var_7 = 0\n for var_11 in range(var_4):\n if var_11 > 0:\n var_17 = var_6.sum(var_4 - 1) - var_6.sum(var_11 - 1)\n else:\n var_17 = 0\n if var_9[var_11][1] - var_17 > 0:\n var_7 += var_9[var_11][1] - var_17\n var_13 = func_2(var_11)\n var_6.add(var_13, var_9[var_11][1] - var_17)\n var_9 = var_9[::-1]\n for var_11 in range(var_4):\n var_9[var_11][0] = -var_9[var_11][0]\n var_6 = Class_1([0] * var_4)\n var_8 = 0\n for var_11 in range(var_4):\n if var_11 > 0:\n var_17 = var_6.sum(var_4 - 1) - var_6.sum(var_11 - 1)\n else:\n var_17 = 0\n if var_9[var_11][1] - var_17 > 0:\n var_8 += var_9[var_11][1] - var_17\n var_13 = func_2(var_11)\n var_6.add(var_13, var_9[var_11][1] - var_17)\n print((min(var_7, var_8)))\n\n\nif __name__ == \"__main__\":\n func_4()\n```\n\n=== Code B (Modified) ===\n```python\nimport bisect\nimport sys\n\n\ndef func_1():\n var_9 = sys.stdin.readline\n var_10, var_4, var_1 = list(map(int, var_9().split()))\n var_5 = [None] * var_10\n for var_7 in range(var_10):\n var_12, var_6 = list(map(int, var_9().split()))\n var_5[var_7] = (var_12, var_6)\n var_5.sort()\n var_12 = [int(var_5[var_7][0]) for var_7 in range(var_10)]\n var_6 = [int(var_5[var_7][1]) for var_7 in range(var_10)]\n var_2 = 0\n var_3 = [0] * var_10\n for var_7 in range(var_10):\n if var_7 != 0:\n var_3[var_7] += var_3[var_7 - 1]\n var_11 = max([(var_6[var_7] - var_3[var_7] - 1) // var_1 + 1, 0])\n var_2 += var_11\n var_3[var_7] += var_11 * var_1\n var_8 = bisect.bisect_right(var_12, var_12[var_7] + 2 * var_4)\n if var_8 != var_10:\n var_3[var_8] -= var_11 * var_1\n print(var_2)\n\n\nif __name__ == \"__main__\":\n func_1()\n```", "output": "FASTER 1.2733", "pair_id": "python_p02788_forward", "problem_id": "p02788", "language": "python", "direction": "forward", "speedup_ratio": 2.4172} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\ndef func_1():\n var_1, var_2 = list(map(int, input().split()))\n var_3 = 0\n for var_4 in range(var_1, var_2 + 1):\n\n if (var_4 % 10) == (var_4 // 10000 % 10) and (var_4 // 10 % 10) == (\n var_4 // 1000 % 10\n ):\n var_3 += 1\n print(var_3)\n\n\nif __name__ == \"__main__\":\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_6 in range(var_1, var_2 + 1):\n var_3 = str(var_6)\n var_5 = True\n for var_7 in range(len(var_3) // 2):\n if var_3[var_7] != var_3[-var_7 - 1] and var_5:\n var_5 = not var_5\n if var_5:\n var_4 += 1\nprint(var_4)\n```", "output": "SLOWER 3.124", "pair_id": "python_p03416_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 8.718} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_8 in range(var_1, var_2 + 1):\n var_7 = str(var_8)\n var_6 = len(var_7)\n var_4 = True\n for var_5 in range(var_6 // 2):\n if var_7[var_5] != var_7[var_6 - 1 - var_5]:\n var_4 = False\n break\n if var_4:\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_5 in range(10):\n for var_6 in range(10):\n for var_7 in range(10):\n var_3 = 10000 * var_5 + 1000 * var_6 + 100 * var_7 + 10 * var_6 + var_5\n if var_1 <= var_3 <= var_2:\n var_4 += 1\nprint(var_4)\n```", "output": "FASTER 4.9518", "pair_id": "python_p03416_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 30.9483} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\ndef func_1():\n from sys import setrecursionlimit, stdin\n from os import environ\n from collections import defaultdict, deque, Counter\n from math import ceil, floor, gcd\n from itertools import accumulate, combinations, combinations_with_replacement\n\n setrecursionlimit(10**6)\n var_7 = (\n (lambda *var_11: print(*var_11))\n if \"TERM_PROGRAM\" in environ\n else lambda *var_12: 0\n )\n var_8 = lambda: stdin.readline().rstrip()\n var_3 = lambda: list(map(int, var_8().split()))\n var_1 = lambda: int(var_8())\n var_4 = 10**9 + 7\n var_2 = 10**9 + 10\n var_9, var_10 = var_8().split()\n var_5 = int(var_9)\n var_10 = var_10.split(\".\")\n var_6 = int(var_10[0]) * 100\n if len(var_10) == 2:\n var_6 += int(var_10[1])\n print(var_5 * var_6 // 100)\n\n\nfunc_1()\n```\n\n=== Code B (Modified) ===\n```python\nimport decimal\n\nvar_1, var_2 = (decimal.Decimal(var_3) for var_3 in input().split())\nprint((int(var_1 * var_2)))\n```", "output": "FASTER 2.0989", "pair_id": "python_p02659_forward", "problem_id": "p02659", "language": "python", "direction": "forward", "speedup_ratio": 4.2837} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nfrom sys import stdin\n\nvar_6 = lambda: list(map(int, stdin.readline().split()))\nvar_5 = lambda: list(map(int, stdin.readline().split()))\nvar_1, var_3 = var_6()\nvar_2 = 0\nfor var_4 in range(var_1, var_3 + 1):\n var_7 = str(var_4)\n if var_7 == var_7[::-1]:\n var_2 += 1\nprint(var_2)\n```\n\n=== Code B (Modified) ===\n```python\nvar_4, var_3 = list(map(int, input().split()))\nvar_1 = 0\nfor var_2 in range(var_4, var_3 + 1):\n if str(var_2)[0] + str(var_2)[1] == str(var_2)[-1] + str(var_2)[-2]:\n var_1 += 1\nprint(var_1)\n```", "output": "SLOWER 1.3227", "pair_id": "python_p03416_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 2.5013} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\n\nvar_10 = sys.stdin.readline\nvar_2, var_3 = list(map(int, var_10().split()))\nvar_1 = [list(map(int, var_10().split())) for _ in range(var_2)]\nvar_8 = [[0 for _ in range(var_2 + 1)] for _ in range(var_3 + 1)]\n\nvar_13 = [[0 for _ in range(var_2 + 1)] for _ in range(var_3 + 1)]\nfor var_11 in range(var_2):\n var_4, var_6 = var_1[var_11]\n for var_15 in range(var_3):\n if var_4 > var_15:\n var_8[var_15][var_11 + 1] = var_8[var_15][var_11]\n var_13[var_15][var_11 + 1] = var_15\n else:\n if var_6 + var_8[var_15 - var_4][var_11] >= var_8[var_15][var_11]:\n var_8[var_15][var_11 + 1] = var_8[var_15 - var_4][var_11] + var_6\n var_13[var_15][var_11 + 1] = var_15 - var_4\n else:\n var_8[var_15][var_11 + 1] = var_8[var_15][var_11]\n var_13[var_15][var_11 + 1] = var_15\nvar_5 = var_8[var_3 - 1][var_2]\nvar_14 = [False] * var_2\nvar_7 = var_3 - 1\nfor var_9 in reversed(list(range(var_2))):\n if var_13[var_7][var_9 + 1] == var_7 - var_1[var_9][0]:\n var_14[var_9] = True\n var_7 = var_13[var_7][var_9 + 1]\nvar_12 = 0\nfor var_9 in range(var_2):\n if not var_14[var_9] and var_1[var_9][1] > var_12:\n var_12 = var_1[var_9][1]\nprint((var_5 + var_12))\n```\n\n=== Code B (Modified) ===\n```python\ndef func_1():\n var_2, var_3, *var_1 = list(map(int, open(0).read().split()))\n var_4 = [0] * (var_3 + max(var_1[::2]))\n for var_7, var_6 in sorted(zip(*[iter(var_1)] * 2)):\n for var_5 in reversed(list(range(var_3))):\n var_4[var_5 + var_7] = max(var_4[var_5 + var_7], var_4[var_5] + var_6)\n print((max(var_4)))\n\n\nfunc_1()\n```", "output": "FASTER 1.7835", "pair_id": "python_p02863_forward", "problem_id": "p02863", "language": "python", "direction": "forward", "speedup_ratio": 3.4426} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nfrom decimal import Decimal\nimport math\n\nvar_1, var_2 = list(map(str, input().split()))\nvar_1 = int(var_1)\nvar_2 = Decimal(var_2)\nvar_3 = math.floor(var_1 * var_2)\nprint((int(var_3)))\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\nimport math\nfrom collections import defaultdict\nfrom bisect import bisect_left, bisect_right\n\nsys.setrecursionlimit(10**7)\n\n\ndef func_4():\n return sys.stdin.readline()[:-1]\n\n\nvar_4 = 10**9 + 7\n\n\ndef func_1():\n return int(eval(func_4()))\n\n\ndef func_2():\n return list(map(int, func_4().split()))\n\n\ndef func_3(var_6, var_3):\n if var_6 <= 0:\n return [[] for _ in range(var_3)]\n elif var_3 == 1:\n return [func_1() for _ in range(var_6)]\n else:\n var_5 = [func_2() for _ in range(var_6)]\n return list(map(list, list(zip(*var_5))))\n\n\nvar_1, var_2 = list(map(str, func_4().split()))\nvar_1 = int(var_1)\nvar_2 = 100 * int(var_2[0]) + 10 * int(var_2[2]) + int(var_2[3])\nprint((var_1 * var_2 // 100))\n```", "output": "SLOWER 1.9772", "pair_id": "python_p02659_reversed", "problem_id": "p02659", "language": "python", "direction": "reversed", "speedup_ratio": 3.9373} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_6, var_7 = list(map(int, input().split()))\nvar_1 = [list(map(int, input().split())) for _ in range(var_6)]\nvar_1.sort()\nvar_3 = [(6007) * [0] for _ in range(var_6 + 1)]\nvar_3[0][0] = 0\nvar_2 = 0\nfor var_4 in range(var_6):\n for var_5 in range(6007):\n var_3[var_4 + 1][var_5] = max(var_3[var_4 + 1][var_5], var_3[var_4][var_5])\n if var_5 < var_7:\n var_3[var_4 + 1][var_5 + var_1[var_4][0]] = max(\n var_3[var_4][var_5] + var_1[var_4][1],\n var_3[var_4][var_5 + var_1[var_4][0]],\n )\n var_2 = max(var_2, var_3[var_4 + 1][var_5])\nprint(var_2)\n```\n\n=== Code B (Modified) ===\n```python\nfrom sys import stdin\n\n\ndef func_1():\n\n var_9 = stdin.readline\n var_8, var_10 = list(map(int, var_9().split()))\n var_7 = [list(map(int, var_9().split())) for _ in range(var_8)]\n var_7.sort()\n var_1 = [0] * var_8\n var_2 = [0] * var_8\n for var_4 in range(var_8):\n var_1[var_4], var_2[var_4] = var_7[var_4][0], var_7[var_4][1]\n\n var_5 = -float(\"inf\")\n var_3 = [[var_5] * (var_10 + 1) for _ in range(var_8 + 1)]\n var_3[0][0] = 0\n for var_4 in range(var_8):\n for var_6 in range(var_10 + 1):\n\n if var_6 != var_10:\n var_3[var_4 + 1][min(var_10, var_6 + var_1[var_4])] = max(\n var_3[var_4 + 1][min(var_10, var_6 + var_1[var_4])],\n var_3[var_4][var_6] + var_2[var_4],\n )\n\n var_3[var_4 + 1][var_6] = max(var_3[var_4 + 1][var_6], var_3[var_4][var_6])\n print((max(var_3[var_8])))\n\n\nif __name__ == \"__main__\":\n func_1()\n```", "output": "FASTER 5.7996", "pair_id": "python_p02863_forward", "problem_id": "p02863", "language": "python", "direction": "forward", "speedup_ratio": 55.7009} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_4 = {}\nvar_5 = 0\nfor var_6 in range(10000, 100000):\n var_3 = list(str(var_6))\n if var_3 == list(reversed(var_3)):\n var_5 += 1\n var_4[var_6] = var_5\nvar_1, var_2 = list(map(int, input().split()))\nprint((var_4[var_2] - var_4[var_1 - 1] if var_1 > 10000 else var_4[var_2]))\n```\n\n=== Code B (Modified) ===\n```python\nvar_1 = list(map(int, input().split()))\nvar_2 = 0\nfor var_3 in range(var_1[0], var_1[1] + 1):\n var_4 = str(var_3)\n if var_4[0] == var_4[4] and var_4[1] == var_4[3]:\n var_2 += 1\nprint(var_2)\n```", "output": "FASTER 3.8624", "pair_id": "python_p03416_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 14.5446} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\ndef func_1():\n var_1, var_2 = list(map(int, input().rstrip().split()))\n var_3 = 0\n for var_4 in range(var_1, var_2 + 1):\n var_5 = str(var_4)\n if var_5 == var_5[::-1]:\n var_3 += 1\n print(var_3)\n\n\nif __name__ == \"__main__\":\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n if str(var_4) == \"\".join(reversed(str(var_4))):\n var_3 += 1\nprint(var_3)\n```", "output": "SLOWER 1.8222", "pair_id": "python_p03416_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 3.5363} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\ndef func_1():\n var_1, var_2 = list(map(int, input().rstrip().split()))\n var_3 = 0\n for var_4 in range(var_1, var_2 + 1):\n var_5 = str(var_4)\n if var_5 == var_5[::-1]:\n var_3 += 1\n print(var_3)\n\n\nif __name__ == \"__main__\":\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = list(reversed(list(str(var_4))))\n if var_5 == list(str(var_4)):\n var_3 += 1\nprint(var_3)\n```", "output": "SLOWER 2.4029", "pair_id": "python_p03416_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 5.2888} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_4 = {}\nvar_5 = 0\nfor var_6 in range(10000, 100000):\n var_3 = list(str(var_6))\n if var_3 == list(reversed(var_3)):\n var_5 += 1\n var_4[var_6] = var_5\nvar_1, var_2 = list(map(int, input().split()))\nprint((var_4[var_2] - var_4[var_1 - 1] if var_1 > 10000 else var_4[var_2]))\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_7 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_3 = True\n var_8 = str(var_4)\n var_6 = len(var_8)\n for var_5 in range(var_6 // 2 + 1):\n if var_8[var_5] != var_8[-var_5 - 1]:\n var_3 = False\n break\n if var_3:\n var_7 += 1\nprint(var_7)\n```", "output": "FASTER 2.4485", "pair_id": "python_p03416_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 5.4585} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\ndef func_1():\n var_1, var_2 = list(map(int, input().rstrip().split()))\n var_3 = 0\n for var_4 in range(var_1, var_2 + 1):\n var_5 = str(var_4)\n if var_5 == var_5[::-1]:\n var_3 += 1\n print(var_3)\n\n\nif __name__ == \"__main__\":\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().rstrip().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = list(map(int, list(str(var_4))))\n if var_5[0] == var_5[4] and var_5[1] == var_5[3]:\n var_3 += 1\nprint(var_3)\n```", "output": "SLOWER 2.429", "pair_id": "python_p03416_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 5.3852} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport bisect\nimport sys\n\n\ndef func_1():\n var_9 = sys.stdin.readline\n var_10, var_4, var_1 = list(map(int, var_9().split()))\n var_5 = [None] * var_10\n for var_7 in range(var_10):\n var_12, var_6 = list(map(int, var_9().split()))\n var_5[var_7] = (var_12, var_6)\n var_5.sort()\n var_12 = [int(var_5[var_7][0]) for var_7 in range(var_10)]\n var_6 = [int(var_5[var_7][1]) for var_7 in range(var_10)]\n var_2 = 0\n var_3 = [0] * var_10\n for var_7 in range(var_10):\n if var_7 != 0:\n var_3[var_7] += var_3[var_7 - 1]\n var_11 = max([(var_6[var_7] - var_3[var_7] - 1) // var_1 + 1, 0])\n var_2 += var_11\n var_3[var_7] += var_11 * var_1\n var_8 = bisect.bisect_right(var_12, var_12[var_7] + 2 * var_4)\n if var_8 != var_10:\n var_3[var_8] -= var_11 * var_1\n print(var_2)\n\n\nif __name__ == \"__main__\":\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\n\nsys.setrecursionlimit(500000)\n\n\ndef func_3():\n return sys.stdin.readline()[:-1]\n\n\nclass Class_1:\n def __init__(self, var_3):\n self.N = len(var_3)\n self.bit = [0] * self.N\n for var_11, var_14 in enumerate(var_3):\n self.add(var_11, var_14)\n\n def func_1(self, var_5, var_18):\n var_19 = var_5 + 1\n for var_11 in range(1000):\n self.bit[var_19 - 1] += var_18\n var_19 += var_19 & -var_19\n if var_19 > self.N:\n break\n\n def func_5(self, var_5):\n var_19 = var_5 + 1\n var_16 = 0\n for var_11 in range(1000):\n var_16 += self.bit[var_19 - 1]\n var_19 -= var_19 & -var_19\n if var_19 <= 0:\n break\n return var_16\n\n\ndef func_4():\n var_4, var_2, var_1 = list(map(int, func_3().split()))\n var_9 = []\n for var_11 in range(var_4):\n var_19, var_10 = list(map(int, func_3().split()))\n if var_10 % var_1 == 0:\n var_9.append([var_19, var_10 // var_1])\n else:\n var_9.append([var_19, var_10 // var_1 + 1])\n var_9.sort(key=lambda var_19: var_19[0])\n\n def func_2(var_12):\n var_19 = var_9[var_12][0]\n if var_9[var_4 - 1][0] <= var_19 + 2 * var_2:\n return var_4 - 1\n var_14 = var_12\n var_15 = var_4 - 1\n while var_15 - var_14 > 1:\n if var_9[(var_15 + var_14) // 2][0] <= var_19 + 2 * var_2:\n var_14 = (var_15 + var_14) // 2\n else:\n var_15 = (var_15 + var_14) // 2\n return var_14\n\n var_6 = Class_1([0] * var_4)\n var_7 = 0\n for var_11 in range(var_4):\n if var_11 > 0:\n var_17 = var_6.sum(var_4 - 1) - var_6.sum(var_11 - 1)\n else:\n var_17 = 0\n if var_9[var_11][1] - var_17 > 0:\n var_7 += var_9[var_11][1] - var_17\n var_13 = func_2(var_11)\n var_6.add(var_13, var_9[var_11][1] - var_17)\n var_9 = var_9[::-1]\n for var_11 in range(var_4):\n var_9[var_11][0] = -var_9[var_11][0]\n var_6 = Class_1([0] * var_4)\n var_8 = 0\n for var_11 in range(var_4):\n if var_11 > 0:\n var_17 = var_6.sum(var_4 - 1) - var_6.sum(var_11 - 1)\n else:\n var_17 = 0\n if var_9[var_11][1] - var_17 > 0:\n var_8 += var_9[var_11][1] - var_17\n var_13 = func_2(var_11)\n var_6.add(var_13, var_9[var_11][1] - var_17)\n print((min(var_7, var_8)))\n\n\nif __name__ == \"__main__\":\n func_4()\n```", "output": "SLOWER 1.2733", "pair_id": "python_p02788_reversed", "problem_id": "p02788", "language": "python", "direction": "reversed", "speedup_ratio": 2.4172} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport itertools\n\nvar_6 = int(eval(input()))\nvar_2 = [[]] * var_6\nfor var_4 in range(var_6):\n var_3 = list(map(int, input().split()))\n\n var_2[var_4] = var_3\nvar_8 = [[]] * var_6\nfor var_4 in range(var_6):\n var_9 = list(map(int, input().split()))\n var_8[var_4] = var_9\nvar_10 = -(10**11)\nfor var_1 in itertools.product([0, 1], repeat=10):\n if sum(var_1) == 0:\n continue\n var_11 = 0\n for var_7 in range(var_6):\n var_5 = 0\n for var_4 in range(10):\n if var_2[var_7][var_4] == 1 and var_1[var_4] == 1:\n var_5 += 1\n var_11 = var_11 + var_8[var_7][var_5]\n var_10 = max(var_10, var_11)\nprint(var_10)\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\n\nvar_8 = sys.stdin.readline\n\n\ndef func_1():\n var_2 = int(eval(var_8()))\n var_1 = [int(var_8().replace(\" \", \"\"), 2) for _ in range(var_2)]\n var_3 = [list(map(int, var_8().split())) for _ in range(var_2)]\n var_4 = -(10**7) * var_2\n for var_7 in range(1, 1 << 10):\n var_10 = 0\n for var_9, var_6 in enumerate(var_1):\n var_5 = bin(var_7 & var_6).count(\"1\")\n var_10 += var_3[var_9][var_5]\n var_4 = max(var_4, var_10)\n print(var_4)\n\n\nif __name__ == \"__main__\":\n func_1()\n```", "output": "FASTER 2.7112", "pair_id": "python_p03503_forward", "problem_id": "p03503", "language": "python", "direction": "forward", "speedup_ratio": 6.5485} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_3 = list(map(int, input().split()))\nvar_2 = 0\nfor var_5 in range(var_3 + 1)[var_1:]:\n if len(str(var_5)) % 2 == 0:\n var_6 = list(str(var_5))[: len(str(var_5)) // 2]\n var_7 = list(reversed(list(str(var_5))[len(str(var_5)) // 2 :]))\n if var_6 == var_7:\n var_2 += 1\n else:\n var_8 = list(str(var_5))[: len(str(var_5)) // 2 + 1]\n var_4 = list(reversed(list(str(var_5))[len(str(var_5)) // 2 :]))\n if var_8 == var_4:\n var_2 += 1\nprint(var_2)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = str(var_4)\n if var_5[0] == var_5[4] and var_5[1] == var_5[3]:\n var_3 += 1\nprint(var_3)\n```", "output": "FASTER 2.7407", "pair_id": "python_p03416_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 6.6839} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\n\nvar_7 = sys.stdin.readline\nfrom itertools import combinations\n\n\ndef func_3(var_10):\n for _ in range(var_10):\n yield list(map(int, var_7().split()))\n\n\ndef func_1(var_9, var_5, var_11):\n var_3 = sum(1 if var_5[var_8] == 1 else 0 for var_8 in var_9)\n return var_11[var_3]\n\n\ndef func_2():\n var_10 = int(eval(var_7()))\n var_1 = list(func_3(var_10))\n var_2 = list(func_3(var_10))\n for var_6 in range(1, 11):\n for var_4 in combinations(list(range(10)), var_6):\n yield sum(\n func_1(var_4, var_5, var_11) for var_5, var_11 in zip(var_1, var_2)\n )\n\n\nprint((max(func_2())))\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\n\nvar_8 = sys.stdin.readline\n\n\ndef func_1():\n var_2 = int(eval(var_8()))\n var_1 = [int(var_8().replace(\" \", \"\"), 2) for _ in range(var_2)]\n var_3 = [list(map(int, var_8().split())) for _ in range(var_2)]\n var_4 = -(10**7) * var_2\n for var_7 in range(1, 1 << 10):\n var_10 = 0\n for var_9, var_6 in enumerate(var_1):\n var_5 = bin(var_7 & var_6).count(\"1\")\n var_10 += var_3[var_9][var_5]\n var_4 = max(var_4, var_10)\n print(var_4)\n\n\nif __name__ == \"__main__\":\n func_1()\n```", "output": "FASTER 1.6626", "pair_id": "python_p03503_forward", "problem_id": "p03503", "language": "python", "direction": "forward", "speedup_ratio": 3.1659} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\ndef func_1():\n var_1, var_2 = list(map(int, input().split()))\n var_3 = 0\n for var_4 in range(var_1, var_2 + 1):\n\n if (var_4 % 10) == (var_4 // 10000 % 10) and (var_4 // 10 % 10) == (\n var_4 // 1000 % 10\n ):\n var_3 += 1\n print(var_3)\n\n\nif __name__ == \"__main__\":\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_3 = list(map(int, input().split()))\nvar_2 = 0\nfor var_5 in range(var_3 + 1)[var_1:]:\n if len(str(var_5)) % 2 == 0:\n var_6 = list(str(var_5))[: len(str(var_5)) // 2]\n var_7 = list(reversed(list(str(var_5))[len(str(var_5)) // 2 :]))\n if var_6 == var_7:\n var_2 += 1\n else:\n var_8 = list(str(var_5))[: len(str(var_5)) // 2 + 1]\n var_4 = list(reversed(list(str(var_5))[len(str(var_5)) // 2 :]))\n if var_8 == var_4:\n var_2 += 1\nprint(var_2)\n```", "output": "SLOWER 4.1386", "pair_id": "python_p03416_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 17.6132} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\n\nvar_3 = sys.stdin.readline\nif __name__ == \"__main__\":\n var_1, var_2 = var_3().split()\n print((int(var_1) * round(float(var_2) * 100) // 100))\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\nimport math\nfrom collections import defaultdict\nfrom bisect import bisect_left, bisect_right\n\nsys.setrecursionlimit(10**7)\n\n\ndef func_4():\n return sys.stdin.readline()[:-1]\n\n\nvar_4 = 10**9 + 7\n\n\ndef func_1():\n return int(eval(func_4()))\n\n\ndef func_2():\n return list(map(int, func_4().split()))\n\n\ndef func_3(var_6, var_3):\n if var_6 <= 0:\n return [[] for _ in range(var_3)]\n elif var_3 == 1:\n return [func_1() for _ in range(var_6)]\n else:\n var_5 = [func_2() for _ in range(var_6)]\n return list(map(list, list(zip(*var_5))))\n\n\nvar_1, var_2 = list(map(str, func_4().split()))\nvar_1 = int(var_1)\nvar_2 = 100 * int(var_2[0]) + 10 * int(var_2[2]) + int(var_2[3])\nprint((var_1 * var_2 // 100))\n```", "output": "SLOWER 2.2625", "pair_id": "python_p02659_reversed", "problem_id": "p02659", "language": "python", "direction": "reversed", "speedup_ratio": 4.7983} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport numpy as np\nfrom itertools import product\n\nvar_6 = int(eval(input()))\nvar_2 = list(map(int, input().split()))\nvar_2 = np.array(var_2)\nvar_5 = [-1, 0, 1]\nvar_3 = 0\nfor var_7 in product(var_5, repeat=var_6):\n var_7 = np.array(var_7)\n var_1 = var_2 + var_7\n var_4 = var_1.cumprod()\n if var_4[-1] % 2 == 0:\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_4 = int(eval(input()))\nvar_1 = list(map(int, input().split()))\nvar_3 = 1\nfor var_2 in var_1:\n var_3 *= 2 if var_2 % 2 == 0 else 1\nprint((3**var_4 - var_3))\n```", "output": "FASTER 10.1485", "pair_id": "python_p03568_forward", "problem_id": "p03568", "language": "python", "direction": "forward", "speedup_ratio": 1134.9796} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_2 = int(eval(input()))\n(*var_1,) = list(map(int, input().split()))\nvar_5 = 0\nfor var_3 in var_1:\n if var_3 % 2 == 0:\n var_5 += 1\nvar_4 = 3**var_2 - 2**var_5\nprint(var_4)\n```\n\n=== Code B (Modified) ===\n```python\ndef func_1():\n var_2 = int(input())\n var_1 = [int(var_6) for var_6 in input().split()]\n if var_2 == 1:\n return print(1 if var_1[0] % 2 == 0 else 2)\n var_3 = 0\n var_5 = (-1, 0, 1)\n from itertools import product\n\n for var_6 in product(range(3), repeat=var_2):\n var_4 = 1\n for var_7 in range(var_2):\n var_4 *= var_1[var_7] + var_5[var_6[var_7]]\n if var_4 % 2 == 0:\n var_3 += 1\n print(var_3)\n\n\nif __name__ == \"__main__\":\n func_1()\n```", "output": "SLOWER 8.5619", "pair_id": "python_p03568_reversed", "problem_id": "p03568", "language": "python", "direction": "reversed", "speedup_ratio": 377.9172} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nfrom math import sqrt\n\nvar_2 = int(eval(input()))\n\n\ndef func_1(var_2):\n if var_2 < 2:\n return False\n for var_1 in range(2, int(sqrt(var_2)) + 1):\n if var_2 % var_1 == 0:\n return False\n return True\n\n\nwhile not func_1(var_2):\n var_2 += 1\nprint(var_2)\n```\n\n=== Code B (Modified) ===\n```python\nimport bisect, copy, heapq, math, sys\nfrom collections import *\nfrom functools import lru_cache\nfrom itertools import accumulate, combinations, permutations, product\n\n\ndef func_2():\n return sys.stdin.readline()[:-1]\n\n\ndef func_4(var_8):\n return [0] + list(accumulate(var_8))\n\n\ndef func_1(var_1, var_4):\n return -(-var_1 // var_4)\n\n\nsys.setrecursionlimit(5000000)\nvar_9 = pow(10, 9) + 7\nvar_2 = [chr(ord(\"a\") + var_6) for var_6 in range(26)]\nvar_5 = [[1, 0], [0, 1], [-1, 0], [0, -1]]\nvar_11 = int(eval(func_2()))\n\n\ndef func_3(var_10):\n if var_10 == 1:\n return False\n for var_7 in range(2, int(math.sqrt(var_10)) + 1):\n if var_10 % var_7 == 0:\n return False\n return True\n\n\nvar_3 = var_11\nwhile not func_3(var_3):\n var_3 += 1\nprint(var_3)\n```", "output": "SLOWER 1.442", "pair_id": "python_p02819_reversed", "problem_id": "p02819", "language": "python", "direction": "reversed", "speedup_ratio": 2.717} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = input().split()\nvar_1 = int(var_1)\nvar_2 = int(\"\".join(var_2.split(\".\")))\nprint(((var_1 * var_2) // 100))\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\nimport math\nfrom collections import defaultdict\nfrom bisect import bisect_left, bisect_right\n\nsys.setrecursionlimit(10**7)\n\n\ndef func_4():\n return sys.stdin.readline()[:-1]\n\n\nvar_4 = 10**9 + 7\n\n\ndef func_1():\n return int(eval(func_4()))\n\n\ndef func_2():\n return list(map(int, func_4().split()))\n\n\ndef func_3(var_6, var_3):\n if var_6 <= 0:\n return [[] for _ in range(var_3)]\n elif var_3 == 1:\n return [func_1() for _ in range(var_6)]\n else:\n var_5 = [func_2() for _ in range(var_6)]\n return list(map(list, list(zip(*var_5))))\n\n\nfrom decimal import getcontext, Decimal\n\ngetcontext().prec = 28\nvar_1, var_2 = list(map(str, func_4().split()))\nvar_1 = int(var_1)\nvar_2 = Decimal(var_2)\nprint((int(var_1 * var_2)))\n```", "output": "SLOWER 2.485", "pair_id": "python_p02659_reversed", "problem_id": "p02659", "language": "python", "direction": "reversed", "speedup_ratio": 5.5983} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport bisect\nimport sys\n\nsys.setrecursionlimit(10**6)\nvar_17 = sys.stdout.write\nvar_7 = lambda *var_15: print(*var_15) if var_1 else 0\nvar_1 = True\n\n\ndef func_1(var_10=sys.stdin.readline):\n var_12 = lambda: var_10().rstrip()\n var_3 = lambda: list(map(int, var_12().split()))\n var_2 = lambda: int(var_12())\n var_4 = lambda var_18: [var_3() for _ in range(var_18)]\n var_14, var_16 = var_3()\n var_5 = var_4(var_14)\n var_8 = [[0] * var_16 for _ in range(var_14)]\n for var_11 in range(1, var_14):\n for var_13 in range(1, var_16):\n if var_13 < var_5[var_11 - 1][0]:\n var_8[var_11][var_13] = var_8[var_11 - 1][var_13]\n else:\n var_8[var_11][var_13] = max(\n var_8[var_11 - 1][var_13],\n var_8[var_11 - 1][var_13 - var_5[var_11 - 1][0]]\n + var_5[var_11 - 1][1],\n )\n var_9 = [[0] * var_16 for _ in range(var_14)]\n for var_11 in range(1, var_14):\n for var_13 in range(1, var_16):\n if var_13 < var_5[var_14 - var_11][0]:\n var_9[var_11][var_13] = var_9[var_11 - 1][var_13]\n else:\n var_9[var_11][var_13] = max(\n var_9[var_11 - 1][var_13],\n var_9[var_11 - 1][var_13 - var_5[var_14 - var_11][0]]\n + var_5[var_14 - var_11][1],\n )\n var_6 = 0\n for var_11 in range(var_14):\n for var_13 in range(var_16 - 1):\n var_6 = max(\n var_6,\n var_8[var_11][var_13]\n + var_9[var_14 - var_11 - 1][var_16 - var_13 - 1]\n + var_5[var_11][1],\n )\n print(var_6)\n\n\nif __name__ == \"__main__\":\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nvar_6, var_7 = list(map(int, input().split()))\nvar_1 = [list(map(int, input().split())) for _ in range(var_6)]\nvar_1.sort()\nvar_3 = [(6007) * [0] for _ in range(var_6 + 1)]\nvar_3[0][0] = 0\nvar_2 = 0\nfor var_4 in range(var_6):\n for var_5 in range(6007):\n var_3[var_4 + 1][var_5] = max(var_3[var_4 + 1][var_5], var_3[var_4][var_5])\n if var_5 < var_7:\n var_3[var_4 + 1][var_5 + var_1[var_4][0]] = max(\n var_3[var_4][var_5] + var_1[var_4][1],\n var_3[var_4][var_5 + var_1[var_4][0]],\n )\n var_2 = max(var_2, var_3[var_4 + 1][var_5])\nprint(var_2)\n```", "output": "SLOWER 5.3172", "pair_id": "python_p02863_reversed", "problem_id": "p02863", "language": "python", "direction": "reversed", "speedup_ratio": 39.8704} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport math\n\nvar_1, var_2 = input().split()\nvar_1 = int(var_1)\nvar_3 = int(var_2[0] + var_2[2] + var_2[3])\nprint((int(var_1 * var_3) // 100))\n```\n\n=== Code B (Modified) ===\n```python\ndef func_1():\n from sys import setrecursionlimit, stdin\n from os import environ\n from collections import defaultdict, deque, Counter\n from math import ceil, floor, gcd\n from itertools import accumulate, combinations, combinations_with_replacement\n\n setrecursionlimit(10**6)\n var_7 = (\n (lambda *var_11: print(*var_11))\n if \"TERM_PROGRAM\" in environ\n else lambda *var_12: 0\n )\n var_8 = lambda: stdin.readline().rstrip()\n var_3 = lambda: list(map(int, var_8().split()))\n var_1 = lambda: int(var_8())\n var_4 = 10**9 + 7\n var_2 = 10**9 + 10\n var_9, var_10 = var_8().split()\n var_5 = int(var_9)\n var_6 = int(float(var_10) * 100 + 0.5)\n print(var_5 * var_6 // 100)\n\n\nfunc_1()\n```", "output": "SLOWER 1.9827", "pair_id": "python_p02659_reversed", "problem_id": "p02659", "language": "python", "direction": "reversed", "speedup_ratio": 3.9522} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\n\nvar_2, var_1, *var_3 = sys.stdin.read().strip().split()\nvar_2 = int(var_2)\nvar_5 = [0] * var_2\nvar_10 = [0] * var_2\nfor var_6, var_8 in zip(*[iter(var_3)] * 2):\n var_6 = int(var_6) - 1\n if var_8 == \"AC\":\n var_5[var_6] = 1\n elif var_5[var_6] == 0:\n var_10[var_6] += 1\nvar_7 = sum([var_9 * var_4 for var_4, var_9 in zip(var_5, var_10)])\nprint((\"{} {}\".format(sum(var_5), var_7)))\n```\n\n=== Code B (Modified) ===\n```python\nvar_2, var_1 = list(map(int, input().split()))\nvar_6 = {}\nvar_3 = {}\nfor var_4 in range(var_1):\n var_5, var_7 = input().split()\n var_5 = int(var_5)\n if not var_5 in var_6:\n var_6[var_5] = 0\n var_3[var_5] = 0\n if var_7 == \"WA\" and var_3[var_5] == 0:\n var_6[var_5] += 1\n elif var_7 == \"AC\" and var_3[var_5] == 0:\n var_3[var_5] += 1\nfor var_4 in var_6:\n if var_6[var_4] != 0 and var_3[var_4] == 0:\n var_6[var_4] = 0\nprint((sum(var_3.values()), sum(var_6.values())))\n```", "output": "FASTER 2.6258", "pair_id": "python_p02802_forward", "problem_id": "p02802", "language": "python", "direction": "forward", "speedup_ratio": 6.1723} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nfrom itertools import product\n\nvar_6 = int(eval(input()))\nvar_1 = list(map(int, input().split()))\nvar_5 = 0\nfor var_2 in product((-1, 0, 1), repeat=var_6):\n var_7 = 1\n for var_3, var_4 in zip(var_1, var_2):\n var_7 *= var_3 + var_4\n if var_7 % 2 == 0:\n var_5 += 1\nprint(var_5)\n```\n\n=== Code B (Modified) ===\n```python\nimport math\nimport string\n\n\ndef func_4():\n return list(map(int, input().split()))\n\n\ndef func_3(var_6, var_7):\n return math.factorial(var_6) // (\n math.factorial(var_6 - var_7) * math.factorial(var_7)\n )\n\n\ndef func_2(var_9):\n var_8 = []\n for var_5 in var_9:\n if not (var_5 in var_8):\n var_8.append(var_5)\n return len(var_9) != len(var_8)\n\n\ndef func_1(var_6):\n func_1 = []\n for var_4 in range(1, var_6 + 1):\n if var_6 % var_4 == 0:\n func_1.append(var_4)\n return func_1\n\n\nvar_2 = [-1, -1, -1, 0, 0, 1, 1, 1]\nvar_3 = [-1, 0, 1, -1, 1, -1, 0, 1]\nvar_6 = int(eval(input()))\nvar_1 = func_4()\nvar_10 = 1\nfor var_4 in range(len(var_1)):\n if var_1[var_4] % 2 == 0:\n var_10 *= 2\n else:\n var_10 *= 1\nprint((3 ** len(var_1) - var_10))\n```", "output": "FASTER 8.339", "pair_id": "python_p03568_forward", "problem_id": "p03568", "language": "python", "direction": "forward", "speedup_ratio": 323.8095} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_4, var_3 = list(map(int, input().split()))\nvar_1 = 0\nfor var_2 in range(var_4, var_3 + 1):\n if str(var_2)[0] + str(var_2)[1] == str(var_2)[-1] + str(var_2)[-2]:\n var_1 += 1\nprint(var_1)\n```\n\n=== Code B (Modified) ===\n```python\ndef func_1():\n var_1, var_2 = list(map(int, input().split()))\n var_3 = 0\n for var_4 in range(var_1, var_2 + 1):\n\n if (var_4 % 10) == (var_4 // 10000 % 10) and (var_4 // 10 % 10) == (\n var_4 // 1000 % 10\n ):\n var_3 += 1\n print(var_3)\n\n\nif __name__ == \"__main__\":\n func_1()\n```", "output": "FASTER 3.0051", "pair_id": "python_p03416_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 8.0286} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1 = [int(eval(input())) for _ in range(int(eval(input())))]\nprint((sum(var_1) - max(var_1) // 2))\n```\n\n=== Code B (Modified) ===\n```python\nimport copy\nimport random\nimport bisect\nimport fractions\nimport math\nimport sys\nimport collections\nfrom decimal import Decimal\n\nvar_5 = 10**9 + 7\nsys.setrecursionlimit(var_5)\nvar_3 = collections.deque()\n\n\ndef func_1():\n return list(map(int, sys.stdin.readline().split()))\n\n\nvar_1 = int(eval(input()))\nvar_6 = [0 for var_4 in range(var_1)]\nfor var_4 in range(var_1):\n var_6[var_4] = int(eval(input()))\nvar_6.sort()\nvar_2 = sum(var_6)\nvar_2 -= var_6[-1] // 2\nprint(var_2)\n```", "output": "SLOWER 1.0725", "pair_id": "python_p03207_reversed", "problem_id": "p03207", "language": "python", "direction": "reversed", "speedup_ratio": 2.1031} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_8, var_9 = list(map(int, input().split()))\nvar_5 = [[0] * (var_9 + 3001) for _ in range(var_8 + 1)]\nvar_3 = 0\nvar_2 = [list(map(int, input().split())) for _ in range(var_8)]\nvar_2.sort()\nfor var_6 in range(1, var_8 + 1):\n var_1, var_4 = var_2[var_6 - 1]\n for var_7 in range(var_9):\n var_5[var_6][var_7] = max(var_5[var_6 - 1][var_7], var_5[var_6][var_7])\n var_5[var_6][var_7 + var_1] = var_5[var_6 - 1][var_7] + var_4\n var_3 = max(var_5[var_6][var_7], var_5[var_6][var_7 + var_1], var_3)\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_2, var_3, *var_1 = list(map(int, open(0).read().split()))\nvar_4 = [0] * (var_3 + max(var_1[::2]))\nfor var_7, var_6 in sorted(zip(*[iter(var_1)] * 2)):\n for var_5 in reversed(list(range(var_3))):\n var_4[var_5 + var_7] = max(var_4[var_5 + var_7], var_4[var_5] + var_6)\nprint((max(var_4)))\n```", "output": "FASTER 1.0971", "pair_id": "python_p02863_forward", "problem_id": "p02863", "language": "python", "direction": "forward", "speedup_ratio": 2.1392} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n if list(str(var_4)) == list(reversed(str(var_4))):\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_4 = str(var_4)\n if var_4 == var_4[::-1]:\n var_3 += 1\nprint(var_3)\n```", "output": "FASTER 1.2534", "pair_id": "python_p03416_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 2.384} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\ndef func_1():\n from sys import setrecursionlimit, stdin\n from os import environ\n from collections import defaultdict, deque, Counter\n from math import ceil, floor, gcd\n from itertools import accumulate, combinations, combinations_with_replacement\n\n setrecursionlimit(10**6)\n var_7 = (\n (lambda *var_11: print(*var_11))\n if \"TERM_PROGRAM\" in environ\n else lambda *var_12: 0\n )\n var_8 = lambda: stdin.readline().rstrip()\n var_3 = lambda: list(map(int, var_8().split()))\n var_1 = lambda: int(var_8())\n var_4 = 10**9 + 7\n var_2 = 10**9 + 10\n var_9, var_10 = var_8().split()\n var_5 = int(var_9)\n var_10 = var_10.split(\".\")\n var_6 = int(var_10[0]) * 100\n if len(var_10) == 2:\n var_6 += int(var_10[1])\n print(var_5 * var_6 // 100)\n\n\nfunc_1()\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = input().split()\nvar_1 = int(var_1)\nvar_2 = int(var_2.replace(\".\", \"\"))\nprint((var_1 * var_2 // 100))\n```", "output": "FASTER 2.4306", "pair_id": "python_p02659_forward", "problem_id": "p02659", "language": "python", "direction": "forward", "speedup_ratio": 5.3911} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_4 = int(eval(input()))\nvar_1 = 0\nif var_4 == 2:\n print((2))\nelse:\n for var_2 in range(var_4, 10**6):\n for var_3 in range(2, var_2 // 2 + 2):\n if var_2 % var_3 == 0:\n break\n else:\n var_1 = var_2\n break\n print(var_1)\n```\n\n=== Code B (Modified) ===\n```python\nimport numpy as np\nfrom bisect import bisect_left\n\n\ndef func_1():\n var_4 = []\n var_1 = np.ones(10**5 + 10)\n var_1[0] = var_1[1] = 0\n for var_3, var_2 in enumerate(var_1):\n if var_2:\n var_4.append(var_3)\n var_1[2 * var_3 : 10**5 + 10 : var_3] = 0\n return var_4\n\n\ndef func_2(var_6):\n var_7 = int(var_6)\n var_5 = func_1()\n return str(var_5[bisect_left(var_5, var_7)])\n\n\nif __name__ == \"__main__\":\n import sys\n\n print((func_2(sys.stdin.read().strip())))\n```", "output": "SLOWER 7.742", "pair_id": "python_p02819_reversed", "problem_id": "p02819", "language": "python", "direction": "reversed", "speedup_ratio": 214.0828} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport decimal\n\n\ndef func_1():\n var_1, var_2 = list(map(decimal.Decimal, input().split()))\n print((var_1 * var_2 // 1))\n\n\nif __name__ == \"__main__\":\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\nimport math\nfrom collections import defaultdict\nfrom bisect import bisect_left, bisect_right\n\nsys.setrecursionlimit(10**7)\n\n\ndef func_4():\n return sys.stdin.readline()[:-1]\n\n\nvar_4 = 10**9 + 7\n\n\ndef func_1():\n return int(eval(func_4()))\n\n\ndef func_2():\n return list(map(int, func_4().split()))\n\n\ndef func_3(var_6, var_3):\n if var_6 <= 0:\n return [[] for _ in range(var_3)]\n elif var_3 == 1:\n return [func_1() for _ in range(var_6)]\n else:\n var_5 = [func_2() for _ in range(var_6)]\n return list(map(list, list(zip(*var_5))))\n\n\nvar_1, var_2 = list(map(str, func_4().split()))\nvar_1 = int(var_1)\nvar_2 = 100 * int(var_2[0]) + 10 * int(var_2[2]) + int(var_2[3])\nprint((var_1 * var_2 // 100))\n```", "output": "SLOWER 2.0678", "pair_id": "python_p02659_reversed", "problem_id": "p02659", "language": "python", "direction": "reversed", "speedup_ratio": 4.1925} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport numpy as np\n\nvar_7 = input()[::-1]\nvar_6 = len(var_7)\nvar_1 = np.zeros(var_6, dtype=int)\nvar_4 = np.zeros(var_6, dtype=int)\nvar_2 = np.zeros(2019, dtype=int)\nvar_8 = 10\nvar_1[0] = int(var_7[0])\nvar_4[0] = var_1[0]\nvar_2[var_4[0]] += 1\nfor var_5 in range(1, var_6):\n var_1[var_5] = int(var_7[var_5]) * var_8 % 2019\n var_4[var_5] = (var_4[var_5 - 1] + var_1[var_5]) % 2019\n var_2[var_4[var_5]] += 1\n var_8 = var_8 * 10 % 2019\nvar_3 = var_2[np.nonzero(var_2)]\nprint(\n (\n int(\n sum([var_3[var_5] * (var_3[var_5] - 1) for var_5 in range(var_3.shape[0])])\n / 2\n )\n + var_2[0]\n )\n)\n```\n\n=== Code B (Modified) ===\n```python\nvar_6 = input()[::-1]\nvar_4 = len(var_6)\nvar_2 = [0] * 2019\nvar_2[0] = 1\nvar_7 = 1\nvar_5 = 0\nvar_1 = 0\nfor var_3 in range(var_4):\n var_5 = (var_5 + int(var_6[var_3]) * var_7) % 2019\n var_7 = var_7 * 10 % 2019\n var_2[var_5] += 1\nfor var_3 in var_2:\n var_1 += var_3 * (var_3 - 1) // 2\nprint(var_1)\n```", "output": "SLOWER 1.3294", "pair_id": "python_p02702_reversed", "problem_id": "p02702", "language": "python", "direction": "reversed", "speedup_ratio": 2.5129} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_4 = {}\nvar_5 = 0\nfor var_6 in range(10000, 100000):\n var_3 = list(str(var_6))\n if var_3 == list(reversed(var_3)):\n var_5 += 1\n var_4[var_6] = var_5\nvar_1, var_2 = list(map(int, input().split()))\nprint((var_4[var_2] - var_4[var_1 - 1] if var_1 > 10000 else var_4[var_2]))\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = list(reversed(list(str(var_4))))\n if var_5 == list(str(var_4)):\n var_3 += 1\nprint(var_3)\n```", "output": "FASTER 1.9167", "pair_id": "python_p03416_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 3.7755} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_6 = int(eval(input()))\nvar_2 = list(map(int, input().split()))\nfrom itertools import product\n\nvar_5 = [-1, 0, 1]\nvar_3 = 0\nfor var_7 in product(var_5, repeat=var_6):\n var_1 = []\n for var_4 in range(var_6):\n var_1.append(var_7[var_4] + var_2[var_4])\n if any(var_8 % 2 == 0 for var_8 in var_1):\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_4 = int(eval(input()))\nvar_1 = list(map(int, input().split()))\nvar_3 = 1\nfor var_2 in var_1:\n var_3 *= 2 if var_2 % 2 == 0 else 1\nprint((3**var_4 - var_3))\n```", "output": "FASTER 9.9565", "pair_id": "python_p03568_forward", "problem_id": "p03568", "language": "python", "direction": "forward", "speedup_ratio": 993.5967} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = str(var_4)\n if var_5 == var_5[::-1]:\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_7 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_3 = True\n var_8 = str(var_4)\n var_6 = len(var_8)\n for var_5 in range(var_6 // 2 + 1):\n if var_8[var_5] != var_8[-var_5 - 1]:\n var_3 = False\n break\n if var_3:\n var_7 += 1\nprint(var_7)\n```", "output": "SLOWER 1.1295", "pair_id": "python_p03416_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 2.1879} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\ndef func_1():\n return list(map(int, input().split()))\n\n\nimport numpy as np\n\nvar_1, var_2, var_3 = func_1()\nvar_4 = np.array(list(func_1()))\nvar_6 = np.array(list(func_1()))\nvar_9 = min(var_4) + min(var_6)\nvar_5 = float(\"inf\")\nfor var_8 in range(var_3):\n var_11, var_12, var_7 = func_1()\n var_10 = var_4[var_11 - 1] + var_6[var_12 - 1] - var_7\n var_5 = min(var_5, var_10)\nprint((min(var_5, var_9)))\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\nfrom collections import Counter\n\n\ndef func_9():\n return sys.stdin.readline().strip()\n\n\ndef func_10(var_8, var_9, var_10):\n return [[var_10] * var_9 for var_13 in range(var_8)]\n\n\ndef func_11(var_8, var_9, var_10, var_11):\n return [[[var_11] * var_10 for var_14 in range(var_9)] for var_13 in range(var_8)]\n\n\ndef func_12(var_8, var_9, var_10, var_11, var_12):\n return [\n [[[var_12] * var_11 for var_14 in range(var_10)] for var_14 in range(var_9)]\n for var_13 in range(var_8)\n ]\n\n\ndef func_8(var_16, var_17=1):\n return int(-(-var_16 // var_17))\n\n\ndef func_1():\n return int(eval(func_9()))\n\n\ndef func_3():\n return list(map(int, func_9().split()))\n\n\ndef func_2(var_7=None):\n return list(func_3()) if var_7 is None else [func_1() for var_13 in range(var_7)]\n\n\ndef func_7():\n print(\"Yes\")\n\n\ndef func_5():\n print(\"No\")\n\n\ndef func_6():\n print(\"YES\")\n\n\ndef func_4():\n print(\"NO\")\n\n\nsys.setrecursionlimit(10**9)\nvar_3 = 10**18\nvar_6 = 10**9 + 7\nvar_7, var_5, var_4 = func_3()\nvar_1 = func_2()\nvar_2 = func_2()\nvar_15 = min(var_1) + min(var_2)\nfor _ in range(var_4):\n var_16, var_17, var_10 = func_3()\n var_16 -= 1\n var_17 -= 1\n var_15 = min(var_15, var_1[var_16] + var_2[var_17] - var_10)\nprint(var_15)\n```", "output": "SLOWER 1.587", "pair_id": "python_p02748_reversed", "problem_id": "p02748", "language": "python", "direction": "reversed", "speedup_ratio": 3.0043} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_7 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_3 = True\n var_8 = str(var_4)\n var_6 = len(var_8)\n for var_5 in range(var_6 // 2 + 1):\n if var_8[var_5] != var_8[-var_5 - 1]:\n var_3 = False\n break\n if var_3:\n var_7 += 1\nprint(var_7)\n```\n\n=== Code B (Modified) ===\n```python\ndef func_1():\n var_1, var_2 = list(map(int, input().rstrip().split()))\n var_3 = 0\n for var_4 in range(var_1, var_2 + 1):\n var_5 = str(var_4)\n if var_5 == var_5[::-1]:\n var_3 += 1\n print(var_3)\n\n\nif __name__ == \"__main__\":\n func_1()\n```", "output": "FASTER 1.8711", "pair_id": "python_p03416_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 3.6581} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\n\nvar_7 = sys.stdin.readline\nfrom itertools import combinations\n\n\ndef func_3(var_10):\n for _ in range(var_10):\n yield list(map(int, var_7().split()))\n\n\ndef func_1(var_9, var_5, var_11):\n var_3 = sum(1 if var_5[var_8] == 1 else 0 for var_8 in var_9)\n return var_11[var_3]\n\n\ndef func_2():\n var_10 = int(eval(var_7()))\n var_1 = list(func_3(var_10))\n var_2 = list(func_3(var_10))\n for var_6 in range(1, 11):\n for var_4 in combinations(list(range(10)), var_6):\n yield sum(\n func_1(var_4, var_5, var_11) for var_5, var_11 in zip(var_1, var_2)\n )\n\n\nprint((max(func_2())))\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\nimport itertools\n\n\ndef func_2(var_4):\n return eval(\"0b\" + var_4)\n\n\ndef func_1():\n var_4 = int(sys.stdin.readline().rstrip())\n var_9 = [\n func_2(\"\".join(str(var_10) for var_10 in sys.stdin.readline().split()))\n for _ in range(var_4)\n ]\n var_8 = [\n [int(var_10) for var_10 in sys.stdin.readline().split()] for _ in range(var_4)\n ]\n var_3 = -(10**10)\n for var_6 in itertools.product(\"01\", repeat=10):\n var_6 = func_2(\"\".join(var_6))\n if var_6 == 0:\n continue\n var_7 = 0\n for var_2 in range(var_4):\n var_1 = var_9[var_2]\n var_5 = bin(var_1 & var_6).count(\"1\")\n var_7 += var_8[var_2][var_5]\n var_3 = max(var_3, var_7)\n print(var_3)\n\n\nif __name__ == \"__main__\":\n\n func_1()\n```", "output": "SLOWER 1.4756", "pair_id": "python_p03503_reversed", "problem_id": "p03503", "language": "python", "direction": "reversed", "speedup_ratio": 2.7809} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_4, var_3 = list(map(int, input().split()))\nvar_1 = 0\nfor var_2 in range(var_4, var_3 + 1):\n if str(var_2)[0] + str(var_2)[1] == str(var_2)[-1] + str(var_2)[-2]:\n var_1 += 1\nprint(var_1)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = [\n var_3 for var_3 in map(str, list(range(var_1, var_2 + 1))) if var_3 == var_3[::-1]\n]\nprint((len(var_4)))\n```", "output": "FASTER 2.0397", "pair_id": "python_p03416_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 4.1115} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_8 = int(eval(input()))\nvar_4 = []\nfor var_5 in range(var_8):\n var_11 = 0\n var_9 = list(map(int, input().split()))\n for var_6 in range(10):\n var_11 += var_9[var_6] << var_6\n var_4.append(var_11)\nvar_10 = []\nfor var_5 in range(var_8):\n var_10.append(list(map(int, input().split())))\nvar_1 = -(10**12)\nfor var_5 in range(1, 1 << 10):\n var_11 = 0\n for var_6 in range(var_8):\n var_3 = var_4[var_6] & var_5\n var_2 = 0\n for var_7 in range(10):\n if (var_3 >> var_7) % 2:\n var_2 += 1\n var_11 += var_10[var_6][var_2]\n var_1 = max(var_1, var_11)\nprint(var_1)\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\n\nvar_7 = sys.stdin.readline\nfrom itertools import combinations\n\n\ndef func_3(var_10):\n for _ in range(var_10):\n yield list(map(int, var_7().split()))\n\n\ndef func_1(var_9, var_5, var_11):\n var_3 = len([0 for var_8 in var_9 if var_5[var_8] == 1])\n return var_11[var_3]\n\n\ndef func_2():\n var_10 = int(eval(var_7()))\n var_1 = list(func_3(var_10))\n var_2 = list(func_3(var_10))\n for var_6 in range(1, 11):\n for var_4 in combinations(list(range(10)), var_6):\n yield sum(\n func_1(var_4, var_5, var_11) for var_5, var_11 in zip(var_1, var_2)\n )\n\n\nprint((max(func_2())))\n```", "output": "FASTER 1.4578", "pair_id": "python_p03503_forward", "problem_id": "p03503", "language": "python", "direction": "forward", "speedup_ratio": 2.7469} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\nimport math\nfrom collections import defaultdict\nfrom bisect import bisect_left, bisect_right\n\nsys.setrecursionlimit(10**7)\n\n\ndef func_4():\n return sys.stdin.readline()[:-1]\n\n\nvar_4 = 10**9 + 7\n\n\ndef func_1():\n return int(eval(func_4()))\n\n\ndef func_2():\n return list(map(int, func_4().split()))\n\n\ndef func_3(var_6, var_3):\n if var_6 <= 0:\n return [[] for _ in range(var_3)]\n elif var_3 == 1:\n return [func_1() for _ in range(var_6)]\n else:\n var_5 = [func_2() for _ in range(var_6)]\n return list(map(list, list(zip(*var_5))))\n\n\nfrom decimal import getcontext, Decimal\n\ngetcontext().prec = 28\nvar_1, var_2 = list(map(str, func_4().split()))\nvar_1 = int(var_1)\nvar_2 = Decimal(var_2)\nprint((int(var_1 * var_2)))\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = input().split()\nvar_1 = int(var_1)\nvar_3, var_4 = list(map(int, var_2.split(\".\")))\nvar_5 = var_1 * (var_3 * 100 + var_4)\nprint((int(var_5 // 100)))\n```", "output": "FASTER 2.0589", "pair_id": "python_p02659_forward", "problem_id": "p02659", "language": "python", "direction": "forward", "speedup_ratio": 4.1668} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\ndef func_1():\n var_1, var_2 = list(map(int, input().rstrip().split()))\n var_3 = 0\n for var_4 in range(var_1, var_2 + 1):\n var_5 = str(var_4)\n if var_5 == var_5[::-1]:\n var_3 += 1\n print(var_3)\n\n\nif __name__ == \"__main__\":\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n if list(str(var_4)) == list(reversed(str(var_4))):\n var_3 += 1\nprint(var_3)\n```", "output": "SLOWER 2.1464", "pair_id": "python_p03416_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 4.4271} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_6 = int(eval(input()))\nvar_2 = list(map(int, input().split()))\nfrom itertools import product\n\nvar_5 = [-1, 0, 1]\nvar_3 = 0\nfor var_7 in product(var_5, repeat=var_6):\n var_1 = []\n for var_4 in range(var_6):\n var_1.append(var_7[var_4] + var_2[var_4])\n if any(var_8 % 2 == 0 for var_8 in var_1):\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nimport math\nimport string\n\n\ndef func_5():\n return list(map(int, input().split()))\n\n\ndef func_4(var_7, var_8):\n return math.factorial(var_7) // (\n math.factorial(var_7 - var_8) * math.factorial(var_8)\n )\n\n\ndef func_3(var_10):\n var_9 = []\n for var_5 in var_10:\n if not (var_5 in var_9):\n var_9.append(var_5)\n return len(var_10) != len(var_9)\n\n\ndef func_1(var_7):\n func_1 = []\n for var_4 in range(1, var_7 + 1):\n if var_7 % var_4 == 0:\n func_1.append(var_4)\n return func_1\n\n\nvar_2 = [-1, -1, -1, 0, 0, 1, 1, 1]\nvar_3 = [-1, 0, 1, -1, 1, -1, 0, 1]\nvar_7 = int(eval(input()))\nvar_1 = func_5()\n\n\ndef func_2(var_6):\n if len(var_6) == var_7:\n for var_4 in range(len(var_6)):\n if var_6[var_4] % 2 == 0:\n return 1\n return 0\n return (\n func_2(var_6 + [var_1[len(var_6)]])\n + func_2(var_6 + [var_1[len(var_6)] - 1])\n + func_2(var_6 + [var_1[len(var_6)] + 1])\n )\n\n\nprint((func_2([])))\n```", "output": "FASTER 2.1906", "pair_id": "python_p03568_forward", "problem_id": "p03568", "language": "python", "direction": "forward", "speedup_ratio": 4.5649} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\nfrom operator import itemgetter\nfrom heapq import heapify, heappop, heappush\n\nvar_1 = int(10e15)\nvar_2 = -var_1\nvar_11 = 1000000007\nsys.setrecursionlimit(1000000)\n\n\ndef func_2():\n return list(map(int, input().split()))\n\n\ndef func_4():\n return input().split()\n\n\ndef func_1():\n return int(sys.stdin.readline())\n\n\ndef func_3():\n return eval(input())\n\n\nvar_3, var_4 = func_2()\nvar_5 = [func_2() for var_9 in range(var_3)]\nvar_5.sort(key=itemgetter(0))\n\nvar_8 = [[0] * (var_4 + 1 + 3000 + 1) for _ in range(var_3 + 1)]\nvar_6 = 0\nfor var_9 in range(var_3):\n for var_10 in range(var_4 + 1 + 3000 + 1):\n var_12, var_7 = var_5[var_9]\n if 0 <= var_10 - var_12 < var_4:\n var_8[var_9 + 1][var_10] = max(\n var_8[var_9][var_10], var_8[var_9][var_10 - var_12] + var_7\n )\n else:\n var_8[var_9 + 1][var_10] = var_8[var_9][var_10]\n var_6 = max(var_6, var_8[var_9 + 1][var_10])\nprint(var_6)\n```\n\n=== Code B (Modified) ===\n```python\ndef func_1():\n var_2, var_3, *var_1 = list(map(int, open(0).read().split()))\n var_4 = [0] * (var_3 + max(var_1[::2]))\n for var_7, var_6 in sorted(zip(*[iter(var_1)] * 2)):\n for var_5 in reversed(list(range(var_3))):\n var_4[var_5 + var_7] = max(var_4[var_5 + var_7], var_4[var_5] + var_6)\n print((max(var_4)))\n\n\nfunc_1()\n```", "output": "FASTER 6.1143", "pair_id": "python_p02863_forward", "problem_id": "p02863", "language": "python", "direction": "forward", "speedup_ratio": 69.2784} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nfrom sys import stdin\n\n\ndef func_1():\n\n var_9 = stdin.readline\n var_8, var_10 = list(map(int, var_9().split()))\n var_7 = [list(map(int, var_9().split())) for _ in range(var_8)]\n var_7.sort()\n var_1 = [0] * var_8\n var_2 = [0] * var_8\n for var_4 in range(var_8):\n var_1[var_4], var_2[var_4] = var_7[var_4][0], var_7[var_4][1]\n\n var_5 = -(10**9)\n var_3 = [[var_5] * (var_10 + 1) for _ in range(var_8 + 1)]\n var_3[0][0] = 0\n for var_4 in range(var_8):\n for var_6 in range(var_10 + 1):\n\n if var_6 != var_10:\n var_3[var_4 + 1][min(var_10, var_6 + var_1[var_4])] = max(\n var_3[var_4 + 1][min(var_10, var_6 + var_1[var_4])],\n var_3[var_4][var_6] + var_2[var_4],\n )\n\n var_3[var_4 + 1][var_6] = max(var_3[var_4 + 1][var_6], var_3[var_4][var_6])\n print((max(var_3[var_8])))\n\n\nif __name__ == \"__main__\":\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\ndef func_1():\n var_2, var_3, *var_1 = list(map(int, open(0).read().split()))\n var_4 = [0] * (var_3 + max(var_1[::2]))\n for var_7, var_6 in sorted(zip(*[iter(var_1)] * 2)):\n for var_5 in reversed(list(range(var_3))):\n var_4[var_5 + var_7] = max(var_4[var_5 + var_7], var_4[var_5] + var_6)\n print((max(var_4)))\n\n\nfunc_1()\n```", "output": "FASTER 1.1965", "pair_id": "python_p02863_forward", "problem_id": "p02863", "language": "python", "direction": "forward", "speedup_ratio": 2.2918} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nfor var_3 in range(1, 1009):\n if int(var_3 * 0.08) == var_1 and int(var_3 * 0.1) == var_2:\n print((int(var_3)))\n exit()\nprint(\"-1\")\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_3 = list(map(int, input().split()))\nvar_2 = -1\nfor var_4 in range(10, 12501):\n if int(var_4 * 0.08) == var_1 and int(var_4 * 0.1) == var_3:\n var_2 = var_4\n break\nprint(var_2)\n```", "output": "SLOWER 3.3967", "pair_id": "python_p02755_reversed", "problem_id": "p02755", "language": "python", "direction": "reversed", "speedup_ratio": 10.5316} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_5 = input()[::-1]\nvar_2 = [0] * 2019\nvar_2[0] = 1\nvar_4 = 0\nvar_6 = 1\nvar_1 = 0\nfor var_3 in var_5:\n var_4 = (var_4 + int(var_3) * var_6) % 2019\n var_6 = var_6 * 10 % 2019\n var_2[var_4] += 1\nfor var_3 in var_2:\n var_1 += var_3 * (var_3 - 1) // 2\nprint(var_1)\n```\n\n=== Code B (Modified) ===\n```python\n\"\"\"\"\"\"\n\nfrom collections import defaultdict\n\n\ndef func_1(var_10, var_9):\n var_5 = 1\n yield var_5\n for _ in range(1, var_10):\n var_5 = (var_5 * 10) % var_9\n yield var_5\n\n\ndef func_2():\n var_3 = 2019\n var_4 = input()[::-1]\n\n var_1 = [\n int(var_11) * var_10 % var_3\n for var_11, var_10 in zip(var_4, func_1(len(var_4), var_3))\n ]\n\n var_2 = [0]\n for var_5 in var_1:\n var_2.append((var_2[-1] + var_5) % var_3)\n\n var_8 = defaultdict(int)\n for var_6 in var_2:\n var_8[var_6] += 1\n var_7 = sum(var_12 * (var_12 - 1) // 2 for var_12 in list(var_8.values()))\n print(var_7)\n\n\nfunc_2()\n```", "output": "FASTER 1.3201", "pair_id": "python_p02702_forward", "problem_id": "p02702", "language": "python", "direction": "forward", "speedup_ratio": 2.4969} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\ndef func_1():\n var_1, var_2 = list(map(int, input().split()))\n var_3 = 0\n for var_4 in range(var_1, var_2 + 1):\n\n if (var_4 % 10) == (var_4 // 10000 % 10) and (var_4 // 10 % 10) == (\n var_4 // 1000 % 10\n ):\n var_3 += 1\n print(var_3)\n\n\nif __name__ == \"__main__\":\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_7 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_3 = True\n var_8 = str(var_4)\n var_6 = len(var_8)\n for var_5 in range(var_6 // 2 + 1):\n if var_8[var_5] != var_8[-var_5 - 1]:\n var_3 = False\n break\n if var_3:\n var_7 += 1\nprint(var_7)\n```", "output": "SLOWER 2.7891", "pair_id": "python_p03416_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 6.9122} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_4 = {}\nvar_5 = 0\nfor var_6 in range(10000, 100000):\n var_3 = list(str(var_6))\n if var_3 == list(reversed(var_3)):\n var_5 += 1\n var_4[var_6] = var_5\nvar_1, var_2 = list(map(int, input().split()))\nprint((var_4[var_2] - var_4[var_1 - 1] if var_1 > 10000 else var_4[var_2]))\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = [0] * (var_2 + 1)\nfor var_3 in range(1, var_2 + 1):\n if str(var_3) == str(var_3)[::-1]:\n var_4[var_3] = var_4[var_3 - 1] + 1\n else:\n var_4[var_3] = var_4[var_3 - 1]\nprint((var_4[var_2] - var_4[var_1 - 1]))\n```", "output": "FASTER 1.6313", "pair_id": "python_p03416_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 3.098} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = input().split()\nprint((int(var_1) * int(var_2[:-3] + var_2[-2:]) // 100))\n```\n\n=== Code B (Modified) ===\n```python\ndef func_1():\n from sys import setrecursionlimit, stdin\n from os import environ\n from collections import defaultdict, deque, Counter\n from math import ceil, floor, gcd\n from itertools import accumulate, combinations, combinations_with_replacement\n\n setrecursionlimit(10**6)\n var_7 = (\n (lambda *var_11: print(*var_11))\n if \"TERM_PROGRAM\" in environ\n else lambda *var_12: 0\n )\n var_8 = lambda: stdin.readline().rstrip()\n var_3 = lambda: list(map(int, var_8().split()))\n var_1 = lambda: int(var_8())\n var_4 = 10**9 + 7\n var_2 = 10**9 + 10\n var_9, var_10 = var_8().split()\n var_5 = int(var_9)\n var_10 = var_10.split(\".\")\n var_6 = int(var_10[0]) * 100\n if len(var_10) == 2:\n var_6 += int(var_10[1])\n print(var_5 * var_6 // 100)\n\n\nfunc_1()\n```", "output": "SLOWER 2.5742", "pair_id": "python_p02659_reversed", "problem_id": "p02659", "language": "python", "direction": "reversed", "speedup_ratio": 5.9555} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport math\nimport string\n\n\ndef func_4():\n return list(map(int, input().split()))\n\n\ndef func_3(var_6, var_7):\n return math.factorial(var_6) // (\n math.factorial(var_6 - var_7) * math.factorial(var_7)\n )\n\n\ndef func_2(var_9):\n var_8 = []\n for var_5 in var_9:\n if not (var_5 in var_8):\n var_8.append(var_5)\n return len(var_9) != len(var_8)\n\n\ndef func_1(var_6):\n func_1 = []\n for var_4 in range(1, var_6 + 1):\n if var_6 % var_4 == 0:\n func_1.append(var_4)\n return func_1\n\n\nvar_2 = [-1, -1, -1, 0, 0, 1, 1, 1]\nvar_3 = [-1, 0, 1, -1, 1, -1, 0, 1]\nvar_6 = int(eval(input()))\nvar_1 = func_4()\nvar_10 = 1\nfor var_4 in range(len(var_1)):\n if var_1[var_4] % 2 == 0:\n var_10 *= 2\n else:\n var_10 *= 1\nprint((3 ** len(var_1) - var_10))\n```\n\n=== Code B (Modified) ===\n```python\nvar_2 = int(eval(input()))\n(*var_1,) = list(map(int, input().split()))\nvar_5 = 0\nfor var_3 in var_1:\n if var_3 % 2 == 0:\n var_5 += 1\nvar_4 = 3**var_2 - 2**var_5\nprint(var_4)\n```", "output": "FASTER 1.6929", "pair_id": "python_p03568_forward", "problem_id": "p03568", "language": "python", "direction": "forward", "speedup_ratio": 3.2331} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = input().split()\nprint((int(var_1) * int(var_2[:-3] + var_2[-2:]) // 100))\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\nimport math\nfrom collections import defaultdict\nfrom bisect import bisect_left, bisect_right\n\nsys.setrecursionlimit(10**7)\n\n\ndef func_4():\n return sys.stdin.readline()[:-1]\n\n\nvar_4 = 10**9 + 7\n\n\ndef func_1():\n return int(eval(func_4()))\n\n\ndef func_2():\n return list(map(int, func_4().split()))\n\n\ndef func_3(var_6, var_3):\n if var_6 <= 0:\n return [[] for _ in range(var_3)]\n elif var_3 == 1:\n return [func_1() for _ in range(var_6)]\n else:\n var_5 = [func_2() for _ in range(var_6)]\n return list(map(list, list(zip(*var_5))))\n\n\nvar_1, var_2 = list(map(str, func_4().split()))\nvar_1 = int(var_1)\nvar_2 = 100 * int(var_2[0]) + 10 * int(var_2[2]) + int(var_2[3])\nprint((var_1 * var_2 // 100))\n```", "output": "SLOWER 2.7265", "pair_id": "python_p02659_reversed", "problem_id": "p02659", "language": "python", "direction": "reversed", "speedup_ratio": 6.6183} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\ndef func_1(*var_2: str) -> str:\n var_3 = int(var_2[0])\n var_4 = 1\n var_1 = 7 % var_3\n while var_1:\n var_1 = (var_1 * 10 + 7) % var_3\n var_4 += 1\n if var_3 < var_4:\n var_4 = -1\n break\n return str(var_4)\n\n\nif __name__ == \"__main__\":\n print((func_1(*(open(0).read().splitlines()))))\n```\n\n=== Code B (Modified) ===\n```python\nvar_1 = int(eval(input()))\nvar_3 = 0\nfor var_2 in range(1000001):\n var_3 += 7 * pow(10, var_2, var_1)\n var_3 %= var_1\n if var_3 == 0:\n print((var_2 + 1))\n break\nelse:\n print((-1))\n```", "output": "SLOWER 3.1368", "pair_id": "python_p02596_reversed", "problem_id": "p02596", "language": "python", "direction": "reversed", "speedup_ratio": 8.7958} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_3 = list(map(int, input().split()))\nvar_2 = 0\nfor var_5 in range(var_3 + 1)[var_1:]:\n if len(str(var_5)) % 2 == 0:\n var_6 = list(str(var_5))[: len(str(var_5)) // 2]\n var_7 = list(reversed(list(str(var_5))[len(str(var_5)) // 2 :]))\n if var_6 == var_7:\n var_2 += 1\n else:\n var_8 = list(str(var_5))[: len(str(var_5)) // 2 + 1]\n var_4 = list(reversed(list(str(var_5))[len(str(var_5)) // 2 :]))\n if var_8 == var_4:\n var_2 += 1\nprint(var_2)\n```\n\n=== Code B (Modified) ===\n```python\nfrom sys import stdin\n\nvar_6 = lambda: list(map(int, stdin.readline().split()))\nvar_5 = lambda: list(map(int, stdin.readline().split()))\nvar_1, var_3 = var_6()\nvar_2 = 0\nfor var_4 in range(var_1, var_3 + 1):\n var_7 = str(var_4)\n if var_7 == var_7[::-1]:\n var_2 += 1\nprint(var_2)\n```", "output": "FASTER 2.4561", "pair_id": "python_p03416_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 5.4874} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = str(var_4)\n if var_5[0] == var_5[4] and var_5[1] == var_5[3]:\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_4, var_3 = list(map(int, input().split()))\nvar_1 = 0\nfor var_2 in range(var_4, var_3 + 1):\n if str(var_2)[0] + str(var_2)[1] == str(var_2)[-1] + str(var_2)[-2]:\n var_1 += 1\nprint(var_1)\n```", "output": "SLOWER 1.6072", "pair_id": "python_p03416_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 3.0467} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = str(var_4)\n if var_5 == var_5[::-1]:\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n if str(var_4) == \"\".join(reversed(str(var_4))):\n var_3 += 1\nprint(var_3)\n```", "output": "SLOWER 1.0807", "pair_id": "python_p03416_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 2.1151} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\n\nvar_7 = sys.stdin.readline\nfrom itertools import combinations\n\n\ndef func_3(var_10):\n for _ in range(var_10):\n yield list(map(int, var_7().split()))\n\n\ndef func_1(var_9, var_5, var_11):\n var_3 = sum(1 if var_5[var_8] == 1 else 0 for var_8 in var_9)\n return var_11[var_3]\n\n\ndef func_2():\n var_10 = int(eval(var_7()))\n var_1 = list(func_3(var_10))\n var_2 = list(func_3(var_10))\n for var_6 in range(1, 11):\n for var_4 in combinations(list(range(10)), var_6):\n yield sum(\n func_1(var_4, var_5, var_11) for var_5, var_11 in zip(var_1, var_2)\n )\n\n\nprint((max(func_2())))\n```\n\n=== Code B (Modified) ===\n```python\nimport itertools\n\nvar_6 = int(eval(input()))\nvar_2 = [[]] * var_6\nfor var_4 in range(var_6):\n var_3 = list(map(int, input().split()))\n\n var_2[var_4] = var_3\nvar_8 = [[]] * var_6\nfor var_4 in range(var_6):\n var_9 = list(map(int, input().split()))\n var_8[var_4] = var_9\nvar_10 = -(10**11)\nfor var_1 in itertools.product([0, 1], repeat=10):\n if sum(var_1) == 0:\n continue\n var_11 = 0\n for var_7 in range(var_6):\n var_5 = 0\n for var_4 in range(10):\n if var_2[var_7][var_4] == 1 and var_1[var_4] == 1:\n var_5 += 1\n var_11 = var_11 + var_8[var_7][var_5]\n var_10 = max(var_10, var_11)\nprint(var_10)\n```", "output": "SLOWER 1.0485", "pair_id": "python_p03503_reversed", "problem_id": "p03503", "language": "python", "direction": "reversed", "speedup_ratio": 2.0684} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_7, var_6 = list(map(int, input().split()))\nvar_5 = [tuple(input().split()) for _ in range(var_6)]\nvar_9 = [[] for _ in range(var_7)]\nfor var_2 in range(var_6):\n var_9[int(var_5[var_2][0]) - 1].append(var_5[var_2][1])\nvar_1, var_8 = 0, 0\nfor var_3 in range(var_7):\n if \"AC\" in var_9[var_3]:\n var_1 += 1\n for var_4 in range(len(var_9[var_3])):\n if var_9[var_3][var_4] == \"WA\":\n var_8 += 1\n else:\n break\nprint((var_1, var_8))\n```\n\n=== Code B (Modified) ===\n```python\nvar_2, var_1 = list(map(int, input().split()))\nvar_3 = 0\nvar_8 = 0\nvar_4 = [0] * (var_2 + 1)\nvar_9 = [0] * (var_2 + 1)\nfor var_5 in range(var_1):\n var_6, var_7 = input().split()\n var_6 = int(var_6)\n if var_7 == \"AC\":\n if var_4[var_6] == 0:\n var_3 += 1\n var_8 += var_9[var_6]\n var_4[var_6] = 1\n else:\n var_9[var_6] += 1\nprint((var_3, var_8))\n```", "output": "FASTER 4.4932", "pair_id": "python_p02802_forward", "problem_id": "p02802", "language": "python", "direction": "forward", "speedup_ratio": 22.5216} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\n\nvar_8 = sys.stdin.readline\n\n\ndef func_1():\n var_2 = int(eval(var_8()))\n var_1 = []\n for _ in range(var_2):\n var_1.append(list(map(int, var_8().split())))\n var_3 = []\n for _ in range(var_2):\n var_3.append(list(map(int, var_8().split())))\n var_4 = -(10**7) * var_2\n for var_7 in range(1, 1 << 10):\n var_11 = 0\n for var_10, var_6 in enumerate(var_1):\n var_5 = 0\n for var_9 in range(10):\n if (var_7 >> var_9) & 1 & var_6[var_9]:\n var_5 += 1\n var_11 += var_3[var_10][var_5]\n var_4 = max(var_4, var_11)\n print(var_4)\n\n\nif __name__ == \"__main__\":\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\nimport itertools\n\n\ndef func_2(var_4):\n return eval(\"0b\" + var_4)\n\n\ndef func_1():\n var_4 = int(sys.stdin.readline().rstrip())\n var_9 = [\n func_2(\"\".join(str(var_10) for var_10 in sys.stdin.readline().split()))\n for _ in range(var_4)\n ]\n var_8 = [\n [int(var_10) for var_10 in sys.stdin.readline().split()] for _ in range(var_4)\n ]\n var_3 = -(10**10)\n for var_6 in itertools.product(\"01\", repeat=10):\n var_6 = func_2(\"\".join(var_6))\n if var_6 == 0:\n continue\n var_7 = 0\n for var_2 in range(var_4):\n var_1 = var_9[var_2]\n var_5 = bin(var_1 & var_6).count(\"1\")\n var_7 += var_8[var_2][var_5]\n var_3 = max(var_3, var_7)\n print(var_3)\n\n\nif __name__ == \"__main__\":\n\n func_1()\n```", "output": "SLOWER 1.366", "pair_id": "python_p03503_reversed", "problem_id": "p03503", "language": "python", "direction": "reversed", "speedup_ratio": 2.5776} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nfrom itertools import product\n\nvar_6 = int(eval(input()))\nvar_1 = list(map(int, input().split()))\nvar_5 = 0\nfor var_2 in product((-1, 0, 1), repeat=var_6):\n var_7 = 1\n for var_3, var_4 in zip(var_1, var_2):\n var_7 *= var_3 + var_4\n if var_7 % 2 == 0:\n var_5 += 1\nprint(var_5)\n```\n\n=== Code B (Modified) ===\n```python\nvar_2 = int(eval(input()))\nvar_1 = list(map(int, input().split()))\nvar_4 = 1\nfor var_3 in range(var_2):\n if var_1[var_3] % 2 == 0:\n var_4 *= 2\nprint((3**var_2 - var_4))\n```", "output": "FASTER 10.0467", "pair_id": "python_p03568_forward", "problem_id": "p03568", "language": "python", "direction": "forward", "speedup_ratio": 1057.6766} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_4 = int(eval(input()))\nvar_1 = list(map(int, input().split()))\nvar_3 = 1\nfor var_2 in var_1:\n var_3 *= 2 if var_2 % 2 == 0 else 1\nprint((3**var_4 - var_3))\n```\n\n=== Code B (Modified) ===\n```python\nfrom itertools import product\n\nvar_6 = int(eval(input()))\nvar_1 = list(map(int, input().split()))\nvar_5 = 0\nfor var_2 in product((-1, 0, 1), repeat=var_6):\n var_7 = 1\n for var_3, var_4 in zip(var_1, var_2):\n var_7 *= var_3 + var_4\n if var_7 % 2 == 0:\n var_5 += 1\nprint(var_5)\n```", "output": "SLOWER 10.1524", "pair_id": "python_p03568_reversed", "problem_id": "p03568", "language": "python", "direction": "reversed", "speedup_ratio": 1138.1035} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_5 in range(10):\n for var_6 in range(10):\n for var_7 in range(10):\n var_3 = 10000 * var_5 + 1000 * var_6 + 100 * var_7 + 10 * var_6 + var_5\n if var_1 <= var_3 <= var_2:\n var_4 += 1\nprint(var_4)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_3 = list(map(int, input().split()))\nvar_2 = 0\nfor var_5 in range(var_3 + 1)[var_1:]:\n if len(str(var_5)) % 2 == 0:\n var_6 = list(str(var_5))[: len(str(var_5)) // 2]\n var_7 = list(reversed(list(str(var_5))[len(str(var_5)) // 2 :]))\n if var_6 == var_7:\n var_2 += 1\n else:\n var_8 = list(str(var_5))[: len(str(var_5)) // 2 + 1]\n var_4 = list(reversed(list(str(var_5))[len(str(var_5)) // 2 :]))\n if var_8 == var_4:\n var_2 += 1\nprint(var_2)\n```", "output": "SLOWER 6.3001", "pair_id": "python_p03416_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 78.7987} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_10 = []\nvar_10 = input().rstrip().split(\" \")\nvar_1 = int(var_10[0])\nvar_3 = int(var_10[1])\nvar_2 = 0\nvar_6 = var_1\nwhile var_6 <= var_3:\n var_4 = var_6 // 10000\n var_5 = (var_6 - var_4 * 10000) // 1000\n var_7 = var_6 // 100\n var_8 = (var_6 - var_7 * 100) // 10\n var_9 = var_6 % 10\n if (var_4 == var_9) and (var_5 == var_8):\n var_2 += 1\n var_6 += 1\nprint(var_2)\n```\n\n=== Code B (Modified) ===\n```python\ndef func_1():\n var_1, var_2 = list(map(int, input().split()))\n var_3 = 0\n for var_4 in range(var_1, var_2 + 1):\n\n if (var_4 % 10) == (var_4 // 10000 % 10) and (var_4 // 10 % 10) == (\n var_4 // 1000 % 10\n ):\n var_3 += 1\n print(var_3)\n\n\nif __name__ == \"__main__\":\n func_1()\n```", "output": "FASTER 2.4731", "pair_id": "python_p03416_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 5.5522} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_7 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_3 = True\n var_8 = str(var_4)\n var_6 = len(var_8)\n for var_5 in range(var_6 // 2 + 1):\n if var_8[var_5] != var_8[-var_5 - 1]:\n var_3 = False\n break\n if var_3:\n var_7 += 1\nprint(var_7)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\n\n\ndef func_1(var_5, var_6):\n var_4 = 0\n for var_3 in range(var_5, var_6 + 1):\n if str(var_3) == str(var_3)[::-1]:\n var_4 += 1\n return var_4\n\n\nprint((func_1(var_1, var_2)))\n```", "output": "FASTER 1.4487", "pair_id": "python_p03416_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 2.7297} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport numpy as np\n\nvar_7 = input()[::-1]\nvar_6 = len(var_7)\nvar_1 = np.zeros(var_6, dtype=int)\nvar_4 = np.zeros(var_6, dtype=int)\nvar_2 = np.zeros(2019, dtype=int)\nvar_8 = 10\nvar_1[0] = int(var_7[0])\nvar_4[0] = var_1[0]\nvar_2[var_4[0]] += 1\nfor var_5 in range(1, var_6):\n var_1[var_5] = int(var_7[var_5]) * var_8 % 2019\n var_4[var_5] = (var_4[var_5 - 1] + var_1[var_5]) % 2019\n var_2[var_4[var_5]] += 1\n var_8 = var_8 * 10 % 2019\nvar_3 = var_2[np.nonzero(var_2)]\nprint(\n (\n int(\n sum([var_3[var_5] * (var_3[var_5] - 1) for var_5 in range(var_3.shape[0])])\n / 2\n )\n + var_2[0]\n )\n)\n```\n\n=== Code B (Modified) ===\n```python\nvar_6 = input()[::-1]\nvar_5 = len(var_6)\nvar_1 = [0] * var_5\nvar_3 = [0] * var_5\nvar_2 = [0] * 2019\nvar_7 = 10\nvar_1[0] = int(var_6[0])\nvar_3[0] = var_1[0]\nvar_2[var_3[0]] += 1\nfor var_4 in range(1, var_5):\n var_1[var_4] = int(var_6[var_4]) * var_7 % 2019\n var_3[var_4] = (var_3[var_4 - 1] + var_1[var_4]) % 2019\n var_2[var_3[var_4]] += 1\n var_7 = var_7 * 10 % 2019\nprint(\n (\n int(sum([var_2[var_4] * (var_2[var_4] - 1) for var_4 in range(2019)]) / 2)\n + var_2[0]\n )\n)\n```", "output": "SLOWER 1.0297", "pair_id": "python_p02702_reversed", "problem_id": "p02702", "language": "python", "direction": "reversed", "speedup_ratio": 2.0416} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\n_, var_1 = open(0)\nvar_1, *var_2 = list(map(int, var_1.split()))\nfor var_2 in var_2:\n var_1 ^= var_2\nprint((\"YNeos\"[var_1 > 0 :: 2]))\n```\n\n=== Code B (Modified) ===\n```python\nfrom collections import defaultdict\n\nvar_8 = int(eval(input()))\nvar_1 = tuple(map(int, input().split()))\nvar_3 = True\nif var_8 % 3 == 0:\n var_5 = defaultdict(int)\n for var_2 in var_1:\n var_5[var_2] += 1\n var_7 = var_8 // 3\n var_10 = []\n for var_9, var_4 in list(var_5.items()):\n if var_4 % var_7 != 0:\n var_3 = False\n break\n else:\n for _ in range(var_4 // var_7):\n var_10.append(var_9)\n else:\n if any(\n var_10[(0 + var_6) % 3] ^ var_10[(1 + var_6) % 3] != var_10[(2 + var_6) % 3]\n for var_6 in range(3)\n ):\n var_3 = False\nelse:\n if any(var_2 != 0 for var_2 in var_1):\n var_3 = False\nprint((\"Yes\" if var_3 else \"No\"))\n```", "output": "SLOWER 1.2494", "pair_id": "python_p02975_reversed", "problem_id": "p02975", "language": "python", "direction": "reversed", "speedup_ratio": 2.3774} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n if list(str(var_4)) == list(reversed(str(var_4))):\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\n\n\ndef func_1(var_5, var_6):\n var_4 = 0\n for var_3 in range(var_5, var_6 + 1):\n if str(var_3) == str(var_3)[::-1]:\n var_4 += 1\n return var_4\n\n\nprint((func_1(var_1, var_2)))\n```", "output": "FASTER 1.724", "pair_id": "python_p03416_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 3.3035} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_4 = str(var_4)\n if var_4 == var_4[::-1]:\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n if list(str(var_4)) == list(reversed(str(var_4))):\n var_3 += 1\nprint(var_3)\n```", "output": "SLOWER 1.2534", "pair_id": "python_p03416_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 2.384} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = input().split()\nvar_1 = int(var_1)\nvar_2 = int(var_2)\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = list(str(var_4))\n if (var_5[0] == var_5[4]) and (var_5[1] == var_5[3]):\n var_3 = var_3 + 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\ndef func_1():\n var_1, var_2 = list(map(int, input().split()))\n var_3 = 0\n for var_4 in range(var_1, var_2 + 1):\n\n if (var_4 % 10) == (var_4 // 10000 % 10) and (var_4 // 10 % 10) == (\n var_4 // 1000 % 10\n ):\n var_3 += 1\n print(var_3)\n\n\nif __name__ == \"__main__\":\n func_1()\n```", "output": "FASTER 2.0684", "pair_id": "python_p03416_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 4.1941} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nfrom sys import stdin\n\n\ndef func_1():\n\n var_11 = stdin.readline\n var_2 = int(var_11())\n var_1 = []\n for var_6 in range(var_2):\n var_5 = int(\"\".join(var_11().strip().split(\" \")), 2)\n var_1.append(var_5)\n var_3 = []\n for var_6 in range(var_2):\n var_10 = list(map(int, var_11().split()))\n var_3.append(var_10)\n var_8 = float(\"-inf\")\n for var_9 in range(1, 1 << 10):\n var_12 = 0\n for var_7 in range(var_2):\n var_4 = bin(var_9 & var_1[var_7]).count(\"1\")\n var_12 += var_3[var_7][var_4]\n var_8 = max(var_12, var_8)\n print(var_8)\n\n\nif __name__ == \"__main__\":\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\n\nvar_7 = sys.stdin.readline\nfrom itertools import combinations\n\n\ndef func_3(var_10):\n for _ in range(var_10):\n yield list(map(int, var_7().split()))\n\n\ndef func_1(var_9, var_5, var_11):\n var_3 = len([0 for var_8 in var_9 if var_5[var_8] == 1])\n return var_11[var_3]\n\n\ndef func_2():\n var_10 = int(eval(var_7()))\n var_1 = list(func_3(var_10))\n var_2 = list(func_3(var_10))\n for var_6 in range(1, 11):\n for var_4 in combinations(list(range(10)), var_6):\n yield sum(\n func_1(var_4, var_5, var_11) for var_5, var_11 in zip(var_1, var_2)\n )\n\n\nprint((max(func_2())))\n```", "output": "SLOWER 1.2554", "pair_id": "python_p03503_reversed", "problem_id": "p03503", "language": "python", "direction": "reversed", "speedup_ratio": 2.3874} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nfrom collections import Counter\n\nvar_1 = input()[::-1]\nvar_5 = [0]\nvar_4 = 0\nvar_6 = 2019\nfor var_7 in var_1:\n var_8 = int(var_7) * pow(10, var_4, var_6) % var_6\n var_8 = var_5[-1] + var_8\n var_5.append(var_8 % var_6)\n var_4 += 1\nvar_3 = Counter(var_5)\nvar_2 = sum(var_9 * (var_9 - 1) // 2 for var_9 in list(var_3.values()))\nprint(var_2)\n```\n\n=== Code B (Modified) ===\n```python\nvar_6 = input()[::-1]\nvar_5 = len(var_6)\nvar_1 = [0] * var_5\nvar_3 = [0] * var_5\nvar_2 = [0] * 2019\nvar_7 = 10\nvar_1[0] = int(var_6[0])\nvar_3[0] = var_1[0]\nvar_2[var_3[0]] += 1\nfor var_4 in range(1, var_5):\n var_1[var_4] = int(var_6[var_4]) * var_7 % 2019\n var_3[var_4] = (var_3[var_4 - 1] + var_1[var_4]) % 2019\n var_2[var_3[var_4]] += 1\n var_7 = var_7 * 10 % 2019\nprint(\n (\n int(sum([var_2[var_4] * (var_2[var_4] - 1) for var_4 in range(2019)]) / 2)\n + var_2[0]\n )\n)\n```", "output": "SLOWER 1.6668", "pair_id": "python_p02702_reversed", "problem_id": "p02702", "language": "python", "direction": "reversed", "speedup_ratio": 3.175} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n if str(var_4) == \"\".join(reversed(str(var_4))):\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\ndef func_1():\n var_1, var_2 = list(map(int, input().split()))\n var_3 = 0\n for var_4 in range(var_1, var_2 + 1):\n\n if (var_4 % 10) == (var_4 // 10000 % 10) and (var_4 // 10 % 10) == (\n var_4 // 1000 % 10\n ):\n var_3 += 1\n print(var_3)\n\n\nif __name__ == \"__main__\":\n func_1()\n```", "output": "FASTER 2.7403", "pair_id": "python_p03416_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 6.682} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_6 = str(var_4)\n var_5 = var_6[::-1]\n if var_6 == var_5:\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_4, var_3 = list(map(int, input().split()))\nvar_1 = 0\nfor var_2 in range(var_4, var_3 + 1):\n if str(var_2)[0] + str(var_2)[1] == str(var_2)[-1] + str(var_2)[-2]:\n var_1 += 1\nprint(var_1)\n```", "output": "SLOWER 1.0907", "pair_id": "python_p03416_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 2.1298} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\nimport math\nfrom collections import defaultdict\nfrom bisect import bisect_left, bisect_right\n\nsys.setrecursionlimit(10**7)\n\n\ndef func_4():\n return sys.stdin.readline()[:-1]\n\n\nvar_4 = 10**9 + 7\n\n\ndef func_1():\n return int(eval(func_4()))\n\n\ndef func_2():\n return list(map(int, func_4().split()))\n\n\ndef func_3(var_6, var_3):\n if var_6 <= 0:\n return [[] for _ in range(var_3)]\n elif var_3 == 1:\n return [func_1() for _ in range(var_6)]\n else:\n var_5 = [func_2() for _ in range(var_6)]\n return list(map(list, list(zip(*var_5))))\n\n\nvar_1, var_2 = list(map(str, func_4().split()))\nvar_1 = int(var_1)\nvar_2 = 100 * int(var_2[0]) + 10 * int(var_2[2]) + int(var_2[3])\nprint((var_1 * var_2 // 100))\n```\n\n=== Code B (Modified) ===\n```python\nimport decimal\n\n\ndef func_1():\n var_1, var_2 = list(map(decimal.Decimal, input().split()))\n print((var_1 * var_2 // 1))\n\n\nif __name__ == \"__main__\":\n func_1()\n```", "output": "FASTER 2.0678", "pair_id": "python_p02659_forward", "problem_id": "p02659", "language": "python", "direction": "forward", "speedup_ratio": 4.1925} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\n\nsys.setrecursionlimit(2147483647)\nvar_2 = float(\"inf\")\nvar_3 = 10**9 + 7\nvar_10 = lambda: sys.stdin.readline().rstrip()\n\n\ndef func_1():\n var_11, var_4 = list(map(int, var_10().split()))\n var_1 = [tuple(map(int, var_10().split())) for _ in range(var_11)]\n var_1.sort()\n var_8 = [0] * var_4\n var_6 = -var_2\n for var_9 in range(var_11):\n var_5, var_7 = var_1[var_9]\n var_12 = var_8[:]\n for var_13 in range(var_4):\n if var_13 + var_5 < var_4:\n var_12[var_13 + var_5] = max(\n var_12[var_13 + var_5], var_8[var_13] + var_7\n )\n else:\n var_6 = max(var_6, var_8[var_13] + var_7)\n var_8 = var_12\n print((max(var_6, max(var_8))))\n\n\nfunc_1()\n```\n\n=== Code B (Modified) ===\n```python\nvar_6, var_7 = list(map(int, input().split()))\nvar_1 = [list(map(int, input().split())) for _ in range(var_6)]\nvar_1.sort()\nvar_3 = [(6007) * [0] for _ in range(var_6 + 1)]\nvar_3[0][0] = 0\nvar_2 = 0\nfor var_4 in range(var_6):\n for var_5 in range(6007):\n var_3[var_4 + 1][var_5] = max(var_3[var_4 + 1][var_5], var_3[var_4][var_5])\n if var_5 < var_7:\n var_3[var_4 + 1][var_5 + var_1[var_4][0]] = max(\n var_3[var_4][var_5] + var_1[var_4][1],\n var_3[var_4][var_5 + var_1[var_4][0]],\n )\n var_2 = max(var_2, var_3[var_4 + 1][var_5])\nprint(var_2)\n```", "output": "SLOWER 6.7598", "pair_id": "python_p02863_reversed", "problem_id": "p02863", "language": "python", "direction": "reversed", "speedup_ratio": 108.3692} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\ndef func_1():\n from sys import setrecursionlimit, stdin\n from os import environ\n from collections import defaultdict, deque, Counter\n from math import ceil, floor, gcd\n from itertools import accumulate, combinations, combinations_with_replacement\n\n setrecursionlimit(10**6)\n var_7 = (\n (lambda *var_11: print(*var_11))\n if \"TERM_PROGRAM\" in environ\n else lambda *var_12: 0\n )\n var_8 = lambda: stdin.readline().rstrip()\n var_3 = lambda: list(map(int, var_8().split()))\n var_1 = lambda: int(var_8())\n var_4 = 10**9 + 7\n var_2 = 10**9 + 10\n var_9, var_10 = var_8().split()\n var_5 = int(var_9)\n var_6 = int(float(var_10) * 100 + 0.5)\n print(var_5 * var_6 // 100)\n\n\nfunc_1()\n```\n\n=== Code B (Modified) ===\n```python\ndef func_1():\n var_1, var_3 = input().split()\n var_1 = int(var_1)\n var_3 = int(float(var_3) * 100 + 0.5)\n var_2 = var_1 * var_3\n print((var_2 // 100))\n\n\nif __name__ == \"__main__\":\n func_1()\n```", "output": "FASTER 1.575", "pair_id": "python_p02659_forward", "problem_id": "p02659", "language": "python", "direction": "forward", "speedup_ratio": 2.9793} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport copy\n\nvar_8 = int(eval(input()))\nvar_10 = set([var_6 for var_6 in range(1, 10**5)])\nvar_5 = []\nvar_11 = {}\nvar_9 = []\nfor var_6 in range(var_8 - 1):\n var_1, var_2 = list(map(int, input().split(\" \")))\n var_5.append([var_1, var_2])\n var_11.setdefault(var_1, []).append(var_2)\n var_9.append([])\nvar_9.append([])\nvar_9.append([])\nvar_7 = 0\nfor var_12 in range(1, var_8 + 1):\n var_14 = var_11.get(var_12, [])\n var_3 = 1\n for var_13 in var_14:\n if var_3 in var_9[var_12]:\n var_3 += 1\n else:\n pass\n var_9[var_13].append(var_3)\n if var_3 >= var_7:\n var_7 = var_3\n var_3 += 1\nprint(var_7)\nfor var_4 in var_5:\n print((var_9[var_4[1]][0]))\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\n\n\ndef func_1():\n var_9 = int(sys.stdin.readline().rstrip())\n var_8 = list(map(int, sys.stdin.read().split()))\n var_2 = list(zip(var_8, var_8))\n var_7 = [[] for _ in range(var_9 + 1)]\n for var_1, var_3 in var_2:\n var_7[var_1].append(var_3)\n var_7[var_3].append(var_1)\n var_13 = 1\n var_11 = [None] * (var_9 + 1)\n\n var_5 = []\n var_14 = [var_13]\n\n while var_14:\n var_15 = var_14.pop()\n\n for var_16 in var_7[var_15]:\n if var_16 == var_11[var_15]:\n continue\n\n var_11[var_16] = var_15\n var_14.append(var_16)\n var_5.append(var_15)\n var_6 = [-1] * (var_9 + 1)\n for var_15 in var_5:\n var_10 = var_6[var_15]\n var_4 = 1\n for var_16 in var_7[var_15]:\n if var_16 == var_11[var_15]:\n continue\n if var_4 == var_10:\n var_4 += 1\n var_6[var_16] = var_4\n var_4 += 1\n var_12 = []\n for var_1, var_3 in var_2:\n if var_1 == var_11[var_3]:\n var_12.append(var_6[var_3])\n else:\n var_12.append(var_6[var_1])\n print((max(var_12)))\n print((\"\\n\".join(map(str, var_12))))\n\n\nif __name__ == \"__main__\":\n func_1()\n```", "output": "FASTER 4.1418", "pair_id": "python_p02850_forward", "problem_id": "p02850", "language": "python", "direction": "forward", "speedup_ratio": 17.653} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\ndef func_1():\n return list(map(int, input().split()))\n\n\nvar_1, var_2, var_3 = func_1()\nvar_4 = list(func_1())\nvar_6 = list(func_1())\nvar_5 = min(var_4) + min(var_6)\nfor _ in range(var_3):\n var_8, var_9, var_7 = func_1()\n var_5 = min(var_5, var_4[var_8 - 1] + var_6[var_9 - 1] - var_7)\nprint(var_5)\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\nfrom collections import Counter\n\n\ndef func_10():\n return sys.stdin.readline().strip()\n\n\ndef func_11(var_12, var_13, var_14):\n return [[var_14] * var_13 for var_17 in range(var_12)]\n\n\ndef func_12(var_12, var_13, var_14, var_15):\n return [[[var_15] * var_14 for var_18 in range(var_13)] for var_17 in range(var_12)]\n\n\ndef func_13(var_12, var_13, var_14, var_15, var_16):\n return [\n [[[var_16] * var_15 for var_18 in range(var_14)] for var_18 in range(var_13)]\n for var_17 in range(var_12)\n ]\n\n\ndef func_8(var_22, var_23=1):\n return int(-(-var_22 // var_23))\n\n\ndef func_1():\n return int(eval(func_10()))\n\n\ndef func_3():\n return list(map(int, func_10().split()))\n\n\ndef func_2(var_11=None):\n return list(func_3()) if var_11 is None else [func_1() for var_17 in range(var_11)]\n\n\ndef func_7():\n print(\"Yes\")\n\n\ndef func_5():\n print(\"No\")\n\n\ndef func_6():\n print(\"YES\")\n\n\ndef func_4():\n print(\"NO\")\n\n\nsys.setrecursionlimit(10**9)\nvar_5 = 10**18\nvar_10 = 10**9 + 7\n\n\ndef func_9(var_1, var_2):\n \"\"\"\"\"\"\n import numpy as np\n from numpy.fft import rfft, irfft\n\n var_8 = max(var_1)\n var_9 = max(var_2)\n var_3 = [0] * (var_8 + 1)\n var_4 = [0] * (var_9 + 1)\n for var_12 in var_1:\n var_3[var_12] += 1\n for var_13 in var_2:\n var_4[var_13] += 1\n\n var_6 = 1\n var_19 = 0\n while var_6 <= var_8 + var_9:\n var_19 += 1\n var_6 = 2**var_19\n\n var_21 = irfft(rfft(var_3, var_6) * rfft(var_4, var_6), var_6)\n\n var_21 = np.rint(var_21).astype(np.int64)\n return var_21\n\n\nvar_11, var_7, var_6 = func_3()\nvar_1 = func_2()\nvar_2 = func_2()\nvar_21 = list(func_9(var_1, var_2))\nvar_20 = var_5\nfor var_17, var_12 in enumerate(var_21):\n if var_12 != 0:\n var_20 = var_17\n break\nfor _ in range(var_6):\n var_22, var_23, var_14 = func_3()\n var_22 -= 1\n var_23 -= 1\n var_20 = min(var_20, var_1[var_22] + var_2[var_23] - var_14)\nprint(var_20)\n```", "output": "SLOWER 3.3693", "pair_id": "python_p02748_reversed", "problem_id": "p02748", "language": "python", "direction": "reversed", "speedup_ratio": 10.3341} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_5 in range(10):\n for var_6 in range(10):\n for var_7 in range(10):\n var_3 = 10000 * var_5 + 1000 * var_6 + 100 * var_7 + 10 * var_6 + var_5\n if var_1 <= var_3 <= var_2:\n var_4 += 1\nprint(var_4)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_5 in range(var_1, var_2 + 1):\n var_3 = str(var_5)\n if var_3[0] == var_3[-1] and var_3[1] == var_3[-2]:\n var_4 += 1\nprint(var_4)\n```", "output": "SLOWER 3.734", "pair_id": "python_p03416_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 13.3058} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_4 = str(var_4)\n if var_4[0] == var_4[-1] and var_4[1] == var_4[-2]:\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_3 in range(var_1, var_2 + 1):\n var_5 = list(str(var_3))\n var_6 = list(reversed(var_5))\n if var_5 == var_6:\n var_4 += 1\nprint(var_4)\n```", "output": "SLOWER 1.4924", "pair_id": "python_p03416_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 2.8135} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\nimport math\nfrom collections import defaultdict\nfrom bisect import bisect_left, bisect_right\n\nsys.setrecursionlimit(10**7)\n\n\ndef func_4():\n return sys.stdin.readline()[:-1]\n\n\nvar_4 = 10**9 + 7\n\n\ndef func_1():\n return int(eval(func_4()))\n\n\ndef func_2():\n return list(map(int, func_4().split()))\n\n\ndef func_3(var_6, var_3):\n if var_6 <= 0:\n return [[] for _ in range(var_3)]\n elif var_3 == 1:\n return [func_1() for _ in range(var_6)]\n else:\n var_5 = [func_2() for _ in range(var_6)]\n return list(map(list, list(zip(*var_5))))\n\n\nfrom decimal import getcontext, Decimal\n\ngetcontext().prec = 28\nvar_1, var_2 = list(map(str, func_4().split()))\nvar_1 = int(var_1)\nvar_2 = Decimal(var_2)\nprint((int(var_1 * var_2)))\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\n\nvar_3 = sys.stdin.readline\nvar_1, var_2 = var_3().split()\nvar_1 = int(var_1)\nvar_2 = int(float(var_2) * 100 + 0.5)\nprint((var_1 * var_2 // 100))\n```", "output": "FASTER 2.2902", "pair_id": "python_p02659_forward", "problem_id": "p02659", "language": "python", "direction": "forward", "speedup_ratio": 4.8913} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\n\n\ndef func_1():\n return sys.stdin.readline()[:-1]\n\n\nvar_3 = int(eval(func_1()))\nwhile 1:\n var_1 = 0\n for var_2 in range(2, int(var_3 ** (1 / 2))):\n if var_3 % var_2 == 0:\n var_1 = 1\n break\n if var_1 == 0:\n break\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nimport numpy as np\nfrom bisect import bisect_left\n\n\ndef func_1():\n var_4 = []\n var_1 = np.ones(10**5 + 10)\n var_1[0] = var_1[1] = 0\n for var_3, var_2 in enumerate(var_1):\n if var_2:\n var_4.append(var_3)\n var_1[2 * var_3 : 10**5 + 10 : var_3] = 0\n return var_4\n\n\ndef func_2(var_6):\n var_7 = int(var_6)\n var_5 = func_1()\n return str(var_5[bisect_left(var_5, var_7)])\n\n\nif __name__ == \"__main__\":\n import sys\n\n print((func_2(sys.stdin.read().strip())))\n```", "output": "SLOWER 7.7323", "pair_id": "python_p02819_reversed", "problem_id": "p02819", "language": "python", "direction": "reversed", "speedup_ratio": 212.6457} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\n\n\ndef func_1(var_5, var_6):\n var_4 = 0\n for var_3 in range(var_5, var_6 + 1):\n if str(var_3) == str(var_3)[::-1]:\n var_4 += 1\n return var_4\n\n\nprint((func_1(var_1, var_2)))\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_5 in range(10):\n for var_6 in range(10):\n for var_7 in range(10):\n var_3 = 10000 * var_5 + 1000 * var_6 + 100 * var_7 + 10 * var_6 + var_5\n if var_1 <= var_3 <= var_2:\n var_4 += 1\nprint(var_4)\n```", "output": "FASTER 3.5019", "pair_id": "python_p03416_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 11.3289} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\nimport math\nfrom collections import defaultdict\nfrom bisect import bisect_left, bisect_right\n\nsys.setrecursionlimit(10**7)\n\n\ndef func_4():\n return sys.stdin.readline()[:-1]\n\n\nvar_4 = 10**9 + 7\n\n\ndef func_1():\n return int(eval(func_4()))\n\n\ndef func_2():\n return list(map(int, func_4().split()))\n\n\ndef func_3(var_6, var_3):\n if var_6 <= 0:\n return [[] for _ in range(var_3)]\n elif var_3 == 1:\n return [func_1() for _ in range(var_6)]\n else:\n var_5 = [func_2() for _ in range(var_6)]\n return list(map(list, list(zip(*var_5))))\n\n\nvar_1, var_2 = list(map(str, func_4().split()))\nvar_1 = int(var_1)\nvar_2 = 100 * int(var_2[0]) + 10 * int(var_2[2]) + int(var_2[3])\nprint((var_1 * var_2 // 100))\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\n\nvar_5 = sys.stdin.readline\nif __name__ == \"__main__\":\n var_1, var_3 = var_5().split()\n var_2 = int(var_1)\n var_4 = round(float(var_3) * 100)\n print((var_2 * var_4 // 100))\n```", "output": "FASTER 2.0389", "pair_id": "python_p02659_forward", "problem_id": "p02659", "language": "python", "direction": "forward", "speedup_ratio": 4.1093} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\ndef func_1():\n var_2 = int(eval(input()))\n var_1 = [int(var_6) for var_6 in input().split()]\n var_4 = 3**var_2\n var_5 = len([var_3 for var_3 in var_1 if var_3 % 2 == 0])\n var_4 -= 2**var_5\n print(var_4)\n\n\nif __name__ == \"__main__\":\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\ndef func_1():\n var_2 = int(input())\n var_1 = [int(var_6) for var_6 in input().split()]\n if var_2 == 1:\n return print(1 if var_1[0] % 2 == 0 else 2)\n var_3 = 0\n var_5 = (-1, 0, 1)\n from itertools import product\n\n for var_6 in product(range(3), repeat=var_2):\n var_4 = 1\n for var_7 in range(var_2):\n var_4 *= var_1[var_7] + var_5[var_6[var_7]]\n if var_4 % 2 == 0:\n var_3 += 1\n print(var_3)\n\n\nif __name__ == \"__main__\":\n func_1()\n```", "output": "SLOWER 8.0497", "pair_id": "python_p03568_reversed", "problem_id": "p03568", "language": "python", "direction": "reversed", "speedup_ratio": 264.9728} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n if list(str(var_4)) == list(reversed(str(var_4))):\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().strip().split(\" \")))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n if str(var_4) == str(var_4)[::-1]:\n var_3 += 1\nprint(var_3)\n```", "output": "FASTER 1.0931", "pair_id": "python_p03416_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 2.1333} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nfrom collections import Counter, defaultdict, deque\nfrom heapq import heappop, heappush, heapify\nimport sys, bisect, math, itertools, fractions, pprint\n\nsys.setrecursionlimit(10**8)\nvar_6 = 10**9 + 7\nvar_1 = float(\"inf\")\n\n\ndef func_1():\n return int(sys.stdin.readline())\n\n\ndef func_2():\n return list(map(int, sys.stdin.readline().split()))\n\n\nvar_8, var_11 = func_2()\nvar_17 = [func_2() for _ in range(var_8)]\nvar_10 = var_17[::-1]\nvar_14 = [[0] * var_11 for _ in range(var_8)]\nvar_3 = [[0] * var_11 for _ in range(var_8)]\nfor var_4 in range(var_8 - 1):\n var_16, var_15 = var_17[var_4]\n for var_5 in range(var_11):\n if var_5 < var_16:\n var_14[var_4 + 1][var_5] = var_14[var_4][var_5]\n else:\n var_14[var_4 + 1][var_5] = max(\n var_14[var_4][var_5], var_14[var_4][var_5 - var_16] + var_15\n )\nvar_9 = var_14[var_8 - 1][var_11 - 1] + var_17[var_8 - 1][1]\nfor var_4 in range(var_8 - 1):\n var_16, var_15 = var_10[var_4]\n for var_5 in range(var_11):\n if var_5 < var_16:\n var_3[var_4 + 1][var_5] = var_3[var_4][var_5]\n else:\n var_3[var_4 + 1][var_5] = max(\n var_3[var_4][var_5], var_3[var_4][var_5 - var_16] + var_15\n )\n var_9 = max(var_9, var_3[var_8 - 1][var_11 - 1] + var_17[0][1])\n\nfor var_4 in range(1, var_8 - 1):\n var_13 = var_4\n var_2 = var_8 - var_4 - 1\n var_7 = 0\n for var_5 in range(var_11):\n var_12 = var_14[var_13][var_5] + var_3[var_2][var_11 - 1 - var_5]\n var_7 = max(var_7, var_12)\n var_9 = max(var_9, var_7 + var_17[var_4][1])\nprint(var_9)\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\n\nvar_9 = sys.stdin.readline\nfrom operator import itemgetter\n\nvar_3, var_4 = list(map(int, var_9().split()))\nvar_1 = [list(map(int, var_9().split())) for _ in range(var_3)]\nvar_1.sort(key=itemgetter(0))\nvar_8 = [[0 for _ in range(var_3 + 1)] for _ in range(var_4 + 1)]\n\nvar_2 = []\nfor var_10 in range(var_3):\n var_5, var_7 = var_1[var_10]\n for var_11 in range(var_4):\n if var_5 > var_11:\n var_8[var_11][var_10 + 1] = var_8[var_11][var_10]\n else:\n if var_7 + var_8[var_11 - var_5][var_10] >= var_8[var_11][var_10]:\n var_8[var_11][var_10 + 1] = var_8[var_11 - var_5][var_10] + var_7\n else:\n var_8[var_11][var_10 + 1] = var_8[var_11][var_10]\n var_2.append(var_8[var_4 - 1][var_10] + var_7)\nvar_6 = max(var_2)\nprint(var_6)\n```", "output": "FASTER 1.024", "pair_id": "python_p02863_forward", "problem_id": "p02863", "language": "python", "direction": "forward", "speedup_ratio": 2.0336} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = str(var_4)\n if var_5 == var_5[::-1]:\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_4 = {}\nvar_5 = 0\nfor var_6 in range(10000, 100000):\n var_3 = list(str(var_6))\n if var_3 == list(reversed(var_3)):\n var_5 += 1\n var_4[var_6] = var_5\nvar_1, var_2 = list(map(int, input().split()))\nprint((var_4[var_2] - var_4[var_1 - 1] if var_1 > 10000 else var_4[var_2]))\n```", "output": "SLOWER 3.5781", "pair_id": "python_p03416_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 11.9428} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().rstrip().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = list(map(int, list(str(var_4))))\n if var_5[0] == var_5[4] and var_5[1] == var_5[3]:\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = str(var_4)\n if var_5 == var_5[::-1]:\n var_3 += 1\nprint(var_3)\n```", "output": "FASTER 1.6875", "pair_id": "python_p03416_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 3.221} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\n\nvar_8 = sys.stdin.readline\n\n\ndef func_1():\n var_2 = int(eval(var_8()))\n var_1 = [int(var_8().replace(\" \", \"\"), 2) for _ in range(var_2)]\n var_3 = [list(map(int, var_8().split())) for _ in range(var_2)]\n var_4 = -(10**7) * var_2\n for var_7 in range(1, 1 << 10):\n var_10 = 0\n for var_9, var_6 in enumerate(var_1):\n var_5 = bin(var_7 & var_6).count(\"1\")\n var_10 += var_3[var_9][var_5]\n var_4 = max(var_4, var_10)\n print(var_4)\n\n\nif __name__ == \"__main__\":\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nvar_8 = int(eval(input()))\nvar_4 = []\nfor var_5 in range(var_8):\n var_11 = 0\n var_9 = list(map(int, input().split()))\n for var_6 in range(10):\n var_11 += var_9[var_6] << var_6\n var_4.append(var_11)\nvar_10 = []\nfor var_5 in range(var_8):\n var_10.append(list(map(int, input().split())))\nvar_1 = -(10**12)\nfor var_5 in range(1, 1 << 10):\n var_11 = 0\n for var_6 in range(var_8):\n var_3 = list(bin(var_4[var_6] & var_5)[2:])\n var_2 = 0\n for var_7 in var_3:\n if var_7 == \"1\":\n var_2 += 1\n var_11 += var_10[var_6][var_2]\n var_1 = max(var_1, var_11)\nprint(var_1)\n```", "output": "SLOWER 2.2065", "pair_id": "python_p03503_reversed", "problem_id": "p03503", "language": "python", "direction": "reversed", "speedup_ratio": 4.6157} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nfrom sys import stdin\n\nvar_6 = lambda: list(map(int, stdin.readline().split()))\nvar_5 = lambda: list(map(int, stdin.readline().split()))\nvar_1, var_3 = var_6()\nvar_2 = 0\nfor var_4 in range(var_1, var_3 + 1):\n var_7 = str(var_4)\n if var_7 == var_7[::-1]:\n var_2 += 1\nprint(var_2)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = [0] * (var_2 + 1)\nfor var_3 in range(1, var_2 + 1):\n if str(var_3) == str(var_3)[::-1]:\n var_4[var_3] = var_4[var_3 - 1] + 1\n else:\n var_4[var_3] = var_4[var_3 - 1]\nprint((var_4[var_2] - var_4[var_1 - 1]))\n```", "output": "SLOWER 1.9239", "pair_id": "python_p03416_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 3.7944} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\ndef func_1():\n var_2, var_3, *var_1 = list(map(int, open(0).read().split()))\n var_4 = [0] * (var_3 + max(var_1[::2]))\n for var_7, var_6 in sorted(zip(*[iter(var_1)] * 2)):\n for var_5 in reversed(list(range(var_3))):\n var_4[var_5 + var_7] = max(var_4[var_5 + var_7], var_4[var_5] + var_6)\n print((max(var_4)))\n\n\nfunc_1()\n```\n\n=== Code B (Modified) ===\n```python\nfrom collections import Counter, defaultdict, deque\nfrom heapq import heappop, heappush, heapify\nimport sys, bisect, math, itertools, fractions, pprint\n\nsys.setrecursionlimit(10**8)\nvar_6 = 10**9 + 7\nvar_1 = float(\"inf\")\n\n\ndef func_1():\n return int(sys.stdin.readline())\n\n\ndef func_2():\n return list(map(int, sys.stdin.readline().split()))\n\n\nvar_8, var_11 = func_2()\nvar_17 = [func_2() for _ in range(var_8)]\nvar_10 = var_17[::-1]\nvar_14 = [[0] * var_11 for _ in range(var_8)]\nvar_3 = [[0] * var_11 for _ in range(var_8)]\nfor var_4 in range(var_8 - 1):\n var_16, var_15 = var_17[var_4]\n for var_5 in range(var_11):\n if var_5 < var_16:\n var_14[var_4 + 1][var_5] = var_14[var_4][var_5]\n else:\n var_14[var_4 + 1][var_5] = max(\n var_14[var_4][var_5], var_14[var_4][var_5 - var_16] + var_15\n )\nvar_9 = var_14[var_8 - 1][var_11 - 1] + var_17[var_8 - 1][1]\nfor var_4 in range(var_8 - 1):\n var_16, var_15 = var_10[var_4]\n for var_5 in range(var_11):\n if var_5 < var_16:\n var_3[var_4 + 1][var_5] = var_3[var_4][var_5]\n else:\n var_3[var_4 + 1][var_5] = max(\n var_3[var_4][var_5], var_3[var_4][var_5 - var_16] + var_15\n )\n var_9 = max(var_9, var_3[var_8 - 1][var_11 - 1] + var_17[0][1])\n\nfor var_4 in range(1, var_8 - 1):\n var_13 = var_4\n var_2 = var_8 - var_4 - 1\n var_7 = 0\n for var_5 in range(var_11):\n var_12 = var_14[var_13][var_5] + var_3[var_2][var_11 - 1 - var_5]\n var_7 = max(var_7, var_12)\n var_9 = max(var_9, var_7 + var_17[var_4][1])\nprint(var_9)\n```", "output": "SLOWER 2.2995", "pair_id": "python_p02863_reversed", "problem_id": "p02863", "language": "python", "direction": "reversed", "speedup_ratio": 4.9229} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\n\"\"\"\"\"\"\n\nfrom collections import defaultdict\n\n\ndef func_1(var_10, var_9):\n var_5 = 1\n yield var_5\n for _ in range(1, var_10):\n var_5 = (var_5 * 10) % var_9\n yield var_5\n\n\ndef func_2():\n var_3 = 2019\n var_4 = input()[::-1]\n\n var_1 = [\n int(var_11) * var_10 % var_3\n for var_11, var_10 in zip(var_4, func_1(len(var_4), var_3))\n ]\n\n var_2 = [0]\n for var_5 in var_1:\n var_2.append((var_2[-1] + var_5) % var_3)\n\n var_8 = defaultdict(int)\n for var_6 in var_2:\n var_8[var_6] += 1\n var_7 = sum(var_12 * (var_12 - 1) // 2 for var_12 in list(var_8.values()))\n print(var_7)\n\n\nfunc_2()\n```\n\n=== Code B (Modified) ===\n```python\nvar_5 = input()[::-1]\nvar_2 = [0] * 2019\nvar_2[0] = 1\nvar_4 = 0\nvar_6 = 1\nvar_1 = 0\nfor var_3 in var_5:\n var_4 = (var_4 + int(var_3) * var_6) % 2019\n var_6 = var_6 * 10 % 2019\n var_2[var_4] += 1\nfor var_3 in var_2:\n var_1 += var_3 * (var_3 - 1) // 2\nprint(var_1)\n```", "output": "SLOWER 1.3201", "pair_id": "python_p02702_reversed", "problem_id": "p02702", "language": "python", "direction": "reversed", "speedup_ratio": 2.4969} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_6 = str(var_4)\n var_5 = var_6[::-1]\n if var_6 == var_5:\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\n\n\ndef func_1(var_5):\n var_4 = 0\n for var_3 in range(1, var_5 + 1):\n if str(var_3) == str(var_3)[::-1]:\n var_4 += 1\n return var_4\n\n\nprint((func_1(var_2) - func_1(var_1 - 1)))\n```", "output": "SLOWER 1.3402", "pair_id": "python_p03416_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 2.5319} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = str(var_4)\n if var_5[0] == var_5[4] and var_5[1] == var_5[3]:\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_5 in range(10):\n for var_6 in range(10):\n for var_7 in range(10):\n var_3 = 10000 * var_5 + 1000 * var_6 + 100 * var_7 + 10 * var_6 + var_5\n if var_1 <= var_3 <= var_2:\n var_4 += 1\nprint(var_4)\n```", "output": "FASTER 3.5594", "pair_id": "python_p03416_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 11.7893} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_6, var_7 = list(map(int, input().split()))\nvar_1 = [list(map(int, input().split())) for _ in range(var_6)]\nvar_1.sort()\nvar_3 = [(6007) * [0] for _ in range(var_6 + 1)]\nvar_3[0][0] = 0\nvar_2 = 0\nfor var_4 in range(var_6):\n for var_5 in range(6007):\n var_3[var_4 + 1][var_5] = max(var_3[var_4 + 1][var_5], var_3[var_4][var_5])\n if var_5 < var_7:\n var_3[var_4 + 1][var_5 + var_1[var_4][0]] = max(\n var_3[var_4][var_5] + var_1[var_4][1],\n var_3[var_4][var_5 + var_1[var_4][0]],\n )\n var_2 = max(var_2, var_3[var_4 + 1][var_5])\nprint(var_2)\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\n\nvar_9 = sys.stdin.readline\nfrom operator import itemgetter\n\nvar_3, var_4 = list(map(int, var_9().split()))\nvar_1 = [list(map(int, var_9().split())) for _ in range(var_3)]\nvar_1.sort(key=itemgetter(0))\nvar_8 = [[0 for _ in range(var_3 + 1)] for _ in range(var_4 + 1)]\n\nvar_2 = []\nfor var_10 in range(var_3):\n var_5, var_7 = var_1[var_10]\n for var_11 in range(var_4):\n if var_5 > var_11:\n var_8[var_11][var_10 + 1] = var_8[var_11][var_10]\n else:\n if var_7 + var_8[var_11 - var_5][var_10] >= var_8[var_11][var_10]:\n var_8[var_11][var_10 + 1] = var_8[var_11 - var_5][var_10] + var_7\n else:\n var_8[var_11][var_10 + 1] = var_8[var_11][var_10]\n var_2.append(var_8[var_4 - 1][var_10] + var_7)\nvar_6 = max(var_2)\nprint(var_6)\n```", "output": "FASTER 5.7437", "pair_id": "python_p02863_forward", "problem_id": "p02863", "language": "python", "direction": "forward", "speedup_ratio": 53.5847} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = input().split()\nprint((int(var_1) * int(var_2[:-3] + var_2[-2:]) // 100))\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\nimport math\nfrom collections import defaultdict\nfrom bisect import bisect_left, bisect_right\n\nsys.setrecursionlimit(10**7)\n\n\ndef func_4():\n return sys.stdin.readline()[:-1]\n\n\nvar_4 = 10**9 + 7\n\n\ndef func_1():\n return int(eval(func_4()))\n\n\ndef func_2():\n return list(map(int, func_4().split()))\n\n\ndef func_3(var_6, var_3):\n if var_6 <= 0:\n return [[] for _ in range(var_3)]\n elif var_3 == 1:\n return [func_1() for _ in range(var_6)]\n else:\n var_5 = [func_2() for _ in range(var_6)]\n return list(map(list, list(zip(*var_5))))\n\n\nfrom decimal import getcontext, Decimal\n\ngetcontext().prec = 28\nvar_1, var_2 = list(map(str, func_4().split()))\nvar_1 = int(var_1)\nvar_2 = Decimal(var_2)\nprint((int(var_1 * var_2)))\n```", "output": "SLOWER 2.7073", "pair_id": "python_p02659_reversed", "problem_id": "p02659", "language": "python", "direction": "reversed", "speedup_ratio": 6.5312} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport bisect\nimport sys\n\nsys.setrecursionlimit(10**6)\nvar_17 = sys.stdout.write\nvar_7 = lambda *var_15: print(*var_15) if var_1 else 0\nvar_1 = True\n\n\ndef func_1(var_10=sys.stdin.readline):\n var_12 = lambda: var_10().rstrip()\n var_3 = lambda: list(map(int, var_12().split()))\n var_2 = lambda: int(var_12())\n var_4 = lambda var_18: [var_3() for _ in range(var_18)]\n var_14, var_16 = var_3()\n var_5 = var_4(var_14)\n var_8 = [[0] * var_16 for _ in range(var_14)]\n for var_11 in range(1, var_14):\n for var_13 in range(1, var_16):\n if var_13 < var_5[var_11 - 1][0]:\n var_8[var_11][var_13] = var_8[var_11 - 1][var_13]\n else:\n var_8[var_11][var_13] = max(\n var_8[var_11 - 1][var_13],\n var_8[var_11 - 1][var_13 - var_5[var_11 - 1][0]]\n + var_5[var_11 - 1][1],\n )\n var_9 = [[0] * var_16 for _ in range(var_14)]\n for var_11 in range(1, var_14):\n for var_13 in range(1, var_16):\n if var_13 < var_5[var_14 - var_11][0]:\n var_9[var_11][var_13] = var_9[var_11 - 1][var_13]\n else:\n var_9[var_11][var_13] = max(\n var_9[var_11 - 1][var_13],\n var_9[var_11 - 1][var_13 - var_5[var_14 - var_11][0]]\n + var_5[var_14 - var_11][1],\n )\n var_6 = 0\n for var_11 in range(var_14):\n for var_13 in range(var_16 - 1):\n var_6 = max(\n var_6,\n var_8[var_11][var_13]\n + var_9[var_14 - var_11 - 1][var_16 - var_13 - 1]\n + var_5[var_11][1],\n )\n print(var_6)\n\n\nif __name__ == \"__main__\":\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\n\nsys.setrecursionlimit(2147483647)\nvar_2 = float(\"inf\")\nvar_3 = 10**9 + 7\nvar_10 = lambda: sys.stdin.readline().rstrip()\n\n\ndef func_1():\n var_11, var_4 = list(map(int, var_10().split()))\n var_1 = [tuple(map(int, var_10().split())) for _ in range(var_11)]\n var_1.sort()\n var_8 = [0] * var_4\n var_6 = -var_2\n for var_9 in range(var_11):\n var_5, var_7 = var_1[var_9]\n var_12 = var_8[:]\n for var_13 in range(var_4):\n if var_13 + var_5 < var_4:\n var_12[var_13 + var_5] = max(\n var_12[var_13 + var_5], var_8[var_13] + var_7\n )\n else:\n var_6 = max(var_6, var_8[var_13] + var_7)\n var_8 = var_12\n print((max(var_6, max(var_8))))\n\n\nfunc_1()\n```", "output": "FASTER 1.4425", "pair_id": "python_p02863_forward", "problem_id": "p02863", "language": "python", "direction": "forward", "speedup_ratio": 2.718} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\nfrom collections import Counter\n\n\ndef func_10():\n return sys.stdin.readline().strip()\n\n\ndef func_11(var_12, var_13, var_14):\n return [[var_14] * var_13 for var_17 in range(var_12)]\n\n\ndef func_12(var_12, var_13, var_14, var_15):\n return [[[var_15] * var_14 for var_18 in range(var_13)] for var_17 in range(var_12)]\n\n\ndef func_13(var_12, var_13, var_14, var_15, var_16):\n return [\n [[[var_16] * var_15 for var_18 in range(var_14)] for var_18 in range(var_13)]\n for var_17 in range(var_12)\n ]\n\n\ndef func_8(var_22, var_23=1):\n return int(-(-var_22 // var_23))\n\n\ndef func_1():\n return int(eval(func_10()))\n\n\ndef func_3():\n return list(map(int, func_10().split()))\n\n\ndef func_2(var_11=None):\n return list(func_3()) if var_11 is None else [func_1() for var_17 in range(var_11)]\n\n\ndef func_7():\n print(\"Yes\")\n\n\ndef func_5():\n print(\"No\")\n\n\ndef func_6():\n print(\"YES\")\n\n\ndef func_4():\n print(\"NO\")\n\n\nsys.setrecursionlimit(10**9)\nvar_5 = 10**18\nvar_10 = 10**9 + 7\n\n\ndef func_9(var_1, var_2):\n \"\"\"\"\"\"\n import numpy as np\n from numpy.fft import rfft, irfft\n\n var_8 = max(var_1)\n var_9 = max(var_2)\n var_3 = [0] * (var_8 + 1)\n var_4 = [0] * (var_9 + 1)\n for var_12 in var_1:\n var_3[var_12] += 1\n for var_13 in var_2:\n var_4[var_13] += 1\n\n var_6 = 1\n var_19 = 0\n while var_6 <= var_8 + var_9:\n var_19 += 1\n var_6 = 2**var_19\n\n var_21 = irfft(rfft(var_3, var_6) * rfft(var_4, var_6), var_6)\n\n var_21 = np.rint(var_21).astype(np.int64)\n return var_21\n\n\nvar_11, var_7, var_6 = func_3()\nvar_1 = func_2()\nvar_2 = func_2()\nvar_21 = list(func_9(var_1, var_2))\nvar_20 = var_5\nfor var_17, var_12 in enumerate(var_21):\n if var_12 != 0:\n var_20 = var_17\n break\nfor _ in range(var_6):\n var_22, var_23, var_14 = func_3()\n var_22 -= 1\n var_23 -= 1\n var_20 = min(var_20, var_1[var_22] + var_2[var_23] - var_14)\nprint(var_20)\n```\n\n=== Code B (Modified) ===\n```python\ndef func_1():\n return list(map(int, input().split()))\n\n\nvar_1, var_2, var_3 = func_1()\nvar_4 = list(func_1())\nvar_6 = list(func_1())\nvar_5 = min(var_4) + min(var_6)\nfor _ in range(var_3):\n var_8, var_9, var_7 = func_1()\n var_5 = min(var_5, var_4[var_8 - 1] + var_6[var_9 - 1] - var_7)\nprint(var_5)\n```", "output": "FASTER 3.3693", "pair_id": "python_p02748_forward", "problem_id": "p02748", "language": "python", "direction": "forward", "speedup_ratio": 10.3341} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_4 = int(eval(input()))\nvar_1 = list(map(int, input().split()))\nvar_3 = 1\nfor var_2 in var_1:\n var_3 *= 2 if var_2 % 2 == 0 else 1\nprint((3**var_4 - var_3))\n```\n\n=== Code B (Modified) ===\n```python\nimport math\nimport string\n\n\ndef func_5():\n return list(map(int, input().split()))\n\n\ndef func_4(var_7, var_8):\n return math.factorial(var_7) // (\n math.factorial(var_7 - var_8) * math.factorial(var_8)\n )\n\n\ndef func_3(var_10):\n var_9 = []\n for var_5 in var_10:\n if not (var_5 in var_9):\n var_9.append(var_5)\n return len(var_10) != len(var_9)\n\n\ndef func_1(var_7):\n func_1 = []\n for var_4 in range(1, var_7 + 1):\n if var_7 % var_4 == 0:\n func_1.append(var_4)\n return func_1\n\n\nvar_2 = [-1, -1, -1, 0, 0, 1, 1, 1]\nvar_3 = [-1, 0, 1, -1, 1, -1, 0, 1]\nvar_7 = int(eval(input()))\nvar_1 = func_5()\n\n\ndef func_2(var_6):\n if len(var_6) == var_7:\n for var_4 in range(len(var_6)):\n if var_6[var_4] % 2 == 0:\n return 1\n return 0\n return (\n func_2(var_6 + [var_1[len(var_6)]])\n + func_2(var_6 + [var_1[len(var_6)] - 1])\n + func_2(var_6 + [var_1[len(var_6)] + 1])\n )\n\n\nprint((func_2([])))\n```", "output": "SLOWER 7.7659", "pair_id": "python_p03568_reversed", "problem_id": "p03568", "language": "python", "direction": "reversed", "speedup_ratio": 217.6585} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\n\"\"\"\"\"\"\n\nfrom collections import defaultdict\n\n\ndef func_1(var_10, var_9):\n var_5 = 1\n yield var_5\n for _ in range(1, var_10):\n var_5 = (var_5 * 10) % var_9\n yield var_5\n\n\ndef func_2():\n var_3 = 2019\n var_4 = input()[::-1]\n\n var_1 = [\n int(var_11) * var_10 % var_3\n for var_11, var_10 in zip(var_4, func_1(len(var_4), var_3))\n ]\n\n var_2 = [0]\n for var_5 in var_1:\n var_2.append((var_2[-1] + var_5) % var_3)\n\n var_8 = defaultdict(int)\n for var_6 in var_2:\n var_8[var_6] += 1\n var_7 = sum(var_12 * (var_12 - 1) // 2 for var_12 in list(var_8.values()))\n print(var_7)\n\n\nfunc_2()\n```\n\n=== Code B (Modified) ===\n```python\nvar_6 = input()[::-1]\nvar_4 = len(var_6)\nvar_2 = [0] * 2019\nvar_2[0] = 1\nvar_7 = 1\nvar_5 = 0\nvar_1 = 0\nfor var_3 in range(var_4):\n var_5 = (var_5 + int(var_6[var_3]) * var_7) % 2019\n var_7 = var_7 * 10 % 2019\n var_2[var_5] += 1\nfor var_3 in var_2:\n var_1 += var_3 * (var_3 - 1) // 2\nprint(var_1)\n```", "output": "SLOWER 1.3499", "pair_id": "python_p02702_reversed", "problem_id": "p02702", "language": "python", "direction": "reversed", "speedup_ratio": 2.5489} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = str(var_4)\n if var_5 == var_5[::-1]:\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().rstrip().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = list(map(int, list(str(var_4))))\n if var_5[0] == var_5[4] and var_5[1] == var_5[3]:\n var_3 += 1\nprint(var_3)\n```", "output": "SLOWER 1.6875", "pair_id": "python_p03416_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 3.221} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = list(str(var_4))\n if var_5 == list(reversed(var_5)):\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_5 in range(10):\n for var_6 in range(10):\n for var_7 in range(10):\n var_3 = 10000 * var_5 + 1000 * var_6 + 100 * var_7 + 10 * var_6 + var_5\n if var_1 <= var_3 <= var_2:\n var_4 += 1\nprint(var_4)\n```", "output": "FASTER 5.0577", "pair_id": "python_p03416_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 33.3066} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nfrom fractions import Fraction\n\nvar_1, var_2 = input().split()\n\n\nfrom decimal import *\n\nvar_4 = var_3(var_1)\nvar_6 = var_3(var_2)\nvar_7().prec = 28\nvar_5 = var_4 * var_6\nprint((int(var_5)))\n```\n\n=== Code B (Modified) ===\n```python\ndef func_1():\n from sys import setrecursionlimit, stdin\n from os import environ\n from collections import defaultdict, deque, Counter\n from math import ceil, floor, gcd\n from itertools import accumulate, combinations, combinations_with_replacement\n\n setrecursionlimit(10**6)\n var_7 = (\n (lambda *var_11: print(*var_11))\n if \"TERM_PROGRAM\" in environ\n else lambda *var_12: 0\n )\n var_8 = lambda: stdin.readline().rstrip()\n var_3 = lambda: list(map(int, var_8().split()))\n var_1 = lambda: int(var_8())\n var_4 = 10**9 + 7\n var_2 = 10**9 + 10\n var_9, var_10 = var_8().split()\n var_5 = int(var_9)\n var_10 = var_10.split(\".\")\n var_6 = int(var_10[0]) * 100\n if len(var_10) == 2:\n var_6 += int(var_10[1])\n print(var_5 * var_6 // 100)\n\n\nfunc_1()\n```", "output": "SLOWER 1.768", "pair_id": "python_p02659_reversed", "problem_id": "p02659", "language": "python", "direction": "reversed", "speedup_ratio": 3.4057} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\ndef func_1():\n var_2 = int(eval(input()))\n var_1 = [int(var_6) for var_6 in input().split()]\n var_4 = 3**var_2\n var_5 = len([var_3 for var_3 in var_1 if var_3 % 2 == 0])\n var_4 -= 2**var_5\n print(var_4)\n\n\nif __name__ == \"__main__\":\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nvar_6 = int(eval(input()))\nvar_2 = list(map(int, input().split()))\nfrom itertools import product\n\nvar_5 = [-1, 0, 1]\nvar_3 = 0\nfor var_7 in product(var_5, repeat=var_6):\n var_1 = []\n for var_4 in range(var_6):\n var_1.append(var_7[var_4] + var_2[var_4])\n if any(var_8 % 2 == 0 for var_8 in var_1):\n var_3 += 1\nprint(var_3)\n```", "output": "SLOWER 9.3238", "pair_id": "python_p03568_reversed", "problem_id": "p03568", "language": "python", "direction": "reversed", "speedup_ratio": 640.828} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\n\nvar_10 = sys.stdin.readline\nvar_2, var_3 = list(map(int, var_10().split()))\nvar_1 = [list(map(int, var_10().split())) for _ in range(var_2)]\nvar_8 = [[0 for _ in range(var_2 + 1)] for _ in range(var_3 + 1)]\n\nvar_13 = [[0 for _ in range(var_2 + 1)] for _ in range(var_3 + 1)]\nfor var_11 in range(var_2):\n var_4, var_6 = var_1[var_11]\n for var_15 in range(var_3):\n if var_4 > var_15:\n var_8[var_15][var_11 + 1] = var_8[var_15][var_11]\n var_13[var_15][var_11 + 1] = var_15\n else:\n if var_6 + var_8[var_15 - var_4][var_11] >= var_8[var_15][var_11]:\n var_8[var_15][var_11 + 1] = var_8[var_15 - var_4][var_11] + var_6\n var_13[var_15][var_11 + 1] = var_15 - var_4\n else:\n var_8[var_15][var_11 + 1] = var_8[var_15][var_11]\n var_13[var_15][var_11 + 1] = var_15\nvar_5 = var_8[var_3 - 1][var_2]\nvar_14 = [False] * var_2\nvar_7 = var_3 - 1\nfor var_9 in reversed(list(range(var_2))):\n if var_13[var_7][var_9 + 1] == var_7 - var_1[var_9][0]:\n var_14[var_9] = True\n var_7 = var_13[var_7][var_9 + 1]\nvar_12 = 0\nfor var_9 in range(var_2):\n if not var_14[var_9] and var_1[var_9][1] > var_12:\n var_12 = var_1[var_9][1]\nprint((var_5 + var_12))\n```\n\n=== Code B (Modified) ===\n```python\nfrom collections import Counter, defaultdict, deque\nfrom heapq import heappop, heappush, heapify\nimport sys, bisect, math, itertools, fractions, pprint\n\nsys.setrecursionlimit(10**8)\nvar_6 = 10**9 + 7\nvar_1 = float(\"inf\")\n\n\ndef func_1():\n return int(sys.stdin.readline())\n\n\ndef func_2():\n return list(map(int, sys.stdin.readline().split()))\n\n\nvar_7, var_9 = func_2()\nvar_13 = [func_2() for _ in range(var_7)]\nvar_13.sort(key=lambda var_14: var_14[1], reverse=True)\nvar_8 = 0\nvar_10 = min(var_7, 5)\nfor var_3 in range(var_10):\n var_2 = [[0] * (var_9 + 5) for _ in range(var_7 + 5)]\n for var_4 in range(var_7):\n var_12, var_11 = var_13[var_4]\n for var_5 in range(var_9):\n if var_5 < var_12 or var_3 == var_4:\n var_2[var_4 + 1][var_5] = var_2[var_4][var_5]\n else:\n var_2[var_4 + 1][var_5] = max(\n var_2[var_4][var_5], var_2[var_4][var_5 - var_12] + var_11\n )\n\n var_8 = max(var_2[var_7][var_9 - 1] + var_13[var_3][1], var_8)\nprint(var_8)\n```", "output": "SLOWER 1.1545", "pair_id": "python_p02863_reversed", "problem_id": "p02863", "language": "python", "direction": "reversed", "speedup_ratio": 2.226} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport math\n\nvar_1, var_2 = input().split()\nvar_1 = int(var_1)\nvar_3 = int(var_2[0] + var_2[2] + var_2[3])\nprint((int(var_1 * var_3) // 100))\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\nimport math\nfrom collections import defaultdict\nfrom bisect import bisect_left, bisect_right\n\nsys.setrecursionlimit(10**7)\n\n\ndef func_4():\n return sys.stdin.readline()[:-1]\n\n\nvar_4 = 10**9 + 7\n\n\ndef func_1():\n return int(eval(func_4()))\n\n\ndef func_2():\n return list(map(int, func_4().split()))\n\n\ndef func_3(var_6, var_3):\n if var_6 <= 0:\n return [[] for _ in range(var_3)]\n elif var_3 == 1:\n return [func_1() for _ in range(var_6)]\n else:\n var_5 = [func_2() for _ in range(var_6)]\n return list(map(list, list(zip(*var_5))))\n\n\nfrom decimal import getcontext, Decimal\n\ngetcontext().prec = 28\nvar_1, var_2 = list(map(str, func_4().split()))\nvar_1 = int(var_1)\nvar_2 = Decimal(var_2)\nprint((int(var_1 * var_2)))\n```", "output": "SLOWER 2.2596", "pair_id": "python_p02659_reversed", "problem_id": "p02659", "language": "python", "direction": "reversed", "speedup_ratio": 4.7885} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\n\"\"\"\"\"\"\n\nfrom collections import deque\n\n\ndef func_1():\n var_5, *var_1 = list(map(int, open(0).read().split()))\n var_2 = var_1[1::2]\n var_4 = [[] for _ in range(var_5 + 1)]\n for var_7, var_8 in zip(*[iter(var_1)] * 2):\n var_4[var_7].append(var_8)\n var_6 = deque([1])\n var_3 = [0] * (var_5 + 1)\n while var_6:\n var_11 = var_6.popleft()\n var_9 = 0\n for var_10 in var_4[var_11]:\n var_9 += 1 + (var_9 + 1 == var_3[var_11])\n var_3[var_10] = var_9\n var_6.append(var_10)\n print((max(var_3)))\n for var_8 in var_2:\n print((var_3[var_8]))\n\n\nfunc_1()\n```\n\n=== Code B (Modified) ===\n```python\nvar_11 = int(eval(input()))\nvar_12 = {var_8: [] for var_8 in range(1, var_11 + 1)}\nvar_19 = [False for var_8 in range(var_11 + 1)]\nvar_16 = []\nfor _ in range(var_11 - 1):\n var_2, var_3 = list(map(int, input().split()))\n var_12[var_2].append(var_3)\n var_12[var_3].append(var_2)\n var_16.append((var_2, var_3))\nvar_9 = var_16[0][0]\nvar_19[var_9] = True\nvar_6 = []\nvar_7 = []\nvar_14 = {var_8: {} for var_8 in range(1, var_11 + 1)}\nvar_10 = [0 for var_8 in range(var_11 + 1)]\n\nvar_4 = 1\nfor var_5 in var_12[var_9]:\n var_19[var_5] = True\n var_14[var_9][var_5] = var_4\n var_14[var_5][var_9] = var_4\n var_10[var_5] = var_4\n var_4 += 1\n var_6.append(var_5)\nwhile var_6:\n for var_15 in var_6:\n var_13 = 1\n for var_5 in var_12[var_15]:\n if var_19[var_5] == False:\n var_19[var_5] = True\n if var_13 != var_10[var_15]:\n var_14[var_15][var_5] = var_13\n var_14[var_5][var_15] = var_13\n var_10[var_5] = var_13\n var_13 += 1\n var_7.append(var_5)\n else:\n var_13 += 1\n var_14[var_15][var_5] = var_13\n var_14[var_5][var_15] = var_13\n var_10[var_5] = var_13\n var_13 += 1\n var_7.append(var_5)\n if var_7:\n var_6 = var_7\n var_7 = []\n else:\n var_6 = []\n var_7 = []\nvar_1 = 0\nfor var_8 in range(1, var_11 + 1):\n var_1 = max(var_1, len(var_12[var_8]))\nprint(var_1)\nfor var_8 in range(var_11 - 1):\n var_17, var_18 = var_16[var_8][0], var_16[var_8][1]\n print((var_14[var_17][var_18]))\n```", "output": "SLOWER 1.0109", "pair_id": "python_p02850_reversed", "problem_id": "p02850", "language": "python", "direction": "reversed", "speedup_ratio": 2.0151} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_4 = str(var_4)\n if var_4[0] == var_4[-1] and var_4[1] == var_4[-2]:\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n if str(var_4) == \"\".join(reversed(str(var_4))):\n var_3 += 1\nprint(var_3)\n```", "output": "SLOWER 1.26", "pair_id": "python_p03416_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 2.3949} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_3 = list(map(int, input().split()))\nvar_2 = 0\nfor var_5 in range(var_3 + 1)[var_1:]:\n if len(str(var_5)) % 2 == 0:\n var_6 = list(str(var_5))[: len(str(var_5)) // 2]\n var_7 = list(reversed(list(str(var_5))[len(str(var_5)) // 2 :]))\n if var_6 == var_7:\n var_2 += 1\n else:\n var_8 = list(str(var_5))[: len(str(var_5)) // 2 + 1]\n var_4 = list(reversed(list(str(var_5))[len(str(var_5)) // 2 :]))\n if var_8 == var_4:\n var_2 += 1\nprint(var_2)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_8 in range(var_1, var_2 + 1):\n var_7 = str(var_8)\n var_6 = len(var_7)\n var_4 = True\n for var_5 in range(var_6 // 2):\n if var_7[var_5] != var_7[var_6 - 1 - var_5]:\n var_4 = False\n break\n if var_4:\n var_3 += 1\nprint(var_3)\n```", "output": "FASTER 1.3483", "pair_id": "python_p03416_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 2.5461} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_6 in range(var_1, var_2 + 1):\n var_3 = str(var_6)\n var_5 = True\n for var_7 in range(len(var_3) // 2):\n if var_3[var_7] != var_3[-var_7 - 1] and var_5:\n var_5 = not var_5\n if var_5:\n var_4 += 1\nprint(var_4)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_4 = str(var_4)\n if var_4[0] == var_4[-1] and var_4[1] == var_4[-2]:\n var_3 += 1\nprint(var_3)\n```", "output": "FASTER 1.6437", "pair_id": "python_p03416_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 3.1246} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport math\n\nvar_1, var_4 = (int(var_10) for var_10 in input().split())\nvar_2 = math.ceil(var_1 / 0.08)\nvar_3 = math.ceil((var_1 + 1) / 0.08)\n\"\"\"\"\"\"\nvar_5 = math.ceil(var_4 / 0.1)\nvar_6 = math.ceil((var_4 + 1) / 0.1)\n\"\"\"\"\"\"\nvar_7 = list(range(var_2, var_3))\nvar_8 = list(range(var_5, var_6))\nvar_9 = set(var_7) & set(var_8)\nif len(var_9) == 0:\n print((-1))\nelse:\n print((min(var_9)))\n```\n\n=== Code B (Modified) ===\n```python\nfrom math import floor\n\nvar_1, var_2 = list(map(int, input().split()))\n\n\nfor var_3 in range(1010):\n if (floor(var_3 * 0.08) == var_1) and (floor(var_3 * 0.1) == var_2):\n\n print(var_3)\n quit()\n\n\nprint((-1))\n```", "output": "SLOWER 1.1204", "pair_id": "python_p02755_reversed", "problem_id": "p02755", "language": "python", "direction": "reversed", "speedup_ratio": 2.1741} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\nfrom collections import Counter\n\n\ndef func_10():\n return sys.stdin.readline().strip()\n\n\ndef func_11(var_12, var_13, var_14):\n return [[var_14] * var_13 for var_17 in range(var_12)]\n\n\ndef func_12(var_12, var_13, var_14, var_15):\n return [[[var_15] * var_14 for var_18 in range(var_13)] for var_17 in range(var_12)]\n\n\ndef func_13(var_12, var_13, var_14, var_15, var_16):\n return [\n [[[var_16] * var_15 for var_18 in range(var_14)] for var_18 in range(var_13)]\n for var_17 in range(var_12)\n ]\n\n\ndef func_8(var_22, var_23=1):\n return int(-(-var_22 // var_23))\n\n\ndef func_1():\n return int(eval(func_10()))\n\n\ndef func_3():\n return list(map(int, func_10().split()))\n\n\ndef func_2(var_11=None):\n return list(func_3()) if var_11 is None else [func_1() for var_17 in range(var_11)]\n\n\ndef func_7():\n print(\"Yes\")\n\n\ndef func_5():\n print(\"No\")\n\n\ndef func_6():\n print(\"YES\")\n\n\ndef func_4():\n print(\"NO\")\n\n\nsys.setrecursionlimit(10**9)\nvar_5 = 10**18\nvar_10 = 10**9 + 7\n\n\ndef func_9(var_1, var_2):\n \"\"\"\"\"\"\n import numpy as np\n from numpy.fft import rfft, irfft\n\n var_8 = max(var_1)\n var_9 = max(var_2)\n var_3 = [0] * (var_8 + 1)\n var_4 = [0] * (var_9 + 1)\n for var_12 in var_1:\n var_3[var_12] += 1\n for var_13 in var_2:\n var_4[var_13] += 1\n\n var_6 = 1\n var_19 = 0\n while var_6 <= var_8 + var_9:\n var_19 += 1\n var_6 = 2**var_19\n\n var_21 = irfft(rfft(var_3, var_6) * rfft(var_4, var_6), var_6)\n\n var_21 = np.rint(var_21).astype(np.int64)\n return var_21\n\n\nvar_11, var_7, var_6 = func_3()\nvar_1 = func_2()\nvar_2 = func_2()\nvar_21 = list(func_9(var_1, var_2))\nvar_20 = var_5\nfor var_17, var_12 in enumerate(var_21):\n if var_12 != 0:\n var_20 = var_17\n break\nfor _ in range(var_6):\n var_22, var_23, var_14 = func_3()\n var_22 -= 1\n var_23 -= 1\n var_20 = min(var_20, var_1[var_22] + var_2[var_23] - var_14)\nprint(var_20)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_3, var_8 = list(map(int, input().split()))\nvar_2 = list(map(int, input().split()))\nvar_4 = list(map(int, input().split()))\nvar_7 = min(var_2) + min(var_4)\nvar_9 = [0] * var_8\nvar_10 = [0] * var_8\nvar_5 = [0] * var_8\nfor var_6 in range(var_8):\n var_9[var_6], var_10[var_6], var_5[var_6] = list(map(int, input().split()))\n var_9[var_6] -= 1\n var_10[var_6] -= 1\nfor var_6 in range(var_8):\n var_7 = min(var_7, var_2[var_9[var_6]] + var_4[var_10[var_6]] - var_5[var_6])\nprint(var_7)\n```", "output": "FASTER 2.762", "pair_id": "python_p02748_forward", "problem_id": "p02748", "language": "python", "direction": "forward", "speedup_ratio": 6.7835} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_4, var_3 = list(map(int, input().split()))\nvar_1 = 0\nfor var_2 in range(var_4, var_3 + 1):\n if str(var_2)[0] + str(var_2)[1] == str(var_2)[-1] + str(var_2)[-2]:\n var_1 += 1\nprint(var_1)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_6 = str(var_4)\n var_5 = var_6[::-1]\n if var_6 == var_5:\n var_3 += 1\nprint(var_3)\n```", "output": "FASTER 1.0907", "pair_id": "python_p03416_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 2.1298} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = str(var_4)\n if var_5[0] == var_5[4] and var_5[1] == var_5[3]:\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n if list(str(var_4)) == list(reversed(str(var_4))):\n var_3 += 1\nprint(var_3)\n```", "output": "SLOWER 1.6665", "pair_id": "python_p03416_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 3.1745} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_4 = {}\nvar_5 = 0\nfor var_6 in range(10000, 100000):\n var_3 = list(str(var_6))\n if var_3 == list(reversed(var_3)):\n var_5 += 1\n var_4[var_6] = var_5\nvar_1, var_2 = list(map(int, input().split()))\nprint((var_4[var_2] - var_4[var_1 - 1] if var_1 > 10000 else var_4[var_2]))\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_5 in range(var_1, var_2 + 1):\n var_3 = str(var_5)\n if var_3[0] == var_3[-1] and var_3[1] == var_3[-2]:\n var_4 += 1\nprint(var_4)\n```", "output": "FASTER 3.6652", "pair_id": "python_p03416_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 12.6861} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport math\nimport string\n\n\ndef func_4():\n return list(map(int, input().split()))\n\n\ndef func_3(var_6, var_7):\n return math.factorial(var_6) // (\n math.factorial(var_6 - var_7) * math.factorial(var_7)\n )\n\n\ndef func_2(var_9):\n var_8 = []\n for var_5 in var_9:\n if not (var_5 in var_8):\n var_8.append(var_5)\n return len(var_9) != len(var_8)\n\n\ndef func_1(var_6):\n func_1 = []\n for var_4 in range(1, var_6 + 1):\n if var_6 % var_4 == 0:\n func_1.append(var_4)\n return func_1\n\n\nvar_2 = [-1, -1, -1, 0, 0, 1, 1, 1]\nvar_3 = [-1, 0, 1, -1, 1, -1, 0, 1]\nvar_6 = int(eval(input()))\nvar_1 = func_4()\nvar_10 = 1\nfor var_4 in range(len(var_1)):\n if var_1[var_4] % 2 == 0:\n var_10 *= 2\n else:\n var_10 *= 1\nprint((3 ** len(var_1) - var_10))\n```\n\n=== Code B (Modified) ===\n```python\ndef func_1():\n var_2 = int(input())\n var_1 = [int(var_6) for var_6 in input().split()]\n if var_2 == 1:\n return print(1 if var_1[0] % 2 == 0 else 2)\n var_3 = 0\n var_5 = (-1, 0, 1)\n from itertools import product\n\n for var_6 in product(range(3), repeat=var_2):\n var_4 = 1\n for var_7 in range(var_2):\n var_4 *= var_1[var_7] + var_5[var_6[var_7]]\n if var_4 % 2 == 0:\n var_3 += 1\n print(var_3)\n\n\nif __name__ == \"__main__\":\n func_1()\n```", "output": "SLOWER 6.869", "pair_id": "python_p03568_reversed", "problem_id": "p03568", "language": "python", "direction": "reversed", "speedup_ratio": 116.8901} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_5 = input()[::-1]\nvar_2 = [0] * 2019\nvar_2[0] = 1\nvar_4 = 0\nvar_6 = 1\nvar_1 = 0\nfor var_3 in var_5:\n var_4 = (var_4 + int(var_3) * var_6) % 2019\n var_6 = var_6 * 10 % 2019\n var_2[var_4] += 1\nfor var_3 in var_2:\n var_1 += var_3 * (var_3 - 1) // 2\nprint(var_1)\n```\n\n=== Code B (Modified) ===\n```python\nfrom collections import Counter\n\nvar_1 = input()[::-1]\nvar_5 = [0]\nvar_4 = 0\nvar_6 = 2019\nfor var_7 in var_1:\n var_8 = int(var_7) * pow(10, var_4, var_6) % var_6\n var_8 = var_5[-1] + var_8\n var_5.append(var_8 % var_6)\n var_4 += 1\nvar_3 = Counter(var_5)\nvar_2 = sum(var_9 * (var_9 - 1) // 2 for var_9 in list(var_3.values()))\nprint(var_2)\n```", "output": "FASTER 1.9367", "pair_id": "python_p02702_forward", "problem_id": "p02702", "language": "python", "direction": "forward", "speedup_ratio": 3.8282} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_8, var_9 = list(map(int, input().split()))\nvar_5 = [[0] * (var_9 + 3001) for _ in range(var_8 + 1)]\nvar_3 = 0\nvar_2 = [list(map(int, input().split())) for _ in range(var_8)]\nvar_2.sort()\nfor var_6 in range(1, var_8 + 1):\n var_1, var_4 = var_2[var_6 - 1]\n for var_7 in range(var_9):\n var_5[var_6][var_7] = max(var_5[var_6 - 1][var_7], var_5[var_6][var_7])\n var_5[var_6][var_7 + var_1] = var_5[var_6 - 1][var_7] + var_4\n var_3 = max(var_5[var_6][var_7], var_5[var_6][var_7 + var_1], var_3)\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\ndef func_1():\n var_2, var_3, *var_1 = list(map(int, open(0).read().split()))\n var_4 = [0] * (var_3 + max(var_1[::2]))\n for var_7, var_6 in sorted(zip(*[iter(var_1)] * 2)):\n for var_5 in reversed(list(range(var_3))):\n var_4[var_5 + var_7] = max(var_4[var_5 + var_7], var_4[var_5] + var_6)\n print((max(var_4)))\n\n\nfunc_1()\n```", "output": "FASTER 1.8091", "pair_id": "python_p02863_forward", "problem_id": "p02863", "language": "python", "direction": "forward", "speedup_ratio": 3.5042} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1 = list(map(int, input().split()))\nvar_2 = 0\nfor var_3 in range(var_1[0], var_1[1] + 1):\n var_4 = str(var_3)\n if var_4[0] == var_4[4] and var_4[1] == var_4[3]:\n var_2 += 1\nprint(var_2)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_5 in range(10):\n for var_6 in range(10):\n for var_7 in range(10):\n var_3 = 10000 * var_5 + 1000 * var_6 + 100 * var_7 + 10 * var_6 + var_5\n if var_1 <= var_3 <= var_2:\n var_4 += 1\nprint(var_4)\n```", "output": "FASTER 3.5367", "pair_id": "python_p03416_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 11.6056} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(str, input().split()))\nvar_1 = int(var_1)\nvar_2 = int(float(var_2) * 1000)\nprint((var_1 * var_2 // 1000))\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\nimport math\nfrom collections import defaultdict\nfrom bisect import bisect_left, bisect_right\n\nsys.setrecursionlimit(10**7)\n\n\ndef func_4():\n return sys.stdin.readline()[:-1]\n\n\nvar_4 = 10**9 + 7\n\n\ndef func_1():\n return int(eval(func_4()))\n\n\ndef func_2():\n return list(map(int, func_4().split()))\n\n\ndef func_3(var_6, var_3):\n if var_6 <= 0:\n return [[] for _ in range(var_3)]\n elif var_3 == 1:\n return [func_1() for _ in range(var_6)]\n else:\n var_5 = [func_2() for _ in range(var_6)]\n return list(map(list, list(zip(*var_5))))\n\n\nvar_1, var_2 = list(map(str, func_4().split()))\nvar_1 = int(var_1)\nvar_2 = 100 * int(var_2[0]) + 10 * int(var_2[2]) + int(var_2[3])\nprint((var_1 * var_2 // 100))\n```", "output": "SLOWER 2.3246", "pair_id": "python_p02659_reversed", "problem_id": "p02659", "language": "python", "direction": "reversed", "speedup_ratio": 5.0091} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nfrom sys import stdin\n\n\ndef func_1():\n\n var_11 = stdin.readline\n var_2 = int(var_11())\n var_1 = []\n for var_6 in range(var_2):\n var_5 = int(\"\".join(var_11().strip().split(\" \")), 2)\n var_1.append(var_5)\n var_3 = []\n for var_6 in range(var_2):\n var_10 = list(map(int, var_11().split()))\n var_3.append(var_10)\n var_8 = float(\"-inf\")\n for var_9 in range(1, 1 << 10):\n var_12 = 0\n for var_7 in range(var_2):\n var_4 = bin(var_9 & var_1[var_7]).count(\"1\")\n var_12 += var_3[var_7][var_4]\n var_8 = max(var_12, var_8)\n print(var_8)\n\n\nif __name__ == \"__main__\":\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\nimport numpy as np\n\nvar_6 = int(eval(input()))\n\nvar_1 = [input().replace(\" \", \"\") for var_4 in range(var_6)]\n\nvar_7 = [list(map(int, input().split())) for var_4 in range(var_6)]\nvar_11 = -999999999999999\nfor var_4 in range(1, 1024):\n var_3 = format(var_4, \"010b\")\n var_9 = 0\n for var_2, var_8 in zip(var_1, var_7):\n var_10 = 0\n for var_5 in range(10):\n if var_2[var_5] == \"1\" and var_3[var_5] == \"1\":\n var_10 += 1\n var_9 += var_8[var_10]\n if var_9 > var_11:\n if var_9 == 0:\n print((str(var_4)))\n break\n var_11 = var_9\nprint(var_11)\n```", "output": "SLOWER 2.3748", "pair_id": "python_p03503_reversed", "problem_id": "p03503", "language": "python", "direction": "reversed", "speedup_ratio": 5.1868} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\n\nsys.setrecursionlimit(2147483647)\nvar_2 = float(\"inf\")\nvar_3 = 10**9 + 7\nvar_10 = lambda: sys.stdin.readline().rstrip()\n\n\ndef func_1():\n var_11, var_4 = list(map(int, var_10().split()))\n var_1 = [tuple(map(int, var_10().split())) for _ in range(var_11)]\n var_1.sort()\n var_8 = [0] * var_4\n var_6 = -var_2\n for var_9 in range(var_11):\n var_5, var_7 = var_1[var_9]\n var_12 = var_8[:]\n for var_13 in range(var_4):\n if var_13 + var_5 < var_4:\n var_12[var_13 + var_5] = max(\n var_12[var_13 + var_5], var_8[var_13] + var_7\n )\n else:\n var_6 = max(var_6, var_8[var_13] + var_7)\n var_8 = var_12\n print((max(var_6, max(var_8))))\n\n\nfunc_1()\n```\n\n=== Code B (Modified) ===\n```python\nfrom collections import Counter, defaultdict, deque\nfrom heapq import heappop, heappush, heapify\nimport sys, bisect, math, itertools, fractions, pprint\n\nsys.setrecursionlimit(10**8)\nvar_6 = 10**9 + 7\nvar_1 = float(\"inf\")\n\n\ndef func_1():\n return int(sys.stdin.readline())\n\n\ndef func_2():\n return list(map(int, sys.stdin.readline().split()))\n\n\nvar_8, var_11 = func_2()\nvar_17 = [func_2() for _ in range(var_8)]\nvar_10 = var_17[::-1]\nvar_14 = [[0] * var_11 for _ in range(var_8)]\nvar_3 = [[0] * var_11 for _ in range(var_8)]\nfor var_4 in range(var_8 - 1):\n var_16, var_15 = var_17[var_4]\n for var_5 in range(var_11):\n if var_5 < var_16:\n var_14[var_4 + 1][var_5] = var_14[var_4][var_5]\n else:\n var_14[var_4 + 1][var_5] = max(\n var_14[var_4][var_5], var_14[var_4][var_5 - var_16] + var_15\n )\nvar_9 = var_14[var_8 - 1][var_11 - 1] + var_17[var_8 - 1][1]\nfor var_4 in range(var_8 - 1):\n var_16, var_15 = var_10[var_4]\n for var_5 in range(var_11):\n if var_5 < var_16:\n var_3[var_4 + 1][var_5] = var_3[var_4][var_5]\n else:\n var_3[var_4 + 1][var_5] = max(\n var_3[var_4][var_5], var_3[var_4][var_5 - var_16] + var_15\n )\n var_9 = max(var_9, var_3[var_8 - 1][var_11 - 1] + var_17[0][1])\n\nfor var_4 in range(1, var_8 - 1):\n var_13 = var_4\n var_2 = var_8 - var_4 - 1\n var_7 = 0\n for var_5 in range(var_11):\n var_12 = var_14[var_13][var_5] + var_3[var_2][var_11 - 1 - var_5]\n var_7 = max(var_7, var_12)\n var_9 = max(var_9, var_7 + var_17[var_4][1])\nprint(var_9)\n```", "output": "SLOWER 2.0401", "pair_id": "python_p02863_reversed", "problem_id": "p02863", "language": "python", "direction": "reversed", "speedup_ratio": 4.1128} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\n\nvar_9 = sys.stdin.readline\nfrom operator import itemgetter\n\nvar_3, var_4 = list(map(int, var_9().split()))\nvar_1 = [list(map(int, var_9().split())) for _ in range(var_3)]\nvar_1.sort(key=itemgetter(0))\nvar_8 = [[0 for _ in range(var_3 + 1)] for _ in range(var_4 + 1)]\n\nvar_2 = []\nfor var_10 in range(var_3):\n var_5, var_7 = var_1[var_10]\n for var_11 in range(var_4):\n if var_5 > var_11:\n var_8[var_11][var_10 + 1] = var_8[var_11][var_10]\n else:\n if var_7 + var_8[var_11 - var_5][var_10] >= var_8[var_11][var_10]:\n var_8[var_11][var_10 + 1] = var_8[var_11 - var_5][var_10] + var_7\n else:\n var_8[var_11][var_10 + 1] = var_8[var_11][var_10]\n var_2.append(var_8[var_4 - 1][var_10] + var_7)\nvar_6 = max(var_2)\nprint(var_6)\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\nfrom operator import itemgetter\nfrom heapq import heapify, heappop, heappush\n\nvar_1 = int(10e15)\nvar_2 = -var_1\nvar_11 = 1000000007\nsys.setrecursionlimit(1000000)\n\n\ndef func_2():\n return list(map(int, input().split()))\n\n\ndef func_4():\n return input().split()\n\n\ndef func_1():\n return int(sys.stdin.readline())\n\n\ndef func_3():\n return eval(input())\n\n\nvar_3, var_4 = func_2()\nvar_5 = [func_2() for var_9 in range(var_3)]\nvar_5.sort(key=itemgetter(0))\n\nvar_8 = [[0] * (var_4 + 1 + 3000 + 1) for _ in range(var_3 + 1)]\nvar_6 = 0\nfor var_9 in range(var_3):\n for var_10 in range(var_4 + 1 + 3000 + 1):\n var_12, var_7 = var_5[var_9]\n if 0 <= var_10 - var_12 < var_4:\n var_8[var_9 + 1][var_10] = max(\n var_8[var_9][var_10], var_8[var_9][var_10 - var_12] + var_7\n )\n else:\n var_8[var_9 + 1][var_10] = var_8[var_9][var_10]\n var_6 = max(var_6, var_8[var_9 + 1][var_10])\nprint(var_6)\n```", "output": "SLOWER 4.8389", "pair_id": "python_p02863_reversed", "problem_id": "p02863", "language": "python", "direction": "reversed", "speedup_ratio": 28.619} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().rstrip().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = list(map(int, list(str(var_4))))\n if var_5[0] == var_5[4] and var_5[1] == var_5[3]:\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = str(var_4)\n if var_5[0] == var_5[4] and var_5[1] == var_5[3]:\n var_3 += 1\nprint(var_3)\n```", "output": "FASTER 1.9492", "pair_id": "python_p03416_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 3.8615} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_3 = list(map(int, input().split()))\nvar_2 = 0\nfor var_5 in range(var_3 + 1)[var_1:]:\n if len(str(var_5)) % 2 == 0:\n var_6 = list(str(var_5))[: len(str(var_5)) // 2]\n var_7 = list(reversed(list(str(var_5))[len(str(var_5)) // 2 :]))\n if var_6 == var_7:\n var_2 += 1\n else:\n var_8 = list(str(var_5))[: len(str(var_5)) // 2 + 1]\n var_4 = list(reversed(list(str(var_5))[len(str(var_5)) // 2 :]))\n if var_8 == var_4:\n var_2 += 1\nprint(var_2)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_7 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_3 = True\n var_8 = str(var_4)\n var_6 = len(var_8)\n for var_5 in range(var_6 // 2 + 1):\n if var_8[var_5] != var_8[-var_5 - 1]:\n var_3 = False\n break\n if var_3:\n var_7 += 1\nprint(var_7)\n```", "output": "FASTER 1.3494", "pair_id": "python_p03416_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 2.5481} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\n\nsys.setrecursionlimit(2147483647)\nvar_2 = float(\"inf\")\nvar_3 = 10**9 + 7\nvar_10 = lambda: sys.stdin.readline().rstrip()\n\n\ndef func_1():\n var_11, var_4 = list(map(int, var_10().split()))\n var_1 = [tuple(map(int, var_10().split())) for _ in range(var_11)]\n var_1.sort()\n var_8 = [0] * var_4\n var_6 = -var_2\n for var_9 in range(var_11):\n var_5, var_7 = var_1[var_9]\n var_12 = var_8[:]\n for var_13 in range(var_4):\n if var_13 + var_5 < var_4:\n var_12[var_13 + var_5] = max(\n var_12[var_13 + var_5], var_8[var_13] + var_7\n )\n else:\n var_6 = max(var_6, var_8[var_13] + var_7)\n var_8 = var_12\n print((max(var_6, max(var_8))))\n\n\nfunc_1()\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_6 = sorted([list(map(int, input().split())) for var_5 in range(var_1)])\n\nvar_4 = [[0] * (var_2 + 1) for var_5 in range(var_1 + 1)]\n\nfor var_5 in range(var_1):\n var_9, var_8 = var_6[var_5]\n for var_7 in range(var_2 + 1):\n if var_7 + var_9 <= var_2:\n var_4[var_5 + 1][var_7 + var_9] = max(\n var_4[var_5 + 1][var_7 + var_9], var_4[var_5][var_7] + var_8\n )\n var_4[var_5 + 1][var_7] = max(var_4[var_5][var_7], var_4[var_5 + 1][var_7])\nvar_3 = 0\nfor var_5, (var_9, var_8) in enumerate(var_6):\n var_3 = max(var_3, var_4[var_5][var_2 - 1] + var_8)\nprint(var_3)\n```", "output": "SLOWER 1.4447", "pair_id": "python_p02863_reversed", "problem_id": "p02863", "language": "python", "direction": "reversed", "speedup_ratio": 2.722} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\n\n\ndef func_1(var_5):\n var_4 = 0\n for var_3 in range(1, var_5 + 1):\n if str(var_3) == str(var_3)[::-1]:\n var_4 += 1\n return var_4\n\n\nprint((func_1(var_2) - func_1(var_1 - 1)))\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_4 = str(var_4)\n if var_4 == var_4[::-1]:\n var_3 += 1\nprint(var_3)\n```", "output": "FASTER 1.4436", "pair_id": "python_p03416_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 2.72} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = [0] * (var_2 + 1)\nfor var_3 in range(1, var_2 + 1):\n if str(var_3) == str(var_3)[::-1]:\n var_4[var_3] = var_4[var_3 - 1] + 1\n else:\n var_4[var_3] = var_4[var_3 - 1]\nprint((var_4[var_2] - var_4[var_1 - 1]))\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = input().split()\nvar_1 = int(var_1)\nvar_2 = int(var_2)\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = list(str(var_4))\n if (var_5[0] == var_5[4]) and (var_5[1] == var_5[3]):\n var_3 = var_3 + 1\nprint(var_3)\n```", "output": "FASTER 1.5379", "pair_id": "python_p03416_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 2.9038} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\n\nvar_3 = sys.stdin.readline\nvar_1, var_2 = var_3().split()\nvar_1 = int(var_1)\nvar_2 = int(float(var_2) * 100 + 0.5)\nprint((var_1 * var_2 // 100))\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\nimport math\nfrom collections import defaultdict\nfrom bisect import bisect_left, bisect_right\n\nsys.setrecursionlimit(10**7)\n\n\ndef func_4():\n return sys.stdin.readline()[:-1]\n\n\nvar_4 = 10**9 + 7\n\n\ndef func_1():\n return int(eval(func_4()))\n\n\ndef func_2():\n return list(map(int, func_4().split()))\n\n\ndef func_3(var_6, var_3):\n if var_6 <= 0:\n return [[] for _ in range(var_3)]\n elif var_3 == 1:\n return [func_1() for _ in range(var_6)]\n else:\n var_5 = [func_2() for _ in range(var_6)]\n return list(map(list, list(zip(*var_5))))\n\n\nvar_1, var_2 = list(map(str, func_4().split()))\nvar_1 = int(var_1)\nvar_2 = 100 * int(var_2[0]) + 10 * int(var_2[2]) + int(var_2[3])\nprint((var_1 * var_2 // 100))\n```", "output": "SLOWER 2.3093", "pair_id": "python_p02659_reversed", "problem_id": "p02659", "language": "python", "direction": "reversed", "speedup_ratio": 4.9565} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\n\nvar_20 = sys.stdin.read\nvar_21 = sys.stdin.readline\nvar_22 = sys.stdin.readlines\nsys.setrecursionlimit(10**9)\nvar_2 = 1 << 60\nvar_5 = 1000000007\n\n\nvar_4 = 1000001\n\n\nclass Class_1:\n def __init__(self, var_13, var_19, var_12):\n self.l = var_13\n self.r = var_19\n self.idx = var_12\n\n\ndef func_4(var_12, var_24, var_10, var_15):\n while var_12 <= var_15:\n var_10[var_12] += var_24\n var_12 += var_12 & -var_12\n\n\ndef func_3(var_12, var_10, var_15):\n var_23 = 0\n while var_12:\n var_23 += var_10[var_12]\n var_12 -= var_12 & -var_12\n return var_23\n\n\ndef func_1(var_9, var_15, var_17, var_16):\n\n var_10 = [0] * (var_15 + 1)\n\n var_14 = [-1] * var_4\n\n var_8 = [0] * var_16\n var_18 = 0\n for var_11 in range(var_15):\n\n if var_14[var_9[var_11]] != -1:\n func_4(var_14[var_9[var_11]] + 1, -1, var_10, var_15)\n\n var_14[var_9[var_11]] = var_11\n func_4(var_11 + 1, 1, var_10, var_15)\n\n while var_18 < var_16 and var_17[var_18].r == var_11:\n var_8[var_17[var_18].idx] = func_3(\n var_17[var_18].r + 1, var_10, var_15\n ) - func_3(var_17[var_18].l, var_10, var_15)\n var_18 += 1\n\n for var_11 in range(var_16):\n print((var_8[var_11]))\n\n\ndef func_2():\n var_6, var_7 = list(map(int, var_21().split()))\n var_1 = list(map(int, var_21().split()))\n (*var_3,) = list(map(int, var_20().split()))\n var_17 = [0] * var_7\n for var_11, (var_13, var_19) in enumerate(zip(*[iter(var_3)] * 2)):\n var_17[var_11] = Class_1(var_13 - 1, var_19 - 1, var_11)\n var_17.sort(key=lambda var_25: var_25.r)\n func_1(var_1, var_6, var_17, var_7)\n return\n\n\nif __name__ == \"__main__\":\n func_2()\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\n\nvar_17 = sys.stdin.read\nvar_18 = sys.stdin.readline\nvar_19 = sys.stdin.readlines\nsys.setrecursionlimit(10**9)\nvar_2 = 1 << 60\nvar_4 = 1000000007\n\n\nclass Class_1:\n def __init__(self, var_12):\n self.n = var_12\n self.data = [0] * (var_12 + 1)\n\n def func_1(self, var_10, var_20=1):\n var_10 += 1\n while var_10 <= self.n:\n self.data[var_10] += var_20\n var_10 += var_10 & -var_10\n\n def func_2(self, var_10):\n var_10 += 1\n var_20 = 0\n while var_10 > 0:\n var_20 += self.data[var_10]\n var_10 -= var_10 & -var_10\n return var_20\n\n def func_3(self, var_11, var_16):\n return self.get_sum(var_16 - 1) - self.get_sum(var_11 - 1)\n\n\ndef func_4():\n var_5, var_6 = map(int, var_18().split())\n var_1 = list(map(int, var_18().split()))\n var_3 = map(int, var_17().split())\n var_13 = [-1] * (var_5 + 1)\n var_14 = [[] for _ in range(var_5)]\n for var_10, var_9 in enumerate(var_1):\n if var_13[var_9] != -1:\n var_14[var_13[var_9]].append(var_10)\n var_13[var_9] = var_10\n var_15 = [[] for _ in range(var_5 + 1)]\n for var_10, (var_11, var_16) in enumerate(zip(*[iter(var_3)] * 2)):\n var_11 -= 1\n var_16 -= 1\n var_15[var_11].append((var_16, var_10))\n var_7 = [0] * var_6\n var_8 = Class_1(var_5)\n for var_11 in range(var_5 - 1, -1, -1):\n for var_16 in var_14[var_11]:\n var_8.add(var_16)\n for var_16, var_10 in var_15[var_11]:\n var_7[var_10] = (var_16 - var_11 + 1) - var_8.get_sum(var_16)\n print(*var_7, sep=\"\\n\")\n return\n\n\nif __name__ == \"__main__\":\n func_4()\n```", "output": "FASTER 2.1032", "pair_id": "python_p02599_forward", "problem_id": "p02599", "language": "python", "direction": "forward", "speedup_ratio": 4.2966} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_3 in range(var_1, var_2 + 1):\n var_5 = list(str(var_3))\n var_6 = list(reversed(var_5))\n if var_5 == var_6:\n var_4 += 1\nprint(var_4)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_6 = str(var_4)\n var_5 = var_6[::-1]\n if var_6 == var_5:\n var_3 += 1\nprint(var_3)\n```", "output": "FASTER 1.0582", "pair_id": "python_p03416_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 2.0824} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\ndef func_1():\n from sys import setrecursionlimit, stdin\n from os import environ\n from collections import defaultdict, deque, Counter\n from math import ceil, floor, gcd\n from itertools import accumulate, combinations, combinations_with_replacement\n\n setrecursionlimit(10**6)\n var_7 = (\n (lambda *var_11: print(*var_11))\n if \"TERM_PROGRAM\" in environ\n else lambda *var_12: 0\n )\n var_8 = lambda: stdin.readline().rstrip()\n var_3 = lambda: list(map(int, var_8().split()))\n var_1 = lambda: int(var_8())\n var_4 = 10**9 + 7\n var_2 = 10**9 + 10\n var_9, var_10 = var_8().split()\n var_5 = int(var_9)\n var_6 = int(float(var_10) * 100 + 0.5)\n print(var_5 * var_6 // 100)\n\n\nfunc_1()\n```\n\n=== Code B (Modified) ===\n```python\nimport decimal\n\nvar_1, var_2 = (decimal.Decimal(var_3) for var_3 in input().split())\nprint((int(var_1 * var_2)))\n```", "output": "FASTER 1.9551", "pair_id": "python_p02659_forward", "problem_id": "p02659", "language": "python", "direction": "forward", "speedup_ratio": 3.8775} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\n\nvar_20 = sys.stdin.read\nvar_21 = sys.stdin.readline\nvar_22 = sys.stdin.readlines\nsys.setrecursionlimit(10**9)\nvar_2 = 1 << 60\nvar_5 = 1000000007\n\n\nvar_4 = 1000001\n\n\nclass Class_1:\n def __init__(self, var_13, var_19, var_12):\n self.l = var_13\n self.r = var_19\n self.idx = var_12\n\n\ndef func_4(var_12, var_24, var_10, var_15):\n while var_12 <= var_15:\n var_10[var_12] += var_24\n var_12 += var_12 & -var_12\n\n\ndef func_3(var_12, var_10, var_15):\n var_23 = 0\n while var_12:\n var_23 += var_10[var_12]\n var_12 -= var_12 & -var_12\n return var_23\n\n\ndef func_1(var_9, var_15, var_17, var_16):\n\n var_10 = [0] * (var_15 + 1)\n\n var_14 = [-1] * var_4\n\n var_8 = [0] * var_16\n var_18 = 0\n for var_11 in range(var_15):\n\n if var_14[var_9[var_11]] != -1:\n func_4(var_14[var_9[var_11]] + 1, -1, var_10, var_15)\n\n var_14[var_9[var_11]] = var_11\n func_4(var_11 + 1, 1, var_10, var_15)\n\n while var_18 < var_16 and var_17[var_18].r == var_11:\n var_8[var_17[var_18].idx] = func_3(\n var_17[var_18].r + 1, var_10, var_15\n ) - func_3(var_17[var_18].l, var_10, var_15)\n var_18 += 1\n\n for var_11 in range(var_16):\n print((var_8[var_11]))\n\n\ndef func_2():\n var_6, var_7 = list(map(int, var_21().split()))\n var_1 = list(map(int, var_21().split()))\n (*var_3,) = list(map(int, var_20().split()))\n var_17 = [0] * var_7\n for var_11, (var_13, var_19) in enumerate(zip(*[iter(var_3)] * 2)):\n var_17[var_11] = Class_1(var_13 - 1, var_19 - 1, var_11)\n var_17.sort(key=lambda var_25: var_25.r)\n func_1(var_1, var_6, var_17, var_7)\n return\n\n\nif __name__ == \"__main__\":\n func_2()\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\n\n\ndef func_5():\n return sys.stdin.readline()[:-1]\n\n\ndef func_2():\n return int(eval(func_5()))\n\n\ndef func_3():\n return list(map(int, func_5().split()))\n\n\ndef func_1():\n return list(func_3())\n\n\nvar_11, var_12 = func_3()\nvar_5 = [0] + func_1()\nvar_2 = [func_1() + [var_6] for var_6 in range(var_12)]\nvar_2.sort(key=lambda var_17: var_17[1])\nvar_4 = [0] * (var_12)\nvar_10 = [0 for var_6 in range(var_11 + 1)]\nvar_1 = 2\nwhile var_1 <= var_11:\n var_1 *= 2\nvar_16 = [0] * (2 * var_1)\n\n\ndef func_7(var_8, var_17):\n var_8 += var_1 - 1\n var_16[var_8] = var_17\n while var_8 > 0:\n var_8 = (var_8 - 1) // 2\n var_16[var_8] = var_16[var_8 * 2 + 1] + var_16[var_8 * 2 + 2]\n\n\ndef func_4(var_8, var_17):\n var_8 += var_1 - 1\n while var_8 >= 0:\n var_16[var_8] += var_17\n var_8 = (var_8 - 1) // 2\n\n\ndef func_6(var_9, var_13):\n func_1 = var_9 + var_1 - 1\n var_3 = var_13 + var_1 - 1\n var_14 = 0\n while func_1 <= var_3:\n if var_3 & 1:\n var_14 += var_16[var_3]\n var_3 -= 2\n else:\n var_3 -= 1\n if func_1 & 1:\n func_1 -= 1\n else:\n var_14 += var_16[func_1]\n func_1 >>= 1\n var_3 >>= 1\n return var_14\n\n\nvar_7 = 1\nfor var_9, var_13, var_6 in var_2:\n while var_7 <= var_13:\n var_15 = var_5[var_7]\n func_4(var_10[var_15], -1)\n func_4(var_7, 1)\n var_10[var_15] = var_7\n var_7 += 1\n var_4[var_6] = func_6(var_9, var_13)\nfor var_6 in var_4:\n print(var_6)\n```", "output": "FASTER 2.1494", "pair_id": "python_p02599_forward", "problem_id": "p02599", "language": "python", "direction": "forward", "speedup_ratio": 4.4365} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_4 = {}\nvar_5 = 0\nfor var_6 in range(10000, 100000):\n var_3 = list(str(var_6))\n if var_3 == list(reversed(var_3)):\n var_5 += 1\n var_4[var_6] = var_5\nvar_1, var_2 = list(map(int, input().split()))\nprint((var_4[var_2] - var_4[var_1 - 1] if var_1 > 10000 else var_4[var_2]))\n```\n\n=== Code B (Modified) ===\n```python\nfrom sys import stdin\n\nvar_6 = lambda: list(map(int, stdin.readline().split()))\nvar_5 = lambda: list(map(int, stdin.readline().split()))\nvar_1, var_3 = var_6()\nvar_2 = 0\nfor var_4 in range(var_1, var_3 + 1):\n var_7 = str(var_4)\n if var_7 == var_7[::-1]:\n var_2 += 1\nprint(var_2)\n```", "output": "FASTER 3.5552", "pair_id": "python_p03416_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 11.7549} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = str(var_4)\n if var_5[0] == var_5[4] and var_5[1] == var_5[3]:\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_8 in range(var_1, var_2 + 1):\n var_7 = str(var_8)\n var_6 = len(var_7)\n var_4 = True\n for var_5 in range(var_6 // 2):\n if var_7[var_5] != var_7[var_6 - 1 - var_5]:\n var_4 = False\n break\n if var_4:\n var_3 += 1\nprint(var_3)\n```", "output": "SLOWER 1.3924", "pair_id": "python_p03416_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 2.6251} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_5 in range(var_1, var_2 + 1):\n var_3 = str(var_5)\n if var_3[0] == var_3[-1] and var_3[1] == var_3[-2]:\n var_4 += 1\nprint(var_4)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = list(str(var_4))\n if var_5 == list(reversed(var_5)):\n var_3 += 1\nprint(var_3)\n```", "output": "SLOWER 1.3238", "pair_id": "python_p03416_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 2.5032} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_3 in range(var_1, var_2 + 1):\n var_5 = list(str(var_3))\n var_6 = list(reversed(var_5))\n if var_5 == var_6:\n var_4 += 1\nprint(var_4)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().strip().split(\" \")))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n if str(var_4) == str(var_4)[::-1]:\n var_3 += 1\nprint(var_3)\n```", "output": "FASTER 1.0014", "pair_id": "python_p03416_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 2.0019} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_7 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_3 = True\n var_8 = str(var_4)\n var_6 = len(var_8)\n for var_5 in range(var_6 // 2 + 1):\n if var_8[var_5] != var_8[-var_5 - 1]:\n var_3 = False\n break\n if var_3:\n var_7 += 1\nprint(var_7)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_4 = str(var_4)\n if var_4[0] == var_4[-1] and var_4[1] == var_4[-2]:\n var_3 += 1\nprint(var_3)\n```", "output": "FASTER 1.3088", "pair_id": "python_p03416_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 2.4774} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().rstrip().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = list(map(int, list(str(var_4))))\n if var_5[0] == var_5[4] and var_5[1] == var_5[3]:\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nfrom sys import stdin\n\nvar_6 = lambda: list(map(int, stdin.readline().split()))\nvar_5 = lambda: list(map(int, stdin.readline().split()))\nvar_1, var_3 = var_6()\nvar_2 = 0\nfor var_4 in range(var_1, var_3 + 1):\n var_7 = str(var_4)\n if var_7 == var_7[::-1]:\n var_2 += 1\nprint(var_2)\n```", "output": "FASTER 1.6646", "pair_id": "python_p03416_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 3.1703} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_3 = list(map(int, input().split()))\nvar_2 = 0\nfor var_5 in range(var_3 + 1)[var_1:]:\n if len(str(var_5)) % 2 == 0:\n var_6 = list(str(var_5))[: len(str(var_5)) // 2]\n var_7 = list(reversed(list(str(var_5))[len(str(var_5)) // 2 :]))\n if var_6 == var_7:\n var_2 += 1\n else:\n var_8 = list(str(var_5))[: len(str(var_5)) // 2 + 1]\n var_4 = list(reversed(list(str(var_5))[len(str(var_5)) // 2 :]))\n if var_8 == var_4:\n var_2 += 1\nprint(var_2)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n if list(str(var_4)) == list(reversed(str(var_4))):\n var_3 += 1\nprint(var_3)\n```", "output": "FASTER 1.0742", "pair_id": "python_p03416_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 2.1055} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_3 in range(var_1, var_2 + 1):\n var_5 = list(str(var_3))\n var_6 = list(reversed(var_5))\n if var_5 == var_6:\n var_4 += 1\nprint(var_4)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_4 = str(var_4)\n if var_4[0] == var_4[-1] and var_4[1] == var_4[-2]:\n var_3 += 1\nprint(var_3)\n```", "output": "FASTER 1.4924", "pair_id": "python_p03416_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 2.8135} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\n\nvar_8 = sys.stdin.readline\n\n\ndef func_1():\n var_2 = int(eval(var_8()))\n var_1 = [int(var_8().replace(\" \", \"\"), 2) for _ in range(var_2)]\n var_3 = [list(map(int, var_8().split())) for _ in range(var_2)]\n var_4 = -(10**7) * var_2\n for var_7 in range(1, 1 << 10):\n var_10 = 0\n for var_9, var_6 in enumerate(var_1):\n var_5 = bin(var_7 & var_6).count(\"1\")\n var_10 += var_3[var_9][var_5]\n var_4 = max(var_4, var_10)\n print(var_4)\n\n\nif __name__ == \"__main__\":\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\n\nvar_7 = sys.stdin.readline\nfrom itertools import combinations\n\n\ndef func_3(var_10):\n for _ in range(var_10):\n yield list(map(int, var_7().split()))\n\n\ndef func_1(var_9, var_5, var_11):\n var_3 = sum(1 if var_5[var_8] == 1 else 0 for var_8 in var_9)\n return var_11[var_3]\n\n\ndef func_2():\n var_10 = int(eval(var_7()))\n var_1 = list(func_3(var_10))\n var_2 = list(func_3(var_10))\n for var_6 in range(1, 11):\n for var_4 in combinations(list(range(10)), var_6):\n yield sum(\n func_1(var_4, var_5, var_11) for var_5, var_11 in zip(var_1, var_2)\n )\n\n\nprint((max(func_2())))\n```", "output": "SLOWER 1.6626", "pair_id": "python_p03503_reversed", "problem_id": "p03503", "language": "python", "direction": "reversed", "speedup_ratio": 3.1659} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nfrom collections import Counter, defaultdict, deque\nfrom heapq import heappop, heappush, heapify\nimport sys, bisect, math, itertools, fractions, pprint\n\nsys.setrecursionlimit(10**8)\nvar_6 = 10**9 + 7\nvar_1 = float(\"inf\")\n\n\ndef func_1():\n return int(sys.stdin.readline())\n\n\ndef func_2():\n return list(map(int, sys.stdin.readline().split()))\n\n\nvar_7, var_9 = func_2()\nvar_13 = [func_2() for _ in range(var_7)]\nvar_13.sort(key=lambda var_14: var_14[1], reverse=True)\nvar_8 = 0\nvar_10 = min(var_7, 5)\nfor var_3 in range(var_10):\n var_2 = [[0] * (var_9 + 5) for _ in range(var_7 + 5)]\n for var_4 in range(var_7):\n var_12, var_11 = var_13[var_4]\n for var_5 in range(var_9):\n if var_5 < var_12 or var_3 == var_4:\n var_2[var_4 + 1][var_5] = var_2[var_4][var_5]\n else:\n var_2[var_4 + 1][var_5] = max(\n var_2[var_4][var_5], var_2[var_4][var_5 - var_12] + var_11\n )\n\n var_8 = max(var_2[var_7][var_9 - 1] + var_13[var_3][1], var_8)\nprint(var_8)\n```\n\n=== Code B (Modified) ===\n```python\nimport bisect\nimport sys\n\nsys.setrecursionlimit(10**6)\nvar_16 = sys.stdout.write\nvar_7 = lambda *var_14: print(*var_14) if var_1 else 0\nvar_1 = True\n\n\ndef func_1(var_9=sys.stdin.readline):\n var_11 = lambda: var_9().rstrip()\n var_3 = lambda: list(map(int, var_11().split()))\n var_2 = lambda: int(var_11())\n var_4 = lambda var_17: [var_3() for _ in range(var_17)]\n var_13, var_15 = var_3()\n var_5 = var_4(var_13)\n var_5.sort()\n var_8 = [[0] * var_15 for _ in range(var_13 + 1)]\n for var_10 in range(1, var_13 + 1):\n for var_12 in range(1, var_15):\n if var_12 < var_5[var_10 - 1][0]:\n var_8[var_10][var_12] = var_8[var_10 - 1][var_12]\n else:\n var_8[var_10][var_12] = max(\n var_8[var_10 - 1][var_12],\n var_8[var_10 - 1][var_12 - var_5[var_10 - 1][0]]\n + var_5[var_10 - 1][1],\n )\n var_6 = 0\n for var_10 in range(var_13):\n var_6 = max(var_6, var_8[var_10][var_15 - 1] + var_5[var_10][1])\n print(var_6)\n\n\nif __name__ == \"__main__\":\n func_1()\n```", "output": "FASTER 2.0434", "pair_id": "python_p02863_forward", "problem_id": "p02863", "language": "python", "direction": "forward", "speedup_ratio": 4.1221} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nfrom fractions import Fraction\n\nvar_1, var_2 = input().split()\n\n\nfrom decimal import *\n\nvar_4 = var_3(var_1)\nvar_6 = var_3(var_2)\nvar_7().prec = 28\nvar_5 = var_4 * var_6\nprint((int(var_5)))\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\nimport math\nfrom collections import defaultdict\nfrom bisect import bisect_left, bisect_right\n\nsys.setrecursionlimit(10**7)\n\n\ndef func_4():\n return sys.stdin.readline()[:-1]\n\n\nvar_4 = 10**9 + 7\n\n\ndef func_1():\n return int(eval(func_4()))\n\n\ndef func_2():\n return list(map(int, func_4().split()))\n\n\ndef func_3(var_6, var_3):\n if var_6 <= 0:\n return [[] for _ in range(var_3)]\n elif var_3 == 1:\n return [func_1() for _ in range(var_6)]\n else:\n var_5 = [func_2() for _ in range(var_6)]\n return list(map(list, list(zip(*var_5))))\n\n\nfrom decimal import getcontext, Decimal\n\ngetcontext().prec = 28\nvar_1, var_2 = list(map(str, func_4().split()))\nvar_1 = int(var_1)\nvar_2 = Decimal(var_2)\nprint((int(var_1 * var_2)))\n```", "output": "SLOWER 1.9011", "pair_id": "python_p02659_reversed", "problem_id": "p02659", "language": "python", "direction": "reversed", "speedup_ratio": 3.7349} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1 = list(map(int, input().split()))\nvar_2 = 0\nfor var_3 in range(var_1[0], var_1[1] + 1):\n var_4 = str(var_3)\n if var_4[0] == var_4[4] and var_4[1] == var_4[3]:\n var_2 += 1\nprint(var_2)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_8 in range(var_1, var_2 + 1):\n var_7 = str(var_8)\n var_6 = len(var_7)\n var_4 = True\n for var_5 in range(var_6 // 2):\n if var_7[var_5] != var_7[var_6 - 1 - var_5]:\n var_4 = False\n break\n if var_4:\n var_3 += 1\nprint(var_3)\n```", "output": "SLOWER 1.4151", "pair_id": "python_p03416_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 2.6667} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_6, var_7 = list(map(int, input().split()))\nvar_1 = [list(map(int, input().split())) for _ in range(var_6)]\nvar_1.sort()\nvar_3 = [(6007) * [0] for _ in range(var_6 + 1)]\nvar_3[0][0] = 0\nvar_2 = 0\nfor var_4 in range(var_6):\n for var_5 in range(6007):\n var_3[var_4 + 1][var_5] = max(var_3[var_4 + 1][var_5], var_3[var_4][var_5])\n if var_5 < var_7:\n var_3[var_4 + 1][var_5 + var_1[var_4][0]] = max(\n var_3[var_4][var_5] + var_1[var_4][1],\n var_3[var_4][var_5 + var_1[var_4][0]],\n )\n var_2 = max(var_2, var_3[var_4 + 1][var_5])\nprint(var_2)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_6 = sorted([list(map(int, input().split())) for var_5 in range(var_1)])\n\nvar_4 = [[0] * (var_2 + 1) for var_5 in range(var_1 + 1)]\n\nfor var_5 in range(var_1):\n var_9, var_8 = var_6[var_5]\n for var_7 in range(var_2 + 1):\n if var_7 + var_9 <= var_2:\n var_4[var_5 + 1][var_7 + var_9] = max(\n var_4[var_5 + 1][var_7 + var_9], var_4[var_5][var_7] + var_8\n )\n var_4[var_5 + 1][var_7] = max(var_4[var_5][var_7], var_4[var_5 + 1][var_7])\nvar_3 = 0\nfor var_5, (var_9, var_8) in enumerate(var_6):\n var_3 = max(var_3, var_4[var_5][var_2 - 1] + var_8)\nprint(var_3)\n```", "output": "FASTER 5.3151", "pair_id": "python_p02863_forward", "problem_id": "p02863", "language": "python", "direction": "forward", "speedup_ratio": 39.8117} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\n\nvar_8 = sys.stdin.readline\nvar_9 = int(eval(var_8()))\nvar_6 = []\nfor var_7 in range(var_9 - 1):\n var_1, var_3 = list(map(int, var_8().split()))\n var_6.append([var_1 - 1, var_3 - 1, var_7])\nvar_6.sort()\nvar_13 = [0] * (var_9)\nvar_2 = [0] * (var_9 - 1)\nvar_10 = 1\nvar_11 = 0\nfor var_5 in var_6:\n _from, var_12, var_7 = var_5\n if _from != var_11:\n var_10 = 1\n if var_13[_from] == var_10:\n var_10 += 1\n var_2[var_7] = var_10\n var_13[var_12] = var_10\n var_10 += 1\n var_11 = _from\nprint((max(var_2)))\nfor var_4 in var_2:\n print(var_4)\n```\n\n=== Code B (Modified) ===\n```python\nvar_11 = int(eval(input()))\nvar_12 = {var_8: [] for var_8 in range(1, var_11 + 1)}\nvar_19 = [False for var_8 in range(var_11 + 1)]\nvar_16 = []\nfor _ in range(var_11 - 1):\n var_2, var_3 = list(map(int, input().split()))\n var_12[var_2].append(var_3)\n var_12[var_3].append(var_2)\n var_16.append((var_2, var_3))\nvar_9 = var_16[0][0]\nvar_19[var_9] = True\nvar_6 = []\nvar_7 = []\nvar_14 = {var_8: {} for var_8 in range(1, var_11 + 1)}\nvar_10 = [0 for var_8 in range(var_11 + 1)]\n\nvar_4 = 1\nfor var_5 in var_12[var_9]:\n var_19[var_5] = True\n var_14[var_9][var_5] = var_4\n var_14[var_5][var_9] = var_4\n var_10[var_5] = var_4\n var_4 += 1\n var_6.append(var_5)\nwhile var_6:\n for var_15 in var_6:\n var_13 = 1\n for var_5 in var_12[var_15]:\n if var_19[var_5] == False:\n var_19[var_5] = True\n if var_13 != var_10[var_15]:\n var_14[var_15][var_5] = var_13\n var_14[var_5][var_15] = var_13\n var_10[var_5] = var_13\n var_13 += 1\n var_7.append(var_5)\n else:\n var_13 += 1\n var_14[var_15][var_5] = var_13\n var_14[var_5][var_15] = var_13\n var_10[var_5] = var_13\n var_13 += 1\n var_7.append(var_5)\n if var_7:\n var_6 = var_7\n var_7 = []\n else:\n var_6 = []\n var_7 = []\nvar_1 = 0\nfor var_8 in range(1, var_11 + 1):\n var_1 = max(var_1, len(var_12[var_8]))\nprint(var_1)\nfor var_8 in range(var_11 - 1):\n var_17, var_18 = var_16[var_8][0], var_16[var_8][1]\n print((var_14[var_17][var_18]))\n```", "output": "SLOWER 1.2377", "pair_id": "python_p02850_reversed", "problem_id": "p02850", "language": "python", "direction": "reversed", "speedup_ratio": 2.3582} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = input().split()\nvar_1 = int(var_1)\nvar_2 = int(var_2)\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = list(str(var_4))\n if (var_5[0] == var_5[4]) and (var_5[1] == var_5[3]):\n var_3 = var_3 + 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = [\n var_3 for var_3 in map(str, list(range(var_1, var_2 + 1))) if var_3 == var_3[::-1]\n]\nprint((len(var_4)))\n```", "output": "FASTER 1.1029", "pair_id": "python_p03416_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 2.1478} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport decimal\n\n\ndef func_1():\n var_1, var_2 = list(map(decimal.Decimal, input().split()))\n print((var_1 * var_2 // 1))\n\n\nif __name__ == \"__main__\":\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\ndef func_1():\n from sys import setrecursionlimit, stdin\n from os import environ\n from collections import defaultdict, deque, Counter\n from math import ceil, floor, gcd\n from itertools import accumulate, combinations, combinations_with_replacement\n\n setrecursionlimit(10**6)\n var_7 = (\n (lambda *var_11: print(*var_11))\n if \"TERM_PROGRAM\" in environ\n else lambda *var_12: 0\n )\n var_8 = lambda: stdin.readline().rstrip()\n var_3 = lambda: list(map(int, var_8().split()))\n var_1 = lambda: int(var_8())\n var_4 = 10**9 + 7\n var_2 = 10**9 + 10\n var_9, var_10 = var_8().split()\n var_5 = int(var_9)\n var_6 = int(float(var_10) * 100 + 0.5)\n print(var_5 * var_6 // 100)\n\n\nfunc_1()\n```", "output": "SLOWER 1.7718", "pair_id": "python_p02659_reversed", "problem_id": "p02659", "language": "python", "direction": "reversed", "speedup_ratio": 3.4148} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\n\nvar_5 = sys.stdin.readline\nif __name__ == \"__main__\":\n var_1, var_3 = var_5().split()\n var_2 = int(var_1)\n var_4 = round(float(var_3) * 100)\n print((var_2 * var_4 // 100))\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\nimport math\nfrom collections import defaultdict\nfrom bisect import bisect_left, bisect_right\n\nsys.setrecursionlimit(10**7)\n\n\ndef func_4():\n return sys.stdin.readline()[:-1]\n\n\nvar_4 = 10**9 + 7\n\n\ndef func_1():\n return int(eval(func_4()))\n\n\ndef func_2():\n return list(map(int, func_4().split()))\n\n\ndef func_3(var_6, var_3):\n if var_6 <= 0:\n return [[] for _ in range(var_3)]\n elif var_3 == 1:\n return [func_1() for _ in range(var_6)]\n else:\n var_5 = [func_2() for _ in range(var_6)]\n return list(map(list, list(zip(*var_5))))\n\n\nfrom decimal import getcontext, Decimal\n\ngetcontext().prec = 28\nvar_1, var_2 = list(map(str, func_4().split()))\nvar_1 = int(var_1)\nvar_2 = Decimal(var_2)\nprint((int(var_1 * var_2)))\n```", "output": "SLOWER 2.0198", "pair_id": "python_p02659_reversed", "problem_id": "p02659", "language": "python", "direction": "reversed", "speedup_ratio": 4.0552} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nfrom sys import stdin\n\nvar_6 = lambda: list(map(int, stdin.readline().split()))\nvar_5 = lambda: list(map(int, stdin.readline().split()))\nvar_1, var_3 = var_6()\nvar_2 = 0\nfor var_4 in range(var_1, var_3 + 1):\n var_7 = str(var_4)\n if var_7 == var_7[::-1]:\n var_2 += 1\nprint(var_2)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_3 in range(var_1, var_2 + 1):\n var_5 = list(str(var_3))\n var_6 = list(reversed(var_5))\n if var_5 == var_6:\n var_4 += 1\nprint(var_4)\n```", "output": "SLOWER 1.2902", "pair_id": "python_p03416_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 2.4457} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_3 in range(var_1, var_2 + 1):\n var_5 = list(str(var_3))\n var_6 = list(reversed(var_5))\n if var_5 == var_6:\n var_4 += 1\nprint(var_4)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_5 in range(var_1, var_2 + 1):\n var_3 = str(var_5)\n if var_3[0] == var_3[-1] and var_3[1] == var_3[-2]:\n var_4 += 1\nprint(var_4)\n```", "output": "FASTER 1.4002", "pair_id": "python_p03416_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 2.6394} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\n\nvar_20 = sys.stdin.read\nvar_21 = sys.stdin.readline\nvar_22 = sys.stdin.readlines\nsys.setrecursionlimit(10**9)\nvar_2 = 1 << 60\nvar_5 = 1000000007\n\n\nvar_4 = 1000001\n\n\nclass Class_1:\n def __init__(self, var_13, var_19, var_12):\n self.l = var_13\n self.r = var_19\n self.idx = var_12\n\n\ndef func_4(var_12, var_24, var_10, var_15):\n while var_12 <= var_15:\n var_10[var_12] += var_24\n var_12 += var_12 & -var_12\n\n\ndef func_3(var_12, var_10, var_15):\n var_23 = 0\n while var_12:\n var_23 += var_10[var_12]\n var_12 -= var_12 & -var_12\n return var_23\n\n\ndef func_1(var_9, var_15, var_17, var_16):\n\n var_10 = [0] * (var_15 + 1)\n\n var_14 = [-1] * var_4\n\n var_8 = [0] * var_16\n var_18 = 0\n for var_11 in range(var_15):\n\n if var_14[var_9[var_11]] != -1:\n func_4(var_14[var_9[var_11]] + 1, -1, var_10, var_15)\n\n var_14[var_9[var_11]] = var_11\n func_4(var_11 + 1, 1, var_10, var_15)\n\n while var_18 < var_16 and var_17[var_18].r == var_11:\n var_8[var_17[var_18].idx] = func_3(\n var_17[var_18].r + 1, var_10, var_15\n ) - func_3(var_17[var_18].l, var_10, var_15)\n var_18 += 1\n\n for var_11 in range(var_16):\n print((var_8[var_11]))\n\n\ndef func_2():\n var_6, var_7 = list(map(int, var_21().split()))\n var_1 = list(map(int, var_21().split()))\n (*var_3,) = list(map(int, var_20().split()))\n var_17 = [0] * var_7\n for var_11, (var_13, var_19) in enumerate(zip(*[iter(var_3)] * 2)):\n var_17[var_11] = Class_1(var_13 - 1, var_19 - 1, var_11)\n var_17.sort(key=lambda var_25: var_25.r)\n func_1(var_1, var_6, var_17, var_7)\n return\n\n\nif __name__ == \"__main__\":\n func_2()\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\n\n\nclass Class_1:\n \"\"\"\"\"\"\n\n def __init__(self, var_1):\n self.__n = len(var_1)\n self.__node = [0] * (self.__n + 1)\n self.__data = [0] * (self.__n + 1)\n var_7 = [0] * (self.__n + 1)\n for var_11 in range(self.__n):\n var_7[var_11 + 1] = var_7[var_11] + var_1[var_11]\n for var_11 in range(1, self.__n + 1):\n self.__data[var_11] = var_1[var_11 - 1]\n self.__node[var_11] = var_7[var_11] - var_7[var_11 - (var_11 & -var_11)]\n\n def func_1(self, var_11, var_22):\n self.__data[var_11] += var_22\n while var_11 <= self.__n:\n self.__node[var_11] += var_22\n var_11 += var_11 & -var_11\n\n def func_4(self, var_11):\n \"\"\"\"\"\"\n var_19 = 0\n while var_11 > 0:\n var_19 += self.__node[var_11]\n var_11 -= var_11 & -var_11\n return var_19\n\n def func_2(self, var_11, var_12):\n \"\"\"\"\"\"\n if var_11 == var_12:\n return self.__data[var_11]\n else:\n return self.sum(var_12) - self.sum(var_11 - 1)\n\n\ndef func_3():\n var_4, var_6 = map(int, input().split())\n var_3 = list(map(int, input().split()))\n var_5 = [[] for _ in range(var_4)]\n for var_11, var_9 in enumerate(var_3):\n var_5[var_9 - 1].append(var_11)\n var_18 = [0] * var_4\n for var_14 in var_5:\n if len(var_14):\n var_18[var_14.pop()] = 1\n var_2 = Class_1(var_18)\n var_16 = [[] for _ in range(var_4)]\n for var_11, var_20 in enumerate(sys.stdin.readlines()):\n var_13, var_17 = map(int, var_20.split())\n var_16[var_17 - 1].append((var_13 - 1, var_11))\n var_8 = [None] * var_6\n var_10 = var_4 - 1\n for var_17, var_15 in enumerate(reversed(var_16)):\n var_17 = (var_4 - 1) - var_17\n while var_15:\n var_13, var_11 = var_15.pop()\n while var_17 < var_10:\n var_9 = var_3[var_10] - 1\n var_14 = var_5[var_9]\n if len(var_14):\n var_2.add(var_14.pop() + 1, 1)\n var_10 -= 1\n var_21 = var_2.get(var_13 + 1, var_17 + 1)\n var_8[var_11] = var_21\n print(*var_8, sep=\"\\n\")\n\n\nif __name__ == \"__main__\":\n func_3()\n```", "output": "FASTER 1.7958", "pair_id": "python_p02599_forward", "problem_id": "p02599", "language": "python", "direction": "forward", "speedup_ratio": 3.472} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nfrom collections import Counter, defaultdict, deque\nfrom heapq import heappop, heappush, heapify\nimport sys, bisect, math, itertools, fractions, pprint\n\nsys.setrecursionlimit(10**8)\nvar_6 = 10**9 + 7\nvar_1 = float(\"inf\")\n\n\ndef func_1():\n return int(sys.stdin.readline())\n\n\ndef func_2():\n return list(map(int, sys.stdin.readline().split()))\n\n\nvar_8, var_11 = func_2()\nvar_17 = [func_2() for _ in range(var_8)]\nvar_10 = var_17[::-1]\nvar_14 = [[0] * var_11 for _ in range(var_8)]\nvar_3 = [[0] * var_11 for _ in range(var_8)]\nfor var_4 in range(var_8 - 1):\n var_16, var_15 = var_17[var_4]\n for var_5 in range(var_11):\n if var_5 < var_16:\n var_14[var_4 + 1][var_5] = var_14[var_4][var_5]\n else:\n var_14[var_4 + 1][var_5] = max(\n var_14[var_4][var_5], var_14[var_4][var_5 - var_16] + var_15\n )\nvar_9 = var_14[var_8 - 1][var_11 - 1] + var_17[var_8 - 1][1]\nfor var_4 in range(var_8 - 1):\n var_16, var_15 = var_10[var_4]\n for var_5 in range(var_11):\n if var_5 < var_16:\n var_3[var_4 + 1][var_5] = var_3[var_4][var_5]\n else:\n var_3[var_4 + 1][var_5] = max(\n var_3[var_4][var_5], var_3[var_4][var_5 - var_16] + var_15\n )\n var_9 = max(var_9, var_3[var_8 - 1][var_11 - 1] + var_17[0][1])\n\nfor var_4 in range(1, var_8 - 1):\n var_13 = var_4\n var_2 = var_8 - var_4 - 1\n var_7 = 0\n for var_5 in range(var_11):\n var_12 = var_14[var_13][var_5] + var_3[var_2][var_11 - 1 - var_5]\n var_7 = max(var_7, var_12)\n var_9 = max(var_9, var_7 + var_17[var_4][1])\nprint(var_9)\n```\n\n=== Code B (Modified) ===\n```python\nfrom sys import stdin\n\n\ndef func_1():\n\n var_9 = stdin.readline\n var_8, var_10 = list(map(int, var_9().split()))\n var_7 = [list(map(int, var_9().split())) for _ in range(var_8)]\n var_7.sort()\n var_1 = [0] * var_8\n var_2 = [0] * var_8\n for var_4 in range(var_8):\n var_1[var_4], var_2[var_4] = var_7[var_4][0], var_7[var_4][1]\n\n var_5 = -(10**9)\n var_3 = [[var_5] * (var_10 + 1) for _ in range(var_8 + 1)]\n var_3[0][0] = 0\n for var_4 in range(var_8):\n for var_6 in range(var_10 + 1):\n\n if var_6 != var_10:\n var_3[var_4 + 1][min(var_10, var_6 + var_1[var_4])] = max(\n var_3[var_4 + 1][min(var_10, var_6 + var_1[var_4])],\n var_3[var_4][var_6] + var_2[var_4],\n )\n\n var_3[var_4 + 1][var_6] = max(var_3[var_4 + 1][var_6], var_3[var_4][var_6])\n print((max(var_3[var_8])))\n\n\nif __name__ == \"__main__\":\n func_1()\n```", "output": "FASTER 1.1031", "pair_id": "python_p02863_forward", "problem_id": "p02863", "language": "python", "direction": "forward", "speedup_ratio": 2.1481} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_2 = int(eval(input()))\nvar_3 = [int(eval(input())) for var_1 in range(var_2)]\nprint((sum(var_3) - max(var_3) // 2))\n```\n\n=== Code B (Modified) ===\n```python\nimport copy\nimport random\nimport bisect\nimport fractions\nimport math\nimport sys\nimport collections\nfrom decimal import Decimal\n\nvar_5 = 10**9 + 7\nsys.setrecursionlimit(var_5)\nvar_3 = collections.deque()\n\n\ndef func_1():\n return list(map(int, sys.stdin.readline().split()))\n\n\nvar_1 = int(eval(input()))\nvar_6 = [0 for var_4 in range(var_1)]\nfor var_4 in range(var_1):\n var_6[var_4] = int(eval(input()))\nvar_6.sort()\nvar_2 = sum(var_6)\nvar_2 -= var_6[-1] // 2\nprint(var_2)\n```", "output": "SLOWER 1.0159", "pair_id": "python_p03207_reversed", "problem_id": "p03207", "language": "python", "direction": "reversed", "speedup_ratio": 2.0221} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_6 = sorted([list(map(int, input().split())) for var_5 in range(var_1)])\n\nvar_4 = [[0] * (var_2 + 1) for var_5 in range(var_1 + 1)]\n\nfor var_5 in range(var_1):\n var_9, var_8 = var_6[var_5]\n for var_7 in range(var_2 + 1):\n if var_7 + var_9 <= var_2:\n var_4[var_5 + 1][var_7 + var_9] = max(\n var_4[var_5 + 1][var_7 + var_9], var_4[var_5][var_7] + var_8\n )\n var_4[var_5 + 1][var_7] = max(var_4[var_5][var_7], var_4[var_5 + 1][var_7])\nvar_3 = 0\nfor var_5, (var_9, var_8) in enumerate(var_6):\n for var_7 in range(var_2):\n var_3 = max(var_3, var_4[var_5][var_7] + var_8)\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_2, var_3, *var_1 = list(map(int, open(0).read().split()))\nvar_4 = [0] * (var_3 + max(var_1[::2]))\nfor var_7, var_6 in sorted(zip(*[iter(var_1)] * 2)):\n for var_5 in reversed(list(range(var_3))):\n var_4[var_5 + var_7] = max(var_4[var_5 + var_7], var_4[var_5] + var_6)\nprint((max(var_4)))\n```", "output": "FASTER 1.3487", "pair_id": "python_p02863_forward", "problem_id": "p02863", "language": "python", "direction": "forward", "speedup_ratio": 2.5469} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_6, var_7 = list(map(int, input().split()))\nvar_1 = [list(map(int, input().split())) for _ in range(var_6)]\nvar_1.sort()\nvar_3 = [(6007) * [0] for _ in range(var_6 + 1)]\nvar_3[0][0] = 0\nvar_2 = 0\nfor var_4 in range(var_6):\n for var_5 in range(6007):\n var_3[var_4 + 1][var_5] = max(var_3[var_4 + 1][var_5], var_3[var_4][var_5])\n if var_5 < var_7:\n var_3[var_4 + 1][var_5 + var_1[var_4][0]] = max(\n var_3[var_4][var_5] + var_1[var_4][1],\n var_3[var_4][var_5 + var_1[var_4][0]],\n )\n var_2 = max(var_2, var_3[var_4 + 1][var_5])\nprint(var_2)\n```\n\n=== Code B (Modified) ===\n```python\nfrom collections import Counter, defaultdict, deque\nfrom heapq import heappop, heappush, heapify\nimport sys, bisect, math, itertools, fractions, pprint\n\nsys.setrecursionlimit(10**8)\nvar_6 = 10**9 + 7\nvar_1 = float(\"inf\")\n\n\ndef func_1():\n return int(sys.stdin.readline())\n\n\ndef func_2():\n return list(map(int, sys.stdin.readline().split()))\n\n\nvar_8, var_11 = func_2()\nvar_17 = [func_2() for _ in range(var_8)]\nvar_10 = var_17[::-1]\nvar_14 = [[0] * var_11 for _ in range(var_8)]\nvar_3 = [[0] * var_11 for _ in range(var_8)]\nfor var_4 in range(var_8 - 1):\n var_16, var_15 = var_17[var_4]\n for var_5 in range(var_11):\n if var_5 < var_16:\n var_14[var_4 + 1][var_5] = var_14[var_4][var_5]\n else:\n var_14[var_4 + 1][var_5] = max(\n var_14[var_4][var_5], var_14[var_4][var_5 - var_16] + var_15\n )\nvar_9 = var_14[var_8 - 1][var_11 - 1] + var_17[var_8 - 1][1]\nfor var_4 in range(var_8 - 1):\n var_16, var_15 = var_10[var_4]\n for var_5 in range(var_11):\n if var_5 < var_16:\n var_3[var_4 + 1][var_5] = var_3[var_4][var_5]\n else:\n var_3[var_4 + 1][var_5] = max(\n var_3[var_4][var_5], var_3[var_4][var_5 - var_16] + var_15\n )\n var_9 = max(var_9, var_3[var_8 - 1][var_11 - 1] + var_17[0][1])\n\nfor var_4 in range(1, var_8 - 1):\n var_13 = var_4\n var_2 = var_8 - var_4 - 1\n var_7 = 0\n for var_5 in range(var_11):\n var_12 = var_14[var_13][var_5] + var_3[var_2][var_11 - 1 - var_5]\n var_7 = max(var_7, var_12)\n var_9 = max(var_9, var_7 + var_17[var_4][1])\nprint(var_9)\n```", "output": "FASTER 4.7197", "pair_id": "python_p02863_forward", "problem_id": "p02863", "language": "python", "direction": "forward", "speedup_ratio": 26.3491} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_2 = int(eval(input()))\n(*var_1,) = list(map(int, input().split()))\nvar_5 = 0\nfor var_3 in var_1:\n if var_3 % 2 == 0:\n var_5 += 1\nvar_4 = 3**var_2 - 2**var_5\nprint(var_4)\n```\n\n=== Code B (Modified) ===\n```python\nimport math\nimport string\n\n\ndef func_5():\n return list(map(int, input().split()))\n\n\ndef func_4(var_7, var_8):\n return math.factorial(var_7) // (\n math.factorial(var_7 - var_8) * math.factorial(var_8)\n )\n\n\ndef func_3(var_10):\n var_9 = []\n for var_5 in var_10:\n if not (var_5 in var_9):\n var_9.append(var_5)\n return len(var_10) != len(var_9)\n\n\ndef func_1(var_7):\n func_1 = []\n for var_4 in range(1, var_7 + 1):\n if var_7 % var_4 == 0:\n func_1.append(var_4)\n return func_1\n\n\nvar_2 = [-1, -1, -1, 0, 0, 1, 1, 1]\nvar_3 = [-1, 0, 1, -1, 1, -1, 0, 1]\nvar_7 = int(eval(input()))\nvar_1 = func_5()\n\n\ndef func_2(var_6):\n if len(var_6) == var_7:\n for var_4 in range(len(var_6)):\n if var_6[var_4] % 2 == 0:\n return 1\n return 0\n return (\n func_2(var_6 + [var_1[len(var_6)]])\n + func_2(var_6 + [var_1[len(var_6)] - 1])\n + func_2(var_6 + [var_1[len(var_6)] + 1])\n )\n\n\nprint((func_2([])))\n```", "output": "SLOWER 7.6454", "pair_id": "python_p03568_reversed", "problem_id": "p03568", "language": "python", "direction": "reversed", "speedup_ratio": 200.2176} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_5 in range(var_1, var_2 + 1):\n var_3 = str(var_5)\n if var_3[0] == var_3[-1] and var_3[1] == var_3[-2]:\n var_4 += 1\nprint(var_4)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_6 in range(var_1, var_2 + 1):\n var_3 = str(var_6)\n var_5 = True\n for var_7 in range(len(var_3) // 2):\n if var_3[var_7] != var_3[-var_7 - 1] and var_5:\n var_5 = not var_5\n if var_5:\n var_4 += 1\nprint(var_4)\n```", "output": "SLOWER 1.5515", "pair_id": "python_p03416_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 2.9313} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport bisect, copy, heapq, math, sys\nfrom collections import *\nfrom functools import lru_cache\nfrom itertools import accumulate, combinations, permutations, product\n\n\ndef func_2():\n return sys.stdin.readline()[:-1]\n\n\ndef func_4(var_8):\n return [0] + list(accumulate(var_8))\n\n\ndef func_1(var_1, var_4):\n return -(-var_1 // var_4)\n\n\nsys.setrecursionlimit(5000000)\nvar_9 = pow(10, 9) + 7\nvar_2 = [chr(ord(\"a\") + var_6) for var_6 in range(26)]\nvar_5 = [[1, 0], [0, 1], [-1, 0], [0, -1]]\nvar_11 = int(eval(func_2()))\n\n\ndef func_3(var_10):\n if var_10 == 1:\n return False\n for var_7 in range(2, int(math.sqrt(var_10)) + 1):\n if var_10 % var_7 == 0:\n return False\n return True\n\n\nvar_3 = var_11\nwhile not func_3(var_3):\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nfrom math import sqrt\n\nvar_2 = int(eval(input()))\n\n\ndef func_1(var_2):\n if var_2 < 2:\n return False\n for var_1 in range(2, int(sqrt(var_2)) + 1):\n if var_2 % var_1 == 0:\n return False\n return True\n\n\nwhile not func_1(var_2):\n var_2 += 1\nprint(var_2)\n```", "output": "FASTER 1.442", "pair_id": "python_p02819_forward", "problem_id": "p02819", "language": "python", "direction": "forward", "speedup_ratio": 2.717} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = str(var_4)\n if var_5[0] == var_5[4] and var_5[1] == var_5[3]:\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n if str(var_4) == \"\".join(reversed(str(var_4))):\n var_3 += 1\nprint(var_3)\n```", "output": "SLOWER 1.3424", "pair_id": "python_p03416_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 2.5357} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport copy\n\nvar_8 = int(eval(input()))\nvar_10 = set([var_6 for var_6 in range(1, 10**5)])\nvar_5 = []\nvar_11 = {}\nvar_9 = []\nfor var_6 in range(var_8 - 1):\n var_1, var_2 = list(map(int, input().split(\" \")))\n var_5.append([var_1, var_2])\n var_11.setdefault(var_1, []).append(var_2)\n var_9.append([])\nvar_9.append([])\nvar_9.append([])\nvar_7 = 0\nfor var_12 in range(1, var_8 + 1):\n var_14 = var_11.get(var_12, [])\n var_3 = 1\n for var_13 in var_14:\n if var_3 in var_9[var_12]:\n var_3 += 1\n else:\n pass\n var_9[var_13].append(var_3)\n if var_3 >= var_7:\n var_7 = var_3\n var_3 += 1\nprint(var_7)\nfor var_4 in var_5:\n print((var_9[var_4[1]][0]))\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\nfrom collections import deque\n\n\ndef func_1():\n var_7 = int(sys.stdin.readline().rstrip())\n var_3 = list(map(int, sys.stdin.read().split()))\n var_3 = list(zip(var_3, var_3))\n var_1 = [[] for _ in range(var_7 + 1)]\n for var_2, var_4 in var_3:\n var_1[var_2].append(var_4)\n var_1[var_4].append(var_2)\n var_10 = deque([1])\n var_9 = [None] * (var_7 + 1)\n var_6 = [0] * (var_7 + 1)\n while var_10:\n var_11 = var_10.popleft()\n var_8 = var_6[var_11]\n var_5 = 1\n for var_12 in var_1[var_11]:\n if var_12 == var_9[var_11]:\n continue\n var_9[var_12] = var_11\n if var_5 == var_8:\n var_5 += 1\n var_6[var_12] = var_5\n var_10.append(var_12)\n var_5 += 1\n print((max(var_6)))\n for var_2, var_4 in var_3:\n if var_2 == var_9[var_4]:\n print((var_6[var_4]))\n else:\n print((var_6[var_2]))\n\n\nif __name__ == \"__main__\":\n func_1()\n```", "output": "FASTER 4.4037", "pair_id": "python_p02850_forward", "problem_id": "p02850", "language": "python", "direction": "forward", "speedup_ratio": 21.1661} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = str(var_4)\n if var_5[0] == var_5[4] and var_5[1] == var_5[3]:\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_3 in range(var_1, var_2 + 1):\n var_5 = list(str(var_3))\n var_6 = list(reversed(var_5))\n if var_5 == var_6:\n var_4 += 1\nprint(var_4)\n```", "output": "SLOWER 1.5748", "pair_id": "python_p03416_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 2.9789} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_5 in range(10):\n for var_6 in range(10):\n for var_7 in range(10):\n var_3 = 10000 * var_5 + 1000 * var_6 + 100 * var_7 + 10 * var_6 + var_5\n if var_1 <= var_3 <= var_2:\n var_4 += 1\nprint(var_4)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\n\n\ndef func_1(var_5, var_6):\n var_4 = 0\n for var_3 in range(var_5, var_6 + 1):\n if str(var_3) == str(var_3)[::-1]:\n var_4 += 1\n return var_4\n\n\nprint((func_1(var_1, var_2)))\n```", "output": "SLOWER 3.5019", "pair_id": "python_p03416_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 11.3289} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\nimport itertools\n\n\ndef func_2(var_4):\n return bin(eval(\"0b\" + str(var_4)))\n\n\ndef func_1():\n var_4 = int(sys.stdin.readline().rstrip())\n var_9 = [\n func_2(\"\".join(str(var_10) for var_10 in sys.stdin.readline().split()))\n for _ in range(var_4)\n ]\n var_8 = [\n [int(var_10) for var_10 in sys.stdin.readline().split()] for _ in range(var_4)\n ]\n var_3 = -(10**10)\n for var_6 in itertools.product(\"01\", repeat=10):\n var_6 = func_2(\"\".join(var_6))\n if var_6 == \"0b0\":\n continue\n var_7 = 0\n for var_2 in range(var_4):\n var_1 = var_9[var_2]\n var_5 = bin(eval(var_1) & eval(var_6)).count(\"1\")\n var_7 += var_8[var_2][var_5]\n var_3 = max(var_3, var_7)\n print(var_3)\n\n\nif __name__ == \"__main__\":\n\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nfrom sys import stdin\n\n\ndef func_1():\n\n var_13 = stdin.readline\n var_2 = int(var_13())\n var_1 = []\n for var_6 in range(var_2):\n var_5 = list(map(int, var_13().split()))\n var_1.append(var_5)\n var_3 = []\n for var_6 in range(var_2):\n var_12 = list(map(int, var_13().split()))\n var_3.append(var_12)\n var_9 = -float(\"inf\")\n for var_6 in range(1 << 10):\n if var_6 == 0:\n continue\n else:\n var_11 = []\n for var_7 in range(10):\n if (var_6 >> var_7) & 1:\n var_11.append(var_7)\n var_10 = [0] * 10\n for var_7 in var_11:\n var_10[var_7] = 1\n var_14 = 0\n for var_7 in range(var_2):\n var_4 = 0\n for var_8 in range(10):\n if var_10[var_8] == 1 and var_1[var_7][var_8] == 1:\n var_4 += 1\n var_14 += var_3[var_7][var_4]\n var_9 = max(var_14, var_9)\n print(var_9)\n\n\nif __name__ == \"__main__\":\n func_1()\n```", "output": "FASTER 3.3644", "pair_id": "python_p03503_forward", "problem_id": "p03503", "language": "python", "direction": "forward", "speedup_ratio": 10.2989} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nfrom sys import stdin\n\n\ndef func_1():\n\n var_9 = stdin.readline\n var_8, var_10 = list(map(int, var_9().split()))\n var_7 = [list(map(int, var_9().split())) for _ in range(var_8)]\n var_7.sort()\n var_1 = [0] * var_8\n var_2 = [0] * var_8\n for var_4 in range(var_8):\n var_1[var_4], var_2[var_4] = var_7[var_4][0], var_7[var_4][1]\n\n var_5 = -float(\"inf\")\n var_3 = [[var_5] * (var_10 + 1) for _ in range(var_8 + 1)]\n var_3[0][0] = 0\n for var_4 in range(var_8):\n for var_6 in range(var_10 + 1):\n\n if var_6 != var_10:\n var_3[var_4 + 1][min(var_10, var_6 + var_1[var_4])] = max(\n var_3[var_4 + 1][min(var_10, var_6 + var_1[var_4])],\n var_3[var_4][var_6] + var_2[var_4],\n )\n\n var_3[var_4 + 1][var_6] = max(var_3[var_4 + 1][var_6], var_3[var_4][var_6])\n print((max(var_3[var_8])))\n\n\nif __name__ == \"__main__\":\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nfrom collections import Counter, defaultdict, deque\nfrom heapq import heappop, heappush, heapify\nimport sys, bisect, math, itertools, fractions, pprint\n\nsys.setrecursionlimit(10**8)\nvar_6 = 10**9 + 7\nvar_1 = float(\"inf\")\n\n\ndef func_1():\n return int(sys.stdin.readline())\n\n\ndef func_2():\n return list(map(int, sys.stdin.readline().split()))\n\n\nvar_7, var_9 = func_2()\nvar_13 = [func_2() for _ in range(var_7)]\nvar_13.sort(key=lambda var_14: var_14[1], reverse=True)\nvar_8 = 0\nvar_10 = min(var_7, 5)\nfor var_3 in range(var_10):\n var_2 = [[0] * (var_9 + 5) for _ in range(var_7 + 5)]\n for var_4 in range(var_7):\n var_12, var_11 = var_13[var_4]\n for var_5 in range(var_9):\n if var_5 < var_12 or var_3 == var_4:\n var_2[var_4 + 1][var_5] = var_2[var_4][var_5]\n else:\n var_2[var_4 + 1][var_5] = max(\n var_2[var_4][var_5], var_2[var_4][var_5 - var_12] + var_11\n )\n\n var_8 = max(var_2[var_7][var_9 - 1] + var_13[var_3][1], var_8)\nprint(var_8)\n```", "output": "SLOWER 1.7184", "pair_id": "python_p02863_reversed", "problem_id": "p02863", "language": "python", "direction": "reversed", "speedup_ratio": 3.2907} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_8 in range(var_1, var_2 + 1):\n var_7 = str(var_8)\n var_6 = len(var_7)\n var_4 = True\n for var_5 in range(var_6 // 2):\n if var_7[var_5] != var_7[var_6 - 1 - var_5]:\n var_4 = False\n break\n if var_4:\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = str(var_4)\n if var_5 == var_5[::-1]:\n var_3 += 1\nprint(var_3)\n```", "output": "FASTER 1.1307", "pair_id": "python_p03416_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 2.1897} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().strip().split(\" \")))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n if str(var_4) == str(var_4)[::-1]:\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\ndef func_1():\n var_1, var_2 = list(map(int, input().rstrip().split()))\n var_3 = 0\n for var_4 in range(var_1, var_2 + 1):\n var_5 = str(var_4)\n if var_5 == var_5[::-1]:\n var_3 += 1\n print(var_3)\n\n\nif __name__ == \"__main__\":\n func_1()\n```", "output": "FASTER 1.0533", "pair_id": "python_p03416_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 2.0752} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = [0] * (var_2 + 1)\nfor var_3 in range(1, var_2 + 1):\n if str(var_3) == str(var_3)[::-1]:\n var_4[var_3] = var_4[var_3 - 1] + 1\n else:\n var_4[var_3] = var_4[var_3 - 1]\nprint((var_4[var_2] - var_4[var_1 - 1]))\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = str(var_4)\n if var_5 == var_5[::-1]:\n var_3 += 1\nprint(var_3)\n```", "output": "FASTER 1.9467", "pair_id": "python_p03416_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 3.855} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = str(var_4)\n if var_5[0] == var_5[4] and var_5[1] == var_5[3]:\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_6 in range(var_1, var_2 + 1):\n var_3 = str(var_6)\n var_5 = True\n for var_7 in range(len(var_3) // 2):\n if var_3[var_7] != var_3[-var_7 - 1] and var_5:\n var_5 = not var_5\n if var_5:\n var_4 += 1\nprint(var_4)\n```", "output": "SLOWER 1.7261", "pair_id": "python_p03416_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 3.3083} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\n\nvar_9 = sys.stdin.readline\nfrom operator import itemgetter\n\nvar_3, var_4 = list(map(int, var_9().split()))\nvar_1 = [list(map(int, var_9().split())) for _ in range(var_3)]\nvar_1.sort(key=itemgetter(0))\nvar_8 = [[0 for _ in range(var_3 + 1)] for _ in range(var_4 + 1)]\n\nvar_2 = []\nfor var_10 in range(var_3):\n var_5, var_7 = var_1[var_10]\n for var_11 in range(var_4):\n if var_5 > var_11:\n var_8[var_11][var_10 + 1] = var_8[var_11][var_10]\n else:\n if var_7 + var_8[var_11 - var_5][var_10] >= var_8[var_11][var_10]:\n var_8[var_11][var_10 + 1] = var_8[var_11 - var_5][var_10] + var_7\n else:\n var_8[var_11][var_10 + 1] = var_8[var_11][var_10]\n var_2.append(var_8[var_4 - 1][var_10] + var_7)\nvar_6 = max(var_2)\nprint(var_6)\n```\n\n=== Code B (Modified) ===\n```python\nfrom collections import Counter, defaultdict, deque\nfrom heapq import heappop, heappush, heapify\nimport sys, bisect, math, itertools, fractions, pprint\n\nsys.setrecursionlimit(10**8)\nvar_6 = 10**9 + 7\nvar_1 = float(\"inf\")\n\n\ndef func_1():\n return int(sys.stdin.readline())\n\n\ndef func_2():\n return list(map(int, sys.stdin.readline().split()))\n\n\nvar_7, var_9 = func_2()\nvar_13 = [func_2() for _ in range(var_7)]\nvar_13.sort(key=lambda var_14: var_14[1], reverse=True)\nvar_8 = 0\nvar_10 = min(var_7, 5)\nfor var_3 in range(var_10):\n var_2 = [[0] * (var_9 + 5) for _ in range(var_7 + 5)]\n for var_4 in range(var_7):\n var_12, var_11 = var_13[var_4]\n for var_5 in range(var_9):\n if var_5 < var_12 or var_3 == var_4:\n var_2[var_4 + 1][var_5] = var_2[var_4][var_5]\n else:\n var_2[var_4 + 1][var_5] = max(\n var_2[var_4][var_5], var_2[var_4][var_5 - var_12] + var_11\n )\n\n var_8 = max(var_2[var_7][var_9 - 1] + var_13[var_3][1], var_8)\nprint(var_8)\n```", "output": "SLOWER 1.6625", "pair_id": "python_p02863_reversed", "problem_id": "p02863", "language": "python", "direction": "reversed", "speedup_ratio": 3.1657} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nfrom collections import deque\n\n\ndef func_2(var_9, var_2, var_4):\n\n var_6 = {var_7: dict() for var_7 in range(var_9)}\n for var_7 in range(var_9 - 1):\n var_1, var_3 = var_2[var_7] - 1, var_4[var_7] - 1\n var_6[var_1][var_3] = -1\n var_6[var_3][var_1] = -1\n var_8 = max([len(var_6[var_1]) for var_1 in range(var_9)])\n var_14 = [-1] * var_9\n var_14[0] = var_8 - 1\n\n var_12 = deque([0])\n while len(var_12) > 0:\n var_10 = var_12.popleft()\n var_5 = var_14[var_10]\n for var_11 in list(var_6[var_10].keys()):\n if var_14[var_11] != -1:\n continue\n var_5 += 1\n var_5 %= var_8\n\n var_6[var_10][var_11] = var_5\n var_6[var_11][var_10] = var_5\n var_14[var_11] = var_5\n var_12.append(var_11)\n var_13 = [0] * (var_9 - 1)\n for var_7 in range(var_9 - 1):\n var_13[var_7] = var_6[var_2[var_7] - 1][var_4[var_7] - 1] + 1\n return var_8, var_13\n\n\ndef func_1():\n var_9 = int(eval(input()))\n var_2 = [0] * (var_9 - 1)\n var_4 = [0] * (var_9 - 1)\n for var_7 in range(var_9 - 1):\n var_1, var_3 = list(map(int, input().split()))\n var_2[var_7] = var_1\n var_4[var_7] = var_3\n var_8, var_13 = func_2(var_9, var_2, var_4)\n print(var_8)\n for var_7 in range(var_9 - 1):\n print((var_13[var_7]))\n\n\ndef func_3():\n print((func_2(3, [1, 2], [2, 3])))\n print((func_2(8, [1, 2, 2, 2, 4, 5, 6], [2, 3, 4, 5, 7, 6, 8])))\n\n\nif __name__ == \"__main__\":\n\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\n\nvar_8 = sys.stdin.readline\nvar_9 = int(eval(var_8()))\nvar_6 = []\nfor var_7 in range(var_9 - 1):\n var_1, var_3 = list(map(int, var_8().split()))\n var_6.append([var_1 - 1, var_3 - 1, var_7])\nvar_6.sort()\nvar_13 = [0] * (var_9)\nvar_2 = [0] * (var_9 - 1)\nvar_10 = 1\nvar_11 = 0\nfor var_5 in var_6:\n _from, var_12, var_7 = var_5\n if _from != var_11:\n var_10 = 1\n if var_13[_from] == var_10:\n var_10 += 1\n var_2[var_7] = var_10\n var_13[var_12] = var_10\n var_10 += 1\n var_11 = _from\nprint((max(var_2)))\nfor var_4 in var_2:\n print(var_4)\n```", "output": "FASTER 1.2025", "pair_id": "python_p02850_forward", "problem_id": "p02850", "language": "python", "direction": "forward", "speedup_ratio": 2.3014} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\ndef func_1():\n from sys import setrecursionlimit, stdin\n from os import environ\n from collections import defaultdict, deque, Counter\n from math import ceil, floor, gcd\n from itertools import accumulate, combinations, combinations_with_replacement\n\n setrecursionlimit(10**6)\n var_7 = (\n (lambda *var_11: print(*var_11))\n if \"TERM_PROGRAM\" in environ\n else lambda *var_12: 0\n )\n var_8 = lambda: stdin.readline().rstrip()\n var_3 = lambda: list(map(int, var_8().split()))\n var_1 = lambda: int(var_8())\n var_4 = 10**9 + 7\n var_2 = 10**9 + 10\n var_9, var_10 = var_8().split()\n var_5 = int(var_9)\n var_6 = int(float(var_10) * 100 + 0.5)\n print(var_5 * var_6 // 100)\n\n\nfunc_1()\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = input().split()\nvar_1 = int(var_1)\nvar_2 = int(\"\".join(var_2.split(\".\")))\nprint(((var_1 * var_2) // 100))\n```", "output": "FASTER 2.2081", "pair_id": "python_p02659_forward", "problem_id": "p02659", "language": "python", "direction": "forward", "speedup_ratio": 4.6207} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_4, var_3 = list(map(int, input().split()))\nvar_1 = 0\nfor var_2 in range(var_4, var_3 + 1):\n if str(var_2)[0] + str(var_2)[1] == str(var_2)[-1] + str(var_2)[-2]:\n var_1 += 1\nprint(var_1)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().strip().split(\" \")))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n if str(var_4) == str(var_4)[::-1]:\n var_3 += 1\nprint(var_3)\n```", "output": "FASTER 1.0338", "pair_id": "python_p03416_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 2.0474} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = input().split()\nvar_1 = int(var_1)\nvar_2 = int(var_2)\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = list(str(var_4))\n if (var_5[0] == var_5[4]) and (var_5[1] == var_5[3]):\n var_3 = var_3 + 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_6 in range(var_1, var_2 + 1):\n var_3 = str(var_6)\n var_5 = True\n for var_7 in range(len(var_3) // 2):\n if var_3[var_7] != var_3[-var_7 - 1] and var_5:\n var_5 = not var_5\n if var_5:\n var_4 += 1\nprint(var_4)\n```", "output": "SLOWER 1.0556", "pair_id": "python_p03416_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 2.0786} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = list(reversed(list(str(var_4))))\n if var_5 == list(str(var_4)):\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = [\n var_3 for var_3 in map(str, list(range(var_1, var_2 + 1))) if var_3 == var_3[::-1]\n]\nprint((len(var_4)))\n```", "output": "FASTER 2.3555", "pair_id": "python_p03416_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 5.1178} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_6, var_5 = list(map(int, input().split(\" \")))\nvar_2 = [list(map(int, input().split(\" \"))) for _ in range(var_5)]\nvar_2.sort(key=lambda var_7: var_7[1])\nvar_4 = 0\nvar_7 = 0\nfor var_1, var_3 in var_2:\n if var_1 <= var_7 < var_3:\n continue\n var_7 = var_3 - 1\n var_4 += 1\nprint(var_4)\n```\n\n=== Code B (Modified) ===\n```python\nvar_2, var_1 = [int(var_12) for var_12 in input().split()]\nvar_3 = []\nfor var_8 in range(var_1):\n var_5, var_6 = [int(var_12) for var_12 in input().split()]\n var_3.append((var_5, var_6))\nvar_3.sort()\nvar_9 = float(\"inf\")\nvar_4 = [var_9 for var_5 in range(var_2 + 1)]\nfor var_5, var_6 in var_3:\n var_4[var_5] = min(var_4[var_5], var_6)\nvar_3 = [\n (var_5, var_4[var_5]) for var_5 in range(1, var_2 + 1) if var_4[var_5] != var_9\n]\nvar_3.sort(key=lambda var_11: var_11[1])\nvar_7 = [True] * (var_2)\nvar_10 = None\nfor var_5, var_6 in var_3:\n if var_10 == None or var_10 < var_5:\n var_7[var_6 - 1] = False\n var_10 = var_6 - 1\nprint((sum(1 for var_6 in var_7 if not var_6)))\n```", "output": "SLOWER 1.0353", "pair_id": "python_p03295_reversed", "problem_id": "p03295", "language": "python", "direction": "reversed", "speedup_ratio": 2.0495} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\ndef func_1():\n var_1, var_2 = list(map(int, input().rstrip().split()))\n var_3 = 0\n for var_4 in range(var_1, var_2 + 1):\n var_5 = str(var_4)\n if var_5 == var_5[::-1]:\n var_3 += 1\n print(var_3)\n\n\nif __name__ == \"__main__\":\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_8 in range(var_1, var_2 + 1):\n var_7 = str(var_8)\n var_6 = len(var_7)\n var_4 = True\n for var_5 in range(var_6 // 2):\n if var_7[var_5] != var_7[var_6 - 1 - var_5]:\n var_4 = False\n break\n if var_4:\n var_3 += 1\nprint(var_3)\n```", "output": "SLOWER 1.8722", "pair_id": "python_p03416_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 3.661} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = input().split()\nvar_1 = int(var_1)\nvar_3, var_4 = list(map(int, var_2.split(\".\")))\nvar_5 = var_1 * (var_3 * 100 + var_4)\nprint((int(var_5 // 100)))\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\nimport math\nfrom collections import defaultdict\nfrom bisect import bisect_left, bisect_right\n\nsys.setrecursionlimit(10**7)\n\n\ndef func_4():\n return sys.stdin.readline()[:-1]\n\n\nvar_4 = 10**9 + 7\n\n\ndef func_1():\n return int(eval(func_4()))\n\n\ndef func_2():\n return list(map(int, func_4().split()))\n\n\ndef func_3(var_6, var_3):\n if var_6 <= 0:\n return [[] for _ in range(var_3)]\n elif var_3 == 1:\n return [func_1() for _ in range(var_6)]\n else:\n var_5 = [func_2() for _ in range(var_6)]\n return list(map(list, list(zip(*var_5))))\n\n\nfrom decimal import getcontext, Decimal\n\ngetcontext().prec = 28\nvar_1, var_2 = list(map(str, func_4().split()))\nvar_1 = int(var_1)\nvar_2 = Decimal(var_2)\nprint((int(var_1 * var_2)))\n```", "output": "SLOWER 2.0589", "pair_id": "python_p02659_reversed", "problem_id": "p02659", "language": "python", "direction": "reversed", "speedup_ratio": 4.1668} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = list(reversed(list(str(var_4))))\n if var_5 == list(str(var_4)):\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = str(var_4)\n if var_5[0] == var_5[4] and var_5[1] == var_5[3]:\n var_3 += 1\nprint(var_3)\n```", "output": "FASTER 1.9231", "pair_id": "python_p03416_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 3.7924} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\nfrom operator import itemgetter\nfrom heapq import heapify, heappop, heappush\n\nvar_1 = int(10e15)\nvar_2 = -var_1\nvar_11 = 1000000007\nsys.setrecursionlimit(1000000)\n\n\ndef func_2():\n return list(map(int, input().split()))\n\n\ndef func_4():\n return input().split()\n\n\ndef func_1():\n return int(sys.stdin.readline())\n\n\ndef func_3():\n return eval(input())\n\n\nvar_3, var_4 = func_2()\nvar_5 = [func_2() for var_9 in range(var_3)]\nvar_5.sort(key=itemgetter(0))\n\nvar_8 = [[0] * (var_4 + 1 + 3000 + 1) for _ in range(var_3 + 1)]\nvar_6 = 0\nfor var_9 in range(var_3):\n for var_10 in range(var_4 + 1 + 3000 + 1):\n var_12, var_7 = var_5[var_9]\n if 0 <= var_10 - var_12 < var_4:\n var_8[var_9 + 1][var_10] = max(\n var_8[var_9][var_10], var_8[var_9][var_10 - var_12] + var_7\n )\n else:\n var_8[var_9 + 1][var_10] = var_8[var_9][var_10]\n var_6 = max(var_6, var_8[var_9 + 1][var_10])\nprint(var_6)\n```\n\n=== Code B (Modified) ===\n```python\nvar_8, var_9 = list(map(int, input().split()))\nvar_5 = [[0] * (var_9 + 3001) for _ in range(var_8 + 1)]\nvar_3 = 0\nvar_2 = [list(map(int, input().split())) for _ in range(var_8)]\nvar_2.sort()\nfor var_6 in range(1, var_8 + 1):\n var_1, var_4 = var_2[var_6 - 1]\n for var_7 in range(var_9):\n var_5[var_6][var_7] = max(var_5[var_6 - 1][var_7], var_5[var_6][var_7])\n var_5[var_6][var_7 + var_1] = var_5[var_6 - 1][var_7] + var_4\n var_3 = max(var_5[var_6][var_7], var_5[var_6][var_7 + var_1], var_3)\nprint(var_3)\n```", "output": "FASTER 4.3053", "pair_id": "python_p02863_forward", "problem_id": "p02863", "language": "python", "direction": "forward", "speedup_ratio": 19.7702} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_3 in range(var_1, var_2 + 1):\n var_5 = list(str(var_3))\n var_6 = list(reversed(var_5))\n if var_5 == var_6:\n var_4 += 1\nprint(var_4)\n```\n\n=== Code B (Modified) ===\n```python\nvar_4 = {}\nvar_5 = 0\nfor var_6 in range(10000, 100000):\n var_3 = list(str(var_6))\n if var_3 == list(reversed(var_3)):\n var_5 += 1\n var_4[var_6] = var_5\nvar_1, var_2 = list(map(int, input().split()))\nprint((var_4[var_2] - var_4[var_1 - 1] if var_1 > 10000 else var_4[var_2]))\n```", "output": "SLOWER 2.265", "pair_id": "python_p03416_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 4.8064} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport math\n\nvar_1, var_2 = input().split()\nvar_1 = int(var_1)\nvar_3 = int(var_2[0] + var_2[2] + var_2[3])\nprint((var_1 * var_3 // 100))\n```\n\n=== Code B (Modified) ===\n```python\ndef func_1():\n from sys import setrecursionlimit, stdin\n from os import environ\n from collections import defaultdict, deque, Counter\n from math import ceil, floor, gcd\n from itertools import accumulate, combinations, combinations_with_replacement\n\n setrecursionlimit(10**6)\n var_7 = (\n (lambda *var_11: print(*var_11))\n if \"TERM_PROGRAM\" in environ\n else lambda *var_12: 0\n )\n var_8 = lambda: stdin.readline().rstrip()\n var_3 = lambda: list(map(int, var_8().split()))\n var_1 = lambda: int(var_8())\n var_4 = 10**9 + 7\n var_2 = 10**9 + 10\n var_9, var_10 = var_8().split()\n var_5 = int(var_9)\n var_10 = var_10.split(\".\")\n var_6 = int(var_10[0]) * 100\n if len(var_10) == 2:\n var_6 += int(var_10[1])\n print(var_5 * var_6 // 100)\n\n\nfunc_1()\n```", "output": "SLOWER 2.2041", "pair_id": "python_p02659_reversed", "problem_id": "p02659", "language": "python", "direction": "reversed", "speedup_ratio": 4.6079} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nfrom collections import deque\n\n\ndef func_2(var_9, var_2, var_4):\n\n var_6 = {var_7: dict() for var_7 in range(var_9)}\n for var_7 in range(var_9 - 1):\n var_1, var_3 = var_2[var_7] - 1, var_4[var_7] - 1\n var_6[var_1][var_3] = -1\n var_6[var_3][var_1] = -1\n var_8 = max([len(var_6[var_1]) for var_1 in range(var_9)])\n var_14 = [-1] * var_9\n var_14[0] = var_8 - 1\n\n var_12 = deque([0])\n while len(var_12) > 0:\n var_10 = var_12.popleft()\n var_5 = var_14[var_10]\n for var_11 in list(var_6[var_10].keys()):\n if var_14[var_11] != -1:\n continue\n var_5 += 1\n var_5 %= var_8\n\n var_6[var_10][var_11] = var_5\n var_6[var_11][var_10] = var_5\n var_14[var_11] = var_5\n var_12.append(var_11)\n var_13 = [0] * (var_9 - 1)\n for var_7 in range(var_9 - 1):\n var_13[var_7] = var_6[var_2[var_7] - 1][var_4[var_7] - 1] + 1\n return var_8, var_13\n\n\ndef func_1():\n var_9 = int(eval(input()))\n var_2 = [0] * (var_9 - 1)\n var_4 = [0] * (var_9 - 1)\n for var_7 in range(var_9 - 1):\n var_1, var_3 = list(map(int, input().split()))\n var_2[var_7] = var_1\n var_4[var_7] = var_3\n var_8, var_13 = func_2(var_9, var_2, var_4)\n print(var_8)\n for var_7 in range(var_9 - 1):\n print((var_13[var_7]))\n\n\ndef func_3():\n print((func_2(3, [1, 2], [2, 3])))\n print((func_2(8, [1, 2, 2, 2, 4, 5, 6], [2, 3, 4, 5, 7, 6, 8])))\n\n\nif __name__ == \"__main__\":\n\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nimport copy\n\nvar_8 = int(eval(input()))\nvar_10 = set([var_6 for var_6 in range(1, 10**5)])\nvar_5 = []\nvar_11 = {}\nvar_9 = []\nfor var_6 in range(var_8 - 1):\n var_1, var_2 = list(map(int, input().split(\" \")))\n var_5.append([var_1, var_2])\n var_11.setdefault(var_1, []).append(var_2)\n var_9.append([])\nvar_9.append([])\nvar_9.append([])\nvar_7 = 0\nfor var_12 in range(1, var_8 + 1):\n var_14 = var_11.get(var_12, [])\n var_3 = 1\n for var_13 in var_14:\n if var_3 in var_9[var_12]:\n var_3 += 1\n else:\n pass\n var_9[var_13].append(var_3)\n if var_3 >= var_7:\n var_7 = var_3\n var_3 += 1\nprint(var_7)\nfor var_4 in var_5:\n print((var_9[var_4[1]][0]))\n```", "output": "SLOWER 3.6429", "pair_id": "python_p02850_reversed", "problem_id": "p02850", "language": "python", "direction": "reversed", "speedup_ratio": 12.4917} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\n\n\ndef func_1(var_5):\n var_4 = 0\n for var_3 in range(1, var_5 + 1):\n if str(var_3) == str(var_3)[::-1]:\n var_4 += 1\n return var_4\n\n\nprint((func_1(var_2) - func_1(var_1 - 1)))\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = input().split()\nvar_1 = int(var_1)\nvar_2 = int(var_2)\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = list(str(var_4))\n if (var_5[0] == var_5[4]) and (var_5[1] == var_5[3]):\n var_3 = var_3 + 1\nprint(var_3)\n```", "output": "FASTER 1.1863", "pair_id": "python_p03416_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 2.2757} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nfrom collections import Counter, defaultdict, deque\nfrom heapq import heappop, heappush, heapify\nimport sys, bisect, math, itertools, fractions, pprint\n\nsys.setrecursionlimit(10**8)\nvar_6 = 10**9 + 7\nvar_1 = float(\"inf\")\n\n\ndef func_1():\n return int(sys.stdin.readline())\n\n\ndef func_2():\n return list(map(int, sys.stdin.readline().split()))\n\n\nvar_8, var_11 = func_2()\nvar_17 = [func_2() for _ in range(var_8)]\nvar_10 = var_17[::-1]\nvar_14 = [[0] * var_11 for _ in range(var_8)]\nvar_3 = [[0] * var_11 for _ in range(var_8)]\nfor var_4 in range(var_8 - 1):\n var_16, var_15 = var_17[var_4]\n for var_5 in range(var_11):\n if var_5 < var_16:\n var_14[var_4 + 1][var_5] = var_14[var_4][var_5]\n else:\n var_14[var_4 + 1][var_5] = max(\n var_14[var_4][var_5], var_14[var_4][var_5 - var_16] + var_15\n )\nvar_9 = var_14[var_8 - 1][var_11 - 1] + var_17[var_8 - 1][1]\nfor var_4 in range(var_8 - 1):\n var_16, var_15 = var_10[var_4]\n for var_5 in range(var_11):\n if var_5 < var_16:\n var_3[var_4 + 1][var_5] = var_3[var_4][var_5]\n else:\n var_3[var_4 + 1][var_5] = max(\n var_3[var_4][var_5], var_3[var_4][var_5 - var_16] + var_15\n )\n var_9 = max(var_9, var_3[var_8 - 1][var_11 - 1] + var_17[0][1])\n\nfor var_4 in range(1, var_8 - 1):\n var_13 = var_4\n var_2 = var_8 - var_4 - 1\n var_7 = 0\n for var_5 in range(var_11):\n var_12 = var_14[var_13][var_5] + var_3[var_2][var_11 - 1 - var_5]\n var_7 = max(var_7, var_12)\n var_9 = max(var_9, var_7 + var_17[var_4][1])\nprint(var_9)\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\n\nsys.setrecursionlimit(2147483647)\nvar_2 = float(\"inf\")\nvar_3 = 10**9 + 7\nvar_10 = lambda: sys.stdin.readline().rstrip()\n\n\ndef func_1():\n var_11, var_4 = list(map(int, var_10().split()))\n var_1 = [tuple(map(int, var_10().split())) for _ in range(var_11)]\n var_1.sort()\n var_8 = [0] * var_4\n var_6 = -var_2\n for var_9 in range(var_11):\n var_5, var_7 = var_1[var_9]\n var_12 = var_8[:]\n for var_13 in range(var_4):\n if var_13 + var_5 < var_4:\n var_12[var_13 + var_5] = max(\n var_12[var_13 + var_5], var_8[var_13] + var_7\n )\n else:\n var_6 = max(var_6, var_8[var_13] + var_7)\n var_8 = var_12\n print((max(var_6, max(var_8))))\n\n\nfunc_1()\n```", "output": "FASTER 2.0401", "pair_id": "python_p02863_forward", "problem_id": "p02863", "language": "python", "direction": "forward", "speedup_ratio": 4.1128} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = list(str(var_4))\n if var_5 == list(reversed(var_5)):\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_4 = {}\nvar_5 = 0\nfor var_6 in range(10000, 100000):\n var_3 = list(str(var_6))\n if var_3 == list(reversed(var_3)):\n var_5 += 1\n var_4[var_6] = var_5\nvar_1, var_2 = list(map(int, input().split()))\nprint((var_4[var_2] - var_4[var_1 - 1] if var_1 > 10000 else var_4[var_2]))\n```", "output": "SLOWER 2.3414", "pair_id": "python_p03416_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 5.068} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\n\n\ndef func_1(var_5, var_6):\n var_4 = 0\n for var_3 in range(var_5, var_6 + 1):\n if str(var_3) == str(var_3)[::-1]:\n var_4 += 1\n return var_4\n\n\nprint((func_1(var_1, var_2)))\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_3 = list(map(int, input().split()))\nvar_2 = 0\nfor var_5 in range(var_3 + 1)[var_1:]:\n if len(str(var_5)) % 2 == 0:\n var_6 = list(str(var_5))[: len(str(var_5)) // 2]\n var_7 = list(reversed(list(str(var_5))[len(str(var_5)) // 2 :]))\n if var_6 == var_7:\n var_2 += 1\n else:\n var_8 = list(str(var_5))[: len(str(var_5)) // 2 + 1]\n var_4 = list(reversed(list(str(var_5))[len(str(var_5)) // 2 :]))\n if var_8 == var_4:\n var_2 += 1\nprint(var_2)\n```", "output": "SLOWER 2.7982", "pair_id": "python_p03416_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 6.9556} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_2 = int(eval(input()))\n(*var_1,) = list(map(int, input().split()))\nvar_5 = 0\nfor var_3 in var_1:\n if var_3 % 2 == 0:\n var_5 += 1\nvar_4 = 3**var_2 - 2**var_5\nprint(var_4)\n```\n\n=== Code B (Modified) ===\n```python\nimport math\nimport string\n\n\ndef func_4():\n return list(map(int, input().split()))\n\n\ndef func_3(var_6, var_7):\n return math.factorial(var_6) // (\n math.factorial(var_6 - var_7) * math.factorial(var_7)\n )\n\n\ndef func_2(var_9):\n var_8 = []\n for var_5 in var_9:\n if not (var_5 in var_8):\n var_8.append(var_5)\n return len(var_9) != len(var_8)\n\n\ndef func_1(var_6):\n func_1 = []\n for var_4 in range(1, var_6 + 1):\n if var_6 % var_4 == 0:\n func_1.append(var_4)\n return func_1\n\n\nvar_2 = [-1, -1, -1, 0, 0, 1, 1, 1]\nvar_3 = [-1, 0, 1, -1, 1, -1, 0, 1]\nvar_6 = int(eval(input()))\nvar_1 = func_4()\nvar_10 = 1\nfor var_4 in range(len(var_1)):\n if var_1[var_4] % 2 == 0:\n var_10 *= 2\n else:\n var_10 *= 1\nprint((3 ** len(var_1) - var_10))\n```", "output": "SLOWER 1.6929", "pair_id": "python_p03568_reversed", "problem_id": "p03568", "language": "python", "direction": "reversed", "speedup_ratio": 3.2331} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nfrom collections import Counter, defaultdict, deque\nfrom heapq import heappop, heappush, heapify\nimport sys, bisect, math, itertools, fractions, pprint\n\nsys.setrecursionlimit(10**8)\nvar_6 = 10**9 + 7\nvar_1 = float(\"inf\")\n\n\ndef func_1():\n return int(sys.stdin.readline())\n\n\ndef func_2():\n return list(map(int, sys.stdin.readline().split()))\n\n\nvar_7, var_9 = func_2()\nvar_13 = [func_2() for _ in range(var_7)]\nvar_13.sort(key=lambda var_14: var_14[1], reverse=True)\nvar_8 = 0\nvar_10 = min(var_7, 5)\nfor var_3 in range(var_10):\n var_2 = [[0] * (var_9 + 5) for _ in range(var_7 + 5)]\n for var_4 in range(var_7):\n var_12, var_11 = var_13[var_4]\n for var_5 in range(var_9):\n if var_5 < var_12 or var_3 == var_4:\n var_2[var_4 + 1][var_5] = var_2[var_4][var_5]\n else:\n var_2[var_4 + 1][var_5] = max(\n var_2[var_4][var_5], var_2[var_4][var_5 - var_12] + var_11\n )\n\n var_8 = max(var_2[var_7][var_9 - 1] + var_13[var_3][1], var_8)\nprint(var_8)\n```\n\n=== Code B (Modified) ===\n```python\nimport bisect\nimport sys\n\nsys.setrecursionlimit(10**6)\nvar_17 = sys.stdout.write\nvar_7 = lambda *var_15: print(*var_15) if var_1 else 0\nvar_1 = True\n\n\ndef func_1(var_10=sys.stdin.readline):\n var_12 = lambda: var_10().rstrip()\n var_3 = lambda: list(map(int, var_12().split()))\n var_2 = lambda: int(var_12())\n var_4 = lambda var_18: [var_3() for _ in range(var_18)]\n var_14, var_16 = var_3()\n var_5 = var_4(var_14)\n var_8 = [[0] * var_16 for _ in range(var_14)]\n for var_11 in range(1, var_14):\n for var_13 in range(1, var_16):\n if var_13 < var_5[var_11 - 1][0]:\n var_8[var_11][var_13] = var_8[var_11 - 1][var_13]\n else:\n var_8[var_11][var_13] = max(\n var_8[var_11 - 1][var_13],\n var_8[var_11 - 1][var_13 - var_5[var_11 - 1][0]]\n + var_5[var_11 - 1][1],\n )\n var_9 = [[0] * var_16 for _ in range(var_14)]\n for var_11 in range(1, var_14):\n for var_13 in range(1, var_16):\n if var_13 < var_5[var_14 - var_11][0]:\n var_9[var_11][var_13] = var_9[var_11 - 1][var_13]\n else:\n var_9[var_11][var_13] = max(\n var_9[var_11 - 1][var_13],\n var_9[var_11 - 1][var_13 - var_5[var_14 - var_11][0]]\n + var_5[var_14 - var_11][1],\n )\n var_6 = 0\n for var_11 in range(var_14):\n for var_13 in range(var_16 - 1):\n var_6 = max(\n var_6,\n var_8[var_11][var_13]\n + var_9[var_14 - var_11 - 1][var_16 - var_13 - 1]\n + var_5[var_11][1],\n )\n print(var_6)\n\n\nif __name__ == \"__main__\":\n func_1()\n```", "output": "FASTER 1.236", "pair_id": "python_p02863_forward", "problem_id": "p02863", "language": "python", "direction": "forward", "speedup_ratio": 2.3555} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\n\n\ndef func_1(var_5, var_6):\n var_4 = 0\n for var_3 in range(var_5, var_6 + 1):\n if str(var_3) == str(var_3)[::-1]:\n var_4 += 1\n return var_4\n\n\nprint((func_1(var_1, var_2)))\n```\n\n=== Code B (Modified) ===\n```python\nvar_4, var_3 = list(map(int, input().split()))\nvar_1 = 0\nfor var_2 in range(var_4, var_3 + 1):\n if str(var_2)[0] + str(var_2)[1] == str(var_2)[-1] + str(var_2)[-2]:\n var_1 += 1\nprint(var_1)\n```", "output": "SLOWER 1.6647", "pair_id": "python_p03416_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 3.1705} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nfrom functools import *\n\n_, var_1 = open(0)\nprint(\n (\n \"YNeos\"[\n var_2(lambda var_3, var_4: var_3 ^ var_4, list(map(int, var_1.split())))\n > 0 :: 2\n ]\n )\n)\n```\n\n=== Code B (Modified) ===\n```python\nfrom collections import defaultdict\n\nvar_8 = int(eval(input()))\nvar_1 = tuple(map(int, input().split()))\nvar_3 = True\nif var_8 % 3 == 0:\n var_5 = defaultdict(int)\n for var_2 in var_1:\n var_5[var_2] += 1\n var_7 = var_8 // 3\n var_10 = []\n for var_9, var_4 in list(var_5.items()):\n if var_4 % var_7 != 0:\n var_3 = False\n break\n else:\n for _ in range(var_4 // var_7):\n var_10.append(var_9)\n else:\n if any(\n var_10[(0 + var_6) % 3] ^ var_10[(1 + var_6) % 3] != var_10[(2 + var_6) % 3]\n for var_6 in range(3)\n ):\n var_3 = False\nelse:\n if any(var_2 != 0 for var_2 in var_1):\n var_3 = False\nprint((\"Yes\" if var_3 else \"No\"))\n```", "output": "SLOWER 1.1419", "pair_id": "python_p02975_reversed", "problem_id": "p02975", "language": "python", "direction": "reversed", "speedup_ratio": 2.2067} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_3 = list(map(int, input().split()))\nvar_2 = 0\nfor var_5 in range(var_3 + 1)[var_1:]:\n if len(str(var_5)) % 2 == 0:\n var_6 = list(str(var_5))[: len(str(var_5)) // 2]\n var_7 = list(reversed(list(str(var_5))[len(str(var_5)) // 2 :]))\n if var_6 == var_7:\n var_2 += 1\n else:\n var_8 = list(str(var_5))[: len(str(var_5)) // 2 + 1]\n var_4 = list(reversed(list(str(var_5))[len(str(var_5)) // 2 :]))\n if var_8 == var_4:\n var_2 += 1\nprint(var_2)\n```\n\n=== Code B (Modified) ===\n```python\ndef func_1():\n var_1, var_2 = list(map(int, input().split()))\n var_3 = 0\n for var_4 in range(var_1, var_2 + 1):\n\n if (var_4 % 10) == (var_4 // 10000 % 10) and (var_4 // 10 % 10) == (\n var_4 // 1000 % 10\n ):\n var_3 += 1\n print(var_3)\n\n\nif __name__ == \"__main__\":\n func_1()\n```", "output": "FASTER 4.1386", "pair_id": "python_p03416_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 17.6132} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\nimport itertools\n\n\ndef func_2(var_4):\n return bin(eval(\"0b\" + str(var_4)))\n\n\ndef func_1():\n var_4 = int(sys.stdin.readline().rstrip())\n var_9 = [\n func_2(\"\".join(str(var_10) for var_10 in sys.stdin.readline().split()))\n for _ in range(var_4)\n ]\n var_8 = [\n [int(var_10) for var_10 in sys.stdin.readline().split()] for _ in range(var_4)\n ]\n var_3 = -(10**10)\n for var_6 in itertools.product(\"01\", repeat=10):\n var_6 = func_2(\"\".join(var_6))\n if var_6 == \"0b0\":\n continue\n var_7 = 0\n for var_2 in range(var_4):\n var_1 = var_9[var_2]\n var_5 = bin(eval(var_1) & eval(var_6)).count(\"1\")\n var_7 += var_8[var_2][var_5]\n var_3 = max(var_3, var_7)\n print(var_3)\n\n\nif __name__ == \"__main__\":\n\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\nimport itertools\n\n\ndef func_2(var_4):\n return eval(\"0b\" + var_4)\n\n\ndef func_1():\n var_4 = int(sys.stdin.readline().rstrip())\n var_9 = [\n func_2(\"\".join(str(var_10) for var_10 in sys.stdin.readline().split()))\n for _ in range(var_4)\n ]\n var_8 = [\n [int(var_10) for var_10 in sys.stdin.readline().split()] for _ in range(var_4)\n ]\n var_3 = -(10**10)\n for var_6 in itertools.product(\"01\", repeat=10):\n var_6 = func_2(\"\".join(var_6))\n if var_6 == 0:\n continue\n var_7 = 0\n for var_2 in range(var_4):\n var_1 = var_9[var_2]\n var_5 = bin(var_1 & var_6).count(\"1\")\n var_7 += var_8[var_2][var_5]\n var_3 = max(var_3, var_7)\n print(var_3)\n\n\nif __name__ == \"__main__\":\n\n func_1()\n```", "output": "FASTER 2.1735", "pair_id": "python_p03503_forward", "problem_id": "p03503", "language": "python", "direction": "forward", "speedup_ratio": 4.5112} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport math\n\nvar_1, var_2 = input().split()\nvar_1 = int(var_1)\nvar_3 = int(var_2[0] + var_2[2] + var_2[3])\nprint((var_1 * var_3 // 100))\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\nimport math\nfrom collections import defaultdict\nfrom bisect import bisect_left, bisect_right\n\nsys.setrecursionlimit(10**7)\n\n\ndef func_4():\n return sys.stdin.readline()[:-1]\n\n\nvar_4 = 10**9 + 7\n\n\ndef func_1():\n return int(eval(func_4()))\n\n\ndef func_2():\n return list(map(int, func_4().split()))\n\n\ndef func_3(var_6, var_3):\n if var_6 <= 0:\n return [[] for _ in range(var_3)]\n elif var_3 == 1:\n return [func_1() for _ in range(var_6)]\n else:\n var_5 = [func_2() for _ in range(var_6)]\n return list(map(list, list(zip(*var_5))))\n\n\nvar_1, var_2 = list(map(str, func_4().split()))\nvar_1 = int(var_1)\nvar_2 = 100 * int(var_2[0]) + 10 * int(var_2[2]) + int(var_2[3])\nprint((var_1 * var_2 // 100))\n```", "output": "SLOWER 2.3564", "pair_id": "python_p02659_reversed", "problem_id": "p02659", "language": "python", "direction": "reversed", "speedup_ratio": 5.1208} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\ndef func_1():\n from sys import setrecursionlimit, stdin\n from os import environ\n from collections import defaultdict, deque, Counter\n from math import ceil, floor, gcd\n from itertools import accumulate, combinations, combinations_with_replacement\n\n setrecursionlimit(10**6)\n var_7 = (\n (lambda *var_11: print(*var_11))\n if \"TERM_PROGRAM\" in environ\n else lambda *var_12: 0\n )\n var_8 = lambda: stdin.readline().rstrip()\n var_3 = lambda: list(map(int, var_8().split()))\n var_1 = lambda: int(var_8())\n var_4 = 10**9 + 7\n var_2 = 10**9 + 10\n var_9, var_10 = var_8().split()\n var_5 = int(var_9)\n var_10 = var_10.split(\".\")\n var_6 = int(var_10[0]) * 100\n if len(var_10) == 2:\n var_6 += int(var_10[1])\n print(var_5 * var_6 // 100)\n\n\nfunc_1()\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\n\nvar_3 = sys.stdin.readline\nif __name__ == \"__main__\":\n var_1, var_2 = var_3().split()\n print((int(var_1) * round(float(var_2) * 100) // 100))\n```", "output": "FASTER 2.1103", "pair_id": "python_p02659_forward", "problem_id": "p02659", "language": "python", "direction": "forward", "speedup_ratio": 4.3177} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nfrom math import floor\n\nvar_1, var_2 = list(map(int, input().split()))\n\n\nfor var_3 in range(1010):\n if (floor(var_3 * 0.08) == var_1) and (floor(var_3 * 0.1) == var_2):\n\n print(var_3)\n quit()\n\n\nprint((-1))\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_3 = list(map(int, input().split()))\nvar_2 = -1\nfor var_4 in range(10, 12501):\n if int(var_4 * 0.08) == var_1 and int(var_4 * 0.1) == var_3:\n var_2 = var_4\n break\nprint(var_2)\n```", "output": "SLOWER 3.4688", "pair_id": "python_p02755_reversed", "problem_id": "p02755", "language": "python", "direction": "reversed", "speedup_ratio": 11.0714} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_4 = {}\nvar_5 = 0\nfor var_6 in range(10000, 100000):\n var_3 = list(str(var_6))\n if var_3 == list(reversed(var_3)):\n var_5 += 1\n var_4[var_6] = var_5\nvar_1, var_2 = list(map(int, input().split()))\nprint((var_4[var_2] - var_4[var_1 - 1] if var_1 > 10000 else var_4[var_2]))\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().strip().split(\" \")))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n if str(var_4) == str(var_4)[::-1]:\n var_3 += 1\nprint(var_3)\n```", "output": "FASTER 3.2663", "pair_id": "python_p03416_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 9.622} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_5 in range(var_1, var_2 + 1):\n var_3 = str(var_5)\n if var_3[0] == var_3[-1] and var_3[1] == var_3[-2]:\n var_4 += 1\nprint(var_4)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_7 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_3 = True\n var_8 = str(var_4)\n var_6 = len(var_8)\n for var_5 in range(var_6 // 2 + 1):\n if var_8[var_5] != var_8[-var_5 - 1]:\n var_3 = False\n break\n if var_3:\n var_7 += 1\nprint(var_7)\n```", "output": "SLOWER 1.2167", "pair_id": "python_p03416_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 2.3241} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\ndef func_1():\n return list(map(int, input().split()))\n\n\nvar_1, var_2, var_3 = func_1()\nvar_4 = list(func_1())\nvar_6 = list(func_1())\nvar_5 = min(var_4) + min(var_6)\nfor _ in range(var_3):\n var_8, var_9, var_7 = func_1()\n var_5 = min(var_5, var_4[var_8 - 1] + var_6[var_9 - 1] - var_7)\nprint(var_5)\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\nfrom collections import Counter\n\n\ndef func_9():\n return sys.stdin.readline().strip()\n\n\ndef func_10(var_8, var_9, var_10):\n return [[var_10] * var_9 for var_13 in range(var_8)]\n\n\ndef func_11(var_8, var_9, var_10, var_11):\n return [[[var_11] * var_10 for var_14 in range(var_9)] for var_13 in range(var_8)]\n\n\ndef func_12(var_8, var_9, var_10, var_11, var_12):\n return [\n [[[var_12] * var_11 for var_14 in range(var_10)] for var_14 in range(var_9)]\n for var_13 in range(var_8)\n ]\n\n\ndef func_8(var_16, var_17=1):\n return int(-(-var_16 // var_17))\n\n\ndef func_1():\n return int(eval(func_9()))\n\n\ndef func_3():\n return list(map(int, func_9().split()))\n\n\ndef func_2(var_7=None):\n return list(func_3()) if var_7 is None else [func_1() for var_13 in range(var_7)]\n\n\ndef func_7():\n print(\"Yes\")\n\n\ndef func_5():\n print(\"No\")\n\n\ndef func_6():\n print(\"YES\")\n\n\ndef func_4():\n print(\"NO\")\n\n\nsys.setrecursionlimit(10**9)\nvar_3 = 10**18\nvar_6 = 10**9 + 7\nvar_7, var_5, var_4 = func_3()\nvar_1 = func_2()\nvar_2 = func_2()\nvar_15 = min(var_1) + min(var_2)\nfor _ in range(var_4):\n var_16, var_17, var_10 = func_3()\n var_16 -= 1\n var_17 -= 1\n var_15 = min(var_15, var_1[var_16] + var_2[var_17] - var_10)\nprint(var_15)\n```", "output": "SLOWER 2.0028", "pair_id": "python_p02748_reversed", "problem_id": "p02748", "language": "python", "direction": "reversed", "speedup_ratio": 4.0077} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = list(reversed(list(str(var_4))))\n if var_5 == list(str(var_4)):\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1 = list(map(int, input().split()))\nvar_2 = 0\nfor var_3 in range(var_1[0], var_1[1] + 1):\n var_4 = str(var_3)\n if var_4[0] == var_4[4] and var_4[1] == var_4[3]:\n var_2 += 1\nprint(var_2)\n```", "output": "FASTER 1.9458", "pair_id": "python_p03416_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 3.8524} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nfrom functools import reduce\nfrom itertools import product\n\nvar_2 = int(eval(input()))\n(*var_1,) = list(map(int, input().split()))\nvar_4 = 0\nfor var_7 in product([-1, 0, 1], repeat=var_2):\n var_6 = reduce(\n lambda var_8, var_9: var_8 * var_9,\n [var_3 + var_7[var_5] for var_5, var_3 in enumerate(var_1)],\n )\n if var_6 % 2 == 0:\n var_4 += 1\nprint(var_4)\n```\n\n=== Code B (Modified) ===\n```python\ndef func_1():\n var_2 = int(eval(input()))\n var_1 = [int(var_6) for var_6 in input().split()]\n var_4 = 3**var_2\n var_5 = len([var_3 for var_3 in var_1 if var_3 % 2 == 0])\n var_4 -= 2**var_5\n print(var_4)\n\n\nif __name__ == \"__main__\":\n func_1()\n```", "output": "FASTER 9.2492", "pair_id": "python_p03568_forward", "problem_id": "p03568", "language": "python", "direction": "forward", "speedup_ratio": 608.5427} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_6 = str(var_4)\n var_5 = var_6[::-1]\n if var_6 == var_5:\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_5 in range(10):\n for var_6 in range(10):\n for var_7 in range(10):\n var_3 = 10000 * var_5 + 1000 * var_6 + 100 * var_7 + 10 * var_6 + var_5\n if var_1 <= var_3 <= var_2:\n var_4 += 1\nprint(var_4)\n```", "output": "FASTER 4.076", "pair_id": "python_p03416_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 16.8649} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_8 = int(eval(input()))\nvar_6 = []\nfor var_7 in range(var_8 - 1):\n var_1, var_3 = list(map(int, input().split()))\n var_6.append([var_1 - 1, var_3 - 1, var_7])\nvar_6.sort()\nvar_12 = [0] * (var_8)\nvar_2 = [0] * (var_8 - 1)\nvar_9 = 1\nvar_10 = 0\nfor var_5 in var_6:\n _from, var_11, var_7 = var_5\n if _from != var_10:\n var_9 = 1\n if var_12[_from] == var_9:\n var_9 += 1\n var_2[var_7] = var_9\n var_12[var_11] = var_9\n var_9 += 1\n var_10 = _from\nprint((max(var_2)))\nfor var_4 in var_2:\n print(var_4)\n```\n\n=== Code B (Modified) ===\n```python\nvar_11 = int(eval(input()))\nvar_12 = {var_8: [] for var_8 in range(1, var_11 + 1)}\nvar_19 = [False for var_8 in range(var_11 + 1)]\nvar_16 = []\nfor _ in range(var_11 - 1):\n var_2, var_3 = list(map(int, input().split()))\n var_12[var_2].append(var_3)\n var_12[var_3].append(var_2)\n var_16.append((var_2, var_3))\nvar_9 = var_16[0][0]\nvar_19[var_9] = True\nvar_6 = []\nvar_7 = []\nvar_14 = {var_8: {} for var_8 in range(1, var_11 + 1)}\nvar_10 = [0 for var_8 in range(var_11 + 1)]\n\nvar_4 = 1\nfor var_5 in var_12[var_9]:\n var_19[var_5] = True\n var_14[var_9][var_5] = var_4\n var_14[var_5][var_9] = var_4\n var_10[var_5] = var_4\n var_4 += 1\n var_6.append(var_5)\nwhile var_6:\n for var_15 in var_6:\n var_13 = 1\n for var_5 in var_12[var_15]:\n if var_19[var_5] == False:\n var_19[var_5] = True\n if var_13 != var_10[var_15]:\n var_14[var_15][var_5] = var_13\n var_14[var_5][var_15] = var_13\n var_10[var_5] = var_13\n var_13 += 1\n var_7.append(var_5)\n else:\n var_13 += 1\n var_14[var_15][var_5] = var_13\n var_14[var_5][var_15] = var_13\n var_10[var_5] = var_13\n var_13 += 1\n var_7.append(var_5)\n if var_7:\n var_6 = var_7\n var_7 = []\n else:\n var_6 = []\n var_7 = []\nvar_1 = 0\nfor var_8 in range(1, var_11 + 1):\n var_1 = max(var_1, len(var_12[var_8]))\nprint(var_1)\nfor var_8 in range(var_11 - 1):\n var_17, var_18 = var_16[var_8][0], var_16[var_8][1]\n print((var_14[var_17][var_18]))\n```", "output": "SLOWER 1.2591", "pair_id": "python_p02850_reversed", "problem_id": "p02850", "language": "python", "direction": "reversed", "speedup_ratio": 2.3934} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\nimport math\nfrom collections import defaultdict\nfrom bisect import bisect_left, bisect_right\n\nsys.setrecursionlimit(10**7)\n\n\ndef func_4():\n return sys.stdin.readline()[:-1]\n\n\nvar_4 = 10**9 + 7\n\n\ndef func_1():\n return int(eval(func_4()))\n\n\ndef func_2():\n return list(map(int, func_4().split()))\n\n\ndef func_3(var_6, var_3):\n if var_6 <= 0:\n return [[] for _ in range(var_3)]\n elif var_3 == 1:\n return [func_1() for _ in range(var_6)]\n else:\n var_5 = [func_2() for _ in range(var_6)]\n return list(map(list, list(zip(*var_5))))\n\n\nvar_1, var_2 = list(map(str, func_4().split()))\nvar_1 = int(var_1)\nvar_2 = 100 * int(var_2[0]) + 10 * int(var_2[2]) + int(var_2[3])\nprint((var_1 * var_2 // 100))\n```\n\n=== Code B (Modified) ===\n```python\ndef func_1():\n var_1, var_3 = input().split()\n var_1 = int(var_1)\n var_3 = int(float(var_3) * 100 + 0.5)\n var_2 = var_1 * var_3\n print((var_2 // 100))\n\n\nif __name__ == \"__main__\":\n func_1()\n```", "output": "FASTER 1.871", "pair_id": "python_p02659_forward", "problem_id": "p02659", "language": "python", "direction": "forward", "speedup_ratio": 3.6579} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\nimport numpy as np\n\nvar_6 = int(eval(input()))\n\nvar_1 = [input().replace(\" \", \"\") for var_4 in range(var_6)]\n\nvar_7 = [list(map(int, input().split())) for var_4 in range(var_6)]\nvar_11 = -999999999999999\nfor var_4 in range(1, 1024):\n var_3 = format(var_4, \"010b\")\n var_9 = 0\n for var_2, var_8 in zip(var_1, var_7):\n var_10 = 0\n for var_5 in range(10):\n if var_2[var_5] == \"1\" and var_3[var_5] == \"1\":\n var_10 += 1\n var_9 += var_8[var_10]\n if var_9 > var_11:\n if var_9 == 0:\n print((str(var_4)))\n break\n var_11 = var_9\nprint(var_11)\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\n\nvar_8 = sys.stdin.readline\n\n\ndef func_1():\n var_2 = int(eval(var_8()))\n var_1 = [int(var_8().replace(\" \", \"\"), 2) for _ in range(var_2)]\n var_3 = [list(map(int, var_8().split())) for _ in range(var_2)]\n var_4 = -(10**7) * var_2\n for var_7 in range(1, 1 << 10):\n var_10 = 0\n for var_9, var_6 in enumerate(var_1):\n var_5 = bin(var_7 & var_6).count(\"1\")\n var_10 += var_3[var_9][var_5]\n var_4 = max(var_4, var_10)\n print(var_4)\n\n\nif __name__ == \"__main__\":\n func_1()\n```", "output": "FASTER 2.2365", "pair_id": "python_p03503_forward", "problem_id": "p03503", "language": "python", "direction": "forward", "speedup_ratio": 4.7126} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport numpy as np\nfrom itertools import product\n\nvar_6 = int(eval(input()))\nvar_2 = list(map(int, input().split()))\nvar_2 = np.array(var_2)\nvar_5 = [-1, 0, 1]\nvar_3 = 0\nfor var_7 in product(var_5, repeat=var_6):\n var_7 = np.array(var_7)\n var_1 = var_2 + var_7\n var_4 = var_1.cumprod()\n if var_4[-1] % 2 == 0:\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nimport math\nimport string\n\n\ndef func_5():\n return list(map(int, input().split()))\n\n\ndef func_4(var_7, var_8):\n return math.factorial(var_7) // (\n math.factorial(var_7 - var_8) * math.factorial(var_8)\n )\n\n\ndef func_3(var_10):\n var_9 = []\n for var_5 in var_10:\n if not (var_5 in var_9):\n var_9.append(var_5)\n return len(var_10) != len(var_9)\n\n\ndef func_1(var_7):\n func_1 = []\n for var_4 in range(1, var_7 + 1):\n if var_7 % var_4 == 0:\n func_1.append(var_4)\n return func_1\n\n\nvar_2 = [-1, -1, -1, 0, 0, 1, 1, 1]\nvar_3 = [-1, 0, 1, -1, 1, -1, 0, 1]\nvar_7 = int(eval(input()))\nvar_1 = func_5()\n\n\ndef func_2(var_6):\n if len(var_6) == var_7:\n for var_4 in range(len(var_6)):\n if var_6[var_4] % 2 == 0:\n return 1\n return 0\n return (\n func_2(var_6 + [var_1[len(var_6)]])\n + func_2(var_6 + [var_1[len(var_6)] - 1])\n + func_2(var_6 + [var_1[len(var_6)] + 1])\n )\n\n\nprint((func_2([])))\n```", "output": "FASTER 2.3825", "pair_id": "python_p03568_forward", "problem_id": "p03568", "language": "python", "direction": "forward", "speedup_ratio": 5.2145} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = input().split()\nvar_1 = int(var_1)\nvar_2 = int(var_2.replace(\".\", \"\"))\nprint((var_1 * var_2 // 100))\n```\n\n=== Code B (Modified) ===\n```python\ndef func_1():\n from sys import setrecursionlimit, stdin\n from os import environ\n from collections import defaultdict, deque, Counter\n from math import ceil, floor, gcd\n from itertools import accumulate, combinations, combinations_with_replacement\n\n setrecursionlimit(10**6)\n var_7 = (\n (lambda *var_11: print(*var_11))\n if \"TERM_PROGRAM\" in environ\n else lambda *var_12: 0\n )\n var_8 = lambda: stdin.readline().rstrip()\n var_3 = lambda: list(map(int, var_8().split()))\n var_1 = lambda: int(var_8())\n var_4 = 10**9 + 7\n var_2 = 10**9 + 10\n var_9, var_10 = var_8().split()\n var_5 = int(var_9)\n var_6 = int(float(var_10) * 100 + 0.5)\n print(var_5 * var_6 // 100)\n\n\nfunc_1()\n```", "output": "SLOWER 2.2868", "pair_id": "python_p02659_reversed", "problem_id": "p02659", "language": "python", "direction": "reversed", "speedup_ratio": 4.8798} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_6, var_7 = list(map(int, input().split()))\nvar_1 = [list(map(int, input().split())) for _ in range(var_6)]\nvar_1.sort()\nvar_3 = [(6007) * [0] for _ in range(var_6 + 1)]\nvar_3[0][0] = 0\nvar_2 = 0\nfor var_4 in range(var_6):\n for var_5 in range(6007):\n var_3[var_4 + 1][var_5] = max(var_3[var_4 + 1][var_5], var_3[var_4][var_5])\n if var_5 < var_7:\n var_3[var_4 + 1][var_5 + var_1[var_4][0]] = max(\n var_3[var_4][var_5] + var_1[var_4][1],\n var_3[var_4][var_5 + var_1[var_4][0]],\n )\n var_2 = max(var_2, var_3[var_4 + 1][var_5])\nprint(var_2)\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\nfrom collections import deque\n\nvar_1 = int(10e10)\nvar_2 = -var_1\nvar_12 = 1000000007\nsys.setrecursionlimit(1000000)\n\n\ndef func_2():\n return list(map(int, input().split()))\n\n\ndef func_4():\n return input().split()\n\n\ndef func_1():\n return int(sys.stdin.readline())\n\n\ndef func_3():\n return eval(input())\n\n\nvar_3, var_4 = func_2()\nvar_6 = [func_2() for var_10 in range(var_3)]\nvar_6.sort()\nvar_7 = 0\nvar_9 = [[0] * var_4 for var_10 in range(var_3 + 1)]\nfor var_10 in range(1, var_3 + 1):\n var_5, var_8 = var_6[var_10 - 1]\n for var_11 in range(var_4):\n if 0 <= var_11 - var_5 < var_4:\n var_9[var_10][var_11] = max(\n var_9[var_10 - 1][var_11], var_9[var_10 - 1][var_11 - var_5] + var_8\n )\n else:\n var_9[var_10][var_11] = var_9[var_10 - 1][var_11]\n else:\n var_7 = max(var_7, var_9[var_10 - 1][-1] + var_8)\nprint(var_7)\n```", "output": "FASTER 5.6348", "pair_id": "python_p02863_forward", "problem_id": "p02863", "language": "python", "direction": "forward", "speedup_ratio": 49.688} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = list(reversed(list(str(var_4))))\n if var_5 == list(str(var_4)):\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_5 in range(10):\n for var_6 in range(10):\n for var_7 in range(10):\n var_3 = 10000 * var_5 + 1000 * var_6 + 100 * var_7 + 10 * var_6 + var_5\n if var_1 <= var_3 <= var_2:\n var_4 += 1\nprint(var_4)\n```", "output": "FASTER 5.4825", "pair_id": "python_p03416_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 44.7094} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\n\n\ndef func_1(var_5, var_6):\n var_4 = 0\n for var_3 in range(var_5, var_6 + 1):\n if str(var_3) == str(var_3)[::-1]:\n var_4 += 1\n return var_4\n\n\nprint((func_1(var_1, var_2)))\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\n\n\ndef func_1(var_5):\n var_4 = 0\n for var_3 in range(1, var_5 + 1):\n if str(var_3) == str(var_3)[::-1]:\n var_4 += 1\n return var_4\n\n\nprint((func_1(var_2) - func_1(var_1 - 1)))\n```", "output": "SLOWER 1.9143", "pair_id": "python_p03416_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 3.7692} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport numpy as np\nfrom itertools import product\n\nvar_6 = int(eval(input()))\nvar_2 = list(map(int, input().split()))\nvar_2 = np.array(var_2)\nvar_5 = [-1, 0, 1]\nvar_3 = 0\nfor var_7 in product(var_5, repeat=var_6):\n var_7 = np.array(var_7)\n var_1 = var_2 + var_7\n var_4 = var_1.cumprod()\n if var_4[-1] % 2 == 0:\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\ndef func_1():\n var_2 = int(input())\n var_1 = [int(var_6) for var_6 in input().split()]\n if var_2 == 1:\n return print(1 if var_1[0] % 2 == 0 else 2)\n var_3 = 0\n var_5 = (-1, 0, 1)\n from itertools import product\n\n for var_6 in product(range(3), repeat=var_2):\n var_4 = 1\n for var_7 in range(var_2):\n var_4 *= var_1[var_7] + var_5[var_6[var_7]]\n if var_4 % 2 == 0:\n var_3 += 1\n print(var_3)\n\n\nif __name__ == \"__main__\":\n func_1()\n```", "output": "FASTER 1.466", "pair_id": "python_p03568_forward", "problem_id": "p03568", "language": "python", "direction": "forward", "speedup_ratio": 2.7626} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().rstrip().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = list(map(int, list(str(var_4))))\n if var_5[0] == var_5[4] and var_5[1] == var_5[3]:\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\ndef func_1():\n var_1, var_2 = list(map(int, input().rstrip().split()))\n var_3 = 0\n for var_4 in range(var_1, var_2 + 1):\n var_5 = str(var_4)\n if var_5 == var_5[::-1]:\n var_3 += 1\n print(var_3)\n\n\nif __name__ == \"__main__\":\n func_1()\n```", "output": "FASTER 2.429", "pair_id": "python_p03416_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 5.3852} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_3 = list(map(int, input().split()))\nvar_2 = 0\nfor var_5 in range(var_3 + 1)[var_1:]:\n if len(str(var_5)) % 2 == 0:\n var_6 = list(str(var_5))[: len(str(var_5)) // 2]\n var_7 = list(reversed(list(str(var_5))[len(str(var_5)) // 2 :]))\n if var_6 == var_7:\n var_2 += 1\n else:\n var_8 = list(str(var_5))[: len(str(var_5)) // 2 + 1]\n var_4 = list(reversed(list(str(var_5))[len(str(var_5)) // 2 :]))\n if var_8 == var_4:\n var_2 += 1\nprint(var_2)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = list(str(var_4))\n if var_5 == list(reversed(var_5)):\n var_3 += 1\nprint(var_3)\n```", "output": "FASTER 1.2424", "pair_id": "python_p03416_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 2.3659} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_4 = int(eval(input()))\nvar_1 = 0\nif var_4 == 2:\n print((2))\nelse:\n for var_2 in range(var_4, 10**6):\n for var_3 in range(2, var_2 // 2 + 2):\n if var_2 % var_3 == 0:\n break\n else:\n var_1 = var_2\n break\n print(var_1)\n```\n\n=== Code B (Modified) ===\n```python\nimport bisect, copy, heapq, math, sys\nfrom collections import *\nfrom functools import lru_cache\nfrom itertools import accumulate, combinations, permutations, product\n\n\ndef func_2():\n return sys.stdin.readline()[:-1]\n\n\ndef func_4(var_8):\n return [0] + list(accumulate(var_8))\n\n\ndef func_1(var_1, var_4):\n return -(-var_1 // var_4)\n\n\nsys.setrecursionlimit(5000000)\nvar_9 = pow(10, 9) + 7\nvar_2 = [chr(ord(\"a\") + var_6) for var_6 in range(26)]\nvar_5 = [[1, 0], [0, 1], [-1, 0], [0, -1]]\nvar_11 = int(eval(func_2()))\n\n\ndef func_3(var_10):\n if var_10 == 1:\n return False\n for var_7 in range(2, int(math.sqrt(var_10)) + 1):\n if var_10 % var_7 == 0:\n return False\n return True\n\n\nvar_3 = var_11\nwhile not func_3(var_3):\n var_3 += 1\nprint(var_3)\n```", "output": "SLOWER 1.4219", "pair_id": "python_p02819_reversed", "problem_id": "p02819", "language": "python", "direction": "reversed", "speedup_ratio": 2.6793} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nfrom functools import reduce\nfrom itertools import product\n\nvar_2 = int(eval(input()))\n(*var_1,) = list(map(int, input().split()))\nvar_4 = 0\nfor var_7 in product([-1, 0, 1], repeat=var_2):\n var_6 = reduce(\n lambda var_8, var_9: var_8 * var_9,\n [var_3 + var_7[var_5] for var_5, var_3 in enumerate(var_1)],\n )\n if var_6 % 2 == 0:\n var_4 += 1\nprint(var_4)\n```\n\n=== Code B (Modified) ===\n```python\nimport math\nimport string\n\n\ndef func_5():\n return list(map(int, input().split()))\n\n\ndef func_4(var_7, var_8):\n return math.factorial(var_7) // (\n math.factorial(var_7 - var_8) * math.factorial(var_8)\n )\n\n\ndef func_3(var_10):\n var_9 = []\n for var_5 in var_10:\n if not (var_5 in var_9):\n var_9.append(var_5)\n return len(var_10) != len(var_9)\n\n\ndef func_1(var_7):\n func_1 = []\n for var_4 in range(1, var_7 + 1):\n if var_7 % var_4 == 0:\n func_1.append(var_4)\n return func_1\n\n\nvar_2 = [-1, -1, -1, 0, 0, 1, 1, 1]\nvar_3 = [-1, 0, 1, -1, 1, -1, 0, 1]\nvar_7 = int(eval(input()))\nvar_1 = func_5()\n\n\ndef func_2(var_6):\n if len(var_6) == var_7:\n for var_4 in range(len(var_6)):\n if var_6[var_4] % 2 == 0:\n return 1\n return 0\n return (\n func_2(var_6 + [var_1[len(var_6)]])\n + func_2(var_6 + [var_1[len(var_6)] - 1])\n + func_2(var_6 + [var_1[len(var_6)] + 1])\n )\n\n\nprint((func_2([])))\n```", "output": "FASTER 2.116", "pair_id": "python_p03568_forward", "problem_id": "p03568", "language": "python", "direction": "forward", "speedup_ratio": 4.3349} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_2 = int(eval(input()))\nvar_1 = list(map(int, input().split()))\nvar_4 = 1\nfor var_3 in range(var_2):\n if var_1[var_3] % 2 == 0:\n var_4 *= 2\nprint((3**var_2 - var_4))\n```\n\n=== Code B (Modified) ===\n```python\nimport numpy as np\nfrom itertools import product\n\nvar_6 = int(eval(input()))\nvar_2 = list(map(int, input().split()))\nvar_2 = np.array(var_2)\nvar_5 = [-1, 0, 1]\nvar_3 = 0\nfor var_7 in product(var_5, repeat=var_6):\n var_7 = np.array(var_7)\n var_1 = var_2 + var_7\n var_4 = var_1.cumprod()\n if var_4[-1] % 2 == 0:\n var_3 += 1\nprint(var_3)\n```", "output": "SLOWER 10.0427", "pair_id": "python_p03568_reversed", "problem_id": "p03568", "language": "python", "direction": "reversed", "speedup_ratio": 1054.7734} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = [0] * (var_2 + 1)\nfor var_3 in range(1, var_2 + 1):\n if str(var_3) == str(var_3)[::-1]:\n var_4[var_3] = var_4[var_3 - 1] + 1\n else:\n var_4[var_3] = var_4[var_3 - 1]\nprint((var_4[var_2] - var_4[var_1 - 1]))\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = str(var_4)\n if var_5[0] == var_5[4] and var_5[1] == var_5[3]:\n var_3 += 1\nprint(var_3)\n```", "output": "FASTER 2.2084", "pair_id": "python_p03416_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 4.6217} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_8 in range(var_1, var_2 + 1):\n var_7 = str(var_8)\n var_6 = len(var_7)\n var_4 = True\n for var_5 in range(var_6 // 2):\n if var_7[var_5] != var_7[var_6 - 1 - var_5]:\n var_4 = False\n break\n if var_4:\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\ndef func_1():\n var_1, var_2 = list(map(int, input().rstrip().split()))\n var_3 = 0\n for var_4 in range(var_1, var_2 + 1):\n var_5 = str(var_4)\n if var_5 == var_5[::-1]:\n var_3 += 1\n print(var_3)\n\n\nif __name__ == \"__main__\":\n func_1()\n```", "output": "FASTER 1.8722", "pair_id": "python_p03416_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 3.661} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = input().split()\nvar_1 = int(var_1)\nvar_2 = int(var_2)\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = list(str(var_4))\n if (var_5[0] == var_5[4]) and (var_5[1] == var_5[3]):\n var_3 = var_3 + 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\ndef func_1():\n var_1, var_2 = list(map(int, input().rstrip().split()))\n var_3 = 0\n for var_4 in range(var_1, var_2 + 1):\n var_5 = str(var_4)\n if var_5 == var_5[::-1]:\n var_3 += 1\n print(var_3)\n\n\nif __name__ == \"__main__\":\n func_1()\n```", "output": "FASTER 1.1503", "pair_id": "python_p03416_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 2.2196} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nimport math\n\nif math.ceil((var_1 + 1) * 12.5) <= math.ceil(var_2 * 10) or math.ceil(\n var_1 * 12.5\n) >= math.ceil((var_2 + 1) * 10):\n print((-1))\nelse:\n print((max(math.ceil(var_1 * 12.5), math.ceil(var_2 * 10))))\n```\n\n=== Code B (Modified) ===\n```python\nfrom math import floor\n\nvar_1, var_2 = list(map(int, input().split()))\n\n\nfor var_3 in range(1010):\n if (floor(var_3 * 0.08) == var_1) and (floor(var_3 * 0.1) == var_2):\n\n print(var_3)\n quit()\n\n\nprint((-1))\n```", "output": "SLOWER 1.8508", "pair_id": "python_p02755_reversed", "problem_id": "p02755", "language": "python", "direction": "reversed", "speedup_ratio": 3.6071} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport math\n\n\ndef func_1():\n var_1, var_2 = list(map(int, input().split()))\n\n var_5 = max(math.ceil(var_1 / 0.08), math.ceil(var_2 / 0.1))\n\n var_4 = min((math.ceil((var_1 + 1) / 0.08), math.ceil((var_2 + 1) / 0.1)))\n\n for var_3 in range(var_5, var_4 + 1):\n if (math.floor(var_3 * 0.08) == var_1) and (math.floor(var_3 * 0.1) == var_2):\n print(var_3)\n quit()\n\n print((-1))\n\n\nif __name__ == \"__main__\":\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nfrom math import floor\n\nvar_1, var_2 = list(map(int, input().split()))\n\n\nfor var_3 in range(1010):\n if (floor(var_3 * 0.08) == var_1) and (floor(var_3 * 0.1) == var_2):\n\n print(var_3)\n quit()\n\n\nprint((-1))\n```", "output": "SLOWER 1.1074", "pair_id": "python_p02755_reversed", "problem_id": "p02755", "language": "python", "direction": "reversed", "speedup_ratio": 2.1545} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_2, var_1 = [int(var_12) for var_12 in input().split()]\nvar_3 = []\nfor var_8 in range(var_1):\n var_5, var_6 = [int(var_12) for var_12 in input().split()]\n var_3.append((var_5, var_6))\nvar_3.sort()\nvar_9 = float(\"inf\")\nvar_4 = [var_9 for var_5 in range(var_2 + 1)]\nfor var_5, var_6 in var_3:\n var_4[var_5] = min(var_4[var_5], var_6)\nvar_3 = [\n (var_5, var_4[var_5]) for var_5 in range(1, var_2 + 1) if var_4[var_5] != var_9\n]\nvar_3.sort(key=lambda var_11: var_11[1])\nvar_7 = [True] * (var_2)\nvar_10 = None\nfor var_5, var_6 in var_3:\n if var_10 == None or var_10 < var_5:\n var_7[var_6 - 1] = False\n var_10 = var_6 - 1\nprint((sum(1 for var_6 in var_7 if not var_6)))\n```\n\n=== Code B (Modified) ===\n```python\nvar_7, var_6 = list(map(int, input().split(\" \")))\nvar_2 = [list(map(int, input().split(\" \"))) for _ in range(var_6)]\nvar_2.sort(key=lambda var_8: var_8[1])\nvar_5 = 0\nvar_4 = 0\nfor var_1, var_3 in var_2:\n if var_4 > var_1:\n continue\n var_4 = var_3\n var_5 += 1\nprint(var_5)\n```", "output": "FASTER 1.0821", "pair_id": "python_p03295_forward", "problem_id": "p03295", "language": "python", "direction": "forward", "speedup_ratio": 2.1171} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\n\"\"\"\"\"\"\n\nfrom collections import deque\n\n\ndef func_1():\n var_5, *var_1 = list(map(int, open(0).read().split()))\n var_2 = var_1[1::2]\n var_4 = [[] for _ in range(var_5 + 1)]\n for var_7, var_8 in zip(*[iter(var_1)] * 2):\n var_4[var_7].append(var_8)\n var_6 = deque([1])\n var_3 = [0] * (var_5 + 1)\n while var_6:\n var_11 = var_6.popleft()\n var_9 = 0\n for var_10 in var_4[var_11]:\n var_9 += 1 + (var_9 + 1 == var_3[var_11])\n var_3[var_10] = var_9\n var_6.append(var_10)\n print((max(var_3)))\n for var_8 in var_2:\n print((var_3[var_8]))\n\n\nfunc_1()\n```\n\n=== Code B (Modified) ===\n```python\nimport copy\n\nvar_8 = int(eval(input()))\nvar_10 = set([var_6 for var_6 in range(1, 10**5)])\nvar_5 = []\nvar_11 = {}\nvar_9 = []\nfor var_6 in range(var_8 - 1):\n var_1, var_2 = list(map(int, input().split(\" \")))\n var_5.append([var_1, var_2])\n var_11.setdefault(var_1, []).append(var_2)\n var_9.append([])\nvar_9.append([])\nvar_9.append([])\nvar_7 = 0\nfor var_12 in range(1, var_8 + 1):\n var_14 = var_11.get(var_12, [])\n var_3 = 1\n for var_13 in var_14:\n if var_3 in var_9[var_12]:\n var_3 += 1\n else:\n pass\n var_9[var_13].append(var_3)\n if var_3 >= var_7:\n var_7 = var_3\n var_3 += 1\nprint(var_7)\nfor var_4 in var_5:\n print((var_9[var_4[1]][0]))\n```", "output": "SLOWER 4.6186", "pair_id": "python_p02850_reversed", "problem_id": "p02850", "language": "python", "direction": "reversed", "speedup_ratio": 24.5662} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\n\nsys.setrecursionlimit(2147483647)\nvar_2 = float(\"inf\")\nvar_3 = 10**9 + 7\nvar_10 = lambda: sys.stdin.readline().rstrip()\n\n\ndef func_1():\n var_11, var_4 = list(map(int, var_10().split()))\n var_1 = [tuple(map(int, var_10().split())) for _ in range(var_11)]\n var_1.sort()\n var_8 = [0] * var_4\n var_6 = -var_2\n for var_9 in range(var_11):\n var_5, var_7 = var_1[var_9]\n var_12 = var_8[:]\n for var_13 in range(var_4):\n if var_13 + var_5 < var_4:\n var_12[var_13 + var_5] = max(\n var_12[var_13 + var_5], var_8[var_13] + var_7\n )\n else:\n var_6 = max(var_6, var_8[var_13] + var_7)\n var_8 = var_12\n print((max(var_6, max(var_8))))\n\n\nfunc_1()\n```\n\n=== Code B (Modified) ===\n```python\nimport bisect\nimport sys\n\nsys.setrecursionlimit(10**6)\nvar_17 = sys.stdout.write\nvar_7 = lambda *var_15: print(*var_15) if var_1 else 0\nvar_1 = True\n\n\ndef func_1(var_10=sys.stdin.readline):\n var_12 = lambda: var_10().rstrip()\n var_3 = lambda: list(map(int, var_12().split()))\n var_2 = lambda: int(var_12())\n var_4 = lambda var_18: [var_3() for _ in range(var_18)]\n var_14, var_16 = var_3()\n var_5 = var_4(var_14)\n var_8 = [[0] * var_16 for _ in range(var_14)]\n for var_11 in range(1, var_14):\n for var_13 in range(1, var_16):\n if var_13 < var_5[var_11 - 1][0]:\n var_8[var_11][var_13] = var_8[var_11 - 1][var_13]\n else:\n var_8[var_11][var_13] = max(\n var_8[var_11 - 1][var_13],\n var_8[var_11 - 1][var_13 - var_5[var_11 - 1][0]]\n + var_5[var_11 - 1][1],\n )\n var_9 = [[0] * var_16 for _ in range(var_14)]\n for var_11 in range(1, var_14):\n for var_13 in range(1, var_16):\n if var_13 < var_5[var_14 - var_11][0]:\n var_9[var_11][var_13] = var_9[var_11 - 1][var_13]\n else:\n var_9[var_11][var_13] = max(\n var_9[var_11 - 1][var_13],\n var_9[var_11 - 1][var_13 - var_5[var_14 - var_11][0]]\n + var_5[var_14 - var_11][1],\n )\n var_6 = 0\n for var_11 in range(var_14):\n for var_13 in range(var_16 - 1):\n var_6 = max(\n var_6,\n var_8[var_11][var_13]\n + var_9[var_14 - var_11 - 1][var_16 - var_13 - 1]\n + var_5[var_11][1],\n )\n print(var_6)\n\n\nif __name__ == \"__main__\":\n func_1()\n```", "output": "SLOWER 1.4425", "pair_id": "python_p02863_reversed", "problem_id": "p02863", "language": "python", "direction": "reversed", "speedup_ratio": 2.718} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_3 = list(map(int, input().split()))\nvar_2 = -1\nfor var_4 in range(10, 12501):\n if int(var_4 * 0.08) == var_1 and int(var_4 * 0.1) == var_3:\n var_2 = var_4\n break\nprint(var_2)\n```\n\n=== Code B (Modified) ===\n```python\nimport math\n\nvar_1, var_4 = (int(var_10) for var_10 in input().split())\nvar_2 = math.ceil(var_1 / 0.08)\nvar_3 = math.ceil((var_1 + 1) / 0.08)\n\"\"\"\"\"\"\nvar_5 = math.ceil(var_4 / 0.1)\nvar_6 = math.ceil((var_4 + 1) / 0.1)\n\"\"\"\"\"\"\nvar_7 = list(range(var_2, var_3))\nvar_8 = list(range(var_5, var_6))\nvar_9 = set(var_7) & set(var_8)\nif len(var_9) == 0:\n print((-1))\nelse:\n print((min(var_9)))\n```", "output": "FASTER 4.5892", "pair_id": "python_p02755_forward", "problem_id": "p02755", "language": "python", "direction": "forward", "speedup_ratio": 24.0708} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport copy\n\nvar_8 = int(eval(input()))\nvar_10 = set([var_6 for var_6 in range(1, 10**5)])\nvar_5 = []\nvar_11 = {}\nvar_9 = []\nfor var_6 in range(var_8 - 1):\n var_1, var_2 = list(map(int, input().split(\" \")))\n var_5.append([var_1, var_2])\n var_11.setdefault(var_1, []).append(var_2)\n var_9.append([])\nvar_9.append([])\nvar_9.append([])\nvar_7 = 0\nfor var_12 in range(1, var_8 + 1):\n var_14 = var_11.get(var_12, [])\n var_3 = 1\n for var_13 in var_14:\n if var_3 in var_9[var_12]:\n var_3 += 1\n else:\n pass\n var_9[var_13].append(var_3)\n if var_3 >= var_7:\n var_7 = var_3\n var_3 += 1\nprint(var_7)\nfor var_4 in var_5:\n print((var_9[var_4[1]][0]))\n```\n\n=== Code B (Modified) ===\n```python\nfrom collections import deque\n\nvar_9 = int(eval(input()))\nvar_6 = {var_7: dict() for var_7 in range(var_9)}\nvar_2 = [0] * (var_9 - 1)\nvar_4 = [0] * (var_9 - 1)\nfor var_7 in range(var_9 - 1):\n var_1, var_3 = list(map(int, input().split()))\n var_2[var_7] = var_1 - 1\n var_4[var_7] = var_3 - 1\n var_6[var_1 - 1][var_3 - 1] = -1\n var_6[var_3 - 1][var_1 - 1] = -1\nvar_8 = max([len(var_6[var_1]) for var_1 in range(var_9)])\nvar_13 = [-1] * var_9\nvar_13[0] = var_8 - 1\n\nvar_12 = deque([0])\nwhile len(var_12) > 0:\n var_10 = var_12.popleft()\n var_5 = var_13[var_10]\n for var_11 in list(var_6[var_10].keys()):\n if var_13[var_11] != -1:\n continue\n var_5 += 1\n var_5 %= var_8\n\n var_6[var_10][var_11] = var_5\n var_6[var_11][var_10] = var_5\n var_13[var_11] = var_5\n var_12.append(var_11)\nprint(var_8)\nfor var_7 in range(var_9 - 1):\n print((var_6[var_2[var_7]][var_4[var_7]] + 1))\n```", "output": "FASTER 4.1649", "pair_id": "python_p02850_forward", "problem_id": "p02850", "language": "python", "direction": "forward", "speedup_ratio": 17.9377} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\ndef func_1():\n var_2 = int(input())\n var_1 = [int(var_6) for var_6 in input().split()]\n if var_2 == 1:\n return print(1 if var_1[0] % 2 == 0 else 2)\n var_3 = 0\n var_5 = (-1, 0, 1)\n from itertools import product\n\n for var_6 in product(range(3), repeat=var_2):\n var_4 = 1\n for var_7 in range(var_2):\n var_4 *= var_1[var_7] + var_5[var_6[var_7]]\n if var_4 % 2 == 0:\n var_3 += 1\n print(var_3)\n\n\nif __name__ == \"__main__\":\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nvar_2 = int(eval(input()))\n(*var_1,) = list(map(int, input().split()))\nvar_5 = 0\nfor var_3 in var_1:\n if var_3 % 2 == 0:\n var_5 += 1\nvar_4 = 3**var_2 - 2**var_5\nprint(var_4)\n```", "output": "FASTER 8.5619", "pair_id": "python_p03568_forward", "problem_id": "p03568", "language": "python", "direction": "forward", "speedup_ratio": 377.9172} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nfrom sys import stdin\n\nvar_5 = stdin.readline\nvar_2, var_1 = list(map(int, var_5().split()))\nvar_3 = [False] * var_2\nvar_8 = [0] * var_2\nvar_9 = 0\nfor var_4 in range(var_1):\n var_6, var_7 = var_5().split()\n var_6 = int(var_6) - 1\n if var_3[var_6] is False and var_7 == \"AC\":\n var_9 += var_8[var_6]\n var_3[var_6] = True\n elif var_7 == \"WA\":\n var_8[var_6] += 1\nprint((var_3.count(True), var_9))\n```\n\n=== Code B (Modified) ===\n```python\nvar_7, var_6 = list(map(int, input().split()))\nvar_5 = [tuple(input().split()) for _ in range(var_6)]\nvar_9 = [[] for _ in range(var_7)]\nfor var_2 in range(var_6):\n var_9[int(var_5[var_2][0]) - 1].append(var_5[var_2][1])\nvar_1, var_8 = 0, 0\nfor var_3 in range(var_7):\n if \"AC\" in var_9[var_3]:\n var_1 += 1\n for var_4 in range(len(var_9[var_3])):\n if var_9[var_3][var_4] == \"WA\":\n var_8 += 1\n else:\n break\nprint((var_1, var_8))\n```", "output": "SLOWER 3.0644", "pair_id": "python_p02802_reversed", "problem_id": "p02802", "language": "python", "direction": "reversed", "speedup_ratio": 8.3654} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\ndef func_1():\n var_2 = int(input())\n var_1 = [int(var_6) for var_6 in input().split()]\n if var_2 == 1:\n return print(1 if var_1[0] % 2 == 0 else 2)\n var_3 = 0\n var_5 = (-1, 0, 1)\n from itertools import product\n\n for var_6 in product(range(3), repeat=var_2):\n var_4 = 1\n for var_7 in range(var_2):\n var_4 *= var_1[var_7] + var_5[var_6[var_7]]\n if var_4 % 2 == 0:\n var_3 += 1\n print(var_3)\n\n\nif __name__ == \"__main__\":\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nfrom itertools import product\n\nvar_6 = int(eval(input()))\nvar_1 = list(map(int, input().split()))\nvar_5 = 0\nfor var_2 in product((-1, 0, 1), repeat=var_6):\n var_7 = 1\n for var_3, var_4 in zip(var_1, var_2):\n var_7 *= var_3 + var_4\n if var_7 % 2 == 0:\n var_5 += 1\nprint(var_5)\n```", "output": "SLOWER 1.47", "pair_id": "python_p03568_reversed", "problem_id": "p03568", "language": "python", "direction": "reversed", "speedup_ratio": 2.7702} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\n\n\ndef func_1(var_5):\n var_4 = 0\n for var_3 in range(1, var_5 + 1):\n if str(var_3) == str(var_3)[::-1]:\n var_4 += 1\n return var_4\n\n\nprint((func_1(var_2) - func_1(var_1 - 1)))\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_4 = str(var_4)\n if var_4[0] == var_4[-1] and var_4[1] == var_4[-2]:\n var_3 += 1\nprint(var_3)\n```", "output": "FASTER 1.7743", "pair_id": "python_p03416_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 3.4208} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = input().split()\nvar_1 = int(var_1)\nvar_2 = int(var_2)\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = list(str(var_4))\n if (var_5[0] == var_5[4]) and (var_5[1] == var_5[3]):\n var_3 = var_3 + 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_5 in range(10):\n for var_6 in range(10):\n for var_7 in range(10):\n var_3 = 10000 * var_5 + 1000 * var_6 + 100 * var_7 + 10 * var_6 + var_5\n if var_1 <= var_3 <= var_2:\n var_4 += 1\nprint(var_4)\n```", "output": "FASTER 4.2299", "pair_id": "python_p03416_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 18.7637} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_6, var_7 = list(map(int, input().split()))\nvar_1 = [list(map(int, input().split())) for _ in range(var_6)]\nvar_1.sort()\nvar_3 = [(6007) * [0] for _ in range(var_6 + 1)]\nvar_3[0][0] = 0\nvar_2 = 0\nfor var_4 in range(var_6):\n for var_5 in range(6007):\n var_3[var_4 + 1][var_5] = max(var_3[var_4 + 1][var_5], var_3[var_4][var_5])\n if var_5 < var_7:\n var_3[var_4 + 1][var_5 + var_1[var_4][0]] = max(\n var_3[var_4][var_5] + var_1[var_4][1],\n var_3[var_4][var_5 + var_1[var_4][0]],\n )\n var_2 = max(var_2, var_3[var_4 + 1][var_5])\nprint(var_2)\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\n\nsys.setrecursionlimit(2147483647)\nvar_2 = float(\"inf\")\nvar_3 = 10**9 + 7\nvar_10 = lambda: sys.stdin.readline().rstrip()\n\n\ndef func_1():\n var_11, var_4 = list(map(int, var_10().split()))\n var_1 = [tuple(map(int, var_10().split())) for _ in range(var_11)]\n var_1.sort()\n var_8 = [0] * var_4\n var_6 = -var_2\n for var_9 in range(var_11):\n var_5, var_7 = var_1[var_9]\n var_12 = var_8[:]\n for var_13 in range(var_4):\n if var_13 + var_5 < var_4:\n var_12[var_13 + var_5] = max(\n var_12[var_13 + var_5], var_8[var_13] + var_7\n )\n else:\n var_6 = max(var_6, var_8[var_13] + var_7)\n var_8 = var_12\n print((max(var_6, max(var_8))))\n\n\nfunc_1()\n```", "output": "FASTER 6.7598", "pair_id": "python_p02863_forward", "problem_id": "p02863", "language": "python", "direction": "forward", "speedup_ratio": 108.3692} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\ndef func_1():\n from sys import setrecursionlimit, stdin\n from os import environ\n from collections import defaultdict, deque, Counter\n from math import ceil, floor, gcd\n from itertools import accumulate, combinations, combinations_with_replacement\n\n setrecursionlimit(10**6)\n var_7 = (\n (lambda *var_11: print(*var_11))\n if \"TERM_PROGRAM\" in environ\n else lambda *var_12: 0\n )\n var_8 = lambda: stdin.readline().rstrip()\n var_3 = lambda: list(map(int, var_8().split()))\n var_1 = lambda: int(var_8())\n var_4 = 10**9 + 7\n var_2 = 10**9 + 10\n var_9, var_10 = var_8().split()\n var_5 = int(var_9)\n var_6 = int(float(var_10) * 100 + 0.5)\n print(var_5 * var_6 // 100)\n\n\nfunc_1()\n```\n\n=== Code B (Modified) ===\n```python\nimport math\n\nvar_1, var_2 = input().split()\nvar_1 = int(var_1)\nvar_3 = int(var_2[0] + var_2[2] + var_2[3])\nprint((var_1 * var_3 // 100))\n```", "output": "FASTER 2.0604", "pair_id": "python_p02659_forward", "problem_id": "p02659", "language": "python", "direction": "forward", "speedup_ratio": 4.1709} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().rstrip().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = list(map(int, list(str(var_4))))\n if var_5[0] == var_5[4] and var_5[1] == var_5[3]:\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = input().split()\nvar_1 = int(var_1)\nvar_2 = int(var_2)\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = list(str(var_4))\n if (var_5[0] == var_5[4]) and (var_5[1] == var_5[3]):\n var_3 = var_3 + 1\nprint(var_3)\n```", "output": "FASTER 1.2787", "pair_id": "python_p03416_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 2.4262} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().strip().split(\" \")))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n if str(var_4) == str(var_4)[::-1]:\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = list(reversed(list(str(var_4))))\n if var_5 == list(str(var_4)):\n var_3 += 1\nprint(var_3)\n```", "output": "SLOWER 1.3497", "pair_id": "python_p03416_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 2.5486} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_3 = list(map(int, input().split()))\nvar_2 = -1\nfor var_4 in range(10, 12501):\n if int(var_4 * 0.08) == var_1 and int(var_4 * 0.1) == var_3:\n var_2 = var_4\n break\nprint(var_2)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_2 = var_2 / 0.1\nvar_3 = [var_4 + var_2 for var_4 in range(10)]\nfor var_4 in var_3:\n if int(var_4 * 0.08) == var_1:\n print((int(var_4)))\n exit()\nprint(\"-1\")\n```", "output": "FASTER 5.3061", "pair_id": "python_p02755_forward", "problem_id": "p02755", "language": "python", "direction": "forward", "speedup_ratio": 39.5622} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = list(str(var_4))\n if var_5 == list(reversed(var_5)):\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_4 = str(var_4)\n if var_4[0] == var_4[-1] and var_4[1] == var_4[-2]:\n var_3 += 1\nprint(var_3)\n```", "output": "FASTER 1.4159", "pair_id": "python_p03416_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 2.6682} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\nfrom collections import deque\n\nvar_1 = int(10e10)\nvar_2 = -var_1\nvar_12 = 1000000007\nsys.setrecursionlimit(1000000)\n\n\ndef func_2():\n return list(map(int, input().split()))\n\n\ndef func_4():\n return input().split()\n\n\ndef func_1():\n return int(sys.stdin.readline())\n\n\ndef func_3():\n return eval(input())\n\n\nvar_3, var_4 = func_2()\nvar_6 = [func_2() for var_10 in range(var_3)]\nvar_6.sort()\nvar_7 = 0\nvar_9 = [[0] * var_4 for var_10 in range(var_3 + 1)]\nfor var_10 in range(1, var_3 + 1):\n var_5, var_8 = var_6[var_10 - 1]\n for var_11 in range(var_4):\n if 0 <= var_11 - var_5 < var_4:\n var_9[var_10][var_11] = max(\n var_9[var_10 - 1][var_11], var_9[var_10 - 1][var_11 - var_5] + var_8\n )\n else:\n var_9[var_10][var_11] = var_9[var_10 - 1][var_11]\n else:\n var_7 = max(var_7, var_9[var_10 - 1][-1] + var_8)\nprint(var_7)\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\n\nsys.setrecursionlimit(2147483647)\nvar_2 = float(\"inf\")\nvar_3 = 10**9 + 7\nvar_10 = lambda: sys.stdin.readline().rstrip()\n\n\ndef func_1():\n var_11, var_4 = list(map(int, var_10().split()))\n var_1 = [tuple(map(int, var_10().split())) for _ in range(var_11)]\n var_1.sort()\n var_8 = [0] * var_4\n var_6 = -var_2\n for var_9 in range(var_11):\n var_5, var_7 = var_1[var_9]\n var_12 = var_8[:]\n for var_13 in range(var_4):\n if var_13 + var_5 < var_4:\n var_12[var_13 + var_5] = max(\n var_12[var_13 + var_5], var_8[var_13] + var_7\n )\n else:\n var_6 = max(var_6, var_8[var_13] + var_7)\n var_8 = var_12\n print((max(var_6, max(var_8))))\n\n\nfunc_1()\n```", "output": "FASTER 1.125", "pair_id": "python_p02863_forward", "problem_id": "p02863", "language": "python", "direction": "forward", "speedup_ratio": 2.181} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_10 = []\nvar_10 = input().rstrip().split(\" \")\nvar_1 = int(var_10[0])\nvar_3 = int(var_10[1])\nvar_2 = 0\nvar_6 = var_1\nwhile var_6 <= var_3:\n var_4 = var_6 // 10000\n var_5 = (var_6 - var_4 * 10000) // 1000\n var_7 = var_6 // 100\n var_8 = (var_6 - var_7 * 100) // 10\n var_9 = var_6 % 10\n if (var_4 == var_9) and (var_5 == var_8):\n var_2 += 1\n var_6 += 1\nprint(var_2)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_3 = list(map(int, input().split()))\nvar_2 = 0\nfor var_5 in range(var_3 + 1)[var_1:]:\n if len(str(var_5)) % 2 == 0:\n var_6 = list(str(var_5))[: len(str(var_5)) // 2]\n var_7 = list(reversed(list(str(var_5))[len(str(var_5)) // 2 :]))\n if var_6 == var_7:\n var_2 += 1\n else:\n var_8 = list(str(var_5))[: len(str(var_5)) // 2 + 1]\n var_4 = list(reversed(list(str(var_5))[len(str(var_5)) // 2 :]))\n if var_8 == var_4:\n var_2 += 1\nprint(var_2)\n```", "output": "SLOWER 1.6655", "pair_id": "python_p03416_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 3.1723} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\n\nvar_10 = sys.stdin.readline\nvar_2, var_3 = list(map(int, var_10().split()))\nvar_1 = [list(map(int, var_10().split())) for _ in range(var_2)]\nvar_8 = [[0 for _ in range(var_2 + 1)] for _ in range(var_3 + 1)]\n\nvar_13 = [[0 for _ in range(var_2 + 1)] for _ in range(var_3 + 1)]\nfor var_11 in range(var_2):\n var_4, var_6 = var_1[var_11]\n for var_15 in range(var_3):\n if var_4 > var_15:\n var_8[var_15][var_11 + 1] = var_8[var_15][var_11]\n var_13[var_15][var_11 + 1] = var_15\n else:\n if var_6 + var_8[var_15 - var_4][var_11] >= var_8[var_15][var_11]:\n var_8[var_15][var_11 + 1] = var_8[var_15 - var_4][var_11] + var_6\n var_13[var_15][var_11 + 1] = var_15 - var_4\n else:\n var_8[var_15][var_11 + 1] = var_8[var_15][var_11]\n var_13[var_15][var_11 + 1] = var_15\nvar_5 = var_8[var_3 - 1][var_2]\nvar_14 = [False] * var_2\nvar_7 = var_3 - 1\nfor var_9 in reversed(list(range(var_2))):\n if var_13[var_7][var_9 + 1] == var_7 - var_1[var_9][0]:\n var_14[var_9] = True\n var_7 = var_13[var_7][var_9 + 1]\nvar_12 = 0\nfor var_9 in range(var_2):\n if not var_14[var_9] and var_1[var_9][1] > var_12:\n var_12 = var_1[var_9][1]\nprint((var_5 + var_12))\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\n\nsys.setrecursionlimit(2147483647)\nvar_2 = float(\"inf\")\nvar_3 = 10**9 + 7\nvar_10 = lambda: sys.stdin.readline().rstrip()\n\n\ndef func_1():\n var_11, var_4 = list(map(int, var_10().split()))\n var_1 = [tuple(map(int, var_10().split())) for _ in range(var_11)]\n var_1.sort()\n var_8 = [0] * var_4\n var_6 = -var_2\n for var_9 in range(var_11):\n var_5, var_7 = var_1[var_9]\n var_12 = var_8[:]\n for var_13 in range(var_4):\n if var_13 + var_5 < var_4:\n var_12[var_13 + var_5] = max(\n var_12[var_13 + var_5], var_8[var_13] + var_7\n )\n else:\n var_6 = max(var_6, var_8[var_13] + var_7)\n var_8 = var_12\n print((max(var_6, max(var_8))))\n\n\nfunc_1()\n```", "output": "FASTER 1.5241", "pair_id": "python_p02863_forward", "problem_id": "p02863", "language": "python", "direction": "forward", "speedup_ratio": 2.8761} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\ndef func_1():\n var_1, var_2 = list(map(int, input().split()))\n var_3 = 0\n for var_4 in range(var_1, var_2 + 1):\n\n if (var_4 % 10) == (var_4 // 10000 % 10) and (var_4 // 10 % 10) == (\n var_4 // 1000 % 10\n ):\n var_3 += 1\n print(var_3)\n\n\nif __name__ == \"__main__\":\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nvar_4 = {}\nvar_5 = 0\nfor var_6 in range(10000, 100000):\n var_3 = list(str(var_6))\n if var_3 == list(reversed(var_3)):\n var_5 += 1\n var_4[var_6] = var_5\nvar_1, var_2 = list(map(int, input().split()))\nprint((var_4[var_2] - var_4[var_1 - 1] if var_1 > 10000 else var_4[var_2]))\n```", "output": "SLOWER 5.2377", "pair_id": "python_p03416_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 37.7303} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_3 = list(map(int, input().split()))\nvar_2 = -1\nfor var_4 in range(10, 12501):\n if int(var_4 * 0.08) == var_1 and int(var_4 * 0.1) == var_3:\n var_2 = var_4\n break\nprint(var_2)\n```\n\n=== Code B (Modified) ===\n```python\nfrom math import floor\n\nvar_1, var_2 = list(map(int, input().split()))\n\n\nfor var_3 in range(1010):\n if (floor(var_3 * 0.08) == var_1) and (floor(var_3 * 0.1) == var_2):\n\n print(var_3)\n quit()\n\n\nprint((-1))\n```", "output": "FASTER 3.4688", "pair_id": "python_p02755_forward", "problem_id": "p02755", "language": "python", "direction": "forward", "speedup_ratio": 11.0714} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nfrom collections import Counter, defaultdict, deque\nfrom heapq import heappop, heappush, heapify\nimport sys, bisect, math, itertools, fractions, pprint\n\nsys.setrecursionlimit(10**8)\nvar_6 = 10**9 + 7\nvar_1 = float(\"inf\")\n\n\ndef func_1():\n return int(sys.stdin.readline())\n\n\ndef func_2():\n return list(map(int, sys.stdin.readline().split()))\n\n\nvar_7, var_9 = func_2()\nvar_13 = [func_2() for _ in range(var_7)]\nvar_13.sort(key=lambda var_14: var_14[1], reverse=True)\nvar_8 = 0\nvar_10 = min(var_7, 5)\nfor var_3 in range(var_10):\n var_2 = [[0] * (var_9 + 5) for _ in range(var_7 + 5)]\n for var_4 in range(var_7):\n var_12, var_11 = var_13[var_4]\n for var_5 in range(var_9):\n if var_5 < var_12 or var_3 == var_4:\n var_2[var_4 + 1][var_5] = var_2[var_4][var_5]\n else:\n var_2[var_4 + 1][var_5] = max(\n var_2[var_4][var_5], var_2[var_4][var_5 - var_12] + var_11\n )\n\n var_8 = max(var_2[var_7][var_9 - 1] + var_13[var_3][1], var_8)\nprint(var_8)\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\nfrom operator import itemgetter\nfrom heapq import heapify, heappop, heappush\n\nvar_1 = int(10e15)\nvar_2 = -var_1\nvar_11 = 1000000007\nsys.setrecursionlimit(1000000)\n\n\ndef func_2():\n return list(map(int, input().split()))\n\n\ndef func_4():\n return input().split()\n\n\ndef func_1():\n return int(sys.stdin.readline())\n\n\ndef func_3():\n return eval(input())\n\n\nvar_3, var_4 = func_2()\nvar_5 = [func_2() for var_9 in range(var_3)]\nvar_5.sort(key=itemgetter(0))\n\nvar_8 = [[0] * (var_4 + 1 + 3000 + 1) for _ in range(var_3 + 1)]\nvar_6 = 0\nfor var_9 in range(var_3):\n for var_10 in range(var_4 + 1 + 3000 + 1):\n var_12, var_7 = var_5[var_9]\n if 0 <= var_10 - var_12 < var_4:\n var_8[var_9 + 1][var_10] = max(\n var_8[var_9][var_10], var_8[var_9][var_10 - var_12] + var_7\n )\n else:\n var_8[var_9 + 1][var_10] = var_8[var_9][var_10]\n var_6 = max(var_6, var_8[var_9 + 1][var_10])\nprint(var_6)\n```", "output": "SLOWER 3.1764", "pair_id": "python_p02863_reversed", "problem_id": "p02863", "language": "python", "direction": "reversed", "speedup_ratio": 9.0403} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_3 = list(map(int, input().split()))\nvar_2 = 0\nfor var_5 in range(var_3 + 1)[var_1:]:\n if len(str(var_5)) % 2 == 0:\n var_6 = list(str(var_5))[: len(str(var_5)) // 2]\n var_7 = list(reversed(list(str(var_5))[len(str(var_5)) // 2 :]))\n if var_6 == var_7:\n var_2 += 1\n else:\n var_8 = list(str(var_5))[: len(str(var_5)) // 2 + 1]\n var_4 = list(reversed(list(str(var_5))[len(str(var_5)) // 2 :]))\n if var_8 == var_4:\n var_2 += 1\nprint(var_2)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1 = list(map(int, input().split()))\nvar_2 = 0\nfor var_3 in range(var_1[0], var_1[1] + 1):\n var_4 = str(var_3)\n if var_4[0] == var_4[4] and var_4[1] == var_4[3]:\n var_2 += 1\nprint(var_2)\n```", "output": "FASTER 2.7633", "pair_id": "python_p03416_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 6.7897} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\n\nvar_8 = sys.stdin.readline\n\n\ndef func_1():\n var_2 = int(eval(var_8()))\n var_1 = []\n for _ in range(var_2):\n var_1.append(list(map(int, var_8().split())))\n var_3 = []\n for _ in range(var_2):\n var_3.append(list(map(int, var_8().split())))\n var_4 = -(10**7) * var_2\n for var_7 in range(1, 1 << 10):\n var_11 = 0\n for var_10, var_6 in enumerate(var_1):\n var_5 = 0\n for var_9 in range(10):\n if (var_7 >> var_9) & 1 & var_6[var_9]:\n var_5 += 1\n var_11 += var_3[var_10][var_5]\n var_4 = max(var_4, var_11)\n print(var_4)\n\n\nif __name__ == \"__main__\":\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nvar_5 = 0\nif var_5 == 0:\n var_8 = int(eval(input()))\n var_2 = []\n for var_4 in range(var_8):\n var_3 = list(map(int, input().split()))\n var_2.append(var_3)\n var_9 = []\n for var_4 in range(var_8):\n var_10 = list(map(int, input().split()))\n var_9.append(var_10)\nelif var_5 == 1:\n var_8 = 1\n var_2 = [[1, 1, 0, 1, 0, 0, 0, 1, 0, 1]]\n var_9 = [[3, 4, 5, 6, 7, 8, 9, -2, -3, 4, -2]]\nelif var_5 == 2:\n var_8 = 2\n var_2 = [[1, 1, 1, 1, 1, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 1, 1, 1, 1, 1]]\n var_9 = [\n [0, -2, -2, -2, -2, -2, -1, -1, -1, -1, -1],\n [0, -2, -2, -2, -2, -2, -1, -1, -1, -1, -1],\n ]\nelif var_5 == 3:\n var_8 = 3\n var_2 = [\n [1, 1, 1, 1, 1, 1, 0, 0, 1, 1],\n [0, 1, 0, 1, 1, 1, 1, 0, 1, 0],\n [1, 0, 1, 1, 0, 1, 0, 1, 0, 1],\n ]\n var_9 = [\n [-8, 6, -2, -8, -8, 4, 8, 7, -6, 2, 2],\n [-9, 2, 0, 1, 7, -5, 0, -2, -6, 5, 5],\n [6, -6, 7, -9, 6, -5, 8, 0, -9, -7, -7],\n ]\nimport itertools\n\nvar_13 = -(10**11)\nfor var_4 in itertools.product([0, 1], repeat=10):\n var_11 = list(var_4)\n var_12 = 0\n if sum(var_11) != 0:\n for var_7 in range(var_8):\n var_1 = 0\n for var_6 in range(10):\n var_1 = var_1 + var_11[var_6] * var_2[var_7][var_6]\n var_12 = var_12 + var_9[var_7][var_1]\n\n var_13 = max(var_12, var_13)\nprint(var_13)\n```", "output": "SLOWER 1.363", "pair_id": "python_p03503_reversed", "problem_id": "p03503", "language": "python", "direction": "reversed", "speedup_ratio": 2.5722} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = [\n var_3 for var_3 in map(str, list(range(var_1, var_2 + 1))) if var_3 == var_3[::-1]\n]\nprint((len(var_4)))\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = [0] * (var_2 + 1)\nfor var_3 in range(1, var_2 + 1):\n if str(var_3) == str(var_3)[::-1]:\n var_4[var_3] = var_4[var_3 - 1] + 1\n else:\n var_4[var_3] = var_4[var_3 - 1]\nprint((var_4[var_2] - var_4[var_1 - 1]))\n```", "output": "SLOWER 2.6408", "pair_id": "python_p03416_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 6.2369} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_5 in range(10):\n for var_6 in range(10):\n for var_7 in range(10):\n var_3 = 10000 * var_5 + 1000 * var_6 + 100 * var_7 + 10 * var_6 + var_5\n if var_1 <= var_3 <= var_2:\n var_4 += 1\nprint(var_4)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\n\n\ndef func_1(var_5):\n var_4 = 0\n for var_3 in range(1, var_5 + 1):\n if str(var_3) == str(var_3)[::-1]:\n var_4 += 1\n return var_4\n\n\nprint((func_1(var_2) - func_1(var_1 - 1)))\n```", "output": "SLOWER 5.4162", "pair_id": "python_p03416_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 42.7005} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nfrom sys import stdin\n\nvar_6 = lambda: list(map(int, stdin.readline().split()))\nvar_5 = lambda: list(map(int, stdin.readline().split()))\nvar_1, var_3 = var_6()\nvar_2 = 0\nfor var_4 in range(var_1, var_3 + 1):\n var_7 = str(var_4)\n if var_7 == var_7[::-1]:\n var_2 += 1\nprint(var_2)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\n\n\ndef func_1(var_5):\n var_4 = 0\n for var_3 in range(1, var_5 + 1):\n if str(var_3) == str(var_3)[::-1]:\n var_4 += 1\n return var_4\n\n\nprint((func_1(var_2) - func_1(var_1 - 1)))\n```", "output": "SLOWER 1.5722", "pair_id": "python_p03416_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 2.9736} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = [0] * (var_2 + 1)\nfor var_3 in range(1, var_2 + 1):\n if str(var_3) == str(var_3)[::-1]:\n var_4[var_3] = var_4[var_3 - 1] + 1\n else:\n var_4[var_3] = var_4[var_3 - 1]\nprint((var_4[var_2] - var_4[var_1 - 1]))\n```\n\n=== Code B (Modified) ===\n```python\nfrom sys import stdin\n\nvar_6 = lambda: list(map(int, stdin.readline().split()))\nvar_5 = lambda: list(map(int, stdin.readline().split()))\nvar_1, var_3 = var_6()\nvar_2 = 0\nfor var_4 in range(var_1, var_3 + 1):\n var_7 = str(var_4)\n if var_7 == var_7[::-1]:\n var_2 += 1\nprint(var_2)\n```", "output": "FASTER 1.9239", "pair_id": "python_p03416_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 3.7944} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_6 = int(eval(input()))\nvar_2 = list(map(int, input().split()))\nfrom itertools import product\n\nvar_5 = [-1, 0, 1]\nvar_3 = 0\nfor var_7 in product(var_5, repeat=var_6):\n var_1 = []\n for var_4 in range(var_6):\n var_1.append(var_7[var_4] + var_2[var_4])\n if any(var_8 % 2 == 0 for var_8 in var_1):\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_4 = int(eval(input()))\nvar_2 = list(map(int, input().split()))\n\n\ndef func_1(var_1, var_8, var_3):\n if var_8 == var_4:\n var_9 = 1\n for var_5 in var_3:\n var_9 *= var_5\n return 1 if var_9 % 2 == 0 else 0\n var_6 = var_3.copy()\n var_6.append(var_1[var_8] - 1)\n var_5 = var_3.copy()\n var_5.append(var_1[var_8])\n var_7 = var_3.copy()\n var_7.append(var_1[var_8] + 1)\n return (\n func_1(var_1, var_8 + 1, var_6)\n + func_1(var_1, var_8 + 1, var_5)\n + func_1(var_1, var_8 + 1, var_7)\n )\n\n\nprint((func_1(var_2, 0, [])))\n```", "output": "FASTER 1.5499", "pair_id": "python_p03568_forward", "problem_id": "p03568", "language": "python", "direction": "forward", "speedup_ratio": 2.928} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = str(var_4)\n if var_5 == var_5[::-1]:\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\ndef func_1():\n var_1, var_2 = list(map(int, input().split()))\n var_3 = 0\n for var_4 in range(var_1, var_2 + 1):\n\n if (var_4 % 10) == (var_4 // 10000 % 10) and (var_4 // 10 % 10) == (\n var_4 // 1000 % 10\n ):\n var_3 += 1\n print(var_3)\n\n\nif __name__ == \"__main__\":\n func_1()\n```", "output": "FASTER 1.6596", "pair_id": "python_p03416_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 3.1592} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_2, var_3, *var_1 = list(map(int, open(0).read().split()))\nvar_4 = [0] * (var_3 + max(var_1[::2]))\nfor var_7, var_6 in sorted(zip(*[iter(var_1)] * 2)):\n for var_5 in reversed(list(range(var_3))):\n var_4[var_5 + var_7] = max(var_4[var_5 + var_7], var_4[var_5] + var_6)\nprint((max(var_4)))\n```\n\n=== Code B (Modified) ===\n```python\nfrom collections import Counter, defaultdict, deque\nfrom heapq import heappop, heappush, heapify\nimport sys, bisect, math, itertools, fractions, pprint\n\nsys.setrecursionlimit(10**8)\nvar_6 = 10**9 + 7\nvar_1 = float(\"inf\")\n\n\ndef func_1():\n return int(sys.stdin.readline())\n\n\ndef func_2():\n return list(map(int, sys.stdin.readline().split()))\n\n\nvar_7, var_9 = func_2()\nvar_13 = [func_2() for _ in range(var_7)]\nvar_13.sort(key=lambda var_14: var_14[1], reverse=True)\nvar_8 = 0\nvar_10 = min(var_7, 5)\nfor var_3 in range(var_10):\n var_2 = [[0] * (var_9 + 5) for _ in range(var_7 + 5)]\n for var_4 in range(var_7):\n var_12, var_11 = var_13[var_4]\n for var_5 in range(var_9):\n if var_5 < var_12 or var_3 == var_4:\n var_2[var_4 + 1][var_5] = var_2[var_4][var_5]\n else:\n var_2[var_4 + 1][var_5] = max(\n var_2[var_4][var_5], var_2[var_4][var_5 - var_12] + var_11\n )\n\n var_8 = max(var_2[var_7][var_9 - 1] + var_13[var_3][1], var_8)\nprint(var_8)\n```", "output": "SLOWER 2.226", "pair_id": "python_p02863_reversed", "problem_id": "p02863", "language": "python", "direction": "reversed", "speedup_ratio": 4.6782} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\n\nsys.setrecursionlimit(500000)\n\n\ndef func_3():\n return sys.stdin.readline()[:-1]\n\n\nclass Class_1:\n def __init__(self, var_3):\n self.N = len(var_3)\n self.bit = [0] * self.N\n for var_11, var_14 in enumerate(var_3):\n self.add(var_11, var_14)\n\n def func_1(self, var_5, var_18):\n var_19 = var_5 + 1\n for var_11 in range(1000):\n self.bit[var_19 - 1] += var_18\n var_19 += var_19 & -var_19\n if var_19 > self.N:\n break\n\n def func_5(self, var_5):\n var_19 = var_5 + 1\n var_16 = 0\n for var_11 in range(1000):\n var_16 += self.bit[var_19 - 1]\n var_19 -= var_19 & -var_19\n if var_19 <= 0:\n break\n return var_16\n\n\ndef func_4():\n var_4, var_2, var_1 = list(map(int, func_3().split()))\n var_9 = []\n for var_11 in range(var_4):\n var_19, var_10 = list(map(int, func_3().split()))\n if var_10 % var_1 == 0:\n var_9.append([var_19, var_10 // var_1])\n else:\n var_9.append([var_19, var_10 // var_1 + 1])\n var_9.sort(key=lambda var_19: var_19[0])\n\n def func_2(var_12):\n var_19 = var_9[var_12][0]\n if var_9[var_4 - 1][0] <= var_19 + 2 * var_2:\n return var_4 - 1\n var_14 = var_12\n var_15 = var_4 - 1\n while var_15 - var_14 > 1:\n if var_9[(var_15 + var_14) // 2][0] <= var_19 + 2 * var_2:\n var_14 = (var_15 + var_14) // 2\n else:\n var_15 = (var_15 + var_14) // 2\n return var_14\n\n var_6 = Class_1([0] * var_4)\n var_7 = 0\n for var_11 in range(var_4):\n if var_11 > 0:\n var_17 = var_6.sum(var_4 - 1) - var_6.sum(var_11 - 1)\n else:\n var_17 = 0\n if var_9[var_11][1] - var_17 > 0:\n var_7 += var_9[var_11][1] - var_17\n var_13 = func_2(var_11)\n var_6.add(var_13, var_9[var_11][1] - var_17)\n var_9 = var_9[::-1]\n for var_11 in range(var_4):\n var_9[var_11][0] = -var_9[var_11][0]\n var_6 = Class_1([0] * var_4)\n var_8 = 0\n for var_11 in range(var_4):\n if var_11 > 0:\n var_17 = var_6.sum(var_4 - 1) - var_6.sum(var_11 - 1)\n else:\n var_17 = 0\n if var_9[var_11][1] - var_17 > 0:\n var_8 += var_9[var_11][1] - var_17\n var_13 = func_2(var_11)\n var_6.add(var_13, var_9[var_11][1] - var_17)\n print((min(var_7, var_8)))\n\n\nif __name__ == \"__main__\":\n func_4()\n```\n\n=== Code B (Modified) ===\n```python\nimport bisect\n\nvar_9, var_4, var_1 = list(map(int, input().split()))\nvar_5 = [None] * var_9\nfor var_7 in range(var_9):\n var_11, var_6 = list(map(int, input().split()))\n var_5[var_7] = (var_11, var_6)\nvar_5.sort()\nvar_11 = [int(var_5[var_7][0]) for var_7 in range(var_9)]\nvar_6 = [int(var_5[var_7][1]) for var_7 in range(var_9)]\nvar_2 = 0\nvar_3 = [0] * var_9\nfor var_7 in range(var_9):\n if var_7 != 0:\n var_3[var_7] += var_3[var_7 - 1]\n if var_3[var_7] >= var_6[var_7]:\n continue\n var_10 = (var_6[var_7] - var_3[var_7] - 1) // var_1 + 1\n var_2 += var_10\n var_3[var_7] += var_10 * var_1\n var_8 = bisect.bisect_right(var_11, var_11[var_7] + 2 * var_4)\n if var_8 == var_9:\n continue\n var_3[var_8] -= var_10 * var_1\nprint(var_2)\n```", "output": "FASTER 1.3694", "pair_id": "python_p02788_forward", "problem_id": "p02788", "language": "python", "direction": "forward", "speedup_ratio": 2.5837} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = str(var_4)\n if var_5 == var_5[::-1]:\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_8 in range(var_1, var_2 + 1):\n var_7 = str(var_8)\n var_6 = len(var_7)\n var_4 = True\n for var_5 in range(var_6 // 2):\n if var_7[var_5] != var_7[var_6 - 1 - var_5]:\n var_4 = False\n break\n if var_4:\n var_3 += 1\nprint(var_3)\n```", "output": "SLOWER 1.1307", "pair_id": "python_p03416_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 2.1897} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nfrom functools import reduce\nfrom itertools import product\n\nvar_2 = int(eval(input()))\n(*var_1,) = list(map(int, input().split()))\nvar_4 = 0\nfor var_7 in product([-1, 0, 1], repeat=var_2):\n var_6 = reduce(\n lambda var_8, var_9: var_8 * var_9,\n [var_3 + var_7[var_5] for var_5, var_3 in enumerate(var_1)],\n )\n if var_6 % 2 == 0:\n var_4 += 1\nprint(var_4)\n```\n\n=== Code B (Modified) ===\n```python\ndef func_1():\n var_2 = int(input())\n var_1 = [int(var_6) for var_6 in input().split()]\n if var_2 == 1:\n return print(1 if var_1[0] % 2 == 0 else 2)\n var_3 = 0\n var_5 = (-1, 0, 1)\n from itertools import product\n\n for var_6 in product(range(3), repeat=var_2):\n var_4 = 1\n for var_7 in range(var_2):\n var_4 *= var_1[var_7] + var_5[var_6[var_7]]\n if var_4 % 2 == 0:\n var_3 += 1\n print(var_3)\n\n\nif __name__ == \"__main__\":\n func_1()\n```", "output": "FASTER 1.1995", "pair_id": "python_p03568_forward", "problem_id": "p03568", "language": "python", "direction": "forward", "speedup_ratio": 2.2966} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_6, var_5 = list(map(int, input().split()))\nvar_8 = [[] for _ in range(var_6)]\nfor var_2 in range(var_5):\n var_10, var_11 = input().split()\n var_8[int(var_10) - 1].append(var_11)\n\nvar_1, var_7 = 0, 0\nfor var_3 in range(var_6):\n var_9 = var_8[var_3]\n if \"AC\" in var_9:\n var_1 += 1\n for var_4 in var_9:\n if var_4 == \"WA\":\n var_7 += 1\n else:\n break\nprint((var_1, var_7))\n```\n\n=== Code B (Modified) ===\n```python\nvar_2, var_1 = list(map(int, input().split()))\nvar_3 = 0\nvar_8 = 0\nvar_4 = [0] * (var_2 + 1)\nvar_9 = [0] * (var_2 + 1)\nfor var_5 in range(var_1):\n var_6, var_7 = input().split()\n var_6 = int(var_6)\n if var_7 == \"AC\":\n if var_4[var_6] == 0:\n var_3 += 1\n var_8 += var_9[var_6]\n var_4[var_6] = 1\n else:\n var_9[var_6] += 1\nprint((var_3, var_8))\n```", "output": "FASTER 4.7247", "pair_id": "python_p02802_forward", "problem_id": "p02802", "language": "python", "direction": "forward", "speedup_ratio": 26.4418} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\nfrom collections import deque\n\nvar_13 = sys.stdin.readline\nvar_2 = int(eval(var_13()))\nvar_5 = [deque() for _ in range(var_2)]\nvar_3 = [-1] * var_2\nfor var_12 in range(var_2 - 1):\n var_6, var_8 = list(map(int, var_13().split()))\n var_5[var_6 - 1].append((var_12, var_8 - 1))\n\n\nvar_4 = deque([(0, -1)])\nvar_1 = [-1] * (var_2 - 1)\nvar_11 = 0\nwhile var_4:\n var_14, var_10 = var_4.pop()\n var_9 = 1\n for var_12, var_15 in var_5[var_14]:\n if var_9 == var_10:\n var_9 += 1\n var_1[var_12] = var_9\n var_4.appendleft((var_15, var_9))\n var_9 += 1\n var_11 = max(var_11, var_9 - 1)\nprint(var_11)\nfor var_7 in var_1:\n print(var_7)\n```\n\n=== Code B (Modified) ===\n```python\nvar_11 = int(eval(input()))\nvar_12 = {var_8: [] for var_8 in range(1, var_11 + 1)}\nvar_19 = [False for var_8 in range(var_11 + 1)]\nvar_16 = []\nfor _ in range(var_11 - 1):\n var_2, var_3 = list(map(int, input().split()))\n var_12[var_2].append(var_3)\n var_12[var_3].append(var_2)\n var_16.append((var_2, var_3))\nvar_9 = var_16[0][0]\nvar_19[var_9] = True\nvar_6 = []\nvar_7 = []\nvar_14 = {var_8: {} for var_8 in range(1, var_11 + 1)}\nvar_10 = [0 for var_8 in range(var_11 + 1)]\n\nvar_4 = 1\nfor var_5 in var_12[var_9]:\n var_19[var_5] = True\n var_14[var_9][var_5] = var_4\n var_14[var_5][var_9] = var_4\n var_10[var_5] = var_4\n var_4 += 1\n var_6.append(var_5)\nwhile var_6:\n for var_15 in var_6:\n var_13 = 1\n for var_5 in var_12[var_15]:\n if var_19[var_5] == False:\n var_19[var_5] = True\n if var_13 != var_10[var_15]:\n var_14[var_15][var_5] = var_13\n var_14[var_5][var_15] = var_13\n var_10[var_5] = var_13\n var_13 += 1\n var_7.append(var_5)\n else:\n var_13 += 1\n var_14[var_15][var_5] = var_13\n var_14[var_5][var_15] = var_13\n var_10[var_5] = var_13\n var_13 += 1\n var_7.append(var_5)\n if var_7:\n var_6 = var_7\n var_7 = []\n else:\n var_6 = []\n var_7 = []\nvar_1 = 0\nfor var_8 in range(1, var_11 + 1):\n var_1 = max(var_1, len(var_12[var_8]))\nprint(var_1)\nfor var_8 in range(var_11 - 1):\n var_17, var_18 = var_16[var_8][0], var_16[var_8][1]\n print((var_14[var_17][var_18]))\n```", "output": "SLOWER 1.0442", "pair_id": "python_p02850_reversed", "problem_id": "p02850", "language": "python", "direction": "reversed", "speedup_ratio": 2.0622} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_11 = int(eval(input()))\nvar_12 = {var_8: [] for var_8 in range(1, var_11 + 1)}\nvar_19 = [False for var_8 in range(var_11 + 1)]\nvar_16 = []\nfor _ in range(var_11 - 1):\n var_2, var_3 = list(map(int, input().split()))\n var_12[var_2].append(var_3)\n var_12[var_3].append(var_2)\n var_16.append((var_2, var_3))\nvar_9 = var_16[0][0]\nvar_19[var_9] = True\nvar_6 = []\nvar_7 = []\nvar_14 = {var_8: {} for var_8 in range(1, var_11 + 1)}\nvar_10 = [0 for var_8 in range(var_11 + 1)]\n\nvar_4 = 1\nfor var_5 in var_12[var_9]:\n var_19[var_5] = True\n var_14[var_9][var_5] = var_4\n var_14[var_5][var_9] = var_4\n var_10[var_5] = var_4\n var_4 += 1\n var_6.append(var_5)\nwhile var_6:\n for var_15 in var_6:\n var_13 = 1\n for var_5 in var_12[var_15]:\n if var_19[var_5] == False:\n var_19[var_5] = True\n if var_13 != var_10[var_15]:\n var_14[var_15][var_5] = var_13\n var_14[var_5][var_15] = var_13\n var_10[var_5] = var_13\n var_13 += 1\n var_7.append(var_5)\n else:\n var_13 += 1\n var_14[var_15][var_5] = var_13\n var_14[var_5][var_15] = var_13\n var_10[var_5] = var_13\n var_13 += 1\n var_7.append(var_5)\n if var_7:\n var_6 = var_7\n var_7 = []\n else:\n var_6 = []\n var_7 = []\nvar_1 = 0\nfor var_8 in range(1, var_11 + 1):\n var_1 = max(var_1, len(var_12[var_8]))\nprint(var_1)\nfor var_8 in range(var_11 - 1):\n var_17, var_18 = var_16[var_8][0], var_16[var_8][1]\n print((var_14[var_17][var_18]))\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\n\nvar_8 = sys.stdin.readline\nvar_9 = int(eval(var_8()))\nvar_6 = []\nfor var_7 in range(var_9 - 1):\n var_1, var_3 = list(map(int, var_8().split()))\n var_6.append([var_1 - 1, var_3 - 1, var_7])\nvar_6.sort()\nvar_13 = [0] * (var_9)\nvar_2 = [0] * (var_9 - 1)\nvar_10 = 1\nvar_11 = 0\nfor var_5 in var_6:\n _from, var_12, var_7 = var_5\n if _from != var_11:\n var_10 = 1\n if var_13[_from] == var_10:\n var_10 += 1\n var_2[var_7] = var_10\n var_13[var_12] = var_10\n var_10 += 1\n var_11 = _from\nprint((max(var_2)))\nfor var_4 in var_2:\n print(var_4)\n```", "output": "FASTER 1.2377", "pair_id": "python_p02850_forward", "problem_id": "p02850", "language": "python", "direction": "forward", "speedup_ratio": 2.3582} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_10 = []\nvar_10 = input().rstrip().split(\" \")\nvar_1 = int(var_10[0])\nvar_3 = int(var_10[1])\nvar_2 = 0\nvar_6 = var_1\nwhile var_6 <= var_3:\n var_4 = var_6 // 10000\n var_5 = (var_6 - var_4 * 10000) // 1000\n var_7 = var_6 // 100\n var_8 = (var_6 - var_7 * 100) // 10\n var_9 = var_6 % 10\n if (var_4 == var_9) and (var_5 == var_8):\n var_2 += 1\n var_6 += 1\nprint(var_2)\n```\n\n=== Code B (Modified) ===\n```python\nvar_4 = {}\nvar_5 = 0\nfor var_6 in range(10000, 100000):\n var_3 = list(str(var_6))\n if var_3 == list(reversed(var_3)):\n var_5 += 1\n var_4[var_6] = var_5\nvar_1, var_2 = list(map(int, input().split()))\nprint((var_4[var_2] - var_4[var_1 - 1] if var_1 > 10000 else var_4[var_2]))\n```", "output": "SLOWER 2.7646", "pair_id": "python_p03416_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 6.7956} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_4 = str(var_4)\n if var_4[0] == var_4[-1] and var_4[1] == var_4[-2]:\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_8 in range(var_1, var_2 + 1):\n var_7 = str(var_8)\n var_6 = len(var_7)\n var_4 = True\n for var_5 in range(var_6 // 2):\n if var_7[var_5] != var_7[var_6 - 1 - var_5]:\n var_4 = False\n break\n if var_4:\n var_3 += 1\nprint(var_3)\n```", "output": "SLOWER 1.3099", "pair_id": "python_p03416_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 2.4793} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_4, var_3 = list(map(int, input().split()))\nvar_1 = 0\nfor var_2 in range(var_4, var_3 + 1):\n if str(var_2)[0] + str(var_2)[1] == str(var_2)[-1] + str(var_2)[-2]:\n var_1 += 1\nprint(var_1)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = str(var_4)\n if var_5 == var_5[::-1]:\n var_3 += 1\nprint(var_3)\n```", "output": "FASTER 1.3456", "pair_id": "python_p03416_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 2.5413} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = [\n var_3 for var_3 in map(str, list(range(var_1, var_2 + 1))) if var_3 == var_3[::-1]\n]\nprint((len(var_4)))\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().strip().split(\" \")))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n if str(var_4) == str(var_4)[::-1]:\n var_3 += 1\nprint(var_3)\n```", "output": "SLOWER 1.0058", "pair_id": "python_p03416_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 2.0081} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\ndef func_1():\n from sys import setrecursionlimit, stdin\n from os import environ\n from collections import defaultdict, deque, Counter\n from math import ceil, floor, gcd\n from itertools import accumulate, combinations, combinations_with_replacement\n\n setrecursionlimit(10**6)\n var_7 = (\n (lambda *var_11: print(*var_11))\n if \"TERM_PROGRAM\" in environ\n else lambda *var_12: 0\n )\n var_8 = lambda: stdin.readline().rstrip()\n var_3 = lambda: list(map(int, var_8().split()))\n var_1 = lambda: int(var_8())\n var_4 = 10**9 + 7\n var_2 = 10**9 + 10\n var_9, var_10 = var_8().split()\n var_5 = int(var_9)\n var_6 = int(float(var_10) * 100 + 0.5)\n print(var_5 * var_6 // 100)\n\n\nfunc_1()\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\n\nvar_5 = sys.stdin.readline\nif __name__ == \"__main__\":\n var_1, var_3 = var_5().split()\n var_2 = int(var_1)\n var_4 = round(float(var_3) * 100)\n print((var_2 * var_4 // 100))\n```", "output": "FASTER 1.7429", "pair_id": "python_p02659_forward", "problem_id": "p02659", "language": "python", "direction": "forward", "speedup_ratio": 3.347} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\n\n\ndef func_1(var_5):\n var_4 = 0\n for var_3 in range(1, var_5 + 1):\n if str(var_3) == str(var_3)[::-1]:\n var_4 += 1\n return var_4\n\n\nprint((func_1(var_2) - func_1(var_1 - 1)))\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = str(var_4)\n if var_5 == var_5[::-1]:\n var_3 += 1\nprint(var_3)\n```", "output": "FASTER 1.5951", "pair_id": "python_p03416_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 3.0211} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport copy\n\nvar_8 = int(eval(input()))\nvar_10 = set([var_6 for var_6 in range(1, 10**5)])\nvar_5 = []\nvar_11 = {}\nvar_9 = []\nfor var_6 in range(var_8 - 1):\n var_1, var_2 = list(map(int, input().split(\" \")))\n var_5.append([var_1, var_2])\n var_11.setdefault(var_1, []).append(var_2)\n var_9.append([])\nvar_9.append([])\nvar_9.append([])\nvar_7 = 0\nfor var_12 in range(1, var_8 + 1):\n var_14 = var_11.get(var_12, [])\n var_3 = 1\n for var_13 in var_14:\n if var_3 in var_9[var_12]:\n var_3 += 1\n else:\n pass\n var_9[var_13].append(var_3)\n if var_3 >= var_7:\n var_7 = var_3\n var_3 += 1\nprint(var_7)\nfor var_4 in var_5:\n print((var_9[var_4[1]][0]))\n```\n\n=== Code B (Modified) ===\n```python\nvar_11 = int(eval(input()))\nvar_12 = {var_8: [] for var_8 in range(1, var_11 + 1)}\nvar_19 = [False for var_8 in range(var_11 + 1)]\nvar_16 = []\nfor _ in range(var_11 - 1):\n var_2, var_3 = list(map(int, input().split()))\n var_12[var_2].append(var_3)\n var_12[var_3].append(var_2)\n var_16.append((var_2, var_3))\nvar_9 = var_16[0][0]\nvar_19[var_9] = True\nvar_6 = []\nvar_7 = []\nvar_14 = {var_8: {} for var_8 in range(1, var_11 + 1)}\nvar_10 = [0 for var_8 in range(var_11 + 1)]\n\nvar_4 = 1\nfor var_5 in var_12[var_9]:\n var_19[var_5] = True\n var_14[var_9][var_5] = var_4\n var_14[var_5][var_9] = var_4\n var_10[var_5] = var_4\n var_4 += 1\n var_6.append(var_5)\nwhile var_6:\n for var_15 in var_6:\n var_13 = 1\n for var_5 in var_12[var_15]:\n if var_19[var_5] == False:\n var_19[var_5] = True\n if var_13 != var_10[var_15]:\n var_14[var_15][var_5] = var_13\n var_14[var_5][var_15] = var_13\n var_10[var_5] = var_13\n var_13 += 1\n var_7.append(var_5)\n else:\n var_13 += 1\n var_14[var_15][var_5] = var_13\n var_14[var_5][var_15] = var_13\n var_10[var_5] = var_13\n var_13 += 1\n var_7.append(var_5)\n if var_7:\n var_6 = var_7\n var_7 = []\n else:\n var_6 = []\n var_7 = []\nvar_1 = 0\nfor var_8 in range(1, var_11 + 1):\n var_1 = max(var_1, len(var_12[var_8]))\nprint(var_1)\nfor var_8 in range(var_11 - 1):\n var_17, var_18 = var_16[var_8][0], var_16[var_8][1]\n print((var_14[var_17][var_18]))\n```", "output": "FASTER 3.6078", "pair_id": "python_p02850_forward", "problem_id": "p02850", "language": "python", "direction": "forward", "speedup_ratio": 12.1912} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_6 = sorted([list(map(int, input().split())) for var_5 in range(var_1)])\n\nvar_4 = [[0] * (var_2 + 1) for var_5 in range(var_1 + 1)]\n\nfor var_5 in range(var_1):\n var_9, var_8 = var_6[var_5]\n for var_7 in range(var_2 + 1):\n if var_7 + var_9 <= var_2:\n var_4[var_5 + 1][var_7 + var_9] = max(\n var_4[var_5 + 1][var_7 + var_9], var_4[var_5][var_7] + var_8\n )\n var_4[var_5 + 1][var_7] = max(var_4[var_5][var_7], var_4[var_5 + 1][var_7])\nvar_3 = 0\nfor var_5, (var_9, var_8) in enumerate(var_6):\n var_3 = max(var_3, var_4[var_5][var_2 - 1] + var_8)\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\ndef func_1():\n var_2, var_3, *var_1 = list(map(int, open(0).read().split()))\n var_4 = [0] * (var_3 + max(var_1[::2]))\n for var_7, var_6 in sorted(zip(*[iter(var_1)] * 2)):\n for var_5 in reversed(list(range(var_3))):\n var_4[var_5 + var_7] = max(var_4[var_5 + var_7], var_4[var_5] + var_6)\n print((max(var_4)))\n\n\nfunc_1()\n```", "output": "FASTER 1.7041", "pair_id": "python_p02863_forward", "problem_id": "p02863", "language": "python", "direction": "forward", "speedup_ratio": 3.2582} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n if str(var_4) == \"\".join(reversed(str(var_4))):\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_5 in range(var_1, var_2 + 1):\n var_3 = str(var_5)\n if var_3[0] == var_3[-1] and var_3[1] == var_3[-2]:\n var_4 += 1\nprint(var_4)\n```", "output": "FASTER 1.1678", "pair_id": "python_p03416_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 2.2467} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1 = (\n input()\n .replace(\"eraser\", \" \")\n .replace(\"erase\", \" \")\n .replace(\"dreamer\", \" \")\n .replace(\"dream\", \" \")\n .replace(\" \", \"\")\n)\nif var_1:\n print(\"NO\")\nelse:\n print(\"YES\")\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\n\nvar_5 = sys.stdin.readline\n\n\ndef func_1():\n var_3 = var_5().rstrip()\n var_11 = [\"dream\", \"dreamer\", \"erase\", \"eraser\"]\n var_9 = \"YES\"\n var_7 = var_3\n var_6 = var_3\n while True:\n for var_4 in range(4):\n var_10 = var_11[var_4]\n var_2 = len(var_10)\n var_1 = len(var_6)\n if var_2 <= var_1:\n var_8 = var_6[var_1 - var_2 :]\n if var_8 == var_10:\n var_6 = var_6[: var_1 - var_2]\n if var_6 == \"\":\n break\n elif var_6 == var_7:\n var_9 = \"NO\"\n break\n else:\n var_7 = var_6\n print(var_9)\n\n\nfunc_1()\n```", "output": "SLOWER 1.396", "pair_id": "python_p03854_reversed", "problem_id": "p03854", "language": "python", "direction": "reversed", "speedup_ratio": 2.6318} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport numpy as np\nfrom itertools import product\n\nvar_6 = int(eval(input()))\nvar_2 = list(map(int, input().split()))\nvar_2 = np.array(var_2)\nvar_5 = [-1, 0, 1]\nvar_3 = 0\nfor var_7 in product(var_5, repeat=var_6):\n var_7 = np.array(var_7)\n var_1 = var_2 + var_7\n var_4 = var_1.cumprod()\n if var_4[-1] % 2 == 0:\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_2 = int(eval(input()))\nvar_1 = list(map(int, input().split()))\nvar_4 = 1\nfor var_3 in range(var_2):\n if var_1[var_3] % 2 == 0:\n var_4 *= 2\nprint((3**var_2 - var_4))\n```", "output": "FASTER 10.0427", "pair_id": "python_p03568_forward", "problem_id": "p03568", "language": "python", "direction": "forward", "speedup_ratio": 1054.7734} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_6 = sorted([list(map(int, input().split())) for var_5 in range(var_1)])\n\nvar_4 = [[0] * (var_2 + 1) for var_5 in range(var_1 + 1)]\n\nfor var_5 in range(var_1):\n var_9, var_8 = var_6[var_5]\n for var_7 in range(var_2 + 1):\n if var_7 + var_9 <= var_2:\n var_4[var_5 + 1][var_7 + var_9] = max(\n var_4[var_5 + 1][var_7 + var_9], var_4[var_5][var_7] + var_8\n )\n var_4[var_5 + 1][var_7] = max(var_4[var_5][var_7], var_4[var_5 + 1][var_7])\nvar_3 = 0\nfor var_5, (var_9, var_8) in enumerate(var_6):\n for var_7 in range(var_2):\n var_3 = max(var_3, var_4[var_5][var_7] + var_8)\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nimport bisect\nimport sys\n\nsys.setrecursionlimit(10**6)\nvar_16 = sys.stdout.write\nvar_7 = lambda *var_14: print(*var_14) if var_1 else 0\nvar_1 = True\n\n\ndef func_1(var_9=sys.stdin.readline):\n var_11 = lambda: var_9().rstrip()\n var_3 = lambda: list(map(int, var_11().split()))\n var_2 = lambda: int(var_11())\n var_4 = lambda var_17: [var_3() for _ in range(var_17)]\n var_13, var_15 = var_3()\n var_5 = var_4(var_13)\n var_5.sort()\n var_8 = [[0] * var_15 for _ in range(var_13 + 1)]\n for var_10 in range(1, var_13 + 1):\n for var_12 in range(1, var_15):\n if var_12 < var_5[var_10 - 1][0]:\n var_8[var_10][var_12] = var_8[var_10 - 1][var_12]\n else:\n var_8[var_10][var_12] = max(\n var_8[var_10 - 1][var_12],\n var_8[var_10 - 1][var_12 - var_5[var_10 - 1][0]]\n + var_5[var_10 - 1][1],\n )\n var_6 = 0\n for var_10 in range(var_13):\n var_6 = max(var_6, var_8[var_10][var_15 - 1] + var_5[var_10][1])\n print(var_6)\n\n\nif __name__ == \"__main__\":\n func_1()\n```", "output": "FASTER 1.1662", "pair_id": "python_p02863_forward", "problem_id": "p02863", "language": "python", "direction": "forward", "speedup_ratio": 2.2442} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_5 in range(var_1, var_2 + 1):\n var_3 = str(var_5)\n if var_3[0] == var_3[-1] and var_3[1] == var_3[-2]:\n var_4 += 1\nprint(var_4)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_3 = list(map(int, input().split()))\nvar_2 = 0\nfor var_5 in range(var_3 + 1)[var_1:]:\n if len(str(var_5)) % 2 == 0:\n var_6 = list(str(var_5))[: len(str(var_5)) // 2]\n var_7 = list(reversed(list(str(var_5))[len(str(var_5)) // 2 :]))\n if var_6 == var_7:\n var_2 += 1\n else:\n var_8 = list(str(var_5))[: len(str(var_5)) // 2 + 1]\n var_4 = list(reversed(list(str(var_5))[len(str(var_5)) // 2 :]))\n if var_8 == var_4:\n var_2 += 1\nprint(var_2)\n```", "output": "SLOWER 2.5661", "pair_id": "python_p03416_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 5.9221} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_6 in range(var_1, var_2 + 1):\n var_3 = str(var_6)\n var_5 = True\n for var_7 in range(len(var_3) // 2):\n if var_3[var_7] != var_3[-var_7 - 1] and var_5:\n var_5 = not var_5\n if var_5:\n var_4 += 1\nprint(var_4)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_5 in range(10):\n for var_6 in range(10):\n for var_7 in range(10):\n var_3 = 10000 * var_5 + 1000 * var_6 + 100 * var_7 + 10 * var_6 + var_5\n if var_1 <= var_3 <= var_2:\n var_4 += 1\nprint(var_4)\n```", "output": "FASTER 5.2855", "pair_id": "python_p03416_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 39.0027} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2, var_3 = list(map(int, input().split()))\nvar_4 = list(map(int, input().split()))\nvar_6 = list(map(int, input().split()))\nvar_5 = min(var_4) + min(var_6)\nfor var_8 in range(var_3):\n var_7 = list(map(int, input().split()))\n var_9 = var_4[var_7[0] - 1] + var_6[var_7[1] - 1] - var_7[2]\n var_5 = min(var_9, var_5)\nprint(var_5)\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\nfrom collections import Counter\n\n\ndef func_10():\n return sys.stdin.readline().strip()\n\n\ndef func_11(var_12, var_13, var_14):\n return [[var_14] * var_13 for var_17 in range(var_12)]\n\n\ndef func_12(var_12, var_13, var_14, var_15):\n return [[[var_15] * var_14 for var_18 in range(var_13)] for var_17 in range(var_12)]\n\n\ndef func_13(var_12, var_13, var_14, var_15, var_16):\n return [\n [[[var_16] * var_15 for var_18 in range(var_14)] for var_18 in range(var_13)]\n for var_17 in range(var_12)\n ]\n\n\ndef func_8(var_22, var_23=1):\n return int(-(-var_22 // var_23))\n\n\ndef func_1():\n return int(eval(func_10()))\n\n\ndef func_3():\n return list(map(int, func_10().split()))\n\n\ndef func_2(var_11=None):\n return list(func_3()) if var_11 is None else [func_1() for var_17 in range(var_11)]\n\n\ndef func_7():\n print(\"Yes\")\n\n\ndef func_5():\n print(\"No\")\n\n\ndef func_6():\n print(\"YES\")\n\n\ndef func_4():\n print(\"NO\")\n\n\nsys.setrecursionlimit(10**9)\nvar_5 = 10**18\nvar_10 = 10**9 + 7\n\n\ndef func_9(var_1, var_2):\n \"\"\"\"\"\"\n import numpy as np\n from numpy.fft import rfft, irfft\n\n var_8 = max(var_1)\n var_9 = max(var_2)\n var_3 = [0] * (var_8 + 1)\n var_4 = [0] * (var_9 + 1)\n for var_12 in var_1:\n var_3[var_12] += 1\n for var_13 in var_2:\n var_4[var_13] += 1\n\n var_6 = 1\n var_19 = 0\n while var_6 <= var_8 + var_9:\n var_19 += 1\n var_6 = 2**var_19\n\n var_21 = irfft(rfft(var_3, var_6) * rfft(var_4, var_6), var_6)\n\n var_21 = np.rint(var_21).astype(np.int64)\n return var_21\n\n\nvar_11, var_7, var_6 = func_3()\nvar_1 = func_2()\nvar_2 = func_2()\nvar_21 = list(func_9(var_1, var_2))\nvar_20 = var_5\nfor var_17, var_12 in enumerate(var_21):\n if var_12 != 0:\n var_20 = var_17\n break\nfor _ in range(var_6):\n var_22, var_23, var_14 = func_3()\n var_22 -= 1\n var_23 -= 1\n var_20 = min(var_20, var_1[var_22] + var_2[var_23] - var_14)\nprint(var_20)\n```", "output": "SLOWER 3.1615", "pair_id": "python_p02748_reversed", "problem_id": "p02748", "language": "python", "direction": "reversed", "speedup_ratio": 8.9474} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_6, var_7 = list(map(int, input().split()))\nvar_1 = [list(map(int, input().split())) for _ in range(var_6)]\nvar_1.sort()\nvar_3 = [(6007) * [0] for _ in range(var_6 + 1)]\nvar_3[0][0] = 0\nvar_2 = 0\nfor var_4 in range(var_6):\n for var_5 in range(6007):\n var_3[var_4 + 1][var_5] = max(var_3[var_4 + 1][var_5], var_3[var_4][var_5])\n if var_5 < var_7:\n var_3[var_4 + 1][var_5 + var_1[var_4][0]] = max(\n var_3[var_4][var_5] + var_1[var_4][1],\n var_3[var_4][var_5 + var_1[var_4][0]],\n )\n var_2 = max(var_2, var_3[var_4 + 1][var_5])\nprint(var_2)\n```\n\n=== Code B (Modified) ===\n```python\nvar_2, var_3, *var_1 = list(map(int, open(0).read().split()))\nvar_4 = [0] * (var_3 + max(var_1[::2]))\nfor var_7, var_6 in sorted(zip(*[iter(var_1)] * 2)):\n for var_5 in reversed(list(range(var_3))):\n var_4[var_5 + var_7] = max(var_4[var_5 + var_7], var_4[var_5] + var_6)\nprint((max(var_4)))\n```", "output": "FASTER 6.3072", "pair_id": "python_p02863_forward", "problem_id": "p02863", "language": "python", "direction": "forward", "speedup_ratio": 79.1867} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport math\nimport string\n\n\ndef func_5():\n return list(map(int, input().split()))\n\n\ndef func_4(var_7, var_8):\n return math.factorial(var_7) // (\n math.factorial(var_7 - var_8) * math.factorial(var_8)\n )\n\n\ndef func_3(var_10):\n var_9 = []\n for var_5 in var_10:\n if not (var_5 in var_9):\n var_9.append(var_5)\n return len(var_10) != len(var_9)\n\n\ndef func_1(var_7):\n func_1 = []\n for var_4 in range(1, var_7 + 1):\n if var_7 % var_4 == 0:\n func_1.append(var_4)\n return func_1\n\n\nvar_2 = [-1, -1, -1, 0, 0, 1, 1, 1]\nvar_3 = [-1, 0, 1, -1, 1, -1, 0, 1]\nvar_7 = int(eval(input()))\nvar_1 = func_5()\n\n\ndef func_2(var_6):\n if len(var_6) == var_7:\n for var_4 in range(len(var_6)):\n if var_6[var_4] % 2 == 0:\n return 1\n return 0\n return (\n func_2(var_6 + [var_1[len(var_6)]])\n + func_2(var_6 + [var_1[len(var_6)] - 1])\n + func_2(var_6 + [var_1[len(var_6)] + 1])\n )\n\n\nprint((func_2([])))\n```\n\n=== Code B (Modified) ===\n```python\nvar_2 = int(eval(input()))\nvar_1 = list(map(int, input().split()))\nvar_4 = 1\nfor var_3 in range(var_2):\n if var_1[var_3] % 2 == 0:\n var_4 *= 2\nprint((3**var_2 - var_4))\n```", "output": "FASTER 7.6602", "pair_id": "python_p03568_forward", "problem_id": "p03568", "language": "python", "direction": "forward", "speedup_ratio": 202.2771} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\n\nvar_7 = sys.stdin.readline\nfrom itertools import combinations\n\n\ndef func_3(var_10):\n for _ in range(var_10):\n yield list(map(int, var_7().split()))\n\n\ndef func_1(var_9, var_5, var_11):\n var_3 = len([0 for var_8 in var_9 if var_5[var_8] == 1])\n return var_11[var_3]\n\n\ndef func_2():\n var_10 = int(eval(var_7()))\n var_1 = list(func_3(var_10))\n var_2 = list(func_3(var_10))\n for var_6 in range(1, 11):\n for var_4 in combinations(list(range(10)), var_6):\n yield sum(\n func_1(var_4, var_5, var_11) for var_5, var_11 in zip(var_1, var_2)\n )\n\n\nprint((max(func_2())))\n```\n\n=== Code B (Modified) ===\n```python\nvar_5 = 0\nif var_5 == 0:\n var_8 = int(eval(input()))\n var_2 = []\n for var_4 in range(var_8):\n var_3 = list(map(int, input().split()))\n var_2.append(var_3)\n var_9 = []\n for var_4 in range(var_8):\n var_10 = list(map(int, input().split()))\n var_9.append(var_10)\nelif var_5 == 1:\n var_8 = 1\n var_2 = [[1, 1, 0, 1, 0, 0, 0, 1, 0, 1]]\n var_9 = [[3, 4, 5, 6, 7, 8, 9, -2, -3, 4, -2]]\nelif var_5 == 2:\n var_8 = 2\n var_2 = [[1, 1, 1, 1, 1, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 1, 1, 1, 1, 1]]\n var_9 = [\n [0, -2, -2, -2, -2, -2, -1, -1, -1, -1, -1],\n [0, -2, -2, -2, -2, -2, -1, -1, -1, -1, -1],\n ]\nelif var_5 == 3:\n var_8 = 3\n var_2 = [\n [1, 1, 1, 1, 1, 1, 0, 0, 1, 1],\n [0, 1, 0, 1, 1, 1, 1, 0, 1, 0],\n [1, 0, 1, 1, 0, 1, 0, 1, 0, 1],\n ]\n var_9 = [\n [-8, 6, -2, -8, -8, 4, 8, 7, -6, 2, 2],\n [-9, 2, 0, 1, 7, -5, 0, -2, -6, 5, 5],\n [6, -6, 7, -9, 6, -5, 8, 0, -9, -7, -7],\n ]\nimport itertools\n\nvar_13 = -(10**11)\nfor var_4 in itertools.product([0, 1], repeat=10):\n var_11 = list(var_4)\n var_12 = 0\n if sum(var_11) != 0:\n for var_7 in range(var_8):\n var_1 = 0\n for var_6 in range(10):\n var_1 = var_1 + var_11[var_6] * var_2[var_7][var_6]\n var_12 = var_12 + var_9[var_7][var_1]\n\n var_13 = max(var_12, var_13)\nprint(var_13)\n```", "output": "SLOWER 2.018", "pair_id": "python_p03503_reversed", "problem_id": "p03503", "language": "python", "direction": "reversed", "speedup_ratio": 4.0503} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\ndef func_1():\n var_1, var_2 = list(map(int, input().split()))\n var_3 = 0\n for var_4 in range(var_1, var_2 + 1):\n\n if (var_4 % 10) == (var_4 // 10000 % 10) and (var_4 // 10 % 10) == (\n var_4 // 1000 % 10\n ):\n var_3 += 1\n print(var_3)\n\n\nif __name__ == \"__main__\":\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n if str(var_4) == \"\".join(reversed(str(var_4))):\n var_3 += 1\nprint(var_3)\n```", "output": "SLOWER 2.7403", "pair_id": "python_p03416_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 6.682} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_6 in range(var_1, var_2 + 1):\n var_3 = str(var_6)\n var_5 = True\n for var_7 in range(len(var_3) // 2):\n if var_3[var_7] != var_3[-var_7 - 1] and var_5:\n var_5 = not var_5\n if var_5:\n var_4 += 1\nprint(var_4)\n```\n\n=== Code B (Modified) ===\n```python\nfrom sys import stdin\n\nvar_6 = lambda: list(map(int, stdin.readline().split()))\nvar_5 = lambda: list(map(int, stdin.readline().split()))\nvar_1, var_3 = var_6()\nvar_2 = 0\nfor var_4 in range(var_1, var_3 + 1):\n var_7 = str(var_4)\n if var_7 == var_7[::-1]:\n var_2 += 1\nprint(var_2)\n```", "output": "FASTER 1.4415", "pair_id": "python_p03416_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 2.7161} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport math\nimport string\n\n\ndef func_5():\n return list(map(int, input().split()))\n\n\ndef func_4(var_7, var_8):\n return math.factorial(var_7) // (\n math.factorial(var_7 - var_8) * math.factorial(var_8)\n )\n\n\ndef func_3(var_10):\n var_9 = []\n for var_5 in var_10:\n if not (var_5 in var_9):\n var_9.append(var_5)\n return len(var_10) != len(var_9)\n\n\ndef func_1(var_7):\n func_1 = []\n for var_4 in range(1, var_7 + 1):\n if var_7 % var_4 == 0:\n func_1.append(var_4)\n return func_1\n\n\nvar_2 = [-1, -1, -1, 0, 0, 1, 1, 1]\nvar_3 = [-1, 0, 1, -1, 1, -1, 0, 1]\nvar_7 = int(eval(input()))\nvar_1 = func_5()\n\n\ndef func_2(var_6):\n if len(var_6) == var_7:\n for var_4 in range(len(var_6)):\n if var_6[var_4] % 2 == 0:\n return 1\n return 0\n return (\n func_2(var_6 + [var_1[len(var_6)]])\n + func_2(var_6 + [var_1[len(var_6)] - 1])\n + func_2(var_6 + [var_1[len(var_6)] + 1])\n )\n\n\nprint((func_2([])))\n```\n\n=== Code B (Modified) ===\n```python\nvar_4 = int(eval(input()))\nvar_1 = list(map(int, input().split()))\nvar_3 = 1\nfor var_2 in var_1:\n var_3 *= 2 if var_2 % 2 == 0 else 1\nprint((3**var_4 - var_3))\n```", "output": "FASTER 7.7659", "pair_id": "python_p03568_forward", "problem_id": "p03568", "language": "python", "direction": "forward", "speedup_ratio": 217.6585} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\ndef func_1():\n from sys import setrecursionlimit, stdin\n from os import environ\n from collections import defaultdict, deque, Counter\n from math import ceil, floor, gcd\n from itertools import accumulate, combinations, combinations_with_replacement\n\n setrecursionlimit(10**6)\n var_7 = (\n (lambda *var_11: print(*var_11))\n if \"TERM_PROGRAM\" in environ\n else lambda *var_12: 0\n )\n var_8 = lambda: stdin.readline().rstrip()\n var_3 = lambda: list(map(int, var_8().split()))\n var_1 = lambda: int(var_8())\n var_4 = 10**9 + 7\n var_2 = 10**9 + 10\n var_9, var_10 = var_8().split()\n var_5 = int(var_9)\n var_10 = var_10.split(\".\")\n var_6 = int(var_10[0]) * 100\n if len(var_10) == 2:\n var_6 += int(var_10[1])\n print(var_5 * var_6 // 100)\n\n\nfunc_1()\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = input().split()\nvar_1 = int(var_1)\nvar_2 = int(\"\".join(var_2.split(\".\")))\nprint(((var_1 * var_2) // 100))\n```", "output": "FASTER 2.3519", "pair_id": "python_p02659_forward", "problem_id": "p02659", "language": "python", "direction": "forward", "speedup_ratio": 5.1048} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_4, var_3 = list(map(int, input().split()))\nvar_1 = 0\nfor var_2 in range(var_4, var_3 + 1):\n if str(var_2)[0] + str(var_2)[1] == str(var_2)[-1] + str(var_2)[-2]:\n var_1 += 1\nprint(var_1)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1 = list(map(int, input().split()))\nvar_2 = 0\nfor var_3 in range(var_1[0], var_1[1] + 1):\n var_4 = str(var_3)\n if var_4[0] == var_4[4] and var_4[1] == var_4[3]:\n var_2 += 1\nprint(var_2)\n```", "output": "FASTER 1.6299", "pair_id": "python_p03416_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 3.0949} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_3 = list(map(int, input().split()))\nvar_2 = 0\nfor var_5 in range(var_3 + 1)[var_1:]:\n if len(str(var_5)) % 2 == 0:\n var_6 = list(str(var_5))[: len(str(var_5)) // 2]\n var_7 = list(reversed(list(str(var_5))[len(str(var_5)) // 2 :]))\n if var_6 == var_7:\n var_2 += 1\n else:\n var_8 = list(str(var_5))[: len(str(var_5)) // 2 + 1]\n var_4 = list(reversed(list(str(var_5))[len(str(var_5)) // 2 :]))\n if var_8 == var_4:\n var_2 += 1\nprint(var_2)\n```\n\n=== Code B (Modified) ===\n```python\nvar_10 = []\nvar_10 = input().rstrip().split(\" \")\nvar_1 = int(var_10[0])\nvar_3 = int(var_10[1])\nvar_2 = 0\nvar_6 = var_1\nwhile var_6 <= var_3:\n var_4 = var_6 // 10000\n var_5 = (var_6 - var_4 * 10000) // 1000\n var_7 = var_6 // 100\n var_8 = (var_6 - var_7 * 100) // 10\n var_9 = var_6 % 10\n if (var_4 == var_9) and (var_5 == var_8):\n var_2 += 1\n var_6 += 1\nprint(var_2)\n```", "output": "FASTER 1.6655", "pair_id": "python_p03416_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 3.1723} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_6 = input()[::-1]\nvar_4 = len(var_6)\nvar_2 = [0] * 2019\nvar_2[0] = 1\nvar_7 = 1\nvar_5 = 0\nvar_1 = 0\nfor var_3 in range(var_4):\n var_5 = (var_5 + int(var_6[var_3]) * var_7) % 2019\n var_7 = var_7 * 10 % 2019\n var_2[var_5] += 1\nfor var_3 in var_2:\n var_1 += var_3 * (var_3 - 1) // 2\nprint(var_1)\n```\n\n=== Code B (Modified) ===\n```python\n\"\"\"\"\"\"\n\nfrom collections import defaultdict\n\n\ndef func_1(var_10, var_9):\n var_5 = 1\n yield var_5\n for _ in range(1, var_10):\n var_5 = (var_5 * 10) % var_9\n yield var_5\n\n\ndef func_2():\n var_3 = 2019\n var_4 = input()[::-1]\n\n var_1 = [\n int(var_11) * var_10 % var_3\n for var_11, var_10 in zip(var_4, func_1(len(var_4), var_3))\n ]\n\n var_2 = [0]\n for var_5 in var_1:\n var_2.append((var_2[-1] + var_5) % var_3)\n\n var_8 = defaultdict(int)\n for var_6 in var_2:\n var_8[var_6] += 1\n var_7 = sum(var_12 * (var_12 - 1) // 2 for var_12 in list(var_8.values()))\n print(var_7)\n\n\nfunc_2()\n```", "output": "FASTER 1.3499", "pair_id": "python_p02702_forward", "problem_id": "p02702", "language": "python", "direction": "forward", "speedup_ratio": 2.5489} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_6, var_5 = list(map(int, input().split()))\nvar_1 = [0] * var_6\nfor var_4 in range(var_5):\n var_2, var_3 = list(map(int, input().split()))\n var_1[var_2 - 1] += 1\n var_1[var_3 - 1] += 1\nfor var_4 in range(var_6):\n print((var_1[var_4]))\n```\n\n=== Code B (Modified) ===\n```python\nvar_3, var_2 = map(int, input().split())\nvar_4 = [0] * var_3\n[\n exec(\n \"roads[%d] += 1; roads[%d] += 1\"\n % tuple(map(lambda var_1: int(var_1) - 1, input().split()))\n )\n for _ in range(var_2)\n]\nprint(*var_4, sep=\"\\n\", end=\"\")\n```", "output": "SLOWER 1.1224", "pair_id": "python_p03720_reversed", "problem_id": "p03720", "language": "python", "direction": "reversed", "speedup_ratio": 2.1771} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\nfrom collections import deque\n\nvar_13 = sys.stdin.readline\nvar_2 = int(eval(var_13()))\nvar_5 = [deque() for _ in range(var_2)]\nvar_3 = [-1] * var_2\nfor var_12 in range(var_2 - 1):\n var_6, var_8 = list(map(int, var_13().split()))\n var_5[var_6 - 1].append((var_12, var_8 - 1))\n\n\nvar_4 = deque([(0, -1)])\nvar_1 = [-1] * (var_2 - 1)\nvar_11 = 0\nwhile var_4:\n var_14, var_10 = var_4.pop()\n var_9 = 1\n for var_12, var_15 in var_5[var_14]:\n if var_9 == var_10:\n var_9 += 1\n var_1[var_12] = var_9\n var_4.appendleft((var_15, var_9))\n var_9 += 1\n var_11 = max(var_11, var_9 - 1)\nprint(var_11)\nfor var_7 in var_1:\n print(var_7)\n```\n\n=== Code B (Modified) ===\n```python\nfrom collections import deque\n\n\ndef func_2(var_9, var_2, var_4):\n\n var_6 = {var_7: dict() for var_7 in range(var_9)}\n for var_7 in range(var_9 - 1):\n var_1, var_3 = var_2[var_7] - 1, var_4[var_7] - 1\n var_6[var_1][var_3] = -1\n var_6[var_3][var_1] = -1\n var_8 = max([len(var_6[var_1]) for var_1 in range(var_9)])\n var_14 = [-1] * var_9\n var_14[0] = var_8 - 1\n\n var_12 = deque([0])\n while len(var_12) > 0:\n var_10 = var_12.popleft()\n var_5 = var_14[var_10]\n for var_11 in list(var_6[var_10].keys()):\n if var_14[var_11] != -1:\n continue\n var_5 += 1\n var_5 %= var_8\n\n var_6[var_10][var_11] = var_5\n var_6[var_11][var_10] = var_5\n var_14[var_11] = var_5\n var_12.append(var_11)\n var_13 = [0] * (var_9 - 1)\n for var_7 in range(var_9 - 1):\n var_13[var_7] = var_6[var_2[var_7] - 1][var_4[var_7] - 1] + 1\n return var_8, var_13\n\n\ndef func_1():\n var_9 = int(eval(input()))\n var_2 = [0] * (var_9 - 1)\n var_4 = [0] * (var_9 - 1)\n for var_7 in range(var_9 - 1):\n var_1, var_3 = list(map(int, input().split()))\n var_2[var_7] = var_1\n var_4[var_7] = var_3\n var_8, var_13 = func_2(var_9, var_2, var_4)\n print(var_8)\n for var_7 in range(var_9 - 1):\n print((var_13[var_7]))\n\n\ndef func_3():\n print((func_2(3, [1, 2], [2, 3])))\n print((func_2(8, [1, 2, 2, 2, 4, 5, 6], [2, 3, 4, 5, 7, 6, 8])))\n\n\nif __name__ == \"__main__\":\n\n func_1()\n```", "output": "SLOWER 1.0091", "pair_id": "python_p02850_reversed", "problem_id": "p02850", "language": "python", "direction": "reversed", "speedup_ratio": 2.0126} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1 = int(eval(input()))\nvar_2 = []\nfor _ in range(var_1):\n var_2.append(int(eval(input())))\nprint((sum(var_2) - max(var_2) // 2))\n```\n\n=== Code B (Modified) ===\n```python\nimport copy\nimport random\nimport bisect\nimport fractions\nimport math\nimport sys\nimport collections\nfrom decimal import Decimal\n\nvar_5 = 10**9 + 7\nsys.setrecursionlimit(var_5)\nvar_3 = collections.deque()\n\n\ndef func_1():\n return list(map(int, sys.stdin.readline().split()))\n\n\nvar_1 = int(eval(input()))\nvar_6 = [0 for var_4 in range(var_1)]\nfor var_4 in range(var_1):\n var_6[var_4] = int(eval(input()))\nvar_6.sort()\nvar_2 = sum(var_6)\nvar_2 -= var_6[-1] // 2\nprint(var_2)\n```", "output": "SLOWER 1.0811", "pair_id": "python_p03207_reversed", "problem_id": "p03207", "language": "python", "direction": "reversed", "speedup_ratio": 2.1156} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\ndef func_1():\n var_2, var_3, *var_1 = list(map(int, open(0).read().split()))\n var_4 = [0] * (var_3 + max(var_1[::2]))\n for var_7, var_6 in sorted(zip(*[iter(var_1)] * 2)):\n for var_5 in reversed(list(range(var_3))):\n var_4[var_5 + var_7] = max(var_4[var_5 + var_7], var_4[var_5] + var_6)\n print((max(var_4)))\n\n\nfunc_1()\n```\n\n=== Code B (Modified) ===\n```python\nvar_6, var_7 = list(map(int, input().split()))\nvar_1 = [list(map(int, input().split())) for _ in range(var_6)]\nvar_1.sort()\nvar_3 = [(6007) * [0] for _ in range(var_6 + 1)]\nvar_3[0][0] = 0\nvar_2 = 0\nfor var_4 in range(var_6):\n for var_5 in range(6007):\n var_3[var_4 + 1][var_5] = max(var_3[var_4 + 1][var_5], var_3[var_4][var_5])\n if var_5 < var_7:\n var_3[var_4 + 1][var_5 + var_1[var_4][0]] = max(\n var_3[var_4][var_5] + var_1[var_4][1],\n var_3[var_4][var_5 + var_1[var_4][0]],\n )\n var_2 = max(var_2, var_3[var_4 + 1][var_5])\nprint(var_2)\n```", "output": "SLOWER 7.0192", "pair_id": "python_p02863_reversed", "problem_id": "p02863", "language": "python", "direction": "reversed", "speedup_ratio": 129.7134} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nfrom collections import Counter, defaultdict, deque\nfrom heapq import heappop, heappush, heapify\nimport sys, bisect, math, itertools, fractions, pprint\n\nsys.setrecursionlimit(10**8)\nvar_6 = 10**9 + 7\nvar_1 = float(\"inf\")\n\n\ndef func_1():\n return int(sys.stdin.readline())\n\n\ndef func_2():\n return list(map(int, sys.stdin.readline().split()))\n\n\nvar_7, var_9 = func_2()\nvar_13 = [func_2() for _ in range(var_7)]\nvar_13.sort(key=lambda var_14: var_14[1], reverse=True)\nvar_8 = 0\nvar_10 = min(var_7, 5)\nfor var_3 in range(var_10):\n var_2 = [[0] * (var_9 + 5) for _ in range(var_7 + 5)]\n for var_4 in range(var_7):\n var_12, var_11 = var_13[var_4]\n for var_5 in range(var_9):\n if var_5 < var_12 or var_3 == var_4:\n var_2[var_4 + 1][var_5] = var_2[var_4][var_5]\n else:\n var_2[var_4 + 1][var_5] = max(\n var_2[var_4][var_5], var_2[var_4][var_5 - var_12] + var_11\n )\n\n var_8 = max(var_2[var_7][var_9 - 1] + var_13[var_3][1], var_8)\nprint(var_8)\n```\n\n=== Code B (Modified) ===\n```python\nvar_6, var_7 = list(map(int, input().split()))\nvar_1 = [list(map(int, input().split())) for _ in range(var_6)]\nvar_1.sort()\nvar_3 = [(6007) * [0] for _ in range(var_6 + 1)]\nvar_3[0][0] = 0\nvar_2 = 0\nfor var_4 in range(var_6):\n for var_5 in range(6007):\n var_3[var_4 + 1][var_5] = max(var_3[var_4 + 1][var_5], var_3[var_4][var_5])\n if var_5 < var_7:\n var_3[var_4 + 1][var_5 + var_1[var_4][0]] = max(\n var_3[var_4][var_5] + var_1[var_4][1],\n var_3[var_4][var_5 + var_1[var_4][0]],\n )\n var_2 = max(var_2, var_3[var_4 + 1][var_5])\nprint(var_2)\n```", "output": "SLOWER 4.0812", "pair_id": "python_p02863_reversed", "problem_id": "p02863", "language": "python", "direction": "reversed", "speedup_ratio": 16.9267} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport math\nimport string\n\n\ndef func_5():\n return list(map(int, input().split()))\n\n\ndef func_4(var_7, var_8):\n return math.factorial(var_7) // (\n math.factorial(var_7 - var_8) * math.factorial(var_8)\n )\n\n\ndef func_3(var_10):\n var_9 = []\n for var_5 in var_10:\n if not (var_5 in var_9):\n var_9.append(var_5)\n return len(var_10) != len(var_9)\n\n\ndef func_1(var_7):\n func_1 = []\n for var_4 in range(1, var_7 + 1):\n if var_7 % var_4 == 0:\n func_1.append(var_4)\n return func_1\n\n\nvar_2 = [-1, -1, -1, 0, 0, 1, 1, 1]\nvar_3 = [-1, 0, 1, -1, 1, -1, 0, 1]\nvar_7 = int(eval(input()))\nvar_1 = func_5()\n\n\ndef func_2(var_6):\n if len(var_6) == var_7:\n for var_4 in range(len(var_6)):\n if var_6[var_4] % 2 == 0:\n return 1\n return 0\n return (\n func_2(var_6 + [var_1[len(var_6)]])\n + func_2(var_6 + [var_1[len(var_6)] - 1])\n + func_2(var_6 + [var_1[len(var_6)] + 1])\n )\n\n\nprint((func_2([])))\n```\n\n=== Code B (Modified) ===\n```python\nimport math\nimport string\n\n\ndef func_4():\n return list(map(int, input().split()))\n\n\ndef func_3(var_6, var_7):\n return math.factorial(var_6) // (\n math.factorial(var_6 - var_7) * math.factorial(var_7)\n )\n\n\ndef func_2(var_9):\n var_8 = []\n for var_5 in var_9:\n if not (var_5 in var_8):\n var_8.append(var_5)\n return len(var_9) != len(var_8)\n\n\ndef func_1(var_6):\n func_1 = []\n for var_4 in range(1, var_6 + 1):\n if var_6 % var_4 == 0:\n func_1.append(var_4)\n return func_1\n\n\nvar_2 = [-1, -1, -1, 0, 0, 1, 1, 1]\nvar_3 = [-1, 0, 1, -1, 1, -1, 0, 1]\nvar_6 = int(eval(input()))\nvar_1 = func_4()\nvar_10 = 1\nfor var_4 in range(len(var_1)):\n if var_1[var_4] % 2 == 0:\n var_10 *= 2\n else:\n var_10 *= 1\nprint((3 ** len(var_1) - var_10))\n```", "output": "FASTER 5.9525", "pair_id": "python_p03568_forward", "problem_id": "p03568", "language": "python", "direction": "forward", "speedup_ratio": 61.9275} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_3, var_8 = list(map(int, input().split()))\nvar_2 = list(map(int, input().split()))\nvar_4 = list(map(int, input().split()))\nvar_7 = min(var_2) + min(var_4)\nvar_9 = [0] * var_8\nvar_10 = [0] * var_8\nvar_5 = [0] * var_8\nfor var_6 in range(var_8):\n var_9[var_6], var_10[var_6], var_5[var_6] = list(map(int, input().split()))\n var_9[var_6] -= 1\n var_10[var_6] -= 1\nfor var_6 in range(var_8):\n var_7 = min(var_7, var_2[var_9[var_6]] + var_4[var_10[var_6]] - var_5[var_6])\nprint(var_7)\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\nfrom collections import Counter\n\n\ndef func_9():\n return sys.stdin.readline().strip()\n\n\ndef func_10(var_8, var_9, var_10):\n return [[var_10] * var_9 for var_13 in range(var_8)]\n\n\ndef func_11(var_8, var_9, var_10, var_11):\n return [[[var_11] * var_10 for var_14 in range(var_9)] for var_13 in range(var_8)]\n\n\ndef func_12(var_8, var_9, var_10, var_11, var_12):\n return [\n [[[var_12] * var_11 for var_14 in range(var_10)] for var_14 in range(var_9)]\n for var_13 in range(var_8)\n ]\n\n\ndef func_8(var_16, var_17=1):\n return int(-(-var_16 // var_17))\n\n\ndef func_1():\n return int(eval(func_9()))\n\n\ndef func_3():\n return list(map(int, func_9().split()))\n\n\ndef func_2(var_7=None):\n return list(func_3()) if var_7 is None else [func_1() for var_13 in range(var_7)]\n\n\ndef func_7():\n print(\"Yes\")\n\n\ndef func_5():\n print(\"No\")\n\n\ndef func_6():\n print(\"YES\")\n\n\ndef func_4():\n print(\"NO\")\n\n\nsys.setrecursionlimit(10**9)\nvar_3 = 10**18\nvar_6 = 10**9 + 7\nvar_7, var_5, var_4 = func_3()\nvar_1 = func_2()\nvar_2 = func_2()\nvar_15 = min(var_1) + min(var_2)\nfor _ in range(var_4):\n var_16, var_17, var_10 = func_3()\n var_16 -= 1\n var_17 -= 1\n var_15 = min(var_15, var_1[var_16] + var_2[var_17] - var_10)\nprint(var_15)\n```", "output": "SLOWER 1.3955", "pair_id": "python_p02748_reversed", "problem_id": "p02748", "language": "python", "direction": "reversed", "speedup_ratio": 2.6308} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_5 in range(var_1, var_2 + 1):\n var_3 = str(var_5)\n if var_3[0] == var_3[-1] and var_3[1] == var_3[-2]:\n var_4 += 1\nprint(var_4)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n if str(var_4) == \"\".join(reversed(str(var_4))):\n var_3 += 1\nprint(var_3)\n```", "output": "SLOWER 1.1678", "pair_id": "python_p03416_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 2.2467} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nfrom sys import stdin\n\n\ndef func_1():\n\n var_11 = stdin.readline\n var_2 = int(var_11())\n var_1 = []\n for var_6 in range(var_2):\n var_5 = int(\"\".join(var_11().strip().split(\" \")), 2)\n var_1.append(var_5)\n var_3 = []\n for var_6 in range(var_2):\n var_10 = list(map(int, var_11().split()))\n var_3.append(var_10)\n var_8 = float(\"-inf\")\n for var_9 in range(1, 1 << 10):\n var_12 = 0\n for var_7 in range(var_2):\n var_4 = bin(var_9 & var_1[var_7]).count(\"1\")\n var_12 += var_3[var_7][var_4]\n var_8 = max(var_12, var_8)\n print(var_8)\n\n\nif __name__ == \"__main__\":\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nvar_5 = 0\nif var_5 == 0:\n var_8 = int(eval(input()))\n var_2 = []\n for var_4 in range(var_8):\n var_3 = list(map(int, input().split()))\n var_2.append(var_3)\n var_9 = []\n for var_4 in range(var_8):\n var_10 = list(map(int, input().split()))\n var_9.append(var_10)\nelif var_5 == 1:\n var_8 = 1\n var_2 = [[1, 1, 0, 1, 0, 0, 0, 1, 0, 1]]\n var_9 = [[3, 4, 5, 6, 7, 8, 9, -2, -3, 4, -2]]\nelif var_5 == 2:\n var_8 = 2\n var_2 = [[1, 1, 1, 1, 1, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 1, 1, 1, 1, 1]]\n var_9 = [\n [0, -2, -2, -2, -2, -2, -1, -1, -1, -1, -1],\n [0, -2, -2, -2, -2, -2, -1, -1, -1, -1, -1],\n ]\nelif var_5 == 3:\n var_8 = 3\n var_2 = [\n [1, 1, 1, 1, 1, 1, 0, 0, 1, 1],\n [0, 1, 0, 1, 1, 1, 1, 0, 1, 0],\n [1, 0, 1, 1, 0, 1, 0, 1, 0, 1],\n ]\n var_9 = [\n [-8, 6, -2, -8, -8, 4, 8, 7, -6, 2, 2],\n [-9, 2, 0, 1, 7, -5, 0, -2, -6, 5, 5],\n [6, -6, 7, -9, 6, -5, 8, 0, -9, -7, -7],\n ]\nimport itertools\n\nvar_13 = -(10**11)\nfor var_4 in itertools.product([0, 1], repeat=10):\n var_11 = list(var_4)\n var_12 = 0\n if sum(var_11) != 0:\n for var_7 in range(var_8):\n var_1 = 0\n for var_6 in range(10):\n var_1 = var_1 + var_11[var_6] * var_2[var_7][var_6]\n var_12 = var_12 + var_9[var_7][var_1]\n\n var_13 = max(var_12, var_13)\nprint(var_13)\n```", "output": "SLOWER 3.2735", "pair_id": "python_p03503_reversed", "problem_id": "p03503", "language": "python", "direction": "reversed", "speedup_ratio": 9.6696} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_5 in range(var_1, var_2 + 1):\n var_3 = str(var_5)\n if var_3[0] == var_3[-1] and var_3[1] == var_3[-2]:\n var_4 += 1\nprint(var_4)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().rstrip().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = list(map(int, list(str(var_4))))\n if var_5[0] == var_5[4] and var_5[1] == var_5[3]:\n var_3 += 1\nprint(var_3)\n```", "output": "SLOWER 1.7746", "pair_id": "python_p03416_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 3.4214} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport numpy as np\nfrom bisect import bisect_left\n\n\ndef func_1():\n var_4 = []\n var_1 = np.ones(10**5 + 10)\n var_1[0] = var_1[1] = 0\n for var_3, var_2 in enumerate(var_1):\n if var_2:\n var_4.append(var_3)\n var_1[2 * var_3 : 10**5 + 10 : var_3] = 0\n return var_4\n\n\ndef func_2(var_6):\n var_7 = int(var_6)\n var_5 = func_1()\n return str(var_5[bisect_left(var_5, var_7)])\n\n\nif __name__ == \"__main__\":\n import sys\n\n print((func_2(sys.stdin.read().strip())))\n```\n\n=== Code B (Modified) ===\n```python\nimport bisect, copy, heapq, math, sys\nfrom collections import *\nfrom functools import lru_cache\nfrom itertools import accumulate, combinations, permutations, product\n\n\ndef func_2():\n return sys.stdin.readline()[:-1]\n\n\ndef func_4(var_8):\n return [0] + list(accumulate(var_8))\n\n\ndef func_1(var_1, var_4):\n return -(-var_1 // var_4)\n\n\nsys.setrecursionlimit(5000000)\nvar_9 = pow(10, 9) + 7\nvar_2 = [chr(ord(\"a\") + var_6) for var_6 in range(26)]\nvar_5 = [[1, 0], [0, 1], [-1, 0], [0, -1]]\nvar_11 = int(eval(func_2()))\n\n\ndef func_3(var_10):\n if var_10 == 1:\n return False\n for var_7 in range(2, int(math.sqrt(var_10)) + 1):\n if var_10 % var_7 == 0:\n return False\n return True\n\n\nvar_3 = var_11\nwhile not func_3(var_3):\n var_3 += 1\nprint(var_3)\n```", "output": "FASTER 6.3202", "pair_id": "python_p02819_forward", "problem_id": "p02819", "language": "python", "direction": "forward", "speedup_ratio": 79.9029} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_6, var_7 = list(map(int, input().split()))\nvar_1 = [list(map(int, input().split())) for _ in range(var_6)]\nvar_1.sort()\nvar_3 = [(6007) * [0] for _ in range(var_6 + 1)]\nvar_3[0][0] = 0\nvar_2 = 0\nfor var_4 in range(var_6):\n for var_5 in range(6007):\n var_3[var_4 + 1][var_5] = max(var_3[var_4 + 1][var_5], var_3[var_4][var_5])\n if var_5 < var_7:\n var_3[var_4 + 1][var_5 + var_1[var_4][0]] = max(\n var_3[var_4][var_5] + var_1[var_4][1],\n var_3[var_4][var_5 + var_1[var_4][0]],\n )\n var_2 = max(var_2, var_3[var_4 + 1][var_5])\nprint(var_2)\n```\n\n=== Code B (Modified) ===\n```python\ndef func_1():\n var_2, var_3, *var_1 = list(map(int, open(0).read().split()))\n var_4 = [0] * (var_3 + max(var_1[::2]))\n for var_7, var_6 in sorted(zip(*[iter(var_1)] * 2)):\n for var_5 in reversed(list(range(var_3))):\n var_4[var_5 + var_7] = max(var_4[var_5 + var_7], var_4[var_5] + var_6)\n print((max(var_4)))\n\n\nfunc_1()\n```", "output": "FASTER 7.0192", "pair_id": "python_p02863_forward", "problem_id": "p02863", "language": "python", "direction": "forward", "speedup_ratio": 129.7134} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport math\n\nvar_1, var_2 = input().split()\nvar_1 = int(var_1)\nvar_3 = int(var_2[0] + var_2[2] + var_2[3])\nprint((var_1 * var_3 // 100))\n```\n\n=== Code B (Modified) ===\n```python\ndef func_1():\n from sys import setrecursionlimit, stdin\n from os import environ\n from collections import defaultdict, deque, Counter\n from math import ceil, floor, gcd\n from itertools import accumulate, combinations, combinations_with_replacement\n\n setrecursionlimit(10**6)\n var_7 = (\n (lambda *var_11: print(*var_11))\n if \"TERM_PROGRAM\" in environ\n else lambda *var_12: 0\n )\n var_8 = lambda: stdin.readline().rstrip()\n var_3 = lambda: list(map(int, var_8().split()))\n var_1 = lambda: int(var_8())\n var_4 = 10**9 + 7\n var_2 = 10**9 + 10\n var_9, var_10 = var_8().split()\n var_5 = int(var_9)\n var_6 = int(float(var_10) * 100 + 0.5)\n print(var_5 * var_6 // 100)\n\n\nfunc_1()\n```", "output": "SLOWER 2.0604", "pair_id": "python_p02659_reversed", "problem_id": "p02659", "language": "python", "direction": "reversed", "speedup_ratio": 4.1709} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport math\nimport string\n\n\ndef func_5():\n return list(map(int, input().split()))\n\n\ndef func_4(var_7, var_8):\n return math.factorial(var_7) // (\n math.factorial(var_7 - var_8) * math.factorial(var_8)\n )\n\n\ndef func_3(var_10):\n var_9 = []\n for var_5 in var_10:\n if not (var_5 in var_9):\n var_9.append(var_5)\n return len(var_10) != len(var_9)\n\n\ndef func_1(var_7):\n func_1 = []\n for var_4 in range(1, var_7 + 1):\n if var_7 % var_4 == 0:\n func_1.append(var_4)\n return func_1\n\n\nvar_2 = [-1, -1, -1, 0, 0, 1, 1, 1]\nvar_3 = [-1, 0, 1, -1, 1, -1, 0, 1]\nvar_7 = int(eval(input()))\nvar_1 = func_5()\n\n\ndef func_2(var_6):\n if len(var_6) == var_7:\n for var_4 in range(len(var_6)):\n if var_6[var_4] % 2 == 0:\n return 1\n return 0\n return (\n func_2(var_6 + [var_1[len(var_6)]])\n + func_2(var_6 + [var_1[len(var_6)] - 1])\n + func_2(var_6 + [var_1[len(var_6)] + 1])\n )\n\n\nprint((func_2([])))\n```\n\n=== Code B (Modified) ===\n```python\nimport numpy as np\nfrom itertools import product\n\nvar_6 = int(eval(input()))\nvar_2 = list(map(int, input().split()))\nvar_2 = np.array(var_2)\nvar_5 = [-1, 0, 1]\nvar_3 = 0\nfor var_7 in product(var_5, repeat=var_6):\n var_7 = np.array(var_7)\n var_1 = var_2 + var_7\n var_4 = var_1.cumprod()\n if var_4[-1] % 2 == 0:\n var_3 += 1\nprint(var_3)\n```", "output": "SLOWER 2.3825", "pair_id": "python_p03568_reversed", "problem_id": "p03568", "language": "python", "direction": "reversed", "speedup_ratio": 5.2145} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_6 = input()[::-1]\nvar_5 = len(var_6)\nvar_1 = [0] * var_5\nvar_3 = [0] * var_5\nvar_2 = [0] * 2019\nvar_7 = 10\nvar_1[0] = int(var_6[0])\nvar_3[0] = var_1[0]\nvar_2[var_3[0]] += 1\nfor var_4 in range(1, var_5):\n var_1[var_4] = int(var_6[var_4]) * var_7 % 2019\n var_3[var_4] = (var_3[var_4 - 1] + var_1[var_4]) % 2019\n var_2[var_3[var_4]] += 1\n var_7 = var_7 * 10 % 2019\nprint(\n (\n int(sum([var_2[var_4] * (var_2[var_4] - 1) for var_4 in range(2019)]) / 2)\n + var_2[0]\n )\n)\n```\n\n=== Code B (Modified) ===\n```python\n\"\"\"\"\"\"\n\nfrom collections import defaultdict\n\n\ndef func_1(var_10, var_9):\n var_5 = 1\n yield var_5\n for _ in range(1, var_10):\n var_5 = (var_5 * 10) % var_9\n yield var_5\n\n\ndef func_2():\n var_3 = 2019\n var_4 = input()[::-1]\n\n var_1 = [\n int(var_11) * var_10 % var_3\n for var_11, var_10 in zip(var_4, func_1(len(var_4), var_3))\n ]\n\n var_2 = [0]\n for var_5 in var_1:\n var_2.append((var_2[-1] + var_5) % var_3)\n\n var_8 = defaultdict(int)\n for var_6 in var_2:\n var_8[var_6] += 1\n var_7 = sum(var_12 * (var_12 - 1) // 2 for var_12 in list(var_8.values()))\n print(var_7)\n\n\nfunc_2()\n```", "output": "FASTER 1.0502", "pair_id": "python_p02702_forward", "problem_id": "p02702", "language": "python", "direction": "forward", "speedup_ratio": 2.0708} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_6 = str(var_4)\n var_5 = var_6[::-1]\n if var_6 == var_5:\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_6 in range(var_1, var_2 + 1):\n var_3 = str(var_6)\n var_5 = True\n for var_7 in range(len(var_3) // 2):\n if var_3[var_7] != var_3[-var_7 - 1] and var_5:\n var_5 = not var_5\n if var_5:\n var_4 += 1\nprint(var_4)\n```", "output": "SLOWER 1.2096", "pair_id": "python_p03416_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 2.3127} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\n\nvar_3 = sys.stdin.readline\nif __name__ == \"__main__\":\n var_1, var_2 = var_3().split()\n print((int(var_1) * round(float(var_2) * 100) // 100))\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\nimport math\nfrom collections import defaultdict\nfrom bisect import bisect_left, bisect_right\n\nsys.setrecursionlimit(10**7)\n\n\ndef func_4():\n return sys.stdin.readline()[:-1]\n\n\nvar_4 = 10**9 + 7\n\n\ndef func_1():\n return int(eval(func_4()))\n\n\ndef func_2():\n return list(map(int, func_4().split()))\n\n\ndef func_3(var_6, var_3):\n if var_6 <= 0:\n return [[] for _ in range(var_3)]\n elif var_3 == 1:\n return [func_1() for _ in range(var_6)]\n else:\n var_5 = [func_2() for _ in range(var_6)]\n return list(map(list, list(zip(*var_5))))\n\n\nfrom decimal import getcontext, Decimal\n\ngetcontext().prec = 28\nvar_1, var_2 = list(map(str, func_4().split()))\nvar_1 = int(var_1)\nvar_2 = Decimal(var_2)\nprint((int(var_1 * var_2)))\n```", "output": "SLOWER 2.2434", "pair_id": "python_p02659_reversed", "problem_id": "p02659", "language": "python", "direction": "reversed", "speedup_ratio": 4.7352} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nfor var_3 in range(1, 1009):\n if int(var_3 * 0.08) == var_1 and int(var_3 * 0.1) == var_2:\n print((int(var_3)))\n exit()\nprint(\"-1\")\n```\n\n=== Code B (Modified) ===\n```python\nimport math\n\n\ndef func_1():\n var_1, var_2 = list(map(int, input().split()))\n\n var_5 = max(math.ceil(var_1 / 0.08), math.ceil(var_2 / 0.1))\n\n var_4 = min((math.ceil((var_1 + 1) / 0.08), math.ceil((var_2 + 1) / 0.1)))\n\n for var_3 in range(var_5, var_4 + 1):\n if (math.floor(var_3 * 0.08) == var_1) and (math.floor(var_3 * 0.1) == var_2):\n print(var_3)\n quit()\n\n print((-1))\n\n\nif __name__ == \"__main__\":\n func_1()\n```", "output": "FASTER 1.1794", "pair_id": "python_p02755_forward", "problem_id": "p02755", "language": "python", "direction": "forward", "speedup_ratio": 2.2649} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\nfrom collections import Counter\n\n\ndef func_9():\n return sys.stdin.readline().strip()\n\n\ndef func_10(var_8, var_9, var_10):\n return [[var_10] * var_9 for var_13 in range(var_8)]\n\n\ndef func_11(var_8, var_9, var_10, var_11):\n return [[[var_11] * var_10 for var_14 in range(var_9)] for var_13 in range(var_8)]\n\n\ndef func_12(var_8, var_9, var_10, var_11, var_12):\n return [\n [[[var_12] * var_11 for var_14 in range(var_10)] for var_14 in range(var_9)]\n for var_13 in range(var_8)\n ]\n\n\ndef func_8(var_16, var_17=1):\n return int(-(-var_16 // var_17))\n\n\ndef func_1():\n return int(eval(func_9()))\n\n\ndef func_3():\n return list(map(int, func_9().split()))\n\n\ndef func_2(var_7=None):\n return list(func_3()) if var_7 is None else [func_1() for var_13 in range(var_7)]\n\n\ndef func_7():\n print(\"Yes\")\n\n\ndef func_5():\n print(\"No\")\n\n\ndef func_6():\n print(\"YES\")\n\n\ndef func_4():\n print(\"NO\")\n\n\nsys.setrecursionlimit(10**9)\nvar_3 = 10**18\nvar_6 = 10**9 + 7\nvar_7, var_5, var_4 = func_3()\nvar_1 = func_2()\nvar_2 = func_2()\nvar_15 = min(var_1) + min(var_2)\nfor _ in range(var_4):\n var_16, var_17, var_10 = func_3()\n var_16 -= 1\n var_17 -= 1\n var_15 = min(var_15, var_1[var_16] + var_2[var_17] - var_10)\nprint(var_15)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_3, var_8 = list(map(int, input().split()))\nvar_2 = list(map(int, input().split()))\nvar_4 = list(map(int, input().split()))\nvar_7 = min(var_2) + min(var_4)\nvar_9 = [0] * var_8\nvar_10 = [0] * var_8\nvar_5 = [0] * var_8\nfor var_6 in range(var_8):\n var_9[var_6], var_10[var_6], var_5[var_6] = list(map(int, input().split()))\n var_9[var_6] -= 1\n var_10[var_6] -= 1\nfor var_6 in range(var_8):\n var_7 = min(var_7, var_2[var_9[var_6]] + var_4[var_10[var_6]] - var_5[var_6])\nprint(var_7)\n```", "output": "FASTER 1.3955", "pair_id": "python_p02748_forward", "problem_id": "p02748", "language": "python", "direction": "forward", "speedup_ratio": 2.6308} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nfrom sys import stdin\n\nvar_6 = lambda: list(map(int, stdin.readline().split()))\nvar_5 = lambda: list(map(int, stdin.readline().split()))\nvar_1, var_3 = var_6()\nvar_2 = 0\nfor var_4 in range(var_1, var_3 + 1):\n var_7 = str(var_4)\n if var_7 == var_7[::-1]:\n var_2 += 1\nprint(var_2)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n if list(str(var_4)) == list(reversed(str(var_4))):\n var_3 += 1\nprint(var_3)\n```", "output": "SLOWER 1.3819", "pair_id": "python_p03416_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 2.6062} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\ndef func_1():\n from sys import setrecursionlimit, stdin\n from os import environ\n from collections import defaultdict, deque, Counter\n from math import ceil, floor, gcd\n from itertools import accumulate, combinations, combinations_with_replacement\n\n setrecursionlimit(10**6)\n var_7 = (\n (lambda *var_11: print(*var_11))\n if \"TERM_PROGRAM\" in environ\n else lambda *var_12: 0\n )\n var_8 = lambda: stdin.readline().rstrip()\n var_3 = lambda: list(map(int, var_8().split()))\n var_1 = lambda: int(var_8())\n var_4 = 10**9 + 7\n var_2 = 10**9 + 10\n var_9, var_10 = var_8().split()\n var_5 = int(var_9)\n var_6 = int(float(var_10) * 100 + 0.5)\n print(var_5 * var_6 // 100)\n\n\nfunc_1()\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(str, input().split()))\nvar_1 = int(var_1)\nvar_2 = int(float(var_2) * 1000)\nprint((var_1 * var_2 // 1000))\n```", "output": "FASTER 2.0285", "pair_id": "python_p02659_forward", "problem_id": "p02659", "language": "python", "direction": "forward", "speedup_ratio": 4.0799} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport math\n\nvar_1, var_2 = input().split()\nvar_1 = int(var_1)\nvar_3 = int(var_2[0] + var_2[2] + var_2[3])\nprint((int(var_1 * var_3) // 100))\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\nimport math\nfrom collections import defaultdict\nfrom bisect import bisect_left, bisect_right\n\nsys.setrecursionlimit(10**7)\n\n\ndef func_4():\n return sys.stdin.readline()[:-1]\n\n\nvar_4 = 10**9 + 7\n\n\ndef func_1():\n return int(eval(func_4()))\n\n\ndef func_2():\n return list(map(int, func_4().split()))\n\n\ndef func_3(var_6, var_3):\n if var_6 <= 0:\n return [[] for _ in range(var_3)]\n elif var_3 == 1:\n return [func_1() for _ in range(var_6)]\n else:\n var_5 = [func_2() for _ in range(var_6)]\n return list(map(list, list(zip(*var_5))))\n\n\nvar_1, var_2 = list(map(str, func_4().split()))\nvar_1 = int(var_1)\nvar_2 = 100 * int(var_2[0]) + 10 * int(var_2[2]) + int(var_2[3])\nprint((var_1 * var_2 // 100))\n```", "output": "SLOWER 2.2787", "pair_id": "python_p02659_reversed", "problem_id": "p02659", "language": "python", "direction": "reversed", "speedup_ratio": 4.8523} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\nfrom collections import deque\n\nvar_1 = int(10e10)\nvar_2 = -var_1\nvar_12 = 1000000007\nsys.setrecursionlimit(1000000)\n\n\ndef func_2():\n return list(map(int, input().split()))\n\n\ndef func_4():\n return input().split()\n\n\ndef func_1():\n return int(sys.stdin.readline())\n\n\ndef func_3():\n return eval(input())\n\n\nvar_3, var_4 = func_2()\nvar_6 = [func_2() for var_10 in range(var_3)]\nvar_6.sort()\nvar_7 = 0\nvar_9 = [[0] * var_4 for var_10 in range(var_3 + 1)]\nfor var_10 in range(1, var_3 + 1):\n var_5, var_8 = var_6[var_10 - 1]\n for var_11 in range(var_4):\n if 0 <= var_11 - var_5 < var_4:\n var_9[var_10][var_11] = max(\n var_9[var_10 - 1][var_11], var_9[var_10 - 1][var_11 - var_5] + var_8\n )\n else:\n var_9[var_10][var_11] = var_9[var_10 - 1][var_11]\n else:\n var_7 = max(var_7, var_9[var_10 - 1][-1] + var_8)\nprint(var_7)\n```\n\n=== Code B (Modified) ===\n```python\nfrom collections import Counter, defaultdict, deque\nfrom heapq import heappop, heappush, heapify\nimport sys, bisect, math, itertools, fractions, pprint\n\nsys.setrecursionlimit(10**8)\nvar_6 = 10**9 + 7\nvar_1 = float(\"inf\")\n\n\ndef func_1():\n return int(sys.stdin.readline())\n\n\ndef func_2():\n return list(map(int, sys.stdin.readline().split()))\n\n\nvar_7, var_9 = func_2()\nvar_13 = [func_2() for _ in range(var_7)]\nvar_13.sort(key=lambda var_14: var_14[1], reverse=True)\nvar_8 = 0\nvar_10 = min(var_7, 5)\nfor var_3 in range(var_10):\n var_2 = [[0] * (var_9 + 5) for _ in range(var_7 + 5)]\n for var_4 in range(var_7):\n var_12, var_11 = var_13[var_4]\n for var_5 in range(var_9):\n if var_5 < var_12 or var_3 == var_4:\n var_2[var_4 + 1][var_5] = var_2[var_4][var_5]\n else:\n var_2[var_4 + 1][var_5] = max(\n var_2[var_4][var_5], var_2[var_4][var_5 - var_12] + var_11\n )\n\n var_8 = max(var_2[var_7][var_9 - 1] + var_13[var_3][1], var_8)\nprint(var_8)\n```", "output": "SLOWER 1.5536", "pair_id": "python_p02863_reversed", "problem_id": "p02863", "language": "python", "direction": "reversed", "speedup_ratio": 2.9355} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_6 in range(var_1, var_2 + 1):\n var_3 = str(var_6)\n var_5 = True\n for var_7 in range(len(var_3) // 2):\n if var_3[var_7] != var_3[-var_7 - 1] and var_5:\n var_5 = not var_5\n if var_5:\n var_4 += 1\nprint(var_4)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_4 = str(var_4)\n if var_4 == var_4[::-1]:\n var_3 += 1\nprint(var_3)\n```", "output": "FASTER 1.313", "pair_id": "python_p03416_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 2.4845} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\ndef func_1():\n var_2, var_3, *var_1 = list(map(int, open(0).read().split()))\n var_4 = [0] * (var_3 + max(var_1[::2]))\n for var_7, var_6 in sorted(zip(*[iter(var_1)] * 2)):\n for var_5 in reversed(list(range(var_3))):\n var_4[var_5 + var_7] = max(var_4[var_5 + var_7], var_4[var_5] + var_6)\n print((max(var_4)))\n\n\nfunc_1()\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\nfrom collections import deque\n\nvar_1 = int(10e10)\nvar_2 = -var_1\nvar_12 = 1000000007\nsys.setrecursionlimit(1000000)\n\n\ndef func_2():\n return list(map(int, input().split()))\n\n\ndef func_4():\n return input().split()\n\n\ndef func_1():\n return int(sys.stdin.readline())\n\n\ndef func_3():\n return eval(input())\n\n\nvar_3, var_4 = func_2()\nvar_6 = [func_2() for var_10 in range(var_3)]\nvar_6.sort()\nvar_7 = 0\nvar_9 = [[0] * var_4 for var_10 in range(var_3 + 1)]\nfor var_10 in range(1, var_3 + 1):\n var_5, var_8 = var_6[var_10 - 1]\n for var_11 in range(var_4):\n if 0 <= var_11 - var_5 < var_4:\n var_9[var_10][var_11] = max(\n var_9[var_10 - 1][var_11], var_9[var_10 - 1][var_11 - var_5] + var_8\n )\n else:\n var_9[var_10][var_11] = var_9[var_10 - 1][var_11]\n else:\n var_7 = max(var_7, var_9[var_10 - 1][-1] + var_8)\nprint(var_7)\n```", "output": "SLOWER 1.3844", "pair_id": "python_p02863_reversed", "problem_id": "p02863", "language": "python", "direction": "reversed", "speedup_ratio": 2.6106} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = list(str(var_4))\n if var_5 == list(reversed(var_5)):\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = str(var_4)\n if var_5 == var_5[::-1]:\n var_3 += 1\nprint(var_3)\n```", "output": "FASTER 1.2366", "pair_id": "python_p03416_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 2.3565} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = str(var_4)\n if var_5 == var_5[::-1]:\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_5 in range(10):\n for var_6 in range(10):\n for var_7 in range(10):\n var_3 = 10000 * var_5 + 1000 * var_6 + 100 * var_7 + 10 * var_6 + var_5\n if var_1 <= var_3 <= var_2:\n var_4 += 1\nprint(var_4)\n```", "output": "FASTER 3.8211", "pair_id": "python_p03416_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 14.1339} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = list(str(var_4))\n if var_5 == list(reversed(var_5)):\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_3 = list(map(int, input().split()))\nvar_2 = 0\nfor var_5 in range(var_3 + 1)[var_1:]:\n if len(str(var_5)) % 2 == 0:\n var_6 = list(str(var_5))[: len(str(var_5)) // 2]\n var_7 = list(reversed(list(str(var_5))[len(str(var_5)) // 2 :]))\n if var_6 == var_7:\n var_2 += 1\n else:\n var_8 = list(str(var_5))[: len(str(var_5)) // 2 + 1]\n var_4 = list(reversed(list(str(var_5))[len(str(var_5)) // 2 :]))\n if var_8 == var_4:\n var_2 += 1\nprint(var_2)\n```", "output": "SLOWER 1.2424", "pair_id": "python_p03416_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 2.3659} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nfrom decimal import Decimal\nimport math\n\nvar_1, var_2 = list(map(str, input().split()))\nvar_1 = int(var_1)\nvar_2 = Decimal(var_2)\nvar_3 = math.floor(var_1 * var_2)\nprint((int(var_3)))\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\nimport math\nfrom collections import defaultdict\nfrom bisect import bisect_left, bisect_right\n\nsys.setrecursionlimit(10**7)\n\n\ndef func_4():\n return sys.stdin.readline()[:-1]\n\n\nvar_4 = 10**9 + 7\n\n\ndef func_1():\n return int(eval(func_4()))\n\n\ndef func_2():\n return list(map(int, func_4().split()))\n\n\ndef func_3(var_6, var_3):\n if var_6 <= 0:\n return [[] for _ in range(var_3)]\n elif var_3 == 1:\n return [func_1() for _ in range(var_6)]\n else:\n var_5 = [func_2() for _ in range(var_6)]\n return list(map(list, list(zip(*var_5))))\n\n\nfrom decimal import getcontext, Decimal\n\ngetcontext().prec = 28\nvar_1, var_2 = list(map(str, func_4().split()))\nvar_1 = int(var_1)\nvar_2 = Decimal(var_2)\nprint((int(var_1 * var_2)))\n```", "output": "SLOWER 1.9581", "pair_id": "python_p02659_reversed", "problem_id": "p02659", "language": "python", "direction": "reversed", "speedup_ratio": 3.8855} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\ndef func_1():\n from sys import setrecursionlimit, stdin\n from os import environ\n from collections import defaultdict, deque, Counter\n from math import ceil, floor, gcd\n from itertools import accumulate, combinations, combinations_with_replacement\n\n setrecursionlimit(10**6)\n var_7 = (\n (lambda *var_11: print(*var_11))\n if \"TERM_PROGRAM\" in environ\n else lambda *var_12: 0\n )\n var_8 = lambda: stdin.readline().rstrip()\n var_3 = lambda: list(map(int, var_8().split()))\n var_1 = lambda: int(var_8())\n var_4 = 10**9 + 7\n var_2 = 10**9 + 10\n var_9, var_10 = var_8().split()\n var_5 = int(var_9)\n var_10 = var_10.split(\".\")\n var_6 = int(var_10[0]) * 100\n if len(var_10) == 2:\n var_6 += int(var_10[1])\n print(var_5 * var_6 // 100)\n\n\nfunc_1()\n```\n\n=== Code B (Modified) ===\n```python\nimport decimal\n\n\ndef func_1():\n var_1, var_2 = list(map(decimal.Decimal, input().split()))\n print((var_1 * var_2 // 1))\n\n\nif __name__ == \"__main__\":\n func_1()\n```", "output": "FASTER 1.9156", "pair_id": "python_p02659_forward", "problem_id": "p02659", "language": "python", "direction": "forward", "speedup_ratio": 3.7726} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().rstrip().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = list(map(int, list(str(var_4))))\n if var_5[0] == var_5[4] and var_5[1] == var_5[3]:\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_5 in range(10):\n for var_6 in range(10):\n for var_7 in range(10):\n var_3 = 10000 * var_5 + 1000 * var_6 + 100 * var_7 + 10 * var_6 + var_5\n if var_1 <= var_3 <= var_2:\n var_4 += 1\nprint(var_4)\n```", "output": "FASTER 5.5086", "pair_id": "python_p03416_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 45.5247} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_3 in range(var_1, var_2 + 1):\n var_5 = list(str(var_3))\n var_6 = list(reversed(var_5))\n if var_5 == var_6:\n var_4 += 1\nprint(var_4)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1 = list(map(int, input().split()))\nvar_2 = 0\nfor var_3 in range(var_1[0], var_1[1] + 1):\n var_4 = str(var_3)\n if var_4[0] == var_4[4] and var_4[1] == var_4[3]:\n var_2 += 1\nprint(var_2)\n```", "output": "FASTER 1.5975", "pair_id": "python_p03416_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 3.0261} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\n\nsys.setrecursionlimit(2147483647)\nvar_2 = float(\"inf\")\nvar_3 = 10**9 + 7\nvar_10 = lambda: sys.stdin.readline().rstrip()\n\n\ndef func_1():\n var_11, var_4 = list(map(int, var_10().split()))\n var_1 = [tuple(map(int, var_10().split())) for _ in range(var_11)]\n var_1.sort()\n var_8 = [0] * var_4\n var_6 = -var_2\n for var_9 in range(var_11):\n var_5, var_7 = var_1[var_9]\n var_12 = var_8[:]\n for var_13 in range(var_4):\n if var_13 + var_5 < var_4:\n var_12[var_13 + var_5] = max(\n var_12[var_13 + var_5], var_8[var_13] + var_7\n )\n else:\n var_6 = max(var_6, var_8[var_13] + var_7)\n var_8 = var_12\n print((max(var_6, max(var_8))))\n\n\nfunc_1()\n```\n\n=== Code B (Modified) ===\n```python\nvar_8, var_9 = list(map(int, input().split()))\nvar_5 = [[0] * (var_9 + 3001) for _ in range(var_8 + 1)]\nvar_3 = 0\nvar_2 = [list(map(int, input().split())) for _ in range(var_8)]\nvar_2.sort()\nfor var_6 in range(1, var_8 + 1):\n var_1, var_4 = var_2[var_6 - 1]\n for var_7 in range(var_9):\n var_5[var_6][var_7] = max(var_5[var_6 - 1][var_7], var_5[var_6][var_7])\n var_5[var_6][var_7 + var_1] = var_5[var_6 - 1][var_7] + var_4\n var_3 = max(var_5[var_6][var_7], var_5[var_6][var_7 + var_1], var_3)\nprint(var_3)\n```", "output": "SLOWER 1.5497", "pair_id": "python_p02863_reversed", "problem_id": "p02863", "language": "python", "direction": "reversed", "speedup_ratio": 2.9276} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_3, var_2 = map(int, input().split())\nvar_4 = [0] * var_3\n[\n exec(\n \"roads[%d] += 1; roads[%d] += 1\"\n % tuple(map(lambda var_1: int(var_1) - 1, input().split()))\n )\n for _ in range(var_2)\n]\nprint(*var_4, sep=\"\\n\", end=\"\")\n```\n\n=== Code B (Modified) ===\n```python\nvar_4, var_3 = list(map(int, input().split()))\nvar_1 = [0] * var_4\nfor var_2 in range(var_3):\n var_5, var_6 = list(map(int, input().split()))\n var_1[var_5 - 1] += 1\n var_1[var_6 - 1] += 1\nfor var_2 in range(var_4):\n print((var_1[var_2]))\n```", "output": "FASTER 1.1067", "pair_id": "python_p03720_forward", "problem_id": "p03720", "language": "python", "direction": "forward", "speedup_ratio": 2.1535} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = [0] * (var_2 + 1)\nfor var_3 in range(1, var_2 + 1):\n if str(var_3) == str(var_3)[::-1]:\n var_4[var_3] = var_4[var_3 - 1] + 1\n else:\n var_4[var_3] = var_4[var_3 - 1]\nprint((var_4[var_2] - var_4[var_1 - 1]))\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_5 in range(10):\n for var_6 in range(10):\n for var_7 in range(10):\n var_3 = 10000 * var_5 + 1000 * var_6 + 100 * var_7 + 10 * var_6 + var_5\n if var_1 <= var_3 <= var_2:\n var_4 += 1\nprint(var_4)\n```", "output": "FASTER 5.7678", "pair_id": "python_p03416_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 54.4866} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = input().split()\nvar_1 = int(var_1)\nvar_2 = int(\"\".join(var_2.split(\".\")))\nprint(((var_1 * var_2) // 100))\n```\n\n=== Code B (Modified) ===\n```python\ndef func_1():\n from sys import setrecursionlimit, stdin\n from os import environ\n from collections import defaultdict, deque, Counter\n from math import ceil, floor, gcd\n from itertools import accumulate, combinations, combinations_with_replacement\n\n setrecursionlimit(10**6)\n var_7 = (\n (lambda *var_11: print(*var_11))\n if \"TERM_PROGRAM\" in environ\n else lambda *var_12: 0\n )\n var_8 = lambda: stdin.readline().rstrip()\n var_3 = lambda: list(map(int, var_8().split()))\n var_1 = lambda: int(var_8())\n var_4 = 10**9 + 7\n var_2 = 10**9 + 10\n var_9, var_10 = var_8().split()\n var_5 = int(var_9)\n var_10 = var_10.split(\".\")\n var_6 = int(var_10[0]) * 100\n if len(var_10) == 2:\n var_6 += int(var_10[1])\n print(var_5 * var_6 // 100)\n\n\nfunc_1()\n```", "output": "SLOWER 2.3519", "pair_id": "python_p02659_reversed", "problem_id": "p02659", "language": "python", "direction": "reversed", "speedup_ratio": 5.1048} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\n\"\"\"\"\"\"\n\nfrom collections import defaultdict\n\n\ndef func_1(var_10, var_9):\n var_5 = 1\n yield var_5\n for _ in range(1, var_10):\n var_5 = (var_5 * 10) % var_9\n yield var_5\n\n\ndef func_2():\n var_3 = 2019\n var_4 = input()[::-1]\n\n var_1 = [\n int(var_11) * var_10 % var_3\n for var_11, var_10 in zip(var_4, func_1(len(var_4), var_3))\n ]\n\n var_2 = [0]\n for var_5 in var_1:\n var_2.append((var_2[-1] + var_5) % var_3)\n\n var_8 = defaultdict(int)\n for var_6 in var_2:\n var_8[var_6] += 1\n var_7 = sum(var_12 * (var_12 - 1) // 2 for var_12 in list(var_8.values()))\n print(var_7)\n\n\nfunc_2()\n```\n\n=== Code B (Modified) ===\n```python\nvar_6 = input()[::-1]\nvar_5 = len(var_6)\nvar_1 = [0] * var_5\nvar_3 = [0] * var_5\nvar_2 = [0] * 2019\nvar_7 = 10\nvar_1[0] = int(var_6[0])\nvar_3[0] = var_1[0]\nvar_2[var_3[0]] += 1\nfor var_4 in range(1, var_5):\n var_1[var_4] = int(var_6[var_4]) * var_7 % 2019\n var_3[var_4] = (var_3[var_4 - 1] + var_1[var_4]) % 2019\n var_2[var_3[var_4]] += 1\n var_7 = var_7 * 10 % 2019\nprint(\n (\n int(sum([var_2[var_4] * (var_2[var_4] - 1) for var_4 in range(2019)]) / 2)\n + var_2[0]\n )\n)\n```", "output": "SLOWER 1.0502", "pair_id": "python_p02702_reversed", "problem_id": "p02702", "language": "python", "direction": "reversed", "speedup_ratio": 2.0708} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_6 = sorted([list(map(int, input().split())) for var_5 in range(var_1)])\n\nvar_4 = [[0] * (var_2 + 1) for var_5 in range(var_1 + 1)]\n\nfor var_5 in range(var_1):\n var_9, var_8 = var_6[var_5]\n for var_7 in range(var_2 + 1):\n if var_7 + var_9 <= var_2:\n var_4[var_5 + 1][var_7 + var_9] = max(\n var_4[var_5 + 1][var_7 + var_9], var_4[var_5][var_7] + var_8\n )\n var_4[var_5 + 1][var_7] = max(var_4[var_5][var_7], var_4[var_5 + 1][var_7])\nvar_3 = 0\nfor var_5, (var_9, var_8) in enumerate(var_6):\n for var_7 in range(var_2):\n var_3 = max(var_3, var_4[var_5][var_7] + var_8)\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\n\nsys.setrecursionlimit(2147483647)\nvar_2 = float(\"inf\")\nvar_3 = 10**9 + 7\nvar_10 = lambda: sys.stdin.readline().rstrip()\n\n\ndef func_1():\n var_11, var_4 = list(map(int, var_10().split()))\n var_1 = [tuple(map(int, var_10().split())) for _ in range(var_11)]\n var_1.sort()\n var_8 = [0] * var_4\n var_6 = -var_2\n for var_9 in range(var_11):\n var_5, var_7 = var_1[var_9]\n var_12 = var_8[:]\n for var_13 in range(var_4):\n if var_13 + var_5 < var_4:\n var_12[var_13 + var_5] = max(\n var_12[var_13 + var_5], var_8[var_13] + var_7\n )\n else:\n var_6 = max(var_6, var_8[var_13] + var_7)\n var_8 = var_12\n print((max(var_6, max(var_8))))\n\n\nfunc_1()\n```", "output": "FASTER 1.8014", "pair_id": "python_p02863_forward", "problem_id": "p02863", "language": "python", "direction": "forward", "speedup_ratio": 3.4856} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = input().split()\nvar_1 = int(var_1)\nvar_2 = int(\"\".join(var_2.split(\".\")))\nprint(((var_1 * var_2) // 100))\n```\n\n=== Code B (Modified) ===\n```python\ndef func_1():\n from sys import setrecursionlimit, stdin\n from os import environ\n from collections import defaultdict, deque, Counter\n from math import ceil, floor, gcd\n from itertools import accumulate, combinations, combinations_with_replacement\n\n setrecursionlimit(10**6)\n var_7 = (\n (lambda *var_11: print(*var_11))\n if \"TERM_PROGRAM\" in environ\n else lambda *var_12: 0\n )\n var_8 = lambda: stdin.readline().rstrip()\n var_3 = lambda: list(map(int, var_8().split()))\n var_1 = lambda: int(var_8())\n var_4 = 10**9 + 7\n var_2 = 10**9 + 10\n var_9, var_10 = var_8().split()\n var_5 = int(var_9)\n var_6 = int(float(var_10) * 100 + 0.5)\n print(var_5 * var_6 // 100)\n\n\nfunc_1()\n```", "output": "SLOWER 2.2081", "pair_id": "python_p02659_reversed", "problem_id": "p02659", "language": "python", "direction": "reversed", "speedup_ratio": 4.6207} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\ndef func_1():\n from sys import setrecursionlimit, stdin\n from os import environ\n from collections import defaultdict, deque, Counter\n from math import ceil, floor, gcd\n from itertools import accumulate, combinations, combinations_with_replacement\n\n setrecursionlimit(10**6)\n var_7 = (\n (lambda *var_11: print(*var_11))\n if \"TERM_PROGRAM\" in environ\n else lambda *var_12: 0\n )\n var_8 = lambda: stdin.readline().rstrip()\n var_3 = lambda: list(map(int, var_8().split()))\n var_1 = lambda: int(var_8())\n var_4 = 10**9 + 7\n var_2 = 10**9 + 10\n var_9, var_10 = var_8().split()\n var_5 = int(var_9)\n var_10 = var_10.split(\".\")\n var_6 = int(var_10[0]) * 100\n if len(var_10) == 2:\n var_6 += int(var_10[1])\n print(var_5 * var_6 // 100)\n\n\nfunc_1()\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = input().split()\nprint((int(var_1) * int(var_2[:-3] + var_2[-2:]) // 100))\n```", "output": "FASTER 2.5742", "pair_id": "python_p02659_forward", "problem_id": "p02659", "language": "python", "direction": "forward", "speedup_ratio": 5.9555} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_4 = str(var_4)\n if var_4[0] == var_4[-1] and var_4[1] == var_4[-2]:\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_4 = {}\nvar_5 = 0\nfor var_6 in range(10000, 100000):\n var_3 = list(str(var_6))\n if var_3 == list(reversed(var_3)):\n var_5 += 1\n var_4[var_6] = var_5\nvar_1, var_2 = list(map(int, input().split()))\nprint((var_4[var_2] - var_4[var_1 - 1] if var_1 > 10000 else var_4[var_2]))\n```", "output": "SLOWER 3.7573", "pair_id": "python_p03416_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 13.5227} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = str(var_4)\n if var_5[0] == var_5[4] and var_5[1] == var_5[3]:\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_4 = {}\nvar_5 = 0\nfor var_6 in range(10000, 100000):\n var_3 = list(str(var_6))\n if var_3 == list(reversed(var_3)):\n var_5 += 1\n var_4[var_6] = var_5\nvar_1, var_2 = list(map(int, input().split()))\nprint((var_4[var_2] - var_4[var_1 - 1] if var_1 > 10000 else var_4[var_2]))\n```", "output": "SLOWER 3.8398", "pair_id": "python_p03416_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 14.318} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\ndef func_1():\n var_1, var_2 = list(map(int, input().split()))\n var_3 = 0\n for var_4 in range(var_1, var_2 + 1):\n\n if (var_4 % 10) == (var_4 // 10000 % 10) and (var_4 // 10 % 10) == (\n var_4 // 1000 % 10\n ):\n var_3 += 1\n print(var_3)\n\n\nif __name__ == \"__main__\":\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_4 = str(var_4)\n if var_4[0] == var_4[-1] and var_4[1] == var_4[-2]:\n var_3 += 1\nprint(var_3)\n```", "output": "SLOWER 1.4803", "pair_id": "python_p03416_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 2.7901} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_2 = int(eval(input()))\n(*var_1,) = list(map(int, input().split()))\nvar_5 = 0\nfor var_3 in var_1:\n if var_3 % 2 == 0:\n var_5 += 1\nvar_4 = 3**var_2 - 2**var_5\nprint(var_4)\n```\n\n=== Code B (Modified) ===\n```python\nvar_6 = int(eval(input()))\nvar_2 = list(map(int, input().split()))\nfrom itertools import product\n\nvar_5 = [-1, 0, 1]\nvar_3 = 0\nfor var_7 in product(var_5, repeat=var_6):\n var_1 = []\n for var_4 in range(var_6):\n var_1.append(var_7[var_4] + var_2[var_4])\n if any(var_8 % 2 == 0 for var_8 in var_1):\n var_3 += 1\nprint(var_3)\n```", "output": "SLOWER 9.836", "pair_id": "python_p03568_reversed", "problem_id": "p03568", "language": "python", "direction": "reversed", "speedup_ratio": 913.9804} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nfrom sys import stdin\n\nvar_6 = lambda: list(map(int, stdin.readline().split()))\nvar_5 = lambda: list(map(int, stdin.readline().split()))\nvar_1, var_3 = var_6()\nvar_2 = 0\nfor var_4 in range(var_1, var_3 + 1):\n var_7 = str(var_4)\n if var_7 == var_7[::-1]:\n var_2 += 1\nprint(var_2)\n```\n\n=== Code B (Modified) ===\n```python\nvar_4 = {}\nvar_5 = 0\nfor var_6 in range(10000, 100000):\n var_3 = list(str(var_6))\n if var_3 == list(reversed(var_3)):\n var_5 += 1\n var_4[var_6] = var_5\nvar_1, var_2 = list(map(int, input().split()))\nprint((var_4[var_2] - var_4[var_1 - 1] if var_1 > 10000 else var_4[var_2]))\n```", "output": "SLOWER 3.5552", "pair_id": "python_p03416_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 11.7549} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\nfrom collections import deque\n\n\ndef func_1():\n var_7 = int(sys.stdin.readline().rstrip())\n var_3 = list(map(int, sys.stdin.read().split()))\n var_3 = list(zip(var_3, var_3))\n var_1 = [[] for _ in range(var_7 + 1)]\n for var_2, var_4 in var_3:\n var_1[var_2].append(var_4)\n var_1[var_4].append(var_2)\n var_10 = deque([1])\n var_9 = [None] * (var_7 + 1)\n var_6 = [0] * (var_7 + 1)\n while var_10:\n var_11 = var_10.popleft()\n var_8 = var_6[var_11]\n var_5 = 1\n for var_12 in var_1[var_11]:\n if var_12 == var_9[var_11]:\n continue\n var_9[var_12] = var_11\n if var_5 == var_8:\n var_5 += 1\n var_6[var_12] = var_5\n var_10.append(var_12)\n var_5 += 1\n print((max(var_6)))\n for var_2, var_4 in var_3:\n if var_2 == var_9[var_4]:\n print((var_6[var_4]))\n else:\n print((var_6[var_2]))\n\n\nif __name__ == \"__main__\":\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nimport copy\n\nvar_8 = int(eval(input()))\nvar_10 = set([var_6 for var_6 in range(1, 10**5)])\nvar_5 = []\nvar_11 = {}\nvar_9 = []\nfor var_6 in range(var_8 - 1):\n var_1, var_2 = list(map(int, input().split(\" \")))\n var_5.append([var_1, var_2])\n var_11.setdefault(var_1, []).append(var_2)\n var_9.append([])\nvar_9.append([])\nvar_9.append([])\nvar_7 = 0\nfor var_12 in range(1, var_8 + 1):\n var_14 = var_11.get(var_12, [])\n var_3 = 1\n for var_13 in var_14:\n if var_3 in var_9[var_12]:\n var_3 += 1\n else:\n pass\n var_9[var_13].append(var_3)\n if var_3 >= var_7:\n var_7 = var_3\n var_3 += 1\nprint(var_7)\nfor var_4 in var_5:\n print((var_9[var_4[1]][0]))\n```", "output": "SLOWER 4.4037", "pair_id": "python_p02850_reversed", "problem_id": "p02850", "language": "python", "direction": "reversed", "speedup_ratio": 21.1661} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_6 in range(var_1, var_2 + 1):\n var_3 = str(var_6)\n var_5 = True\n for var_7 in range(len(var_3) // 2):\n if var_3[var_7] != var_3[-var_7 - 1] and var_5:\n var_5 = not var_5\n if var_5:\n var_4 += 1\nprint(var_4)\n```\n\n=== Code B (Modified) ===\n```python\ndef func_1():\n var_1, var_2 = list(map(int, input().split()))\n var_3 = 0\n for var_4 in range(var_1, var_2 + 1):\n\n if (var_4 % 10) == (var_4 // 10000 % 10) and (var_4 // 10 % 10) == (\n var_4 // 1000 % 10\n ):\n var_3 += 1\n print(var_3)\n\n\nif __name__ == \"__main__\":\n func_1()\n```", "output": "FASTER 3.124", "pair_id": "python_p03416_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 8.718} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\nfrom collections import Counter\n\n\ndef func_9():\n return sys.stdin.readline().strip()\n\n\ndef func_10(var_8, var_9, var_10):\n return [[var_10] * var_9 for var_13 in range(var_8)]\n\n\ndef func_11(var_8, var_9, var_10, var_11):\n return [[[var_11] * var_10 for var_14 in range(var_9)] for var_13 in range(var_8)]\n\n\ndef func_12(var_8, var_9, var_10, var_11, var_12):\n return [\n [[[var_12] * var_11 for var_14 in range(var_10)] for var_14 in range(var_9)]\n for var_13 in range(var_8)\n ]\n\n\ndef func_8(var_16, var_17=1):\n return int(-(-var_16 // var_17))\n\n\ndef func_1():\n return int(eval(func_9()))\n\n\ndef func_3():\n return list(map(int, func_9().split()))\n\n\ndef func_2(var_7=None):\n return list(func_3()) if var_7 is None else [func_1() for var_13 in range(var_7)]\n\n\ndef func_7():\n print(\"Yes\")\n\n\ndef func_5():\n print(\"No\")\n\n\ndef func_6():\n print(\"YES\")\n\n\ndef func_4():\n print(\"NO\")\n\n\nsys.setrecursionlimit(10**9)\nvar_3 = 10**18\nvar_6 = 10**9 + 7\nvar_7, var_5, var_4 = func_3()\nvar_1 = func_2()\nvar_2 = func_2()\nvar_15 = min(var_1) + min(var_2)\nfor _ in range(var_4):\n var_16, var_17, var_10 = func_3()\n var_16 -= 1\n var_17 -= 1\n var_15 = min(var_15, var_1[var_16] + var_2[var_17] - var_10)\nprint(var_15)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2, var_8 = list(map(int, input().split()))\nvar_4 = list(map(int, input().split()))\nvar_9 = list(map(int, input().split()))\nvar_10 = [list(map(int, input().split())) for var_6 in range(var_8)]\nvar_7 = 200001\nfor var_6 in range(var_8):\n var_5 = var_10[var_6][0] - 1\n var_3 = var_10[var_6][1] - 1\n if var_7 >= var_4[var_5] + var_9[var_3] - var_10[var_6][2]:\n var_7 = var_4[var_5] + var_9[var_3] - var_10[var_6][2]\nvar_4.sort()\nvar_9.sort()\nif var_7 >= (var_4[0] + var_9[0]):\n print((var_4[0] + var_9[0]))\nelse:\n print(var_7)\n```", "output": "FASTER 1.1425", "pair_id": "python_p02748_forward", "problem_id": "p02748", "language": "python", "direction": "forward", "speedup_ratio": 2.2077} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\n\nvar_7 = sys.stdin.readline\nfrom itertools import combinations\n\n\ndef func_3(var_10):\n for _ in range(var_10):\n yield list(map(int, var_7().split()))\n\n\ndef func_1(var_9, var_5, var_11):\n var_3 = len([0 for var_8 in var_9 if var_5[var_8] == 1])\n return var_11[var_3]\n\n\ndef func_2():\n var_10 = int(eval(var_7()))\n var_1 = list(func_3(var_10))\n var_2 = list(func_3(var_10))\n for var_6 in range(1, 11):\n for var_4 in combinations(list(range(10)), var_6):\n yield sum(\n func_1(var_4, var_5, var_11) for var_5, var_11 in zip(var_1, var_2)\n )\n\n\nprint((max(func_2())))\n```\n\n=== Code B (Modified) ===\n```python\nvar_8 = int(eval(input()))\nvar_4 = []\nfor var_5 in range(var_8):\n var_11 = 0\n var_9 = list(map(int, input().split()))\n for var_6 in range(10):\n var_11 += var_9[var_6] << var_6\n var_4.append(var_11)\nvar_10 = []\nfor var_5 in range(var_8):\n var_10.append(list(map(int, input().split())))\nvar_1 = -(10**12)\nfor var_5 in range(1, 1 << 10):\n var_11 = 0\n for var_6 in range(var_8):\n var_3 = var_4[var_6] & var_5\n var_2 = 0\n for var_7 in range(10):\n if (var_3 >> var_7) % 2:\n var_2 += 1\n var_11 += var_10[var_6][var_2]\n var_1 = max(var_1, var_11)\nprint(var_1)\n```", "output": "SLOWER 1.4578", "pair_id": "python_p03503_reversed", "problem_id": "p03503", "language": "python", "direction": "reversed", "speedup_ratio": 2.7469} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport numpy as np\nfrom itertools import product\n\nvar_6 = int(eval(input()))\nvar_2 = list(map(int, input().split()))\nvar_2 = np.array(var_2)\nvar_5 = [-1, 0, 1]\nvar_3 = 0\nfor var_7 in product(var_5, repeat=var_6):\n var_7 = np.array(var_7)\n var_1 = var_2 + var_7\n var_4 = var_1.cumprod()\n if var_4[-1] % 2 == 0:\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_4 = int(eval(input()))\nvar_2 = list(map(int, input().split()))\n\n\ndef func_1(var_1, var_8, var_3):\n if var_8 == var_4:\n var_9 = 1\n for var_5 in var_3:\n var_9 *= var_5\n return 1 if var_9 % 2 == 0 else 0\n var_6 = var_3.copy()\n var_6.append(var_1[var_8] - 1)\n var_5 = var_3.copy()\n var_5.append(var_1[var_8])\n var_7 = var_3.copy()\n var_7.append(var_1[var_8] + 1)\n return (\n func_1(var_1, var_8 + 1, var_6)\n + func_1(var_1, var_8 + 1, var_5)\n + func_1(var_1, var_8 + 1, var_7)\n )\n\n\nprint((func_1(var_2, 0, [])))\n```", "output": "FASTER 1.7419", "pair_id": "python_p03568_forward", "problem_id": "p03568", "language": "python", "direction": "forward", "speedup_ratio": 3.3447} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_5 in range(var_1, var_2 + 1):\n var_3 = str(var_5)\n if var_3[0] == var_3[-1] and var_3[1] == var_3[-2]:\n var_4 += 1\nprint(var_4)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = list(reversed(list(str(var_4))))\n if var_5 == list(str(var_4)):\n var_3 += 1\nprint(var_3)\n```", "output": "SLOWER 1.7485", "pair_id": "python_p03416_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 3.3602} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport copy\nimport random\nimport bisect\nimport fractions\nimport math\nimport sys\nimport collections\nfrom decimal import Decimal\n\nvar_5 = 10**9 + 7\nsys.setrecursionlimit(var_5)\nvar_3 = collections.deque()\n\n\ndef func_1():\n return list(map(int, sys.stdin.readline().split()))\n\n\nvar_1 = int(eval(input()))\nvar_6 = [0 for var_4 in range(var_1)]\nfor var_4 in range(var_1):\n var_6[var_4] = int(eval(input()))\nvar_6.sort()\nvar_2 = sum(var_6)\nvar_2 -= var_6[-1] // 2\nprint(var_2)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1 = [int(eval(input())) for _ in range(int(eval(input())))]\nprint((sum(var_1) - int(max(var_1) / 2)))\n```", "output": "FASTER 1.0343", "pair_id": "python_p03207_forward", "problem_id": "p03207", "language": "python", "direction": "forward", "speedup_ratio": 2.0481} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = [\n var_3 for var_3 in map(str, list(range(var_1, var_2 + 1))) if var_3 == var_3[::-1]\n]\nprint((len(var_4)))\n```\n\n=== Code B (Modified) ===\n```python\nvar_4, var_3 = list(map(int, input().split()))\nvar_1 = 0\nfor var_2 in range(var_4, var_3 + 1):\n if str(var_2)[0] + str(var_2)[1] == str(var_2)[-1] + str(var_2)[-2]:\n var_1 += 1\nprint(var_1)\n```", "output": "SLOWER 2.0397", "pair_id": "python_p03416_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 4.1115} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\nfrom collections import Counter\n\n\ndef func_10():\n return sys.stdin.readline().strip()\n\n\ndef func_11(var_12, var_13, var_14):\n return [[var_14] * var_13 for var_17 in range(var_12)]\n\n\ndef func_12(var_12, var_13, var_14, var_15):\n return [[[var_15] * var_14 for var_18 in range(var_13)] for var_17 in range(var_12)]\n\n\ndef func_13(var_12, var_13, var_14, var_15, var_16):\n return [\n [[[var_16] * var_15 for var_18 in range(var_14)] for var_18 in range(var_13)]\n for var_17 in range(var_12)\n ]\n\n\ndef func_8(var_22, var_23=1):\n return int(-(-var_22 // var_23))\n\n\ndef func_1():\n return int(eval(func_10()))\n\n\ndef func_3():\n return list(map(int, func_10().split()))\n\n\ndef func_2(var_11=None):\n return list(func_3()) if var_11 is None else [func_1() for var_17 in range(var_11)]\n\n\ndef func_7():\n print(\"Yes\")\n\n\ndef func_5():\n print(\"No\")\n\n\ndef func_6():\n print(\"YES\")\n\n\ndef func_4():\n print(\"NO\")\n\n\nsys.setrecursionlimit(10**9)\nvar_5 = 10**18\nvar_10 = 10**9 + 7\n\n\ndef func_9(var_1, var_2):\n \"\"\"\"\"\"\n import numpy as np\n from numpy.fft import rfft, irfft\n\n var_8 = max(var_1)\n var_9 = max(var_2)\n var_3 = [0] * (var_8 + 1)\n var_4 = [0] * (var_9 + 1)\n for var_12 in var_1:\n var_3[var_12] += 1\n for var_13 in var_2:\n var_4[var_13] += 1\n\n var_6 = 1\n var_19 = 0\n while var_6 <= var_8 + var_9:\n var_19 += 1\n var_6 = 2**var_19\n\n var_21 = irfft(rfft(var_3, var_6) * rfft(var_4, var_6), var_6)\n\n var_21 = np.rint(var_21).astype(np.int64)\n return var_21\n\n\nvar_11, var_7, var_6 = func_3()\nvar_1 = func_2()\nvar_2 = func_2()\nvar_21 = list(func_9(var_1, var_2))\nvar_20 = var_5\nfor var_17, var_12 in enumerate(var_21):\n if var_12 != 0:\n var_20 = var_17\n break\nfor _ in range(var_6):\n var_22, var_23, var_14 = func_3()\n var_22 -= 1\n var_23 -= 1\n var_20 = min(var_20, var_1[var_22] + var_2[var_23] - var_14)\nprint(var_20)\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\nfrom collections import Counter\n\n\ndef func_9():\n return sys.stdin.readline().strip()\n\n\ndef func_10(var_8, var_9, var_10):\n return [[var_10] * var_9 for var_13 in range(var_8)]\n\n\ndef func_11(var_8, var_9, var_10, var_11):\n return [[[var_11] * var_10 for var_14 in range(var_9)] for var_13 in range(var_8)]\n\n\ndef func_12(var_8, var_9, var_10, var_11, var_12):\n return [\n [[[var_12] * var_11 for var_14 in range(var_10)] for var_14 in range(var_9)]\n for var_13 in range(var_8)\n ]\n\n\ndef func_8(var_16, var_17=1):\n return int(-(-var_16 // var_17))\n\n\ndef func_1():\n return int(eval(func_9()))\n\n\ndef func_3():\n return list(map(int, func_9().split()))\n\n\ndef func_2(var_7=None):\n return list(func_3()) if var_7 is None else [func_1() for var_13 in range(var_7)]\n\n\ndef func_7():\n print(\"Yes\")\n\n\ndef func_5():\n print(\"No\")\n\n\ndef func_6():\n print(\"YES\")\n\n\ndef func_4():\n print(\"NO\")\n\n\nsys.setrecursionlimit(10**9)\nvar_3 = 10**18\nvar_6 = 10**9 + 7\nvar_7, var_5, var_4 = func_3()\nvar_1 = func_2()\nvar_2 = func_2()\nvar_15 = min(var_1) + min(var_2)\nfor _ in range(var_4):\n var_16, var_17, var_10 = func_3()\n var_16 -= 1\n var_17 -= 1\n var_15 = min(var_15, var_1[var_16] + var_2[var_17] - var_10)\nprint(var_15)\n```", "output": "FASTER 1.3665", "pair_id": "python_p02748_forward", "problem_id": "p02748", "language": "python", "direction": "forward", "speedup_ratio": 2.5785} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1 = list(map(int, input().split()))\nvar_2 = 0\nfor var_3 in range(var_1[0], var_1[1] + 1):\n var_4 = str(var_3)\n if var_4[0] == var_4[4] and var_4[1] == var_4[3]:\n var_2 += 1\nprint(var_2)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = list(reversed(list(str(var_4))))\n if var_5 == list(str(var_4)):\n var_3 += 1\nprint(var_3)\n```", "output": "SLOWER 1.9458", "pair_id": "python_p03416_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 3.8524} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\ndef func_1():\n var_1, var_2 = list(map(int, input().rstrip().split()))\n var_3 = 0\n for var_4 in range(var_1, var_2 + 1):\n var_5 = str(var_4)\n if var_5 == var_5[::-1]:\n var_3 += 1\n print(var_3)\n\n\nif __name__ == \"__main__\":\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = input().split()\nvar_1 = int(var_1)\nvar_2 = int(var_2)\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = list(str(var_4))\n if (var_5[0] == var_5[4]) and (var_5[1] == var_5[3]):\n var_3 = var_3 + 1\nprint(var_3)\n```", "output": "SLOWER 1.1503", "pair_id": "python_p03416_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 2.2196} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport bisect\n\nvar_9, var_4, var_1 = list(map(int, input().split()))\nvar_5 = [None] * var_9\nfor var_7 in range(var_9):\n var_11, var_6 = list(map(int, input().split()))\n var_5[var_7] = (var_11, var_6)\nvar_5.sort()\nvar_11 = [int(var_5[var_7][0]) for var_7 in range(var_9)]\nvar_6 = [int(var_5[var_7][1]) for var_7 in range(var_9)]\nvar_2 = 0\nvar_3 = [0] * var_9\nfor var_7 in range(var_9):\n if var_7 != 0:\n var_3[var_7] += var_3[var_7 - 1]\n if var_3[var_7] >= var_6[var_7]:\n continue\n var_10 = (var_6[var_7] - var_3[var_7] - 1) // var_1 + 1\n var_2 += var_10\n var_3[var_7] += var_10 * var_1\n var_8 = bisect.bisect_right(var_11, var_11[var_7] + 2 * var_4)\n if var_8 == var_9:\n continue\n var_3[var_8] -= var_10 * var_1\nprint(var_2)\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\n\nsys.setrecursionlimit(500000)\n\n\ndef func_3():\n return sys.stdin.readline()[:-1]\n\n\nclass Class_1:\n def __init__(self, var_3):\n self.N = len(var_3)\n self.bit = [0] * self.N\n for var_11, var_14 in enumerate(var_3):\n self.add(var_11, var_14)\n\n def func_1(self, var_5, var_18):\n var_19 = var_5 + 1\n for var_11 in range(1000):\n self.bit[var_19 - 1] += var_18\n var_19 += var_19 & -var_19\n if var_19 > self.N:\n break\n\n def func_5(self, var_5):\n var_19 = var_5 + 1\n var_16 = 0\n for var_11 in range(1000):\n var_16 += self.bit[var_19 - 1]\n var_19 -= var_19 & -var_19\n if var_19 <= 0:\n break\n return var_16\n\n\ndef func_4():\n var_4, var_2, var_1 = list(map(int, func_3().split()))\n var_9 = []\n for var_11 in range(var_4):\n var_19, var_10 = list(map(int, func_3().split()))\n if var_10 % var_1 == 0:\n var_9.append([var_19, var_10 // var_1])\n else:\n var_9.append([var_19, var_10 // var_1 + 1])\n var_9.sort(key=lambda var_19: var_19[0])\n\n def func_2(var_12):\n var_19 = var_9[var_12][0]\n if var_9[var_4 - 1][0] <= var_19 + 2 * var_2:\n return var_4 - 1\n var_14 = var_12\n var_15 = var_4 - 1\n while var_15 - var_14 > 1:\n if var_9[(var_15 + var_14) // 2][0] <= var_19 + 2 * var_2:\n var_14 = (var_15 + var_14) // 2\n else:\n var_15 = (var_15 + var_14) // 2\n return var_14\n\n var_6 = Class_1([0] * var_4)\n var_7 = 0\n for var_11 in range(var_4):\n if var_11 > 0:\n var_17 = var_6.sum(var_4 - 1) - var_6.sum(var_11 - 1)\n else:\n var_17 = 0\n if var_9[var_11][1] - var_17 > 0:\n var_7 += var_9[var_11][1] - var_17\n var_13 = func_2(var_11)\n var_6.add(var_13, var_9[var_11][1] - var_17)\n var_9 = var_9[::-1]\n for var_11 in range(var_4):\n var_9[var_11][0] = -var_9[var_11][0]\n var_6 = Class_1([0] * var_4)\n var_8 = 0\n for var_11 in range(var_4):\n if var_11 > 0:\n var_17 = var_6.sum(var_4 - 1) - var_6.sum(var_11 - 1)\n else:\n var_17 = 0\n if var_9[var_11][1] - var_17 > 0:\n var_8 += var_9[var_11][1] - var_17\n var_13 = func_2(var_11)\n var_6.add(var_13, var_9[var_11][1] - var_17)\n print((min(var_7, var_8)))\n\n\nif __name__ == \"__main__\":\n func_4()\n```", "output": "SLOWER 1.3694", "pair_id": "python_p02788_reversed", "problem_id": "p02788", "language": "python", "direction": "reversed", "speedup_ratio": 2.5837} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport math\n\n\ndef func_1():\n var_1, var_2 = list(map(int, input().split()))\n\n var_5 = max(math.ceil(var_1 / 0.08), math.ceil(var_2 / 0.1))\n\n var_4 = min((math.ceil((var_1 + 1) / 0.08), math.ceil((var_2 + 1) / 0.1)))\n\n for var_3 in range(var_5, var_4 + 1):\n if (math.floor(var_3 * 0.08) == var_1) and (math.floor(var_3 * 0.1) == var_2):\n print(var_3)\n quit()\n\n print((-1))\n\n\nif __name__ == \"__main__\":\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_3 = list(map(int, input().split()))\nvar_2 = -1\nfor var_4 in range(10, 12501):\n if int(var_4 * 0.08) == var_1 and int(var_4 * 0.1) == var_3:\n var_2 = var_4\n break\nprint(var_2)\n```", "output": "SLOWER 4.5761", "pair_id": "python_p02755_reversed", "problem_id": "p02755", "language": "python", "direction": "reversed", "speedup_ratio": 23.8532} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nfrom collections import Counter\n\nvar_4 = int(eval(input()))\nvar_1 = list(map(int, input().split()))\nvar_2 = Counter(var_1)\nvar_3 = list(var_2)\nif sum(var_1) == 0:\n print(\"Yes\")\nelif len(var_1) % 3 != 0:\n print(\"No\")\nelif len(var_2) > 3 or len(var_2) <= 1:\n print(\"No\")\nelif len(var_2) == 3:\n if (\n var_2[var_3[0]] == var_4 // 3\n and var_2[var_3[1]] == var_4 // 3\n and var_2[var_3[2]] == var_4 // 3\n ):\n if var_3[0] ^ var_3[1] ^ var_3[2] == 0:\n print(\"Yes\")\n else:\n print(\"No\")\n else:\n print(\"No\")\nelse:\n var_3.sort()\n if var_3[0] == 0 and var_2[var_3[0]] == var_4 // 3:\n print(\"Yes\")\n else:\n print(\"No\")\n```\n\n=== Code B (Modified) ===\n```python\n_, var_1 = open(0)\nvar_1, *var_2 = list(map(int, var_1.split()))\nfor var_2 in var_2:\n var_1 ^= var_2\nprint((\"YNeos\"[var_1 > 0 :: 2]))\n```", "output": "FASTER 1.4077", "pair_id": "python_p02975_forward", "problem_id": "p02975", "language": "python", "direction": "forward", "speedup_ratio": 2.6532} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_4 = {}\nvar_5 = 0\nfor var_6 in range(10000, 100000):\n var_3 = list(str(var_6))\n if var_3 == list(reversed(var_3)):\n var_5 += 1\n var_4[var_6] = var_5\nvar_1, var_2 = list(map(int, input().split()))\nprint((var_4[var_2] - var_4[var_1 - 1] if var_1 > 10000 else var_4[var_2]))\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_6 = str(var_4)\n var_5 = var_6[::-1]\n if var_6 == var_5:\n var_3 += 1\nprint(var_3)\n```", "output": "FASTER 3.3232", "pair_id": "python_p03416_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 10.0089} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().rstrip().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = list(map(int, list(str(var_4))))\n if var_5[0] == var_5[4] and var_5[1] == var_5[3]:\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_4 = {}\nvar_5 = 0\nfor var_6 in range(10000, 100000):\n var_3 = list(str(var_6))\n if var_3 == list(reversed(var_3)):\n var_5 += 1\n var_4[var_6] = var_5\nvar_1, var_2 = list(map(int, input().split()))\nprint((var_4[var_2] - var_4[var_1 - 1] if var_1 > 10000 else var_4[var_2]))\n```", "output": "SLOWER 1.8906", "pair_id": "python_p03416_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 3.7079} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\nimport itertools\n\n\ndef func_2(var_4):\n return eval(\"0b\" + var_4)\n\n\ndef func_1():\n var_4 = int(sys.stdin.readline().rstrip())\n var_9 = [\n func_2(\"\".join(str(var_10) for var_10 in sys.stdin.readline().split()))\n for _ in range(var_4)\n ]\n var_8 = [\n [int(var_10) for var_10 in sys.stdin.readline().split()] for _ in range(var_4)\n ]\n var_3 = -(10**10)\n for var_6 in itertools.product(\"01\", repeat=10):\n var_6 = func_2(\"\".join(var_6))\n if var_6 == 0:\n continue\n var_7 = 0\n for var_2 in range(var_4):\n var_1 = var_9[var_2]\n var_5 = bin(var_1 & var_6).count(\"1\")\n var_7 += var_8[var_2][var_5]\n var_3 = max(var_3, var_7)\n print(var_3)\n\n\nif __name__ == \"__main__\":\n\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\nimport itertools\n\n\ndef func_2(var_4):\n return bin(eval(\"0b\" + str(var_4)))\n\n\ndef func_1():\n var_4 = int(sys.stdin.readline().rstrip())\n var_9 = [\n func_2(\"\".join(str(var_10) for var_10 in sys.stdin.readline().split()))\n for _ in range(var_4)\n ]\n var_8 = [\n [int(var_10) for var_10 in sys.stdin.readline().split()] for _ in range(var_4)\n ]\n var_3 = -(10**10)\n for var_6 in itertools.product(\"01\", repeat=10):\n var_6 = func_2(\"\".join(var_6))\n if var_6 == \"0b0\":\n continue\n var_7 = 0\n for var_2 in range(var_4):\n var_1 = var_9[var_2]\n var_5 = bin(eval(var_1) & eval(var_6)).count(\"1\")\n var_7 += var_8[var_2][var_5]\n var_3 = max(var_3, var_7)\n print(var_3)\n\n\nif __name__ == \"__main__\":\n\n func_1()\n```", "output": "SLOWER 2.1735", "pair_id": "python_p03503_reversed", "problem_id": "p03503", "language": "python", "direction": "reversed", "speedup_ratio": 4.5112} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\n\"\"\"\"\"\"\n\nfrom collections import deque\n\n\ndef func_1():\n var_5, *var_1 = list(map(int, open(0).read().split()))\n var_2 = var_1[1::2]\n var_4 = [[] for _ in range(var_5 + 1)]\n for var_7, var_8 in zip(*[iter(var_1)] * 2):\n var_4[var_7] += (var_8,)\n var_6 = deque([1])\n var_3 = [0] * (var_5 + 1)\n while var_6:\n var_11 = var_6.popleft()\n var_9 = 0\n for var_10 in var_4[var_11]:\n var_9 += 1 + (var_9 + 1 == var_3[var_11])\n var_3[var_10] = var_9\n var_6 += (var_10,)\n print((max(var_3)))\n for var_8 in var_2:\n print((var_3[var_8]))\n\n\nfunc_1()\n```\n\n=== Code B (Modified) ===\n```python\nimport copy\n\nvar_8 = int(eval(input()))\nvar_10 = set([var_6 for var_6 in range(1, 10**5)])\nvar_5 = []\nvar_11 = {}\nvar_9 = []\nfor var_6 in range(var_8 - 1):\n var_1, var_2 = list(map(int, input().split(\" \")))\n var_5.append([var_1, var_2])\n var_11.setdefault(var_1, []).append(var_2)\n var_9.append([])\nvar_9.append([])\nvar_9.append([])\nvar_7 = 0\nfor var_12 in range(1, var_8 + 1):\n var_14 = var_11.get(var_12, [])\n var_3 = 1\n for var_13 in var_14:\n if var_3 in var_9[var_12]:\n var_3 += 1\n else:\n pass\n var_9[var_13].append(var_3)\n if var_3 >= var_7:\n var_7 = var_3\n var_3 += 1\nprint(var_7)\nfor var_4 in var_5:\n print((var_9[var_4[1]][0]))\n```", "output": "SLOWER 4.6116", "pair_id": "python_p02850_reversed", "problem_id": "p02850", "language": "python", "direction": "reversed", "speedup_ratio": 24.4475} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_4 = int(eval(input()))\nvar_2 = list(map(int, input().split()))\n\n\ndef func_1(var_1, var_8, var_3):\n if var_8 == var_4:\n var_9 = 1\n for var_5 in var_3:\n var_9 *= var_5\n return 1 if var_9 % 2 == 0 else 0\n var_6 = var_3.copy()\n var_6.append(var_1[var_8] - 1)\n var_5 = var_3.copy()\n var_5.append(var_1[var_8])\n var_7 = var_3.copy()\n var_7.append(var_1[var_8] + 1)\n return (\n func_1(var_1, var_8 + 1, var_6)\n + func_1(var_1, var_8 + 1, var_5)\n + func_1(var_1, var_8 + 1, var_7)\n )\n\n\nprint((func_1(var_2, 0, [])))\n```\n\n=== Code B (Modified) ===\n```python\nvar_4 = int(eval(input()))\nvar_1 = list(map(int, input().split()))\nvar_3 = 1\nfor var_2 in var_1:\n var_3 *= 2 if var_2 % 2 == 0 else 1\nprint((3**var_4 - var_3))\n```", "output": "FASTER 8.4066", "pair_id": "python_p03568_forward", "problem_id": "p03568", "language": "python", "direction": "forward", "speedup_ratio": 339.3399} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_4, var_3 = list(map(int, input().split()))\nvar_1 = 0\nfor var_2 in range(var_4, var_3 + 1):\n if str(var_2)[0] + str(var_2)[1] == str(var_2)[-1] + str(var_2)[-2]:\n var_1 += 1\nprint(var_1)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\n\n\ndef func_1(var_5, var_6):\n var_4 = 0\n for var_3 in range(var_5, var_6 + 1):\n if str(var_3) == str(var_3)[::-1]:\n var_4 += 1\n return var_4\n\n\nprint((func_1(var_1, var_2)))\n```", "output": "FASTER 1.6647", "pair_id": "python_p03416_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 3.1705} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1 = lambda: list(map(int, input().split()))\nvar_6 = int(eval(input()))\nif var_6 % 3:\n var_3 = \"YNeos\"[any(var_1()) :: 2]\nelse:\n var_2 = sorted(var_1())\n var_5 = var_6 // 3\n if var_2[0] ^ var_2[var_5] ^ var_2[2 * var_5]:\n var_3 = \"No\"\n elif any(\n len(set(var_2[var_4 : var_4 + var_5])) > 1 for var_4 in range(0, var_6, var_5)\n ):\n var_3 = \"No\"\n else:\n var_3 = \"Yes\"\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_3, var_1 = int(eval(input())), 0\nfor var_2 in list(map(int, input().split())):\n var_1 ^= var_2\nprint((\"Yes\" if var_1 == 0 else \"No\"))\n```", "output": "FASTER 1.2261", "pair_id": "python_p02975_forward", "problem_id": "p02975", "language": "python", "direction": "forward", "speedup_ratio": 2.3393} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_11 = int(eval(input()))\nvar_12 = {var_8: [] for var_8 in range(1, var_11 + 1)}\nvar_19 = [False for var_8 in range(var_11 + 1)]\nvar_16 = []\nfor _ in range(var_11 - 1):\n var_2, var_3 = list(map(int, input().split()))\n var_12[var_2].append(var_3)\n var_12[var_3].append(var_2)\n var_16.append((var_2, var_3))\nvar_9 = var_16[0][0]\nvar_19[var_9] = True\nvar_6 = []\nvar_7 = []\nvar_14 = {var_8: {} for var_8 in range(1, var_11 + 1)}\nvar_10 = [0 for var_8 in range(var_11 + 1)]\n\nvar_4 = 1\nfor var_5 in var_12[var_9]:\n var_19[var_5] = True\n var_14[var_9][var_5] = var_4\n var_14[var_5][var_9] = var_4\n var_10[var_5] = var_4\n var_4 += 1\n var_6.append(var_5)\nwhile var_6:\n for var_15 in var_6:\n var_13 = 1\n for var_5 in var_12[var_15]:\n if var_19[var_5] == False:\n var_19[var_5] = True\n if var_13 != var_10[var_15]:\n var_14[var_15][var_5] = var_13\n var_14[var_5][var_15] = var_13\n var_10[var_5] = var_13\n var_13 += 1\n var_7.append(var_5)\n else:\n var_13 += 1\n var_14[var_15][var_5] = var_13\n var_14[var_5][var_15] = var_13\n var_10[var_5] = var_13\n var_13 += 1\n var_7.append(var_5)\n if var_7:\n var_6 = var_7\n var_7 = []\n else:\n var_6 = []\n var_7 = []\nvar_1 = 0\nfor var_8 in range(1, var_11 + 1):\n var_1 = max(var_1, len(var_12[var_8]))\nprint(var_1)\nfor var_8 in range(var_11 - 1):\n var_17, var_18 = var_16[var_8][0], var_16[var_8][1]\n print((var_14[var_17][var_18]))\n```\n\n=== Code B (Modified) ===\n```python\n\"\"\"\"\"\"\n\nfrom collections import deque\n\n\ndef func_1():\n var_5, *var_1 = list(map(int, open(0).read().split()))\n var_2 = var_1[1::2]\n var_4 = [[] for _ in range(var_5 + 1)]\n for var_7, var_8 in zip(*[iter(var_1)] * 2):\n var_4[var_7].append(var_8)\n var_6 = deque([1])\n var_3 = [0] * (var_5 + 1)\n while var_6:\n var_11 = var_6.popleft()\n var_9 = 0\n for var_10 in var_4[var_11]:\n var_9 += 1 + (var_9 + 1 == var_3[var_11])\n var_3[var_10] = var_9\n var_6.append(var_10)\n print((max(var_3)))\n for var_8 in var_2:\n print((var_3[var_8]))\n\n\nfunc_1()\n```", "output": "FASTER 1.0109", "pair_id": "python_p02850_forward", "problem_id": "p02850", "language": "python", "direction": "forward", "speedup_ratio": 2.0151} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\n\nvar_20 = sys.stdin.read\nvar_21 = sys.stdin.readline\nvar_22 = sys.stdin.readlines\nsys.setrecursionlimit(10**9)\nvar_2 = 1 << 60\nvar_5 = 1000000007\n\n\nvar_4 = 1000001\n\n\nclass Class_1:\n def __init__(self, var_13, var_19, var_12):\n self.l = var_13\n self.r = var_19\n self.idx = var_12\n\n\ndef func_4(var_12, var_24, var_10, var_15):\n while var_12 <= var_15:\n var_10[var_12] += var_24\n var_12 += var_12 & -var_12\n\n\ndef func_3(var_12, var_10, var_15):\n var_23 = 0\n while var_12:\n var_23 += var_10[var_12]\n var_12 -= var_12 & -var_12\n return var_23\n\n\ndef func_1(var_9, var_15, var_17, var_16):\n\n var_10 = [0] * (var_15 + 1)\n\n var_14 = [-1] * var_4\n\n var_8 = [0] * var_16\n var_18 = 0\n for var_11 in range(var_15):\n\n if var_14[var_9[var_11]] != -1:\n func_4(var_14[var_9[var_11]] + 1, -1, var_10, var_15)\n\n var_14[var_9[var_11]] = var_11\n func_4(var_11 + 1, 1, var_10, var_15)\n\n while var_18 < var_16 and var_17[var_18].r == var_11:\n var_8[var_17[var_18].idx] = func_3(\n var_17[var_18].r + 1, var_10, var_15\n ) - func_3(var_17[var_18].l, var_10, var_15)\n var_18 += 1\n\n for var_11 in range(var_16):\n print((var_8[var_11]))\n\n\ndef func_2():\n var_6, var_7 = list(map(int, var_21().split()))\n var_1 = list(map(int, var_21().split()))\n (*var_3,) = list(map(int, var_20().split()))\n var_17 = [0] * var_7\n for var_11, (var_13, var_19) in enumerate(zip(*[iter(var_3)] * 2)):\n var_17[var_11] = Class_1(var_13 - 1, var_19 - 1, var_11)\n var_17.sort(key=lambda var_25: var_25.r)\n func_1(var_1, var_6, var_17, var_7)\n return\n\n\nif __name__ == \"__main__\":\n func_2()\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\n\n\ndef func_6():\n return sys.stdin.readline()[:-1]\n\n\ndef func_2():\n return int(eval(func_6()))\n\n\ndef func_3():\n return list(map(int, func_6().split()))\n\n\ndef func_1():\n return list(func_3())\n\n\nvar_10, var_11 = func_3()\nvar_5 = [0] + func_1()\nvar_3 = [func_1() + [var_6] for var_6 in range(var_11)]\nvar_3.sort(key=lambda var_15: var_15[1])\nvar_4 = [0] * (var_11)\nvar_9 = [0 for var_6 in range(var_10 + 1)]\nvar_2 = 2\nwhile var_2 <= var_10:\n var_2 *= 2\nvar_1 = [0] * (var_2 + 1)\n\n\ndef func_4(var_6, var_15):\n while var_6 <= var_2:\n var_1[var_6] += var_15\n var_6 += var_6 & -var_6\n\n\ndef func_5(var_6):\n var_13 = 0\n while var_6:\n var_13 += var_1[var_6]\n var_6 -= var_6 & -var_6\n return var_13\n\n\ndef func_7(var_8, var_12):\n return func_5(var_12) - func_5(var_8 - 1)\n\n\nvar_7 = 1\nfor var_8, var_12, var_6 in var_3:\n while var_7 <= var_12:\n var_14 = var_5[var_7]\n if var_9[var_14]:\n func_4(var_9[var_14], -1)\n func_4(var_7, 1)\n var_9[var_14] = var_7\n var_7 += 1\n var_4[var_6] = func_7(var_8, var_12)\nfor var_6 in var_4:\n print(var_6)\n```", "output": "FASTER 2.4053", "pair_id": "python_p02599_forward", "problem_id": "p02599", "language": "python", "direction": "forward", "speedup_ratio": 5.2974} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_5 in range(10):\n for var_6 in range(10):\n for var_7 in range(10):\n var_3 = 10000 * var_5 + 1000 * var_6 + 100 * var_7 + 10 * var_6 + var_5\n if var_1 <= var_3 <= var_2:\n var_4 += 1\nprint(var_4)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = [\n var_3 for var_3 in map(str, list(range(var_1, var_2 + 1))) if var_3 == var_3[::-1]\n]\nprint((len(var_4)))\n```", "output": "SLOWER 3.127", "pair_id": "python_p03416_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 8.7361} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\n\n\ndef func_1(var_5):\n var_4 = 0\n for var_3 in range(1, var_5 + 1):\n if str(var_3) == str(var_3)[::-1]:\n var_4 += 1\n return var_4\n\n\nprint((func_1(var_2) - func_1(var_1 - 1)))\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_5 in range(var_1, var_2 + 1):\n var_3 = str(var_5)\n if var_3[0] == var_3[-1] and var_3[1] == var_3[-2]:\n var_4 += 1\nprint(var_4)\n```", "output": "FASTER 1.6822", "pair_id": "python_p03416_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 3.2092} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_3 = list(map(int, input().split()))\nvar_2 = 0\nfor var_5 in range(var_3 + 1)[var_1:]:\n if len(str(var_5)) % 2 == 0:\n var_6 = list(str(var_5))[: len(str(var_5)) // 2]\n var_7 = list(reversed(list(str(var_5))[len(str(var_5)) // 2 :]))\n if var_6 == var_7:\n var_2 += 1\n else:\n var_8 = list(str(var_5))[: len(str(var_5)) // 2 + 1]\n var_4 = list(reversed(list(str(var_5))[len(str(var_5)) // 2 :]))\n if var_8 == var_4:\n var_2 += 1\nprint(var_2)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = input().split()\nvar_1 = int(var_1)\nvar_2 = int(var_2)\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = list(str(var_4))\n if (var_5[0] == var_5[4]) and (var_5[1] == var_5[3]):\n var_3 = var_3 + 1\nprint(var_3)\n```", "output": "FASTER 2.0702", "pair_id": "python_p03416_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 4.1995} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_3 = list(map(int, input().split()))\nvar_2 = 0\nfor var_5 in range(var_3 + 1)[var_1:]:\n if len(str(var_5)) % 2 == 0:\n var_6 = list(str(var_5))[: len(str(var_5)) // 2]\n var_7 = list(reversed(list(str(var_5))[len(str(var_5)) // 2 :]))\n if var_6 == var_7:\n var_2 += 1\n else:\n var_8 = list(str(var_5))[: len(str(var_5)) // 2 + 1]\n var_4 = list(reversed(list(str(var_5))[len(str(var_5)) // 2 :]))\n if var_8 == var_4:\n var_2 += 1\nprint(var_2)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\n\n\ndef func_1(var_5, var_6):\n var_4 = 0\n for var_3 in range(var_5, var_6 + 1):\n if str(var_3) == str(var_3)[::-1]:\n var_4 += 1\n return var_4\n\n\nprint((func_1(var_1, var_2)))\n```", "output": "FASTER 2.7982", "pair_id": "python_p03416_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 6.9556} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport copy\n\nvar_8 = int(eval(input()))\nvar_10 = set([var_6 for var_6 in range(1, 10**5)])\nvar_5 = []\nvar_11 = {}\nvar_9 = []\nfor var_6 in range(var_8 - 1):\n var_1, var_2 = list(map(int, input().split(\" \")))\n var_5.append([var_1, var_2])\n var_11.setdefault(var_1, []).append(var_2)\n var_9.append([])\nvar_9.append([])\nvar_9.append([])\nvar_7 = 0\nfor var_12 in range(1, var_8 + 1):\n var_14 = var_11.get(var_12, [])\n var_3 = 1\n for var_13 in var_14:\n if var_3 in var_9[var_12]:\n var_3 += 1\n else:\n pass\n var_9[var_13].append(var_3)\n if var_3 >= var_7:\n var_7 = var_3\n var_3 += 1\nprint(var_7)\nfor var_4 in var_5:\n print((var_9[var_4[1]][0]))\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\n\nvar_12 = sys.stdin.readline\nvar_2 = int(eval(var_12()))\nvar_9 = [[] for _ in range(var_2)]\nvar_1 = {}\nfor var_10 in range(var_2 - 1):\n var_4, var_6 = list(map(int, var_12().split()))\n var_9[var_4 - 1].append(var_6 - 1)\n var_9[var_6 - 1].append(var_4 - 1)\n var_1[(var_4 - 1) * var_2 + var_6 - 1] = var_10\n var_1[(var_6 - 1) * var_2 + var_4 - 1] = var_10\nvar_15 = [0]\nvar_8 = [False] * var_2\nvar_8[0] = True\nvar_3 = [None] * var_2\nvar_3[0] = 0\nvar_5 = [None] * (var_2 - 1)\nwhile var_15:\n var_16 = []\n for var_14 in var_15:\n var_7 = var_3[var_14]\n var_17 = 1\n for var_13 in var_9[var_14]:\n if not var_8[var_13]:\n var_8[var_13] = True\n var_16.append(var_13)\n var_11 = var_1[var_14 * var_2 + var_13]\n if var_17 == var_7:\n var_17 += 1\n var_5[var_11] = var_17\n var_3[var_13] = var_17\n var_17 += 1\n var_15 = var_16\nprint((max(var_5)))\nfor var_4 in var_5:\n print(var_4)\n```", "output": "FASTER 4.2702", "pair_id": "python_p02850_forward", "problem_id": "p02850", "language": "python", "direction": "forward", "speedup_ratio": 19.2961} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_2, var_3, *var_1 = list(map(int, open(0).read().split()))\nvar_4 = [0] * (var_3 + max(var_1[::2]))\nfor var_7, var_6 in sorted(zip(*[iter(var_1)] * 2)):\n for var_5 in reversed(list(range(var_3))):\n var_4[var_5 + var_7] = max(var_4[var_5 + var_7], var_4[var_5] + var_6)\nprint((max(var_4)))\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_6 = sorted([list(map(int, input().split())) for var_5 in range(var_1)])\n\nvar_4 = [[0] * (var_2 + 1) for var_5 in range(var_1 + 1)]\n\nfor var_5 in range(var_1):\n var_9, var_8 = var_6[var_5]\n for var_7 in range(var_2 + 1):\n if var_7 + var_9 <= var_2:\n var_4[var_5 + 1][var_7 + var_9] = max(\n var_4[var_5 + 1][var_7 + var_9], var_4[var_5][var_7] + var_8\n )\n var_4[var_5 + 1][var_7] = max(var_4[var_5][var_7], var_4[var_5 + 1][var_7])\nvar_3 = 0\nfor var_5, (var_9, var_8) in enumerate(var_6):\n for var_7 in range(var_2):\n var_3 = max(var_3, var_4[var_5][var_7] + var_8)\nprint(var_3)\n```", "output": "SLOWER 1.3487", "pair_id": "python_p02863_reversed", "problem_id": "p02863", "language": "python", "direction": "reversed", "speedup_ratio": 2.5469} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_4 = str(var_4)\n if var_4 == var_4[::-1]:\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_5 in range(10):\n for var_6 in range(10):\n for var_7 in range(10):\n var_3 = 10000 * var_5 + 1000 * var_6 + 100 * var_7 + 10 * var_6 + var_5\n if var_1 <= var_3 <= var_2:\n var_4 += 1\nprint(var_4)\n```", "output": "FASTER 3.9726", "pair_id": "python_p03416_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 15.6985} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport copy\n\nvar_8 = int(eval(input()))\nvar_10 = set([var_6 for var_6 in range(1, 10**5)])\nvar_5 = []\nvar_11 = {}\nvar_9 = []\nfor var_6 in range(var_8 - 1):\n var_1, var_2 = list(map(int, input().split(\" \")))\n var_5.append([var_1, var_2])\n var_11.setdefault(var_1, []).append(var_2)\n var_9.append([])\nvar_9.append([])\nvar_9.append([])\nvar_7 = 0\nfor var_12 in range(1, var_8 + 1):\n var_14 = var_11.get(var_12, [])\n var_3 = 1\n for var_13 in var_14:\n if var_3 in var_9[var_12]:\n var_3 += 1\n else:\n pass\n var_9[var_13].append(var_3)\n if var_3 >= var_7:\n var_7 = var_3\n var_3 += 1\nprint(var_7)\nfor var_4 in var_5:\n print((var_9[var_4[1]][0]))\n```\n\n=== Code B (Modified) ===\n```python\n\"\"\"\"\"\"\n\nfrom collections import deque\n\n\ndef func_1():\n var_5, *var_1 = list(map(int, open(0).read().split()))\n var_2 = var_1[1::2]\n var_4 = [[] for _ in range(var_5 + 1)]\n for var_7, var_8 in zip(*[iter(var_1)] * 2):\n var_4[var_7] += (var_8,)\n var_6 = deque([1])\n var_3 = [0] * (var_5 + 1)\n while var_6:\n var_11 = var_6.popleft()\n var_9 = 0\n for var_10 in var_4[var_11]:\n var_9 += 1 + (var_9 + 1 == var_3[var_11])\n var_3[var_10] = var_9\n var_6 += (var_10,)\n print((max(var_3)))\n for var_8 in var_2:\n print((var_3[var_8]))\n\n\nfunc_1()\n```", "output": "FASTER 4.6116", "pair_id": "python_p02850_forward", "problem_id": "p02850", "language": "python", "direction": "forward", "speedup_ratio": 24.4475} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\nfrom operator import itemgetter\nfrom heapq import heapify, heappop, heappush\n\nvar_1 = int(10e15)\nvar_2 = -var_1\nvar_11 = 1000000007\nsys.setrecursionlimit(1000000)\n\n\ndef func_2():\n return list(map(int, input().split()))\n\n\ndef func_4():\n return input().split()\n\n\ndef func_1():\n return int(sys.stdin.readline())\n\n\ndef func_3():\n return eval(input())\n\n\nvar_3, var_4 = func_2()\nvar_5 = [func_2() for var_9 in range(var_3)]\nvar_5.sort(key=itemgetter(0))\n\nvar_8 = [[0] * (var_4 + 1 + 3000 + 1) for _ in range(var_3 + 1)]\nvar_6 = 0\nfor var_9 in range(var_3):\n for var_10 in range(var_4 + 1 + 3000 + 1):\n var_12, var_7 = var_5[var_9]\n if 0 <= var_10 - var_12 < var_4:\n var_8[var_9 + 1][var_10] = max(\n var_8[var_9][var_10], var_8[var_9][var_10 - var_12] + var_7\n )\n else:\n var_8[var_9 + 1][var_10] = var_8[var_9][var_10]\n var_6 = max(var_6, var_8[var_9 + 1][var_10])\nprint(var_6)\n```\n\n=== Code B (Modified) ===\n```python\nimport bisect\nimport sys\n\nsys.setrecursionlimit(10**6)\nvar_16 = sys.stdout.write\nvar_7 = lambda *var_14: print(*var_14) if var_1 else 0\nvar_1 = True\n\n\ndef func_1(var_9=sys.stdin.readline):\n var_11 = lambda: var_9().rstrip()\n var_3 = lambda: list(map(int, var_11().split()))\n var_2 = lambda: int(var_11())\n var_4 = lambda var_17: [var_3() for _ in range(var_17)]\n var_13, var_15 = var_3()\n var_5 = var_4(var_13)\n var_5.sort()\n var_8 = [[0] * var_15 for _ in range(var_13 + 1)]\n for var_10 in range(1, var_13 + 1):\n for var_12 in range(1, var_15):\n if var_12 < var_5[var_10 - 1][0]:\n var_8[var_10][var_12] = var_8[var_10 - 1][var_12]\n else:\n var_8[var_10][var_12] = max(\n var_8[var_10 - 1][var_12],\n var_8[var_10 - 1][var_12 - var_5[var_10 - 1][0]]\n + var_5[var_10 - 1][1],\n )\n var_6 = 0\n for var_10 in range(var_13):\n var_6 = max(var_6, var_8[var_10][var_15 - 1] + var_5[var_10][1])\n print(var_6)\n\n\nif __name__ == \"__main__\":\n func_1()\n```", "output": "FASTER 5.2198", "pair_id": "python_p02863_forward", "problem_id": "p02863", "language": "python", "direction": "forward", "speedup_ratio": 37.2652} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_5 in range(10):\n for var_6 in range(10):\n for var_7 in range(10):\n var_3 = 10000 * var_5 + 1000 * var_6 + 100 * var_7 + 10 * var_6 + var_5\n if var_1 <= var_3 <= var_2:\n var_4 += 1\nprint(var_4)\n```\n\n=== Code B (Modified) ===\n```python\nvar_4 = {}\nvar_5 = 0\nfor var_6 in range(10000, 100000):\n var_3 = list(str(var_6))\n if var_3 == list(reversed(var_3)):\n var_5 += 1\n var_4[var_6] = var_5\nvar_1, var_2 = list(map(int, input().split()))\nprint((var_4[var_2] - var_4[var_1 - 1] if var_1 > 10000 else var_4[var_2]))\n```", "output": "SLOWER 7.3992", "pair_id": "python_p03416_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 168.7989} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = input().split()\nprint((int(var_1) * int(var_2[:-3] + var_2[-2:]) // 100))\n```\n\n=== Code B (Modified) ===\n```python\ndef func_1():\n from sys import setrecursionlimit, stdin\n from os import environ\n from collections import defaultdict, deque, Counter\n from math import ceil, floor, gcd\n from itertools import accumulate, combinations, combinations_with_replacement\n\n setrecursionlimit(10**6)\n var_7 = (\n (lambda *var_11: print(*var_11))\n if \"TERM_PROGRAM\" in environ\n else lambda *var_12: 0\n )\n var_8 = lambda: stdin.readline().rstrip()\n var_3 = lambda: list(map(int, var_8().split()))\n var_1 = lambda: int(var_8())\n var_4 = 10**9 + 7\n var_2 = 10**9 + 10\n var_9, var_10 = var_8().split()\n var_5 = int(var_9)\n var_6 = int(float(var_10) * 100 + 0.5)\n print(var_5 * var_6 // 100)\n\n\nfunc_1()\n```", "output": "SLOWER 2.4305", "pair_id": "python_p02659_reversed", "problem_id": "p02659", "language": "python", "direction": "reversed", "speedup_ratio": 5.3907} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\ndef func_1():\n from sys import setrecursionlimit, stdin\n from os import environ\n from collections import defaultdict, deque, Counter\n from math import ceil, floor, gcd\n from itertools import accumulate, combinations, combinations_with_replacement\n\n setrecursionlimit(10**6)\n var_7 = (\n (lambda *var_11: print(*var_11))\n if \"TERM_PROGRAM\" in environ\n else lambda *var_12: 0\n )\n var_8 = lambda: stdin.readline().rstrip()\n var_3 = lambda: list(map(int, var_8().split()))\n var_1 = lambda: int(var_8())\n var_4 = 10**9 + 7\n var_2 = 10**9 + 10\n var_9, var_10 = var_8().split()\n var_5 = int(var_9)\n var_6 = int(float(var_10) * 100 + 0.5)\n print(var_5 * var_6 // 100)\n\n\nfunc_1()\n```\n\n=== Code B (Modified) ===\n```python\nfrom decimal import Decimal\nimport math\n\nvar_1, var_2 = list(map(str, input().split()))\nvar_1 = int(var_1)\nvar_2 = Decimal(var_2)\nvar_3 = math.floor(var_1 * var_2)\nprint((int(var_3)))\n```", "output": "FASTER 1.6812", "pair_id": "python_p02659_forward", "problem_id": "p02659", "language": "python", "direction": "forward", "speedup_ratio": 3.207} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport numpy as np\nfrom itertools import product\n\nvar_6 = int(eval(input()))\nvar_2 = list(map(int, input().split()))\nvar_2 = np.array(var_2)\nvar_5 = [-1, 0, 1]\nvar_3 = 0\nfor var_7 in product(var_5, repeat=var_6):\n var_7 = np.array(var_7)\n var_1 = var_2 + var_7\n var_4 = var_1.cumprod()\n if var_4[-1] % 2 == 0:\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\ndef func_1():\n var_2 = int(eval(input()))\n var_1 = [int(var_6) for var_6 in input().split()]\n var_4 = 3**var_2\n var_5 = len([var_3 for var_3 in var_1 if var_3 % 2 == 0])\n var_4 -= 2**var_5\n print(var_4)\n\n\nif __name__ == \"__main__\":\n func_1()\n```", "output": "FASTER 9.5157", "pair_id": "python_p03568_forward", "problem_id": "p03568", "language": "python", "direction": "forward", "speedup_ratio": 732.014} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nfrom sys import stdin\n\n\ndef func_1():\n\n var_13 = stdin.readline\n var_2 = int(var_13())\n var_1 = []\n for var_6 in range(var_2):\n var_5 = list(map(int, var_13().split()))\n var_1.append(var_5)\n var_3 = []\n for var_6 in range(var_2):\n var_12 = list(map(int, var_13().split()))\n var_3.append(var_12)\n var_9 = -float(\"inf\")\n for var_6 in range(1 << 10):\n if var_6 == 0:\n continue\n else:\n var_11 = []\n for var_7 in range(10):\n if (var_6 >> var_7) & 1:\n var_11.append(var_7)\n var_10 = [0] * 10\n for var_7 in var_11:\n var_10[var_7] = 1\n var_14 = 0\n for var_7 in range(var_2):\n var_4 = 0\n for var_8 in range(10):\n if var_10[var_8] == 1 and var_1[var_7][var_8] == 1:\n var_4 += 1\n var_14 += var_3[var_7][var_4]\n var_9 = max(var_14, var_9)\n print(var_9)\n\n\nif __name__ == \"__main__\":\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nvar_5 = 0\nif var_5 == 0:\n var_8 = int(eval(input()))\n var_2 = []\n for var_4 in range(var_8):\n var_3 = list(map(int, input().split()))\n var_2.append(var_3)\n var_9 = []\n for var_4 in range(var_8):\n var_10 = list(map(int, input().split()))\n var_9.append(var_10)\nelif var_5 == 1:\n var_8 = 1\n var_2 = [[1, 1, 0, 1, 0, 0, 0, 1, 0, 1]]\n var_9 = [[3, 4, 5, 6, 7, 8, 9, -2, -3, 4, -2]]\nelif var_5 == 2:\n var_8 = 2\n var_2 = [[1, 1, 1, 1, 1, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 1, 1, 1, 1, 1]]\n var_9 = [\n [0, -2, -2, -2, -2, -2, -1, -1, -1, -1, -1],\n [0, -2, -2, -2, -2, -2, -1, -1, -1, -1, -1],\n ]\nelif var_5 == 3:\n var_8 = 3\n var_2 = [\n [1, 1, 1, 1, 1, 1, 0, 0, 1, 1],\n [0, 1, 0, 1, 1, 1, 1, 0, 1, 0],\n [1, 0, 1, 1, 0, 1, 0, 1, 0, 1],\n ]\n var_9 = [\n [-8, 6, -2, -8, -8, 4, 8, 7, -6, 2, 2],\n [-9, 2, 0, 1, 7, -5, 0, -2, -6, 5, 5],\n [6, -6, 7, -9, 6, -5, 8, 0, -9, -7, -7],\n ]\nimport itertools\n\nvar_13 = -(10**11)\nfor var_4 in itertools.product([0, 1], repeat=10):\n var_11 = list(var_4)\n var_12 = 0\n if sum(var_11) != 0:\n for var_7 in range(var_8):\n var_1 = 0\n for var_6 in range(10):\n var_1 = var_1 + var_11[var_6] * var_2[var_7][var_6]\n var_12 = var_12 + var_9[var_7][var_1]\n\n var_13 = max(var_12, var_13)\nprint(var_13)\n```", "output": "SLOWER 1.1878", "pair_id": "python_p03503_reversed", "problem_id": "p03503", "language": "python", "direction": "reversed", "speedup_ratio": 2.2781} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\ndef func_1():\n var_1, var_2 = list(map(int, input().split()))\n var_3 = 0\n for var_4 in range(var_1, var_2 + 1):\n\n if (var_4 % 10) == (var_4 // 10000 % 10) and (var_4 // 10 % 10) == (\n var_4 // 1000 % 10\n ):\n var_3 += 1\n print(var_3)\n\n\nif __name__ == \"__main__\":\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_8 in range(var_1, var_2 + 1):\n var_7 = str(var_8)\n var_6 = len(var_7)\n var_4 = True\n for var_5 in range(var_6 // 2):\n if var_7[var_5] != var_7[var_6 - 1 - var_5]:\n var_4 = False\n break\n if var_4:\n var_3 += 1\nprint(var_3)\n```", "output": "SLOWER 2.7903", "pair_id": "python_p03416_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 6.9176} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_4, var_3 = list(map(int, input().split()))\nvar_1 = [0] * var_4\nfor var_2 in range(var_3):\n var_5, var_6 = list(map(int, input().split()))\n var_1[var_5 - 1] += 1\n var_1[var_6 - 1] += 1\nfor var_2 in range(var_4):\n print((var_1[var_2]))\n```\n\n=== Code B (Modified) ===\n```python\nvar_3, var_2 = map(int, input().split())\nvar_4 = [0] * var_3\n[\n exec(\n \"roads[%d] += 1; roads[%d] += 1\"\n % tuple(map(lambda var_1: int(var_1) - 1, input().split()))\n )\n for _ in range(var_2)\n]\nprint(*var_4, sep=\"\\n\", end=\"\")\n```", "output": "SLOWER 1.1067", "pair_id": "python_p03720_reversed", "problem_id": "p03720", "language": "python", "direction": "reversed", "speedup_ratio": 2.1535} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_2, var_1 = list(map(int, input().split()))\nvar_7 = []\nfor var_6 in range(var_1):\n var_3, var_5 = list(map(int, input().split()))\n var_7.append([var_5, var_3])\n\nvar_7.sort()\nvar_4 = 1\nvar_9, var_8 = var_7[0]\nfor var_6 in range(1, var_1):\n var_5, var_3 = var_7[var_6]\n if var_9 <= var_3:\n var_9 = var_5\n var_4 += 1\nprint(var_4)\n```\n\n=== Code B (Modified) ===\n```python\nvar_2, var_1 = [int(var_12) for var_12 in input().split()]\nvar_3 = []\nfor var_8 in range(var_1):\n var_5, var_6 = [int(var_12) for var_12 in input().split()]\n var_3.append((var_5, var_6))\nvar_3.sort()\nvar_9 = float(\"inf\")\nvar_4 = [var_9 for var_5 in range(var_2 + 1)]\nfor var_5, var_6 in var_3:\n var_4[var_5] = min(var_4[var_5], var_6)\nvar_3 = [\n (var_5, var_4[var_5]) for var_5 in range(1, var_2 + 1) if var_4[var_5] != var_9\n]\nvar_3.sort(key=lambda var_11: var_11[1])\nvar_7 = [True] * (var_2)\nvar_10 = None\nfor var_5, var_6 in var_3:\n if var_10 == None or var_10 < var_5:\n var_7[var_6 - 1] = False\n var_10 = var_6 - 1\nprint((sum(1 for var_6 in var_7 if not var_6)))\n```", "output": "SLOWER 1.0817", "pair_id": "python_p03295_reversed", "problem_id": "p03295", "language": "python", "direction": "reversed", "speedup_ratio": 2.1165} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\n_, var_1 = open(0)\nvar_1, *var_2 = list(map(int, var_1.split()))\nfor var_2 in var_2:\n var_1 ^= var_2\nprint((\"YNeos\"[var_1 > 0 :: 2]))\n```\n\n=== Code B (Modified) ===\n```python\ndef func_1():\n from collections import Counter\n\n var_4 = int(eval(input()))\n (*var_1,) = list(map(int, input().split()))\n if var_4 % 3 == 0:\n var_2 = Counter(var_1)\n if len(var_2) == 1:\n print((\"Yes\" if 0 in var_2 else \"No\"))\n return\n elif len(var_2) == 2:\n print((\"Yes\" if var_2[0] == var_4 // 3 else \"No\"))\n return\n elif len(var_2) == 3:\n var_7 = 0\n var_5 = None\n for var_3, var_6 in list(var_2.items()):\n if var_5 is None:\n var_5 = var_6\n elif var_5 != var_6:\n print(\"No\")\n return\n var_7 ^= var_3\n print((\"Yes\" if var_7 == 0 else \"No\"))\n return\n else:\n print(\"No\")\n return\n else:\n print((\"Yes\" if all([var_7 == 0 for var_7 in var_1]) else \"No\"))\n return\n\n\nif __name__ == \"__main__\":\n func_1()\n```", "output": "SLOWER 1.5263", "pair_id": "python_p02975_reversed", "problem_id": "p02975", "language": "python", "direction": "reversed", "speedup_ratio": 2.8805} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().strip().split(\" \")))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n if str(var_4) == str(var_4)[::-1]:\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_6 in range(var_1, var_2 + 1):\n var_3 = str(var_6)\n var_5 = True\n for var_7 in range(len(var_3) // 2):\n if var_3[var_7] != var_3[-var_7 - 1] and var_5:\n var_5 = not var_5\n if var_5:\n var_4 += 1\nprint(var_4)\n```", "output": "SLOWER 1.1527", "pair_id": "python_p03416_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 2.2233} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = [\n var_3 for var_3 in map(str, list(range(var_1, var_2 + 1))) if var_3 == var_3[::-1]\n]\nprint((len(var_4)))\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = input().split()\nvar_1 = int(var_1)\nvar_2 = int(var_2)\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = list(str(var_4))\n if (var_5[0] == var_5[4]) and (var_5[1] == var_5[3]):\n var_3 = var_3 + 1\nprint(var_3)\n```", "output": "SLOWER 1.1029", "pair_id": "python_p03416_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 2.1478} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_4 = str(var_4)\n if var_4[0] == var_4[-1] and var_4[1] == var_4[-2]:\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = list(str(var_4))\n if var_5 == list(reversed(var_5)):\n var_3 += 1\nprint(var_3)\n```", "output": "SLOWER 1.4159", "pair_id": "python_p03416_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 2.6682} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = list(str(var_4))\n if var_5 == list(reversed(var_5)):\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = [\n var_3 for var_3 in map(str, list(range(var_1, var_2 + 1))) if var_3 == var_3[::-1]\n]\nprint((len(var_4)))\n```", "output": "FASTER 1.9307", "pair_id": "python_p03416_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 3.8125} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_5 = 0\nif var_5 == 0:\n var_8 = int(eval(input()))\n var_2 = []\n for var_4 in range(var_8):\n var_3 = list(map(int, input().split()))\n var_2.append(var_3)\n var_9 = []\n for var_4 in range(var_8):\n var_10 = list(map(int, input().split()))\n var_9.append(var_10)\nelif var_5 == 1:\n var_8 = 1\n var_2 = [[1, 1, 0, 1, 0, 0, 0, 1, 0, 1]]\n var_9 = [[3, 4, 5, 6, 7, 8, 9, -2, -3, 4, -2]]\nelif var_5 == 2:\n var_8 = 2\n var_2 = [[1, 1, 1, 1, 1, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 1, 1, 1, 1, 1]]\n var_9 = [\n [0, -2, -2, -2, -2, -2, -1, -1, -1, -1, -1],\n [0, -2, -2, -2, -2, -2, -1, -1, -1, -1, -1],\n ]\nelif var_5 == 3:\n var_8 = 3\n var_2 = [\n [1, 1, 1, 1, 1, 1, 0, 0, 1, 1],\n [0, 1, 0, 1, 1, 1, 1, 0, 1, 0],\n [1, 0, 1, 1, 0, 1, 0, 1, 0, 1],\n ]\n var_9 = [\n [-8, 6, -2, -8, -8, 4, 8, 7, -6, 2, 2],\n [-9, 2, 0, 1, 7, -5, 0, -2, -6, 5, 5],\n [6, -6, 7, -9, 6, -5, 8, 0, -9, -7, -7],\n ]\nimport itertools\n\nvar_13 = -(10**11)\nfor var_4 in itertools.product([0, 1], repeat=10):\n var_11 = list(var_4)\n var_12 = 0\n if sum(var_11) != 0:\n for var_7 in range(var_8):\n var_1 = 0\n for var_6 in range(10):\n var_1 = var_1 + var_11[var_6] * var_2[var_7][var_6]\n var_12 = var_12 + var_9[var_7][var_1]\n\n var_13 = max(var_12, var_13)\nprint(var_13)\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\n\nvar_8 = sys.stdin.readline\n\n\ndef func_1():\n var_2 = int(eval(var_8()))\n var_1 = [int(var_8().replace(\" \", \"\"), 2) for _ in range(var_2)]\n var_3 = [list(map(int, var_8().split())) for _ in range(var_2)]\n var_4 = -(10**7) * var_2\n for var_7 in range(1, 1 << 10):\n var_10 = 0\n for var_9, var_6 in enumerate(var_1):\n var_5 = bin(var_7 & var_6).count(\"1\")\n var_10 += var_3[var_9][var_5]\n var_4 = max(var_4, var_10)\n print(var_4)\n\n\nif __name__ == \"__main__\":\n func_1()\n```", "output": "FASTER 3.1351", "pair_id": "python_p03503_forward", "problem_id": "p03503", "language": "python", "direction": "forward", "speedup_ratio": 8.7856} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\n\nvar_7 = sys.stdin.readline\nfrom itertools import combinations\n\n\ndef func_3(var_10):\n for _ in range(var_10):\n yield list(map(int, var_7().split()))\n\n\ndef func_1(var_9, var_5, var_11):\n var_3 = len([0 for var_8 in var_9 if var_5[var_8] == 1])\n return var_11[var_3]\n\n\ndef func_2():\n var_10 = int(eval(var_7()))\n var_1 = list(func_3(var_10))\n var_2 = list(func_3(var_10))\n for var_6 in range(1, 11):\n for var_4 in combinations(list(range(10)), var_6):\n yield sum(\n func_1(var_4, var_5, var_11) for var_5, var_11 in zip(var_1, var_2)\n )\n\n\nprint((max(func_2())))\n```\n\n=== Code B (Modified) ===\n```python\nfrom sys import stdin\n\n\ndef func_1():\n\n var_11 = stdin.readline\n var_2 = int(var_11())\n var_1 = []\n for var_6 in range(var_2):\n var_5 = int(\"\".join(var_11().strip().split(\" \")), 2)\n var_1.append(var_5)\n var_3 = []\n for var_6 in range(var_2):\n var_10 = list(map(int, var_11().split()))\n var_3.append(var_10)\n var_8 = float(\"-inf\")\n for var_9 in range(1, 1 << 10):\n var_12 = 0\n for var_7 in range(var_2):\n var_4 = bin(var_9 & var_1[var_7]).count(\"1\")\n var_12 += var_3[var_7][var_4]\n var_8 = max(var_12, var_8)\n print(var_8)\n\n\nif __name__ == \"__main__\":\n func_1()\n```", "output": "FASTER 1.2554", "pair_id": "python_p03503_forward", "problem_id": "p03503", "language": "python", "direction": "forward", "speedup_ratio": 2.3874} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nfrom sys import stdin\n\nvar_6 = lambda: list(map(int, stdin.readline().split()))\nvar_5 = lambda: list(map(int, stdin.readline().split()))\nvar_1, var_3 = var_6()\nvar_2 = 0\nfor var_4 in range(var_1, var_3 + 1):\n var_7 = str(var_4)\n if var_7 == var_7[::-1]:\n var_2 += 1\nprint(var_2)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_3 = list(map(int, input().split()))\nvar_2 = 0\nfor var_5 in range(var_3 + 1)[var_1:]:\n if len(str(var_5)) % 2 == 0:\n var_6 = list(str(var_5))[: len(str(var_5)) // 2]\n var_7 = list(reversed(list(str(var_5))[len(str(var_5)) // 2 :]))\n if var_6 == var_7:\n var_2 += 1\n else:\n var_8 = list(str(var_5))[: len(str(var_5)) // 2 + 1]\n var_4 = list(reversed(list(str(var_5))[len(str(var_5)) // 2 :]))\n if var_8 == var_4:\n var_2 += 1\nprint(var_2)\n```", "output": "SLOWER 2.4561", "pair_id": "python_p03416_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 5.4874} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\nfrom operator import itemgetter\nfrom heapq import heapify, heappop, heappush\n\nvar_1 = int(10e15)\nvar_2 = -var_1\nvar_11 = 1000000007\nsys.setrecursionlimit(1000000)\n\n\ndef func_2():\n return list(map(int, input().split()))\n\n\ndef func_4():\n return input().split()\n\n\ndef func_1():\n return int(sys.stdin.readline())\n\n\ndef func_3():\n return eval(input())\n\n\nvar_3, var_4 = func_2()\nvar_5 = [func_2() for var_9 in range(var_3)]\nvar_5.sort(key=itemgetter(0))\n\nvar_8 = [[0] * (var_4 + 1 + 3000 + 1) for _ in range(var_3 + 1)]\nvar_6 = 0\nfor var_9 in range(var_3):\n for var_10 in range(var_4 + 1 + 3000 + 1):\n var_12, var_7 = var_5[var_9]\n if 0 <= var_10 - var_12 < var_4:\n var_8[var_9 + 1][var_10] = max(\n var_8[var_9][var_10], var_8[var_9][var_10 - var_12] + var_7\n )\n else:\n var_8[var_9 + 1][var_10] = var_8[var_9][var_10]\n var_6 = max(var_6, var_8[var_9 + 1][var_10])\nprint(var_6)\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\n\nvar_10 = sys.stdin.readline\nvar_2, var_3 = list(map(int, var_10().split()))\nvar_1 = [list(map(int, var_10().split())) for _ in range(var_2)]\nvar_8 = [[0 for _ in range(var_2 + 1)] for _ in range(var_3 + 1)]\n\nvar_13 = [[0 for _ in range(var_2 + 1)] for _ in range(var_3 + 1)]\nfor var_11 in range(var_2):\n var_4, var_6 = var_1[var_11]\n for var_15 in range(var_3):\n if var_4 > var_15:\n var_8[var_15][var_11 + 1] = var_8[var_15][var_11]\n var_13[var_15][var_11 + 1] = var_15\n else:\n if var_6 + var_8[var_15 - var_4][var_11] >= var_8[var_15][var_11]:\n var_8[var_15][var_11 + 1] = var_8[var_15 - var_4][var_11] + var_6\n var_13[var_15][var_11 + 1] = var_15 - var_4\n else:\n var_8[var_15][var_11 + 1] = var_8[var_15][var_11]\n var_13[var_15][var_11 + 1] = var_15\nvar_5 = var_8[var_3 - 1][var_2]\nvar_14 = [False] * var_2\nvar_7 = var_3 - 1\nfor var_9 in reversed(list(range(var_2))):\n if var_13[var_7][var_9 + 1] == var_7 - var_1[var_9][0]:\n var_14[var_9] = True\n var_7 = var_13[var_7][var_9 + 1]\nvar_12 = 0\nfor var_9 in range(var_2):\n if not var_14[var_9] and var_1[var_9][1] > var_12:\n var_12 = var_1[var_9][1]\nprint((var_5 + var_12))\n```", "output": "FASTER 4.3309", "pair_id": "python_p02863_forward", "problem_id": "p02863", "language": "python", "direction": "forward", "speedup_ratio": 20.1241} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nfrom collections import Counter, defaultdict, deque\nfrom heapq import heappop, heappush, heapify\nimport sys, bisect, math, itertools, fractions, pprint\n\nsys.setrecursionlimit(10**8)\nvar_6 = 10**9 + 7\nvar_1 = float(\"inf\")\n\n\ndef func_1():\n return int(sys.stdin.readline())\n\n\ndef func_2():\n return list(map(int, sys.stdin.readline().split()))\n\n\nvar_8, var_11 = func_2()\nvar_17 = [func_2() for _ in range(var_8)]\nvar_10 = var_17[::-1]\nvar_14 = [[0] * var_11 for _ in range(var_8)]\nvar_3 = [[0] * var_11 for _ in range(var_8)]\nfor var_4 in range(var_8 - 1):\n var_16, var_15 = var_17[var_4]\n for var_5 in range(var_11):\n if var_5 < var_16:\n var_14[var_4 + 1][var_5] = var_14[var_4][var_5]\n else:\n var_14[var_4 + 1][var_5] = max(\n var_14[var_4][var_5], var_14[var_4][var_5 - var_16] + var_15\n )\nvar_9 = var_14[var_8 - 1][var_11 - 1] + var_17[var_8 - 1][1]\nfor var_4 in range(var_8 - 1):\n var_16, var_15 = var_10[var_4]\n for var_5 in range(var_11):\n if var_5 < var_16:\n var_3[var_4 + 1][var_5] = var_3[var_4][var_5]\n else:\n var_3[var_4 + 1][var_5] = max(\n var_3[var_4][var_5], var_3[var_4][var_5 - var_16] + var_15\n )\n var_9 = max(var_9, var_3[var_8 - 1][var_11 - 1] + var_17[0][1])\n\nfor var_4 in range(1, var_8 - 1):\n var_13 = var_4\n var_2 = var_8 - var_4 - 1\n var_7 = 0\n for var_5 in range(var_11):\n var_12 = var_14[var_13][var_5] + var_3[var_2][var_11 - 1 - var_5]\n var_7 = max(var_7, var_12)\n var_9 = max(var_9, var_7 + var_17[var_4][1])\nprint(var_9)\n```\n\n=== Code B (Modified) ===\n```python\nvar_6, var_7 = list(map(int, input().split()))\nvar_1 = [list(map(int, input().split())) for _ in range(var_6)]\nvar_1.sort()\nvar_3 = [(6007) * [0] for _ in range(var_6 + 1)]\nvar_3[0][0] = 0\nvar_2 = 0\nfor var_4 in range(var_6):\n for var_5 in range(6007):\n var_3[var_4 + 1][var_5] = max(var_3[var_4 + 1][var_5], var_3[var_4][var_5])\n if var_5 < var_7:\n var_3[var_4 + 1][var_5 + var_1[var_4][0]] = max(\n var_3[var_4][var_5] + var_1[var_4][1],\n var_3[var_4][var_5 + var_1[var_4][0]],\n )\n var_2 = max(var_2, var_3[var_4 + 1][var_5])\nprint(var_2)\n```", "output": "SLOWER 4.7197", "pair_id": "python_p02863_reversed", "problem_id": "p02863", "language": "python", "direction": "reversed", "speedup_ratio": 26.3491} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().rstrip().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = list(map(int, list(str(var_4))))\n if var_5[0] == var_5[4] and var_5[1] == var_5[3]:\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = [\n var_3 for var_3 in map(str, list(range(var_1, var_2 + 1))) if var_3 == var_3[::-1]\n]\nprint((len(var_4)))\n```", "output": "FASTER 2.3816", "pair_id": "python_p03416_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 5.2111} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\ndef func_1():\n var_2 = int(eval(input()))\n var_1 = [int(var_6) for var_6 in input().split()]\n var_4 = 3**var_2\n var_5 = len([var_3 for var_3 in var_1 if var_3 % 2 == 0])\n var_4 -= 2**var_5\n print(var_4)\n\n\nif __name__ == \"__main__\":\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nfrom functools import reduce\nfrom itertools import product\n\nvar_2 = int(eval(input()))\n(*var_1,) = list(map(int, input().split()))\nvar_4 = 0\nfor var_7 in product([-1, 0, 1], repeat=var_2):\n var_6 = reduce(\n lambda var_8, var_9: var_8 * var_9,\n [var_3 + var_7[var_5] for var_5, var_3 in enumerate(var_1)],\n )\n if var_6 % 2 == 0:\n var_4 += 1\nprint(var_4)\n```", "output": "SLOWER 9.2492", "pair_id": "python_p03568_reversed", "problem_id": "p03568", "language": "python", "direction": "reversed", "speedup_ratio": 608.5427} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_5 in range(10):\n for var_6 in range(10):\n for var_7 in range(10):\n var_3 = 10000 * var_5 + 1000 * var_6 + 100 * var_7 + 10 * var_6 + var_5\n if var_1 <= var_3 <= var_2:\n var_4 += 1\nprint(var_4)\n```\n\n=== Code B (Modified) ===\n```python\ndef func_1():\n var_1, var_2 = list(map(int, input().split()))\n var_3 = 0\n for var_4 in range(var_1, var_2 + 1):\n\n if (var_4 % 10) == (var_4 // 10000 % 10) and (var_4 // 10 % 10) == (\n var_4 // 1000 % 10\n ):\n var_3 += 1\n print(var_3)\n\n\nif __name__ == \"__main__\":\n func_1()\n```", "output": "SLOWER 2.1615", "pair_id": "python_p03416_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 4.4738} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\nimport math\nfrom collections import defaultdict\nfrom bisect import bisect_left, bisect_right\n\nsys.setrecursionlimit(10**7)\n\n\ndef func_4():\n return sys.stdin.readline()[:-1]\n\n\nvar_4 = 10**9 + 7\n\n\ndef func_1():\n return int(eval(func_4()))\n\n\ndef func_2():\n return list(map(int, func_4().split()))\n\n\ndef func_3(var_6, var_3):\n if var_6 <= 0:\n return [[] for _ in range(var_3)]\n elif var_3 == 1:\n return [func_1() for _ in range(var_6)]\n else:\n var_5 = [func_2() for _ in range(var_6)]\n return list(map(list, list(zip(*var_5))))\n\n\nfrom decimal import getcontext, Decimal\n\ngetcontext().prec = 28\nvar_1, var_2 = list(map(str, func_4().split()))\nvar_1 = int(var_1)\nvar_2 = Decimal(var_2)\nprint((int(var_1 * var_2)))\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(str, input().split()))\nvar_1 = int(var_1)\nvar_2 = int(float(var_2) * 1000)\nprint((var_1 * var_2 // 1000))\n```", "output": "FASTER 2.3054", "pair_id": "python_p02659_forward", "problem_id": "p02659", "language": "python", "direction": "forward", "speedup_ratio": 4.9432} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2, var_3 = list(map(int, input().split()))\nvar_4 = list(map(int, input().split()))\nvar_6 = list(map(int, input().split()))\nvar_5 = min(var_4) + min(var_6)\nfor var_8 in range(var_3):\n var_7 = list(map(int, input().split()))\n var_9 = var_4[var_7[0] - 1] + var_6[var_7[1] - 1] - var_7[2]\n var_5 = min(var_9, var_5)\nprint(var_5)\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\nfrom collections import Counter\n\n\ndef func_9():\n return sys.stdin.readline().strip()\n\n\ndef func_10(var_8, var_9, var_10):\n return [[var_10] * var_9 for var_13 in range(var_8)]\n\n\ndef func_11(var_8, var_9, var_10, var_11):\n return [[[var_11] * var_10 for var_14 in range(var_9)] for var_13 in range(var_8)]\n\n\ndef func_12(var_8, var_9, var_10, var_11, var_12):\n return [\n [[[var_12] * var_11 for var_14 in range(var_10)] for var_14 in range(var_9)]\n for var_13 in range(var_8)\n ]\n\n\ndef func_8(var_16, var_17=1):\n return int(-(-var_16 // var_17))\n\n\ndef func_1():\n return int(eval(func_9()))\n\n\ndef func_3():\n return list(map(int, func_9().split()))\n\n\ndef func_2(var_7=None):\n return list(func_3()) if var_7 is None else [func_1() for var_13 in range(var_7)]\n\n\ndef func_7():\n print(\"Yes\")\n\n\ndef func_5():\n print(\"No\")\n\n\ndef func_6():\n print(\"YES\")\n\n\ndef func_4():\n print(\"NO\")\n\n\nsys.setrecursionlimit(10**9)\nvar_3 = 10**18\nvar_6 = 10**9 + 7\nvar_7, var_5, var_4 = func_3()\nvar_1 = func_2()\nvar_2 = func_2()\nvar_15 = min(var_1) + min(var_2)\nfor _ in range(var_4):\n var_16, var_17, var_10 = func_3()\n var_16 -= 1\n var_17 -= 1\n var_15 = min(var_15, var_1[var_16] + var_2[var_17] - var_10)\nprint(var_15)\n```", "output": "SLOWER 1.7949", "pair_id": "python_p02748_reversed", "problem_id": "p02748", "language": "python", "direction": "reversed", "speedup_ratio": 3.47} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_7 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_3 = True\n var_8 = str(var_4)\n var_6 = len(var_8)\n for var_5 in range(var_6 // 2 + 1):\n if var_8[var_5] != var_8[-var_5 - 1]:\n var_3 = False\n break\n if var_3:\n var_7 += 1\nprint(var_7)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_5 in range(10):\n for var_6 in range(10):\n for var_7 in range(10):\n var_3 = 10000 * var_5 + 1000 * var_6 + 100 * var_7 + 10 * var_6 + var_5\n if var_1 <= var_3 <= var_2:\n var_4 += 1\nprint(var_4)\n```", "output": "FASTER 4.9507", "pair_id": "python_p03416_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 30.924} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\n\nvar_3 = sys.stdin.readline\nvar_1, var_2 = var_3().split()\nvar_1 = int(var_1)\nvar_2 = int(float(var_2) * 100 + 0.5)\nprint((var_1 * var_2 // 100))\n```\n\n=== Code B (Modified) ===\n```python\ndef func_1():\n from sys import setrecursionlimit, stdin\n from os import environ\n from collections import defaultdict, deque, Counter\n from math import ceil, floor, gcd\n from itertools import accumulate, combinations, combinations_with_replacement\n\n setrecursionlimit(10**6)\n var_7 = (\n (lambda *var_11: print(*var_11))\n if \"TERM_PROGRAM\" in environ\n else lambda *var_12: 0\n )\n var_8 = lambda: stdin.readline().rstrip()\n var_3 = lambda: list(map(int, var_8().split()))\n var_1 = lambda: int(var_8())\n var_4 = 10**9 + 7\n var_2 = 10**9 + 10\n var_9, var_10 = var_8().split()\n var_5 = int(var_9)\n var_10 = var_10.split(\".\")\n var_6 = int(var_10[0]) * 100\n if len(var_10) == 2:\n var_6 += int(var_10[1])\n print(var_5 * var_6 // 100)\n\n\nfunc_1()\n```", "output": "SLOWER 2.1571", "pair_id": "python_p02659_reversed", "problem_id": "p02659", "language": "python", "direction": "reversed", "speedup_ratio": 4.4601} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_2 = int(eval(input()))\nvar_1 = list(map(int, input().split()))\nvar_4 = 1\nfor var_3 in range(var_2):\n if var_1[var_3] % 2 == 0:\n var_4 *= 2\nprint((3**var_2 - var_4))\n```\n\n=== Code B (Modified) ===\n```python\nvar_6 = int(eval(input()))\nvar_2 = list(map(int, input().split()))\nfrom itertools import product\n\nvar_5 = [-1, 0, 1]\nvar_3 = 0\nfor var_7 in product(var_5, repeat=var_6):\n var_1 = []\n for var_4 in range(var_6):\n var_1.append(var_7[var_4] + var_2[var_4])\n if any(var_8 % 2 == 0 for var_8 in var_1):\n var_3 += 1\nprint(var_3)\n```", "output": "SLOWER 9.8508", "pair_id": "python_p03568_reversed", "problem_id": "p03568", "language": "python", "direction": "reversed", "speedup_ratio": 923.3817} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\nimport math\nfrom collections import defaultdict\nfrom bisect import bisect_left, bisect_right\n\nsys.setrecursionlimit(10**7)\n\n\ndef func_4():\n return sys.stdin.readline()[:-1]\n\n\nvar_4 = 10**9 + 7\n\n\ndef func_1():\n return int(eval(func_4()))\n\n\ndef func_2():\n return list(map(int, func_4().split()))\n\n\ndef func_3(var_6, var_3):\n if var_6 <= 0:\n return [[] for _ in range(var_3)]\n elif var_3 == 1:\n return [func_1() for _ in range(var_6)]\n else:\n var_5 = [func_2() for _ in range(var_6)]\n return list(map(list, list(zip(*var_5))))\n\n\nfrom decimal import getcontext, Decimal\n\ngetcontext().prec = 28\nvar_1, var_2 = list(map(str, func_4().split()))\nvar_1 = int(var_1)\nvar_2 = Decimal(var_2)\nprint((int(var_1 * var_2)))\n```\n\n=== Code B (Modified) ===\n```python\ndef func_1():\n var_1, var_3 = input().split()\n var_1 = int(var_1)\n var_3 = int(float(var_3) * 100 + 0.5)\n var_2 = var_1 * var_3\n print((var_2 // 100))\n\n\nif __name__ == \"__main__\":\n func_1()\n```", "output": "FASTER 1.8519", "pair_id": "python_p02659_forward", "problem_id": "p02659", "language": "python", "direction": "forward", "speedup_ratio": 3.6097} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\ndef func_1():\n from sys import setrecursionlimit, stdin\n from os import environ\n from collections import defaultdict, deque, Counter\n from math import ceil, floor, gcd\n from itertools import accumulate, combinations, combinations_with_replacement\n\n setrecursionlimit(10**6)\n var_7 = (\n (lambda *var_11: print(*var_11))\n if \"TERM_PROGRAM\" in environ\n else lambda *var_12: 0\n )\n var_8 = lambda: stdin.readline().rstrip()\n var_3 = lambda: list(map(int, var_8().split()))\n var_1 = lambda: int(var_8())\n var_4 = 10**9 + 7\n var_2 = 10**9 + 10\n var_9, var_10 = var_8().split()\n var_5 = int(var_9)\n var_10 = var_10.split(\".\")\n var_6 = int(var_10[0]) * 100\n if len(var_10) == 2:\n var_6 += int(var_10[1])\n print(var_5 * var_6 // 100)\n\n\nfunc_1()\n```\n\n=== Code B (Modified) ===\n```python\nfrom fractions import Fraction\n\nvar_1, var_2 = input().split()\n\n\nfrom decimal import *\n\nvar_4 = var_3(var_1)\nvar_6 = var_3(var_2)\nvar_7().prec = 28\nvar_5 = var_4 * var_6\nprint((int(var_5)))\n```", "output": "FASTER 1.768", "pair_id": "python_p02659_forward", "problem_id": "p02659", "language": "python", "direction": "forward", "speedup_ratio": 3.4057} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_4 = 19\nvar_7 = [0] * (2 ** (var_4 + 1) - 1)\n\n\ndef func_1(var_12, var_17):\n var_11 = 2**var_4 + var_12 - 1\n while var_11 >= 0:\n var_7[var_11] += var_17\n var_11 = (var_11 - 1) // 2\n\n\ndef func_2(var_8, var_9):\n var_13 = var_8 + (1 << var_4)\n var_15 = var_9 + (1 << var_4)\n var_16 = 0\n while var_13 < var_15:\n if var_13 % 2:\n var_16 += var_7[var_13 - 1]\n var_13 += 1\n if var_15 % 2:\n var_15 -= 1\n var_16 += var_7[var_15 - 1]\n var_13 >>= 1\n var_15 >>= 1\n return var_16\n\n\nvar_3, var_5 = map(int, input().split())\nvar_2 = [int(var_8) - 1 for var_8 in input().split()]\nvar_6 = [[] for _ in range(var_3)]\nfor var_11 in range(var_5):\n var_13, var_15 = map(int, input().split())\n var_6[var_15 - 1].append((var_13 - 1, var_11))\nvar_14 = [-1] * var_3\nvar_1 = [-1] * var_5\nfunc_1(1, var_3)\nfor var_15 in range(var_3):\n var_10 = var_2[var_15]\n func_1(var_14[var_10] + 2, -1)\n func_1(var_15 + 2, 1)\n var_14[var_10] = var_15\n for var_13, var_11 in var_6[var_15]:\n var_1[var_11] = func_2(var_13 + 2, 1 << var_4)\nprint(*var_1, sep=\"\\n\")\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\n\nvar_20 = sys.stdin.read\nvar_21 = sys.stdin.readline\nvar_22 = sys.stdin.readlines\nsys.setrecursionlimit(10**9)\nvar_2 = 1 << 60\nvar_5 = 1000000007\n\n\nvar_4 = 1000001\n\n\nclass Class_1:\n def __init__(self, var_13, var_19, var_12):\n self.l = var_13\n self.r = var_19\n self.idx = var_12\n\n\ndef func_4(var_12, var_24, var_10, var_15):\n while var_12 <= var_15:\n var_10[var_12] += var_24\n var_12 += var_12 & -var_12\n\n\ndef func_3(var_12, var_10, var_15):\n var_23 = 0\n while var_12:\n var_23 += var_10[var_12]\n var_12 -= var_12 & -var_12\n return var_23\n\n\ndef func_1(var_9, var_15, var_17, var_16):\n\n var_10 = [0] * (var_15 + 1)\n\n var_14 = [-1] * var_4\n\n var_8 = [0] * var_16\n var_18 = 0\n for var_11 in range(var_15):\n\n if var_14[var_9[var_11]] != -1:\n func_4(var_14[var_9[var_11]] + 1, -1, var_10, var_15)\n\n var_14[var_9[var_11]] = var_11\n func_4(var_11 + 1, 1, var_10, var_15)\n\n while var_18 < var_16 and var_17[var_18].r == var_11:\n var_8[var_17[var_18].idx] = func_3(\n var_17[var_18].r + 1, var_10, var_15\n ) - func_3(var_17[var_18].l, var_10, var_15)\n var_18 += 1\n\n for var_11 in range(var_16):\n print((var_8[var_11]))\n\n\ndef func_2():\n var_6, var_7 = list(map(int, var_21().split()))\n var_1 = list(map(int, var_21().split()))\n (*var_3,) = list(map(int, var_20().split()))\n var_17 = [0] * var_7\n for var_11, (var_13, var_19) in enumerate(zip(*[iter(var_3)] * 2)):\n var_17[var_11] = Class_1(var_13 - 1, var_19 - 1, var_11)\n var_17.sort(key=lambda var_25: var_25.r)\n func_1(var_1, var_6, var_17, var_7)\n return\n\n\nif __name__ == \"__main__\":\n func_2()\n```", "output": "SLOWER 1.8145", "pair_id": "python_p02599_reversed", "problem_id": "p02599", "language": "python", "direction": "reversed", "speedup_ratio": 3.5173} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport copy\n\nvar_8 = int(eval(input()))\nvar_10 = set([var_6 for var_6 in range(1, 10**5)])\nvar_5 = []\nvar_11 = {}\nvar_9 = []\nfor var_6 in range(var_8 - 1):\n var_1, var_2 = list(map(int, input().split(\" \")))\n var_5.append([var_1, var_2])\n var_11.setdefault(var_1, []).append(var_2)\n var_9.append([])\nvar_9.append([])\nvar_9.append([])\nvar_7 = 0\nfor var_12 in range(1, var_8 + 1):\n var_14 = var_11.get(var_12, [])\n var_3 = 1\n for var_13 in var_14:\n if var_3 in var_9[var_12]:\n var_3 += 1\n else:\n pass\n var_9[var_13].append(var_3)\n if var_3 >= var_7:\n var_7 = var_3\n var_3 += 1\nprint(var_7)\nfor var_4 in var_5:\n print((var_9[var_4[1]][0]))\n```\n\n=== Code B (Modified) ===\n```python\nfrom collections import deque\n\nvar_4, *var_2 = list(map(int, open(0).read().split()))\nvar_3 = [set() for _ in range(var_4 + 1)]\nfor var_9, (var_6, var_7) in enumerate(zip(*[iter(var_2)] * 2)):\n var_3[var_6].add((var_7, var_9))\n var_3[var_7].add((var_6, var_9))\nvar_1 = [0] * (var_4 - 1)\nvar_5 = deque([(0, 1)])\nwhile var_5:\n var_10, var_12 = var_5.popleft()\n var_8 = 0\n for var_11, var_9 in var_3[var_12]:\n var_3[var_11].remove((var_12, var_9))\n var_8 += 1 + (var_8 + 1 == var_10)\n var_5.append((var_8, var_11))\n var_1[var_9] = var_8\nprint((max(var_1), *var_1))\n```", "output": "FASTER 4.5634", "pair_id": "python_p02850_forward", "problem_id": "p02850", "language": "python", "direction": "forward", "speedup_ratio": 23.6433} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\n\n\ndef func_1(var_5, var_6):\n var_4 = 0\n for var_3 in range(var_5, var_6 + 1):\n if str(var_3) == str(var_3)[::-1]:\n var_4 += 1\n return var_4\n\n\nprint((func_1(var_1, var_2)))\n```\n\n=== Code B (Modified) ===\n```python\ndef func_1():\n var_1, var_2 = list(map(int, input().split()))\n var_3 = 0\n for var_4 in range(var_1, var_2 + 1):\n\n if (var_4 % 10) == (var_4 // 10000 % 10) and (var_4 // 10 % 10) == (\n var_4 // 1000 % 10\n ):\n var_3 += 1\n print(var_3)\n\n\nif __name__ == \"__main__\":\n func_1()\n```", "output": "FASTER 1.3404", "pair_id": "python_p03416_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 2.5323} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\n\nvar_7 = sys.stdin.readline\nfrom itertools import combinations\n\n\ndef func_3(var_10):\n for _ in range(var_10):\n yield list(map(int, var_7().split()))\n\n\ndef func_1(var_9, var_5, var_11):\n var_3 = len([0 for var_8 in var_9 if var_5[var_8] == 1])\n return var_11[var_3]\n\n\ndef func_2():\n var_10 = int(eval(var_7()))\n var_1 = list(func_3(var_10))\n var_2 = list(func_3(var_10))\n for var_6 in range(1, 11):\n for var_4 in combinations(list(range(10)), var_6):\n yield sum(\n func_1(var_4, var_5, var_11) for var_5, var_11 in zip(var_1, var_2)\n )\n\n\nprint((max(func_2())))\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\nimport numpy as np\n\nvar_5 = sys.stdin.readline\n\nvar_7 = int(eval(var_5()))\n\nvar_1 = [var_5().replace(\" \", \"\") for var_4 in range(var_7)]\n\nvar_8 = [list(map(int, var_5().split())) for var_4 in range(var_7)]\n\n\nvar_12 = -999999999999999\n\nfor var_4 in range(1, 1024):\n\n var_3 = format(var_4, \"010b\")\n\n var_10 = 0\n for var_2, var_9 in zip(var_1, var_8):\n\n var_11 = 0\n for var_6 in range(10):\n\n if var_2[var_6] == \"1\" and var_3[var_6] == \"1\":\n\n var_11 += 1\n\n var_10 += var_9[var_11]\n if var_10 > var_12:\n\n var_12 = var_10\nprint(var_12)\n```", "output": "SLOWER 1.6251", "pair_id": "python_p03503_reversed", "problem_id": "p03503", "language": "python", "direction": "reversed", "speedup_ratio": 3.0846} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_4 = str(var_4)\n if var_4 == var_4[::-1]:\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_3 in range(var_1, var_2 + 1):\n var_5 = list(str(var_3))\n var_6 = list(reversed(var_5))\n if var_5 == var_6:\n var_4 += 1\nprint(var_4)\n```", "output": "SLOWER 1.1616", "pair_id": "python_p03416_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 2.2371} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = str(var_4)\n if var_5 == var_5[::-1]:\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = list(reversed(list(str(var_4))))\n if var_5 == list(str(var_4)):\n var_3 += 1\nprint(var_3)\n```", "output": "SLOWER 1.6614", "pair_id": "python_p03416_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 3.1633} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nfrom sys import stdin\n\n\ndef func_1():\n\n var_13 = stdin.readline\n var_2 = int(var_13())\n var_1 = []\n for var_6 in range(var_2):\n var_5 = list(map(int, var_13().split()))\n var_1.append(var_5)\n var_3 = []\n for var_6 in range(var_2):\n var_12 = list(map(int, var_13().split()))\n var_3.append(var_12)\n var_9 = -float(\"inf\")\n for var_6 in range(1 << 10):\n if var_6 == 0:\n continue\n else:\n var_11 = []\n for var_7 in range(10):\n if (var_6 >> var_7) & 1:\n var_11.append(var_7)\n var_10 = [0] * 10\n for var_7 in var_11:\n var_10[var_7] = 1\n var_14 = 0\n for var_7 in range(var_2):\n var_4 = 0\n for var_8 in range(10):\n if var_10[var_8] == 1 and var_1[var_7][var_8] == 1:\n var_4 += 1\n var_14 += var_3[var_7][var_4]\n var_9 = max(var_14, var_9)\n print(var_9)\n\n\nif __name__ == \"__main__\":\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\nimport itertools\n\n\ndef func_2(var_4):\n return bin(eval(\"0b\" + str(var_4)))\n\n\ndef func_1():\n var_4 = int(sys.stdin.readline().rstrip())\n var_9 = [\n func_2(\"\".join(str(var_10) for var_10 in sys.stdin.readline().split()))\n for _ in range(var_4)\n ]\n var_8 = [\n [int(var_10) for var_10 in sys.stdin.readline().split()] for _ in range(var_4)\n ]\n var_3 = -(10**10)\n for var_6 in itertools.product(\"01\", repeat=10):\n var_6 = func_2(\"\".join(var_6))\n if var_6 == \"0b0\":\n continue\n var_7 = 0\n for var_2 in range(var_4):\n var_1 = var_9[var_2]\n var_5 = bin(eval(var_1) & eval(var_6)).count(\"1\")\n var_7 += var_8[var_2][var_5]\n var_3 = max(var_3, var_7)\n print(var_3)\n\n\nif __name__ == \"__main__\":\n\n func_1()\n```", "output": "SLOWER 3.3644", "pair_id": "python_p03503_reversed", "problem_id": "p03503", "language": "python", "direction": "reversed", "speedup_ratio": 10.2989} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport itertools\n\nvar_6 = int(eval(input()))\nvar_2 = [[]] * var_6\nfor var_4 in range(var_6):\n var_3 = list(map(int, input().split()))\n\n var_2[var_4] = var_3\nvar_8 = [[]] * var_6\nfor var_4 in range(var_6):\n var_9 = list(map(int, input().split()))\n var_8[var_4] = var_9\nvar_10 = -(10**11)\nfor var_1 in itertools.product([0, 1], repeat=10):\n if sum(var_1) == 0:\n continue\n var_11 = 0\n for var_7 in range(var_6):\n var_5 = 0\n for var_4 in range(10):\n if var_2[var_7][var_4] == 1 and var_1[var_4] == 1:\n var_5 += 1\n var_11 = var_11 + var_8[var_7][var_5]\n var_10 = max(var_10, var_11)\nprint(var_10)\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\n\nvar_7 = sys.stdin.readline\nfrom itertools import combinations\n\n\ndef func_3(var_10):\n for _ in range(var_10):\n yield list(map(int, var_7().split()))\n\n\ndef func_1(var_9, var_5, var_11):\n var_3 = len([0 for var_8 in var_9 if var_5[var_8] == 1])\n return var_11[var_3]\n\n\ndef func_2():\n var_10 = int(eval(var_7()))\n var_1 = list(func_3(var_10))\n var_2 = list(func_3(var_10))\n for var_6 in range(1, 11):\n for var_4 in combinations(list(range(10)), var_6):\n yield sum(\n func_1(var_4, var_5, var_11) for var_5, var_11 in zip(var_1, var_2)\n )\n\n\nprint((max(func_2())))\n```", "output": "FASTER 1.5941", "pair_id": "python_p03503_forward", "problem_id": "p03503", "language": "python", "direction": "forward", "speedup_ratio": 3.019} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_4 = int(eval(input()))\nvar_2 = list(map(int, input().split()))\n\n\ndef func_1(var_1, var_8, var_3):\n if var_8 == var_4:\n var_9 = 1\n for var_5 in var_3:\n var_9 *= var_5\n return 1 if var_9 % 2 == 0 else 0\n var_6 = var_3.copy()\n var_6.append(var_1[var_8] - 1)\n var_5 = var_3.copy()\n var_5.append(var_1[var_8])\n var_7 = var_3.copy()\n var_7.append(var_1[var_8] + 1)\n return (\n func_1(var_1, var_8 + 1, var_6)\n + func_1(var_1, var_8 + 1, var_5)\n + func_1(var_1, var_8 + 1, var_7)\n )\n\n\nprint((func_1(var_2, 0, [])))\n```\n\n=== Code B (Modified) ===\n```python\nfrom functools import reduce\nfrom itertools import product\n\nvar_2 = int(eval(input()))\n(*var_1,) = list(map(int, input().split()))\nvar_4 = 0\nfor var_7 in product([-1, 0, 1], repeat=var_2):\n var_6 = reduce(\n lambda var_8, var_9: var_8 * var_9,\n [var_3 + var_7[var_5] for var_5, var_3 in enumerate(var_1)],\n )\n if var_6 % 2 == 0:\n var_4 += 1\nprint(var_4)\n```", "output": "SLOWER 1.4753", "pair_id": "python_p03568_reversed", "problem_id": "p03568", "language": "python", "direction": "reversed", "speedup_ratio": 2.7805} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nfor var_3 in range(1, 1009):\n if int(var_3 * 0.08) == var_1 and int(var_3 * 0.1) == var_2:\n print((int(var_3)))\n exit()\nprint(\"-1\")\n```\n\n=== Code B (Modified) ===\n```python\nimport math\n\nvar_1, var_4 = (int(var_10) for var_10 in input().split())\nvar_2 = math.ceil(var_1 / 0.08)\nvar_3 = math.ceil((var_1 + 1) / 0.08)\n\"\"\"\"\"\"\nvar_5 = math.ceil(var_4 / 0.1)\nvar_6 = math.ceil((var_4 + 1) / 0.1)\n\"\"\"\"\"\"\nvar_7 = list(range(var_2, var_3))\nvar_8 = list(range(var_5, var_6))\nvar_9 = set(var_7) & set(var_8)\nif len(var_9) == 0:\n print((-1))\nelse:\n print((min(var_9)))\n```", "output": "FASTER 1.1926", "pair_id": "python_p02755_forward", "problem_id": "p02755", "language": "python", "direction": "forward", "speedup_ratio": 2.2856} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nfrom collections import deque\n\nvar_4, *var_2 = list(map(int, open(0).read().split()))\nvar_3 = [set() for _ in range(var_4 + 1)]\nfor var_9, (var_6, var_7) in enumerate(zip(*[iter(var_2)] * 2)):\n var_3[var_6].add((var_7, var_9))\n var_3[var_7].add((var_6, var_9))\nvar_1 = [0] * (var_4 - 1)\nvar_5 = deque([(0, 1)])\nwhile var_5:\n var_10, var_12 = var_5.popleft()\n var_8 = 0\n for var_11, var_9 in var_3[var_12]:\n var_3[var_11].remove((var_12, var_9))\n var_8 += 1 + (var_8 + 1 == var_10)\n var_5.append((var_8, var_11))\n var_1[var_9] = var_8\nprint((max(var_1), *var_1))\n```\n\n=== Code B (Modified) ===\n```python\nimport copy\n\nvar_8 = int(eval(input()))\nvar_10 = set([var_6 for var_6 in range(1, 10**5)])\nvar_5 = []\nvar_11 = {}\nvar_9 = []\nfor var_6 in range(var_8 - 1):\n var_1, var_2 = list(map(int, input().split(\" \")))\n var_5.append([var_1, var_2])\n var_11.setdefault(var_1, []).append(var_2)\n var_9.append([])\nvar_9.append([])\nvar_9.append([])\nvar_7 = 0\nfor var_12 in range(1, var_8 + 1):\n var_14 = var_11.get(var_12, [])\n var_3 = 1\n for var_13 in var_14:\n if var_3 in var_9[var_12]:\n var_3 += 1\n else:\n pass\n var_9[var_13].append(var_3)\n if var_3 >= var_7:\n var_7 = var_3\n var_3 += 1\nprint(var_7)\nfor var_4 in var_5:\n print((var_9[var_4[1]][0]))\n```", "output": "SLOWER 4.5634", "pair_id": "python_p02850_reversed", "problem_id": "p02850", "language": "python", "direction": "reversed", "speedup_ratio": 23.6433} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = list(reversed(list(str(var_4))))\n if var_5 == list(str(var_4)):\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\ndef func_1():\n var_1, var_2 = list(map(int, input().rstrip().split()))\n var_3 = 0\n for var_4 in range(var_1, var_2 + 1):\n var_5 = str(var_4)\n if var_5 == var_5[::-1]:\n var_3 += 1\n print(var_3)\n\n\nif __name__ == \"__main__\":\n func_1()\n```", "output": "FASTER 2.4029", "pair_id": "python_p03416_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 5.2888} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_4 = int(eval(input()))\nvar_2 = list(map(int, input().split()))\n\n\ndef func_1(var_1, var_8, var_3):\n if var_8 == var_4:\n var_9 = 1\n for var_5 in var_3:\n var_9 *= var_5\n return 1 if var_9 % 2 == 0 else 0\n var_6 = var_3.copy()\n var_6.append(var_1[var_8] - 1)\n var_5 = var_3.copy()\n var_5.append(var_1[var_8])\n var_7 = var_3.copy()\n var_7.append(var_1[var_8] + 1)\n return (\n func_1(var_1, var_8 + 1, var_6)\n + func_1(var_1, var_8 + 1, var_5)\n + func_1(var_1, var_8 + 1, var_7)\n )\n\n\nprint((func_1(var_2, 0, [])))\n```\n\n=== Code B (Modified) ===\n```python\nimport numpy as np\nfrom itertools import product\n\nvar_6 = int(eval(input()))\nvar_2 = list(map(int, input().split()))\nvar_2 = np.array(var_2)\nvar_5 = [-1, 0, 1]\nvar_3 = 0\nfor var_7 in product(var_5, repeat=var_6):\n var_7 = np.array(var_7)\n var_1 = var_2 + var_7\n var_4 = var_1.cumprod()\n if var_4[-1] % 2 == 0:\n var_3 += 1\nprint(var_3)\n```", "output": "SLOWER 1.7419", "pair_id": "python_p03568_reversed", "problem_id": "p03568", "language": "python", "direction": "reversed", "speedup_ratio": 3.3447} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\n\"\"\"\"\"\"\n\nfrom collections import defaultdict\n\n\ndef func_1(var_10, var_9):\n var_5 = 1\n yield var_5\n for _ in range(1, var_10):\n var_5 = (var_5 * 10) % var_9\n yield var_5\n\n\ndef func_2():\n var_3 = 2019\n var_4 = input()[::-1]\n\n var_1 = [\n int(var_11) * var_10 % var_3\n for var_11, var_10 in zip(var_4, func_1(len(var_4), var_3))\n ]\n\n var_2 = [0]\n for var_5 in var_1:\n var_2.append((var_2[-1] + var_5) % var_3)\n\n var_8 = defaultdict(int)\n for var_6 in var_2:\n var_8[var_6] += 1\n var_7 = sum(var_12 * (var_12 - 1) // 2 for var_12 in list(var_8.values()))\n print(var_7)\n\n\nfunc_2()\n```\n\n=== Code B (Modified) ===\n```python\nvar_6 = 2019\nvar_1 = [0] * var_6\nvar_3 = 1\nvar_5 = var_4 = 0\nfor var_2 in input()[::-1]:\n var_1[var_4] += 1\n var_4 -= int(var_2) * var_3\n var_4 %= var_6\n var_5 += var_1[var_4]\n var_3 *= 10\n var_3 %= var_6\nprint(var_5)\n```", "output": "FASTER 1.5308", "pair_id": "python_p02702_forward", "problem_id": "p02702", "language": "python", "direction": "forward", "speedup_ratio": 2.8894} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_6 in range(var_1, var_2 + 1):\n var_3 = str(var_6)\n var_5 = True\n for var_7 in range(len(var_3) // 2):\n if var_3[var_7] != var_3[-var_7 - 1] and var_5:\n var_5 = not var_5\n if var_5:\n var_4 += 1\nprint(var_4)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_3 = list(map(int, input().split()))\nvar_2 = 0\nfor var_5 in range(var_3 + 1)[var_1:]:\n if len(str(var_5)) % 2 == 0:\n var_6 = list(str(var_5))[: len(str(var_5)) // 2]\n var_7 = list(reversed(list(str(var_5))[len(str(var_5)) // 2 :]))\n if var_6 == var_7:\n var_2 += 1\n else:\n var_8 = list(str(var_5))[: len(str(var_5)) // 2 + 1]\n var_4 = list(reversed(list(str(var_5))[len(str(var_5)) // 2 :]))\n if var_8 == var_4:\n var_2 += 1\nprint(var_2)\n```", "output": "SLOWER 1.0146", "pair_id": "python_p03416_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 2.0203} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport math\nimport string\n\n\ndef func_4():\n return list(map(int, input().split()))\n\n\ndef func_3(var_6, var_7):\n return math.factorial(var_6) // (\n math.factorial(var_6 - var_7) * math.factorial(var_7)\n )\n\n\ndef func_2(var_9):\n var_8 = []\n for var_5 in var_9:\n if not (var_5 in var_8):\n var_8.append(var_5)\n return len(var_9) != len(var_8)\n\n\ndef func_1(var_6):\n func_1 = []\n for var_4 in range(1, var_6 + 1):\n if var_6 % var_4 == 0:\n func_1.append(var_4)\n return func_1\n\n\nvar_2 = [-1, -1, -1, 0, 0, 1, 1, 1]\nvar_3 = [-1, 0, 1, -1, 1, -1, 0, 1]\nvar_6 = int(eval(input()))\nvar_1 = func_4()\nvar_10 = 1\nfor var_4 in range(len(var_1)):\n if var_1[var_4] % 2 == 0:\n var_10 *= 2\n else:\n var_10 *= 1\nprint((3 ** len(var_1) - var_10))\n```\n\n=== Code B (Modified) ===\n```python\nfrom itertools import product\n\nvar_6 = int(eval(input()))\nvar_1 = list(map(int, input().split()))\nvar_5 = 0\nfor var_2 in product((-1, 0, 1), repeat=var_6):\n var_7 = 1\n for var_3, var_4 in zip(var_1, var_2):\n var_7 *= var_3 + var_4\n if var_7 % 2 == 0:\n var_5 += 1\nprint(var_5)\n```", "output": "SLOWER 8.339", "pair_id": "python_p03568_reversed", "problem_id": "p03568", "language": "python", "direction": "reversed", "speedup_ratio": 323.8095} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_3 in range(var_1, var_2 + 1):\n var_5 = list(str(var_3))\n var_6 = list(reversed(var_5))\n if var_5 == var_6:\n var_4 += 1\nprint(var_4)\n```\n\n=== Code B (Modified) ===\n```python\ndef func_1():\n var_1, var_2 = list(map(int, input().rstrip().split()))\n var_3 = 0\n for var_4 in range(var_1, var_2 + 1):\n var_5 = str(var_4)\n if var_5 == var_5[::-1]:\n var_3 += 1\n print(var_3)\n\n\nif __name__ == \"__main__\":\n func_1()\n```", "output": "FASTER 2.0546", "pair_id": "python_p03416_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 4.1544} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport math\nimport string\n\n\ndef func_5():\n return list(map(int, input().split()))\n\n\ndef func_4(var_7, var_8):\n return math.factorial(var_7) // (\n math.factorial(var_7 - var_8) * math.factorial(var_8)\n )\n\n\ndef func_3(var_10):\n var_9 = []\n for var_5 in var_10:\n if not (var_5 in var_9):\n var_9.append(var_5)\n return len(var_10) != len(var_9)\n\n\ndef func_1(var_7):\n func_1 = []\n for var_4 in range(1, var_7 + 1):\n if var_7 % var_4 == 0:\n func_1.append(var_4)\n return func_1\n\n\nvar_2 = [-1, -1, -1, 0, 0, 1, 1, 1]\nvar_3 = [-1, 0, 1, -1, 1, -1, 0, 1]\nvar_7 = int(eval(input()))\nvar_1 = func_5()\n\n\ndef func_2(var_6):\n if len(var_6) == var_7:\n for var_4 in range(len(var_6)):\n if var_6[var_4] % 2 == 0:\n return 1\n return 0\n return (\n func_2(var_6 + [var_1[len(var_6)]])\n + func_2(var_6 + [var_1[len(var_6)] - 1])\n + func_2(var_6 + [var_1[len(var_6)] + 1])\n )\n\n\nprint((func_2([])))\n```\n\n=== Code B (Modified) ===\n```python\nvar_2 = int(eval(input()))\n(*var_1,) = list(map(int, input().split()))\nvar_5 = 0\nfor var_3 in var_1:\n if var_3 % 2 == 0:\n var_5 += 1\nvar_4 = 3**var_2 - 2**var_5\nprint(var_4)\n```", "output": "FASTER 7.6454", "pair_id": "python_p03568_forward", "problem_id": "p03568", "language": "python", "direction": "forward", "speedup_ratio": 200.2176} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport math\n\nvar_1, var_4 = (int(var_10) for var_10 in input().split())\nvar_2 = math.ceil(var_1 / 0.08)\nvar_3 = math.ceil((var_1 + 1) / 0.08)\n\"\"\"\"\"\"\nvar_5 = math.ceil(var_4 / 0.1)\nvar_6 = math.ceil((var_4 + 1) / 0.1)\n\"\"\"\"\"\"\nvar_7 = list(range(var_2, var_3))\nvar_8 = list(range(var_5, var_6))\nvar_9 = set(var_7) & set(var_8)\nif len(var_9) == 0:\n print((-1))\nelse:\n print((min(var_9)))\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_3 = list(map(int, input().split()))\nvar_2 = -1\nfor var_4 in range(10, 12501):\n if int(var_4 * 0.08) == var_1 and int(var_4 * 0.1) == var_3:\n var_2 = var_4\n break\nprint(var_2)\n```", "output": "SLOWER 4.5892", "pair_id": "python_p02755_reversed", "problem_id": "p02755", "language": "python", "direction": "reversed", "speedup_ratio": 24.0708} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nfrom sys import stdin\n\nvar_6 = lambda: list(map(int, stdin.readline().split()))\nvar_5 = lambda: list(map(int, stdin.readline().split()))\nvar_1, var_3 = var_6()\nvar_2 = 0\nfor var_4 in range(var_1, var_3 + 1):\n var_7 = str(var_4)\n if var_7 == var_7[::-1]:\n var_2 += 1\nprint(var_2)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_5 in range(10):\n for var_6 in range(10):\n for var_7 in range(10):\n var_3 = 10000 * var_5 + 1000 * var_6 + 100 * var_7 + 10 * var_6 + var_5\n if var_1 <= var_3 <= var_2:\n var_4 += 1\nprint(var_4)\n```", "output": "FASTER 3.844", "pair_id": "python_p03416_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 14.3598} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport copy\n\nvar_8 = int(eval(input()))\nvar_10 = set([var_6 for var_6 in range(1, 10**5)])\nvar_5 = []\nvar_11 = {}\nvar_9 = []\nfor var_6 in range(var_8 - 1):\n var_1, var_2 = list(map(int, input().split(\" \")))\n var_5.append([var_1, var_2])\n var_11.setdefault(var_1, []).append(var_2)\n var_9.append([])\nvar_9.append([])\nvar_9.append([])\nvar_7 = 0\nfor var_12 in range(1, var_8 + 1):\n var_14 = var_11.get(var_12, [])\n var_3 = 1\n for var_13 in var_14:\n if var_3 in var_9[var_12]:\n var_3 += 1\n else:\n pass\n var_9[var_13].append(var_3)\n if var_3 >= var_7:\n var_7 = var_3\n var_3 += 1\nprint(var_7)\nfor var_4 in var_5:\n print((var_9[var_4[1]][0]))\n```\n\n=== Code B (Modified) ===\n```python\nvar_6 = int(eval(input()))\nimport sys\n\nsys.setrecursionlimit(10**6)\nvar_11 = [[] for _ in range(var_6)]\nfor var_4 in range(var_6 - 1):\n var_1, var_2 = list(map(int, input().split()))\n var_11[var_1 - 1].append((var_2 - 1, var_4))\n var_11[var_2 - 1].append((var_1 - 1, var_4))\nvar_5 = [0] * (var_6 - 1)\n\n\ndef func_1(var_8, var_10, var_9):\n var_3 = 1\n for var_7, var_4 in var_11[var_8]:\n if var_7 == var_9:\n continue\n if var_3 == var_10:\n var_3 += 1\n var_5[var_4] = var_3\n func_1(var_7, var_3, var_8)\n var_3 += 1\n\n\nfunc_1(0, -1, -1)\nprint((max(var_5)))\nfor var_4 in var_5:\n print(var_4)\n```", "output": "FASTER 4.64", "pair_id": "python_p02850_forward", "problem_id": "p02850", "language": "python", "direction": "forward", "speedup_ratio": 24.934} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = [\n var_3 for var_3 in map(str, list(range(var_1, var_2 + 1))) if var_3 == var_3[::-1]\n]\nprint((len(var_4)))\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n if str(var_4) == \"\".join(reversed(str(var_4))):\n var_3 += 1\nprint(var_3)\n```", "output": "SLOWER 1.7748", "pair_id": "python_p03416_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 3.4219} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nfrom collections import Counter, defaultdict, deque\nfrom heapq import heappop, heappush, heapify\nimport sys, bisect, math, itertools, fractions, pprint\n\nsys.setrecursionlimit(10**8)\nvar_6 = 10**9 + 7\nvar_1 = float(\"inf\")\n\n\ndef func_1():\n return int(sys.stdin.readline())\n\n\ndef func_2():\n return list(map(int, sys.stdin.readline().split()))\n\n\nvar_8, var_11 = func_2()\nvar_17 = [func_2() for _ in range(var_8)]\nvar_10 = var_17[::-1]\nvar_14 = [[0] * var_11 for _ in range(var_8)]\nvar_3 = [[0] * var_11 for _ in range(var_8)]\nfor var_4 in range(var_8 - 1):\n var_16, var_15 = var_17[var_4]\n for var_5 in range(var_11):\n if var_5 < var_16:\n var_14[var_4 + 1][var_5] = var_14[var_4][var_5]\n else:\n var_14[var_4 + 1][var_5] = max(\n var_14[var_4][var_5], var_14[var_4][var_5 - var_16] + var_15\n )\nvar_9 = var_14[var_8 - 1][var_11 - 1] + var_17[var_8 - 1][1]\nfor var_4 in range(var_8 - 1):\n var_16, var_15 = var_10[var_4]\n for var_5 in range(var_11):\n if var_5 < var_16:\n var_3[var_4 + 1][var_5] = var_3[var_4][var_5]\n else:\n var_3[var_4 + 1][var_5] = max(\n var_3[var_4][var_5], var_3[var_4][var_5 - var_16] + var_15\n )\n var_9 = max(var_9, var_3[var_8 - 1][var_11 - 1] + var_17[0][1])\n\nfor var_4 in range(1, var_8 - 1):\n var_13 = var_4\n var_2 = var_8 - var_4 - 1\n var_7 = 0\n for var_5 in range(var_11):\n var_12 = var_14[var_13][var_5] + var_3[var_2][var_11 - 1 - var_5]\n var_7 = max(var_7, var_12)\n var_9 = max(var_9, var_7 + var_17[var_4][1])\nprint(var_9)\n```\n\n=== Code B (Modified) ===\n```python\nimport bisect\nimport sys\n\nsys.setrecursionlimit(10**6)\nvar_16 = sys.stdout.write\nvar_7 = lambda *var_14: print(*var_14) if var_1 else 0\nvar_1 = True\n\n\ndef func_1(var_9=sys.stdin.readline):\n var_11 = lambda: var_9().rstrip()\n var_3 = lambda: list(map(int, var_11().split()))\n var_2 = lambda: int(var_11())\n var_4 = lambda var_17: [var_3() for _ in range(var_17)]\n var_13, var_15 = var_3()\n var_5 = var_4(var_13)\n var_5.sort()\n var_8 = [[0] * var_15 for _ in range(var_13 + 1)]\n for var_10 in range(1, var_13 + 1):\n for var_12 in range(1, var_15):\n if var_12 < var_5[var_10 - 1][0]:\n var_8[var_10][var_12] = var_8[var_10 - 1][var_12]\n else:\n var_8[var_10][var_12] = max(\n var_8[var_10 - 1][var_12],\n var_8[var_10 - 1][var_12 - var_5[var_10 - 1][0]]\n + var_5[var_10 - 1][1],\n )\n var_6 = 0\n for var_10 in range(var_13):\n var_6 = max(var_6, var_8[var_10][var_15 - 1] + var_5[var_10][1])\n print(var_6)\n\n\nif __name__ == \"__main__\":\n func_1()\n```", "output": "FASTER 1.4049", "pair_id": "python_p02863_forward", "problem_id": "p02863", "language": "python", "direction": "forward", "speedup_ratio": 2.648} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_3 in range(var_1, var_2 + 1):\n var_5 = list(str(var_3))\n var_6 = list(reversed(var_5))\n if var_5 == var_6:\n var_4 += 1\nprint(var_4)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = str(var_4)\n if var_5[0] == var_5[4] and var_5[1] == var_5[3]:\n var_3 += 1\nprint(var_3)\n```", "output": "FASTER 1.5748", "pair_id": "python_p03416_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 2.9789} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\ndef func_1():\n var_1, var_3 = input().split()\n var_1 = int(var_1)\n var_3 = int(float(var_3) * 100 + 0.5)\n var_2 = var_1 * var_3\n print((var_2 // 100))\n\n\nif __name__ == \"__main__\":\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\nimport math\nfrom collections import defaultdict\nfrom bisect import bisect_left, bisect_right\n\nsys.setrecursionlimit(10**7)\n\n\ndef func_4():\n return sys.stdin.readline()[:-1]\n\n\nvar_4 = 10**9 + 7\n\n\ndef func_1():\n return int(eval(func_4()))\n\n\ndef func_2():\n return list(map(int, func_4().split()))\n\n\ndef func_3(var_6, var_3):\n if var_6 <= 0:\n return [[] for _ in range(var_3)]\n elif var_3 == 1:\n return [func_1() for _ in range(var_6)]\n else:\n var_5 = [func_2() for _ in range(var_6)]\n return list(map(list, list(zip(*var_5))))\n\n\nvar_1, var_2 = list(map(str, func_4().split()))\nvar_1 = int(var_1)\nvar_2 = 100 * int(var_2[0]) + 10 * int(var_2[2]) + int(var_2[3])\nprint((var_1 * var_2 // 100))\n```", "output": "SLOWER 1.871", "pair_id": "python_p02659_reversed", "problem_id": "p02659", "language": "python", "direction": "reversed", "speedup_ratio": 3.6579} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1 = int(eval(input()))\nvar_3 = 0\nfor var_2 in range(1000001):\n var_3 += 7 * pow(10, var_2, var_1)\n var_3 %= var_1\n if var_3 == 0:\n print((var_2 + 1))\n break\nelse:\n print((-1))\n```\n\n=== Code B (Modified) ===\n```python\ndef func_1(var_1):\n var_2 = 0\n var_4 = 1\n for var_3 in range(1_000_001):\n var_2 += 7 * var_4\n var_2 %= var_1\n if var_2 == 0:\n return var_3 + 1\n var_4 *= 10\n var_4 %= var_1\n else:\n return -1\n\n\nprint((func_1(int(eval(input())))))\n```", "output": "FASTER 2.9835", "pair_id": "python_p02596_forward", "problem_id": "p02596", "language": "python", "direction": "forward", "speedup_ratio": 7.9088} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\nimport math\nfrom collections import defaultdict\nfrom bisect import bisect_left, bisect_right\n\nsys.setrecursionlimit(10**7)\n\n\ndef func_4():\n return sys.stdin.readline()[:-1]\n\n\nvar_4 = 10**9 + 7\n\n\ndef func_1():\n return int(eval(func_4()))\n\n\ndef func_2():\n return list(map(int, func_4().split()))\n\n\ndef func_3(var_6, var_3):\n if var_6 <= 0:\n return [[] for _ in range(var_3)]\n elif var_3 == 1:\n return [func_1() for _ in range(var_6)]\n else:\n var_5 = [func_2() for _ in range(var_6)]\n return list(map(list, list(zip(*var_5))))\n\n\nvar_1, var_2 = list(map(str, func_4().split()))\nvar_1 = int(var_1)\nvar_2 = 100 * int(var_2[0]) + 10 * int(var_2[2]) + int(var_2[3])\nprint((var_1 * var_2 // 100))\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = input().split()\nvar_1 = int(var_1)\nvar_3, var_4 = list(map(int, var_2.split(\".\")))\nvar_5 = var_1 * (var_3 * 100 + var_4)\nprint((int(var_5 // 100)))\n```", "output": "FASTER 2.0781", "pair_id": "python_p02659_forward", "problem_id": "p02659", "language": "python", "direction": "forward", "speedup_ratio": 4.2224} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_7 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_3 = True\n var_8 = str(var_4)\n var_6 = len(var_8)\n for var_5 in range(var_6 // 2 + 1):\n if var_8[var_5] != var_8[-var_5 - 1]:\n var_3 = False\n break\n if var_3:\n var_7 += 1\nprint(var_7)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = str(var_4)\n if var_5[0] == var_5[4] and var_5[1] == var_5[3]:\n var_3 += 1\nprint(var_3)\n```", "output": "FASTER 1.3913", "pair_id": "python_p03416_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 2.6231} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\ndef func_1():\n return list(map(int, input().split()))\n\n\nimport numpy as np\n\nvar_1, var_2, var_3 = func_1()\nvar_4 = np.array(list(func_1()))\nvar_6 = np.array(list(func_1()))\nvar_9 = min(var_4) + min(var_6)\nvar_5 = float(\"inf\")\nfor var_8 in range(var_3):\n var_11, var_12, var_7 = func_1()\n var_10 = var_4[var_11 - 1] + var_6[var_12 - 1] - var_7\n var_5 = min(var_5, var_10)\nprint((min(var_5, var_9)))\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\nfrom collections import Counter\n\n\ndef func_10():\n return sys.stdin.readline().strip()\n\n\ndef func_11(var_12, var_13, var_14):\n return [[var_14] * var_13 for var_17 in range(var_12)]\n\n\ndef func_12(var_12, var_13, var_14, var_15):\n return [[[var_15] * var_14 for var_18 in range(var_13)] for var_17 in range(var_12)]\n\n\ndef func_13(var_12, var_13, var_14, var_15, var_16):\n return [\n [[[var_16] * var_15 for var_18 in range(var_14)] for var_18 in range(var_13)]\n for var_17 in range(var_12)\n ]\n\n\ndef func_8(var_22, var_23=1):\n return int(-(-var_22 // var_23))\n\n\ndef func_1():\n return int(eval(func_10()))\n\n\ndef func_3():\n return list(map(int, func_10().split()))\n\n\ndef func_2(var_11=None):\n return list(func_3()) if var_11 is None else [func_1() for var_17 in range(var_11)]\n\n\ndef func_7():\n print(\"Yes\")\n\n\ndef func_5():\n print(\"No\")\n\n\ndef func_6():\n print(\"YES\")\n\n\ndef func_4():\n print(\"NO\")\n\n\nsys.setrecursionlimit(10**9)\nvar_5 = 10**18\nvar_10 = 10**9 + 7\n\n\ndef func_9(var_1, var_2):\n \"\"\"\"\"\"\n import numpy as np\n from numpy.fft import rfft, irfft\n\n var_8 = max(var_1)\n var_9 = max(var_2)\n var_3 = [0] * (var_8 + 1)\n var_4 = [0] * (var_9 + 1)\n for var_12 in var_1:\n var_3[var_12] += 1\n for var_13 in var_2:\n var_4[var_13] += 1\n\n var_6 = 1\n var_19 = 0\n while var_6 <= var_8 + var_9:\n var_19 += 1\n var_6 = 2**var_19\n\n var_21 = irfft(rfft(var_3, var_6) * rfft(var_4, var_6), var_6)\n\n var_21 = np.rint(var_21).astype(np.int64)\n return var_21\n\n\nvar_11, var_7, var_6 = func_3()\nvar_1 = func_2()\nvar_2 = func_2()\nvar_21 = list(func_9(var_1, var_2))\nvar_20 = var_5\nfor var_17, var_12 in enumerate(var_21):\n if var_12 != 0:\n var_20 = var_17\n break\nfor _ in range(var_6):\n var_22, var_23, var_14 = func_3()\n var_22 -= 1\n var_23 -= 1\n var_20 = min(var_20, var_1[var_22] + var_2[var_23] - var_14)\nprint(var_20)\n```", "output": "SLOWER 2.9536", "pair_id": "python_p02748_reversed", "problem_id": "p02748", "language": "python", "direction": "reversed", "speedup_ratio": 7.7468} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = list(reversed(list(str(var_4))))\n if var_5 == list(str(var_4)):\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = input().split()\nvar_1 = int(var_1)\nvar_2 = int(var_2)\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = list(str(var_4))\n if (var_5[0] == var_5[4]) and (var_5[1] == var_5[3]):\n var_3 = var_3 + 1\nprint(var_3)\n```", "output": "FASTER 1.2527", "pair_id": "python_p03416_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 2.3828} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_8 in range(var_1, var_2 + 1):\n var_7 = str(var_8)\n var_6 = len(var_7)\n var_4 = True\n for var_5 in range(var_6 // 2):\n if var_7[var_5] != var_7[var_6 - 1 - var_5]:\n var_4 = False\n break\n if var_4:\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1 = list(map(int, input().split()))\nvar_2 = 0\nfor var_3 in range(var_1[0], var_1[1] + 1):\n var_4 = str(var_3)\n if var_4[0] == var_4[4] and var_4[1] == var_4[3]:\n var_2 += 1\nprint(var_2)\n```", "output": "FASTER 1.4151", "pair_id": "python_p03416_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 2.6667} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\nfrom operator import itemgetter\nfrom heapq import heapify, heappop, heappush\n\nvar_1 = int(10e15)\nvar_2 = -var_1\nvar_11 = 1000000007\nsys.setrecursionlimit(1000000)\n\n\ndef func_2():\n return list(map(int, input().split()))\n\n\ndef func_4():\n return input().split()\n\n\ndef func_1():\n return int(sys.stdin.readline())\n\n\ndef func_3():\n return eval(input())\n\n\nvar_3, var_4 = func_2()\nvar_5 = [func_2() for var_9 in range(var_3)]\nvar_5.sort(key=itemgetter(0))\n\nvar_8 = [[0] * (var_4 + 1 + 3000 + 1) for _ in range(var_3 + 1)]\nvar_6 = 0\nfor var_9 in range(var_3):\n for var_10 in range(var_4 + 1 + 3000 + 1):\n var_12, var_7 = var_5[var_9]\n if 0 <= var_10 - var_12 < var_4:\n var_8[var_9 + 1][var_10] = max(\n var_8[var_9][var_10], var_8[var_9][var_10 - var_12] + var_7\n )\n else:\n var_8[var_9 + 1][var_10] = var_8[var_9][var_10]\n var_6 = max(var_6, var_8[var_9 + 1][var_10])\nprint(var_6)\n```\n\n=== Code B (Modified) ===\n```python\nfrom collections import Counter, defaultdict, deque\nfrom heapq import heappop, heappush, heapify\nimport sys, bisect, math, itertools, fractions, pprint\n\nsys.setrecursionlimit(10**8)\nvar_6 = 10**9 + 7\nvar_1 = float(\"inf\")\n\n\ndef func_1():\n return int(sys.stdin.readline())\n\n\ndef func_2():\n return list(map(int, sys.stdin.readline().split()))\n\n\nvar_7, var_9 = func_2()\nvar_13 = [func_2() for _ in range(var_7)]\nvar_13.sort(key=lambda var_14: var_14[1], reverse=True)\nvar_8 = 0\nvar_10 = min(var_7, 5)\nfor var_3 in range(var_10):\n var_2 = [[0] * (var_9 + 5) for _ in range(var_7 + 5)]\n for var_4 in range(var_7):\n var_12, var_11 = var_13[var_4]\n for var_5 in range(var_9):\n if var_5 < var_12 or var_3 == var_4:\n var_2[var_4 + 1][var_5] = var_2[var_4][var_5]\n else:\n var_2[var_4 + 1][var_5] = max(\n var_2[var_4][var_5], var_2[var_4][var_5 - var_12] + var_11\n )\n\n var_8 = max(var_2[var_7][var_9 - 1] + var_13[var_3][1], var_8)\nprint(var_8)\n```", "output": "FASTER 3.1764", "pair_id": "python_p02863_forward", "problem_id": "p02863", "language": "python", "direction": "forward", "speedup_ratio": 9.0403} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_8 in range(var_1, var_2 + 1):\n var_7 = str(var_8)\n var_6 = len(var_7)\n var_4 = True\n for var_5 in range(var_6 // 2):\n if var_7[var_5] != var_7[var_6 - 1 - var_5]:\n var_4 = False\n break\n if var_4:\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_5 in range(var_1, var_2 + 1):\n var_3 = str(var_5)\n if var_3[0] == var_3[-1] and var_3[1] == var_3[-2]:\n var_4 += 1\nprint(var_4)\n```", "output": "FASTER 1.2178", "pair_id": "python_p03416_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 2.3259} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_11 = int(eval(input()))\nvar_12 = {var_8: [] for var_8 in range(1, var_11 + 1)}\nvar_19 = [False for var_8 in range(var_11 + 1)]\nvar_16 = []\nfor _ in range(var_11 - 1):\n var_2, var_3 = list(map(int, input().split()))\n var_12[var_2].append(var_3)\n var_12[var_3].append(var_2)\n var_16.append((var_2, var_3))\nvar_9 = var_16[0][0]\nvar_19[var_9] = True\nvar_6 = []\nvar_7 = []\nvar_14 = {var_8: {} for var_8 in range(1, var_11 + 1)}\nvar_10 = [0 for var_8 in range(var_11 + 1)]\n\nvar_4 = 1\nfor var_5 in var_12[var_9]:\n var_19[var_5] = True\n var_14[var_9][var_5] = var_4\n var_14[var_5][var_9] = var_4\n var_10[var_5] = var_4\n var_4 += 1\n var_6.append(var_5)\nwhile var_6:\n for var_15 in var_6:\n var_13 = 1\n for var_5 in var_12[var_15]:\n if var_19[var_5] == False:\n var_19[var_5] = True\n if var_13 != var_10[var_15]:\n var_14[var_15][var_5] = var_13\n var_14[var_5][var_15] = var_13\n var_10[var_5] = var_13\n var_13 += 1\n var_7.append(var_5)\n else:\n var_13 += 1\n var_14[var_15][var_5] = var_13\n var_14[var_5][var_15] = var_13\n var_10[var_5] = var_13\n var_13 += 1\n var_7.append(var_5)\n if var_7:\n var_6 = var_7\n var_7 = []\n else:\n var_6 = []\n var_7 = []\nvar_1 = 0\nfor var_8 in range(1, var_11 + 1):\n var_1 = max(var_1, len(var_12[var_8]))\nprint(var_1)\nfor var_8 in range(var_11 - 1):\n var_17, var_18 = var_16[var_8][0], var_16[var_8][1]\n print((var_14[var_17][var_18]))\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\nfrom collections import deque\n\nvar_13 = sys.stdin.readline\nvar_2 = int(eval(var_13()))\nvar_5 = [deque() for _ in range(var_2)]\nvar_3 = [-1] * var_2\nfor var_12 in range(var_2 - 1):\n var_6, var_8 = list(map(int, var_13().split()))\n var_5[var_6 - 1].append((var_12, var_8 - 1))\n\n\nvar_4 = deque([(0, -1)])\nvar_1 = [-1] * (var_2 - 1)\nvar_11 = 0\nwhile var_4:\n var_14, var_10 = var_4.pop()\n var_9 = 1\n for var_12, var_15 in var_5[var_14]:\n if var_9 == var_10:\n var_9 += 1\n var_1[var_12] = var_9\n var_4.appendleft((var_15, var_9))\n var_9 += 1\n var_11 = max(var_11, var_9 - 1)\nprint(var_11)\nfor var_7 in var_1:\n print(var_7)\n```", "output": "FASTER 1.0442", "pair_id": "python_p02850_forward", "problem_id": "p02850", "language": "python", "direction": "forward", "speedup_ratio": 2.0622} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nfrom sys import stdin\n\n\ndef func_1():\n\n var_11 = stdin.readline\n var_2 = int(var_11())\n var_1 = []\n for var_6 in range(var_2):\n var_5 = int(\"\".join(var_11().strip().split(\" \")), 2)\n var_1.append(var_5)\n var_3 = []\n for var_6 in range(var_2):\n var_10 = list(map(int, var_11().split()))\n var_3.append(var_10)\n var_8 = float(\"-inf\")\n for var_9 in range(1, 1 << 10):\n var_12 = 0\n for var_7 in range(var_2):\n var_4 = bin(var_9 & var_1[var_7]).count(\"1\")\n var_12 += var_3[var_7][var_4]\n var_8 = max(var_12, var_8)\n print(var_8)\n\n\nif __name__ == \"__main__\":\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\nimport itertools\n\n\ndef func_2(var_4):\n return bin(eval(\"0b\" + str(var_4)))\n\n\ndef func_1():\n var_4 = int(sys.stdin.readline().rstrip())\n var_9 = [\n func_2(\"\".join(str(var_10) for var_10 in sys.stdin.readline().split()))\n for _ in range(var_4)\n ]\n var_8 = [\n [int(var_10) for var_10 in sys.stdin.readline().split()] for _ in range(var_4)\n ]\n var_3 = -(10**10)\n for var_6 in itertools.product(\"01\", repeat=10):\n var_6 = func_2(\"\".join(var_6))\n if var_6 == \"0b0\":\n continue\n var_7 = 0\n for var_2 in range(var_4):\n var_1 = var_9[var_2]\n var_5 = bin(eval(var_1) & eval(var_6)).count(\"1\")\n var_7 += var_8[var_2][var_5]\n var_3 = max(var_3, var_7)\n print(var_3)\n\n\nif __name__ == \"__main__\":\n\n func_1()\n```", "output": "SLOWER 5.45", "pair_id": "python_p03503_reversed", "problem_id": "p03503", "language": "python", "direction": "reversed", "speedup_ratio": 43.7144} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\nimport numpy as np\n\nvar_6 = int(eval(input()))\n\nvar_1 = [input().replace(\" \", \"\") for var_4 in range(var_6)]\n\nvar_7 = [list(map(int, input().split())) for var_4 in range(var_6)]\nvar_11 = -999999999999999\nfor var_4 in range(1, 1024):\n var_3 = format(var_4, \"010b\")\n var_9 = 0\n for var_2, var_8 in zip(var_1, var_7):\n var_10 = 0\n for var_5 in range(10):\n if var_2[var_5] == \"1\" and var_3[var_5] == \"1\":\n var_10 += 1\n var_9 += var_8[var_10]\n if var_9 > var_11:\n if var_9 == 0:\n print((str(var_4)))\n break\n var_11 = var_9\nprint(var_11)\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\n\nvar_7 = sys.stdin.readline\nfrom itertools import combinations\n\n\ndef func_3(var_10):\n for _ in range(var_10):\n yield list(map(int, var_7().split()))\n\n\ndef func_1(var_9, var_5, var_11):\n var_3 = len([0 for var_8 in var_9 if var_5[var_8] == 1])\n return var_11[var_3]\n\n\ndef func_2():\n var_10 = int(eval(var_7()))\n var_1 = list(func_3(var_10))\n var_2 = list(func_3(var_10))\n for var_6 in range(1, 11):\n for var_4 in combinations(list(range(10)), var_6):\n yield sum(\n func_1(var_4, var_5, var_11) for var_5, var_11 in zip(var_1, var_2)\n )\n\n\nprint((max(func_2())))\n```", "output": "FASTER 1.1194", "pair_id": "python_p03503_forward", "problem_id": "p03503", "language": "python", "direction": "forward", "speedup_ratio": 2.1726} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport copy\n\nvar_8 = int(eval(input()))\nvar_10 = set([var_6 for var_6 in range(1, 10**5)])\nvar_5 = []\nvar_11 = {}\nvar_9 = []\nfor var_6 in range(var_8 - 1):\n var_1, var_2 = list(map(int, input().split(\" \")))\n var_5.append([var_1, var_2])\n var_11.setdefault(var_1, []).append(var_2)\n var_9.append([])\nvar_9.append([])\nvar_9.append([])\nvar_7 = 0\nfor var_12 in range(1, var_8 + 1):\n var_14 = var_11.get(var_12, [])\n var_3 = 1\n for var_13 in var_14:\n if var_3 in var_9[var_12]:\n var_3 += 1\n else:\n pass\n var_9[var_13].append(var_3)\n if var_3 >= var_7:\n var_7 = var_3\n var_3 += 1\nprint(var_7)\nfor var_4 in var_5:\n print((var_9[var_4[1]][0]))\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\n\nvar_10 = sys.stdin.readline\nvar_4 = int(eval(var_10()))\nvar_9 = [[] for _ in range(var_4)]\nvar_3 = []\nfor _ in range(var_4 - 1):\n var_5, var_6 = list(map(int, var_10().split()))\n var_9[var_5 - 1].append(var_6 - 1)\n var_9[var_6 - 1].append(var_5 - 1)\n var_3.append((var_5 - 1, var_6 - 1))\nvar_1 = 0\nfor var_11 in range(var_4):\n var_1 = max(var_1, len(var_9[var_11]))\nvar_2 = dict()\nvar_8 = [-1] * var_4\nvar_14 = [0]\nvar_8[0] = var_1 + 1\nwhile var_14:\n var_15 = []\n for var_13 in var_14:\n var_7 = var_8[var_13]\n var_16 = 0\n for var_12 in var_9[var_13]:\n if var_8[var_12] == -1:\n if var_16 == var_7:\n var_16 += 1\n var_8[var_12] = var_16\n var_2[(var_13, var_12)] = var_16\n var_2[(var_12, var_13)] = var_16\n var_16 += 1\n var_15.append(var_12)\n var_14 = var_15\nprint(var_1)\nfor var_5, var_6 in var_3:\n print((var_2[(var_5, var_6)] + 1))\n```", "output": "FASTER 4.2291", "pair_id": "python_p02850_forward", "problem_id": "p02850", "language": "python", "direction": "forward", "speedup_ratio": 18.7534} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport numpy as np\nfrom itertools import product\n\nvar_6 = int(eval(input()))\nvar_2 = list(map(int, input().split()))\nvar_2 = np.array(var_2)\nvar_5 = [-1, 0, 1]\nvar_3 = 0\nfor var_7 in product(var_5, repeat=var_6):\n var_7 = np.array(var_7)\n var_1 = var_2 + var_7\n var_4 = var_1.cumprod()\n if var_4[-1] % 2 == 0:\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_2 = int(eval(input()))\n(*var_1,) = list(map(int, input().split()))\nvar_5 = 0\nfor var_3 in var_1:\n if var_3 % 2 == 0:\n var_5 += 1\nvar_4 = 3**var_2 - 2**var_5\nprint(var_4)\n```", "output": "FASTER 10.028", "pair_id": "python_p03568_forward", "problem_id": "p03568", "language": "python", "direction": "forward", "speedup_ratio": 1044.0343} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = input().split()\nvar_1 = int(var_1)\nvar_2 = int(var_2)\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = list(str(var_4))\n if (var_5[0] == var_5[4]) and (var_5[1] == var_5[3]):\n var_3 = var_3 + 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = [0] * (var_2 + 1)\nfor var_3 in range(1, var_2 + 1):\n if str(var_3) == str(var_3)[::-1]:\n var_4[var_3] = var_4[var_3 - 1] + 1\n else:\n var_4[var_3] = var_4[var_3 - 1]\nprint((var_4[var_2] - var_4[var_1 - 1]))\n```", "output": "SLOWER 1.5379", "pair_id": "python_p03416_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 2.9038} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_6 = 2019\nvar_1 = [0] * var_6\nvar_3 = 1\nvar_5 = var_4 = 0\nfor var_2 in input()[::-1]:\n var_1[var_4] += 1\n var_4 -= int(var_2) * var_3\n var_4 %= var_6\n var_5 += var_1[var_4]\n var_3 *= 10\n var_3 %= var_6\nprint(var_5)\n```\n\n=== Code B (Modified) ===\n```python\n\"\"\"\"\"\"\n\nfrom collections import defaultdict\n\n\ndef func_1(var_10, var_9):\n var_5 = 1\n yield var_5\n for _ in range(1, var_10):\n var_5 = (var_5 * 10) % var_9\n yield var_5\n\n\ndef func_2():\n var_3 = 2019\n var_4 = input()[::-1]\n\n var_1 = [\n int(var_11) * var_10 % var_3\n for var_11, var_10 in zip(var_4, func_1(len(var_4), var_3))\n ]\n\n var_2 = [0]\n for var_5 in var_1:\n var_2.append((var_2[-1] + var_5) % var_3)\n\n var_8 = defaultdict(int)\n for var_6 in var_2:\n var_8[var_6] += 1\n var_7 = sum(var_12 * (var_12 - 1) // 2 for var_12 in list(var_8.values()))\n print(var_7)\n\n\nfunc_2()\n```", "output": "SLOWER 1.5308", "pair_id": "python_p02702_reversed", "problem_id": "p02702", "language": "python", "direction": "reversed", "speedup_ratio": 2.8894} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\nimport itertools\n\n\ndef func_2(var_4):\n return bin(eval(\"0b\" + str(var_4)))\n\n\ndef func_1():\n var_4 = int(sys.stdin.readline().rstrip())\n var_9 = [\n func_2(\"\".join(str(var_10) for var_10 in sys.stdin.readline().split()))\n for _ in range(var_4)\n ]\n var_8 = [\n [int(var_10) for var_10 in sys.stdin.readline().split()] for _ in range(var_4)\n ]\n var_3 = -(10**10)\n for var_6 in itertools.product(\"01\", repeat=10):\n var_6 = func_2(\"\".join(var_6))\n if var_6 == \"0b0\":\n continue\n var_7 = 0\n for var_2 in range(var_4):\n var_1 = var_9[var_2]\n var_5 = bin(eval(var_1) & eval(var_6)).count(\"1\")\n var_7 += var_8[var_2][var_5]\n var_3 = max(var_3, var_7)\n print(var_3)\n\n\nif __name__ == \"__main__\":\n\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nfrom sys import stdin\n\n\ndef func_1():\n\n var_11 = stdin.readline\n var_2 = int(var_11())\n var_1 = []\n for var_6 in range(var_2):\n var_5 = int(\"\".join(var_11().strip().split(\" \")), 2)\n var_1.append(var_5)\n var_3 = []\n for var_6 in range(var_2):\n var_10 = list(map(int, var_11().split()))\n var_3.append(var_10)\n var_8 = float(\"-inf\")\n for var_9 in range(1, 1 << 10):\n var_12 = 0\n for var_7 in range(var_2):\n var_4 = bin(var_9 & var_1[var_7]).count(\"1\")\n var_12 += var_3[var_7][var_4]\n var_8 = max(var_12, var_8)\n print(var_8)\n\n\nif __name__ == \"__main__\":\n func_1()\n```", "output": "FASTER 5.45", "pair_id": "python_p03503_forward", "problem_id": "p03503", "language": "python", "direction": "forward", "speedup_ratio": 43.7144} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\ndef func_1():\n var_1, var_2 = list(map(int, input().split()))\n var_3 = 0\n for var_4 in range(var_1, var_2 + 1):\n\n if (var_4 % 10) == (var_4 // 10000 % 10) and (var_4 // 10 % 10) == (\n var_4 // 1000 % 10\n ):\n var_3 += 1\n print(var_3)\n\n\nif __name__ == \"__main__\":\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_5 in range(var_1, var_2 + 1):\n var_3 = str(var_5)\n if var_3[0] == var_3[-1] and var_3[1] == var_3[-2]:\n var_4 += 1\nprint(var_4)\n```", "output": "SLOWER 1.5725", "pair_id": "python_p03416_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 2.9741} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1 = list(map(int, input().split()))\nvar_2 = 0\nfor var_3 in range(var_1[0], var_1[1] + 1):\n var_4 = str(var_3)\n if var_4[0] == var_4[4] and var_4[1] == var_4[3]:\n var_2 += 1\nprint(var_2)\n```\n\n=== Code B (Modified) ===\n```python\nvar_4, var_3 = list(map(int, input().split()))\nvar_1 = 0\nfor var_2 in range(var_4, var_3 + 1):\n if str(var_2)[0] + str(var_2)[1] == str(var_2)[-1] + str(var_2)[-2]:\n var_1 += 1\nprint(var_1)\n```", "output": "SLOWER 1.6299", "pair_id": "python_p03416_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 3.0949} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n if str(var_4) == \"\".join(reversed(str(var_4))):\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nfrom sys import stdin\n\nvar_6 = lambda: list(map(int, stdin.readline().split()))\nvar_5 = lambda: list(map(int, stdin.readline().split()))\nvar_1, var_3 = var_6()\nvar_2 = 0\nfor var_4 in range(var_1, var_3 + 1):\n var_7 = str(var_4)\n if var_7 == var_7[::-1]:\n var_2 += 1\nprint(var_2)\n```", "output": "FASTER 1.0578", "pair_id": "python_p03416_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 2.0818} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport math\n\nvar_1, var_4 = (int(var_10) for var_10 in input().split())\nvar_2 = math.ceil(var_1 / 0.08)\nvar_3 = math.ceil((var_1 + 1) / 0.08)\n\"\"\"\"\"\"\nvar_5 = math.ceil(var_4 / 0.1)\nvar_6 = math.ceil((var_4 + 1) / 0.1)\n\"\"\"\"\"\"\nvar_7 = list(range(var_2, var_3))\nvar_8 = list(range(var_5, var_6))\nvar_9 = set(var_7) & set(var_8)\nif len(var_9) == 0:\n print((-1))\nelse:\n print((min(var_9)))\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nfor var_3 in range(1, 1009):\n if int(var_3 * 0.08) == var_1 and int(var_3 * 0.1) == var_2:\n print((int(var_3)))\n exit()\nprint(\"-1\")\n```", "output": "SLOWER 1.1926", "pair_id": "python_p02755_reversed", "problem_id": "p02755", "language": "python", "direction": "reversed", "speedup_ratio": 2.2856} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\ndef func_1():\n var_2 = int(input())\n var_1 = [int(var_6) for var_6 in input().split()]\n if var_2 == 1:\n return print(1 if var_1[0] % 2 == 0 else 2)\n var_3 = 0\n var_5 = (-1, 0, 1)\n from itertools import product\n\n for var_6 in product(range(3), repeat=var_2):\n var_4 = 1\n for var_7 in range(var_2):\n var_4 *= var_1[var_7] + var_5[var_6[var_7]]\n if var_4 % 2 == 0:\n var_3 += 1\n print(var_3)\n\n\nif __name__ == \"__main__\":\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nimport math\nimport string\n\n\ndef func_4():\n return list(map(int, input().split()))\n\n\ndef func_3(var_6, var_7):\n return math.factorial(var_6) // (\n math.factorial(var_6 - var_7) * math.factorial(var_7)\n )\n\n\ndef func_2(var_9):\n var_8 = []\n for var_5 in var_9:\n if not (var_5 in var_8):\n var_8.append(var_5)\n return len(var_9) != len(var_8)\n\n\ndef func_1(var_6):\n func_1 = []\n for var_4 in range(1, var_6 + 1):\n if var_6 % var_4 == 0:\n func_1.append(var_4)\n return func_1\n\n\nvar_2 = [-1, -1, -1, 0, 0, 1, 1, 1]\nvar_3 = [-1, 0, 1, -1, 1, -1, 0, 1]\nvar_6 = int(eval(input()))\nvar_1 = func_4()\nvar_10 = 1\nfor var_4 in range(len(var_1)):\n if var_1[var_4] % 2 == 0:\n var_10 *= 2\n else:\n var_10 *= 1\nprint((3 ** len(var_1) - var_10))\n```", "output": "FASTER 6.869", "pair_id": "python_p03568_forward", "problem_id": "p03568", "language": "python", "direction": "forward", "speedup_ratio": 116.8901} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\ndef func_1():\n var_2 = int(input())\n var_1 = [int(var_6) for var_6 in input().split()]\n if var_2 == 1:\n return print(1 if var_1[0] % 2 == 0 else 2)\n var_3 = 0\n var_5 = (-1, 0, 1)\n from itertools import product\n\n for var_6 in product(range(3), repeat=var_2):\n var_4 = 1\n for var_7 in range(var_2):\n var_4 *= var_1[var_7] + var_5[var_6[var_7]]\n if var_4 % 2 == 0:\n var_3 += 1\n print(var_3)\n\n\nif __name__ == \"__main__\":\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nfrom functools import reduce\nfrom itertools import product\n\nvar_2 = int(eval(input()))\n(*var_1,) = list(map(int, input().split()))\nvar_4 = 0\nfor var_7 in product([-1, 0, 1], repeat=var_2):\n var_6 = reduce(\n lambda var_8, var_9: var_8 * var_9,\n [var_3 + var_7[var_5] for var_5, var_3 in enumerate(var_1)],\n )\n if var_6 % 2 == 0:\n var_4 += 1\nprint(var_4)\n```", "output": "SLOWER 1.1995", "pair_id": "python_p03568_reversed", "problem_id": "p03568", "language": "python", "direction": "reversed", "speedup_ratio": 2.2966} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\nimport itertools\n\n\ndef func_2(var_4):\n return eval(\"0b\" + var_4)\n\n\ndef func_1():\n var_4 = int(sys.stdin.readline().rstrip())\n var_9 = [\n func_2(\"\".join(str(var_10) for var_10 in sys.stdin.readline().split()))\n for _ in range(var_4)\n ]\n var_8 = [\n [int(var_10) for var_10 in sys.stdin.readline().split()] for _ in range(var_4)\n ]\n var_3 = -(10**10)\n for var_6 in itertools.product(\"01\", repeat=10):\n var_6 = func_2(\"\".join(var_6))\n if var_6 == 0:\n continue\n var_7 = 0\n for var_2 in range(var_4):\n var_1 = var_9[var_2]\n var_5 = bin(var_1 & var_6).count(\"1\")\n var_7 += var_8[var_2][var_5]\n var_3 = max(var_3, var_7)\n print(var_3)\n\n\nif __name__ == \"__main__\":\n\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nfrom sys import stdin\n\n\ndef func_1():\n\n var_13 = stdin.readline\n var_2 = int(var_13())\n var_1 = []\n for var_6 in range(var_2):\n var_5 = list(map(int, var_13().split()))\n var_1.append(var_5)\n var_3 = []\n for var_6 in range(var_2):\n var_12 = list(map(int, var_13().split()))\n var_3.append(var_12)\n var_9 = -float(\"inf\")\n for var_6 in range(1 << 10):\n if var_6 == 0:\n continue\n else:\n var_11 = []\n for var_7 in range(10):\n if (var_6 >> var_7) & 1:\n var_11.append(var_7)\n var_10 = [0] * 10\n for var_7 in var_11:\n var_10[var_7] = 1\n var_14 = 0\n for var_7 in range(var_2):\n var_4 = 0\n for var_8 in range(10):\n if var_10[var_8] == 1 and var_1[var_7][var_8] == 1:\n var_4 += 1\n var_14 += var_3[var_7][var_4]\n var_9 = max(var_14, var_9)\n print(var_9)\n\n\nif __name__ == \"__main__\":\n func_1()\n```", "output": "FASTER 1.1909", "pair_id": "python_p03503_forward", "problem_id": "p03503", "language": "python", "direction": "forward", "speedup_ratio": 2.2829} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\ndef func_1():\n var_2, var_3, *var_1 = list(map(int, open(0).read().split()))\n var_4 = [0] * (var_3 + max(var_1[::2]))\n for var_7, var_6 in sorted(zip(*[iter(var_1)] * 2)):\n for var_5 in reversed(list(range(var_3))):\n var_4[var_5 + var_7] = max(var_4[var_5 + var_7], var_4[var_5] + var_6)\n print((max(var_4)))\n\n\nfunc_1()\n```\n\n=== Code B (Modified) ===\n```python\nfrom collections import Counter, defaultdict, deque\nfrom heapq import heappop, heappush, heapify\nimport sys, bisect, math, itertools, fractions, pprint\n\nsys.setrecursionlimit(10**8)\nvar_6 = 10**9 + 7\nvar_1 = float(\"inf\")\n\n\ndef func_1():\n return int(sys.stdin.readline())\n\n\ndef func_2():\n return list(map(int, sys.stdin.readline().split()))\n\n\nvar_7, var_9 = func_2()\nvar_13 = [func_2() for _ in range(var_7)]\nvar_13.sort(key=lambda var_14: var_14[1], reverse=True)\nvar_8 = 0\nvar_10 = min(var_7, 5)\nfor var_3 in range(var_10):\n var_2 = [[0] * (var_9 + 5) for _ in range(var_7 + 5)]\n for var_4 in range(var_7):\n var_12, var_11 = var_13[var_4]\n for var_5 in range(var_9):\n if var_5 < var_12 or var_3 == var_4:\n var_2[var_4 + 1][var_5] = var_2[var_4][var_5]\n else:\n var_2[var_4 + 1][var_5] = max(\n var_2[var_4][var_5], var_2[var_4][var_5 - var_12] + var_11\n )\n\n var_8 = max(var_2[var_7][var_9 - 1] + var_13[var_3][1], var_8)\nprint(var_8)\n```", "output": "SLOWER 2.938", "pair_id": "python_p02863_reversed", "problem_id": "p02863", "language": "python", "direction": "reversed", "speedup_ratio": 7.6633} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_4 = str(var_4)\n if var_4[0] == var_4[-1] and var_4[1] == var_4[-2]:\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n if list(str(var_4)) == list(reversed(str(var_4))):\n var_3 += 1\nprint(var_3)\n```", "output": "SLOWER 1.584", "pair_id": "python_p03416_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 2.9981} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\ndef func_1():\n from sys import setrecursionlimit, stdin\n from os import environ\n from collections import defaultdict, deque, Counter\n from math import ceil, floor, gcd\n from itertools import accumulate, combinations, combinations_with_replacement\n\n setrecursionlimit(10**6)\n var_7 = (\n (lambda *var_11: print(*var_11))\n if \"TERM_PROGRAM\" in environ\n else lambda *var_12: 0\n )\n var_8 = lambda: stdin.readline().rstrip()\n var_3 = lambda: list(map(int, var_8().split()))\n var_1 = lambda: int(var_8())\n var_4 = 10**9 + 7\n var_2 = 10**9 + 10\n var_9, var_10 = var_8().split()\n var_5 = int(var_9)\n var_6 = int(float(var_10) * 100 + 0.5)\n print(var_5 * var_6 // 100)\n\n\nfunc_1()\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = input().split()\nvar_1 = int(var_1)\nvar_3, var_4 = list(map(int, var_2.split(\".\")))\nvar_5 = var_1 * (var_3 * 100 + var_4)\nprint((int(var_5 // 100)))\n```", "output": "FASTER 1.782", "pair_id": "python_p02659_forward", "problem_id": "p02659", "language": "python", "direction": "forward", "speedup_ratio": 3.4391} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = str(var_4)\n if var_5[0] == var_5[4] and var_5[1] == var_5[3]:\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\n\n\ndef func_1(var_5):\n var_4 = 0\n for var_3 in range(1, var_5 + 1):\n if str(var_3) == str(var_3)[::-1]:\n var_4 += 1\n return var_4\n\n\nprint((func_1(var_2) - func_1(var_1 - 1)))\n```", "output": "SLOWER 1.8568", "pair_id": "python_p03416_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 3.622} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_5 in range(10):\n for var_6 in range(10):\n for var_7 in range(10):\n var_3 = 10000 * var_5 + 1000 * var_6 + 100 * var_7 + 10 * var_6 + var_5\n if var_1 <= var_3 <= var_2:\n var_4 += 1\nprint(var_4)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n if str(var_4) == \"\".join(reversed(str(var_4))):\n var_3 += 1\nprint(var_3)\n```", "output": "SLOWER 4.9018", "pair_id": "python_p03416_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 29.8943} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_4 = int(eval(input()))\nvar_2 = list(map(int, input().split()))\n\n\ndef func_1(var_1, var_8, var_3):\n if var_8 == var_4:\n var_9 = 1\n for var_5 in var_3:\n var_9 *= var_5\n return 1 if var_9 % 2 == 0 else 0\n var_6 = var_3.copy()\n var_6.append(var_1[var_8] - 1)\n var_5 = var_3.copy()\n var_5.append(var_1[var_8])\n var_7 = var_3.copy()\n var_7.append(var_1[var_8] + 1)\n return (\n func_1(var_1, var_8 + 1, var_6)\n + func_1(var_1, var_8 + 1, var_5)\n + func_1(var_1, var_8 + 1, var_7)\n )\n\n\nprint((func_1(var_2, 0, [])))\n```\n\n=== Code B (Modified) ===\n```python\nfrom itertools import product\n\nvar_6 = int(eval(input()))\nvar_1 = list(map(int, input().split()))\nvar_5 = 0\nfor var_2 in product((-1, 0, 1), repeat=var_6):\n var_7 = 1\n for var_3, var_4 in zip(var_1, var_2):\n var_7 *= var_3 + var_4\n if var_7 % 2 == 0:\n var_5 += 1\nprint(var_5)\n```", "output": "SLOWER 1.7458", "pair_id": "python_p03568_reversed", "problem_id": "p03568", "language": "python", "direction": "reversed", "speedup_ratio": 3.3539} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = list(reversed(list(str(var_4))))\n if var_5 == list(str(var_4)):\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_4 = {}\nvar_5 = 0\nfor var_6 in range(10000, 100000):\n var_3 = list(str(var_6))\n if var_3 == list(reversed(var_3)):\n var_5 += 1\n var_4[var_6] = var_5\nvar_1, var_2 = list(map(int, input().split()))\nprint((var_4[var_2] - var_4[var_1 - 1] if var_1 > 10000 else var_4[var_2]))\n```", "output": "SLOWER 1.9167", "pair_id": "python_p03416_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 3.7755} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\n\nvar_5 = sys.stdin.readline\nif __name__ == \"__main__\":\n var_1, var_3 = var_5().split()\n var_2 = int(var_1)\n var_4 = round(float(var_3) * 100)\n print((var_2 * var_4 // 100))\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\nimport math\nfrom collections import defaultdict\nfrom bisect import bisect_left, bisect_right\n\nsys.setrecursionlimit(10**7)\n\n\ndef func_4():\n return sys.stdin.readline()[:-1]\n\n\nvar_4 = 10**9 + 7\n\n\ndef func_1():\n return int(eval(func_4()))\n\n\ndef func_2():\n return list(map(int, func_4().split()))\n\n\ndef func_3(var_6, var_3):\n if var_6 <= 0:\n return [[] for _ in range(var_3)]\n elif var_3 == 1:\n return [func_1() for _ in range(var_6)]\n else:\n var_5 = [func_2() for _ in range(var_6)]\n return list(map(list, list(zip(*var_5))))\n\n\nvar_1, var_2 = list(map(str, func_4().split()))\nvar_1 = int(var_1)\nvar_2 = 100 * int(var_2[0]) + 10 * int(var_2[2]) + int(var_2[3])\nprint((var_1 * var_2 // 100))\n```", "output": "SLOWER 2.0389", "pair_id": "python_p02659_reversed", "problem_id": "p02659", "language": "python", "direction": "reversed", "speedup_ratio": 4.1093} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n if list(str(var_4)) == list(reversed(str(var_4))):\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_6 = str(var_4)\n var_5 = var_6[::-1]\n if var_6 == var_5:\n var_3 += 1\nprint(var_3)\n```", "output": "FASTER 1.15", "pair_id": "python_p03416_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 2.2191} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\n\nvar_8 = sys.stdin.readline\nvar_9 = int(eval(var_8()))\nvar_6 = []\nfor var_7 in range(var_9 - 1):\n var_1, var_3 = list(map(int, var_8().split()))\n var_6.append([var_1 - 1, var_3 - 1, var_7])\nvar_6.sort()\nvar_13 = [0] * (var_9)\nvar_2 = [0] * (var_9 - 1)\nvar_10 = 1\nvar_11 = 0\nfor var_5 in var_6:\n _from, var_12, var_7 = var_5\n if _from != var_11:\n var_10 = 1\n if var_13[_from] == var_10:\n var_10 += 1\n var_2[var_7] = var_10\n var_13[var_12] = var_10\n var_10 += 1\n var_11 = _from\nprint((max(var_2)))\nfor var_4 in var_2:\n print(var_4)\n```\n\n=== Code B (Modified) ===\n```python\nimport copy\n\nvar_8 = int(eval(input()))\nvar_10 = set([var_6 for var_6 in range(1, 10**5)])\nvar_5 = []\nvar_11 = {}\nvar_9 = []\nfor var_6 in range(var_8 - 1):\n var_1, var_2 = list(map(int, input().split(\" \")))\n var_5.append([var_1, var_2])\n var_11.setdefault(var_1, []).append(var_2)\n var_9.append([])\nvar_9.append([])\nvar_9.append([])\nvar_7 = 0\nfor var_12 in range(1, var_8 + 1):\n var_14 = var_11.get(var_12, [])\n var_3 = 1\n for var_13 in var_14:\n if var_3 in var_9[var_12]:\n var_3 += 1\n else:\n pass\n var_9[var_13].append(var_3)\n if var_3 >= var_7:\n var_7 = var_3\n var_3 += 1\nprint(var_7)\nfor var_4 in var_5:\n print((var_9[var_4[1]][0]))\n```", "output": "SLOWER 4.8454", "pair_id": "python_p02850_reversed", "problem_id": "p02850", "language": "python", "direction": "reversed", "speedup_ratio": 28.7486} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport copy\n\nvar_8 = int(eval(input()))\nvar_10 = set([var_6 for var_6 in range(1, 10**5)])\nvar_5 = []\nvar_11 = {}\nvar_9 = []\nfor var_6 in range(var_8 - 1):\n var_1, var_2 = list(map(int, input().split(\" \")))\n var_5.append([var_1, var_2])\n var_11.setdefault(var_1, []).append(var_2)\n var_9.append([])\nvar_9.append([])\nvar_9.append([])\nvar_7 = 0\nfor var_12 in range(1, var_8 + 1):\n var_14 = var_11.get(var_12, [])\n var_3 = 1\n for var_13 in var_14:\n if var_3 in var_9[var_12]:\n var_3 += 1\n else:\n pass\n var_9[var_13].append(var_3)\n if var_3 >= var_7:\n var_7 = var_3\n var_3 += 1\nprint(var_7)\nfor var_4 in var_5:\n print((var_9[var_4[1]][0]))\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\nfrom collections import deque\nimport numpy as np\n\n\ndef func_1():\n var_7 = int(sys.stdin.readline().rstrip())\n var_3 = np.array(sys.stdin.read().split(), dtype=np.int64).reshape(-1, 2)\n var_1 = [[] for _ in range(var_7 + 1)]\n for var_2, var_4 in var_3:\n var_1[var_2].append(var_4)\n var_1[var_4].append(var_2)\n var_9 = np.zeros(var_7 + 1, dtype=np.int64)\n var_6 = np.zeros(var_7 + 1, dtype=np.int64)\n var_10 = deque([1])\n while var_10:\n var_11 = var_10.popleft()\n var_8 = var_6[var_11]\n var_5 = 1\n for var_12 in var_1[var_11]:\n if var_12 == var_9[var_11]:\n continue\n var_9[var_12] = var_11\n if var_5 == var_8:\n var_5 += 1\n var_6[var_12] = var_5\n var_10.append(var_12)\n var_5 += 1\n print((np.amax(var_6)))\n for var_2, var_4 in var_3:\n if var_2 == var_9[var_4]:\n print((var_6[var_4]))\n else:\n print((var_6[var_2]))\n\n\nif __name__ == \"__main__\":\n func_1()\n```", "output": "FASTER 4.2049", "pair_id": "python_p02850_forward", "problem_id": "p02850", "language": "python", "direction": "forward", "speedup_ratio": 18.4421} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_4 = int(eval(input()))\nvar_1 = list(map(int, input().split()))\nvar_3 = 1\nfor var_2 in var_1:\n var_3 *= 2 if var_2 % 2 == 0 else 1\nprint((3**var_4 - var_3))\n```\n\n=== Code B (Modified) ===\n```python\nvar_4 = int(eval(input()))\nvar_2 = list(map(int, input().split()))\n\n\ndef func_1(var_1, var_8, var_3):\n if var_8 == var_4:\n var_9 = 1\n for var_5 in var_3:\n var_9 *= var_5\n return 1 if var_9 % 2 == 0 else 0\n var_6 = var_3.copy()\n var_6.append(var_1[var_8] - 1)\n var_5 = var_3.copy()\n var_5.append(var_1[var_8])\n var_7 = var_3.copy()\n var_7.append(var_1[var_8] + 1)\n return (\n func_1(var_1, var_8 + 1, var_6)\n + func_1(var_1, var_8 + 1, var_5)\n + func_1(var_1, var_8 + 1, var_7)\n )\n\n\nprint((func_1(var_2, 0, [])))\n```", "output": "SLOWER 8.4066", "pair_id": "python_p03568_reversed", "problem_id": "p03568", "language": "python", "direction": "reversed", "speedup_ratio": 339.3399} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport math\nimport string\n\n\ndef func_5():\n return list(map(int, input().split()))\n\n\ndef func_4(var_7, var_8):\n return math.factorial(var_7) // (\n math.factorial(var_7 - var_8) * math.factorial(var_8)\n )\n\n\ndef func_3(var_10):\n var_9 = []\n for var_5 in var_10:\n if not (var_5 in var_9):\n var_9.append(var_5)\n return len(var_10) != len(var_9)\n\n\ndef func_1(var_7):\n func_1 = []\n for var_4 in range(1, var_7 + 1):\n if var_7 % var_4 == 0:\n func_1.append(var_4)\n return func_1\n\n\nvar_2 = [-1, -1, -1, 0, 0, 1, 1, 1]\nvar_3 = [-1, 0, 1, -1, 1, -1, 0, 1]\nvar_7 = int(eval(input()))\nvar_1 = func_5()\n\n\ndef func_2(var_6):\n if len(var_6) == var_7:\n for var_4 in range(len(var_6)):\n if var_6[var_4] % 2 == 0:\n return 1\n return 0\n return (\n func_2(var_6 + [var_1[len(var_6)]])\n + func_2(var_6 + [var_1[len(var_6)] - 1])\n + func_2(var_6 + [var_1[len(var_6)] + 1])\n )\n\n\nprint((func_2([])))\n```\n\n=== Code B (Modified) ===\n```python\nvar_6 = int(eval(input()))\nvar_2 = list(map(int, input().split()))\nfrom itertools import product\n\nvar_5 = [-1, 0, 1]\nvar_3 = 0\nfor var_7 in product(var_5, repeat=var_6):\n var_1 = []\n for var_4 in range(var_6):\n var_1.append(var_7[var_4] + var_2[var_4])\n if any(var_8 % 2 == 0 for var_8 in var_1):\n var_3 += 1\nprint(var_3)\n```", "output": "SLOWER 2.1906", "pair_id": "python_p03568_reversed", "problem_id": "p03568", "language": "python", "direction": "reversed", "speedup_ratio": 4.5649} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n if str(var_4) == \"\".join(reversed(str(var_4))):\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_4 = {}\nvar_5 = 0\nfor var_6 in range(10000, 100000):\n var_3 = list(str(var_6))\n if var_3 == list(reversed(var_3)):\n var_5 += 1\n var_4[var_6] = var_5\nvar_1, var_2 = list(map(int, input().split()))\nprint((var_4[var_2] - var_4[var_1 - 1] if var_1 > 10000 else var_4[var_2]))\n```", "output": "SLOWER 2.4974", "pair_id": "python_p03416_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 5.6465} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\n\nvar_8 = sys.stdin.readline\n\n\ndef func_1():\n var_2 = int(eval(var_8()))\n var_1 = [int(var_8().replace(\" \", \"\"), 2) for _ in range(var_2)]\n var_3 = [list(map(int, var_8().split())) for _ in range(var_2)]\n var_4 = -(10**7) * var_2\n for var_7 in range(1, 1 << 10):\n var_10 = 0\n for var_9, var_6 in enumerate(var_1):\n var_5 = bin(var_7 & var_6).count(\"1\")\n var_10 += var_3[var_9][var_5]\n var_4 = max(var_4, var_10)\n print(var_4)\n\n\nif __name__ == \"__main__\":\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nfrom sys import stdin\n\n\ndef func_1():\n\n var_13 = stdin.readline\n var_2 = int(var_13())\n var_1 = []\n for var_6 in range(var_2):\n var_5 = list(map(int, var_13().split()))\n var_1.append(var_5)\n var_3 = []\n for var_6 in range(var_2):\n var_12 = list(map(int, var_13().split()))\n var_3.append(var_12)\n var_9 = -float(\"inf\")\n for var_6 in range(1 << 10):\n if var_6 == 0:\n continue\n else:\n var_11 = []\n for var_7 in range(10):\n if (var_6 >> var_7) & 1:\n var_11.append(var_7)\n var_10 = [0] * 10\n for var_7 in var_11:\n var_10[var_7] = 1\n var_14 = 0\n for var_7 in range(var_2):\n var_4 = 0\n for var_8 in range(10):\n if var_10[var_8] == 1 and var_1[var_7][var_8] == 1:\n var_4 += 1\n var_14 += var_3[var_7][var_4]\n var_9 = max(var_14, var_9)\n print(var_9)\n\n\nif __name__ == \"__main__\":\n func_1()\n```", "output": "SLOWER 1.9473", "pair_id": "python_p03503_reversed", "problem_id": "p03503", "language": "python", "direction": "reversed", "speedup_ratio": 3.8565} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_6 = int(eval(input()))\nvar_2 = list(map(int, input().split()))\nfrom itertools import product\n\nvar_5 = [-1, 0, 1]\nvar_3 = 0\nfor var_7 in product(var_5, repeat=var_6):\n var_1 = []\n for var_4 in range(var_6):\n var_1.append(var_7[var_4] + var_2[var_4])\n if any(var_8 % 2 == 0 for var_8 in var_1):\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_2 = int(eval(input()))\n(*var_1,) = list(map(int, input().split()))\nvar_5 = 0\nfor var_3 in var_1:\n if var_3 % 2 == 0:\n var_5 += 1\nvar_4 = 3**var_2 - 2**var_5\nprint(var_4)\n```", "output": "FASTER 9.836", "pair_id": "python_p03568_forward", "problem_id": "p03568", "language": "python", "direction": "forward", "speedup_ratio": 913.9804} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nfrom collections import defaultdict\n\nvar_8 = int(eval(input()))\nvar_1 = tuple(map(int, input().split()))\nvar_3 = True\nif var_8 % 3 == 0:\n var_5 = defaultdict(int)\n for var_2 in var_1:\n var_5[var_2] += 1\n var_7 = var_8 // 3\n var_10 = []\n for var_9, var_4 in list(var_5.items()):\n if var_4 % var_7 != 0:\n var_3 = False\n break\n else:\n for _ in range(var_4 // var_7):\n var_10.append(var_9)\n else:\n if any(\n var_10[(0 + var_6) % 3] ^ var_10[(1 + var_6) % 3] != var_10[(2 + var_6) % 3]\n for var_6 in range(3)\n ):\n var_3 = False\nelse:\n if any(var_2 != 0 for var_2 in var_1):\n var_3 = False\nprint((\"Yes\" if var_3 else \"No\"))\n```\n\n=== Code B (Modified) ===\n```python\n_, var_1 = open(0)\nvar_1, *var_2 = list(map(int, var_1.split()))\nfor var_2 in var_2:\n var_1 ^= var_2\nprint((\"YNeos\"[var_1 > 0 :: 2]))\n```", "output": "FASTER 1.2494", "pair_id": "python_p02975_forward", "problem_id": "p02975", "language": "python", "direction": "forward", "speedup_ratio": 2.3774} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport math\nimport string\n\n\ndef func_4():\n return list(map(int, input().split()))\n\n\ndef func_3(var_6, var_7):\n return math.factorial(var_6) // (\n math.factorial(var_6 - var_7) * math.factorial(var_7)\n )\n\n\ndef func_2(var_9):\n var_8 = []\n for var_5 in var_9:\n if not (var_5 in var_8):\n var_8.append(var_5)\n return len(var_9) != len(var_8)\n\n\ndef func_1(var_6):\n func_1 = []\n for var_4 in range(1, var_6 + 1):\n if var_6 % var_4 == 0:\n func_1.append(var_4)\n return func_1\n\n\nvar_2 = [-1, -1, -1, 0, 0, 1, 1, 1]\nvar_3 = [-1, 0, 1, -1, 1, -1, 0, 1]\nvar_6 = int(eval(input()))\nvar_1 = func_4()\nvar_10 = 1\nfor var_4 in range(len(var_1)):\n if var_1[var_4] % 2 == 0:\n var_10 *= 2\n else:\n var_10 *= 1\nprint((3 ** len(var_1) - var_10))\n```\n\n=== Code B (Modified) ===\n```python\nvar_2 = int(eval(input()))\nvar_1 = list(map(int, input().split()))\nvar_4 = 1\nfor var_3 in range(var_2):\n if var_1[var_3] % 2 == 0:\n var_4 *= 2\nprint((3**var_2 - var_4))\n```", "output": "FASTER 1.7077", "pair_id": "python_p03568_forward", "problem_id": "p03568", "language": "python", "direction": "forward", "speedup_ratio": 3.2664} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_4 = {}\nvar_5 = 0\nfor var_6 in range(10000, 100000):\n var_3 = list(str(var_6))\n if var_3 == list(reversed(var_3)):\n var_5 += 1\n var_4[var_6] = var_5\nvar_1, var_2 = list(map(int, input().split()))\nprint((var_4[var_2] - var_4[var_1 - 1] if var_1 > 10000 else var_4[var_2]))\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = list(str(var_4))\n if var_5 == list(reversed(var_5)):\n var_3 += 1\nprint(var_3)\n```", "output": "FASTER 2.3414", "pair_id": "python_p03416_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 5.068} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\ndef func_1():\n from sys import setrecursionlimit, stdin\n from os import environ\n from collections import defaultdict, deque, Counter\n from math import ceil, floor, gcd\n from itertools import accumulate, combinations, combinations_with_replacement\n\n setrecursionlimit(10**6)\n var_7 = (\n (lambda *var_11: print(*var_11))\n if \"TERM_PROGRAM\" in environ\n else lambda *var_12: 0\n )\n var_8 = lambda: stdin.readline().rstrip()\n var_3 = lambda: list(map(int, var_8().split()))\n var_1 = lambda: int(var_8())\n var_4 = 10**9 + 7\n var_2 = 10**9 + 10\n var_9, var_10 = var_8().split()\n var_5 = int(var_9)\n var_6 = int(float(var_10) * 100 + 0.5)\n print(var_5 * var_6 // 100)\n\n\nfunc_1()\n```\n\n=== Code B (Modified) ===\n```python\nimport decimal\n\n\ndef func_1():\n var_1, var_2 = list(map(decimal.Decimal, input().split()))\n print((var_1 * var_2 // 1))\n\n\nif __name__ == \"__main__\":\n func_1()\n```", "output": "FASTER 1.7718", "pair_id": "python_p02659_forward", "problem_id": "p02659", "language": "python", "direction": "forward", "speedup_ratio": 3.4148} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nfrom collections import deque\n\nvar_9 = int(eval(input()))\nvar_6 = {var_7: dict() for var_7 in range(var_9)}\nvar_2 = [0] * (var_9 - 1)\nvar_4 = [0] * (var_9 - 1)\nfor var_7 in range(var_9 - 1):\n var_1, var_3 = list(map(int, input().split()))\n var_2[var_7] = var_1 - 1\n var_4[var_7] = var_3 - 1\n var_6[var_1 - 1][var_3 - 1] = -1\n var_6[var_3 - 1][var_1 - 1] = -1\nvar_8 = max([len(var_6[var_1]) for var_1 in range(var_9)])\nvar_13 = [-1] * var_9\nvar_13[0] = var_8 - 1\n\nvar_12 = deque([0])\nwhile len(var_12) > 0:\n var_10 = var_12.popleft()\n var_5 = var_13[var_10]\n for var_11 in list(var_6[var_10].keys()):\n if var_13[var_11] != -1:\n continue\n var_5 += 1\n var_5 %= var_8\n\n var_6[var_10][var_11] = var_5\n var_6[var_11][var_10] = var_5\n var_13[var_11] = var_5\n var_12.append(var_11)\nprint(var_8)\nfor var_7 in range(var_9 - 1):\n print((var_6[var_2[var_7]][var_4[var_7]] + 1))\n```\n\n=== Code B (Modified) ===\n```python\nimport copy\n\nvar_8 = int(eval(input()))\nvar_10 = set([var_6 for var_6 in range(1, 10**5)])\nvar_5 = []\nvar_11 = {}\nvar_9 = []\nfor var_6 in range(var_8 - 1):\n var_1, var_2 = list(map(int, input().split(\" \")))\n var_5.append([var_1, var_2])\n var_11.setdefault(var_1, []).append(var_2)\n var_9.append([])\nvar_9.append([])\nvar_9.append([])\nvar_7 = 0\nfor var_12 in range(1, var_8 + 1):\n var_14 = var_11.get(var_12, [])\n var_3 = 1\n for var_13 in var_14:\n if var_3 in var_9[var_12]:\n var_3 += 1\n else:\n pass\n var_9[var_13].append(var_3)\n if var_3 >= var_7:\n var_7 = var_3\n var_3 += 1\nprint(var_7)\nfor var_4 in var_5:\n print((var_9[var_4[1]][0]))\n```", "output": "SLOWER 4.1649", "pair_id": "python_p02850_reversed", "problem_id": "p02850", "language": "python", "direction": "reversed", "speedup_ratio": 17.9377} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1 = list(map(int, input().split()))\nvar_2 = 0\nfor var_3 in range(var_1[0], var_1[1] + 1):\n var_4 = str(var_3)\n if var_4[0] == var_4[4] and var_4[1] == var_4[3]:\n var_2 += 1\nprint(var_2)\n```\n\n=== Code B (Modified) ===\n```python\nvar_10 = []\nvar_10 = input().rstrip().split(\" \")\nvar_1 = int(var_10[0])\nvar_3 = int(var_10[1])\nvar_2 = 0\nvar_6 = var_1\nwhile var_6 <= var_3:\n var_4 = var_6 // 10000\n var_5 = (var_6 - var_4 * 10000) // 1000\n var_7 = var_6 // 100\n var_8 = (var_6 - var_7 * 100) // 10\n var_9 = var_6 % 10\n if (var_4 == var_9) and (var_5 == var_8):\n var_2 += 1\n var_6 += 1\nprint(var_2)\n```", "output": "SLOWER 1.0978", "pair_id": "python_p03416_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 2.1403} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\nimport itertools\n\n\ndef func_2(var_4):\n return eval(\"0b\" + var_4)\n\n\ndef func_1():\n var_4 = int(sys.stdin.readline().rstrip())\n var_9 = [\n func_2(\"\".join(str(var_10) for var_10 in sys.stdin.readline().split()))\n for _ in range(var_4)\n ]\n var_8 = [\n [int(var_10) for var_10 in sys.stdin.readline().split()] for _ in range(var_4)\n ]\n var_3 = -(10**10)\n for var_6 in itertools.product(\"01\", repeat=10):\n var_6 = func_2(\"\".join(var_6))\n if var_6 == 0:\n continue\n var_7 = 0\n for var_2 in range(var_4):\n var_1 = var_9[var_2]\n var_5 = bin(var_1 & var_6).count(\"1\")\n var_7 += var_8[var_2][var_5]\n var_3 = max(var_3, var_7)\n print(var_3)\n\n\nif __name__ == \"__main__\":\n\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\n\nvar_7 = sys.stdin.readline\nfrom itertools import combinations\n\n\ndef func_3(var_10):\n for _ in range(var_10):\n yield list(map(int, var_7().split()))\n\n\ndef func_1(var_9, var_5, var_11):\n var_3 = sum(1 if var_5[var_8] == 1 else 0 for var_8 in var_9)\n return var_11[var_3]\n\n\ndef func_2():\n var_10 = int(eval(var_7()))\n var_1 = list(func_3(var_10))\n var_2 = list(func_3(var_10))\n for var_6 in range(1, 11):\n for var_4 in combinations(list(range(10)), var_6):\n yield sum(\n func_1(var_4, var_5, var_11) for var_5, var_11 in zip(var_1, var_2)\n )\n\n\nprint((max(func_2())))\n```", "output": "FASTER 1.4756", "pair_id": "python_p03503_forward", "problem_id": "p03503", "language": "python", "direction": "forward", "speedup_ratio": 2.7809} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\n\nsys.setrecursionlimit(2147483647)\nvar_2 = float(\"inf\")\nvar_3 = 10**9 + 7\nvar_10 = lambda: sys.stdin.readline().rstrip()\n\n\ndef func_1():\n var_11, var_4 = list(map(int, var_10().split()))\n var_1 = [tuple(map(int, var_10().split())) for _ in range(var_11)]\n var_1.sort()\n var_8 = [0] * var_4\n var_6 = -var_2\n for var_9 in range(var_11):\n var_5, var_7 = var_1[var_9]\n var_12 = var_8[:]\n for var_13 in range(var_4):\n if var_13 + var_5 < var_4:\n var_12[var_13 + var_5] = max(\n var_12[var_13 + var_5], var_8[var_13] + var_7\n )\n else:\n var_6 = max(var_6, var_8[var_13] + var_7)\n var_8 = var_12\n print((max(var_6, max(var_8))))\n\n\nfunc_1()\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\nfrom collections import deque\n\nvar_1 = int(10e10)\nvar_2 = -var_1\nvar_12 = 1000000007\nsys.setrecursionlimit(1000000)\n\n\ndef func_2():\n return list(map(int, input().split()))\n\n\ndef func_4():\n return input().split()\n\n\ndef func_1():\n return int(sys.stdin.readline())\n\n\ndef func_3():\n return eval(input())\n\n\nvar_3, var_4 = func_2()\nvar_6 = [func_2() for var_10 in range(var_3)]\nvar_6.sort()\nvar_7 = 0\nvar_9 = [[0] * var_4 for var_10 in range(var_3 + 1)]\nfor var_10 in range(1, var_3 + 1):\n var_5, var_8 = var_6[var_10 - 1]\n for var_11 in range(var_4):\n if 0 <= var_11 - var_5 < var_4:\n var_9[var_10][var_11] = max(\n var_9[var_10 - 1][var_11], var_9[var_10 - 1][var_11 - var_5] + var_8\n )\n else:\n var_9[var_10][var_11] = var_9[var_10 - 1][var_11]\n else:\n var_7 = max(var_7, var_9[var_10 - 1][-1] + var_8)\nprint(var_7)\n```", "output": "SLOWER 1.125", "pair_id": "python_p02863_reversed", "problem_id": "p02863", "language": "python", "direction": "reversed", "speedup_ratio": 2.181} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\nimport math\nfrom collections import defaultdict\nfrom bisect import bisect_left, bisect_right\n\nsys.setrecursionlimit(10**7)\n\n\ndef func_4():\n return sys.stdin.readline()[:-1]\n\n\nvar_4 = 10**9 + 7\n\n\ndef func_1():\n return int(eval(func_4()))\n\n\ndef func_2():\n return list(map(int, func_4().split()))\n\n\ndef func_3(var_6, var_3):\n if var_6 <= 0:\n return [[] for _ in range(var_3)]\n elif var_3 == 1:\n return [func_1() for _ in range(var_6)]\n else:\n var_5 = [func_2() for _ in range(var_6)]\n return list(map(list, list(zip(*var_5))))\n\n\nfrom decimal import getcontext, Decimal\n\ngetcontext().prec = 28\nvar_1, var_2 = list(map(str, func_4().split()))\nvar_1 = int(var_1)\nvar_2 = Decimal(var_2)\nprint((int(var_1 * var_2)))\n```\n\n=== Code B (Modified) ===\n```python\nimport decimal\n\nvar_1, var_2 = (decimal.Decimal(var_3) for var_3 in input().split())\nprint((int(var_1 * var_2)))\n```", "output": "FASTER 2.232", "pair_id": "python_p02659_forward", "problem_id": "p02659", "language": "python", "direction": "forward", "speedup_ratio": 4.6978} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_5 in range(var_1, var_2 + 1):\n var_3 = str(var_5)\n if var_3[0] == var_3[-1] and var_3[1] == var_3[-2]:\n var_4 += 1\nprint(var_4)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n if list(str(var_4)) == list(reversed(str(var_4))):\n var_3 += 1\nprint(var_3)\n```", "output": "SLOWER 1.492", "pair_id": "python_p03416_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 2.8127} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\ndef func_1():\n var_2 = int(input())\n var_1 = [int(var_6) for var_6 in input().split()]\n if var_2 == 1:\n return print(1 if var_1[0] % 2 == 0 else 2)\n var_3 = 0\n var_5 = (-1, 0, 1)\n from itertools import product\n\n for var_6 in product(range(3), repeat=var_2):\n var_4 = 1\n for var_7 in range(var_2):\n var_4 *= var_1[var_7] + var_5[var_6[var_7]]\n if var_4 % 2 == 0:\n var_3 += 1\n print(var_3)\n\n\nif __name__ == \"__main__\":\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nimport numpy as np\nfrom itertools import product\n\nvar_6 = int(eval(input()))\nvar_2 = list(map(int, input().split()))\nvar_2 = np.array(var_2)\nvar_5 = [-1, 0, 1]\nvar_3 = 0\nfor var_7 in product(var_5, repeat=var_6):\n var_7 = np.array(var_7)\n var_1 = var_2 + var_7\n var_4 = var_1.cumprod()\n if var_4[-1] % 2 == 0:\n var_3 += 1\nprint(var_3)\n```", "output": "SLOWER 1.466", "pair_id": "python_p03568_reversed", "problem_id": "p03568", "language": "python", "direction": "reversed", "speedup_ratio": 2.7626} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nfrom sys import stdin\n\n\ndef func_1():\n\n var_11 = stdin.readline\n var_2 = int(var_11())\n var_1 = []\n for var_6 in range(var_2):\n var_5 = int(\"\".join(var_11().strip().split(\" \")), 2)\n var_1.append(var_5)\n var_3 = []\n for var_6 in range(var_2):\n var_10 = list(map(int, var_11().split()))\n var_3.append(var_10)\n var_8 = float(\"-inf\")\n for var_9 in range(1, 1 << 10):\n var_12 = 0\n for var_7 in range(var_2):\n var_4 = bin(var_9 & var_1[var_7]).count(\"1\")\n var_12 += var_3[var_7][var_4]\n var_8 = max(var_12, var_8)\n print(var_8)\n\n\nif __name__ == \"__main__\":\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\nimport numpy as np\n\nvar_5 = sys.stdin.readline\n\nvar_7 = int(eval(var_5()))\n\nvar_1 = [var_5().replace(\" \", \"\") for var_4 in range(var_7)]\n\nvar_8 = [list(map(int, var_5().split())) for var_4 in range(var_7)]\n\n\nvar_12 = -999999999999999\n\nfor var_4 in range(1, 1024):\n\n var_3 = format(var_4, \"010b\")\n\n var_10 = 0\n for var_2, var_9 in zip(var_1, var_8):\n\n var_11 = 0\n for var_6 in range(10):\n\n if var_2[var_6] == \"1\" and var_3[var_6] == \"1\":\n\n var_11 += 1\n\n var_10 += var_9[var_11]\n if var_10 > var_12:\n\n var_12 = var_10\nprint(var_12)\n```", "output": "SLOWER 2.8805", "pair_id": "python_p03503_reversed", "problem_id": "p03503", "language": "python", "direction": "reversed", "speedup_ratio": 7.3642} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_2 = int(eval(input()))\nvar_1 = list(map(int, input().split()))\nvar_4 = 1\nfor var_3 in range(var_2):\n if var_1[var_3] % 2 == 0:\n var_4 *= 2\nprint((3**var_2 - var_4))\n```\n\n=== Code B (Modified) ===\n```python\nimport math\nimport string\n\n\ndef func_4():\n return list(map(int, input().split()))\n\n\ndef func_3(var_6, var_7):\n return math.factorial(var_6) // (\n math.factorial(var_6 - var_7) * math.factorial(var_7)\n )\n\n\ndef func_2(var_9):\n var_8 = []\n for var_5 in var_9:\n if not (var_5 in var_8):\n var_8.append(var_5)\n return len(var_9) != len(var_8)\n\n\ndef func_1(var_6):\n func_1 = []\n for var_4 in range(1, var_6 + 1):\n if var_6 % var_4 == 0:\n func_1.append(var_4)\n return func_1\n\n\nvar_2 = [-1, -1, -1, 0, 0, 1, 1, 1]\nvar_3 = [-1, 0, 1, -1, 1, -1, 0, 1]\nvar_6 = int(eval(input()))\nvar_1 = func_4()\nvar_10 = 1\nfor var_4 in range(len(var_1)):\n if var_1[var_4] % 2 == 0:\n var_10 *= 2\n else:\n var_10 *= 1\nprint((3 ** len(var_1) - var_10))\n```", "output": "SLOWER 1.7077", "pair_id": "python_p03568_reversed", "problem_id": "p03568", "language": "python", "direction": "reversed", "speedup_ratio": 3.2664} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_5 = 0\nif var_5 == 0:\n var_8 = int(eval(input()))\n var_2 = []\n for var_4 in range(var_8):\n var_3 = list(map(int, input().split()))\n var_2.append(var_3)\n var_9 = []\n for var_4 in range(var_8):\n var_10 = list(map(int, input().split()))\n var_9.append(var_10)\nelif var_5 == 1:\n var_8 = 1\n var_2 = [[1, 1, 0, 1, 0, 0, 0, 1, 0, 1]]\n var_9 = [[3, 4, 5, 6, 7, 8, 9, -2, -3, 4, -2]]\nelif var_5 == 2:\n var_8 = 2\n var_2 = [[1, 1, 1, 1, 1, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 1, 1, 1, 1, 1]]\n var_9 = [\n [0, -2, -2, -2, -2, -2, -1, -1, -1, -1, -1],\n [0, -2, -2, -2, -2, -2, -1, -1, -1, -1, -1],\n ]\nelif var_5 == 3:\n var_8 = 3\n var_2 = [\n [1, 1, 1, 1, 1, 1, 0, 0, 1, 1],\n [0, 1, 0, 1, 1, 1, 1, 0, 1, 0],\n [1, 0, 1, 1, 0, 1, 0, 1, 0, 1],\n ]\n var_9 = [\n [-8, 6, -2, -8, -8, 4, 8, 7, -6, 2, 2],\n [-9, 2, 0, 1, 7, -5, 0, -2, -6, 5, 5],\n [6, -6, 7, -9, 6, -5, 8, 0, -9, -7, -7],\n ]\nimport itertools\n\nvar_13 = -(10**11)\nfor var_4 in itertools.product([0, 1], repeat=10):\n var_11 = list(var_4)\n var_12 = 0\n if sum(var_11) != 0:\n for var_7 in range(var_8):\n var_1 = 0\n for var_6 in range(10):\n var_1 = var_1 + var_11[var_6] * var_2[var_7][var_6]\n var_12 = var_12 + var_9[var_7][var_1]\n\n var_13 = max(var_12, var_13)\nprint(var_13)\n```\n\n=== Code B (Modified) ===\n```python\nfrom sys import stdin\n\n\ndef func_1():\n\n var_11 = stdin.readline\n var_2 = int(var_11())\n var_1 = []\n for var_6 in range(var_2):\n var_5 = int(\"\".join(var_11().strip().split(\" \")), 2)\n var_1.append(var_5)\n var_3 = []\n for var_6 in range(var_2):\n var_10 = list(map(int, var_11().split()))\n var_3.append(var_10)\n var_8 = float(\"-inf\")\n for var_9 in range(1, 1 << 10):\n var_12 = 0\n for var_7 in range(var_2):\n var_4 = bin(var_9 & var_1[var_7]).count(\"1\")\n var_12 += var_3[var_7][var_4]\n var_8 = max(var_12, var_8)\n print(var_8)\n\n\nif __name__ == \"__main__\":\n func_1()\n```", "output": "FASTER 3.2735", "pair_id": "python_p03503_forward", "problem_id": "p03503", "language": "python", "direction": "forward", "speedup_ratio": 9.6696} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\ndef func_1():\n from sys import setrecursionlimit, stdin\n from os import environ\n from collections import defaultdict, deque, Counter\n from math import ceil, floor, gcd\n from itertools import accumulate, combinations, combinations_with_replacement\n\n setrecursionlimit(10**6)\n var_7 = (\n (lambda *var_11: print(*var_11))\n if \"TERM_PROGRAM\" in environ\n else lambda *var_12: 0\n )\n var_8 = lambda: stdin.readline().rstrip()\n var_3 = lambda: list(map(int, var_8().split()))\n var_1 = lambda: int(var_8())\n var_4 = 10**9 + 7\n var_2 = 10**9 + 10\n var_9, var_10 = var_8().split()\n var_5 = int(var_9)\n var_10 = var_10.split(\".\")\n var_6 = int(var_10[0]) * 100\n if len(var_10) == 2:\n var_6 += int(var_10[1])\n print(var_5 * var_6 // 100)\n\n\nfunc_1()\n```\n\n=== Code B (Modified) ===\n```python\nimport math\nfrom decimal import Decimal\n\nvar_1, var_2 = list(map(Decimal, input().split()))\nprint((math.floor(var_1 * var_2)))\n```", "output": "FASTER 2.3027", "pair_id": "python_p02659_forward", "problem_id": "p02659", "language": "python", "direction": "forward", "speedup_ratio": 4.9339} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = [\n var_3 for var_3 in map(str, list(range(var_1, var_2 + 1))) if var_3 == var_3[::-1]\n]\nprint((len(var_4)))\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = list(reversed(list(str(var_4))))\n if var_5 == list(str(var_4)):\n var_3 += 1\nprint(var_3)\n```", "output": "SLOWER 2.3555", "pair_id": "python_p03416_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 5.1178} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nfrom sys import stdin\n\n\ndef func_1():\n\n var_13 = stdin.readline\n var_2 = int(var_13())\n var_1 = []\n for var_6 in range(var_2):\n var_5 = list(map(int, var_13().split()))\n var_1.append(var_5)\n var_3 = []\n for var_6 in range(var_2):\n var_12 = list(map(int, var_13().split()))\n var_3.append(var_12)\n var_9 = -float(\"inf\")\n for var_6 in range(1 << 10):\n if var_6 == 0:\n continue\n else:\n var_11 = []\n for var_7 in range(10):\n if (var_6 >> var_7) & 1:\n var_11.append(var_7)\n var_10 = [0] * 10\n for var_7 in var_11:\n var_10[var_7] = 1\n var_14 = 0\n for var_7 in range(var_2):\n var_4 = 0\n for var_8 in range(10):\n if var_10[var_8] == 1 and var_1[var_7][var_8] == 1:\n var_4 += 1\n var_14 += var_3[var_7][var_4]\n var_9 = max(var_14, var_9)\n print(var_9)\n\n\nif __name__ == \"__main__\":\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\n\nvar_8 = sys.stdin.readline\n\n\ndef func_1():\n var_2 = int(eval(var_8()))\n var_1 = [int(var_8().replace(\" \", \"\"), 2) for _ in range(var_2)]\n var_3 = [list(map(int, var_8().split())) for _ in range(var_2)]\n var_4 = -(10**7) * var_2\n for var_7 in range(1, 1 << 10):\n var_10 = 0\n for var_9, var_6 in enumerate(var_1):\n var_5 = bin(var_7 & var_6).count(\"1\")\n var_10 += var_3[var_9][var_5]\n var_4 = max(var_4, var_10)\n print(var_4)\n\n\nif __name__ == \"__main__\":\n func_1()\n```", "output": "FASTER 1.9473", "pair_id": "python_p03503_forward", "problem_id": "p03503", "language": "python", "direction": "forward", "speedup_ratio": 3.8565} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_6, var_7 = list(map(int, input().split()))\nvar_1 = [list(map(int, input().split())) for _ in range(var_6)]\nvar_1.sort()\nvar_3 = [(6007) * [0] for _ in range(var_6 + 1)]\nvar_3[0][0] = 0\nvar_2 = 0\nfor var_4 in range(var_6):\n for var_5 in range(6007):\n var_3[var_4 + 1][var_5] = max(var_3[var_4 + 1][var_5], var_3[var_4][var_5])\n if var_5 < var_7:\n var_3[var_4 + 1][var_5 + var_1[var_4][0]] = max(\n var_3[var_4][var_5] + var_1[var_4][1],\n var_3[var_4][var_5 + var_1[var_4][0]],\n )\n var_2 = max(var_2, var_3[var_4 + 1][var_5])\nprint(var_2)\n```\n\n=== Code B (Modified) ===\n```python\nfrom collections import Counter, defaultdict, deque\nfrom heapq import heappop, heappush, heapify\nimport sys, bisect, math, itertools, fractions, pprint\n\nsys.setrecursionlimit(10**8)\nvar_6 = 10**9 + 7\nvar_1 = float(\"inf\")\n\n\ndef func_1():\n return int(sys.stdin.readline())\n\n\ndef func_2():\n return list(map(int, sys.stdin.readline().split()))\n\n\nvar_7, var_9 = func_2()\nvar_13 = [func_2() for _ in range(var_7)]\nvar_13.sort(key=lambda var_14: var_14[1], reverse=True)\nvar_8 = 0\nvar_10 = min(var_7, 5)\nfor var_3 in range(var_10):\n var_2 = [[0] * (var_9 + 5) for _ in range(var_7 + 5)]\n for var_4 in range(var_7):\n var_12, var_11 = var_13[var_4]\n for var_5 in range(var_9):\n if var_5 < var_12 or var_3 == var_4:\n var_2[var_4 + 1][var_5] = var_2[var_4][var_5]\n else:\n var_2[var_4 + 1][var_5] = max(\n var_2[var_4][var_5], var_2[var_4][var_5 - var_12] + var_11\n )\n\n var_8 = max(var_2[var_7][var_9 - 1] + var_13[var_3][1], var_8)\nprint(var_8)\n```", "output": "FASTER 4.0812", "pair_id": "python_p02863_forward", "problem_id": "p02863", "language": "python", "direction": "forward", "speedup_ratio": 16.9267} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_6 = str(var_4)\n var_5 = var_6[::-1]\n if var_6 == var_5:\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = [0] * (var_2 + 1)\nfor var_3 in range(1, var_2 + 1):\n if str(var_3) == str(var_3)[::-1]:\n var_4[var_3] = var_4[var_3 - 1] + 1\n else:\n var_4[var_3] = var_4[var_3 - 1]\nprint((var_4[var_2] - var_4[var_1 - 1]))\n```", "output": "SLOWER 1.6919", "pair_id": "python_p03416_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 3.2308} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = [0] * (var_2 + 1)\nfor var_3 in range(1, var_2 + 1):\n if str(var_3) == str(var_3)[::-1]:\n var_4[var_3] = var_4[var_3 - 1] + 1\n else:\n var_4[var_3] = var_4[var_3 - 1]\nprint((var_4[var_2] - var_4[var_1 - 1]))\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_6 = str(var_4)\n var_5 = var_6[::-1]\n if var_6 == var_5:\n var_3 += 1\nprint(var_3)\n```", "output": "FASTER 1.6919", "pair_id": "python_p03416_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 3.2308} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\nfrom collections import deque\n\nvar_13 = sys.stdin.readline\nvar_2 = int(eval(var_13()))\nvar_5 = [[] for _ in range(var_2)]\nvar_3 = [-1] * var_2\nfor var_12 in range(var_2 - 1):\n var_6, var_8 = list(map(int, var_13().split()))\n var_5[var_6 - 1].append((var_12, var_8 - 1))\n\n\nvar_4 = deque([(0, -1)])\nvar_1 = [-1] * (var_2 - 1)\nvar_11 = 0\nwhile var_4:\n var_14, var_10 = var_4.pop()\n var_9 = 1\n for var_12, var_15 in var_5[var_14]:\n if var_9 == var_10:\n var_9 += 1\n var_1[var_12] = var_9\n var_4.appendleft((var_15, var_9))\n var_9 += 1\n var_11 = max(var_11, var_9 - 1)\nprint(var_11)\nfor var_7 in var_1:\n print(var_7)\n```\n\n=== Code B (Modified) ===\n```python\nfrom collections import deque\n\n\ndef func_2(var_9, var_2, var_4):\n\n var_6 = {var_7: dict() for var_7 in range(var_9)}\n for var_7 in range(var_9 - 1):\n var_1, var_3 = var_2[var_7] - 1, var_4[var_7] - 1\n var_6[var_1][var_3] = -1\n var_6[var_3][var_1] = -1\n var_8 = max([len(var_6[var_1]) for var_1 in range(var_9)])\n var_14 = [-1] * var_9\n var_14[0] = var_8 - 1\n\n var_12 = deque([0])\n while len(var_12) > 0:\n var_10 = var_12.popleft()\n var_5 = var_14[var_10]\n for var_11 in list(var_6[var_10].keys()):\n if var_14[var_11] != -1:\n continue\n var_5 += 1\n var_5 %= var_8\n\n var_6[var_10][var_11] = var_5\n var_6[var_11][var_10] = var_5\n var_14[var_11] = var_5\n var_12.append(var_11)\n var_13 = [0] * (var_9 - 1)\n for var_7 in range(var_9 - 1):\n var_13[var_7] = var_6[var_2[var_7] - 1][var_4[var_7] - 1] + 1\n return var_8, var_13\n\n\ndef func_1():\n var_9 = int(eval(input()))\n var_2 = [0] * (var_9 - 1)\n var_4 = [0] * (var_9 - 1)\n for var_7 in range(var_9 - 1):\n var_1, var_3 = list(map(int, input().split()))\n var_2[var_7] = var_1\n var_4[var_7] = var_3\n var_8, var_13 = func_2(var_9, var_2, var_4)\n print(var_8)\n for var_7 in range(var_9 - 1):\n print((var_13[var_7]))\n\n\ndef func_3():\n print((func_2(3, [1, 2], [2, 3])))\n print((func_2(8, [1, 2, 2, 2, 4, 5, 6], [2, 3, 4, 5, 7, 6, 8])))\n\n\nif __name__ == \"__main__\":\n\n func_1()\n```", "output": "SLOWER 1.0324", "pair_id": "python_p02850_reversed", "problem_id": "p02850", "language": "python", "direction": "reversed", "speedup_ratio": 2.0454} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = [\n var_3 for var_3 in map(str, list(range(var_1, var_2 + 1))) if var_3 == var_3[::-1]\n]\nprint((len(var_4)))\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().rstrip().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = list(map(int, list(str(var_4))))\n if var_5[0] == var_5[4] and var_5[1] == var_5[3]:\n var_3 += 1\nprint(var_3)\n```", "output": "SLOWER 2.3816", "pair_id": "python_p03416_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 5.2111} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = str(var_4)\n if var_5[0] == var_5[4] and var_5[1] == var_5[3]:\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_10 = []\nvar_10 = input().rstrip().split(\" \")\nvar_1 = int(var_10[0])\nvar_3 = int(var_10[1])\nvar_2 = 0\nvar_6 = var_1\nwhile var_6 <= var_3:\n var_4 = var_6 // 10000\n var_5 = (var_6 - var_4 * 10000) // 1000\n var_7 = var_6 // 100\n var_8 = (var_6 - var_7 * 100) // 10\n var_9 = var_6 % 10\n if (var_4 == var_9) and (var_5 == var_8):\n var_2 += 1\n var_6 += 1\nprint(var_2)\n```", "output": "SLOWER 1.0752", "pair_id": "python_p03416_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 2.107} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_6 = str(var_4)\n var_5 = var_6[::-1]\n if var_6 == var_5:\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().rstrip().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = list(map(int, list(str(var_4))))\n if var_5[0] == var_5[4] and var_5[1] == var_5[3]:\n var_3 += 1\nprint(var_3)\n```", "output": "SLOWER 1.4326", "pair_id": "python_p03416_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 2.6994} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\nfrom operator import itemgetter\nfrom heapq import heapify, heappop, heappush\n\nvar_1 = int(10e15)\nvar_2 = -var_1\nvar_11 = 1000000007\nsys.setrecursionlimit(1000000)\n\n\ndef func_2():\n return list(map(int, input().split()))\n\n\ndef func_4():\n return input().split()\n\n\ndef func_1():\n return int(sys.stdin.readline())\n\n\ndef func_3():\n return eval(input())\n\n\nvar_3, var_4 = func_2()\nvar_5 = [func_2() for var_9 in range(var_3)]\nvar_5.sort(key=itemgetter(0))\n\nvar_8 = [[0] * (var_4 + 1 + 3000 + 1) for _ in range(var_3 + 1)]\nvar_6 = 0\nfor var_9 in range(var_3):\n for var_10 in range(var_4 + 1 + 3000 + 1):\n var_12, var_7 = var_5[var_9]\n if 0 <= var_10 - var_12 < var_4:\n var_8[var_9 + 1][var_10] = max(\n var_8[var_9][var_10], var_8[var_9][var_10 - var_12] + var_7\n )\n else:\n var_8[var_9 + 1][var_10] = var_8[var_9][var_10]\n var_6 = max(var_6, var_8[var_9 + 1][var_10])\nprint(var_6)\n```\n\n=== Code B (Modified) ===\n```python\nimport bisect\nimport sys\n\nsys.setrecursionlimit(10**6)\nvar_17 = sys.stdout.write\nvar_7 = lambda *var_15: print(*var_15) if var_1 else 0\nvar_1 = True\n\n\ndef func_1(var_10=sys.stdin.readline):\n var_12 = lambda: var_10().rstrip()\n var_3 = lambda: list(map(int, var_12().split()))\n var_2 = lambda: int(var_12())\n var_4 = lambda var_18: [var_3() for _ in range(var_18)]\n var_14, var_16 = var_3()\n var_5 = var_4(var_14)\n var_8 = [[0] * var_16 for _ in range(var_14)]\n for var_11 in range(1, var_14):\n for var_13 in range(1, var_16):\n if var_13 < var_5[var_11 - 1][0]:\n var_8[var_11][var_13] = var_8[var_11 - 1][var_13]\n else:\n var_8[var_11][var_13] = max(\n var_8[var_11 - 1][var_13],\n var_8[var_11 - 1][var_13 - var_5[var_11 - 1][0]]\n + var_5[var_11 - 1][1],\n )\n var_9 = [[0] * var_16 for _ in range(var_14)]\n for var_11 in range(1, var_14):\n for var_13 in range(1, var_16):\n if var_13 < var_5[var_14 - var_11][0]:\n var_9[var_11][var_13] = var_9[var_11 - 1][var_13]\n else:\n var_9[var_11][var_13] = max(\n var_9[var_11 - 1][var_13],\n var_9[var_11 - 1][var_13 - var_5[var_14 - var_11][0]]\n + var_5[var_14 - var_11][1],\n )\n var_6 = 0\n for var_11 in range(var_14):\n for var_13 in range(var_16 - 1):\n var_6 = max(\n var_6,\n var_8[var_11][var_13]\n + var_9[var_14 - var_11 - 1][var_16 - var_13 - 1]\n + var_5[var_11][1],\n )\n print(var_6)\n\n\nif __name__ == \"__main__\":\n func_1()\n```", "output": "FASTER 4.4124", "pair_id": "python_p02863_forward", "problem_id": "p02863", "language": "python", "direction": "forward", "speedup_ratio": 21.2943} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\ndef func_1():\n var_2 = int(input())\n var_1 = [int(var_6) for var_6 in input().split()]\n if var_2 == 1:\n return print(1 if var_1[0] % 2 == 0 else 2)\n var_3 = 0\n var_5 = (-1, 0, 1)\n from itertools import product\n\n for var_6 in product(range(3), repeat=var_2):\n var_4 = 1\n for var_7 in range(var_2):\n var_4 *= var_1[var_7] + var_5[var_6[var_7]]\n if var_4 % 2 == 0:\n var_3 += 1\n print(var_3)\n\n\nif __name__ == \"__main__\":\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nvar_4 = int(eval(input()))\nvar_1 = list(map(int, input().split()))\nvar_3 = 1\nfor var_2 in var_1:\n var_3 *= 2 if var_2 % 2 == 0 else 1\nprint((3**var_4 - var_3))\n```", "output": "FASTER 8.6824", "pair_id": "python_p03568_forward", "problem_id": "p03568", "language": "python", "direction": "forward", "speedup_ratio": 410.8374} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_5 in range(var_1, var_2 + 1):\n var_3 = str(var_5)\n if var_3[0] == var_3[-1] and var_3[1] == var_3[-2]:\n var_4 += 1\nprint(var_4)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_3 in range(var_1, var_2 + 1):\n var_5 = list(str(var_3))\n var_6 = list(reversed(var_5))\n if var_5 == var_6:\n var_4 += 1\nprint(var_4)\n```", "output": "SLOWER 1.4002", "pair_id": "python_p03416_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 2.6394} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nfrom sys import stdin\n\n\ndef func_1():\n\n var_13 = stdin.readline\n var_2 = int(var_13())\n var_1 = []\n for var_6 in range(var_2):\n var_5 = list(map(int, var_13().split()))\n var_1.append(var_5)\n var_3 = []\n for var_6 in range(var_2):\n var_12 = list(map(int, var_13().split()))\n var_3.append(var_12)\n var_9 = -float(\"inf\")\n for var_6 in range(1 << 10):\n if var_6 == 0:\n continue\n else:\n var_11 = []\n for var_7 in range(10):\n if (var_6 >> var_7) & 1:\n var_11.append(var_7)\n var_10 = [0] * 10\n for var_7 in var_11:\n var_10[var_7] = 1\n var_14 = 0\n for var_7 in range(var_2):\n var_4 = 0\n for var_8 in range(10):\n if var_10[var_8] == 1 and var_1[var_7][var_8] == 1:\n var_4 += 1\n var_14 += var_3[var_7][var_4]\n var_9 = max(var_14, var_9)\n print(var_9)\n\n\nif __name__ == \"__main__\":\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nfrom sys import stdin\n\n\ndef func_1():\n\n var_11 = stdin.readline\n var_2 = int(var_11())\n var_1 = []\n for var_6 in range(var_2):\n var_5 = int(\"\".join(var_11().strip().split(\" \")), 2)\n var_1.append(var_5)\n var_3 = []\n for var_6 in range(var_2):\n var_10 = list(map(int, var_11().split()))\n var_3.append(var_10)\n var_8 = float(\"-inf\")\n for var_9 in range(1, 1 << 10):\n var_12 = 0\n for var_7 in range(var_2):\n var_4 = bin(var_9 & var_1[var_7]).count(\"1\")\n var_12 += var_3[var_7][var_4]\n var_8 = max(var_12, var_8)\n print(var_8)\n\n\nif __name__ == \"__main__\":\n func_1()\n```", "output": "FASTER 2.0856", "pair_id": "python_p03503_forward", "problem_id": "p03503", "language": "python", "direction": "forward", "speedup_ratio": 4.2446} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\ndef func_1(var_3):\n var_4 = int(var_3)\n for var_1 in range(var_4, 2 * var_4):\n for var_2 in range(2, int(var_1**0.5)):\n if var_1 % var_2 == 0:\n break\n else:\n return str(var_1)\n\n\nif __name__ == \"__main__\":\n import sys\n\n print((func_1(sys.stdin.read().strip())))\n```\n\n=== Code B (Modified) ===\n```python\nimport bisect, copy, heapq, math, sys\nfrom collections import *\nfrom functools import lru_cache\nfrom itertools import accumulate, combinations, permutations, product\n\n\ndef func_2():\n return sys.stdin.readline()[:-1]\n\n\ndef func_4(var_8):\n return [0] + list(accumulate(var_8))\n\n\ndef func_1(var_1, var_4):\n return -(-var_1 // var_4)\n\n\nsys.setrecursionlimit(5000000)\nvar_9 = pow(10, 9) + 7\nvar_2 = [chr(ord(\"a\") + var_6) for var_6 in range(26)]\nvar_5 = [[1, 0], [0, 1], [-1, 0], [0, -1]]\nvar_11 = int(eval(func_2()))\n\n\ndef func_3(var_10):\n if var_10 == 1:\n return False\n for var_7 in range(2, int(math.sqrt(var_10)) + 1):\n if var_10 % var_7 == 0:\n return False\n return True\n\n\nvar_3 = var_11\nwhile not func_3(var_3):\n var_3 += 1\nprint(var_3)\n```", "output": "SLOWER 1.4975", "pair_id": "python_p02819_reversed", "problem_id": "p02819", "language": "python", "direction": "reversed", "speedup_ratio": 2.8236} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().rstrip().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = list(map(int, list(str(var_4))))\n if var_5[0] == var_5[4] and var_5[1] == var_5[3]:\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_4 = str(var_4)\n if var_4 == var_4[::-1]:\n var_3 += 1\nprint(var_3)\n```", "output": "FASTER 1.536", "pair_id": "python_p03416_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 2.8999} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\nimport numpy as np\n\nvar_6 = int(eval(input()))\n\nvar_1 = [input().replace(\" \", \"\") for var_4 in range(var_6)]\n\nvar_7 = [list(map(int, input().split())) for var_4 in range(var_6)]\nvar_11 = -999999999999999\nfor var_4 in range(1, 1024):\n var_3 = format(var_4, \"010b\")\n var_9 = 0\n for var_2, var_8 in zip(var_1, var_7):\n var_10 = 0\n for var_5 in range(10):\n if var_2[var_5] == \"1\" and var_3[var_5] == \"1\":\n var_10 += 1\n var_9 += var_8[var_10]\n if var_9 > var_11:\n if var_9 == 0:\n print((str(var_4)))\n break\n var_11 = var_9\nprint(var_11)\n```\n\n=== Code B (Modified) ===\n```python\nfrom sys import stdin\n\n\ndef func_1():\n\n var_11 = stdin.readline\n var_2 = int(var_11())\n var_1 = []\n for var_6 in range(var_2):\n var_5 = int(\"\".join(var_11().strip().split(\" \")), 2)\n var_1.append(var_5)\n var_3 = []\n for var_6 in range(var_2):\n var_10 = list(map(int, var_11().split()))\n var_3.append(var_10)\n var_8 = float(\"-inf\")\n for var_9 in range(1, 1 << 10):\n var_12 = 0\n for var_7 in range(var_2):\n var_4 = bin(var_9 & var_1[var_7]).count(\"1\")\n var_12 += var_3[var_7][var_4]\n var_8 = max(var_12, var_8)\n print(var_8)\n\n\nif __name__ == \"__main__\":\n func_1()\n```", "output": "FASTER 2.3748", "pair_id": "python_p03503_forward", "problem_id": "p03503", "language": "python", "direction": "forward", "speedup_ratio": 5.1868} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_6 = int(eval(input()))\nimport sys\n\nsys.setrecursionlimit(10**6)\nvar_11 = [[] for _ in range(var_6)]\nfor var_4 in range(var_6 - 1):\n var_1, var_2 = list(map(int, input().split()))\n var_11[var_1 - 1].append((var_2 - 1, var_4))\n var_11[var_2 - 1].append((var_1 - 1, var_4))\nvar_5 = [0] * (var_6 - 1)\n\n\ndef func_1(var_8, var_10, var_9):\n var_3 = 1\n for var_7, var_4 in var_11[var_8]:\n if var_7 == var_9:\n continue\n if var_3 == var_10:\n var_3 += 1\n var_5[var_4] = var_3\n func_1(var_7, var_3, var_8)\n var_3 += 1\n\n\nfunc_1(0, -1, -1)\nprint((max(var_5)))\nfor var_4 in var_5:\n print(var_4)\n```\n\n=== Code B (Modified) ===\n```python\nvar_11 = int(eval(input()))\nvar_12 = {var_8: [] for var_8 in range(1, var_11 + 1)}\nvar_19 = [False for var_8 in range(var_11 + 1)]\nvar_16 = []\nfor _ in range(var_11 - 1):\n var_2, var_3 = list(map(int, input().split()))\n var_12[var_2].append(var_3)\n var_12[var_3].append(var_2)\n var_16.append((var_2, var_3))\nvar_9 = var_16[0][0]\nvar_19[var_9] = True\nvar_6 = []\nvar_7 = []\nvar_14 = {var_8: {} for var_8 in range(1, var_11 + 1)}\nvar_10 = [0 for var_8 in range(var_11 + 1)]\n\nvar_4 = 1\nfor var_5 in var_12[var_9]:\n var_19[var_5] = True\n var_14[var_9][var_5] = var_4\n var_14[var_5][var_9] = var_4\n var_10[var_5] = var_4\n var_4 += 1\n var_6.append(var_5)\nwhile var_6:\n for var_15 in var_6:\n var_13 = 1\n for var_5 in var_12[var_15]:\n if var_19[var_5] == False:\n var_19[var_5] = True\n if var_13 != var_10[var_15]:\n var_14[var_15][var_5] = var_13\n var_14[var_5][var_15] = var_13\n var_10[var_5] = var_13\n var_13 += 1\n var_7.append(var_5)\n else:\n var_13 += 1\n var_14[var_15][var_5] = var_13\n var_14[var_5][var_15] = var_13\n var_10[var_5] = var_13\n var_13 += 1\n var_7.append(var_5)\n if var_7:\n var_6 = var_7\n var_7 = []\n else:\n var_6 = []\n var_7 = []\nvar_1 = 0\nfor var_8 in range(1, var_11 + 1):\n var_1 = max(var_1, len(var_12[var_8]))\nprint(var_1)\nfor var_8 in range(var_11 - 1):\n var_17, var_18 = var_16[var_8][0], var_16[var_8][1]\n print((var_14[var_17][var_18]))\n```", "output": "SLOWER 1.0322", "pair_id": "python_p02850_reversed", "problem_id": "p02850", "language": "python", "direction": "reversed", "speedup_ratio": 2.0452} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_5 in range(10):\n for var_6 in range(10):\n for var_7 in range(10):\n var_3 = 10000 * var_5 + 1000 * var_6 + 100 * var_7 + 10 * var_6 + var_5\n if var_1 <= var_3 <= var_2:\n var_4 += 1\nprint(var_4)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().rstrip().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = list(map(int, list(str(var_4))))\n if var_5[0] == var_5[4] and var_5[1] == var_5[3]:\n var_3 += 1\nprint(var_3)\n```", "output": "SLOWER 5.5086", "pair_id": "python_p03416_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 45.5247} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_4 = int(eval(input()))\nvar_1 = list(map(int, input().split()))\nvar_3 = 1\nfor var_2 in var_1:\n var_3 *= 2 if var_2 % 2 == 0 else 1\nprint((3**var_4 - var_3))\n```\n\n=== Code B (Modified) ===\n```python\nimport math\nimport string\n\n\ndef func_4():\n return list(map(int, input().split()))\n\n\ndef func_3(var_6, var_7):\n return math.factorial(var_6) // (\n math.factorial(var_6 - var_7) * math.factorial(var_7)\n )\n\n\ndef func_2(var_9):\n var_8 = []\n for var_5 in var_9:\n if not (var_5 in var_8):\n var_8.append(var_5)\n return len(var_9) != len(var_8)\n\n\ndef func_1(var_6):\n func_1 = []\n for var_4 in range(1, var_6 + 1):\n if var_6 % var_4 == 0:\n func_1.append(var_4)\n return func_1\n\n\nvar_2 = [-1, -1, -1, 0, 0, 1, 1, 1]\nvar_3 = [-1, 0, 1, -1, 1, -1, 0, 1]\nvar_6 = int(eval(input()))\nvar_1 = func_4()\nvar_10 = 1\nfor var_4 in range(len(var_1)):\n if var_1[var_4] % 2 == 0:\n var_10 *= 2\n else:\n var_10 *= 1\nprint((3 ** len(var_1) - var_10))\n```", "output": "SLOWER 1.8134", "pair_id": "python_p03568_reversed", "problem_id": "p03568", "language": "python", "direction": "reversed", "speedup_ratio": 3.5147} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nfrom sys import stdin\n\n\ndef func_1():\n\n var_11 = stdin.readline\n var_2 = int(var_11())\n var_1 = []\n for var_6 in range(var_2):\n var_5 = int(\"\".join(var_11().strip().split(\" \")), 2)\n var_1.append(var_5)\n var_3 = []\n for var_6 in range(var_2):\n var_10 = list(map(int, var_11().split()))\n var_3.append(var_10)\n var_8 = float(\"-inf\")\n for var_9 in range(1, 1 << 10):\n var_12 = 0\n for var_7 in range(var_2):\n var_4 = bin(var_9 & var_1[var_7]).count(\"1\")\n var_12 += var_3[var_7][var_4]\n var_8 = max(var_12, var_8)\n print(var_8)\n\n\nif __name__ == \"__main__\":\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nfrom sys import stdin\n\n\ndef func_1():\n\n var_13 = stdin.readline\n var_2 = int(var_13())\n var_1 = []\n for var_6 in range(var_2):\n var_5 = list(map(int, var_13().split()))\n var_1.append(var_5)\n var_3 = []\n for var_6 in range(var_2):\n var_12 = list(map(int, var_13().split()))\n var_3.append(var_12)\n var_9 = -float(\"inf\")\n for var_6 in range(1 << 10):\n if var_6 == 0:\n continue\n else:\n var_11 = []\n for var_7 in range(10):\n if (var_6 >> var_7) & 1:\n var_11.append(var_7)\n var_10 = [0] * 10\n for var_7 in var_11:\n var_10[var_7] = 1\n var_14 = 0\n for var_7 in range(var_2):\n var_4 = 0\n for var_8 in range(10):\n if var_10[var_8] == 1 and var_1[var_7][var_8] == 1:\n var_4 += 1\n var_14 += var_3[var_7][var_4]\n var_9 = max(var_14, var_9)\n print(var_9)\n\n\nif __name__ == \"__main__\":\n func_1()\n```", "output": "SLOWER 2.0856", "pair_id": "python_p03503_reversed", "problem_id": "p03503", "language": "python", "direction": "reversed", "speedup_ratio": 4.2446} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\ndef func_1():\n from sys import setrecursionlimit, stdin\n from os import environ\n from collections import defaultdict, deque, Counter\n from math import ceil, floor, gcd\n from itertools import accumulate, combinations, combinations_with_replacement\n\n setrecursionlimit(10**6)\n var_7 = (\n (lambda *var_11: print(*var_11))\n if \"TERM_PROGRAM\" in environ\n else lambda *var_12: 0\n )\n var_8 = lambda: stdin.readline().rstrip()\n var_3 = lambda: list(map(int, var_8().split()))\n var_1 = lambda: int(var_8())\n var_4 = 10**9 + 7\n var_2 = 10**9 + 10\n var_9, var_10 = var_8().split()\n var_5 = int(var_9)\n var_10 = var_10.split(\".\")\n var_6 = int(var_10[0]) * 100\n if len(var_10) == 2:\n var_6 += int(var_10[1])\n print(var_5 * var_6 // 100)\n\n\nfunc_1()\n```\n\n=== Code B (Modified) ===\n```python\nimport math\n\nvar_1, var_2 = input().split()\nvar_1 = int(var_1)\nvar_3 = int(var_2[0] + var_2[2] + var_2[3])\nprint((int(var_1 * var_3) // 100))\n```", "output": "FASTER 2.1264", "pair_id": "python_p02659_forward", "problem_id": "p02659", "language": "python", "direction": "forward", "speedup_ratio": 4.3663} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_2 = var_2 / 0.1\nvar_3 = [var_4 + var_2 for var_4 in range(10)]\nfor var_4 in var_3:\n if int(var_4 * 0.08) == var_1:\n print((int(var_4)))\n exit()\nprint(\"-1\")\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_3 = list(map(int, input().split()))\nvar_2 = -1\nfor var_4 in range(10, 12501):\n if int(var_4 * 0.08) == var_1 and int(var_4 * 0.1) == var_3:\n var_2 = var_4\n break\nprint(var_2)\n```", "output": "SLOWER 5.3061", "pair_id": "python_p02755_reversed", "problem_id": "p02755", "language": "python", "direction": "reversed", "speedup_ratio": 39.5622} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\nimport math\nfrom collections import defaultdict\nfrom bisect import bisect_left, bisect_right\n\nsys.setrecursionlimit(10**7)\n\n\ndef func_4():\n return sys.stdin.readline()[:-1]\n\n\nvar_4 = 10**9 + 7\n\n\ndef func_1():\n return int(eval(func_4()))\n\n\ndef func_2():\n return list(map(int, func_4().split()))\n\n\ndef func_3(var_6, var_3):\n if var_6 <= 0:\n return [[] for _ in range(var_3)]\n elif var_3 == 1:\n return [func_1() for _ in range(var_6)]\n else:\n var_5 = [func_2() for _ in range(var_6)]\n return list(map(list, list(zip(*var_5))))\n\n\nvar_1, var_2 = list(map(str, func_4().split()))\nvar_1 = int(var_1)\nvar_2 = 100 * int(var_2[0]) + 10 * int(var_2[2]) + int(var_2[3])\nprint((var_1 * var_2 // 100))\n```\n\n=== Code B (Modified) ===\n```python\nimport math\nfrom decimal import Decimal\n\nvar_1, var_2 = list(map(Decimal, input().split()))\nprint((math.floor(var_1 * var_2)))\n```", "output": "FASTER 2.455", "pair_id": "python_p02659_forward", "problem_id": "p02659", "language": "python", "direction": "forward", "speedup_ratio": 5.4831} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\n\nvar_20 = sys.stdin.read\nvar_21 = sys.stdin.readline\nvar_22 = sys.stdin.readlines\nsys.setrecursionlimit(10**9)\nvar_2 = 1 << 60\nvar_5 = 1000000007\n\n\nvar_4 = 1000001\n\n\nclass Class_1:\n def __init__(self, var_13, var_19, var_12):\n self.l = var_13\n self.r = var_19\n self.idx = var_12\n\n\ndef func_4(var_12, var_24, var_10, var_15):\n while var_12 <= var_15:\n var_10[var_12] += var_24\n var_12 += var_12 & -var_12\n\n\ndef func_3(var_12, var_10, var_15):\n var_23 = 0\n while var_12:\n var_23 += var_10[var_12]\n var_12 -= var_12 & -var_12\n return var_23\n\n\ndef func_1(var_9, var_15, var_17, var_16):\n\n var_10 = [0] * (var_15 + 1)\n\n var_14 = [-1] * var_4\n\n var_8 = [0] * var_16\n var_18 = 0\n for var_11 in range(var_15):\n\n if var_14[var_9[var_11]] != -1:\n func_4(var_14[var_9[var_11]] + 1, -1, var_10, var_15)\n\n var_14[var_9[var_11]] = var_11\n func_4(var_11 + 1, 1, var_10, var_15)\n\n while var_18 < var_16 and var_17[var_18].r == var_11:\n var_8[var_17[var_18].idx] = func_3(\n var_17[var_18].r + 1, var_10, var_15\n ) - func_3(var_17[var_18].l, var_10, var_15)\n var_18 += 1\n\n for var_11 in range(var_16):\n print((var_8[var_11]))\n\n\ndef func_2():\n var_6, var_7 = list(map(int, var_21().split()))\n var_1 = list(map(int, var_21().split()))\n (*var_3,) = list(map(int, var_20().split()))\n var_17 = [0] * var_7\n for var_11, (var_13, var_19) in enumerate(zip(*[iter(var_3)] * 2)):\n var_17[var_11] = Class_1(var_13 - 1, var_19 - 1, var_11)\n var_17.sort(key=lambda var_25: var_25.r)\n func_1(var_1, var_6, var_17, var_7)\n return\n\n\nif __name__ == \"__main__\":\n func_2()\n```\n\n=== Code B (Modified) ===\n```python\nvar_4 = 19\nvar_7 = [0] * (2 ** (var_4 + 1) - 1)\n\n\ndef func_1(var_12, var_17):\n var_11 = 2**var_4 + var_12 - 1\n while var_11 >= 0:\n var_7[var_11] += var_17\n var_11 = (var_11 - 1) // 2\n\n\ndef func_2(var_8, var_9):\n var_13 = var_8 + (1 << var_4)\n var_15 = var_9 + (1 << var_4)\n var_16 = 0\n while var_13 < var_15:\n if var_13 % 2:\n var_16 += var_7[var_13 - 1]\n var_13 += 1\n if var_15 % 2:\n var_15 -= 1\n var_16 += var_7[var_15 - 1]\n var_13 >>= 1\n var_15 >>= 1\n return var_16\n\n\nvar_3, var_5 = map(int, input().split())\nvar_2 = [int(var_8) - 1 for var_8 in input().split()]\nvar_6 = [[] for _ in range(var_3)]\nfor var_11 in range(var_5):\n var_13, var_15 = map(int, input().split())\n var_6[var_15 - 1].append((var_13 - 1, var_11))\nvar_14 = [-1] * var_3\nvar_1 = [-1] * var_5\nfunc_1(1, var_3)\nfor var_15 in range(var_3):\n var_10 = var_2[var_15]\n func_1(var_14[var_10] + 2, -1)\n func_1(var_15 + 2, 1)\n var_14[var_10] = var_15\n for var_13, var_11 in var_6[var_15]:\n var_1[var_11] = func_2(var_13 + 2, 1 << var_4)\nprint(*var_1, sep=\"\\n\")\n```", "output": "FASTER 1.8145", "pair_id": "python_p02599_forward", "problem_id": "p02599", "language": "python", "direction": "forward", "speedup_ratio": 3.5173} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nfrom collections import Counter, defaultdict, deque\nfrom heapq import heappop, heappush, heapify\nimport sys, bisect, math, itertools, fractions, pprint\n\nsys.setrecursionlimit(10**8)\nvar_6 = 10**9 + 7\nvar_1 = float(\"inf\")\n\n\ndef func_1():\n return int(sys.stdin.readline())\n\n\ndef func_2():\n return list(map(int, sys.stdin.readline().split()))\n\n\nvar_7, var_9 = func_2()\nvar_13 = [func_2() for _ in range(var_7)]\nvar_13.sort(key=lambda var_14: var_14[1], reverse=True)\nvar_8 = 0\nvar_10 = min(var_7, 5)\nfor var_3 in range(var_10):\n var_2 = [[0] * (var_9 + 5) for _ in range(var_7 + 5)]\n for var_4 in range(var_7):\n var_12, var_11 = var_13[var_4]\n for var_5 in range(var_9):\n if var_5 < var_12 or var_3 == var_4:\n var_2[var_4 + 1][var_5] = var_2[var_4][var_5]\n else:\n var_2[var_4 + 1][var_5] = max(\n var_2[var_4][var_5], var_2[var_4][var_5 - var_12] + var_11\n )\n\n var_8 = max(var_2[var_7][var_9 - 1] + var_13[var_3][1], var_8)\nprint(var_8)\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\n\nvar_10 = sys.stdin.readline\nvar_2, var_3 = list(map(int, var_10().split()))\nvar_1 = [list(map(int, var_10().split())) for _ in range(var_2)]\nvar_8 = [[0 for _ in range(var_2 + 1)] for _ in range(var_3 + 1)]\n\nvar_13 = [[0 for _ in range(var_2 + 1)] for _ in range(var_3 + 1)]\nfor var_11 in range(var_2):\n var_4, var_6 = var_1[var_11]\n for var_15 in range(var_3):\n if var_4 > var_15:\n var_8[var_15][var_11 + 1] = var_8[var_15][var_11]\n var_13[var_15][var_11 + 1] = var_15\n else:\n if var_6 + var_8[var_15 - var_4][var_11] >= var_8[var_15][var_11]:\n var_8[var_15][var_11 + 1] = var_8[var_15 - var_4][var_11] + var_6\n var_13[var_15][var_11 + 1] = var_15 - var_4\n else:\n var_8[var_15][var_11 + 1] = var_8[var_15][var_11]\n var_13[var_15][var_11 + 1] = var_15\nvar_5 = var_8[var_3 - 1][var_2]\nvar_14 = [False] * var_2\nvar_7 = var_3 - 1\nfor var_9 in reversed(list(range(var_2))):\n if var_13[var_7][var_9 + 1] == var_7 - var_1[var_9][0]:\n var_14[var_9] = True\n var_7 = var_13[var_7][var_9 + 1]\nvar_12 = 0\nfor var_9 in range(var_2):\n if not var_14[var_9] and var_1[var_9][1] > var_12:\n var_12 = var_1[var_9][1]\nprint((var_5 + var_12))\n```", "output": "FASTER 1.1545", "pair_id": "python_p02863_forward", "problem_id": "p02863", "language": "python", "direction": "forward", "speedup_ratio": 2.226} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_6 in range(var_1, var_2 + 1):\n var_3 = str(var_6)\n var_5 = True\n for var_7 in range(len(var_3) // 2):\n if var_3[var_7] != var_3[-var_7 - 1] and var_5:\n var_5 = not var_5\n if var_5:\n var_4 += 1\nprint(var_4)\n```\n\n=== Code B (Modified) ===\n```python\nvar_4 = {}\nvar_5 = 0\nfor var_6 in range(10000, 100000):\n var_3 = list(str(var_6))\n if var_3 == list(reversed(var_3)):\n var_5 += 1\n var_4[var_6] = var_5\nvar_1, var_2 = list(map(int, input().split()))\nprint((var_4[var_2] - var_4[var_1 - 1] if var_1 > 10000 else var_4[var_2]))\n```", "output": "SLOWER 2.1137", "pair_id": "python_p03416_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 4.3279} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport math\nimport string\n\n\ndef func_5():\n return list(map(int, input().split()))\n\n\ndef func_4(var_7, var_8):\n return math.factorial(var_7) // (\n math.factorial(var_7 - var_8) * math.factorial(var_8)\n )\n\n\ndef func_3(var_10):\n var_9 = []\n for var_5 in var_10:\n if not (var_5 in var_9):\n var_9.append(var_5)\n return len(var_10) != len(var_9)\n\n\ndef func_1(var_7):\n func_1 = []\n for var_4 in range(1, var_7 + 1):\n if var_7 % var_4 == 0:\n func_1.append(var_4)\n return func_1\n\n\nvar_2 = [-1, -1, -1, 0, 0, 1, 1, 1]\nvar_3 = [-1, 0, 1, -1, 1, -1, 0, 1]\nvar_7 = int(eval(input()))\nvar_1 = func_5()\n\n\ndef func_2(var_6):\n if len(var_6) == var_7:\n for var_4 in range(len(var_6)):\n if var_6[var_4] % 2 == 0:\n return 1\n return 0\n return (\n func_2(var_6 + [var_1[len(var_6)]])\n + func_2(var_6 + [var_1[len(var_6)] - 1])\n + func_2(var_6 + [var_1[len(var_6)] + 1])\n )\n\n\nprint((func_2([])))\n```\n\n=== Code B (Modified) ===\n```python\nfrom itertools import product\n\nvar_6 = int(eval(input()))\nvar_1 = list(map(int, input().split()))\nvar_5 = 0\nfor var_2 in product((-1, 0, 1), repeat=var_6):\n var_7 = 1\n for var_3, var_4 in zip(var_1, var_2):\n var_7 *= var_3 + var_4\n if var_7 % 2 == 0:\n var_5 += 1\nprint(var_5)\n```", "output": "SLOWER 2.3865", "pair_id": "python_p03568_reversed", "problem_id": "p03568", "language": "python", "direction": "reversed", "speedup_ratio": 5.2288} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_8 in range(var_1, var_2 + 1):\n var_7 = str(var_8)\n var_6 = len(var_7)\n var_4 = True\n for var_5 in range(var_6 // 2):\n if var_7[var_5] != var_7[var_6 - 1 - var_5]:\n var_4 = False\n break\n if var_4:\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_3 = list(map(int, input().split()))\nvar_2 = 0\nfor var_5 in range(var_3 + 1)[var_1:]:\n if len(str(var_5)) % 2 == 0:\n var_6 = list(str(var_5))[: len(str(var_5)) // 2]\n var_7 = list(reversed(list(str(var_5))[len(str(var_5)) // 2 :]))\n if var_6 == var_7:\n var_2 += 1\n else:\n var_8 = list(str(var_5))[: len(str(var_5)) // 2 + 1]\n var_4 = list(reversed(list(str(var_5))[len(str(var_5)) // 2 :]))\n if var_8 == var_4:\n var_2 += 1\nprint(var_2)\n```", "output": "SLOWER 1.3483", "pair_id": "python_p03416_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 2.5461} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_4 = str(var_4)\n if var_4[0] == var_4[-1] and var_4[1] == var_4[-2]:\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_4, var_3 = list(map(int, input().split()))\nvar_1 = 0\nfor var_2 in range(var_4, var_3 + 1):\n if str(var_2)[0] + str(var_2)[1] == str(var_2)[-1] + str(var_2)[-2]:\n var_1 += 1\nprint(var_1)\n```", "output": "SLOWER 1.5248", "pair_id": "python_p03416_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 2.8775} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\n\n\ndef func_1(var_5):\n var_4 = 0\n for var_3 in range(1, var_5 + 1):\n if str(var_3) == str(var_3)[::-1]:\n var_4 += 1\n return var_4\n\n\nprint((func_1(var_2) - func_1(var_1 - 1)))\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_5 in range(10):\n for var_6 in range(10):\n for var_7 in range(10):\n var_3 = 10000 * var_5 + 1000 * var_6 + 100 * var_7 + 10 * var_6 + var_5\n if var_1 <= var_3 <= var_2:\n var_4 += 1\nprint(var_4)\n```", "output": "FASTER 5.4162", "pair_id": "python_p03416_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 42.7005} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_5 in range(10):\n for var_6 in range(10):\n for var_7 in range(10):\n var_3 = 10000 * var_5 + 1000 * var_6 + 100 * var_7 + 10 * var_6 + var_5\n if var_1 <= var_3 <= var_2:\n var_4 += 1\nprint(var_4)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = str(var_4)\n if var_5[0] == var_5[4] and var_5[1] == var_5[3]:\n var_3 += 1\nprint(var_3)\n```", "output": "SLOWER 3.5594", "pair_id": "python_p03416_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 11.7893} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nfrom sys import stdin\n\nvar_6 = lambda: list(map(int, stdin.readline().split()))\nvar_5 = lambda: list(map(int, stdin.readline().split()))\nvar_1, var_3 = var_6()\nvar_2 = 0\nfor var_4 in range(var_1, var_3 + 1):\n var_7 = str(var_4)\n if var_7 == var_7[::-1]:\n var_2 += 1\nprint(var_2)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = list(reversed(list(str(var_4))))\n if var_5 == list(str(var_4)):\n var_3 += 1\nprint(var_3)\n```", "output": "SLOWER 1.6385", "pair_id": "python_p03416_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 3.1135} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().strip().split(\" \")))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n if str(var_4) == str(var_4)[::-1]:\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_3 = list(map(int, input().split()))\nvar_2 = 0\nfor var_5 in range(var_3 + 1)[var_1:]:\n if len(str(var_5)) % 2 == 0:\n var_6 = list(str(var_5))[: len(str(var_5)) // 2]\n var_7 = list(reversed(list(str(var_5))[len(str(var_5)) // 2 :]))\n if var_6 == var_7:\n var_2 += 1\n else:\n var_8 = list(str(var_5))[: len(str(var_5)) // 2 + 1]\n var_4 = list(reversed(list(str(var_5))[len(str(var_5)) // 2 :]))\n if var_8 == var_4:\n var_2 += 1\nprint(var_2)\n```", "output": "SLOWER 2.1673", "pair_id": "python_p03416_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 4.4917} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nfrom sys import stdin\n\n\ndef func_1():\n\n var_9 = stdin.readline\n var_8, var_10 = list(map(int, var_9().split()))\n var_7 = [list(map(int, var_9().split())) for _ in range(var_8)]\n var_7.sort()\n var_1 = [0] * var_8\n var_2 = [0] * var_8\n for var_4 in range(var_8):\n var_1[var_4], var_2[var_4] = var_7[var_4][0], var_7[var_4][1]\n\n var_5 = -float(\"inf\")\n var_3 = [[var_5] * (var_10 + 1) for _ in range(var_8 + 1)]\n var_3[0][0] = 0\n for var_4 in range(var_8):\n for var_6 in range(var_10 + 1):\n\n if var_6 != var_10:\n var_3[var_4 + 1][min(var_10, var_6 + var_1[var_4])] = max(\n var_3[var_4 + 1][min(var_10, var_6 + var_1[var_4])],\n var_3[var_4][var_6] + var_2[var_4],\n )\n\n var_3[var_4 + 1][var_6] = max(var_3[var_4 + 1][var_6], var_3[var_4][var_6])\n print((max(var_3[var_8])))\n\n\nif __name__ == \"__main__\":\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nfrom collections import Counter, defaultdict, deque\nfrom heapq import heappop, heappush, heapify\nimport sys, bisect, math, itertools, fractions, pprint\n\nsys.setrecursionlimit(10**8)\nvar_6 = 10**9 + 7\nvar_1 = float(\"inf\")\n\n\ndef func_1():\n return int(sys.stdin.readline())\n\n\ndef func_2():\n return list(map(int, sys.stdin.readline().split()))\n\n\nvar_8, var_11 = func_2()\nvar_17 = [func_2() for _ in range(var_8)]\nvar_10 = var_17[::-1]\nvar_14 = [[0] * var_11 for _ in range(var_8)]\nvar_3 = [[0] * var_11 for _ in range(var_8)]\nfor var_4 in range(var_8 - 1):\n var_16, var_15 = var_17[var_4]\n for var_5 in range(var_11):\n if var_5 < var_16:\n var_14[var_4 + 1][var_5] = var_14[var_4][var_5]\n else:\n var_14[var_4 + 1][var_5] = max(\n var_14[var_4][var_5], var_14[var_4][var_5 - var_16] + var_15\n )\nvar_9 = var_14[var_8 - 1][var_11 - 1] + var_17[var_8 - 1][1]\nfor var_4 in range(var_8 - 1):\n var_16, var_15 = var_10[var_4]\n for var_5 in range(var_11):\n if var_5 < var_16:\n var_3[var_4 + 1][var_5] = var_3[var_4][var_5]\n else:\n var_3[var_4 + 1][var_5] = max(\n var_3[var_4][var_5], var_3[var_4][var_5 - var_16] + var_15\n )\n var_9 = max(var_9, var_3[var_8 - 1][var_11 - 1] + var_17[0][1])\n\nfor var_4 in range(1, var_8 - 1):\n var_13 = var_4\n var_2 = var_8 - var_4 - 1\n var_7 = 0\n for var_5 in range(var_11):\n var_12 = var_14[var_13][var_5] + var_3[var_2][var_11 - 1 - var_5]\n var_7 = max(var_7, var_12)\n var_9 = max(var_9, var_7 + var_17[var_4][1])\nprint(var_9)\n```", "output": "SLOWER 1.08", "pair_id": "python_p02863_reversed", "problem_id": "p02863", "language": "python", "direction": "reversed", "speedup_ratio": 2.114} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\ndef func_1():\n var_1, var_2 = list(map(int, input().split()))\n var_3 = 0\n for var_4 in range(var_1, var_2 + 1):\n\n if (var_4 % 10) == (var_4 // 10000 % 10) and (var_4 // 10 % 10) == (\n var_4 // 1000 % 10\n ):\n var_3 += 1\n print(var_3)\n\n\nif __name__ == \"__main__\":\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = list(reversed(list(str(var_4))))\n if var_5 == list(str(var_4)):\n var_3 += 1\nprint(var_3)\n```", "output": "SLOWER 3.321", "pair_id": "python_p03416_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 9.9935} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = list(reversed(list(str(var_4))))\n if var_5 == list(str(var_4)):\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\ndef func_1():\n var_1, var_2 = list(map(int, input().split()))\n var_3 = 0\n for var_4 in range(var_1, var_2 + 1):\n\n if (var_4 % 10) == (var_4 // 10000 % 10) and (var_4 // 10 % 10) == (\n var_4 // 1000 % 10\n ):\n var_3 += 1\n print(var_3)\n\n\nif __name__ == \"__main__\":\n func_1()\n```", "output": "FASTER 3.321", "pair_id": "python_p03416_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 9.9935} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_4 = str(var_4)\n if var_4 == var_4[::-1]:\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_6 in range(var_1, var_2 + 1):\n var_3 = str(var_6)\n var_5 = True\n for var_7 in range(len(var_3) // 2):\n if var_3[var_7] != var_3[-var_7 - 1] and var_5:\n var_5 = not var_5\n if var_5:\n var_4 += 1\nprint(var_4)\n```", "output": "SLOWER 1.313", "pair_id": "python_p03416_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 2.4845} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nfrom decimal import Decimal\nimport math\n\nvar_1, var_2 = list(map(str, input().split()))\nvar_1 = int(var_1)\nvar_2 = Decimal(var_2)\nvar_3 = math.floor(var_1 * var_2)\nprint((int(var_3)))\n```\n\n=== Code B (Modified) ===\n```python\ndef func_1():\n from sys import setrecursionlimit, stdin\n from os import environ\n from collections import defaultdict, deque, Counter\n from math import ceil, floor, gcd\n from itertools import accumulate, combinations, combinations_with_replacement\n\n setrecursionlimit(10**6)\n var_7 = (\n (lambda *var_11: print(*var_11))\n if \"TERM_PROGRAM\" in environ\n else lambda *var_12: 0\n )\n var_8 = lambda: stdin.readline().rstrip()\n var_3 = lambda: list(map(int, var_8().split()))\n var_1 = lambda: int(var_8())\n var_4 = 10**9 + 7\n var_2 = 10**9 + 10\n var_9, var_10 = var_8().split()\n var_5 = int(var_9)\n var_10 = var_10.split(\".\")\n var_6 = int(var_10[0]) * 100\n if len(var_10) == 2:\n var_6 += int(var_10[1])\n print(var_5 * var_6 // 100)\n\n\nfunc_1()\n```", "output": "SLOWER 1.825", "pair_id": "python_p02659_reversed", "problem_id": "p02659", "language": "python", "direction": "reversed", "speedup_ratio": 3.543} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\ndef func_1():\n var_2, var_3, *var_1 = list(map(int, open(0).read().split()))\n var_4 = [0] * (var_3 + max(var_1[::2]))\n for var_7, var_6 in sorted(zip(*[iter(var_1)] * 2)):\n for var_5 in reversed(list(range(var_3))):\n var_4[var_5 + var_7] = max(var_4[var_5 + var_7], var_4[var_5] + var_6)\n print((max(var_4)))\n\n\nfunc_1()\n```\n\n=== Code B (Modified) ===\n```python\nvar_8, var_9 = list(map(int, input().split()))\nvar_5 = [[0] * (var_9 + 3001) for _ in range(var_8 + 1)]\nvar_3 = 0\nvar_2 = [list(map(int, input().split())) for _ in range(var_8)]\nvar_2.sort()\nfor var_6 in range(1, var_8 + 1):\n var_1, var_4 = var_2[var_6 - 1]\n for var_7 in range(var_9):\n var_5[var_6][var_7] = max(var_5[var_6 - 1][var_7], var_5[var_6][var_7])\n var_5[var_6][var_7 + var_1] = var_5[var_6 - 1][var_7] + var_4\n var_3 = max(var_5[var_6][var_7], var_5[var_6][var_7 + var_1], var_3)\nprint(var_3)\n```", "output": "SLOWER 1.8091", "pair_id": "python_p02863_reversed", "problem_id": "p02863", "language": "python", "direction": "reversed", "speedup_ratio": 3.5042} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_2, var_1 = [int(var_12) for var_12 in input().split()]\nvar_3 = []\nfor var_8 in range(var_1):\n var_5, var_6 = [int(var_12) for var_12 in input().split()]\n var_3.append((var_5, var_6))\nvar_3.sort()\nvar_9 = float(\"inf\")\nvar_4 = [var_9 for var_5 in range(var_2 + 1)]\nfor var_5, var_6 in var_3:\n var_4[var_5] = min(var_4[var_5], var_6)\nvar_3 = [\n (var_5, var_4[var_5]) for var_5 in range(1, var_2 + 1) if var_4[var_5] != var_9\n]\nvar_3.sort(key=lambda var_11: var_11[1])\nvar_7 = [True] * (var_2)\nvar_10 = None\nfor var_5, var_6 in var_3:\n if var_10 == None or var_10 < var_5:\n var_7[var_6 - 1] = False\n var_10 = var_6 - 1\nprint((sum(1 for var_6 in var_7 if not var_6)))\n```\n\n=== Code B (Modified) ===\n```python\nvar_2, var_1 = list(map(int, input().split()))\nvar_7 = []\nfor var_6 in range(var_1):\n var_3, var_5 = list(map(int, input().split()))\n var_7.append([var_5, var_3])\n\nvar_7.sort()\nvar_4 = 1\nvar_9, var_8 = var_7[0]\nfor var_6 in range(1, var_1):\n var_5, var_3 = var_7[var_6]\n if var_9 <= var_3:\n var_9 = var_5\n var_4 += 1\nprint(var_4)\n```", "output": "FASTER 1.0817", "pair_id": "python_p03295_forward", "problem_id": "p03295", "language": "python", "direction": "forward", "speedup_ratio": 2.1165} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\n\nvar_9 = sys.stdin.readline\nfrom operator import itemgetter\n\nvar_3, var_4 = list(map(int, var_9().split()))\nvar_1 = [list(map(int, var_9().split())) for _ in range(var_3)]\nvar_1.sort(key=itemgetter(0))\nvar_8 = [[0 for _ in range(var_3 + 1)] for _ in range(var_4 + 1)]\n\nvar_2 = []\nfor var_10 in range(var_3):\n var_5, var_7 = var_1[var_10]\n for var_11 in range(var_4):\n if var_5 > var_11:\n var_8[var_11][var_10 + 1] = var_8[var_11][var_10]\n else:\n if var_7 + var_8[var_11 - var_5][var_10] >= var_8[var_11][var_10]:\n var_8[var_11][var_10 + 1] = var_8[var_11 - var_5][var_10] + var_7\n else:\n var_8[var_11][var_10 + 1] = var_8[var_11][var_10]\n var_2.append(var_8[var_4 - 1][var_10] + var_7)\nvar_6 = max(var_2)\nprint(var_6)\n```\n\n=== Code B (Modified) ===\n```python\ndef func_1():\n var_2, var_3, *var_1 = list(map(int, open(0).read().split()))\n var_4 = [0] * (var_3 + max(var_1[::2]))\n for var_7, var_6 in sorted(zip(*[iter(var_1)] * 2)):\n for var_5 in reversed(list(range(var_3))):\n var_4[var_5 + var_7] = max(var_4[var_5 + var_7], var_4[var_5] + var_6)\n print((max(var_4)))\n\n\nfunc_1()\n```", "output": "FASTER 1.2754", "pair_id": "python_p02863_forward", "problem_id": "p02863", "language": "python", "direction": "forward", "speedup_ratio": 2.4207} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\nimport math\nfrom collections import defaultdict\nfrom bisect import bisect_left, bisect_right\n\nsys.setrecursionlimit(10**7)\n\n\ndef func_4():\n return sys.stdin.readline()[:-1]\n\n\nvar_4 = 10**9 + 7\n\n\ndef func_1():\n return int(eval(func_4()))\n\n\ndef func_2():\n return list(map(int, func_4().split()))\n\n\ndef func_3(var_6, var_3):\n if var_6 <= 0:\n return [[] for _ in range(var_3)]\n elif var_3 == 1:\n return [func_1() for _ in range(var_6)]\n else:\n var_5 = [func_2() for _ in range(var_6)]\n return list(map(list, list(zip(*var_5))))\n\n\nfrom decimal import getcontext, Decimal\n\ngetcontext().prec = 28\nvar_1, var_2 = list(map(str, func_4().split()))\nvar_1 = int(var_1)\nvar_2 = Decimal(var_2)\nprint((int(var_1 * var_2)))\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = input().split()\nprint((int(var_1) * int(var_2[:-3] + var_2[-2:]) // 100))\n```", "output": "FASTER 2.7073", "pair_id": "python_p02659_forward", "problem_id": "p02659", "language": "python", "direction": "forward", "speedup_ratio": 6.5312} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_8 = int(eval(input()))\nvar_4 = []\nfor var_5 in range(var_8):\n var_11 = 0\n var_9 = list(map(int, input().split()))\n for var_6 in range(10):\n var_11 += var_9[var_6] << var_6\n var_4.append(var_11)\nvar_10 = []\nfor var_5 in range(var_8):\n var_10.append(list(map(int, input().split())))\nvar_1 = -(10**12)\nfor var_5 in range(1, 1 << 10):\n var_11 = 0\n for var_6 in range(var_8):\n var_3 = list(bin(var_4[var_6] & var_5)[2:])\n var_2 = 0\n for var_7 in var_3:\n if var_7 == \"1\":\n var_2 += 1\n var_11 += var_10[var_6][var_2]\n var_1 = max(var_1, var_11)\nprint(var_1)\n```\n\n=== Code B (Modified) ===\n```python\nfrom sys import stdin\n\n\ndef func_1():\n\n var_11 = stdin.readline\n var_2 = int(var_11())\n var_1 = []\n for var_6 in range(var_2):\n var_5 = int(\"\".join(var_11().strip().split(\" \")), 2)\n var_1.append(var_5)\n var_3 = []\n for var_6 in range(var_2):\n var_10 = list(map(int, var_11().split()))\n var_3.append(var_10)\n var_8 = float(\"-inf\")\n for var_9 in range(1, 1 << 10):\n var_12 = 0\n for var_7 in range(var_2):\n var_4 = bin(var_9 & var_1[var_7]).count(\"1\")\n var_12 += var_3[var_7][var_4]\n var_8 = max(var_12, var_8)\n print(var_8)\n\n\nif __name__ == \"__main__\":\n func_1()\n```", "output": "FASTER 2.3449", "pair_id": "python_p03503_forward", "problem_id": "p03503", "language": "python", "direction": "forward", "speedup_ratio": 5.0801} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n if list(str(var_4)) == list(reversed(str(var_4))):\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nfrom sys import stdin\n\nvar_6 = lambda: list(map(int, stdin.readline().split()))\nvar_5 = lambda: list(map(int, stdin.readline().split()))\nvar_1, var_3 = var_6()\nvar_2 = 0\nfor var_4 in range(var_1, var_3 + 1):\n var_7 = str(var_4)\n if var_7 == var_7[::-1]:\n var_2 += 1\nprint(var_2)\n```", "output": "FASTER 1.3819", "pair_id": "python_p03416_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 2.6062} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\n\nvar_9 = sys.stdin.readline\nfrom operator import itemgetter\n\nvar_3, var_4 = list(map(int, var_9().split()))\nvar_1 = [list(map(int, var_9().split())) for _ in range(var_3)]\nvar_1.sort(key=itemgetter(0))\nvar_8 = [[0 for _ in range(var_3 + 1)] for _ in range(var_4 + 1)]\n\nvar_2 = []\nfor var_10 in range(var_3):\n var_5, var_7 = var_1[var_10]\n for var_11 in range(var_4):\n if var_5 > var_11:\n var_8[var_11][var_10 + 1] = var_8[var_11][var_10]\n else:\n if var_7 + var_8[var_11 - var_5][var_10] >= var_8[var_11][var_10]:\n var_8[var_11][var_10 + 1] = var_8[var_11 - var_5][var_10] + var_7\n else:\n var_8[var_11][var_10 + 1] = var_8[var_11][var_10]\n var_2.append(var_8[var_4 - 1][var_10] + var_7)\nvar_6 = max(var_2)\nprint(var_6)\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\n\nsys.setrecursionlimit(2147483647)\nvar_2 = float(\"inf\")\nvar_3 = 10**9 + 7\nvar_10 = lambda: sys.stdin.readline().rstrip()\n\n\ndef func_1():\n var_11, var_4 = list(map(int, var_10().split()))\n var_1 = [tuple(map(int, var_10().split())) for _ in range(var_11)]\n var_1.sort()\n var_8 = [0] * var_4\n var_6 = -var_2\n for var_9 in range(var_11):\n var_5, var_7 = var_1[var_9]\n var_12 = var_8[:]\n for var_13 in range(var_4):\n if var_13 + var_5 < var_4:\n var_12[var_13 + var_5] = max(\n var_12[var_13 + var_5], var_8[var_13] + var_7\n )\n else:\n var_6 = max(var_6, var_8[var_13] + var_7)\n var_8 = var_12\n print((max(var_6, max(var_8))))\n\n\nfunc_1()\n```", "output": "FASTER 1.0161", "pair_id": "python_p02863_forward", "problem_id": "p02863", "language": "python", "direction": "forward", "speedup_ratio": 2.0224} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\n\n\ndef func_1(var_5, var_6):\n var_4 = 0\n for var_3 in range(var_5, var_6 + 1):\n if str(var_3) == str(var_3)[::-1]:\n var_4 += 1\n return var_4\n\n\nprint((func_1(var_1, var_2)))\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_7 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_3 = True\n var_8 = str(var_4)\n var_6 = len(var_8)\n for var_5 in range(var_6 // 2 + 1):\n if var_8[var_5] != var_8[-var_5 - 1]:\n var_3 = False\n break\n if var_3:\n var_7 += 1\nprint(var_7)\n```", "output": "SLOWER 1.4487", "pair_id": "python_p03416_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 2.7297} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\nimport math\nfrom collections import defaultdict\nfrom bisect import bisect_left, bisect_right\n\nsys.setrecursionlimit(10**7)\n\n\ndef func_4():\n return sys.stdin.readline()[:-1]\n\n\nvar_4 = 10**9 + 7\n\n\ndef func_1():\n return int(eval(func_4()))\n\n\ndef func_2():\n return list(map(int, func_4().split()))\n\n\ndef func_3(var_6, var_3):\n if var_6 <= 0:\n return [[] for _ in range(var_3)]\n elif var_3 == 1:\n return [func_1() for _ in range(var_6)]\n else:\n var_5 = [func_2() for _ in range(var_6)]\n return list(map(list, list(zip(*var_5))))\n\n\nvar_1, var_2 = list(map(str, func_4().split()))\nvar_1 = int(var_1)\nvar_2 = 100 * int(var_2[0]) + 10 * int(var_2[2]) + int(var_2[3])\nprint((var_1 * var_2 // 100))\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\n\nvar_3 = sys.stdin.readline\nvar_1, var_2 = var_3().split()\nvar_1 = int(var_1)\nvar_2 = int(float(var_2) * 100 + 0.5)\nprint((var_1 * var_2 // 100))\n```", "output": "FASTER 2.3093", "pair_id": "python_p02659_forward", "problem_id": "p02659", "language": "python", "direction": "forward", "speedup_ratio": 4.9565} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nfrom collections import Counter, defaultdict, deque\nfrom heapq import heappop, heappush, heapify\nimport sys, bisect, math, itertools, fractions, pprint\n\nsys.setrecursionlimit(10**8)\nvar_6 = 10**9 + 7\nvar_1 = float(\"inf\")\n\n\ndef func_1():\n return int(sys.stdin.readline())\n\n\ndef func_2():\n return list(map(int, sys.stdin.readline().split()))\n\n\nvar_7, var_9 = func_2()\nvar_13 = [func_2() for _ in range(var_7)]\nvar_13.sort(key=lambda var_14: var_14[1], reverse=True)\nvar_8 = 0\nvar_10 = min(var_7, 5)\nfor var_3 in range(var_10):\n var_2 = [[0] * (var_9 + 5) for _ in range(var_7 + 5)]\n for var_4 in range(var_7):\n var_12, var_11 = var_13[var_4]\n for var_5 in range(var_9):\n if var_5 < var_12 or var_3 == var_4:\n var_2[var_4 + 1][var_5] = var_2[var_4][var_5]\n else:\n var_2[var_4 + 1][var_5] = max(\n var_2[var_4][var_5], var_2[var_4][var_5 - var_12] + var_11\n )\n\n var_8 = max(var_2[var_7][var_9 - 1] + var_13[var_3][1], var_8)\nprint(var_8)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_6 = sorted([list(map(int, input().split())) for var_5 in range(var_1)])\n\nvar_4 = [[0] * (var_2 + 1) for var_5 in range(var_1 + 1)]\n\nfor var_5 in range(var_1):\n var_9, var_8 = var_6[var_5]\n for var_7 in range(var_2 + 1):\n if var_7 + var_9 <= var_2:\n var_4[var_5 + 1][var_7 + var_9] = max(\n var_4[var_5 + 1][var_7 + var_9], var_4[var_5][var_7] + var_8\n )\n var_4[var_5 + 1][var_7] = max(var_4[var_5][var_7], var_4[var_5 + 1][var_7])\nvar_3 = 0\nfor var_5, (var_9, var_8) in enumerate(var_6):\n var_3 = max(var_3, var_4[var_5][var_2 - 1] + var_8)\nprint(var_3)\n```", "output": "FASTER 1.2339", "pair_id": "python_p02863_forward", "problem_id": "p02863", "language": "python", "direction": "forward", "speedup_ratio": 2.352} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_4 = {}\nvar_5 = 0\nfor var_6 in range(10000, 100000):\n var_3 = list(str(var_6))\n if var_3 == list(reversed(var_3)):\n var_5 += 1\n var_4[var_6] = var_5\nvar_1, var_2 = list(map(int, input().split()))\nprint((var_4[var_2] - var_4[var_1 - 1] if var_1 > 10000 else var_4[var_2]))\n```\n\n=== Code B (Modified) ===\n```python\nvar_4, var_3 = list(map(int, input().split()))\nvar_1 = 0\nfor var_2 in range(var_4, var_3 + 1):\n if str(var_2)[0] + str(var_2)[1] == str(var_2)[-1] + str(var_2)[-2]:\n var_1 += 1\nprint(var_1)\n```", "output": "FASTER 2.2325", "pair_id": "python_p03416_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 4.6995} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_6 = sorted([list(map(int, input().split())) for var_5 in range(var_1)])\n\nvar_4 = [[0] * (var_2 + 1) for var_5 in range(var_1 + 1)]\n\nfor var_5 in range(var_1):\n var_9, var_8 = var_6[var_5]\n for var_7 in range(var_2 + 1):\n if var_7 + var_9 <= var_2:\n var_4[var_5 + 1][var_7 + var_9] = max(\n var_4[var_5 + 1][var_7 + var_9], var_4[var_5][var_7] + var_8\n )\n var_4[var_5 + 1][var_7] = max(var_4[var_5][var_7], var_4[var_5 + 1][var_7])\nvar_3 = 0\nfor var_5, (var_9, var_8) in enumerate(var_6):\n var_3 = max(var_3, var_4[var_5][var_2 - 1] + var_8)\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\n\nsys.setrecursionlimit(2147483647)\nvar_2 = float(\"inf\")\nvar_3 = 10**9 + 7\nvar_10 = lambda: sys.stdin.readline().rstrip()\n\n\ndef func_1():\n var_11, var_4 = list(map(int, var_10().split()))\n var_1 = [tuple(map(int, var_10().split())) for _ in range(var_11)]\n var_1.sort()\n var_8 = [0] * var_4\n var_6 = -var_2\n for var_9 in range(var_11):\n var_5, var_7 = var_1[var_9]\n var_12 = var_8[:]\n for var_13 in range(var_4):\n if var_13 + var_5 < var_4:\n var_12[var_13 + var_5] = max(\n var_12[var_13 + var_5], var_8[var_13] + var_7\n )\n else:\n var_6 = max(var_6, var_8[var_13] + var_7)\n var_8 = var_12\n print((max(var_6, max(var_8))))\n\n\nfunc_1()\n```", "output": "FASTER 1.4447", "pair_id": "python_p02863_forward", "problem_id": "p02863", "language": "python", "direction": "forward", "speedup_ratio": 2.722} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\nimport math\nfrom collections import defaultdict\nfrom bisect import bisect_left, bisect_right\n\nsys.setrecursionlimit(10**7)\n\n\ndef func_4():\n return sys.stdin.readline()[:-1]\n\n\nvar_4 = 10**9 + 7\n\n\ndef func_1():\n return int(eval(func_4()))\n\n\ndef func_2():\n return list(map(int, func_4().split()))\n\n\ndef func_3(var_6, var_3):\n if var_6 <= 0:\n return [[] for _ in range(var_3)]\n elif var_3 == 1:\n return [func_1() for _ in range(var_6)]\n else:\n var_5 = [func_2() for _ in range(var_6)]\n return list(map(list, list(zip(*var_5))))\n\n\nvar_1, var_2 = list(map(str, func_4().split()))\nvar_1 = int(var_1)\nvar_2 = 100 * int(var_2[0]) + 10 * int(var_2[2]) + int(var_2[3])\nprint((var_1 * var_2 // 100))\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = input().split()\nprint((int(var_1) * int(var_2[:-3] + var_2[-2:]) // 100))\n```", "output": "FASTER 2.7265", "pair_id": "python_p02659_forward", "problem_id": "p02659", "language": "python", "direction": "forward", "speedup_ratio": 6.6183} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\nimport math\nfrom collections import defaultdict\nfrom bisect import bisect_left, bisect_right\n\nsys.setrecursionlimit(10**7)\n\n\ndef func_4():\n return sys.stdin.readline()[:-1]\n\n\nvar_4 = 10**9 + 7\n\n\ndef func_1():\n return int(eval(func_4()))\n\n\ndef func_2():\n return list(map(int, func_4().split()))\n\n\ndef func_3(var_6, var_3):\n if var_6 <= 0:\n return [[] for _ in range(var_3)]\n elif var_3 == 1:\n return [func_1() for _ in range(var_6)]\n else:\n var_5 = [func_2() for _ in range(var_6)]\n return list(map(list, list(zip(*var_5))))\n\n\nvar_1, var_2 = list(map(str, func_4().split()))\nvar_1 = int(var_1)\nvar_2 = 100 * int(var_2[0]) + 10 * int(var_2[2]) + int(var_2[3])\nprint((var_1 * var_2 // 100))\n```\n\n=== Code B (Modified) ===\n```python\nimport decimal\n\nvar_1, var_2 = (decimal.Decimal(var_3) for var_3 in input().split())\nprint((int(var_1 * var_2)))\n```", "output": "FASTER 2.2511", "pair_id": "python_p02659_forward", "problem_id": "p02659", "language": "python", "direction": "forward", "speedup_ratio": 4.7605} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = [\n var_3 for var_3 in map(str, list(range(var_1, var_2 + 1))) if var_3 == var_3[::-1]\n]\nprint((len(var_4)))\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\n\n\ndef func_1(var_5):\n var_4 = 0\n for var_3 in range(1, var_5 + 1):\n if str(var_3) == str(var_3)[::-1]:\n var_4 += 1\n return var_4\n\n\nprint((func_1(var_2) - func_1(var_1 - 1)))\n```", "output": "SLOWER 2.2892", "pair_id": "python_p03416_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 4.8878} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\ndef func_1():\n var_1, var_2 = list(map(int, input().split()))\n var_3 = 0\n for var_4 in range(var_1, var_2 + 1):\n\n if (var_4 % 10) == (var_4 // 10000 % 10) and (var_4 // 10 % 10) == (\n var_4 // 1000 % 10\n ):\n var_3 += 1\n print(var_3)\n\n\nif __name__ == \"__main__\":\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = str(var_4)\n if var_5 == var_5[::-1]:\n var_3 += 1\nprint(var_3)\n```", "output": "SLOWER 1.6596", "pair_id": "python_p03416_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 3.1592} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = list(str(var_4))\n if var_5 == list(reversed(var_5)):\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = str(var_4)\n if var_5[0] == var_5[4] and var_5[1] == var_5[3]:\n var_3 += 1\nprint(var_3)\n```", "output": "FASTER 1.4984", "pair_id": "python_p03416_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 2.8252} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\n\nvar_8 = sys.stdin.readline\n\n\ndef func_1():\n var_2 = int(eval(var_8()))\n var_1 = [int(var_8().replace(\" \", \"\"), 2) for _ in range(var_2)]\n var_3 = [list(map(int, var_8().split())) for _ in range(var_2)]\n var_4 = -(10**7) * var_2\n for var_7 in range(1, 1 << 10):\n var_10 = 0\n for var_9, var_6 in enumerate(var_1):\n var_5 = bin(var_7 & var_6).count(\"1\")\n var_10 += var_3[var_9][var_5]\n var_4 = max(var_4, var_10)\n print(var_4)\n\n\nif __name__ == \"__main__\":\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nvar_5 = 0\nif var_5 == 0:\n var_8 = int(eval(input()))\n var_2 = []\n for var_4 in range(var_8):\n var_3 = list(map(int, input().split()))\n var_2.append(var_3)\n var_9 = []\n for var_4 in range(var_8):\n var_10 = list(map(int, input().split()))\n var_9.append(var_10)\nelif var_5 == 1:\n var_8 = 1\n var_2 = [[1, 1, 0, 1, 0, 0, 0, 1, 0, 1]]\n var_9 = [[3, 4, 5, 6, 7, 8, 9, -2, -3, 4, -2]]\nelif var_5 == 2:\n var_8 = 2\n var_2 = [[1, 1, 1, 1, 1, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 1, 1, 1, 1, 1]]\n var_9 = [\n [0, -2, -2, -2, -2, -2, -1, -1, -1, -1, -1],\n [0, -2, -2, -2, -2, -2, -1, -1, -1, -1, -1],\n ]\nelif var_5 == 3:\n var_8 = 3\n var_2 = [\n [1, 1, 1, 1, 1, 1, 0, 0, 1, 1],\n [0, 1, 0, 1, 1, 1, 1, 0, 1, 0],\n [1, 0, 1, 1, 0, 1, 0, 1, 0, 1],\n ]\n var_9 = [\n [-8, 6, -2, -8, -8, 4, 8, 7, -6, 2, 2],\n [-9, 2, 0, 1, 7, -5, 0, -2, -6, 5, 5],\n [6, -6, 7, -9, 6, -5, 8, 0, -9, -7, -7],\n ]\nimport itertools\n\nvar_13 = -(10**11)\nfor var_4 in itertools.product([0, 1], repeat=10):\n var_11 = list(var_4)\n var_12 = 0\n if sum(var_11) != 0:\n for var_7 in range(var_8):\n var_1 = 0\n for var_6 in range(10):\n var_1 = var_1 + var_11[var_6] * var_2[var_7][var_6]\n var_12 = var_12 + var_9[var_7][var_1]\n\n var_13 = max(var_12, var_13)\nprint(var_13)\n```", "output": "SLOWER 3.1351", "pair_id": "python_p03503_reversed", "problem_id": "p03503", "language": "python", "direction": "reversed", "speedup_ratio": 8.7856} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = [0] * (var_2 + 1)\nfor var_3 in range(1, var_2 + 1):\n if str(var_3) == str(var_3)[::-1]:\n var_4[var_3] = var_4[var_3 - 1] + 1\n else:\n var_4[var_3] = var_4[var_3 - 1]\nprint((var_4[var_2] - var_4[var_1 - 1]))\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_4 = str(var_4)\n if var_4[0] == var_4[-1] and var_4[1] == var_4[-2]:\n var_3 += 1\nprint(var_3)\n```", "output": "FASTER 2.126", "pair_id": "python_p03416_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 4.365} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_6 = 2019\nvar_1 = [0] * var_6\nvar_3 = 1\nvar_5 = var_4 = 0\nfor var_2 in input()[::-1]:\n var_1[var_4] += 1\n var_4 -= int(var_2) * var_3\n var_4 %= var_6\n var_5 += var_1[var_4]\n var_3 *= 10\n var_3 %= var_6\nprint(var_5)\n```\n\n=== Code B (Modified) ===\n```python\nvar_5 = input()[::-1]\nvar_2 = [0] * 2019\nvar_2[0] = 1\nvar_4 = 0\nvar_6 = 1\nvar_1 = 0\nfor var_3 in var_5:\n var_4 = (var_4 + int(var_3) * var_6) % 2019\n var_6 = var_6 * 10 % 2019\n var_2[var_4] += 1\nfor var_3 in var_2:\n var_1 += var_3 * (var_3 - 1) // 2\nprint(var_1)\n```", "output": "SLOWER 2.8509", "pair_id": "python_p02702_reversed", "problem_id": "p02702", "language": "python", "direction": "reversed", "speedup_ratio": 7.2145} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_8 in range(var_1, var_2 + 1):\n var_7 = str(var_8)\n var_6 = len(var_7)\n var_4 = True\n for var_5 in range(var_6 // 2):\n if var_7[var_5] != var_7[var_6 - 1 - var_5]:\n var_4 = False\n break\n if var_4:\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = [\n var_3 for var_3 in map(str, list(range(var_1, var_2 + 1))) if var_3 == var_3[::-1]\n]\nprint((len(var_4)))\n```", "output": "FASTER 1.8248", "pair_id": "python_p03416_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 3.5426} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\nfrom collections import deque\n\nvar_13 = sys.stdin.readline\nvar_2 = int(eval(var_13()))\nvar_5 = [deque() for _ in range(var_2)]\nvar_3 = [-1] * var_2\nfor var_12 in range(var_2 - 1):\n var_6, var_8 = list(map(int, var_13().split()))\n var_5[var_6 - 1].append((var_12, var_8 - 1))\n\n\nvar_4 = deque([(0, -1)])\nvar_1 = [-1] * (var_2 - 1)\nvar_11 = 0\nwhile var_4:\n var_14, var_10 = var_4.pop()\n var_9 = 1\n for var_12, var_15 in var_5[var_14]:\n if var_9 == var_10:\n var_9 += 1\n var_1[var_12] = var_9\n var_4.appendleft((var_15, var_9))\n var_9 += 1\n var_11 = max(var_11, var_9 - 1)\nprint(var_11)\nfor var_7 in var_1:\n print(var_7)\n```\n\n=== Code B (Modified) ===\n```python\nimport copy\n\nvar_8 = int(eval(input()))\nvar_10 = set([var_6 for var_6 in range(1, 10**5)])\nvar_5 = []\nvar_11 = {}\nvar_9 = []\nfor var_6 in range(var_8 - 1):\n var_1, var_2 = list(map(int, input().split(\" \")))\n var_5.append([var_1, var_2])\n var_11.setdefault(var_1, []).append(var_2)\n var_9.append([])\nvar_9.append([])\nvar_9.append([])\nvar_7 = 0\nfor var_12 in range(1, var_8 + 1):\n var_14 = var_11.get(var_12, [])\n var_3 = 1\n for var_13 in var_14:\n if var_3 in var_9[var_12]:\n var_3 += 1\n else:\n pass\n var_9[var_13].append(var_3)\n if var_3 >= var_7:\n var_7 = var_3\n var_3 += 1\nprint(var_7)\nfor var_4 in var_5:\n print((var_9[var_4[1]][0]))\n```", "output": "SLOWER 4.6519", "pair_id": "python_p02850_reversed", "problem_id": "p02850", "language": "python", "direction": "reversed", "speedup_ratio": 25.1403} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport math\nimport string\n\n\ndef func_4():\n return list(map(int, input().split()))\n\n\ndef func_3(var_6, var_7):\n return math.factorial(var_6) // (\n math.factorial(var_6 - var_7) * math.factorial(var_7)\n )\n\n\ndef func_2(var_9):\n var_8 = []\n for var_5 in var_9:\n if not (var_5 in var_8):\n var_8.append(var_5)\n return len(var_9) != len(var_8)\n\n\ndef func_1(var_6):\n func_1 = []\n for var_4 in range(1, var_6 + 1):\n if var_6 % var_4 == 0:\n func_1.append(var_4)\n return func_1\n\n\nvar_2 = [-1, -1, -1, 0, 0, 1, 1, 1]\nvar_3 = [-1, 0, 1, -1, 1, -1, 0, 1]\nvar_6 = int(eval(input()))\nvar_1 = func_4()\nvar_10 = 1\nfor var_4 in range(len(var_1)):\n if var_1[var_4] % 2 == 0:\n var_10 *= 2\n else:\n var_10 *= 1\nprint((3 ** len(var_1) - var_10))\n```\n\n=== Code B (Modified) ===\n```python\nimport numpy as np\nfrom itertools import product\n\nvar_6 = int(eval(input()))\nvar_2 = list(map(int, input().split()))\nvar_2 = np.array(var_2)\nvar_5 = [-1, 0, 1]\nvar_3 = 0\nfor var_7 in product(var_5, repeat=var_6):\n var_7 = np.array(var_7)\n var_1 = var_2 + var_7\n var_4 = var_1.cumprod()\n if var_4[-1] % 2 == 0:\n var_3 += 1\nprint(var_3)\n```", "output": "SLOWER 8.335", "pair_id": "python_p03568_reversed", "problem_id": "p03568", "language": "python", "direction": "reversed", "speedup_ratio": 322.9207} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_8 = int(eval(input()))\nvar_1 = list(map(int, input().split()))\nvar_3 = 0\nvar_9 = sum(var_1)\nvar_2 = []\nvar_10 = 0\nfor var_6 in range(0, var_8):\n\n var_10 += var_1[var_6]\n var_11 = var_9 - var_10\n\n var_2.append(abs(var_10 - var_11))\n if var_10 == var_11:\n print((0))\n exit()\nvar_7 = var_2.index(min(var_2))\n\n\nvar_12 = sum(var_1[0:var_7])\nvar_13 = sum(var_1[var_7:])\n\n\nvar_4 = abs(var_12 - var_13)\nvar_14 = sum(var_1[0 : var_7 + 1])\nvar_15 = sum(var_1[var_7 + 1 :])\n\n\nvar_5 = abs(var_14 - var_15)\nprint((min(var_4, var_5)))\n```\n\n=== Code B (Modified) ===\n```python\nfrom itertools import accumulate, count\nfrom bisect import bisect_right\n\neval(input())\nvar_1 = [0] + list(accumulate(list(map(int, input().split()))))\nvar_2 = bisect_right(var_1, var_1[-1] // 2)\nprint((min(2 * var_1[var_2] - var_1[-1], var_1[-1] - 2 * var_1[var_2 - 1])))\n```", "output": "FASTER 1.1094", "pair_id": "python_p02854_forward", "problem_id": "p02854", "language": "python", "direction": "forward", "speedup_ratio": 2.1576} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_8 = int(eval(input()))\nvar_4 = []\nfor var_5 in range(var_8):\n var_11 = 0\n var_9 = list(map(int, input().split()))\n for var_6 in range(10):\n var_11 += var_9[var_6] << var_6\n var_4.append(var_11)\nvar_10 = []\nfor var_5 in range(var_8):\n var_10.append(list(map(int, input().split())))\nvar_1 = -(10**12)\nfor var_5 in range(1, 1 << 10):\n var_11 = 0\n for var_6 in range(var_8):\n var_3 = list(bin(var_4[var_6] & var_5)[2:])\n var_2 = 0\n for var_7 in var_3:\n if var_7 == \"1\":\n var_2 += 1\n var_11 += var_10[var_6][var_2]\n var_1 = max(var_1, var_11)\nprint(var_1)\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\n\nvar_7 = sys.stdin.readline\nfrom itertools import combinations\n\n\ndef func_3(var_10):\n for _ in range(var_10):\n yield list(map(int, var_7().split()))\n\n\ndef func_1(var_9, var_5, var_11):\n var_3 = len([0 for var_8 in var_9 if var_5[var_8] == 1])\n return var_11[var_3]\n\n\ndef func_2():\n var_10 = int(eval(var_7()))\n var_1 = list(func_3(var_10))\n var_2 = list(func_3(var_10))\n for var_6 in range(1, 11):\n for var_4 in combinations(list(range(10)), var_6):\n yield sum(\n func_1(var_4, var_5, var_11) for var_5, var_11 in zip(var_1, var_2)\n )\n\n\nprint((max(func_2())))\n```", "output": "FASTER 1.0894", "pair_id": "python_p03503_forward", "problem_id": "p03503", "language": "python", "direction": "forward", "speedup_ratio": 2.1279} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\n\nvar_2, var_1, *var_3 = sys.stdin.read().strip().split()\nvar_2 = int(var_2)\nvar_5 = [0] * var_2\nvar_10 = [0] * var_2\nfor var_6, var_8 in zip(*[iter(var_3)] * 2):\n var_6 = int(var_6) - 1\n if var_8 == \"AC\":\n var_5[var_6] = 1\n elif var_5[var_6] == 0:\n var_10[var_6] += 1\nvar_7 = sum([var_9 * var_4 for var_4, var_9 in zip(var_5, var_10)])\nprint((\"{} {}\".format(sum(var_5), var_7)))\n```\n\n=== Code B (Modified) ===\n```python\nvar_6, var_5 = list(map(int, input().split()))\nvar_8 = [[] for _ in range(var_6)]\nfor var_2 in range(var_5):\n var_10, var_11 = input().split()\n var_8[int(var_10) - 1].append(var_11)\n\nvar_1, var_7 = 0, 0\nfor var_3 in range(var_6):\n var_9 = var_8[var_3]\n if \"AC\" in var_9:\n var_1 += 1\n for var_4 in var_9:\n if var_4 == \"WA\":\n var_7 += 1\n else:\n break\nprint((var_1, var_7))\n```", "output": "SLOWER 1.7771", "pair_id": "python_p02802_reversed", "problem_id": "p02802", "language": "python", "direction": "reversed", "speedup_ratio": 3.4274} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_3 = list(map(int, input().split()))\nvar_2 = 0\nfor var_5 in range(var_3 + 1)[var_1:]:\n if len(str(var_5)) % 2 == 0:\n var_6 = list(str(var_5))[: len(str(var_5)) // 2]\n var_7 = list(reversed(list(str(var_5))[len(str(var_5)) // 2 :]))\n if var_6 == var_7:\n var_2 += 1\n else:\n var_8 = list(str(var_5))[: len(str(var_5)) // 2 + 1]\n var_4 = list(reversed(list(str(var_5))[len(str(var_5)) // 2 :]))\n if var_8 == var_4:\n var_2 += 1\nprint(var_2)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = [\n var_3 for var_3 in map(str, list(range(var_1, var_2 + 1))) if var_3 == var_3[::-1]\n]\nprint((len(var_4)))\n```", "output": "FASTER 3.1731", "pair_id": "python_p03416_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 9.0199} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = str(var_4)\n if var_5 == var_5[::-1]:\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_4, var_3 = list(map(int, input().split()))\nvar_1 = 0\nfor var_2 in range(var_4, var_3 + 1):\n if str(var_2)[0] + str(var_2)[1] == str(var_2)[-1] + str(var_2)[-2]:\n var_1 += 1\nprint(var_1)\n```", "output": "SLOWER 1.3456", "pair_id": "python_p03416_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 2.5413} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\ndef func_1():\n var_1, var_2 = list(map(int, input().rstrip().split()))\n var_3 = 0\n for var_4 in range(var_1, var_2 + 1):\n var_5 = str(var_4)\n if var_5 == var_5[::-1]:\n var_3 += 1\n print(var_3)\n\n\nif __name__ == \"__main__\":\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_3 in range(var_1, var_2 + 1):\n var_5 = list(str(var_3))\n var_6 = list(reversed(var_5))\n if var_5 == var_6:\n var_4 += 1\nprint(var_4)\n```", "output": "SLOWER 2.0546", "pair_id": "python_p03416_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 4.1544} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport bisect\nimport sys\n\nsys.setrecursionlimit(10**6)\nvar_16 = sys.stdout.write\nvar_7 = lambda *var_14: print(*var_14) if var_1 else 0\nvar_1 = True\n\n\ndef func_1(var_9=sys.stdin.readline):\n var_11 = lambda: var_9().rstrip()\n var_3 = lambda: list(map(int, var_11().split()))\n var_2 = lambda: int(var_11())\n var_4 = lambda var_17: [var_3() for _ in range(var_17)]\n var_13, var_15 = var_3()\n var_5 = var_4(var_13)\n var_5.sort()\n var_8 = [[0] * var_15 for _ in range(var_13 + 1)]\n for var_10 in range(1, var_13 + 1):\n for var_12 in range(1, var_15):\n if var_12 < var_5[var_10 - 1][0]:\n var_8[var_10][var_12] = var_8[var_10 - 1][var_12]\n else:\n var_8[var_10][var_12] = max(\n var_8[var_10 - 1][var_12],\n var_8[var_10 - 1][var_12 - var_5[var_10 - 1][0]]\n + var_5[var_10 - 1][1],\n )\n var_6 = 0\n for var_10 in range(var_13):\n var_6 = max(var_6, var_8[var_10][var_15 - 1] + var_5[var_10][1])\n print(var_6)\n\n\nif __name__ == \"__main__\":\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\nfrom operator import itemgetter\nfrom heapq import heapify, heappop, heappush\n\nvar_1 = int(10e15)\nvar_2 = -var_1\nvar_11 = 1000000007\nsys.setrecursionlimit(1000000)\n\n\ndef func_2():\n return list(map(int, input().split()))\n\n\ndef func_4():\n return input().split()\n\n\ndef func_1():\n return int(sys.stdin.readline())\n\n\ndef func_3():\n return eval(input())\n\n\nvar_3, var_4 = func_2()\nvar_5 = [func_2() for var_9 in range(var_3)]\nvar_5.sort(key=itemgetter(0))\n\nvar_8 = [[0] * (var_4 + 1 + 3000 + 1) for _ in range(var_3 + 1)]\nvar_6 = 0\nfor var_9 in range(var_3):\n for var_10 in range(var_4 + 1 + 3000 + 1):\n var_12, var_7 = var_5[var_9]\n if 0 <= var_10 - var_12 < var_4:\n var_8[var_9 + 1][var_10] = max(\n var_8[var_9][var_10], var_8[var_9][var_10 - var_12] + var_7\n )\n else:\n var_8[var_9 + 1][var_10] = var_8[var_9][var_10]\n var_6 = max(var_6, var_8[var_9 + 1][var_10])\nprint(var_6)\n```", "output": "SLOWER 5.2198", "pair_id": "python_p02863_reversed", "problem_id": "p02863", "language": "python", "direction": "reversed", "speedup_ratio": 37.2652} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\n\nvar_8 = sys.stdin.readline\n\n\ndef func_1():\n var_2 = int(eval(var_8()))\n var_1 = [int(var_8().replace(\" \", \"\"), 2) for _ in range(var_2)]\n var_3 = [list(map(int, var_8().split())) for _ in range(var_2)]\n var_4 = -(10**7) * var_2\n for var_7 in range(1, 1 << 10):\n var_10 = 0\n for var_9, var_6 in enumerate(var_1):\n var_5 = bin(var_7 & var_6).count(\"1\")\n var_10 += var_3[var_9][var_5]\n var_4 = max(var_4, var_10)\n print(var_4)\n\n\nif __name__ == \"__main__\":\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\n\nvar_7 = sys.stdin.readline\nfrom itertools import combinations\n\n\ndef func_3(var_10):\n for _ in range(var_10):\n yield list(map(int, var_7().split()))\n\n\ndef func_1(var_9, var_5, var_11):\n var_3 = len([0 for var_8 in var_9 if var_5[var_8] == 1])\n return var_11[var_3]\n\n\ndef func_2():\n var_10 = int(eval(var_7()))\n var_1 = list(func_3(var_10))\n var_2 = list(func_3(var_10))\n for var_6 in range(1, 11):\n for var_4 in combinations(list(range(10)), var_6):\n yield sum(\n func_1(var_4, var_5, var_11) for var_5, var_11 in zip(var_1, var_2)\n )\n\n\nprint((max(func_2())))\n```", "output": "SLOWER 1.1171", "pair_id": "python_p03503_reversed", "problem_id": "p03503", "language": "python", "direction": "reversed", "speedup_ratio": 2.1691} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = str(var_4)\n if var_5[0] == var_5[4] and var_5[1] == var_5[3]:\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_7 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_3 = True\n var_8 = str(var_4)\n var_6 = len(var_8)\n for var_5 in range(var_6 // 2 + 1):\n if var_8[var_5] != var_8[-var_5 - 1]:\n var_3 = False\n break\n if var_3:\n var_7 += 1\nprint(var_7)\n```", "output": "SLOWER 1.3913", "pair_id": "python_p03416_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 2.6231} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\n\n\ndef func_1(var_5, var_6):\n var_4 = 0\n for var_3 in range(var_5, var_6 + 1):\n if str(var_3) == str(var_3)[::-1]:\n var_4 += 1\n return var_4\n\n\nprint((func_1(var_1, var_2)))\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n if list(str(var_4)) == list(reversed(str(var_4))):\n var_3 += 1\nprint(var_3)\n```", "output": "SLOWER 1.724", "pair_id": "python_p03416_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 3.3035} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n if list(str(var_4)) == list(reversed(str(var_4))):\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_3 = list(map(int, input().split()))\nvar_2 = 0\nfor var_5 in range(var_3 + 1)[var_1:]:\n if len(str(var_5)) % 2 == 0:\n var_6 = list(str(var_5))[: len(str(var_5)) // 2]\n var_7 = list(reversed(list(str(var_5))[len(str(var_5)) // 2 :]))\n if var_6 == var_7:\n var_2 += 1\n else:\n var_8 = list(str(var_5))[: len(str(var_5)) // 2 + 1]\n var_4 = list(reversed(list(str(var_5))[len(str(var_5)) // 2 :]))\n if var_8 == var_4:\n var_2 += 1\nprint(var_2)\n```", "output": "SLOWER 1.0742", "pair_id": "python_p03416_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 2.1055} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\n\nvar_9 = sys.stdin.readline\nfrom operator import itemgetter\n\nvar_3, var_4 = list(map(int, var_9().split()))\nvar_1 = [list(map(int, var_9().split())) for _ in range(var_3)]\nvar_1.sort(key=itemgetter(0))\nvar_8 = [[0 for _ in range(var_3 + 1)] for _ in range(var_4 + 1)]\n\nvar_2 = []\nfor var_10 in range(var_3):\n var_5, var_7 = var_1[var_10]\n for var_11 in range(var_4):\n if var_5 > var_11:\n var_8[var_11][var_10 + 1] = var_8[var_11][var_10]\n else:\n if var_7 + var_8[var_11 - var_5][var_10] >= var_8[var_11][var_10]:\n var_8[var_11][var_10 + 1] = var_8[var_11 - var_5][var_10] + var_7\n else:\n var_8[var_11][var_10 + 1] = var_8[var_11][var_10]\n var_2.append(var_8[var_4 - 1][var_10] + var_7)\nvar_6 = max(var_2)\nprint(var_6)\n```\n\n=== Code B (Modified) ===\n```python\nfrom collections import Counter, defaultdict, deque\nfrom heapq import heappop, heappush, heapify\nimport sys, bisect, math, itertools, fractions, pprint\n\nsys.setrecursionlimit(10**8)\nvar_6 = 10**9 + 7\nvar_1 = float(\"inf\")\n\n\ndef func_1():\n return int(sys.stdin.readline())\n\n\ndef func_2():\n return list(map(int, sys.stdin.readline().split()))\n\n\nvar_8, var_11 = func_2()\nvar_17 = [func_2() for _ in range(var_8)]\nvar_10 = var_17[::-1]\nvar_14 = [[0] * var_11 for _ in range(var_8)]\nvar_3 = [[0] * var_11 for _ in range(var_8)]\nfor var_4 in range(var_8 - 1):\n var_16, var_15 = var_17[var_4]\n for var_5 in range(var_11):\n if var_5 < var_16:\n var_14[var_4 + 1][var_5] = var_14[var_4][var_5]\n else:\n var_14[var_4 + 1][var_5] = max(\n var_14[var_4][var_5], var_14[var_4][var_5 - var_16] + var_15\n )\nvar_9 = var_14[var_8 - 1][var_11 - 1] + var_17[var_8 - 1][1]\nfor var_4 in range(var_8 - 1):\n var_16, var_15 = var_10[var_4]\n for var_5 in range(var_11):\n if var_5 < var_16:\n var_3[var_4 + 1][var_5] = var_3[var_4][var_5]\n else:\n var_3[var_4 + 1][var_5] = max(\n var_3[var_4][var_5], var_3[var_4][var_5 - var_16] + var_15\n )\n var_9 = max(var_9, var_3[var_8 - 1][var_11 - 1] + var_17[0][1])\n\nfor var_4 in range(1, var_8 - 1):\n var_13 = var_4\n var_2 = var_8 - var_4 - 1\n var_7 = 0\n for var_5 in range(var_11):\n var_12 = var_14[var_13][var_5] + var_3[var_2][var_11 - 1 - var_5]\n var_7 = max(var_7, var_12)\n var_9 = max(var_9, var_7 + var_17[var_4][1])\nprint(var_9)\n```", "output": "SLOWER 1.024", "pair_id": "python_p02863_reversed", "problem_id": "p02863", "language": "python", "direction": "reversed", "speedup_ratio": 2.0336} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().strip().split(\" \")))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n if str(var_4) == str(var_4)[::-1]:\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = [0] * (var_2 + 1)\nfor var_3 in range(1, var_2 + 1):\n if str(var_3) == str(var_3)[::-1]:\n var_4[var_3] = var_4[var_3 - 1] + 1\n else:\n var_4[var_3] = var_4[var_3 - 1]\nprint((var_4[var_2] - var_4[var_1 - 1]))\n```", "output": "SLOWER 1.635", "pair_id": "python_p03416_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 3.1059} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = input().split()\nvar_1 = int(var_1)\nvar_2 = int(\"\".join(var_2.split(\".\")))\nprint(((var_1 * var_2) // 100))\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\nimport math\nfrom collections import defaultdict\nfrom bisect import bisect_left, bisect_right\n\nsys.setrecursionlimit(10**7)\n\n\ndef func_4():\n return sys.stdin.readline()[:-1]\n\n\nvar_4 = 10**9 + 7\n\n\ndef func_1():\n return int(eval(func_4()))\n\n\ndef func_2():\n return list(map(int, func_4().split()))\n\n\ndef func_3(var_6, var_3):\n if var_6 <= 0:\n return [[] for _ in range(var_3)]\n elif var_3 == 1:\n return [func_1() for _ in range(var_6)]\n else:\n var_5 = [func_2() for _ in range(var_6)]\n return list(map(list, list(zip(*var_5))))\n\n\nvar_1, var_2 = list(map(str, func_4().split()))\nvar_1 = int(var_1)\nvar_2 = 100 * int(var_2[0]) + 10 * int(var_2[2]) + int(var_2[3])\nprint((var_1 * var_2 // 100))\n```", "output": "SLOWER 2.5041", "pair_id": "python_p02659_reversed", "problem_id": "p02659", "language": "python", "direction": "reversed", "speedup_ratio": 5.673} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = input().split()\nvar_1 = int(var_1)\nvar_2 = int(var_2)\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = list(str(var_4))\n if (var_5[0] == var_5[4]) and (var_5[1] == var_5[3]):\n var_3 = var_3 + 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\n\n\ndef func_1(var_5):\n var_4 = 0\n for var_3 in range(1, var_5 + 1):\n if str(var_3) == str(var_3)[::-1]:\n var_4 += 1\n return var_4\n\n\nprint((func_1(var_2) - func_1(var_1 - 1)))\n```", "output": "SLOWER 1.1863", "pair_id": "python_p03416_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 2.2757} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_8 = int(eval(input()))\nvar_4 = []\nfor var_5 in range(var_8):\n var_11 = 0\n var_9 = list(map(int, input().split()))\n for var_6 in range(10):\n var_11 += var_9[var_6] << var_6\n var_4.append(var_11)\nvar_10 = []\nfor var_5 in range(var_8):\n var_10.append(list(map(int, input().split())))\nvar_1 = -(10**12)\nfor var_5 in range(1, 1 << 10):\n var_11 = 0\n for var_6 in range(var_8):\n var_3 = var_4[var_6] & var_5\n var_2 = 0\n for var_7 in range(10):\n if (var_3 >> var_7) % 2:\n var_2 += 1\n var_11 += var_10[var_6][var_2]\n var_1 = max(var_1, var_11)\nprint(var_1)\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\nimport itertools\n\n\ndef func_2(var_4):\n return bin(eval(\"0b\" + str(var_4)))\n\n\ndef func_1():\n var_4 = int(sys.stdin.readline().rstrip())\n var_9 = [\n func_2(\"\".join(str(var_10) for var_10 in sys.stdin.readline().split()))\n for _ in range(var_4)\n ]\n var_8 = [\n [int(var_10) for var_10 in sys.stdin.readline().split()] for _ in range(var_4)\n ]\n var_3 = -(10**10)\n for var_6 in itertools.product(\"01\", repeat=10):\n var_6 = func_2(\"\".join(var_6))\n if var_6 == \"0b0\":\n continue\n var_7 = 0\n for var_2 in range(var_4):\n var_1 = var_9[var_2]\n var_5 = bin(eval(var_1) & eval(var_6)).count(\"1\")\n var_7 += var_8[var_2][var_5]\n var_3 = max(var_3, var_7)\n print(var_3)\n\n\nif __name__ == \"__main__\":\n\n func_1()\n```", "output": "SLOWER 2.7368", "pair_id": "python_p03503_reversed", "problem_id": "p03503", "language": "python", "direction": "reversed", "speedup_ratio": 6.6658} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = list(str(var_4))\n if var_5 == list(reversed(var_5)):\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1 = list(map(int, input().split()))\nvar_2 = 0\nfor var_3 in range(var_1[0], var_1[1] + 1):\n var_4 = str(var_3)\n if var_4[0] == var_4[4] and var_4[1] == var_4[3]:\n var_2 += 1\nprint(var_2)\n```", "output": "FASTER 1.521", "pair_id": "python_p03416_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 2.8699} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_6 in range(var_1, var_2 + 1):\n var_3 = str(var_6)\n var_5 = True\n for var_7 in range(len(var_3) // 2):\n if var_3[var_7] != var_3[-var_7 - 1] and var_5:\n var_5 = not var_5\n if var_5:\n var_4 += 1\nprint(var_4)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = str(var_4)\n if var_5 == var_5[::-1]:\n var_3 += 1\nprint(var_3)\n```", "output": "FASTER 1.4644", "pair_id": "python_p03416_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 2.7595} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport bisect\nimport sys\n\nsys.setrecursionlimit(10**6)\nvar_17 = sys.stdout.write\nvar_7 = lambda *var_15: print(*var_15) if var_1 else 0\nvar_1 = True\n\n\ndef func_1(var_10=sys.stdin.readline):\n var_12 = lambda: var_10().rstrip()\n var_3 = lambda: list(map(int, var_12().split()))\n var_2 = lambda: int(var_12())\n var_4 = lambda var_18: [var_3() for _ in range(var_18)]\n var_14, var_16 = var_3()\n var_5 = var_4(var_14)\n var_8 = [[0] * var_16 for _ in range(var_14)]\n for var_11 in range(1, var_14):\n for var_13 in range(1, var_16):\n if var_13 < var_5[var_11 - 1][0]:\n var_8[var_11][var_13] = var_8[var_11 - 1][var_13]\n else:\n var_8[var_11][var_13] = max(\n var_8[var_11 - 1][var_13],\n var_8[var_11 - 1][var_13 - var_5[var_11 - 1][0]]\n + var_5[var_11 - 1][1],\n )\n var_9 = [[0] * var_16 for _ in range(var_14)]\n for var_11 in range(1, var_14):\n for var_13 in range(1, var_16):\n if var_13 < var_5[var_14 - var_11][0]:\n var_9[var_11][var_13] = var_9[var_11 - 1][var_13]\n else:\n var_9[var_11][var_13] = max(\n var_9[var_11 - 1][var_13],\n var_9[var_11 - 1][var_13 - var_5[var_14 - var_11][0]]\n + var_5[var_14 - var_11][1],\n )\n var_6 = 0\n for var_11 in range(var_14):\n for var_13 in range(var_16 - 1):\n var_6 = max(\n var_6,\n var_8[var_11][var_13]\n + var_9[var_14 - var_11 - 1][var_16 - var_13 - 1]\n + var_5[var_11][1],\n )\n print(var_6)\n\n\nif __name__ == \"__main__\":\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\ndef func_1():\n var_2, var_3, *var_1 = list(map(int, open(0).read().split()))\n var_4 = [0] * (var_3 + max(var_1[::2]))\n for var_7, var_6 in sorted(zip(*[iter(var_1)] * 2)):\n for var_5 in reversed(list(range(var_3))):\n var_4[var_5 + var_7] = max(var_4[var_5 + var_7], var_4[var_5] + var_6)\n print((max(var_4)))\n\n\nfunc_1()\n```", "output": "FASTER 1.7019", "pair_id": "python_p02863_forward", "problem_id": "p02863", "language": "python", "direction": "forward", "speedup_ratio": 3.2534} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_8, var_9 = list(map(int, input().split()))\nvar_5 = [[0] * (var_9 + 3001) for _ in range(var_8 + 1)]\nvar_3 = 0\nvar_2 = [list(map(int, input().split())) for _ in range(var_8)]\nvar_2.sort()\nfor var_6 in range(1, var_8 + 1):\n var_1, var_4 = var_2[var_6 - 1]\n for var_7 in range(var_9):\n var_5[var_6][var_7] = max(var_5[var_6 - 1][var_7], var_5[var_6][var_7])\n var_5[var_6][var_7 + var_1] = var_5[var_6 - 1][var_7] + var_4\n var_3 = max(var_5[var_6][var_7], var_5[var_6][var_7 + var_1], var_3)\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_6, var_7 = list(map(int, input().split()))\nvar_1 = [list(map(int, input().split())) for _ in range(var_6)]\nvar_1.sort()\nvar_3 = [(6007) * [0] for _ in range(var_6 + 1)]\nvar_3[0][0] = 0\nvar_2 = 0\nfor var_4 in range(var_6):\n for var_5 in range(6007):\n var_3[var_4 + 1][var_5] = max(var_3[var_4 + 1][var_5], var_3[var_4][var_5])\n if var_5 < var_7:\n var_3[var_4 + 1][var_5 + var_1[var_4][0]] = max(\n var_3[var_4][var_5] + var_1[var_4][1],\n var_3[var_4][var_5 + var_1[var_4][0]],\n )\n var_2 = max(var_2, var_3[var_4 + 1][var_5])\nprint(var_2)\n```", "output": "SLOWER 5.2101", "pair_id": "python_p02863_reversed", "problem_id": "p02863", "language": "python", "direction": "reversed", "speedup_ratio": 37.0168} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport math\n\nvar_1, var_2 = input().split()\nvar_1 = int(var_1)\nvar_3 = int(var_2[0] + var_2[2] + var_2[3])\nprint((int(var_1 * var_3) // 100))\n```\n\n=== Code B (Modified) ===\n```python\ndef func_1():\n from sys import setrecursionlimit, stdin\n from os import environ\n from collections import defaultdict, deque, Counter\n from math import ceil, floor, gcd\n from itertools import accumulate, combinations, combinations_with_replacement\n\n setrecursionlimit(10**6)\n var_7 = (\n (lambda *var_11: print(*var_11))\n if \"TERM_PROGRAM\" in environ\n else lambda *var_12: 0\n )\n var_8 = lambda: stdin.readline().rstrip()\n var_3 = lambda: list(map(int, var_8().split()))\n var_1 = lambda: int(var_8())\n var_4 = 10**9 + 7\n var_2 = 10**9 + 10\n var_9, var_10 = var_8().split()\n var_5 = int(var_9)\n var_10 = var_10.split(\".\")\n var_6 = int(var_10[0]) * 100\n if len(var_10) == 2:\n var_6 += int(var_10[1])\n print(var_5 * var_6 // 100)\n\n\nfunc_1()\n```", "output": "SLOWER 2.1264", "pair_id": "python_p02659_reversed", "problem_id": "p02659", "language": "python", "direction": "reversed", "speedup_ratio": 4.3663} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport copy\nimport random\nimport bisect\nimport fractions\nimport math\nimport sys\nimport collections\nfrom decimal import Decimal\n\nvar_5 = 10**9 + 7\nsys.setrecursionlimit(var_5)\nvar_3 = collections.deque()\n\n\ndef func_1():\n return list(map(int, sys.stdin.readline().split()))\n\n\nvar_1 = int(eval(input()))\nvar_6 = [0 for var_4 in range(var_1)]\nfor var_4 in range(var_1):\n var_6[var_4] = int(eval(input()))\nvar_6.sort()\nvar_2 = sum(var_6)\nvar_2 -= var_6[-1] // 2\nprint(var_2)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1 = int(eval(input()))\nvar_2 = []\nfor _ in range(var_1):\n var_2.append(int(eval(input())))\nprint((sum(var_2) - max(var_2) // 2))\n```", "output": "FASTER 1.0811", "pair_id": "python_p03207_forward", "problem_id": "p03207", "language": "python", "direction": "forward", "speedup_ratio": 2.1156} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = list(str(var_4))\n if var_5 == list(reversed(var_5)):\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\ndef func_1():\n var_1, var_2 = list(map(int, input().rstrip().split()))\n var_3 = 0\n for var_4 in range(var_1, var_2 + 1):\n var_5 = str(var_4)\n if var_5 == var_5[::-1]:\n var_3 += 1\n print(var_3)\n\n\nif __name__ == \"__main__\":\n func_1()\n```", "output": "FASTER 1.9782", "pair_id": "python_p03416_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 3.9399} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\nimport itertools\n\n\ndef func_2(var_4):\n return bin(eval(\"0b\" + str(var_4)))\n\n\ndef func_1():\n var_4 = int(sys.stdin.readline().rstrip())\n var_9 = [\n func_2(\"\".join(str(var_10) for var_10 in sys.stdin.readline().split()))\n for _ in range(var_4)\n ]\n var_8 = [\n [int(var_10) for var_10 in sys.stdin.readline().split()] for _ in range(var_4)\n ]\n var_3 = -(10**10)\n for var_6 in itertools.product(\"01\", repeat=10):\n var_6 = func_2(\"\".join(var_6))\n if var_6 == \"0b0\":\n continue\n var_7 = 0\n for var_2 in range(var_4):\n var_1 = var_9[var_2]\n var_5 = bin(eval(var_1) & eval(var_6)).count(\"1\")\n var_7 += var_8[var_2][var_5]\n var_3 = max(var_3, var_7)\n print(var_3)\n\n\nif __name__ == \"__main__\":\n\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\n\nvar_7 = sys.stdin.readline\nfrom itertools import combinations\n\n\ndef func_3(var_10):\n for _ in range(var_10):\n yield list(map(int, var_7().split()))\n\n\ndef func_1(var_9, var_5, var_11):\n var_3 = sum(1 if var_5[var_8] == 1 else 0 for var_8 in var_9)\n return var_11[var_3]\n\n\ndef func_2():\n var_10 = int(eval(var_7()))\n var_1 = list(func_3(var_10))\n var_2 = list(func_3(var_10))\n for var_6 in range(1, 11):\n for var_4 in combinations(list(range(10)), var_6):\n yield sum(\n func_1(var_4, var_5, var_11) for var_5, var_11 in zip(var_1, var_2)\n )\n\n\nprint((max(func_2())))\n```", "output": "FASTER 3.6491", "pair_id": "python_p03503_forward", "problem_id": "p03503", "language": "python", "direction": "forward", "speedup_ratio": 12.5454} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport math\n\nvar_1, var_2 = input().split()\nvar_1 = int(var_1)\nvar_3 = int(var_2[0] + var_2[2] + var_2[3])\nprint((var_1 * var_3 // 100))\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\nimport math\nfrom collections import defaultdict\nfrom bisect import bisect_left, bisect_right\n\nsys.setrecursionlimit(10**7)\n\n\ndef func_4():\n return sys.stdin.readline()[:-1]\n\n\nvar_4 = 10**9 + 7\n\n\ndef func_1():\n return int(eval(func_4()))\n\n\ndef func_2():\n return list(map(int, func_4().split()))\n\n\ndef func_3(var_6, var_3):\n if var_6 <= 0:\n return [[] for _ in range(var_3)]\n elif var_3 == 1:\n return [func_1() for _ in range(var_6)]\n else:\n var_5 = [func_2() for _ in range(var_6)]\n return list(map(list, list(zip(*var_5))))\n\n\nfrom decimal import getcontext, Decimal\n\ngetcontext().prec = 28\nvar_1, var_2 = list(map(str, func_4().split()))\nvar_1 = int(var_1)\nvar_2 = Decimal(var_2)\nprint((int(var_1 * var_2)))\n```", "output": "SLOWER 2.3373", "pair_id": "python_p02659_reversed", "problem_id": "p02659", "language": "python", "direction": "reversed", "speedup_ratio": 5.0534} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_5 = 0\nif var_5 == 0:\n var_8 = int(eval(input()))\n var_2 = []\n for var_4 in range(var_8):\n var_3 = list(map(int, input().split()))\n var_2.append(var_3)\n var_9 = []\n for var_4 in range(var_8):\n var_10 = list(map(int, input().split()))\n var_9.append(var_10)\nelif var_5 == 1:\n var_8 = 1\n var_2 = [[1, 1, 0, 1, 0, 0, 0, 1, 0, 1]]\n var_9 = [[3, 4, 5, 6, 7, 8, 9, -2, -3, 4, -2]]\nelif var_5 == 2:\n var_8 = 2\n var_2 = [[1, 1, 1, 1, 1, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 1, 1, 1, 1, 1]]\n var_9 = [\n [0, -2, -2, -2, -2, -2, -1, -1, -1, -1, -1],\n [0, -2, -2, -2, -2, -2, -1, -1, -1, -1, -1],\n ]\nelif var_5 == 3:\n var_8 = 3\n var_2 = [\n [1, 1, 1, 1, 1, 1, 0, 0, 1, 1],\n [0, 1, 0, 1, 1, 1, 1, 0, 1, 0],\n [1, 0, 1, 1, 0, 1, 0, 1, 0, 1],\n ]\n var_9 = [\n [-8, 6, -2, -8, -8, 4, 8, 7, -6, 2, 2],\n [-9, 2, 0, 1, 7, -5, 0, -2, -6, 5, 5],\n [6, -6, 7, -9, 6, -5, 8, 0, -9, -7, -7],\n ]\nimport itertools\n\nvar_13 = -(10**11)\nfor var_4 in itertools.product([0, 1], repeat=10):\n var_11 = list(var_4)\n var_12 = 0\n if sum(var_11) != 0:\n for var_7 in range(var_8):\n var_1 = 0\n for var_6 in range(10):\n var_1 = var_1 + var_11[var_6] * var_2[var_7][var_6]\n var_12 = var_12 + var_9[var_7][var_1]\n\n var_13 = max(var_12, var_13)\nprint(var_13)\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\n\nvar_7 = sys.stdin.readline\nfrom itertools import combinations\n\n\ndef func_3(var_10):\n for _ in range(var_10):\n yield list(map(int, var_7().split()))\n\n\ndef func_1(var_9, var_5, var_11):\n var_3 = len([0 for var_8 in var_9 if var_5[var_8] == 1])\n return var_11[var_3]\n\n\ndef func_2():\n var_10 = int(eval(var_7()))\n var_1 = list(func_3(var_10))\n var_2 = list(func_3(var_10))\n for var_6 in range(1, 11):\n for var_4 in combinations(list(range(10)), var_6):\n yield sum(\n func_1(var_4, var_5, var_11) for var_5, var_11 in zip(var_1, var_2)\n )\n\n\nprint((max(func_2())))\n```", "output": "FASTER 2.018", "pair_id": "python_p03503_forward", "problem_id": "p03503", "language": "python", "direction": "forward", "speedup_ratio": 4.0503} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_6 in range(var_1, var_2 + 1):\n var_3 = str(var_6)\n var_5 = True\n for var_7 in range(len(var_3) // 2):\n if var_3[var_7] != var_3[-var_7 - 1] and var_5:\n var_5 = not var_5\n if var_5:\n var_4 += 1\nprint(var_4)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = str(var_4)\n if var_5[0] == var_5[4] and var_5[1] == var_5[3]:\n var_3 += 1\nprint(var_3)\n```", "output": "FASTER 1.7261", "pair_id": "python_p03416_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 3.3083} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\ndef func_1():\n var_1, var_2 = list(map(int, input().rstrip().split()))\n var_3 = 0\n for var_4 in range(var_1, var_2 + 1):\n var_5 = str(var_4)\n if var_5 == var_5[::-1]:\n var_3 += 1\n print(var_3)\n\n\nif __name__ == \"__main__\":\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = [0] * (var_2 + 1)\nfor var_3 in range(1, var_2 + 1):\n if str(var_3) == str(var_3)[::-1]:\n var_4[var_3] = var_4[var_3 - 1] + 1\n else:\n var_4[var_3] = var_4[var_3 - 1]\nprint((var_4[var_2] - var_4[var_1 - 1]))\n```", "output": "SLOWER 2.6882", "pair_id": "python_p03416_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 6.4453} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = [\n var_3 for var_3 in map(str, list(range(var_1, var_2 + 1))) if var_3 == var_3[::-1]\n]\nprint((len(var_4)))\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_6 in range(var_1, var_2 + 1):\n var_3 = str(var_6)\n var_5 = True\n for var_7 in range(len(var_3) // 2):\n if var_3[var_7] != var_3[-var_7 - 1] and var_5:\n var_5 = not var_5\n if var_5:\n var_4 += 1\nprint(var_4)\n```", "output": "SLOWER 2.1585", "pair_id": "python_p03416_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 4.4645} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_5 in range(10):\n for var_6 in range(10):\n for var_7 in range(10):\n var_3 = 10000 * var_5 + 1000 * var_6 + 100 * var_7 + 10 * var_6 + var_5\n if var_1 <= var_3 <= var_2:\n var_4 += 1\nprint(var_4)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_6 = str(var_4)\n var_5 = var_6[::-1]\n if var_6 == var_5:\n var_3 += 1\nprint(var_3)\n```", "output": "SLOWER 4.076", "pair_id": "python_p03416_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 16.8649} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n if str(var_4) == \"\".join(reversed(str(var_4))):\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\n\n\ndef func_1(var_5, var_6):\n var_4 = 0\n for var_3 in range(var_5, var_6 + 1):\n if str(var_3) == str(var_3)[::-1]:\n var_4 += 1\n return var_4\n\n\nprint((func_1(var_1, var_2)))\n```", "output": "FASTER 1.3999", "pair_id": "python_p03416_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 2.6388} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_4 = {}\nvar_5 = 0\nfor var_6 in range(10000, 100000):\n var_3 = list(str(var_6))\n if var_3 == list(reversed(var_3)):\n var_5 += 1\n var_4[var_6] = var_5\nvar_1, var_2 = list(map(int, input().split()))\nprint((var_4[var_2] - var_4[var_1 - 1] if var_1 > 10000 else var_4[var_2]))\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\n\n\ndef func_1(var_5):\n var_4 = 0\n for var_3 in range(1, var_5 + 1):\n if str(var_3) == str(var_3)[::-1]:\n var_4 += 1\n return var_4\n\n\nprint((func_1(var_2) - func_1(var_1 - 1)))\n```", "output": "FASTER 1.983", "pair_id": "python_p03416_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 3.9531} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport math\nfrom decimal import Decimal\n\nvar_1, var_2 = list(map(Decimal, input().split()))\nprint((math.floor(var_1 * var_2)))\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\nimport math\nfrom collections import defaultdict\nfrom bisect import bisect_left, bisect_right\n\nsys.setrecursionlimit(10**7)\n\n\ndef func_4():\n return sys.stdin.readline()[:-1]\n\n\nvar_4 = 10**9 + 7\n\n\ndef func_1():\n return int(eval(func_4()))\n\n\ndef func_2():\n return list(map(int, func_4().split()))\n\n\ndef func_3(var_6, var_3):\n if var_6 <= 0:\n return [[] for _ in range(var_3)]\n elif var_3 == 1:\n return [func_1() for _ in range(var_6)]\n else:\n var_5 = [func_2() for _ in range(var_6)]\n return list(map(list, list(zip(*var_5))))\n\n\nfrom decimal import getcontext, Decimal\n\ngetcontext().prec = 28\nvar_1, var_2 = list(map(str, func_4().split()))\nvar_1 = int(var_1)\nvar_2 = Decimal(var_2)\nprint((int(var_1 * var_2)))\n```", "output": "SLOWER 2.4359", "pair_id": "python_p02659_reversed", "problem_id": "p02659", "language": "python", "direction": "reversed", "speedup_ratio": 5.4109} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\ndef func_1():\n var_2, var_3, *var_1 = list(map(int, open(0).read().split()))\n var_4 = [0] * (var_3 + max(var_1[::2]))\n for var_7, var_6 in sorted(zip(*[iter(var_1)] * 2)):\n for var_5 in reversed(list(range(var_3))):\n var_4[var_5 + var_7] = max(var_4[var_5 + var_7], var_4[var_5] + var_6)\n print((max(var_4)))\n\n\nfunc_1()\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\n\nvar_9 = sys.stdin.readline\nfrom operator import itemgetter\n\nvar_3, var_4 = list(map(int, var_9().split()))\nvar_1 = [list(map(int, var_9().split())) for _ in range(var_3)]\nvar_1.sort(key=itemgetter(0))\nvar_8 = [[0 for _ in range(var_3 + 1)] for _ in range(var_4 + 1)]\n\nvar_2 = []\nfor var_10 in range(var_3):\n var_5, var_7 = var_1[var_10]\n for var_11 in range(var_4):\n if var_5 > var_11:\n var_8[var_11][var_10 + 1] = var_8[var_11][var_10]\n else:\n if var_7 + var_8[var_11 - var_5][var_10] >= var_8[var_11][var_10]:\n var_8[var_11][var_10 + 1] = var_8[var_11 - var_5][var_10] + var_7\n else:\n var_8[var_11][var_10 + 1] = var_8[var_11][var_10]\n var_2.append(var_8[var_4 - 1][var_10] + var_7)\nvar_6 = max(var_2)\nprint(var_6)\n```", "output": "SLOWER 1.2754", "pair_id": "python_p02863_reversed", "problem_id": "p02863", "language": "python", "direction": "reversed", "speedup_ratio": 2.4207} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\ndef func_1():\n var_1, var_2 = list(map(int, input().rstrip().split()))\n var_3 = 0\n for var_4 in range(var_1, var_2 + 1):\n var_5 = str(var_4)\n if var_5 == var_5[::-1]:\n var_3 += 1\n print(var_3)\n\n\nif __name__ == \"__main__\":\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_6 in range(var_1, var_2 + 1):\n var_3 = str(var_6)\n var_5 = True\n for var_7 in range(len(var_3) // 2):\n if var_3[var_7] != var_3[-var_7 - 1] and var_5:\n var_5 = not var_5\n if var_5:\n var_4 += 1\nprint(var_4)\n```", "output": "SLOWER 2.2059", "pair_id": "python_p03416_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 4.6137} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = list(reversed(list(str(var_4))))\n if var_5 == list(str(var_4)):\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = str(var_4)\n if var_5 == var_5[::-1]:\n var_3 += 1\nprint(var_3)\n```", "output": "FASTER 1.6614", "pair_id": "python_p03416_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 3.1633} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_6 = sorted([list(map(int, input().split())) for var_5 in range(var_1)])\n\nvar_4 = [[0] * (var_2 + 1) for var_5 in range(var_1 + 1)]\n\nfor var_5 in range(var_1):\n var_9, var_8 = var_6[var_5]\n for var_7 in range(var_2 + 1):\n if var_7 + var_9 <= var_2:\n var_4[var_5 + 1][var_7 + var_9] = max(\n var_4[var_5 + 1][var_7 + var_9], var_4[var_5][var_7] + var_8\n )\n var_4[var_5 + 1][var_7] = max(var_4[var_5][var_7], var_4[var_5 + 1][var_7])\nvar_3 = 0\nfor var_5, (var_9, var_8) in enumerate(var_6):\n var_3 = max(var_3, var_4[var_5][var_2 - 1] + var_8)\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_6, var_7 = list(map(int, input().split()))\nvar_1 = [list(map(int, input().split())) for _ in range(var_6)]\nvar_1.sort()\nvar_3 = [(6007) * [0] for _ in range(var_6 + 1)]\nvar_3[0][0] = 0\nvar_2 = 0\nfor var_4 in range(var_6):\n for var_5 in range(6007):\n var_3[var_4 + 1][var_5] = max(var_3[var_4 + 1][var_5], var_3[var_4][var_5])\n if var_5 < var_7:\n var_3[var_4 + 1][var_5 + var_1[var_4][0]] = max(\n var_3[var_4][var_5] + var_1[var_4][1],\n var_3[var_4][var_5 + var_1[var_4][0]],\n )\n var_2 = max(var_2, var_3[var_4 + 1][var_5])\nprint(var_2)\n```", "output": "SLOWER 5.3151", "pair_id": "python_p02863_reversed", "problem_id": "p02863", "language": "python", "direction": "reversed", "speedup_ratio": 39.8117} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_4 = {}\nvar_5 = 0\nfor var_6 in range(10000, 100000):\n var_3 = list(str(var_6))\n if var_3 == list(reversed(var_3)):\n var_5 += 1\n var_4[var_6] = var_5\nvar_1, var_2 = list(map(int, input().split()))\nprint((var_4[var_2] - var_4[var_1 - 1] if var_1 > 10000 else var_4[var_2]))\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = str(var_4)\n if var_5[0] == var_5[4] and var_5[1] == var_5[3]:\n var_3 += 1\nprint(var_3)\n```", "output": "FASTER 3.8398", "pair_id": "python_p03416_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 14.318} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\ndef func_1():\n from sys import setrecursionlimit, stdin\n from os import environ\n from collections import defaultdict, deque, Counter\n from math import ceil, floor, gcd\n from itertools import accumulate, combinations, combinations_with_replacement\n\n setrecursionlimit(10**6)\n var_7 = (\n (lambda *var_11: print(*var_11))\n if \"TERM_PROGRAM\" in environ\n else lambda *var_12: 0\n )\n var_8 = lambda: stdin.readline().rstrip()\n var_3 = lambda: list(map(int, var_8().split()))\n var_1 = lambda: int(var_8())\n var_4 = 10**9 + 7\n var_2 = 10**9 + 10\n var_9, var_10 = var_8().split()\n var_5 = int(var_9)\n var_10 = var_10.split(\".\")\n var_6 = int(var_10[0]) * 100\n if len(var_10) == 2:\n var_6 += int(var_10[1])\n print(var_5 * var_6 // 100)\n\n\nfunc_1()\n```\n\n=== Code B (Modified) ===\n```python\nfrom decimal import Decimal\nimport math\n\nvar_1, var_2 = list(map(str, input().split()))\nvar_1 = int(var_1)\nvar_2 = Decimal(var_2)\nvar_3 = math.floor(var_1 * var_2)\nprint((int(var_3)))\n```", "output": "FASTER 1.825", "pair_id": "python_p02659_forward", "problem_id": "p02659", "language": "python", "direction": "forward", "speedup_ratio": 3.543} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nfrom collections import Counter, defaultdict, deque\nfrom heapq import heappop, heappush, heapify\nimport sys, bisect, math, itertools, fractions, pprint\n\nsys.setrecursionlimit(10**8)\nvar_6 = 10**9 + 7\nvar_1 = float(\"inf\")\n\n\ndef func_1():\n return int(sys.stdin.readline())\n\n\ndef func_2():\n return list(map(int, sys.stdin.readline().split()))\n\n\nvar_8, var_11 = func_2()\nvar_17 = [func_2() for _ in range(var_8)]\nvar_10 = var_17[::-1]\nvar_14 = [[0] * var_11 for _ in range(var_8)]\nvar_3 = [[0] * var_11 for _ in range(var_8)]\nfor var_4 in range(var_8 - 1):\n var_16, var_15 = var_17[var_4]\n for var_5 in range(var_11):\n if var_5 < var_16:\n var_14[var_4 + 1][var_5] = var_14[var_4][var_5]\n else:\n var_14[var_4 + 1][var_5] = max(\n var_14[var_4][var_5], var_14[var_4][var_5 - var_16] + var_15\n )\nvar_9 = var_14[var_8 - 1][var_11 - 1] + var_17[var_8 - 1][1]\nfor var_4 in range(var_8 - 1):\n var_16, var_15 = var_10[var_4]\n for var_5 in range(var_11):\n if var_5 < var_16:\n var_3[var_4 + 1][var_5] = var_3[var_4][var_5]\n else:\n var_3[var_4 + 1][var_5] = max(\n var_3[var_4][var_5], var_3[var_4][var_5 - var_16] + var_15\n )\n var_9 = max(var_9, var_3[var_8 - 1][var_11 - 1] + var_17[0][1])\n\nfor var_4 in range(1, var_8 - 1):\n var_13 = var_4\n var_2 = var_8 - var_4 - 1\n var_7 = 0\n for var_5 in range(var_11):\n var_12 = var_14[var_13][var_5] + var_3[var_2][var_11 - 1 - var_5]\n var_7 = max(var_7, var_12)\n var_9 = max(var_9, var_7 + var_17[var_4][1])\nprint(var_9)\n```\n\n=== Code B (Modified) ===\n```python\nvar_2, var_3, *var_1 = list(map(int, open(0).read().split()))\nvar_4 = [0] * (var_3 + max(var_1[::2]))\nfor var_7, var_6 in sorted(zip(*[iter(var_1)] * 2)):\n for var_5 in reversed(list(range(var_3))):\n var_4[var_5 + var_7] = max(var_4[var_5 + var_7], var_4[var_5] + var_6)\nprint((max(var_4)))\n```", "output": "FASTER 1.5875", "pair_id": "python_p02863_forward", "problem_id": "p02863", "language": "python", "direction": "forward", "speedup_ratio": 3.0053} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_3 = list(map(int, input().split()))\nvar_2 = 0\nfor var_5 in range(var_3 + 1)[var_1:]:\n if len(str(var_5)) % 2 == 0:\n var_6 = list(str(var_5))[: len(str(var_5)) // 2]\n var_7 = list(reversed(list(str(var_5))[len(str(var_5)) // 2 :]))\n if var_6 == var_7:\n var_2 += 1\n else:\n var_8 = list(str(var_5))[: len(str(var_5)) // 2 + 1]\n var_4 = list(reversed(list(str(var_5))[len(str(var_5)) // 2 :]))\n if var_8 == var_4:\n var_2 += 1\nprint(var_2)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_4 = str(var_4)\n if var_4[0] == var_4[-1] and var_4[1] == var_4[-2]:\n var_3 += 1\nprint(var_3)\n```", "output": "FASTER 2.6583", "pair_id": "python_p03416_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 6.3127} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport copy\n\nvar_8 = int(eval(input()))\nvar_10 = set([var_6 for var_6 in range(1, 10**5)])\nvar_5 = []\nvar_11 = {}\nvar_9 = []\nfor var_6 in range(var_8 - 1):\n var_1, var_2 = list(map(int, input().split(\" \")))\n var_5.append([var_1, var_2])\n var_11.setdefault(var_1, []).append(var_2)\n var_9.append([])\nvar_9.append([])\nvar_9.append([])\nvar_7 = 0\nfor var_12 in range(1, var_8 + 1):\n var_14 = var_11.get(var_12, [])\n var_3 = 1\n for var_13 in var_14:\n if var_3 in var_9[var_12]:\n var_3 += 1\n else:\n pass\n var_9[var_13].append(var_3)\n if var_3 >= var_7:\n var_7 = var_3\n var_3 += 1\nprint(var_7)\nfor var_4 in var_5:\n print((var_9[var_4[1]][0]))\n```\n\n=== Code B (Modified) ===\n```python\nfrom collections import deque\n\nvar_4, *var_2 = list(map(int, open(0).read().split()))\nvar_3 = [set() for _ in range(var_4 + 1)]\nfor var_9, (var_6, var_7) in enumerate(zip(*[iter(var_2)] * 2)):\n var_3[var_6].add((var_7, var_9))\n var_3[var_7].add((var_6, var_9))\nvar_1 = [0] * (var_4 - 1)\nvar_5 = deque([1])\nwhile var_5:\n var_10, var_12 = divmod(var_5.popleft(), var_4 + 1)\n var_8 = 0\n for var_11, var_9 in var_3[var_12]:\n var_3[var_11].remove((var_12, var_9))\n var_8 += 1 + (var_8 + 1 == var_10)\n var_5.append(var_8 * (var_4 + 1) + var_11)\n var_1[var_9] = var_8\nprint((max(var_1)))\nprint((\"\\n\".join(map(str, var_1))))\n```", "output": "FASTER 4.4548", "pair_id": "python_p02850_forward", "problem_id": "p02850", "language": "python", "direction": "forward", "speedup_ratio": 21.93} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport bisect\nimport sys\n\nsys.setrecursionlimit(10**6)\nvar_17 = sys.stdout.write\nvar_7 = lambda *var_15: print(*var_15) if var_1 else 0\nvar_1 = True\n\n\ndef func_1(var_10=sys.stdin.readline):\n var_12 = lambda: var_10().rstrip()\n var_3 = lambda: list(map(int, var_12().split()))\n var_2 = lambda: int(var_12())\n var_4 = lambda var_18: [var_3() for _ in range(var_18)]\n var_14, var_16 = var_3()\n var_5 = var_4(var_14)\n var_8 = [[0] * var_16 for _ in range(var_14)]\n for var_11 in range(1, var_14):\n for var_13 in range(1, var_16):\n if var_13 < var_5[var_11 - 1][0]:\n var_8[var_11][var_13] = var_8[var_11 - 1][var_13]\n else:\n var_8[var_11][var_13] = max(\n var_8[var_11 - 1][var_13],\n var_8[var_11 - 1][var_13 - var_5[var_11 - 1][0]]\n + var_5[var_11 - 1][1],\n )\n var_9 = [[0] * var_16 for _ in range(var_14)]\n for var_11 in range(1, var_14):\n for var_13 in range(1, var_16):\n if var_13 < var_5[var_14 - var_11][0]:\n var_9[var_11][var_13] = var_9[var_11 - 1][var_13]\n else:\n var_9[var_11][var_13] = max(\n var_9[var_11 - 1][var_13],\n var_9[var_11 - 1][var_13 - var_5[var_14 - var_11][0]]\n + var_5[var_14 - var_11][1],\n )\n var_6 = 0\n for var_11 in range(var_14):\n for var_13 in range(var_16 - 1):\n var_6 = max(\n var_6,\n var_8[var_11][var_13]\n + var_9[var_14 - var_11 - 1][var_16 - var_13 - 1]\n + var_5[var_11][1],\n )\n print(var_6)\n\n\nif __name__ == \"__main__\":\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nfrom collections import Counter, defaultdict, deque\nfrom heapq import heappop, heappush, heapify\nimport sys, bisect, math, itertools, fractions, pprint\n\nsys.setrecursionlimit(10**8)\nvar_6 = 10**9 + 7\nvar_1 = float(\"inf\")\n\n\ndef func_1():\n return int(sys.stdin.readline())\n\n\ndef func_2():\n return list(map(int, sys.stdin.readline().split()))\n\n\nvar_7, var_9 = func_2()\nvar_13 = [func_2() for _ in range(var_7)]\nvar_13.sort(key=lambda var_14: var_14[1], reverse=True)\nvar_8 = 0\nvar_10 = min(var_7, 5)\nfor var_3 in range(var_10):\n var_2 = [[0] * (var_9 + 5) for _ in range(var_7 + 5)]\n for var_4 in range(var_7):\n var_12, var_11 = var_13[var_4]\n for var_5 in range(var_9):\n if var_5 < var_12 or var_3 == var_4:\n var_2[var_4 + 1][var_5] = var_2[var_4][var_5]\n else:\n var_2[var_4 + 1][var_5] = max(\n var_2[var_4][var_5], var_2[var_4][var_5 - var_12] + var_11\n )\n\n var_8 = max(var_2[var_7][var_9 - 1] + var_13[var_3][1], var_8)\nprint(var_8)\n```", "output": "SLOWER 1.236", "pair_id": "python_p02863_reversed", "problem_id": "p02863", "language": "python", "direction": "reversed", "speedup_ratio": 2.3555} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_7 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_3 = True\n var_8 = str(var_4)\n var_6 = len(var_8)\n for var_5 in range(var_6 // 2 + 1):\n if var_8[var_5] != var_8[-var_5 - 1]:\n var_3 = False\n break\n if var_3:\n var_7 += 1\nprint(var_7)\n```\n\n=== Code B (Modified) ===\n```python\nfrom sys import stdin\n\nvar_6 = lambda: list(map(int, stdin.readline().split()))\nvar_5 = lambda: list(map(int, stdin.readline().split()))\nvar_1, var_3 = var_6()\nvar_2 = 0\nfor var_4 in range(var_1, var_3 + 1):\n var_7 = str(var_4)\n if var_7 == var_7[::-1]:\n var_2 += 1\nprint(var_2)\n```", "output": "FASTER 1.1067", "pair_id": "python_p03416_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 2.1535} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nfrom itertools import product\n\nvar_6 = int(eval(input()))\nvar_1 = list(map(int, input().split()))\nvar_5 = 0\nfor var_2 in product((-1, 0, 1), repeat=var_6):\n var_7 = 1\n for var_3, var_4 in zip(var_1, var_2):\n var_7 *= var_3 + var_4\n if var_7 % 2 == 0:\n var_5 += 1\nprint(var_5)\n```\n\n=== Code B (Modified) ===\n```python\nimport math\nimport string\n\n\ndef func_5():\n return list(map(int, input().split()))\n\n\ndef func_4(var_7, var_8):\n return math.factorial(var_7) // (\n math.factorial(var_7 - var_8) * math.factorial(var_8)\n )\n\n\ndef func_3(var_10):\n var_9 = []\n for var_5 in var_10:\n if not (var_5 in var_9):\n var_9.append(var_5)\n return len(var_10) != len(var_9)\n\n\ndef func_1(var_7):\n func_1 = []\n for var_4 in range(1, var_7 + 1):\n if var_7 % var_4 == 0:\n func_1.append(var_4)\n return func_1\n\n\nvar_2 = [-1, -1, -1, 0, 0, 1, 1, 1]\nvar_3 = [-1, 0, 1, -1, 1, -1, 0, 1]\nvar_7 = int(eval(input()))\nvar_1 = func_5()\n\n\ndef func_2(var_6):\n if len(var_6) == var_7:\n for var_4 in range(len(var_6)):\n if var_6[var_4] % 2 == 0:\n return 1\n return 0\n return (\n func_2(var_6 + [var_1[len(var_6)]])\n + func_2(var_6 + [var_1[len(var_6)] - 1])\n + func_2(var_6 + [var_1[len(var_6)] + 1])\n )\n\n\nprint((func_2([])))\n```", "output": "FASTER 2.3865", "pair_id": "python_p03568_forward", "problem_id": "p03568", "language": "python", "direction": "forward", "speedup_ratio": 5.2288} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_8 = int(eval(input()))\nvar_4 = []\nfor var_5 in range(var_8):\n var_11 = 0\n var_9 = list(map(int, input().split()))\n for var_6 in range(10):\n var_11 += var_9[var_6] << var_6\n var_4.append(var_11)\nvar_10 = []\nfor var_5 in range(var_8):\n var_10.append(list(map(int, input().split())))\nvar_1 = -(10**12)\nfor var_5 in range(1, 1 << 10):\n var_11 = 0\n for var_6 in range(var_8):\n var_3 = var_4[var_6] & var_5\n var_2 = 0\n for var_7 in range(10):\n if (var_3 >> var_7) % 2:\n var_2 += 1\n var_11 += var_10[var_6][var_2]\n var_1 = max(var_1, var_11)\nprint(var_1)\n```\n\n=== Code B (Modified) ===\n```python\nfrom sys import stdin\n\n\ndef func_1():\n\n var_11 = stdin.readline\n var_2 = int(var_11())\n var_1 = []\n for var_6 in range(var_2):\n var_5 = int(\"\".join(var_11().strip().split(\" \")), 2)\n var_1.append(var_5)\n var_3 = []\n for var_6 in range(var_2):\n var_10 = list(map(int, var_11().split()))\n var_3.append(var_10)\n var_8 = float(\"-inf\")\n for var_9 in range(1, 1 << 10):\n var_12 = 0\n for var_7 in range(var_2):\n var_4 = bin(var_9 & var_1[var_7]).count(\"1\")\n var_12 += var_3[var_7][var_4]\n var_8 = max(var_12, var_8)\n print(var_8)\n\n\nif __name__ == \"__main__\":\n func_1()\n```", "output": "FASTER 2.7133", "pair_id": "python_p03503_forward", "problem_id": "p03503", "language": "python", "direction": "forward", "speedup_ratio": 6.558} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\nimport itertools\n\n\ndef func_2(var_4):\n return bin(eval(\"0b\" + str(var_4)))\n\n\ndef func_1():\n var_4 = int(sys.stdin.readline().rstrip())\n var_9 = [\n func_2(\"\".join(str(var_10) for var_10 in sys.stdin.readline().split()))\n for _ in range(var_4)\n ]\n var_8 = [\n [int(var_10) for var_10 in sys.stdin.readline().split()] for _ in range(var_4)\n ]\n var_3 = -(10**10)\n for var_6 in itertools.product(\"01\", repeat=10):\n var_6 = func_2(\"\".join(var_6))\n if var_6 == \"0b0\":\n continue\n var_7 = 0\n for var_2 in range(var_4):\n var_1 = var_9[var_2]\n var_5 = bin(eval(var_1) & eval(var_6)).count(\"1\")\n var_7 += var_8[var_2][var_5]\n var_3 = max(var_3, var_7)\n print(var_3)\n\n\nif __name__ == \"__main__\":\n\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nvar_8 = int(eval(input()))\nvar_4 = []\nfor var_5 in range(var_8):\n var_11 = 0\n var_9 = list(map(int, input().split()))\n for var_6 in range(10):\n var_11 += var_9[var_6] << var_6\n var_4.append(var_11)\nvar_10 = []\nfor var_5 in range(var_8):\n var_10.append(list(map(int, input().split())))\nvar_1 = -(10**12)\nfor var_5 in range(1, 1 << 10):\n var_11 = 0\n for var_6 in range(var_8):\n var_3 = list(bin(var_4[var_6] & var_5)[2:])\n var_2 = 0\n for var_7 in var_3:\n if var_7 == \"1\":\n var_2 += 1\n var_11 += var_10[var_6][var_2]\n var_1 = max(var_1, var_11)\nprint(var_1)\n```", "output": "FASTER 3.1052", "pair_id": "python_p03503_forward", "problem_id": "p03503", "language": "python", "direction": "forward", "speedup_ratio": 8.605} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\nfrom operator import itemgetter\nfrom heapq import heapify, heappop, heappush\n\nvar_1 = int(10e15)\nvar_2 = -var_1\nvar_11 = 1000000007\nsys.setrecursionlimit(1000000)\n\n\ndef func_2():\n return list(map(int, input().split()))\n\n\ndef func_4():\n return input().split()\n\n\ndef func_1():\n return int(sys.stdin.readline())\n\n\ndef func_3():\n return eval(input())\n\n\nvar_3, var_4 = func_2()\nvar_5 = [func_2() for var_9 in range(var_3)]\nvar_5.sort(key=itemgetter(0))\n\nvar_8 = [[0] * (var_4 + 1 + 3000 + 1) for _ in range(var_3 + 1)]\nvar_6 = 0\nfor var_9 in range(var_3):\n for var_10 in range(var_4 + 1 + 3000 + 1):\n var_12, var_7 = var_5[var_9]\n if 0 <= var_10 - var_12 < var_4:\n var_8[var_9 + 1][var_10] = max(\n var_8[var_9][var_10], var_8[var_9][var_10 - var_12] + var_7\n )\n else:\n var_8[var_9 + 1][var_10] = var_8[var_9][var_10]\n var_6 = max(var_6, var_8[var_9 + 1][var_10])\nprint(var_6)\n```\n\n=== Code B (Modified) ===\n```python\nfrom sys import stdin\n\n\ndef func_1():\n\n var_9 = stdin.readline\n var_8, var_10 = list(map(int, var_9().split()))\n var_7 = [list(map(int, var_9().split())) for _ in range(var_8)]\n var_7.sort()\n var_1 = [0] * var_8\n var_2 = [0] * var_8\n for var_4 in range(var_8):\n var_1[var_4], var_2[var_4] = var_7[var_4][0], var_7[var_4][1]\n\n var_5 = -float(\"inf\")\n var_3 = [[var_5] * (var_10 + 1) for _ in range(var_8 + 1)]\n var_3[0][0] = 0\n for var_4 in range(var_8):\n for var_6 in range(var_10 + 1):\n\n if var_6 != var_10:\n var_3[var_4 + 1][min(var_10, var_6 + var_1[var_4])] = max(\n var_3[var_4 + 1][min(var_10, var_6 + var_1[var_4])],\n var_3[var_4][var_6] + var_2[var_4],\n )\n\n var_3[var_4 + 1][var_6] = max(var_3[var_4 + 1][var_6], var_3[var_4][var_6])\n print((max(var_3[var_8])))\n\n\nif __name__ == \"__main__\":\n func_1()\n```", "output": "FASTER 4.8948", "pair_id": "python_p02863_forward", "problem_id": "p02863", "language": "python", "direction": "forward", "speedup_ratio": 29.7492} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_5 = 0\nif var_5 == 0:\n var_8 = int(eval(input()))\n var_2 = []\n for var_4 in range(var_8):\n var_3 = list(map(int, input().split()))\n var_2.append(var_3)\n var_9 = []\n for var_4 in range(var_8):\n var_10 = list(map(int, input().split()))\n var_9.append(var_10)\nelif var_5 == 1:\n var_8 = 1\n var_2 = [[1, 1, 0, 1, 0, 0, 0, 1, 0, 1]]\n var_9 = [[3, 4, 5, 6, 7, 8, 9, -2, -3, 4, -2]]\nelif var_5 == 2:\n var_8 = 2\n var_2 = [[1, 1, 1, 1, 1, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 1, 1, 1, 1, 1]]\n var_9 = [\n [0, -2, -2, -2, -2, -2, -1, -1, -1, -1, -1],\n [0, -2, -2, -2, -2, -2, -1, -1, -1, -1, -1],\n ]\nelif var_5 == 3:\n var_8 = 3\n var_2 = [\n [1, 1, 1, 1, 1, 1, 0, 0, 1, 1],\n [0, 1, 0, 1, 1, 1, 1, 0, 1, 0],\n [1, 0, 1, 1, 0, 1, 0, 1, 0, 1],\n ]\n var_9 = [\n [-8, 6, -2, -8, -8, 4, 8, 7, -6, 2, 2],\n [-9, 2, 0, 1, 7, -5, 0, -2, -6, 5, 5],\n [6, -6, 7, -9, 6, -5, 8, 0, -9, -7, -7],\n ]\nimport itertools\n\nvar_13 = -(10**11)\nfor var_4 in itertools.product([0, 1], repeat=10):\n var_11 = list(var_4)\n var_12 = 0\n if sum(var_11) != 0:\n for var_7 in range(var_8):\n var_1 = 0\n for var_6 in range(10):\n var_1 = var_1 + var_11[var_6] * var_2[var_7][var_6]\n var_12 = var_12 + var_9[var_7][var_1]\n\n var_13 = max(var_12, var_13)\nprint(var_13)\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\n\nvar_7 = sys.stdin.readline\nfrom itertools import combinations\n\n\ndef func_3(var_10):\n for _ in range(var_10):\n yield list(map(int, var_7().split()))\n\n\ndef func_1(var_9, var_5, var_11):\n var_3 = sum(1 if var_5[var_8] == 1 else 0 for var_8 in var_9)\n return var_11[var_3]\n\n\ndef func_2():\n var_10 = int(eval(var_7()))\n var_1 = list(func_3(var_10))\n var_2 = list(func_3(var_10))\n for var_6 in range(1, 11):\n for var_4 in combinations(list(range(10)), var_6):\n yield sum(\n func_1(var_4, var_5, var_11) for var_5, var_11 in zip(var_1, var_2)\n )\n\n\nprint((max(func_2())))\n```", "output": "FASTER 1.4725", "pair_id": "python_p03503_forward", "problem_id": "p03503", "language": "python", "direction": "forward", "speedup_ratio": 2.775} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport itertools\n\nvar_6 = int(eval(input()))\nvar_2 = [[]] * var_6\nfor var_4 in range(var_6):\n var_3 = list(map(int, input().split()))\n\n var_2[var_4] = var_3\nvar_8 = [[]] * var_6\nfor var_4 in range(var_6):\n var_9 = list(map(int, input().split()))\n var_8[var_4] = var_9\nvar_10 = -(10**11)\nfor var_1 in itertools.product([0, 1], repeat=10):\n if sum(var_1) == 0:\n continue\n var_11 = 0\n for var_7 in range(var_6):\n var_5 = 0\n for var_4 in range(10):\n if var_2[var_7][var_4] == 1 and var_1[var_4] == 1:\n var_5 += 1\n var_11 = var_11 + var_8[var_7][var_5]\n var_10 = max(var_10, var_11)\nprint(var_10)\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\nimport itertools\n\n\ndef func_2(var_4):\n return bin(eval(\"0b\" + str(var_4)))\n\n\ndef func_1():\n var_4 = int(sys.stdin.readline().rstrip())\n var_9 = [\n func_2(\"\".join(str(var_10) for var_10 in sys.stdin.readline().split()))\n for _ in range(var_4)\n ]\n var_8 = [\n [int(var_10) for var_10 in sys.stdin.readline().split()] for _ in range(var_4)\n ]\n var_3 = -(10**10)\n for var_6 in itertools.product(\"01\", repeat=10):\n var_6 = func_2(\"\".join(var_6))\n if var_6 == \"0b0\":\n continue\n var_7 = 0\n for var_2 in range(var_4):\n var_1 = var_9[var_2]\n var_5 = bin(eval(var_1) & eval(var_6)).count(\"1\")\n var_7 += var_8[var_2][var_5]\n var_3 = max(var_3, var_7)\n print(var_3)\n\n\nif __name__ == \"__main__\":\n\n func_1()\n```", "output": "SLOWER 2.6006", "pair_id": "python_p03503_reversed", "problem_id": "p03503", "language": "python", "direction": "reversed", "speedup_ratio": 6.0652} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_5 = input()[::-1]\nvar_2 = [0] * 2019\nvar_2[0] = 1\nvar_4 = 0\nvar_6 = 1\nvar_1 = 0\nfor var_3 in var_5:\n var_4 = (var_4 + int(var_3) * var_6) % 2019\n var_6 = var_6 * 10 % 2019\n var_2[var_4] += 1\nfor var_3 in var_2:\n var_1 += var_3 * (var_3 - 1) // 2\nprint(var_1)\n```\n\n=== Code B (Modified) ===\n```python\nvar_6 = 2019\nvar_1 = [0] * var_6\nvar_3 = 1\nvar_5 = var_4 = 0\nfor var_2 in input()[::-1]:\n var_1[var_4] += 1\n var_4 -= int(var_2) * var_3\n var_4 %= var_6\n var_5 += var_1[var_4]\n var_3 *= 10\n var_3 %= var_6\nprint(var_5)\n```", "output": "FASTER 2.8509", "pair_id": "python_p02702_forward", "problem_id": "p02702", "language": "python", "direction": "forward", "speedup_ratio": 7.2145} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_2, var_1 = list(map(int, input().split()))\nvar_3 = 0\nvar_8 = 0\nvar_4 = [0] * (var_2 + 1)\nvar_9 = [0] * (var_2 + 1)\nfor var_5 in range(var_1):\n var_6, var_7 = input().split()\n var_6 = int(var_6)\n if var_7 == \"AC\":\n if var_4[var_6] == 0:\n var_3 += 1\n var_8 += var_9[var_6]\n var_4[var_6] = 1\n else:\n var_9[var_6] += 1\nprint((var_3, var_8))\n```\n\n=== Code B (Modified) ===\n```python\nvar_7, var_6 = list(map(int, input().split()))\nvar_5 = [tuple(input().split()) for _ in range(var_6)]\nvar_9 = [[] for _ in range(var_7)]\nfor var_2 in range(var_6):\n var_9[int(var_5[var_2][0]) - 1].append(var_5[var_2][1])\nvar_1, var_8 = 0, 0\nfor var_3 in range(var_7):\n if \"AC\" in var_9[var_3]:\n var_1 += 1\n for var_4 in range(len(var_9[var_3])):\n if var_9[var_3][var_4] == \"WA\":\n var_8 += 1\n else:\n break\nprint((var_1, var_8))\n```", "output": "SLOWER 4.4932", "pair_id": "python_p02802_reversed", "problem_id": "p02802", "language": "python", "direction": "reversed", "speedup_ratio": 22.5216} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nfrom sys import stdin\n\n\ndef func_1():\n\n var_9 = stdin.readline\n var_8, var_10 = list(map(int, var_9().split()))\n var_7 = [list(map(int, var_9().split())) for _ in range(var_8)]\n var_7.sort()\n var_1 = [0] * var_8\n var_2 = [0] * var_8\n for var_4 in range(var_8):\n var_1[var_4], var_2[var_4] = var_7[var_4][0], var_7[var_4][1]\n\n var_5 = -float(\"inf\")\n var_3 = [[var_5] * (var_10 + 1) for _ in range(var_8 + 1)]\n var_3[0][0] = 0\n for var_4 in range(var_8):\n for var_6 in range(var_10 + 1):\n\n if var_6 != var_10:\n var_3[var_4 + 1][min(var_10, var_6 + var_1[var_4])] = max(\n var_3[var_4 + 1][min(var_10, var_6 + var_1[var_4])],\n var_3[var_4][var_6] + var_2[var_4],\n )\n\n var_3[var_4 + 1][var_6] = max(var_3[var_4 + 1][var_6], var_3[var_4][var_6])\n print((max(var_3[var_8])))\n\n\nif __name__ == \"__main__\":\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nvar_6, var_7 = list(map(int, input().split()))\nvar_1 = [list(map(int, input().split())) for _ in range(var_6)]\nvar_1.sort()\nvar_3 = [(6007) * [0] for _ in range(var_6 + 1)]\nvar_3[0][0] = 0\nvar_2 = 0\nfor var_4 in range(var_6):\n for var_5 in range(6007):\n var_3[var_4 + 1][var_5] = max(var_3[var_4 + 1][var_5], var_3[var_4][var_5])\n if var_5 < var_7:\n var_3[var_4 + 1][var_5 + var_1[var_4][0]] = max(\n var_3[var_4][var_5] + var_1[var_4][1],\n var_3[var_4][var_5 + var_1[var_4][0]],\n )\n var_2 = max(var_2, var_3[var_4 + 1][var_5])\nprint(var_2)\n```", "output": "SLOWER 5.7996", "pair_id": "python_p02863_reversed", "problem_id": "p02863", "language": "python", "direction": "reversed", "speedup_ratio": 55.7009} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\n_, var_1 = open(0)\nvar_1, *var_2 = list(map(int, var_1.split()))\nfor var_2 in var_2:\n var_1 ^= var_2\nprint((\"YNeos\"[var_1 > 0 :: 2]))\n```\n\n=== Code B (Modified) ===\n```python\nfrom collections import Counter\n\nvar_4 = int(eval(input()))\nvar_1 = list(map(int, input().split()))\nvar_2 = Counter(var_1)\nvar_3 = list(var_2)\nif sum(var_1) == 0:\n print(\"Yes\")\nelif len(var_1) % 3 != 0:\n print(\"No\")\nelif len(var_2) > 3 or len(var_2) <= 1:\n print(\"No\")\nelif len(var_2) == 3:\n if (\n var_2[var_3[0]] == var_4 // 3\n and var_2[var_3[1]] == var_4 // 3\n and var_2[var_3[2]] == var_4 // 3\n ):\n if var_3[0] ^ var_3[1] ^ var_3[2] == 0:\n print(\"Yes\")\n else:\n print(\"No\")\n else:\n print(\"No\")\nelse:\n var_3.sort()\n if var_3[0] == 0 and var_2[var_3[0]] == var_4 // 3:\n print(\"Yes\")\n else:\n print(\"No\")\n```", "output": "SLOWER 1.4077", "pair_id": "python_p02975_reversed", "problem_id": "p02975", "language": "python", "direction": "reversed", "speedup_ratio": 2.6532} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nfrom itertools import product\n\nvar_6 = int(eval(input()))\nvar_1 = list(map(int, input().split()))\nvar_5 = 0\nfor var_2 in product((-1, 0, 1), repeat=var_6):\n var_7 = 1\n for var_3, var_4 in zip(var_1, var_2):\n var_7 *= var_3 + var_4\n if var_7 % 2 == 0:\n var_5 += 1\nprint(var_5)\n```\n\n=== Code B (Modified) ===\n```python\ndef func_1():\n var_2 = int(input())\n var_1 = [int(var_6) for var_6 in input().split()]\n if var_2 == 1:\n return print(1 if var_1[0] % 2 == 0 else 2)\n var_3 = 0\n var_5 = (-1, 0, 1)\n from itertools import product\n\n for var_6 in product(range(3), repeat=var_2):\n var_4 = 1\n for var_7 in range(var_2):\n var_4 *= var_1[var_7] + var_5[var_6[var_7]]\n if var_4 % 2 == 0:\n var_3 += 1\n print(var_3)\n\n\nif __name__ == \"__main__\":\n func_1()\n```", "output": "FASTER 1.47", "pair_id": "python_p03568_forward", "problem_id": "p03568", "language": "python", "direction": "forward", "speedup_ratio": 2.7702} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\n\nvar_8 = sys.stdin.readline\n\n\ndef func_1():\n var_2 = int(eval(var_8()))\n var_1 = []\n for _ in range(var_2):\n var_1.append(list(map(int, var_8().split())))\n var_3 = []\n for _ in range(var_2):\n var_3.append(list(map(int, var_8().split())))\n var_4 = -(10**7) * var_2\n for var_7 in range(1, 1 << 10):\n var_11 = 0\n for var_10, var_6 in enumerate(var_1):\n var_5 = 0\n for var_9 in range(10):\n if (var_7 >> var_9) & 1 & var_6[var_9]:\n var_5 += 1\n var_11 += var_3[var_10][var_5]\n var_4 = max(var_4, var_11)\n print(var_4)\n\n\nif __name__ == \"__main__\":\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\nimport itertools\n\n\ndef func_2(var_4):\n return bin(eval(\"0b\" + str(var_4)))\n\n\ndef func_1():\n var_4 = int(sys.stdin.readline().rstrip())\n var_9 = [\n func_2(\"\".join(str(var_10) for var_10 in sys.stdin.readline().split()))\n for _ in range(var_4)\n ]\n var_8 = [\n [int(var_10) for var_10 in sys.stdin.readline().split()] for _ in range(var_4)\n ]\n var_3 = -(10**10)\n for var_6 in itertools.product(\"01\", repeat=10):\n var_6 = func_2(\"\".join(var_6))\n if var_6 == \"0b0\":\n continue\n var_7 = 0\n for var_2 in range(var_4):\n var_1 = var_9[var_2]\n var_5 = bin(eval(var_1) & eval(var_6)).count(\"1\")\n var_7 += var_8[var_2][var_5]\n var_3 = max(var_3, var_7)\n print(var_3)\n\n\nif __name__ == \"__main__\":\n\n func_1()\n```", "output": "SLOWER 3.5396", "pair_id": "python_p03503_reversed", "problem_id": "p03503", "language": "python", "direction": "reversed", "speedup_ratio": 11.6284} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\nfrom operator import itemgetter\nfrom heapq import heapify, heappop, heappush\n\nvar_1 = int(10e15)\nvar_2 = -var_1\nvar_11 = 1000000007\nsys.setrecursionlimit(1000000)\n\n\ndef func_2():\n return list(map(int, input().split()))\n\n\ndef func_4():\n return input().split()\n\n\ndef func_1():\n return int(sys.stdin.readline())\n\n\ndef func_3():\n return eval(input())\n\n\nvar_3, var_4 = func_2()\nvar_5 = [func_2() for var_9 in range(var_3)]\nvar_5.sort(key=itemgetter(0))\n\nvar_8 = [[0] * (var_4 + 1 + 3000 + 1) for _ in range(var_3 + 1)]\nvar_6 = 0\nfor var_9 in range(var_3):\n for var_10 in range(var_4 + 1 + 3000 + 1):\n var_12, var_7 = var_5[var_9]\n if 0 <= var_10 - var_12 < var_4:\n var_8[var_9 + 1][var_10] = max(\n var_8[var_9][var_10], var_8[var_9][var_10 - var_12] + var_7\n )\n else:\n var_8[var_9 + 1][var_10] = var_8[var_9][var_10]\n var_6 = max(var_6, var_8[var_9 + 1][var_10])\nprint(var_6)\n```\n\n=== Code B (Modified) ===\n```python\nfrom sys import stdin\n\n\ndef func_1():\n\n var_9 = stdin.readline\n var_8, var_10 = list(map(int, var_9().split()))\n var_7 = [list(map(int, var_9().split())) for _ in range(var_8)]\n var_7.sort()\n var_1 = [0] * var_8\n var_2 = [0] * var_8\n for var_4 in range(var_8):\n var_1[var_4], var_2[var_4] = var_7[var_4][0], var_7[var_4][1]\n\n var_5 = -(10**9)\n var_3 = [[var_5] * (var_10 + 1) for _ in range(var_8 + 1)]\n var_3[0][0] = 0\n for var_4 in range(var_8):\n for var_6 in range(var_10 + 1):\n\n if var_6 != var_10:\n var_3[var_4 + 1][min(var_10, var_6 + var_1[var_4])] = max(\n var_3[var_4 + 1][min(var_10, var_6 + var_1[var_4])],\n var_3[var_4][var_6] + var_2[var_4],\n )\n\n var_3[var_4 + 1][var_6] = max(var_3[var_4 + 1][var_6], var_3[var_4][var_6])\n print((max(var_3[var_8])))\n\n\nif __name__ == \"__main__\":\n func_1()\n```", "output": "FASTER 4.9179", "pair_id": "python_p02863_forward", "problem_id": "p02863", "language": "python", "direction": "forward", "speedup_ratio": 30.2293} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_8, var_9 = list(map(int, input().split()))\nvar_5 = [[0] * (var_9 + 3001) for _ in range(var_8 + 1)]\nvar_3 = 0\nvar_2 = [list(map(int, input().split())) for _ in range(var_8)]\nvar_2.sort()\nfor var_6 in range(1, var_8 + 1):\n var_1, var_4 = var_2[var_6 - 1]\n for var_7 in range(var_9):\n var_5[var_6][var_7] = max(var_5[var_6 - 1][var_7], var_5[var_6][var_7])\n var_5[var_6][var_7 + var_1] = var_5[var_6 - 1][var_7] + var_4\n var_3 = max(var_5[var_6][var_7], var_5[var_6][var_7 + var_1], var_3)\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\nfrom operator import itemgetter\nfrom heapq import heapify, heappop, heappush\n\nvar_1 = int(10e15)\nvar_2 = -var_1\nvar_11 = 1000000007\nsys.setrecursionlimit(1000000)\n\n\ndef func_2():\n return list(map(int, input().split()))\n\n\ndef func_4():\n return input().split()\n\n\ndef func_1():\n return int(sys.stdin.readline())\n\n\ndef func_3():\n return eval(input())\n\n\nvar_3, var_4 = func_2()\nvar_5 = [func_2() for var_9 in range(var_3)]\nvar_5.sort(key=itemgetter(0))\n\nvar_8 = [[0] * (var_4 + 1 + 3000 + 1) for _ in range(var_3 + 1)]\nvar_6 = 0\nfor var_9 in range(var_3):\n for var_10 in range(var_4 + 1 + 3000 + 1):\n var_12, var_7 = var_5[var_9]\n if 0 <= var_10 - var_12 < var_4:\n var_8[var_9 + 1][var_10] = max(\n var_8[var_9][var_10], var_8[var_9][var_10 - var_12] + var_7\n )\n else:\n var_8[var_9 + 1][var_10] = var_8[var_9][var_10]\n var_6 = max(var_6, var_8[var_9 + 1][var_10])\nprint(var_6)\n```", "output": "SLOWER 4.3053", "pair_id": "python_p02863_reversed", "problem_id": "p02863", "language": "python", "direction": "reversed", "speedup_ratio": 19.7702} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = input().split()\nvar_1 = int(var_1)\nvar_3, var_4 = list(map(int, var_2.split(\".\")))\nvar_5 = var_1 * (var_3 * 100 + var_4)\nprint((int(var_5 // 100)))\n```\n\n=== Code B (Modified) ===\n```python\ndef func_1():\n from sys import setrecursionlimit, stdin\n from os import environ\n from collections import defaultdict, deque, Counter\n from math import ceil, floor, gcd\n from itertools import accumulate, combinations, combinations_with_replacement\n\n setrecursionlimit(10**6)\n var_7 = (\n (lambda *var_11: print(*var_11))\n if \"TERM_PROGRAM\" in environ\n else lambda *var_12: 0\n )\n var_8 = lambda: stdin.readline().rstrip()\n var_3 = lambda: list(map(int, var_8().split()))\n var_1 = lambda: int(var_8())\n var_4 = 10**9 + 7\n var_2 = 10**9 + 10\n var_9, var_10 = var_8().split()\n var_5 = int(var_9)\n var_10 = var_10.split(\".\")\n var_6 = int(var_10[0]) * 100\n if len(var_10) == 2:\n var_6 += int(var_10[1])\n print(var_5 * var_6 // 100)\n\n\nfunc_1()\n```", "output": "SLOWER 1.9258", "pair_id": "python_p02659_reversed", "problem_id": "p02659", "language": "python", "direction": "reversed", "speedup_ratio": 3.7995} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n if list(str(var_4)) == list(reversed(str(var_4))):\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1 = list(map(int, input().split()))\nvar_2 = 0\nfor var_3 in range(var_1[0], var_1[1] + 1):\n var_4 = str(var_3)\n if var_4[0] == var_4[4] and var_4[1] == var_4[3]:\n var_2 += 1\nprint(var_2)\n```", "output": "FASTER 1.6892", "pair_id": "python_p03416_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 3.2247} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nfrom sys import stdin\n\nvar_6 = lambda: list(map(int, stdin.readline().split()))\nvar_5 = lambda: list(map(int, stdin.readline().split()))\nvar_1, var_3 = var_6()\nvar_2 = 0\nfor var_4 in range(var_1, var_3 + 1):\n var_7 = str(var_4)\n if var_7 == var_7[::-1]:\n var_2 += 1\nprint(var_2)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_8 in range(var_1, var_2 + 1):\n var_7 = str(var_8)\n var_6 = len(var_7)\n var_4 = True\n for var_5 in range(var_6 // 2):\n if var_7[var_5] != var_7[var_6 - 1 - var_5]:\n var_4 = False\n break\n if var_4:\n var_3 += 1\nprint(var_3)\n```", "output": "SLOWER 1.1078", "pair_id": "python_p03416_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 2.1552} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\n\n\ndef func_1(var_5, var_6):\n var_4 = 0\n for var_3 in range(var_5, var_6 + 1):\n if str(var_3) == str(var_3)[::-1]:\n var_4 += 1\n return var_4\n\n\nprint((func_1(var_1, var_2)))\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_6 in range(var_1, var_2 + 1):\n var_3 = str(var_6)\n var_5 = True\n for var_7 in range(len(var_3) // 2):\n if var_3[var_7] != var_3[-var_7 - 1] and var_5:\n var_5 = not var_5\n if var_5:\n var_4 += 1\nprint(var_4)\n```", "output": "SLOWER 1.7836", "pair_id": "python_p03416_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 3.4428} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = str(var_4)\n if var_5[0] == var_5[4] and var_5[1] == var_5[3]:\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\ndef func_1():\n var_1, var_2 = list(map(int, input().split()))\n var_3 = 0\n for var_4 in range(var_1, var_2 + 1):\n\n if (var_4 % 10) == (var_4 // 10000 % 10) and (var_4 // 10 % 10) == (\n var_4 // 1000 % 10\n ):\n var_3 += 1\n print(var_3)\n\n\nif __name__ == \"__main__\":\n func_1()\n```", "output": "FASTER 1.3979", "pair_id": "python_p03416_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 2.6352} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = list(reversed(list(str(var_4))))\n if var_5 == list(str(var_4)):\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().strip().split(\" \")))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n if str(var_4) == str(var_4)[::-1]:\n var_3 += 1\nprint(var_3)\n```", "output": "FASTER 1.3497", "pair_id": "python_p03416_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 2.5486} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nfrom itertools import product\n\nvar_6 = int(eval(input()))\nvar_1 = list(map(int, input().split()))\nvar_5 = 0\nfor var_2 in product((-1, 0, 1), repeat=var_6):\n var_7 = 1\n for var_3, var_4 in zip(var_1, var_2):\n var_7 *= var_3 + var_4\n if var_7 % 2 == 0:\n var_5 += 1\nprint(var_5)\n```\n\n=== Code B (Modified) ===\n```python\nvar_2 = int(eval(input()))\n(*var_1,) = list(map(int, input().split()))\nvar_5 = 0\nfor var_3 in var_1:\n if var_3 % 2 == 0:\n var_5 += 1\nvar_4 = 3**var_2 - 2**var_5\nprint(var_4)\n```", "output": "FASTER 10.0319", "pair_id": "python_p03568_forward", "problem_id": "p03568", "language": "python", "direction": "forward", "speedup_ratio": 1046.9079} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\n\nsys.setrecursionlimit(2147483647)\nvar_2 = float(\"inf\")\nvar_3 = 10**9 + 7\nvar_10 = lambda: sys.stdin.readline().rstrip()\n\n\ndef func_1():\n var_11, var_4 = list(map(int, var_10().split()))\n var_1 = [tuple(map(int, var_10().split())) for _ in range(var_11)]\n var_1.sort()\n var_8 = [0] * var_4\n var_6 = -var_2\n for var_9 in range(var_11):\n var_5, var_7 = var_1[var_9]\n var_12 = var_8[:]\n for var_13 in range(var_4):\n if var_13 + var_5 < var_4:\n var_12[var_13 + var_5] = max(\n var_12[var_13 + var_5], var_8[var_13] + var_7\n )\n else:\n var_6 = max(var_6, var_8[var_13] + var_7)\n var_8 = var_12\n print((max(var_6, max(var_8))))\n\n\nfunc_1()\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\n\nvar_9 = sys.stdin.readline\nfrom operator import itemgetter\n\nvar_3, var_4 = list(map(int, var_9().split()))\nvar_1 = [list(map(int, var_9().split())) for _ in range(var_3)]\nvar_1.sort(key=itemgetter(0))\nvar_8 = [[0 for _ in range(var_3 + 1)] for _ in range(var_4 + 1)]\n\nvar_2 = []\nfor var_10 in range(var_3):\n var_5, var_7 = var_1[var_10]\n for var_11 in range(var_4):\n if var_5 > var_11:\n var_8[var_11][var_10 + 1] = var_8[var_11][var_10]\n else:\n if var_7 + var_8[var_11 - var_5][var_10] >= var_8[var_11][var_10]:\n var_8[var_11][var_10 + 1] = var_8[var_11 - var_5][var_10] + var_7\n else:\n var_8[var_11][var_10 + 1] = var_8[var_11][var_10]\n var_2.append(var_8[var_4 - 1][var_10] + var_7)\nvar_6 = max(var_2)\nprint(var_6)\n```", "output": "SLOWER 1.0161", "pair_id": "python_p02863_reversed", "problem_id": "p02863", "language": "python", "direction": "reversed", "speedup_ratio": 2.0224} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_2, var_3, *var_1 = list(map(int, open(0).read().split()))\nvar_4 = [0] * (var_3 + max(var_1[::2]))\nfor var_7, var_6 in sorted(zip(*[iter(var_1)] * 2)):\n for var_5 in reversed(list(range(var_3))):\n var_4[var_5 + var_7] = max(var_4[var_5 + var_7], var_4[var_5] + var_6)\nprint((max(var_4)))\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\n\nvar_10 = sys.stdin.readline\nvar_2, var_3 = list(map(int, var_10().split()))\nvar_1 = [list(map(int, var_10().split())) for _ in range(var_2)]\nvar_8 = [[0 for _ in range(var_2 + 1)] for _ in range(var_3 + 1)]\n\nvar_13 = [[0 for _ in range(var_2 + 1)] for _ in range(var_3 + 1)]\nfor var_11 in range(var_2):\n var_4, var_6 = var_1[var_11]\n for var_15 in range(var_3):\n if var_4 > var_15:\n var_8[var_15][var_11 + 1] = var_8[var_15][var_11]\n var_13[var_15][var_11 + 1] = var_15\n else:\n if var_6 + var_8[var_15 - var_4][var_11] >= var_8[var_15][var_11]:\n var_8[var_15][var_11 + 1] = var_8[var_15 - var_4][var_11] + var_6\n var_13[var_15][var_11 + 1] = var_15 - var_4\n else:\n var_8[var_15][var_11 + 1] = var_8[var_15][var_11]\n var_13[var_15][var_11 + 1] = var_15\nvar_5 = var_8[var_3 - 1][var_2]\nvar_14 = [False] * var_2\nvar_7 = var_3 - 1\nfor var_9 in reversed(list(range(var_2))):\n if var_13[var_7][var_9 + 1] == var_7 - var_1[var_9][0]:\n var_14[var_9] = True\n var_7 = var_13[var_7][var_9 + 1]\nvar_12 = 0\nfor var_9 in range(var_2):\n if not var_14[var_9] and var_1[var_9][1] > var_12:\n var_12 = var_1[var_9][1]\nprint((var_5 + var_12))\n```", "output": "SLOWER 1.0715", "pair_id": "python_p02863_reversed", "problem_id": "p02863", "language": "python", "direction": "reversed", "speedup_ratio": 2.1016} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_6 in range(var_1, var_2 + 1):\n var_3 = str(var_6)\n var_5 = True\n for var_7 in range(len(var_3) // 2):\n if var_3[var_7] != var_3[-var_7 - 1] and var_5:\n var_5 = not var_5\n if var_5:\n var_4 += 1\nprint(var_4)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = [\n var_3 for var_3 in map(str, list(range(var_1, var_2 + 1))) if var_3 == var_3[::-1]\n]\nprint((len(var_4)))\n```", "output": "FASTER 2.1585", "pair_id": "python_p03416_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 4.4645} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = input().split()\nvar_1 = int(var_1)\nvar_2 = int(var_2)\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = list(str(var_4))\n if (var_5[0] == var_5[4]) and (var_5[1] == var_5[3]):\n var_3 = var_3 + 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_4 = {}\nvar_5 = 0\nfor var_6 in range(10000, 100000):\n var_3 = list(str(var_6))\n if var_3 == list(reversed(var_3)):\n var_5 += 1\n var_4[var_6] = var_5\nvar_1, var_2 = list(map(int, input().split()))\nprint((var_4[var_2] - var_4[var_1 - 1] if var_1 > 10000 else var_4[var_2]))\n```", "output": "SLOWER 3.1693", "pair_id": "python_p03416_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 8.996} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_3, var_2 = map(int, input().split())\nvar_4 = [0] * var_3\n[\n exec(\n \"roads[%d] += 1; roads[%d] += 1\"\n % tuple(map(lambda var_1: int(var_1) - 1, input().split()))\n )\n for _ in range(var_2)\n]\nprint(*var_4, sep=\"\\n\", end=\"\")\n```\n\n=== Code B (Modified) ===\n```python\nvar_6, var_5 = list(map(int, input().split()))\nvar_1 = [0] * var_6\nfor var_4 in range(var_5):\n var_2, var_3 = list(map(int, input().split()))\n var_1[var_2 - 1] += 1\n var_1[var_3 - 1] += 1\nfor var_4 in range(var_6):\n print((var_1[var_4]))\n```", "output": "FASTER 1.1224", "pair_id": "python_p03720_forward", "problem_id": "p03720", "language": "python", "direction": "forward", "speedup_ratio": 2.1771} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_4 = str(var_4)\n if var_4[0] == var_4[-1] and var_4[1] == var_4[-2]:\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_7 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_3 = True\n var_8 = str(var_4)\n var_6 = len(var_8)\n for var_5 in range(var_6 // 2 + 1):\n if var_8[var_5] != var_8[-var_5 - 1]:\n var_3 = False\n break\n if var_3:\n var_7 += 1\nprint(var_7)\n```", "output": "SLOWER 1.3088", "pair_id": "python_p03416_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 2.4774} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\ndef func_1():\n from sys import setrecursionlimit, stdin\n from os import environ\n from collections import defaultdict, deque, Counter\n from math import ceil, floor, gcd\n from itertools import accumulate, combinations, combinations_with_replacement\n\n setrecursionlimit(10**6)\n var_7 = (\n (lambda *var_11: print(*var_11))\n if \"TERM_PROGRAM\" in environ\n else lambda *var_12: 0\n )\n var_8 = lambda: stdin.readline().rstrip()\n var_3 = lambda: list(map(int, var_8().split()))\n var_1 = lambda: int(var_8())\n var_4 = 10**9 + 7\n var_2 = 10**9 + 10\n var_9, var_10 = var_8().split()\n var_5 = int(var_9)\n var_10 = var_10.split(\".\")\n var_6 = int(var_10[0]) * 100\n if len(var_10) == 2:\n var_6 += int(var_10[1])\n print(var_5 * var_6 // 100)\n\n\nfunc_1()\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\n\nvar_5 = sys.stdin.readline\nif __name__ == \"__main__\":\n var_1, var_3 = var_5().split()\n var_2 = int(var_1)\n var_4 = round(float(var_3) * 100)\n print((var_2 * var_4 // 100))\n```", "output": "FASTER 1.8866", "pair_id": "python_p02659_forward", "problem_id": "p02659", "language": "python", "direction": "forward", "speedup_ratio": 3.6977} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport decimal\n\n\ndef func_1():\n var_1, var_2 = list(map(decimal.Decimal, input().split()))\n print((var_1 * var_2 // 1))\n\n\nif __name__ == \"__main__\":\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\nimport math\nfrom collections import defaultdict\nfrom bisect import bisect_left, bisect_right\n\nsys.setrecursionlimit(10**7)\n\n\ndef func_4():\n return sys.stdin.readline()[:-1]\n\n\nvar_4 = 10**9 + 7\n\n\ndef func_1():\n return int(eval(func_4()))\n\n\ndef func_2():\n return list(map(int, func_4().split()))\n\n\ndef func_3(var_6, var_3):\n if var_6 <= 0:\n return [[] for _ in range(var_3)]\n elif var_3 == 1:\n return [func_1() for _ in range(var_6)]\n else:\n var_5 = [func_2() for _ in range(var_6)]\n return list(map(list, list(zip(*var_5))))\n\n\nfrom decimal import getcontext, Decimal\n\ngetcontext().prec = 28\nvar_1, var_2 = list(map(str, func_4().split()))\nvar_1 = int(var_1)\nvar_2 = Decimal(var_2)\nprint((int(var_1 * var_2)))\n```", "output": "SLOWER 2.0487", "pair_id": "python_p02659_reversed", "problem_id": "p02659", "language": "python", "direction": "reversed", "speedup_ratio": 4.1373} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\nimport numpy as np\n\nvar_6 = int(eval(input()))\n\nvar_1 = [input().replace(\" \", \"\") for var_4 in range(var_6)]\n\nvar_7 = [list(map(int, input().split())) for var_4 in range(var_6)]\nvar_11 = -999999999999999\nfor var_4 in range(1, 1024):\n var_3 = format(var_4, \"010b\")\n var_9 = 0\n for var_2, var_8 in zip(var_1, var_7):\n var_10 = 0\n for var_5 in range(10):\n if var_2[var_5] == \"1\" and var_3[var_5] == \"1\":\n var_10 += 1\n var_9 += var_8[var_10]\n if var_9 > var_11:\n if var_9 == 0:\n print((str(var_4)))\n break\n var_11 = var_9\nprint(var_11)\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\nimport itertools\n\n\ndef func_2(var_4):\n return bin(eval(\"0b\" + str(var_4)))\n\n\ndef func_1():\n var_4 = int(sys.stdin.readline().rstrip())\n var_9 = [\n func_2(\"\".join(str(var_10) for var_10 in sys.stdin.readline().split()))\n for _ in range(var_4)\n ]\n var_8 = [\n [int(var_10) for var_10 in sys.stdin.readline().split()] for _ in range(var_4)\n ]\n var_3 = -(10**10)\n for var_6 in itertools.product(\"01\", repeat=10):\n var_6 = func_2(\"\".join(var_6))\n if var_6 == \"0b0\":\n continue\n var_7 = 0\n for var_2 in range(var_4):\n var_1 = var_9[var_2]\n var_5 = bin(eval(var_1) & eval(var_6)).count(\"1\")\n var_7 += var_8[var_2][var_5]\n var_3 = max(var_3, var_7)\n print(var_3)\n\n\nif __name__ == \"__main__\":\n\n func_1()\n```", "output": "SLOWER 3.0752", "pair_id": "python_p03503_reversed", "problem_id": "p03503", "language": "python", "direction": "reversed", "speedup_ratio": 8.4281} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_4 = str(var_4)\n if var_4[0] == var_4[-1] and var_4[1] == var_4[-2]:\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_3 = list(map(int, input().split()))\nvar_2 = 0\nfor var_5 in range(var_3 + 1)[var_1:]:\n if len(str(var_5)) % 2 == 0:\n var_6 = list(str(var_5))[: len(str(var_5)) // 2]\n var_7 = list(reversed(list(str(var_5))[len(str(var_5)) // 2 :]))\n if var_6 == var_7:\n var_2 += 1\n else:\n var_8 = list(str(var_5))[: len(str(var_5)) // 2 + 1]\n var_4 = list(reversed(list(str(var_5))[len(str(var_5)) // 2 :]))\n if var_8 == var_4:\n var_2 += 1\nprint(var_2)\n```", "output": "SLOWER 2.6583", "pair_id": "python_p03416_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 6.3127} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = input().split()\nvar_1 = int(var_1)\nvar_2 = int(var_2.replace(\".\", \"\"))\nprint((var_1 * var_2 // 100))\n```\n\n=== Code B (Modified) ===\n```python\ndef func_1():\n from sys import setrecursionlimit, stdin\n from os import environ\n from collections import defaultdict, deque, Counter\n from math import ceil, floor, gcd\n from itertools import accumulate, combinations, combinations_with_replacement\n\n setrecursionlimit(10**6)\n var_7 = (\n (lambda *var_11: print(*var_11))\n if \"TERM_PROGRAM\" in environ\n else lambda *var_12: 0\n )\n var_8 = lambda: stdin.readline().rstrip()\n var_3 = lambda: list(map(int, var_8().split()))\n var_1 = lambda: int(var_8())\n var_4 = 10**9 + 7\n var_2 = 10**9 + 10\n var_9, var_10 = var_8().split()\n var_5 = int(var_9)\n var_10 = var_10.split(\".\")\n var_6 = int(var_10[0]) * 100\n if len(var_10) == 2:\n var_6 += int(var_10[1])\n print(var_5 * var_6 // 100)\n\n\nfunc_1()\n```", "output": "SLOWER 2.4306", "pair_id": "python_p02659_reversed", "problem_id": "p02659", "language": "python", "direction": "reversed", "speedup_ratio": 5.3911} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_4, var_3 = list(map(int, input().split()))\nvar_1 = 0\nfor var_2 in range(var_4, var_3 + 1):\n if str(var_2)[0] + str(var_2)[1] == str(var_2)[-1] + str(var_2)[-2]:\n var_1 += 1\nprint(var_1)\n```\n\n=== Code B (Modified) ===\n```python\nvar_4 = {}\nvar_5 = 0\nfor var_6 in range(10000, 100000):\n var_3 = list(str(var_6))\n if var_3 == list(reversed(var_3)):\n var_5 += 1\n var_4[var_6] = var_5\nvar_1, var_2 = list(map(int, input().split()))\nprint((var_4[var_2] - var_4[var_1 - 1] if var_1 > 10000 else var_4[var_2]))\n```", "output": "SLOWER 2.2325", "pair_id": "python_p03416_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 4.6995} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_6 = sorted([list(map(int, input().split())) for var_5 in range(var_1)])\n\nvar_4 = [[0] * (var_2 + 1) for var_5 in range(var_1 + 1)]\n\nfor var_5 in range(var_1):\n var_9, var_8 = var_6[var_5]\n for var_7 in range(var_2 + 1):\n if var_7 + var_9 <= var_2:\n var_4[var_5 + 1][var_7 + var_9] = max(\n var_4[var_5 + 1][var_7 + var_9], var_4[var_5][var_7] + var_8\n )\n var_4[var_5 + 1][var_7] = max(var_4[var_5][var_7], var_4[var_5 + 1][var_7])\nvar_3 = 0\nfor var_5, (var_9, var_8) in enumerate(var_6):\n var_3 = max(var_3, var_4[var_5][var_2 - 1] + var_8)\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nfrom collections import Counter, defaultdict, deque\nfrom heapq import heappop, heappush, heapify\nimport sys, bisect, math, itertools, fractions, pprint\n\nsys.setrecursionlimit(10**8)\nvar_6 = 10**9 + 7\nvar_1 = float(\"inf\")\n\n\ndef func_1():\n return int(sys.stdin.readline())\n\n\ndef func_2():\n return list(map(int, sys.stdin.readline().split()))\n\n\nvar_7, var_9 = func_2()\nvar_13 = [func_2() for _ in range(var_7)]\nvar_13.sort(key=lambda var_14: var_14[1], reverse=True)\nvar_8 = 0\nvar_10 = min(var_7, 5)\nfor var_3 in range(var_10):\n var_2 = [[0] * (var_9 + 5) for _ in range(var_7 + 5)]\n for var_4 in range(var_7):\n var_12, var_11 = var_13[var_4]\n for var_5 in range(var_9):\n if var_5 < var_12 or var_3 == var_4:\n var_2[var_4 + 1][var_5] = var_2[var_4][var_5]\n else:\n var_2[var_4 + 1][var_5] = max(\n var_2[var_4][var_5], var_2[var_4][var_5 - var_12] + var_11\n )\n\n var_8 = max(var_2[var_7][var_9 - 1] + var_13[var_3][1], var_8)\nprint(var_8)\n```", "output": "SLOWER 1.2339", "pair_id": "python_p02863_reversed", "problem_id": "p02863", "language": "python", "direction": "reversed", "speedup_ratio": 2.352} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\nimport numpy as np\n\nvar_5 = sys.stdin.readline\n\nvar_7 = int(eval(var_5()))\n\nvar_1 = [var_5().replace(\" \", \"\") for var_4 in range(var_7)]\n\nvar_8 = [list(map(int, var_5().split())) for var_4 in range(var_7)]\n\n\nvar_12 = -999999999999999\n\nfor var_4 in range(1, 1024):\n\n var_3 = format(var_4, \"010b\")\n\n var_10 = 0\n for var_2, var_9 in zip(var_1, var_8):\n\n var_11 = 0\n for var_6 in range(10):\n\n if var_2[var_6] == \"1\" and var_3[var_6] == \"1\":\n\n var_11 += 1\n\n var_10 += var_9[var_11]\n if var_10 > var_12:\n\n var_12 = var_10\nprint(var_12)\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\n\nvar_7 = sys.stdin.readline\nfrom itertools import combinations\n\n\ndef func_3(var_10):\n for _ in range(var_10):\n yield list(map(int, var_7().split()))\n\n\ndef func_1(var_9, var_5, var_11):\n var_3 = sum(1 if var_5[var_8] == 1 else 0 for var_8 in var_9)\n return var_11[var_3]\n\n\ndef func_2():\n var_10 = int(eval(var_7()))\n var_1 = list(func_3(var_10))\n var_2 = list(func_3(var_10))\n for var_6 in range(1, 11):\n for var_4 in combinations(list(range(10)), var_6):\n yield sum(\n func_1(var_4, var_5, var_11) for var_5, var_11 in zip(var_1, var_2)\n )\n\n\nprint((max(func_2())))\n```", "output": "FASTER 1.0796", "pair_id": "python_p03503_forward", "problem_id": "p03503", "language": "python", "direction": "forward", "speedup_ratio": 2.1134} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_6, var_7 = list(map(int, input().split()))\nvar_1 = [list(map(int, input().split())) for _ in range(var_6)]\nvar_1.sort()\nvar_3 = [(6007) * [0] for _ in range(var_6 + 1)]\nvar_3[0][0] = 0\nvar_2 = 0\nfor var_4 in range(var_6):\n for var_5 in range(6007):\n var_3[var_4 + 1][var_5] = max(var_3[var_4 + 1][var_5], var_3[var_4][var_5])\n if var_5 < var_7:\n var_3[var_4 + 1][var_5 + var_1[var_4][0]] = max(\n var_3[var_4][var_5] + var_1[var_4][1],\n var_3[var_4][var_5 + var_1[var_4][0]],\n )\n var_2 = max(var_2, var_3[var_4 + 1][var_5])\nprint(var_2)\n```\n\n=== Code B (Modified) ===\n```python\nimport bisect\nimport sys\n\nsys.setrecursionlimit(10**6)\nvar_17 = sys.stdout.write\nvar_7 = lambda *var_15: print(*var_15) if var_1 else 0\nvar_1 = True\n\n\ndef func_1(var_10=sys.stdin.readline):\n var_12 = lambda: var_10().rstrip()\n var_3 = lambda: list(map(int, var_12().split()))\n var_2 = lambda: int(var_12())\n var_4 = lambda var_18: [var_3() for _ in range(var_18)]\n var_14, var_16 = var_3()\n var_5 = var_4(var_14)\n var_8 = [[0] * var_16 for _ in range(var_14)]\n for var_11 in range(1, var_14):\n for var_13 in range(1, var_16):\n if var_13 < var_5[var_11 - 1][0]:\n var_8[var_11][var_13] = var_8[var_11 - 1][var_13]\n else:\n var_8[var_11][var_13] = max(\n var_8[var_11 - 1][var_13],\n var_8[var_11 - 1][var_13 - var_5[var_11 - 1][0]]\n + var_5[var_11 - 1][1],\n )\n var_9 = [[0] * var_16 for _ in range(var_14)]\n for var_11 in range(1, var_14):\n for var_13 in range(1, var_16):\n if var_13 < var_5[var_14 - var_11][0]:\n var_9[var_11][var_13] = var_9[var_11 - 1][var_13]\n else:\n var_9[var_11][var_13] = max(\n var_9[var_11 - 1][var_13],\n var_9[var_11 - 1][var_13 - var_5[var_14 - var_11][0]]\n + var_5[var_14 - var_11][1],\n )\n var_6 = 0\n for var_11 in range(var_14):\n for var_13 in range(var_16 - 1):\n var_6 = max(\n var_6,\n var_8[var_11][var_13]\n + var_9[var_14 - var_11 - 1][var_16 - var_13 - 1]\n + var_5[var_11][1],\n )\n print(var_6)\n\n\nif __name__ == \"__main__\":\n func_1()\n```", "output": "FASTER 5.3172", "pair_id": "python_p02863_forward", "problem_id": "p02863", "language": "python", "direction": "forward", "speedup_ratio": 39.8704} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_2 = int(eval(input()))\n(*var_1,) = list(map(int, input().split()))\nvar_5 = 0\nfor var_3 in var_1:\n if var_3 % 2 == 0:\n var_5 += 1\nvar_4 = 3**var_2 - 2**var_5\nprint(var_4)\n```\n\n=== Code B (Modified) ===\n```python\nvar_4 = int(eval(input()))\nvar_2 = list(map(int, input().split()))\n\n\ndef func_1(var_1, var_8, var_3):\n if var_8 == var_4:\n var_9 = 1\n for var_5 in var_3:\n var_9 *= var_5\n return 1 if var_9 % 2 == 0 else 0\n var_6 = var_3.copy()\n var_6.append(var_1[var_8] - 1)\n var_5 = var_3.copy()\n var_5.append(var_1[var_8])\n var_7 = var_3.copy()\n var_7.append(var_1[var_8] + 1)\n return (\n func_1(var_1, var_8 + 1, var_6)\n + func_1(var_1, var_8 + 1, var_5)\n + func_1(var_1, var_8 + 1, var_7)\n )\n\n\nprint((func_1(var_2, 0, [])))\n```", "output": "SLOWER 8.2861", "pair_id": "python_p03568_reversed", "problem_id": "p03568", "language": "python", "direction": "reversed", "speedup_ratio": 312.1488} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_5 in range(10):\n for var_6 in range(10):\n for var_7 in range(10):\n var_3 = 10000 * var_5 + 1000 * var_6 + 100 * var_7 + 10 * var_6 + var_5\n if var_1 <= var_3 <= var_2:\n var_4 += 1\nprint(var_4)\n```\n\n=== Code B (Modified) ===\n```python\nvar_4, var_3 = list(map(int, input().split()))\nvar_1 = 0\nfor var_2 in range(var_4, var_3 + 1):\n if str(var_2)[0] + str(var_2)[1] == str(var_2)[-1] + str(var_2)[-2]:\n var_1 += 1\nprint(var_1)\n```", "output": "SLOWER 5.1667", "pair_id": "python_p03416_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 35.9185} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\n\nvar_3 = sys.stdin.readline\nif __name__ == \"__main__\":\n var_1, var_2 = var_3().split()\n print((int(var_1) * round(float(var_2) * 100) // 100))\n```\n\n=== Code B (Modified) ===\n```python\ndef func_1():\n from sys import setrecursionlimit, stdin\n from os import environ\n from collections import defaultdict, deque, Counter\n from math import ceil, floor, gcd\n from itertools import accumulate, combinations, combinations_with_replacement\n\n setrecursionlimit(10**6)\n var_7 = (\n (lambda *var_11: print(*var_11))\n if \"TERM_PROGRAM\" in environ\n else lambda *var_12: 0\n )\n var_8 = lambda: stdin.readline().rstrip()\n var_3 = lambda: list(map(int, var_8().split()))\n var_1 = lambda: int(var_8())\n var_4 = 10**9 + 7\n var_2 = 10**9 + 10\n var_9, var_10 = var_8().split()\n var_5 = int(var_9)\n var_6 = int(float(var_10) * 100 + 0.5)\n print(var_5 * var_6 // 100)\n\n\nfunc_1()\n```", "output": "SLOWER 1.9665", "pair_id": "python_p02659_reversed", "problem_id": "p02659", "language": "python", "direction": "reversed", "speedup_ratio": 3.9083} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\n_, var_1 = open(0)\nvar_1, *var_2 = list(map(int, var_1.split()))\nfor var_2 in var_2:\n var_1 ^= var_2\nprint((\"YNeos\"[var_1 > 0 :: 2]))\n```\n\n=== Code B (Modified) ===\n```python\nfrom collections import Counter\n\nvar_4 = int(eval(input()))\nvar_1 = list(map(int, input().split()))\nvar_2 = Counter(var_1)\nvar_3 = list(var_2.keys())\nvar_5 = list(var_2.values())\nif (\n len(var_2) == 3\n and var_3[0] ^ var_3[1] ^ var_3[2] == 0\n and var_5[0] == var_5[1] == var_5[2]\n):\n print(\"Yes\")\nelif (\n len(var_2) == 2\n and 0 in var_3\n and (var_5[0] == var_5[1] * 2 or var_5[1] == var_5[0] * 2)\n):\n print(\"Yes\")\nelif len(var_2) == 1 and 0 in var_3:\n print(\"Yes\")\nelse:\n print(\"No\")\n```", "output": "SLOWER 1.0753", "pair_id": "python_p02975_reversed", "problem_id": "p02975", "language": "python", "direction": "reversed", "speedup_ratio": 2.1071} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_7 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_3 = True\n var_8 = str(var_4)\n var_6 = len(var_8)\n for var_5 in range(var_6 // 2 + 1):\n if var_8[var_5] != var_8[-var_5 - 1]:\n var_3 = False\n break\n if var_3:\n var_7 += 1\nprint(var_7)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_5 in range(var_1, var_2 + 1):\n var_3 = str(var_5)\n if var_3[0] == var_3[-1] and var_3[1] == var_3[-2]:\n var_4 += 1\nprint(var_4)\n```", "output": "FASTER 1.2167", "pair_id": "python_p03416_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 2.3241} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport math\nimport string\n\n\ndef func_4():\n return list(map(int, input().split()))\n\n\ndef func_3(var_6, var_7):\n return math.factorial(var_6) // (\n math.factorial(var_6 - var_7) * math.factorial(var_7)\n )\n\n\ndef func_2(var_9):\n var_8 = []\n for var_5 in var_9:\n if not (var_5 in var_8):\n var_8.append(var_5)\n return len(var_9) != len(var_8)\n\n\ndef func_1(var_6):\n func_1 = []\n for var_4 in range(1, var_6 + 1):\n if var_6 % var_4 == 0:\n func_1.append(var_4)\n return func_1\n\n\nvar_2 = [-1, -1, -1, 0, 0, 1, 1, 1]\nvar_3 = [-1, 0, 1, -1, 1, -1, 0, 1]\nvar_6 = int(eval(input()))\nvar_1 = func_4()\nvar_10 = 1\nfor var_4 in range(len(var_1)):\n if var_1[var_4] % 2 == 0:\n var_10 *= 2\n else:\n var_10 *= 1\nprint((3 ** len(var_1) - var_10))\n```\n\n=== Code B (Modified) ===\n```python\nfrom functools import reduce\nfrom itertools import product\n\nvar_2 = int(eval(input()))\n(*var_1,) = list(map(int, input().split()))\nvar_4 = 0\nfor var_7 in product([-1, 0, 1], repeat=var_2):\n var_6 = reduce(\n lambda var_8, var_9: var_8 * var_9,\n [var_3 + var_7[var_5] for var_5, var_3 in enumerate(var_1)],\n )\n if var_6 % 2 == 0:\n var_4 += 1\nprint(var_4)\n```", "output": "SLOWER 8.0685", "pair_id": "python_p03568_reversed", "problem_id": "p03568", "language": "python", "direction": "reversed", "speedup_ratio": 268.4525} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_7, var_6 = list(map(int, input().split(\" \")))\nvar_2 = [list(map(int, input().split(\" \"))) for _ in range(var_6)]\nvar_2.sort(key=lambda var_8: var_8[1])\nvar_5 = 0\nvar_4 = 0\nfor var_1, var_3 in var_2:\n if var_4 > var_1:\n continue\n var_4 = var_3\n var_5 += 1\nprint(var_5)\n```\n\n=== Code B (Modified) ===\n```python\nvar_2, var_1 = [int(var_12) for var_12 in input().split()]\nvar_3 = []\nfor var_8 in range(var_1):\n var_5, var_6 = [int(var_12) for var_12 in input().split()]\n var_3.append((var_5, var_6))\nvar_3.sort()\nvar_9 = float(\"inf\")\nvar_4 = [var_9 for var_5 in range(var_2 + 1)]\nfor var_5, var_6 in var_3:\n var_4[var_5] = min(var_4[var_5], var_6)\nvar_3 = [\n (var_5, var_4[var_5]) for var_5 in range(1, var_2 + 1) if var_4[var_5] != var_9\n]\nvar_3.sort(key=lambda var_11: var_11[1])\nvar_7 = [True] * (var_2)\nvar_10 = None\nfor var_5, var_6 in var_3:\n if var_10 == None or var_10 < var_5:\n var_7[var_6 - 1] = False\n var_10 = var_6 - 1\nprint((sum(1 for var_6 in var_7 if not var_6)))\n```", "output": "SLOWER 1.0821", "pair_id": "python_p03295_reversed", "problem_id": "p03295", "language": "python", "direction": "reversed", "speedup_ratio": 2.1171} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_4, var_3 = list(map(int, input().split()))\nvar_1 = 0\nfor var_2 in range(var_4, var_3 + 1):\n if str(var_2)[0] + str(var_2)[1] == str(var_2)[-1] + str(var_2)[-2]:\n var_1 += 1\nprint(var_1)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_4 = str(var_4)\n if var_4 == var_4[::-1]:\n var_3 += 1\nprint(var_3)\n```", "output": "FASTER 1.1941", "pair_id": "python_p03416_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 2.288} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport numpy as np\nfrom bisect import bisect_left\n\n\ndef func_1():\n var_4 = []\n var_1 = np.ones(10**5 + 10)\n var_1[0] = var_1[1] = 0\n for var_3, var_2 in enumerate(var_1):\n if var_2:\n var_4.append(var_3)\n var_1[2 * var_3 : 10**5 + 10 : var_3] = 0\n return var_4\n\n\ndef func_2(var_6):\n var_7 = int(var_6)\n var_5 = func_1()\n return str(var_5[bisect_left(var_5, var_7)])\n\n\nif __name__ == \"__main__\":\n import sys\n\n print((func_2(sys.stdin.read().strip())))\n```\n\n=== Code B (Modified) ===\n```python\nvar_4 = int(eval(input()))\nvar_1 = 0\nif var_4 == 2:\n print((2))\nelse:\n for var_2 in range(var_4, 10**6):\n for var_3 in range(2, var_2 // 2 + 2):\n if var_2 % var_3 == 0:\n break\n else:\n var_1 = var_2\n break\n print(var_1)\n```", "output": "FASTER 7.742", "pair_id": "python_p02819_forward", "problem_id": "p02819", "language": "python", "direction": "forward", "speedup_ratio": 214.0828} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\ndef func_1():\n var_1, var_2 = list(map(int, input().split()))\n var_3 = 0\n for var_4 in range(var_1, var_2 + 1):\n\n if (var_4 % 10) == (var_4 // 10000 % 10) and (var_4 // 10 % 10) == (\n var_4 // 1000 % 10\n ):\n var_3 += 1\n print(var_3)\n\n\nif __name__ == \"__main__\":\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = str(var_4)\n if var_5[0] == var_5[4] and var_5[1] == var_5[3]:\n var_3 += 1\nprint(var_3)\n```", "output": "SLOWER 1.3979", "pair_id": "python_p03416_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 2.6352} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().strip().split(\" \")))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n if str(var_4) == str(var_4)[::-1]:\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_3 in range(var_1, var_2 + 1):\n var_5 = list(str(var_3))\n var_6 = list(reversed(var_5))\n if var_5 == var_6:\n var_4 += 1\nprint(var_4)\n```", "output": "SLOWER 1.0014", "pair_id": "python_p03416_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 2.0019} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nfrom sys import stdin\n\nvar_5 = stdin.readline\nvar_2, var_1 = list(map(int, var_5().split()))\nvar_3 = [False] * var_2\nvar_8 = [0] * var_2\nvar_9 = 0\nfor var_4 in range(var_1):\n var_6, var_7 = var_5().split()\n var_6 = int(var_6) - 1\n if var_3[var_6] is False and var_7 == \"AC\":\n var_9 += var_8[var_6]\n var_3[var_6] = True\n elif var_7 == \"WA\":\n var_8[var_6] += 1\nprint((var_3.count(True), var_9))\n```\n\n=== Code B (Modified) ===\n```python\nvar_2, var_1 = list(map(int, input().split()))\nvar_6 = {}\nvar_3 = {}\nfor var_4 in range(var_1):\n var_5, var_7 = input().split()\n var_5 = int(var_5)\n if not var_5 in var_6:\n var_6[var_5] = 0\n var_3[var_5] = 0\n if var_7 == \"WA\" and var_3[var_5] == 0:\n var_6[var_5] += 1\n elif var_7 == \"AC\" and var_3[var_5] == 0:\n var_3[var_5] += 1\nfor var_4 in var_6:\n if var_6[var_4] != 0 and var_3[var_4] == 0:\n var_6[var_4] = 0\nprint((sum(var_3.values()), sum(var_6.values())))\n```", "output": "FASTER 1.107", "pair_id": "python_p02802_forward", "problem_id": "p02802", "language": "python", "direction": "forward", "speedup_ratio": 2.154} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_4 = {}\nvar_5 = 0\nfor var_6 in range(10000, 100000):\n var_3 = list(str(var_6))\n if var_3 == list(reversed(var_3)):\n var_5 += 1\n var_4[var_6] = var_5\nvar_1, var_2 = list(map(int, input().split()))\nprint((var_4[var_2] - var_4[var_1 - 1] if var_1 > 10000 else var_4[var_2]))\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_4 = str(var_4)\n if var_4 == var_4[::-1]:\n var_3 += 1\nprint(var_3)\n```", "output": "FASTER 3.4266", "pair_id": "python_p03416_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 10.7526} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_2 = int(eval(input()))\nvar_1 = list(map(int, input().split()))\nvar_4 = 1\nfor var_3 in range(var_2):\n if var_1[var_3] % 2 == 0:\n var_4 *= 2\nprint((3**var_2 - var_4))\n```\n\n=== Code B (Modified) ===\n```python\nimport math\nimport string\n\n\ndef func_5():\n return list(map(int, input().split()))\n\n\ndef func_4(var_7, var_8):\n return math.factorial(var_7) // (\n math.factorial(var_7 - var_8) * math.factorial(var_8)\n )\n\n\ndef func_3(var_10):\n var_9 = []\n for var_5 in var_10:\n if not (var_5 in var_9):\n var_9.append(var_5)\n return len(var_10) != len(var_9)\n\n\ndef func_1(var_7):\n func_1 = []\n for var_4 in range(1, var_7 + 1):\n if var_7 % var_4 == 0:\n func_1.append(var_4)\n return func_1\n\n\nvar_2 = [-1, -1, -1, 0, 0, 1, 1, 1]\nvar_3 = [-1, 0, 1, -1, 1, -1, 0, 1]\nvar_7 = int(eval(input()))\nvar_1 = func_5()\n\n\ndef func_2(var_6):\n if len(var_6) == var_7:\n for var_4 in range(len(var_6)):\n if var_6[var_4] % 2 == 0:\n return 1\n return 0\n return (\n func_2(var_6 + [var_1[len(var_6)]])\n + func_2(var_6 + [var_1[len(var_6)] - 1])\n + func_2(var_6 + [var_1[len(var_6)] + 1])\n )\n\n\nprint((func_2([])))\n```", "output": "SLOWER 7.6602", "pair_id": "python_p03568_reversed", "problem_id": "p03568", "language": "python", "direction": "reversed", "speedup_ratio": 202.2771} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\n\nvar_3 = sys.stdin.readline\nvar_1, var_2 = var_3().split()\nvar_1 = int(var_1)\nvar_2 = int(float(var_2) * 100 + 0.5)\nprint((var_1 * var_2 // 100))\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\nimport math\nfrom collections import defaultdict\nfrom bisect import bisect_left, bisect_right\n\nsys.setrecursionlimit(10**7)\n\n\ndef func_4():\n return sys.stdin.readline()[:-1]\n\n\nvar_4 = 10**9 + 7\n\n\ndef func_1():\n return int(eval(func_4()))\n\n\ndef func_2():\n return list(map(int, func_4().split()))\n\n\ndef func_3(var_6, var_3):\n if var_6 <= 0:\n return [[] for _ in range(var_3)]\n elif var_3 == 1:\n return [func_1() for _ in range(var_6)]\n else:\n var_5 = [func_2() for _ in range(var_6)]\n return list(map(list, list(zip(*var_5))))\n\n\nfrom decimal import getcontext, Decimal\n\ngetcontext().prec = 28\nvar_1, var_2 = list(map(str, func_4().split()))\nvar_1 = int(var_1)\nvar_2 = Decimal(var_2)\nprint((int(var_1 * var_2)))\n```", "output": "SLOWER 2.2902", "pair_id": "python_p02659_reversed", "problem_id": "p02659", "language": "python", "direction": "reversed", "speedup_ratio": 4.8913} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = str(var_4)\n if var_5 == var_5[::-1]:\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n if list(str(var_4)) == list(reversed(str(var_4))):\n var_3 += 1\nprint(var_3)\n```", "output": "SLOWER 1.4048", "pair_id": "python_p03416_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 2.6479} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2, var_8 = list(map(int, input().split()))\nvar_4 = list(map(int, input().split()))\nvar_9 = list(map(int, input().split()))\nvar_10 = [list(map(int, input().split())) for var_6 in range(var_8)]\nvar_7 = 200001\nfor var_6 in range(var_8):\n var_5 = var_10[var_6][0] - 1\n var_3 = var_10[var_6][1] - 1\n if var_7 >= var_4[var_5] + var_9[var_3] - var_10[var_6][2]:\n var_7 = var_4[var_5] + var_9[var_3] - var_10[var_6][2]\nvar_4.sort()\nvar_9.sort()\nif var_7 >= (var_4[0] + var_9[0]):\n print((var_4[0] + var_9[0]))\nelse:\n print(var_7)\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\nfrom collections import Counter\n\n\ndef func_10():\n return sys.stdin.readline().strip()\n\n\ndef func_11(var_12, var_13, var_14):\n return [[var_14] * var_13 for var_17 in range(var_12)]\n\n\ndef func_12(var_12, var_13, var_14, var_15):\n return [[[var_15] * var_14 for var_18 in range(var_13)] for var_17 in range(var_12)]\n\n\ndef func_13(var_12, var_13, var_14, var_15, var_16):\n return [\n [[[var_16] * var_15 for var_18 in range(var_14)] for var_18 in range(var_13)]\n for var_17 in range(var_12)\n ]\n\n\ndef func_8(var_22, var_23=1):\n return int(-(-var_22 // var_23))\n\n\ndef func_1():\n return int(eval(func_10()))\n\n\ndef func_3():\n return list(map(int, func_10().split()))\n\n\ndef func_2(var_11=None):\n return list(func_3()) if var_11 is None else [func_1() for var_17 in range(var_11)]\n\n\ndef func_7():\n print(\"Yes\")\n\n\ndef func_5():\n print(\"No\")\n\n\ndef func_6():\n print(\"YES\")\n\n\ndef func_4():\n print(\"NO\")\n\n\nsys.setrecursionlimit(10**9)\nvar_5 = 10**18\nvar_10 = 10**9 + 7\n\n\ndef func_9(var_1, var_2):\n \"\"\"\"\"\"\n import numpy as np\n from numpy.fft import rfft, irfft\n\n var_8 = max(var_1)\n var_9 = max(var_2)\n var_3 = [0] * (var_8 + 1)\n var_4 = [0] * (var_9 + 1)\n for var_12 in var_1:\n var_3[var_12] += 1\n for var_13 in var_2:\n var_4[var_13] += 1\n\n var_6 = 1\n var_19 = 0\n while var_6 <= var_8 + var_9:\n var_19 += 1\n var_6 = 2**var_19\n\n var_21 = irfft(rfft(var_3, var_6) * rfft(var_4, var_6), var_6)\n\n var_21 = np.rint(var_21).astype(np.int64)\n return var_21\n\n\nvar_11, var_7, var_6 = func_3()\nvar_1 = func_2()\nvar_2 = func_2()\nvar_21 = list(func_9(var_1, var_2))\nvar_20 = var_5\nfor var_17, var_12 in enumerate(var_21):\n if var_12 != 0:\n var_20 = var_17\n break\nfor _ in range(var_6):\n var_22, var_23, var_14 = func_3()\n var_22 -= 1\n var_23 -= 1\n var_20 = min(var_20, var_1[var_22] + var_2[var_23] - var_14)\nprint(var_20)\n```", "output": "SLOWER 2.5091", "pair_id": "python_p02748_reversed", "problem_id": "p02748", "language": "python", "direction": "reversed", "speedup_ratio": 5.6927} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_5 in range(var_1, var_2 + 1):\n var_3 = str(var_5)\n if var_3[0] == var_3[-1] and var_3[1] == var_3[-2]:\n var_4 += 1\nprint(var_4)\n```\n\n=== Code B (Modified) ===\n```python\nvar_4 = {}\nvar_5 = 0\nfor var_6 in range(10000, 100000):\n var_3 = list(str(var_6))\n if var_3 == list(reversed(var_3)):\n var_5 += 1\n var_4[var_6] = var_5\nvar_1, var_2 = list(map(int, input().split()))\nprint((var_4[var_2] - var_4[var_1 - 1] if var_1 > 10000 else var_4[var_2]))\n```", "output": "SLOWER 3.6652", "pair_id": "python_p03416_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 12.6861} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_8 = int(eval(input()))\nvar_5 = []\nvar_10 = {}\nvar_9 = [0, 0]\nfor var_6 in range(var_8 - 1):\n var_1, var_2 = list(map(int, input().split(\" \")))\n var_5.append([var_1, var_2])\n var_10.setdefault(var_1, []).append(var_2)\n var_9.append(0)\nvar_7 = 0\nfor var_11 in range(1, var_8 + 1):\n var_13 = var_10.get(var_11, [])\n var_3 = 1\n for var_12 in var_13:\n if var_3 == var_9[var_11]:\n var_3 += 1\n else:\n pass\n var_9[var_12] = var_3\n if var_3 >= var_7:\n var_7 = var_3\n var_3 += 1\nprint(var_7)\nfor var_4 in var_5:\n print((var_9[var_4[1]]))\n```\n\n=== Code B (Modified) ===\n```python\nvar_11 = int(eval(input()))\nvar_12 = {var_8: [] for var_8 in range(1, var_11 + 1)}\nvar_19 = [False for var_8 in range(var_11 + 1)]\nvar_16 = []\nfor _ in range(var_11 - 1):\n var_2, var_3 = list(map(int, input().split()))\n var_12[var_2].append(var_3)\n var_12[var_3].append(var_2)\n var_16.append((var_2, var_3))\nvar_9 = var_16[0][0]\nvar_19[var_9] = True\nvar_6 = []\nvar_7 = []\nvar_14 = {var_8: {} for var_8 in range(1, var_11 + 1)}\nvar_10 = [0 for var_8 in range(var_11 + 1)]\n\nvar_4 = 1\nfor var_5 in var_12[var_9]:\n var_19[var_5] = True\n var_14[var_9][var_5] = var_4\n var_14[var_5][var_9] = var_4\n var_10[var_5] = var_4\n var_4 += 1\n var_6.append(var_5)\nwhile var_6:\n for var_15 in var_6:\n var_13 = 1\n for var_5 in var_12[var_15]:\n if var_19[var_5] == False:\n var_19[var_5] = True\n if var_13 != var_10[var_15]:\n var_14[var_15][var_5] = var_13\n var_14[var_5][var_15] = var_13\n var_10[var_5] = var_13\n var_13 += 1\n var_7.append(var_5)\n else:\n var_13 += 1\n var_14[var_15][var_5] = var_13\n var_14[var_5][var_15] = var_13\n var_10[var_5] = var_13\n var_13 += 1\n var_7.append(var_5)\n if var_7:\n var_6 = var_7\n var_7 = []\n else:\n var_6 = []\n var_7 = []\nvar_1 = 0\nfor var_8 in range(1, var_11 + 1):\n var_1 = max(var_1, len(var_12[var_8]))\nprint(var_1)\nfor var_8 in range(var_11 - 1):\n var_17, var_18 = var_16[var_8][0], var_16[var_8][1]\n print((var_14[var_17][var_18]))\n```", "output": "SLOWER 1.1629", "pair_id": "python_p02850_reversed", "problem_id": "p02850", "language": "python", "direction": "reversed", "speedup_ratio": 2.239} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_2, var_1 = [int(var_12) for var_12 in input().split()]\nvar_3 = []\nfor var_8 in range(var_1):\n var_5, var_6 = [int(var_12) for var_12 in input().split()]\n var_3.append((var_5, var_6))\nvar_3.sort()\nvar_9 = float(\"inf\")\nvar_4 = [var_9 for var_5 in range(var_2 + 1)]\nfor var_5, var_6 in var_3:\n var_4[var_5] = min(var_4[var_5], var_6)\nvar_3 = [\n (var_5, var_4[var_5]) for var_5 in range(1, var_2 + 1) if var_4[var_5] != var_9\n]\nvar_3.sort(key=lambda var_11: var_11[1])\nvar_7 = [True] * (var_2)\nvar_10 = None\nfor var_5, var_6 in var_3:\n if var_10 == None or var_10 < var_5:\n var_7[var_6 - 1] = False\n var_10 = var_6 - 1\nprint((sum(1 for var_6 in var_7 if not var_6)))\n```\n\n=== Code B (Modified) ===\n```python\nvar_4, var_3 = list(map(int, input().split()))\nvar_1 = [tuple(map(int, input().split())) for _ in range(var_3)]\nvar_1.sort(key=lambda var_8: var_8[0])\nvar_7 = 1\nvar_2 = 10**9\nfor var_5, var_6 in var_1:\n if var_5 < var_2:\n var_2 = min(var_2, var_6)\n else:\n var_7 += 1\n var_2 = var_6\nprint(var_7)\n```", "output": "FASTER 1.0247", "pair_id": "python_p03295_forward", "problem_id": "p03295", "language": "python", "direction": "forward", "speedup_ratio": 2.0345} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1 = list(map(int, input().split()))\nvar_2 = 0\nfor var_3 in range(var_1[0], var_1[1] + 1):\n var_4 = str(var_3)\n if var_4[0] == var_4[4] and var_4[1] == var_4[3]:\n var_2 += 1\nprint(var_2)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\n\n\ndef func_1(var_5):\n var_4 = 0\n for var_3 in range(1, var_5 + 1):\n if str(var_3) == str(var_3)[::-1]:\n var_4 += 1\n return var_4\n\n\nprint((func_1(var_2) - func_1(var_1 - 1)))\n```", "output": "SLOWER 1.8794", "pair_id": "python_p03416_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 3.6793} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\ndef func_1(var_3):\n var_4 = int(var_3)\n for var_1 in range(var_4, 2 * var_4):\n for var_2 in range(2, int(var_1**0.5)):\n if var_1 % var_2 == 0:\n break\n else:\n return str(var_1)\n\n\nif __name__ == \"__main__\":\n import sys\n\n print((func_1(sys.stdin.read().strip())))\n```\n\n=== Code B (Modified) ===\n```python\nimport numpy as np\nfrom bisect import bisect_left\n\n\ndef func_1():\n var_4 = []\n var_1 = np.ones(10**5 + 10)\n var_1[0] = var_1[1] = 0\n for var_3, var_2 in enumerate(var_1):\n if var_2:\n var_4.append(var_3)\n var_1[2 * var_3 : 10**5 + 10 : var_3] = 0\n return var_4\n\n\ndef func_2(var_6):\n var_7 = int(var_6)\n var_5 = func_1()\n return str(var_5[bisect_left(var_5, var_7)])\n\n\nif __name__ == \"__main__\":\n import sys\n\n print((func_2(sys.stdin.read().strip())))\n```", "output": "SLOWER 7.8177", "pair_id": "python_p02819_reversed", "problem_id": "p02819", "language": "python", "direction": "reversed", "speedup_ratio": 225.6147} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_3 in range(var_1, var_2 + 1):\n var_5 = list(str(var_3))\n var_6 = list(reversed(var_5))\n if var_5 == var_6:\n var_4 += 1\nprint(var_4)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\n\n\ndef func_1(var_5, var_6):\n var_4 = 0\n for var_3 in range(var_5, var_6 + 1):\n if str(var_3) == str(var_3)[::-1]:\n var_4 += 1\n return var_4\n\n\nprint((func_1(var_1, var_2)))\n```", "output": "FASTER 1.6323", "pair_id": "python_p03416_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 3.1} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_4 = int(eval(input()))\nvar_1 = list(map(int, input().split()))\nvar_3 = 1\nfor var_2 in var_1:\n var_3 *= 2 if var_2 % 2 == 0 else 1\nprint((3**var_4 - var_3))\n```\n\n=== Code B (Modified) ===\n```python\nfrom functools import reduce\nfrom itertools import product\n\nvar_2 = int(eval(input()))\n(*var_1,) = list(map(int, input().split()))\nvar_4 = 0\nfor var_7 in product([-1, 0, 1], repeat=var_2):\n var_6 = reduce(\n lambda var_8, var_9: var_8 * var_9,\n [var_3 + var_7[var_5] for var_5, var_3 in enumerate(var_1)],\n )\n if var_6 % 2 == 0:\n var_4 += 1\nprint(var_4)\n```", "output": "SLOWER 9.8819", "pair_id": "python_p03568_reversed", "problem_id": "p03568", "language": "python", "direction": "reversed", "speedup_ratio": 943.5387} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nfrom itertools import accumulate, count\nfrom bisect import bisect_right\n\neval(input())\nvar_1 = [0] + list(accumulate(list(map(int, input().split()))))\nvar_2 = bisect_right(var_1, var_1[-1] // 2)\nprint((min(2 * var_1[var_2] - var_1[-1], var_1[-1] - 2 * var_1[var_2 - 1])))\n```\n\n=== Code B (Modified) ===\n```python\nvar_8 = int(eval(input()))\nvar_1 = list(map(int, input().split()))\nvar_3 = 0\nvar_9 = sum(var_1)\nvar_2 = []\nvar_10 = 0\nfor var_6 in range(0, var_8):\n\n var_10 += var_1[var_6]\n var_11 = var_9 - var_10\n\n var_2.append(abs(var_10 - var_11))\n if var_10 == var_11:\n print((0))\n exit()\nvar_7 = var_2.index(min(var_2))\n\n\nvar_12 = sum(var_1[0:var_7])\nvar_13 = sum(var_1[var_7:])\n\n\nvar_4 = abs(var_12 - var_13)\nvar_14 = sum(var_1[0 : var_7 + 1])\nvar_15 = sum(var_1[var_7 + 1 :])\n\n\nvar_5 = abs(var_14 - var_15)\nprint((min(var_4, var_5)))\n```", "output": "SLOWER 1.1094", "pair_id": "python_p02854_reversed", "problem_id": "p02854", "language": "python", "direction": "reversed", "speedup_ratio": 2.1576} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_4 = {}\nvar_5 = 0\nfor var_6 in range(10000, 100000):\n var_3 = list(str(var_6))\n if var_3 == list(reversed(var_3)):\n var_5 += 1\n var_4[var_6] = var_5\nvar_1, var_2 = list(map(int, input().split()))\nprint((var_4[var_2] - var_4[var_1 - 1] if var_1 > 10000 else var_4[var_2]))\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_3 = list(map(int, input().split()))\nvar_2 = 0\nfor var_5 in range(var_3 + 1)[var_1:]:\n if len(str(var_5)) % 2 == 0:\n var_6 = list(str(var_5))[: len(str(var_5)) // 2]\n var_7 = list(reversed(list(str(var_5))[len(str(var_5)) // 2 :]))\n if var_6 == var_7:\n var_2 += 1\n else:\n var_8 = list(str(var_5))[: len(str(var_5)) // 2 + 1]\n var_4 = list(reversed(list(str(var_5))[len(str(var_5)) // 2 :]))\n if var_8 == var_4:\n var_2 += 1\nprint(var_2)\n```", "output": "FASTER 1.0991", "pair_id": "python_p03416_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 2.1422} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_4 = {}\nvar_5 = 0\nfor var_6 in range(10000, 100000):\n var_3 = list(str(var_6))\n if var_3 == list(reversed(var_3)):\n var_5 += 1\n var_4[var_6] = var_5\nvar_1, var_2 = list(map(int, input().split()))\nprint((var_4[var_2] - var_4[var_1 - 1] if var_1 > 10000 else var_4[var_2]))\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n if str(var_4) == \"\".join(reversed(str(var_4))):\n var_3 += 1\nprint(var_3)\n```", "output": "FASTER 2.4974", "pair_id": "python_p03416_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 5.6465} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_4 = str(var_4)\n if var_4 == var_4[::-1]:\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = [0] * (var_2 + 1)\nfor var_3 in range(1, var_2 + 1):\n if str(var_3) == str(var_3)[::-1]:\n var_4[var_3] = var_4[var_3 - 1] + 1\n else:\n var_4[var_3] = var_4[var_3 - 1]\nprint((var_4[var_2] - var_4[var_1 - 1]))\n```", "output": "SLOWER 1.7953", "pair_id": "python_p03416_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 3.4708} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\nimport math\nfrom collections import defaultdict\nfrom bisect import bisect_left, bisect_right\n\nsys.setrecursionlimit(10**7)\n\n\ndef func_4():\n return sys.stdin.readline()[:-1]\n\n\nvar_4 = 10**9 + 7\n\n\ndef func_1():\n return int(eval(func_4()))\n\n\ndef func_2():\n return list(map(int, func_4().split()))\n\n\ndef func_3(var_6, var_3):\n if var_6 <= 0:\n return [[] for _ in range(var_3)]\n elif var_3 == 1:\n return [func_1() for _ in range(var_6)]\n else:\n var_5 = [func_2() for _ in range(var_6)]\n return list(map(list, list(zip(*var_5))))\n\n\nvar_1, var_2 = list(map(str, func_4().split()))\nvar_1 = int(var_1)\nvar_2 = 100 * int(var_2[0]) + 10 * int(var_2[2]) + int(var_2[3])\nprint((var_1 * var_2 // 100))\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\n\nvar_3 = sys.stdin.readline\nif __name__ == \"__main__\":\n var_1, var_2 = var_3().split()\n print((int(var_1) * round(float(var_2) * 100) // 100))\n```", "output": "FASTER 2.2625", "pair_id": "python_p02659_forward", "problem_id": "p02659", "language": "python", "direction": "forward", "speedup_ratio": 4.7983} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nfrom collections import Counter\n\nvar_1 = input()[::-1]\nvar_5 = [0]\nvar_4 = 0\nvar_6 = 2019\nfor var_7 in var_1:\n var_8 = int(var_7) * pow(10, var_4, var_6) % var_6\n var_8 = var_5[-1] + var_8\n var_5.append(var_8 % var_6)\n var_4 += 1\nvar_3 = Counter(var_5)\nvar_2 = sum(var_9 * (var_9 - 1) // 2 for var_9 in list(var_3.values()))\nprint(var_2)\n```\n\n=== Code B (Modified) ===\n```python\nvar_6 = input()[::-1]\nvar_4 = len(var_6)\nvar_2 = [0] * 2019\nvar_2[0] = 1\nvar_7 = 1\nvar_5 = 0\nvar_1 = 0\nfor var_3 in range(var_4):\n var_5 = (var_5 + int(var_6[var_3]) * var_7) % 2019\n var_7 = var_7 * 10 % 2019\n var_2[var_5] += 1\nfor var_3 in var_2:\n var_1 += var_3 * (var_3 - 1) // 2\nprint(var_1)\n```", "output": "SLOWER 1.9664", "pair_id": "python_p02702_reversed", "problem_id": "p02702", "language": "python", "direction": "reversed", "speedup_ratio": 3.908} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\nfrom operator import itemgetter\nfrom heapq import heapify, heappop, heappush\n\nvar_1 = int(10e15)\nvar_2 = -var_1\nvar_11 = 1000000007\nsys.setrecursionlimit(1000000)\n\n\ndef func_2():\n return list(map(int, input().split()))\n\n\ndef func_4():\n return input().split()\n\n\ndef func_1():\n return int(sys.stdin.readline())\n\n\ndef func_3():\n return eval(input())\n\n\nvar_3, var_4 = func_2()\nvar_5 = [func_2() for var_9 in range(var_3)]\nvar_5.sort(key=itemgetter(0))\n\nvar_8 = [[0] * (var_4 + 1 + 3000 + 1) for _ in range(var_3 + 1)]\nvar_6 = 0\nfor var_9 in range(var_3):\n for var_10 in range(var_4 + 1 + 3000 + 1):\n var_12, var_7 = var_5[var_9]\n if 0 <= var_10 - var_12 < var_4:\n var_8[var_9 + 1][var_10] = max(\n var_8[var_9][var_10], var_8[var_9][var_10 - var_12] + var_7\n )\n else:\n var_8[var_9 + 1][var_10] = var_8[var_9][var_10]\n var_6 = max(var_6, var_8[var_9 + 1][var_10])\nprint(var_6)\n```\n\n=== Code B (Modified) ===\n```python\nfrom collections import Counter, defaultdict, deque\nfrom heapq import heappop, heappush, heapify\nimport sys, bisect, math, itertools, fractions, pprint\n\nsys.setrecursionlimit(10**8)\nvar_6 = 10**9 + 7\nvar_1 = float(\"inf\")\n\n\ndef func_1():\n return int(sys.stdin.readline())\n\n\ndef func_2():\n return list(map(int, sys.stdin.readline().split()))\n\n\nvar_8, var_11 = func_2()\nvar_17 = [func_2() for _ in range(var_8)]\nvar_10 = var_17[::-1]\nvar_14 = [[0] * var_11 for _ in range(var_8)]\nvar_3 = [[0] * var_11 for _ in range(var_8)]\nfor var_4 in range(var_8 - 1):\n var_16, var_15 = var_17[var_4]\n for var_5 in range(var_11):\n if var_5 < var_16:\n var_14[var_4 + 1][var_5] = var_14[var_4][var_5]\n else:\n var_14[var_4 + 1][var_5] = max(\n var_14[var_4][var_5], var_14[var_4][var_5 - var_16] + var_15\n )\nvar_9 = var_14[var_8 - 1][var_11 - 1] + var_17[var_8 - 1][1]\nfor var_4 in range(var_8 - 1):\n var_16, var_15 = var_10[var_4]\n for var_5 in range(var_11):\n if var_5 < var_16:\n var_3[var_4 + 1][var_5] = var_3[var_4][var_5]\n else:\n var_3[var_4 + 1][var_5] = max(\n var_3[var_4][var_5], var_3[var_4][var_5 - var_16] + var_15\n )\n var_9 = max(var_9, var_3[var_8 - 1][var_11 - 1] + var_17[0][1])\n\nfor var_4 in range(1, var_8 - 1):\n var_13 = var_4\n var_2 = var_8 - var_4 - 1\n var_7 = 0\n for var_5 in range(var_11):\n var_12 = var_14[var_13][var_5] + var_3[var_2][var_11 - 1 - var_5]\n var_7 = max(var_7, var_12)\n var_9 = max(var_9, var_7 + var_17[var_4][1])\nprint(var_9)\n```", "output": "FASTER 3.8148", "pair_id": "python_p02863_forward", "problem_id": "p02863", "language": "python", "direction": "forward", "speedup_ratio": 14.0727} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_4 = str(var_4)\n if var_4 == var_4[::-1]:\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = list(str(var_4))\n if var_5 == list(reversed(var_5)):\n var_3 += 1\nprint(var_3)\n```", "output": "SLOWER 1.0852", "pair_id": "python_p03416_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 2.1216} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\n\n\ndef func_1(var_5):\n var_4 = 0\n for var_3 in range(1, var_5 + 1):\n if str(var_3) == str(var_3)[::-1]:\n var_4 += 1\n return var_4\n\n\nprint((func_1(var_2) - func_1(var_1 - 1)))\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = str(var_4)\n if var_5[0] == var_5[4] and var_5[1] == var_5[3]:\n var_3 += 1\nprint(var_3)\n```", "output": "FASTER 1.8568", "pair_id": "python_p03416_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 3.622} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\ndef func_1():\n var_1, var_2 = list(map(int, input().split()))\n var_3 = 0\n for var_4 in range(var_1, var_2 + 1):\n\n if (var_4 % 10) == (var_4 // 10000 % 10) and (var_4 // 10 % 10) == (\n var_4 // 1000 % 10\n ):\n var_3 += 1\n print(var_3)\n\n\nif __name__ == \"__main__\":\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = input().split()\nvar_1 = int(var_1)\nvar_2 = int(var_2)\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = list(str(var_4))\n if (var_5[0] == var_5[4]) and (var_5[1] == var_5[3]):\n var_3 = var_3 + 1\nprint(var_3)\n```", "output": "SLOWER 2.0684", "pair_id": "python_p03416_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 4.1941} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_8 in range(var_1, var_2 + 1):\n var_7 = str(var_8)\n var_6 = len(var_7)\n var_4 = True\n for var_5 in range(var_6 // 2):\n if var_7[var_5] != var_7[var_6 - 1 - var_5]:\n var_4 = False\n break\n if var_4:\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\ndef func_1():\n var_1, var_2 = list(map(int, input().split()))\n var_3 = 0\n for var_4 in range(var_1, var_2 + 1):\n\n if (var_4 % 10) == (var_4 // 10000 % 10) and (var_4 // 10 % 10) == (\n var_4 // 1000 % 10\n ):\n var_3 += 1\n print(var_3)\n\n\nif __name__ == \"__main__\":\n func_1()\n```", "output": "FASTER 2.7903", "pair_id": "python_p03416_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 6.9176} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\nimport itertools\n\n\ndef func_2(var_4):\n return bin(eval(\"0b\" + str(var_4)))\n\n\ndef func_1():\n var_4 = int(sys.stdin.readline().rstrip())\n var_9 = [\n func_2(\"\".join(str(var_10) for var_10 in sys.stdin.readline().split()))\n for _ in range(var_4)\n ]\n var_8 = [\n [int(var_10) for var_10 in sys.stdin.readline().split()] for _ in range(var_4)\n ]\n var_3 = -(10**10)\n for var_6 in itertools.product(\"01\", repeat=10):\n var_6 = func_2(\"\".join(var_6))\n if var_6 == \"0b0\":\n continue\n var_7 = 0\n for var_2 in range(var_4):\n var_1 = var_9[var_2]\n var_5 = bin(eval(var_1) & eval(var_6)).count(\"1\")\n var_7 += var_8[var_2][var_5]\n var_3 = max(var_3, var_7)\n print(var_3)\n\n\nif __name__ == \"__main__\":\n\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\n\nvar_8 = sys.stdin.readline\n\n\ndef func_1():\n var_2 = int(eval(var_8()))\n var_1 = []\n for _ in range(var_2):\n var_1.append(list(map(int, var_8().split())))\n var_3 = []\n for _ in range(var_2):\n var_3.append(list(map(int, var_8().split())))\n var_4 = -(10**7) * var_2\n for var_7 in range(1, 1 << 10):\n var_11 = 0\n for var_10, var_6 in enumerate(var_1):\n var_5 = 0\n for var_9 in range(10):\n if (var_7 >> var_9) & 1 & var_6[var_9]:\n var_5 += 1\n var_11 += var_3[var_10][var_5]\n var_4 = max(var_4, var_11)\n print(var_4)\n\n\nif __name__ == \"__main__\":\n func_1()\n```", "output": "FASTER 3.5396", "pair_id": "python_p03503_forward", "problem_id": "p03503", "language": "python", "direction": "forward", "speedup_ratio": 11.6284} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nfrom sys import stdin\n\nvar_5 = stdin.readline\nvar_2, var_1 = list(map(int, var_5().split()))\nvar_3 = [False] * var_2\nvar_8 = [0] * var_2\nvar_9 = 0\nfor var_4 in range(var_1):\n var_6, var_7 = var_5().split()\n var_6 = int(var_6) - 1\n if var_3[var_6] is False and var_7 == \"AC\":\n var_9 += var_8[var_6]\n var_3[var_6] = True\n elif var_7 == \"WA\":\n var_8[var_6] += 1\nprint((var_3.count(True), var_9))\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\n\nvar_2, var_1, *var_3 = sys.stdin.read().strip().split()\nvar_2 = int(var_2)\nvar_5 = [0] * var_2\nvar_10 = [0] * var_2\nfor var_6, var_8 in zip(*[iter(var_3)] * 2):\n var_6 = int(var_6) - 1\n if var_8 == \"AC\":\n var_5[var_6] = 1\n elif var_5[var_6] == 0:\n var_10[var_6] += 1\nvar_7 = sum([var_9 * var_4 for var_4, var_9 in zip(var_5, var_10)])\nprint((\"{} {}\".format(sum(var_5), var_7)))\n```", "output": "SLOWER 1.5188", "pair_id": "python_p02802_reversed", "problem_id": "p02802", "language": "python", "direction": "reversed", "speedup_ratio": 2.8656} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nfrom math import sqrt\n\nvar_2 = int(eval(input()))\n\n\ndef func_1(var_2):\n if var_2 < 2:\n return False\n for var_1 in range(2, int(sqrt(var_2)) + 1):\n if var_2 % var_1 == 0:\n return False\n return True\n\n\nwhile not func_1(var_2):\n var_2 += 1\nprint(var_2)\n```\n\n=== Code B (Modified) ===\n```python\nimport numpy as np\nfrom bisect import bisect_left\n\n\ndef func_1():\n var_4 = []\n var_1 = np.ones(10**5 + 10)\n var_1[0] = var_1[1] = 0\n for var_3, var_2 in enumerate(var_1):\n if var_2:\n var_4.append(var_3)\n var_1[2 * var_3 : 10**5 + 10 : var_3] = 0\n return var_4\n\n\ndef func_2(var_6):\n var_7 = int(var_6)\n var_5 = func_1()\n return str(var_5[bisect_left(var_5, var_7)])\n\n\nif __name__ == \"__main__\":\n import sys\n\n print((func_2(sys.stdin.read().strip())))\n```", "output": "SLOWER 7.7622", "pair_id": "python_p02819_reversed", "problem_id": "p02819", "language": "python", "direction": "reversed", "speedup_ratio": 217.0952} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport math\n\n\ndef func_1():\n var_1, var_2 = list(map(int, input().split()))\n\n var_5 = max(math.ceil(var_1 / 0.08), math.ceil(var_2 / 0.1))\n\n var_4 = min((math.ceil((var_1 + 1) / 0.08), math.ceil((var_2 + 1) / 0.1)))\n\n for var_3 in range(var_5, var_4 + 1):\n if (math.floor(var_3 * 0.08) == var_1) and (math.floor(var_3 * 0.1) == var_2):\n print(var_3)\n quit()\n\n print((-1))\n\n\nif __name__ == \"__main__\":\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nfor var_3 in range(1, 1009):\n if int(var_3 * 0.08) == var_1 and int(var_3 * 0.1) == var_2:\n print((int(var_3)))\n exit()\nprint(\"-1\")\n```", "output": "SLOWER 1.1794", "pair_id": "python_p02755_reversed", "problem_id": "p02755", "language": "python", "direction": "reversed", "speedup_ratio": 2.2649} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\nimport math\nfrom collections import defaultdict\nfrom bisect import bisect_left, bisect_right\n\nsys.setrecursionlimit(10**7)\n\n\ndef func_4():\n return sys.stdin.readline()[:-1]\n\n\nvar_4 = 10**9 + 7\n\n\ndef func_1():\n return int(eval(func_4()))\n\n\ndef func_2():\n return list(map(int, func_4().split()))\n\n\ndef func_3(var_6, var_3):\n if var_6 <= 0:\n return [[] for _ in range(var_3)]\n elif var_3 == 1:\n return [func_1() for _ in range(var_6)]\n else:\n var_5 = [func_2() for _ in range(var_6)]\n return list(map(list, list(zip(*var_5))))\n\n\nfrom decimal import getcontext, Decimal\n\ngetcontext().prec = 28\nvar_1, var_2 = list(map(str, func_4().split()))\nvar_1 = int(var_1)\nvar_2 = Decimal(var_2)\nprint((int(var_1 * var_2)))\n```\n\n=== Code B (Modified) ===\n```python\nimport math\n\nvar_1, var_2 = input().split()\nvar_1 = int(var_1)\nvar_3 = int(var_2[0] + var_2[2] + var_2[3])\nprint((int(var_1 * var_3) // 100))\n```", "output": "FASTER 2.2596", "pair_id": "python_p02659_forward", "problem_id": "p02659", "language": "python", "direction": "forward", "speedup_ratio": 4.7885} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\nimport itertools\n\n\ndef func_2(var_4):\n return eval(\"0b\" + var_4)\n\n\ndef func_1():\n var_4 = int(sys.stdin.readline().rstrip())\n var_9 = [\n func_2(\"\".join(str(var_10) for var_10 in sys.stdin.readline().split()))\n for _ in range(var_4)\n ]\n var_8 = [\n [int(var_10) for var_10 in sys.stdin.readline().split()] for _ in range(var_4)\n ]\n var_3 = -(10**10)\n for var_6 in itertools.product(\"01\", repeat=10):\n var_6 = func_2(\"\".join(var_6))\n if var_6 == 0:\n continue\n var_7 = 0\n for var_2 in range(var_4):\n var_1 = var_9[var_2]\n var_5 = bin(var_1 & var_6).count(\"1\")\n var_7 += var_8[var_2][var_5]\n var_3 = max(var_3, var_7)\n print(var_3)\n\n\nif __name__ == \"__main__\":\n\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\n\nvar_8 = sys.stdin.readline\n\n\ndef func_1():\n var_2 = int(eval(var_8()))\n var_1 = [int(var_8().replace(\" \", \"\"), 2) for _ in range(var_2)]\n var_3 = [list(map(int, var_8().split())) for _ in range(var_2)]\n var_4 = -(10**7) * var_2\n for var_7 in range(1, 1 << 10):\n var_10 = 0\n for var_9, var_6 in enumerate(var_1):\n var_5 = bin(var_7 & var_6).count(\"1\")\n var_10 += var_3[var_9][var_5]\n var_4 = max(var_4, var_10)\n print(var_4)\n\n\nif __name__ == \"__main__\":\n func_1()\n```", "output": "FASTER 3.1382", "pair_id": "python_p03503_forward", "problem_id": "p03503", "language": "python", "direction": "forward", "speedup_ratio": 8.8042} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\nimport math\nfrom collections import defaultdict\nfrom bisect import bisect_left, bisect_right\n\nsys.setrecursionlimit(10**7)\n\n\ndef func_4():\n return sys.stdin.readline()[:-1]\n\n\nvar_4 = 10**9 + 7\n\n\ndef func_1():\n return int(eval(func_4()))\n\n\ndef func_2():\n return list(map(int, func_4().split()))\n\n\ndef func_3(var_6, var_3):\n if var_6 <= 0:\n return [[] for _ in range(var_3)]\n elif var_3 == 1:\n return [func_1() for _ in range(var_6)]\n else:\n var_5 = [func_2() for _ in range(var_6)]\n return list(map(list, list(zip(*var_5))))\n\n\nvar_1, var_2 = list(map(str, func_4().split()))\nvar_1 = int(var_1)\nvar_2 = 100 * int(var_2[0]) + 10 * int(var_2[2]) + int(var_2[3])\nprint((var_1 * var_2 // 100))\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = input().split()\nvar_1 = int(var_1)\nvar_2 = int(\"\".join(var_2.split(\".\")))\nprint(((var_1 * var_2) // 100))\n```", "output": "FASTER 2.5041", "pair_id": "python_p02659_forward", "problem_id": "p02659", "language": "python", "direction": "forward", "speedup_ratio": 5.673} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n if list(str(var_4)) == list(reversed(str(var_4))):\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_5 in range(var_1, var_2 + 1):\n var_3 = str(var_5)\n if var_3[0] == var_3[-1] and var_3[1] == var_3[-2]:\n var_4 += 1\nprint(var_4)\n```", "output": "FASTER 1.492", "pair_id": "python_p03416_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 2.8127} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = str(var_4)\n if var_5 == var_5[::-1]:\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\n\n\ndef func_1(var_5):\n var_4 = 0\n for var_3 in range(1, var_5 + 1):\n if str(var_3) == str(var_3)[::-1]:\n var_4 += 1\n return var_4\n\n\nprint((func_1(var_2) - func_1(var_1 - 1)))\n```", "output": "SLOWER 1.5951", "pair_id": "python_p03416_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 3.0211} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nfrom fractions import Fraction\n\nvar_1, var_2 = input().split()\n\n\nfrom decimal import *\n\nvar_4 = var_3(var_1)\nvar_6 = var_3(var_2)\nvar_7().prec = 28\nvar_5 = var_4 * var_6\nprint((int(var_5)))\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\nimport math\nfrom collections import defaultdict\nfrom bisect import bisect_left, bisect_right\n\nsys.setrecursionlimit(10**7)\n\n\ndef func_4():\n return sys.stdin.readline()[:-1]\n\n\nvar_4 = 10**9 + 7\n\n\ndef func_1():\n return int(eval(func_4()))\n\n\ndef func_2():\n return list(map(int, func_4().split()))\n\n\ndef func_3(var_6, var_3):\n if var_6 <= 0:\n return [[] for _ in range(var_3)]\n elif var_3 == 1:\n return [func_1() for _ in range(var_6)]\n else:\n var_5 = [func_2() for _ in range(var_6)]\n return list(map(list, list(zip(*var_5))))\n\n\nvar_1, var_2 = list(map(str, func_4().split()))\nvar_1 = int(var_1)\nvar_2 = 100 * int(var_2[0]) + 10 * int(var_2[2]) + int(var_2[3])\nprint((var_1 * var_2 // 100))\n```", "output": "SLOWER 1.9202", "pair_id": "python_p02659_reversed", "problem_id": "p02659", "language": "python", "direction": "reversed", "speedup_ratio": 3.7848} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_4 = {}\nvar_5 = 0\nfor var_6 in range(10000, 100000):\n var_3 = list(str(var_6))\n if var_3 == list(reversed(var_3)):\n var_5 += 1\n var_4[var_6] = var_5\nvar_1, var_2 = list(map(int, input().split()))\nprint((var_4[var_2] - var_4[var_1 - 1] if var_1 > 10000 else var_4[var_2]))\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = input().split()\nvar_1 = int(var_1)\nvar_2 = int(var_2)\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = list(str(var_4))\n if (var_5[0] == var_5[4]) and (var_5[1] == var_5[3]):\n var_3 = var_3 + 1\nprint(var_3)\n```", "output": "FASTER 3.1693", "pair_id": "python_p03416_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 8.996} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_5 in range(10):\n for var_6 in range(10):\n for var_7 in range(10):\n var_3 = 10000 * var_5 + 1000 * var_6 + 100 * var_7 + 10 * var_6 + var_5\n if var_1 <= var_3 <= var_2:\n var_4 += 1\nprint(var_4)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_3 in range(var_1, var_2 + 1):\n var_5 = list(str(var_3))\n var_6 = list(reversed(var_5))\n if var_5 == var_6:\n var_4 += 1\nprint(var_4)\n```", "output": "SLOWER 5.1342", "pair_id": "python_p03416_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 35.1196} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\ndef func_1():\n var_1, var_2 = list(map(int, input().rstrip().split()))\n var_3 = 0\n for var_4 in range(var_1, var_2 + 1):\n var_5 = str(var_4)\n if var_5 == var_5[::-1]:\n var_3 += 1\n print(var_3)\n\n\nif __name__ == \"__main__\":\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nvar_10 = []\nvar_10 = input().rstrip().split(\" \")\nvar_1 = int(var_10[0])\nvar_3 = int(var_10[1])\nvar_2 = 0\nvar_6 = var_1\nwhile var_6 <= var_3:\n var_4 = var_6 // 10000\n var_5 = (var_6 - var_4 * 10000) // 1000\n var_7 = var_6 // 100\n var_8 = (var_6 - var_7 * 100) // 10\n var_9 = var_6 % 10\n if (var_4 == var_9) and (var_5 == var_8):\n var_2 += 1\n var_6 += 1\nprint(var_2)\n```", "output": "SLOWER 1.555", "pair_id": "python_p03416_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 2.9383} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = [\n var_3 for var_3 in map(str, list(range(var_1, var_2 + 1))) if var_3 == var_3[::-1]\n]\nprint((len(var_4)))\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_3 = list(map(int, input().split()))\nvar_2 = 0\nfor var_5 in range(var_3 + 1)[var_1:]:\n if len(str(var_5)) % 2 == 0:\n var_6 = list(str(var_5))[: len(str(var_5)) // 2]\n var_7 = list(reversed(list(str(var_5))[len(str(var_5)) // 2 :]))\n if var_6 == var_7:\n var_2 += 1\n else:\n var_8 = list(str(var_5))[: len(str(var_5)) // 2 + 1]\n var_4 = list(reversed(list(str(var_5))[len(str(var_5)) // 2 :]))\n if var_8 == var_4:\n var_2 += 1\nprint(var_2)\n```", "output": "SLOWER 3.1731", "pair_id": "python_p03416_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 9.0199} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_11 = int(eval(input()))\nvar_12 = {var_8: [] for var_8 in range(1, var_11 + 1)}\nvar_19 = [False for var_8 in range(var_11 + 1)]\nvar_16 = []\nfor _ in range(var_11 - 1):\n var_2, var_3 = list(map(int, input().split()))\n var_12[var_2].append(var_3)\n var_12[var_3].append(var_2)\n var_16.append((var_2, var_3))\nvar_9 = var_16[0][0]\nvar_19[var_9] = True\nvar_6 = []\nvar_7 = []\nvar_14 = {var_8: {} for var_8 in range(1, var_11 + 1)}\nvar_10 = [0 for var_8 in range(var_11 + 1)]\n\nvar_4 = 1\nfor var_5 in var_12[var_9]:\n var_19[var_5] = True\n var_14[var_9][var_5] = var_4\n var_14[var_5][var_9] = var_4\n var_10[var_5] = var_4\n var_4 += 1\n var_6.append(var_5)\nwhile var_6:\n for var_15 in var_6:\n var_13 = 1\n for var_5 in var_12[var_15]:\n if var_19[var_5] == False:\n var_19[var_5] = True\n if var_13 != var_10[var_15]:\n var_14[var_15][var_5] = var_13\n var_14[var_5][var_15] = var_13\n var_10[var_5] = var_13\n var_13 += 1\n var_7.append(var_5)\n else:\n var_13 += 1\n var_14[var_15][var_5] = var_13\n var_14[var_5][var_15] = var_13\n var_10[var_5] = var_13\n var_13 += 1\n var_7.append(var_5)\n if var_7:\n var_6 = var_7\n var_7 = []\n else:\n var_6 = []\n var_7 = []\nvar_1 = 0\nfor var_8 in range(1, var_11 + 1):\n var_1 = max(var_1, len(var_12[var_8]))\nprint(var_1)\nfor var_8 in range(var_11 - 1):\n var_17, var_18 = var_16[var_8][0], var_16[var_8][1]\n print((var_14[var_17][var_18]))\n```\n\n=== Code B (Modified) ===\n```python\nvar_8 = int(eval(input()))\nvar_5 = []\nvar_10 = {}\nvar_9 = [0, 0]\nfor var_6 in range(var_8 - 1):\n var_1, var_2 = list(map(int, input().split(\" \")))\n var_5.append([var_1, var_2])\n var_10.setdefault(var_1, []).append(var_2)\n var_9.append(0)\nvar_7 = 0\nfor var_11 in range(1, var_8 + 1):\n var_13 = var_10.get(var_11, [])\n var_3 = 1\n for var_12 in var_13:\n if var_3 == var_9[var_11]:\n var_3 += 1\n else:\n pass\n var_9[var_12] = var_3\n if var_3 >= var_7:\n var_7 = var_3\n var_3 += 1\nprint(var_7)\nfor var_4 in var_5:\n print((var_9[var_4[1]]))\n```", "output": "FASTER 1.1629", "pair_id": "python_p02850_forward", "problem_id": "p02850", "language": "python", "direction": "forward", "speedup_ratio": 2.239} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_4 = str(var_4)\n if var_4 == var_4[::-1]:\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_4 = {}\nvar_5 = 0\nfor var_6 in range(10000, 100000):\n var_3 = list(str(var_6))\n if var_3 == list(reversed(var_3)):\n var_5 += 1\n var_4[var_6] = var_5\nvar_1, var_2 = list(map(int, input().split()))\nprint((var_4[var_2] - var_4[var_1 - 1] if var_1 > 10000 else var_4[var_2]))\n```", "output": "SLOWER 3.4266", "pair_id": "python_p03416_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 10.7526} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_8, var_9 = list(map(int, input().split()))\nvar_5 = [[0] * (var_9 + 3001) for _ in range(var_8 + 1)]\nvar_3 = 0\nvar_2 = [list(map(int, input().split())) for _ in range(var_8)]\nvar_2.sort()\nfor var_6 in range(1, var_8 + 1):\n var_1, var_4 = var_2[var_6 - 1]\n for var_7 in range(var_9):\n var_5[var_6][var_7] = max(var_5[var_6 - 1][var_7], var_5[var_6][var_7])\n var_5[var_6][var_7 + var_1] = var_5[var_6 - 1][var_7] + var_4\n var_3 = max(var_5[var_6][var_7], var_5[var_6][var_7 + var_1], var_3)\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nfrom collections import Counter, defaultdict, deque\nfrom heapq import heappop, heappush, heapify\nimport sys, bisect, math, itertools, fractions, pprint\n\nsys.setrecursionlimit(10**8)\nvar_6 = 10**9 + 7\nvar_1 = float(\"inf\")\n\n\ndef func_1():\n return int(sys.stdin.readline())\n\n\ndef func_2():\n return list(map(int, sys.stdin.readline().split()))\n\n\nvar_7, var_9 = func_2()\nvar_13 = [func_2() for _ in range(var_7)]\nvar_13.sort(key=lambda var_14: var_14[1], reverse=True)\nvar_8 = 0\nvar_10 = min(var_7, 5)\nfor var_3 in range(var_10):\n var_2 = [[0] * (var_9 + 5) for _ in range(var_7 + 5)]\n for var_4 in range(var_7):\n var_12, var_11 = var_13[var_4]\n for var_5 in range(var_9):\n if var_5 < var_12 or var_3 == var_4:\n var_2[var_4 + 1][var_5] = var_2[var_4][var_5]\n else:\n var_2[var_4 + 1][var_5] = max(\n var_2[var_4][var_5], var_2[var_4][var_5 - var_12] + var_11\n )\n\n var_8 = max(var_2[var_7][var_9 - 1] + var_13[var_3][1], var_8)\nprint(var_8)\n```", "output": "SLOWER 1.1289", "pair_id": "python_p02863_reversed", "problem_id": "p02863", "language": "python", "direction": "reversed", "speedup_ratio": 2.1869} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_7, var_6 = list(map(int, input().split()))\nvar_5 = [tuple(input().split()) for _ in range(var_6)]\nvar_9 = [[] for _ in range(var_7)]\nfor var_2 in range(var_6):\n var_9[int(var_5[var_2][0]) - 1].append(var_5[var_2][1])\nvar_1, var_8 = 0, 0\nfor var_3 in range(var_7):\n if \"AC\" in var_9[var_3]:\n var_1 += 1\n for var_4 in range(len(var_9[var_3])):\n if var_9[var_3][var_4] == \"WA\":\n var_8 += 1\n else:\n break\nprint((var_1, var_8))\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\n\nvar_2, var_1, *var_3 = sys.stdin.read().strip().split()\nvar_2 = int(var_2)\nvar_5 = [0] * var_2\nvar_10 = [0] * var_2\nfor var_6, var_8 in zip(*[iter(var_3)] * 2):\n var_6 = int(var_6) - 1\n if var_8 == \"AC\":\n var_5[var_6] = 1\n elif var_5[var_6] == 0:\n var_10[var_6] += 1\nvar_7 = sum([var_9 * var_4 for var_4, var_9 in zip(var_5, var_10)])\nprint((\"{} {}\".format(sum(var_5), var_7)))\n```", "output": "FASTER 1.5456", "pair_id": "python_p02802_forward", "problem_id": "p02802", "language": "python", "direction": "forward", "speedup_ratio": 2.9193} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nfrom collections import deque\n\n\ndef func_2(var_9, var_2, var_4):\n\n var_6 = {var_7: dict() for var_7 in range(var_9)}\n for var_7 in range(var_9 - 1):\n var_1, var_3 = var_2[var_7] - 1, var_4[var_7] - 1\n var_6[var_1][var_3] = -1\n var_6[var_3][var_1] = -1\n var_8 = max([len(var_6[var_1]) for var_1 in range(var_9)])\n var_14 = [-1] * var_9\n var_14[0] = var_8 - 1\n\n var_12 = deque([0])\n while len(var_12) > 0:\n var_10 = var_12.popleft()\n var_5 = var_14[var_10]\n for var_11 in list(var_6[var_10].keys()):\n if var_14[var_11] != -1:\n continue\n var_5 += 1\n var_5 %= var_8\n\n var_6[var_10][var_11] = var_5\n var_6[var_11][var_10] = var_5\n var_14[var_11] = var_5\n var_12.append(var_11)\n var_13 = [0] * (var_9 - 1)\n for var_7 in range(var_9 - 1):\n var_13[var_7] = var_6[var_2[var_7] - 1][var_4[var_7] - 1] + 1\n return var_8, var_13\n\n\ndef func_1():\n var_9 = int(eval(input()))\n var_2 = [0] * (var_9 - 1)\n var_4 = [0] * (var_9 - 1)\n for var_7 in range(var_9 - 1):\n var_1, var_3 = list(map(int, input().split()))\n var_2[var_7] = var_1\n var_4[var_7] = var_3\n var_8, var_13 = func_2(var_9, var_2, var_4)\n print(var_8)\n for var_7 in range(var_9 - 1):\n print((var_13[var_7]))\n\n\ndef func_3():\n print((func_2(3, [1, 2], [2, 3])))\n print((func_2(8, [1, 2, 2, 2, 4, 5, 6], [2, 3, 4, 5, 7, 6, 8])))\n\n\nif __name__ == \"__main__\":\n\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\nfrom collections import deque\n\nvar_13 = sys.stdin.readline\nvar_2 = int(eval(var_13()))\nvar_5 = [[] for _ in range(var_2)]\nvar_3 = [-1] * var_2\nfor var_12 in range(var_2 - 1):\n var_6, var_8 = list(map(int, var_13().split()))\n var_5[var_6 - 1].append((var_12, var_8 - 1))\n\n\nvar_4 = deque([(0, -1)])\nvar_1 = [-1] * (var_2 - 1)\nvar_11 = 0\nwhile var_4:\n var_14, var_10 = var_4.pop()\n var_9 = 1\n for var_12, var_15 in var_5[var_14]:\n if var_9 == var_10:\n var_9 += 1\n var_1[var_12] = var_9\n var_4.appendleft((var_15, var_9))\n var_9 += 1\n var_11 = max(var_11, var_9 - 1)\nprint(var_11)\nfor var_7 in var_1:\n print(var_7)\n```", "output": "FASTER 1.0324", "pair_id": "python_p02850_forward", "problem_id": "p02850", "language": "python", "direction": "forward", "speedup_ratio": 2.0454} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nfrom math import floor\n\nvar_1, var_2 = list(map(int, input().split()))\n\n\nfor var_3 in range(1010):\n if (floor(var_3 * 0.08) == var_1) and (floor(var_3 * 0.1) == var_2):\n\n print(var_3)\n quit()\n\n\nprint((-1))\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nimport math\n\nif math.ceil((var_1 + 1) * 12.5) <= math.ceil(var_2 * 10) or math.ceil(\n var_1 * 12.5\n) >= math.ceil((var_2 + 1) * 10):\n print((-1))\nelse:\n print((max(math.ceil(var_1 * 12.5), math.ceil(var_2 * 10))))\n```", "output": "FASTER 1.8508", "pair_id": "python_p02755_forward", "problem_id": "p02755", "language": "python", "direction": "forward", "speedup_ratio": 3.6071} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1 = list(map(int, input().split()))\nvar_2 = 0\nfor var_3 in range(var_1[0], var_1[1] + 1):\n var_4 = str(var_3)\n if var_4[0] == var_4[4] and var_4[1] == var_4[3]:\n var_2 += 1\nprint(var_2)\n```\n\n=== Code B (Modified) ===\n```python\nvar_4 = {}\nvar_5 = 0\nfor var_6 in range(10000, 100000):\n var_3 = list(str(var_6))\n if var_3 == list(reversed(var_3)):\n var_5 += 1\n var_4[var_6] = var_5\nvar_1, var_2 = list(map(int, input().split()))\nprint((var_4[var_2] - var_4[var_1 - 1] if var_1 > 10000 else var_4[var_2]))\n```", "output": "SLOWER 3.8624", "pair_id": "python_p03416_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 14.5446} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_4 = {}\nvar_5 = 0\nfor var_6 in range(10000, 100000):\n var_3 = list(str(var_6))\n if var_3 == list(reversed(var_3)):\n var_5 += 1\n var_4[var_6] = var_5\nvar_1, var_2 = list(map(int, input().split()))\nprint((var_4[var_2] - var_4[var_1 - 1] if var_1 > 10000 else var_4[var_2]))\n```\n\n=== Code B (Modified) ===\n```python\ndef func_1():\n var_1, var_2 = list(map(int, input().split()))\n var_3 = 0\n for var_4 in range(var_1, var_2 + 1):\n\n if (var_4 % 10) == (var_4 // 10000 % 10) and (var_4 // 10 % 10) == (\n var_4 // 1000 % 10\n ):\n var_3 += 1\n print(var_3)\n\n\nif __name__ == \"__main__\":\n func_1()\n```", "output": "FASTER 5.2377", "pair_id": "python_p03416_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 37.7303} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_3 = list(map(int, input().split()))\nvar_2 = 0\nfor var_5 in range(var_3 + 1)[var_1:]:\n if len(str(var_5)) % 2 == 0:\n var_6 = list(str(var_5))[: len(str(var_5)) // 2]\n var_7 = list(reversed(list(str(var_5))[len(str(var_5)) // 2 :]))\n if var_6 == var_7:\n var_2 += 1\n else:\n var_8 = list(str(var_5))[: len(str(var_5)) // 2 + 1]\n var_4 = list(reversed(list(str(var_5))[len(str(var_5)) // 2 :]))\n if var_8 == var_4:\n var_2 += 1\nprint(var_2)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_5 in range(var_1, var_2 + 1):\n var_3 = str(var_5)\n if var_3[0] == var_3[-1] and var_3[1] == var_3[-2]:\n var_4 += 1\nprint(var_4)\n```", "output": "FASTER 2.5661", "pair_id": "python_p03416_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 5.9221} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_2, var_3, *var_1 = list(map(int, open(0).read().split()))\nvar_4 = [0] * (var_3 + max(var_1[::2]))\nfor var_7, var_6 in sorted(zip(*[iter(var_1)] * 2)):\n for var_5 in reversed(list(range(var_3))):\n var_4[var_5 + var_7] = max(var_4[var_5 + var_7], var_4[var_5] + var_6)\nprint((max(var_4)))\n```\n\n=== Code B (Modified) ===\n```python\nvar_8, var_9 = list(map(int, input().split()))\nvar_5 = [[0] * (var_9 + 3001) for _ in range(var_8 + 1)]\nvar_3 = 0\nvar_2 = [list(map(int, input().split())) for _ in range(var_8)]\nvar_2.sort()\nfor var_6 in range(1, var_8 + 1):\n var_1, var_4 = var_2[var_6 - 1]\n for var_7 in range(var_9):\n var_5[var_6][var_7] = max(var_5[var_6 - 1][var_7], var_5[var_6][var_7])\n var_5[var_6][var_7 + var_1] = var_5[var_6 - 1][var_7] + var_4\n var_3 = max(var_5[var_6][var_7], var_5[var_6][var_7 + var_1], var_3)\nprint(var_3)\n```", "output": "SLOWER 1.0971", "pair_id": "python_p02863_reversed", "problem_id": "p02863", "language": "python", "direction": "reversed", "speedup_ratio": 2.1392} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_4 = int(eval(input()))\nvar_2 = list(map(int, input().split()))\n\n\ndef func_1(var_1, var_8, var_3):\n if var_8 == var_4:\n var_9 = 1\n for var_5 in var_3:\n var_9 *= var_5\n return 1 if var_9 % 2 == 0 else 0\n var_6 = var_3.copy()\n var_6.append(var_1[var_8] - 1)\n var_5 = var_3.copy()\n var_5.append(var_1[var_8])\n var_7 = var_3.copy()\n var_7.append(var_1[var_8] + 1)\n return (\n func_1(var_1, var_8 + 1, var_6)\n + func_1(var_1, var_8 + 1, var_5)\n + func_1(var_1, var_8 + 1, var_7)\n )\n\n\nprint((func_1(var_2, 0, [])))\n```\n\n=== Code B (Modified) ===\n```python\ndef func_1():\n var_2 = int(eval(input()))\n var_1 = [int(var_6) for var_6 in input().split()]\n var_4 = 3**var_2\n var_5 = len([var_3 for var_3 in var_1 if var_3 % 2 == 0])\n var_4 -= 2**var_5\n print(var_4)\n\n\nif __name__ == \"__main__\":\n func_1()\n```", "output": "FASTER 7.7739", "pair_id": "python_p03568_forward", "problem_id": "p03568", "language": "python", "direction": "forward", "speedup_ratio": 218.8599} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\n\nvar_10 = sys.stdin.readline\nvar_2, var_3 = list(map(int, var_10().split()))\nvar_1 = [list(map(int, var_10().split())) for _ in range(var_2)]\nvar_8 = [[0 for _ in range(var_2 + 1)] for _ in range(var_3 + 1)]\n\nvar_13 = [[0 for _ in range(var_2 + 1)] for _ in range(var_3 + 1)]\nfor var_11 in range(var_2):\n var_4, var_6 = var_1[var_11]\n for var_15 in range(var_3):\n if var_4 > var_15:\n var_8[var_15][var_11 + 1] = var_8[var_15][var_11]\n var_13[var_15][var_11 + 1] = var_15\n else:\n if var_6 + var_8[var_15 - var_4][var_11] >= var_8[var_15][var_11]:\n var_8[var_15][var_11 + 1] = var_8[var_15 - var_4][var_11] + var_6\n var_13[var_15][var_11 + 1] = var_15 - var_4\n else:\n var_8[var_15][var_11 + 1] = var_8[var_15][var_11]\n var_13[var_15][var_11 + 1] = var_15\nvar_5 = var_8[var_3 - 1][var_2]\nvar_14 = [False] * var_2\nvar_7 = var_3 - 1\nfor var_9 in reversed(list(range(var_2))):\n if var_13[var_7][var_9 + 1] == var_7 - var_1[var_9][0]:\n var_14[var_9] = True\n var_7 = var_13[var_7][var_9 + 1]\nvar_12 = 0\nfor var_9 in range(var_2):\n if not var_14[var_9] and var_1[var_9][1] > var_12:\n var_12 = var_1[var_9][1]\nprint((var_5 + var_12))\n```\n\n=== Code B (Modified) ===\n```python\nvar_2, var_3, *var_1 = list(map(int, open(0).read().split()))\nvar_4 = [0] * (var_3 + max(var_1[::2]))\nfor var_7, var_6 in sorted(zip(*[iter(var_1)] * 2)):\n for var_5 in reversed(list(range(var_3))):\n var_4[var_5 + var_7] = max(var_4[var_5 + var_7], var_4[var_5] + var_6)\nprint((max(var_4)))\n```", "output": "FASTER 1.0715", "pair_id": "python_p02863_forward", "problem_id": "p02863", "language": "python", "direction": "forward", "speedup_ratio": 2.1016} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nfrom sys import stdin\n\n\ndef func_1():\n\n var_13 = stdin.readline\n var_2 = int(var_13())\n var_1 = []\n for var_6 in range(var_2):\n var_5 = list(map(int, var_13().split()))\n var_1.append(var_5)\n var_3 = []\n for var_6 in range(var_2):\n var_12 = list(map(int, var_13().split()))\n var_3.append(var_12)\n var_9 = -float(\"inf\")\n for var_6 in range(1 << 10):\n if var_6 == 0:\n continue\n else:\n var_11 = []\n for var_7 in range(10):\n if (var_6 >> var_7) & 1:\n var_11.append(var_7)\n var_10 = [0] * 10\n for var_7 in var_11:\n var_10[var_7] = 1\n var_14 = 0\n for var_7 in range(var_2):\n var_4 = 0\n for var_8 in range(10):\n if var_10[var_8] == 1 and var_1[var_7][var_8] == 1:\n var_4 += 1\n var_14 += var_3[var_7][var_4]\n var_9 = max(var_14, var_9)\n print(var_9)\n\n\nif __name__ == \"__main__\":\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\nimport itertools\n\n\ndef func_2(var_4):\n return eval(\"0b\" + var_4)\n\n\ndef func_1():\n var_4 = int(sys.stdin.readline().rstrip())\n var_9 = [\n func_2(\"\".join(str(var_10) for var_10 in sys.stdin.readline().split()))\n for _ in range(var_4)\n ]\n var_8 = [\n [int(var_10) for var_10 in sys.stdin.readline().split()] for _ in range(var_4)\n ]\n var_3 = -(10**10)\n for var_6 in itertools.product(\"01\", repeat=10):\n var_6 = func_2(\"\".join(var_6))\n if var_6 == 0:\n continue\n var_7 = 0\n for var_2 in range(var_4):\n var_1 = var_9[var_2]\n var_5 = bin(var_1 & var_6).count(\"1\")\n var_7 += var_8[var_2][var_5]\n var_3 = max(var_3, var_7)\n print(var_3)\n\n\nif __name__ == \"__main__\":\n\n func_1()\n```", "output": "SLOWER 1.1909", "pair_id": "python_p03503_reversed", "problem_id": "p03503", "language": "python", "direction": "reversed", "speedup_ratio": 2.2829} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nfrom collections import deque\n\n\ndef func_2(var_9, var_2, var_4):\n\n var_6 = {var_7: dict() for var_7 in range(var_9)}\n for var_7 in range(var_9 - 1):\n var_1, var_3 = var_2[var_7] - 1, var_4[var_7] - 1\n var_6[var_1][var_3] = -1\n var_6[var_3][var_1] = -1\n var_8 = max([len(var_6[var_1]) for var_1 in range(var_9)])\n var_14 = [-1] * var_9\n var_14[0] = var_8 - 1\n\n var_12 = deque([0])\n while len(var_12) > 0:\n var_10 = var_12.popleft()\n var_5 = var_14[var_10]\n for var_11 in list(var_6[var_10].keys()):\n if var_14[var_11] != -1:\n continue\n var_5 += 1\n var_5 %= var_8\n\n var_6[var_10][var_11] = var_5\n var_6[var_11][var_10] = var_5\n var_14[var_11] = var_5\n var_12.append(var_11)\n var_13 = [0] * (var_9 - 1)\n for var_7 in range(var_9 - 1):\n var_13[var_7] = var_6[var_2[var_7] - 1][var_4[var_7] - 1] + 1\n return var_8, var_13\n\n\ndef func_1():\n var_9 = int(eval(input()))\n var_2 = [0] * (var_9 - 1)\n var_4 = [0] * (var_9 - 1)\n for var_7 in range(var_9 - 1):\n var_1, var_3 = list(map(int, input().split()))\n var_2[var_7] = var_1\n var_4[var_7] = var_3\n var_8, var_13 = func_2(var_9, var_2, var_4)\n print(var_8)\n for var_7 in range(var_9 - 1):\n print((var_13[var_7]))\n\n\ndef func_3():\n print((func_2(3, [1, 2], [2, 3])))\n print((func_2(8, [1, 2, 2, 2, 4, 5, 6], [2, 3, 4, 5, 7, 6, 8])))\n\n\nif __name__ == \"__main__\":\n\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\nfrom collections import deque\n\nvar_13 = sys.stdin.readline\nvar_2 = int(eval(var_13()))\nvar_5 = [deque() for _ in range(var_2)]\nvar_3 = [-1] * var_2\nfor var_12 in range(var_2 - 1):\n var_6, var_8 = list(map(int, var_13().split()))\n var_5[var_6 - 1].append((var_12, var_8 - 1))\n\n\nvar_4 = deque([(0, -1)])\nvar_1 = [-1] * (var_2 - 1)\nvar_11 = 0\nwhile var_4:\n var_14, var_10 = var_4.pop()\n var_9 = 1\n for var_12, var_15 in var_5[var_14]:\n if var_9 == var_10:\n var_9 += 1\n var_1[var_12] = var_9\n var_4.appendleft((var_15, var_9))\n var_9 += 1\n var_11 = max(var_11, var_9 - 1)\nprint(var_11)\nfor var_7 in var_1:\n print(var_7)\n```", "output": "FASTER 1.0091", "pair_id": "python_p02850_forward", "problem_id": "p02850", "language": "python", "direction": "forward", "speedup_ratio": 2.0126} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\ndef func_1():\n var_1, var_2 = list(map(int, input().rstrip().split()))\n var_3 = 0\n for var_4 in range(var_1, var_2 + 1):\n var_5 = str(var_4)\n if var_5 == var_5[::-1]:\n var_3 += 1\n print(var_3)\n\n\nif __name__ == \"__main__\":\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_7 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_3 = True\n var_8 = str(var_4)\n var_6 = len(var_8)\n for var_5 in range(var_6 // 2 + 1):\n if var_8[var_5] != var_8[-var_5 - 1]:\n var_3 = False\n break\n if var_3:\n var_7 += 1\nprint(var_7)\n```", "output": "SLOWER 1.8711", "pair_id": "python_p03416_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 3.6581} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\ndef func_1():\n var_2 = int(input())\n var_1 = [int(var_6) for var_6 in input().split()]\n if var_2 == 1:\n return print(1 if var_1[0] % 2 == 0 else 2)\n var_3 = 0\n var_5 = (-1, 0, 1)\n from itertools import product\n\n for var_6 in product(range(3), repeat=var_2):\n var_4 = 1\n for var_7 in range(var_2):\n var_4 *= var_1[var_7] + var_5[var_6[var_7]]\n if var_4 % 2 == 0:\n var_3 += 1\n print(var_3)\n\n\nif __name__ == \"__main__\":\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\ndef func_1():\n var_2 = int(eval(input()))\n var_1 = [int(var_6) for var_6 in input().split()]\n var_4 = 3**var_2\n var_5 = len([var_3 for var_3 in var_1 if var_3 % 2 == 0])\n var_4 -= 2**var_5\n print(var_4)\n\n\nif __name__ == \"__main__\":\n func_1()\n```", "output": "FASTER 8.0497", "pair_id": "python_p03568_forward", "problem_id": "p03568", "language": "python", "direction": "forward", "speedup_ratio": 264.9728} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\n\nvar_2, var_1, *var_3 = sys.stdin.read().strip().split()\nvar_2 = int(var_2)\nvar_5 = [0] * var_2\nvar_10 = [0] * var_2\nfor var_6, var_8 in zip(*[iter(var_3)] * 2):\n var_6 = int(var_6) - 1\n if var_8 == \"AC\":\n var_5[var_6] = 1\n elif var_5[var_6] == 0:\n var_10[var_6] += 1\nvar_7 = sum([var_9 * var_4 for var_4, var_9 in zip(var_5, var_10)])\nprint((\"{} {}\".format(sum(var_5), var_7)))\n```\n\n=== Code B (Modified) ===\n```python\nfrom sys import stdin\n\nvar_5 = stdin.readline\nvar_2, var_1 = list(map(int, var_5().split()))\nvar_3 = [False] * var_2\nvar_8 = [0] * var_2\nvar_9 = 0\nfor var_4 in range(var_1):\n var_6, var_7 = var_5().split()\n var_6 = int(var_6) - 1\n if var_3[var_6] is False and var_7 == \"AC\":\n var_9 += var_8[var_6]\n var_3[var_6] = True\n elif var_7 == \"WA\":\n var_8[var_6] += 1\nprint((var_3.count(True), var_9))\n```", "output": "FASTER 1.5188", "pair_id": "python_p02802_forward", "problem_id": "p02802", "language": "python", "direction": "forward", "speedup_ratio": 2.8656} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nfrom sys import stdin\n\n\ndef func_1():\n\n var_9 = stdin.readline\n var_8, var_10 = list(map(int, var_9().split()))\n var_7 = [list(map(int, var_9().split())) for _ in range(var_8)]\n var_7.sort()\n var_1 = [0] * var_8\n var_2 = [0] * var_8\n for var_4 in range(var_8):\n var_1[var_4], var_2[var_4] = var_7[var_4][0], var_7[var_4][1]\n\n var_5 = -float(\"inf\")\n var_3 = [[var_5] * (var_10 + 1) for _ in range(var_8 + 1)]\n var_3[0][0] = 0\n for var_4 in range(var_8):\n for var_6 in range(var_10 + 1):\n\n if var_6 != var_10:\n var_3[var_4 + 1][min(var_10, var_6 + var_1[var_4])] = max(\n var_3[var_4 + 1][min(var_10, var_6 + var_1[var_4])],\n var_3[var_4][var_6] + var_2[var_4],\n )\n\n var_3[var_4 + 1][var_6] = max(var_3[var_4 + 1][var_6], var_3[var_4][var_6])\n print((max(var_3[var_8])))\n\n\nif __name__ == \"__main__\":\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\nfrom operator import itemgetter\nfrom heapq import heapify, heappop, heappush\n\nvar_1 = int(10e15)\nvar_2 = -var_1\nvar_11 = 1000000007\nsys.setrecursionlimit(1000000)\n\n\ndef func_2():\n return list(map(int, input().split()))\n\n\ndef func_4():\n return input().split()\n\n\ndef func_1():\n return int(sys.stdin.readline())\n\n\ndef func_3():\n return eval(input())\n\n\nvar_3, var_4 = func_2()\nvar_5 = [func_2() for var_9 in range(var_3)]\nvar_5.sort(key=itemgetter(0))\n\nvar_8 = [[0] * (var_4 + 1 + 3000 + 1) for _ in range(var_3 + 1)]\nvar_6 = 0\nfor var_9 in range(var_3):\n for var_10 in range(var_4 + 1 + 3000 + 1):\n var_12, var_7 = var_5[var_9]\n if 0 <= var_10 - var_12 < var_4:\n var_8[var_9 + 1][var_10] = max(\n var_8[var_9][var_10], var_8[var_9][var_10 - var_12] + var_7\n )\n else:\n var_8[var_9 + 1][var_10] = var_8[var_9][var_10]\n var_6 = max(var_6, var_8[var_9 + 1][var_10])\nprint(var_6)\n```", "output": "SLOWER 4.8948", "pair_id": "python_p02863_reversed", "problem_id": "p02863", "language": "python", "direction": "reversed", "speedup_ratio": 29.7492} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\nimport itertools\n\n\ndef func_2(var_4):\n return bin(eval(\"0b\" + str(var_4)))\n\n\ndef func_1():\n var_4 = int(sys.stdin.readline().rstrip())\n var_9 = [\n func_2(\"\".join(str(var_10) for var_10 in sys.stdin.readline().split()))\n for _ in range(var_4)\n ]\n var_8 = [\n [int(var_10) for var_10 in sys.stdin.readline().split()] for _ in range(var_4)\n ]\n var_3 = -(10**10)\n for var_6 in itertools.product(\"01\", repeat=10):\n var_6 = func_2(\"\".join(var_6))\n if var_6 == \"0b0\":\n continue\n var_7 = 0\n for var_2 in range(var_4):\n var_1 = var_9[var_2]\n var_5 = bin(eval(var_1) & eval(var_6)).count(\"1\")\n var_7 += var_8[var_2][var_5]\n var_3 = max(var_3, var_7)\n print(var_3)\n\n\nif __name__ == \"__main__\":\n\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\n\nvar_7 = sys.stdin.readline\nfrom itertools import combinations\n\n\ndef func_3(var_10):\n for _ in range(var_10):\n yield list(map(int, var_7().split()))\n\n\ndef func_1(var_9, var_5, var_11):\n var_3 = len([0 for var_8 in var_9 if var_5[var_8] == 1])\n return var_11[var_3]\n\n\ndef func_2():\n var_10 = int(eval(var_7()))\n var_1 = list(func_3(var_10))\n var_2 = list(func_3(var_10))\n for var_6 in range(1, 11):\n for var_4 in combinations(list(range(10)), var_6):\n yield sum(\n func_1(var_4, var_5, var_11) for var_5, var_11 in zip(var_1, var_2)\n )\n\n\nprint((max(func_2())))\n```", "output": "FASTER 4.1946", "pair_id": "python_p03503_forward", "problem_id": "p03503", "language": "python", "direction": "forward", "speedup_ratio": 18.3107} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_6 = int(eval(input()))\nvar_2 = list(map(int, input().split()))\nfrom itertools import product\n\nvar_5 = [-1, 0, 1]\nvar_3 = 0\nfor var_7 in product(var_5, repeat=var_6):\n var_1 = []\n for var_4 in range(var_6):\n var_1.append(var_7[var_4] + var_2[var_4])\n if any(var_8 % 2 == 0 for var_8 in var_1):\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nimport math\nimport string\n\n\ndef func_4():\n return list(map(int, input().split()))\n\n\ndef func_3(var_6, var_7):\n return math.factorial(var_6) // (\n math.factorial(var_6 - var_7) * math.factorial(var_7)\n )\n\n\ndef func_2(var_9):\n var_8 = []\n for var_5 in var_9:\n if not (var_5 in var_8):\n var_8.append(var_5)\n return len(var_9) != len(var_8)\n\n\ndef func_1(var_6):\n func_1 = []\n for var_4 in range(1, var_6 + 1):\n if var_6 % var_4 == 0:\n func_1.append(var_4)\n return func_1\n\n\nvar_2 = [-1, -1, -1, 0, 0, 1, 1, 1]\nvar_3 = [-1, 0, 1, -1, 1, -1, 0, 1]\nvar_6 = int(eval(input()))\nvar_1 = func_4()\nvar_10 = 1\nfor var_4 in range(len(var_1)):\n if var_1[var_4] % 2 == 0:\n var_10 *= 2\n else:\n var_10 *= 1\nprint((3 ** len(var_1) - var_10))\n```", "output": "FASTER 8.1431", "pair_id": "python_p03568_forward", "problem_id": "p03568", "language": "python", "direction": "forward", "speedup_ratio": 282.6949} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport bisect\nimport sys\n\nsys.setrecursionlimit(10**6)\nvar_16 = sys.stdout.write\nvar_7 = lambda *var_14: print(*var_14) if var_1 else 0\nvar_1 = True\n\n\ndef func_1(var_9=sys.stdin.readline):\n var_11 = lambda: var_9().rstrip()\n var_3 = lambda: list(map(int, var_11().split()))\n var_2 = lambda: int(var_11())\n var_4 = lambda var_17: [var_3() for _ in range(var_17)]\n var_13, var_15 = var_3()\n var_5 = var_4(var_13)\n var_5.sort()\n var_8 = [[0] * var_15 for _ in range(var_13 + 1)]\n for var_10 in range(1, var_13 + 1):\n for var_12 in range(1, var_15):\n if var_12 < var_5[var_10 - 1][0]:\n var_8[var_10][var_12] = var_8[var_10 - 1][var_12]\n else:\n var_8[var_10][var_12] = max(\n var_8[var_10 - 1][var_12],\n var_8[var_10 - 1][var_12 - var_5[var_10 - 1][0]]\n + var_5[var_10 - 1][1],\n )\n var_6 = 0\n for var_10 in range(var_13):\n var_6 = max(var_6, var_8[var_10][var_15 - 1] + var_5[var_10][1])\n print(var_6)\n\n\nif __name__ == \"__main__\":\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nfrom collections import Counter, defaultdict, deque\nfrom heapq import heappop, heappush, heapify\nimport sys, bisect, math, itertools, fractions, pprint\n\nsys.setrecursionlimit(10**8)\nvar_6 = 10**9 + 7\nvar_1 = float(\"inf\")\n\n\ndef func_1():\n return int(sys.stdin.readline())\n\n\ndef func_2():\n return list(map(int, sys.stdin.readline().split()))\n\n\nvar_8, var_11 = func_2()\nvar_17 = [func_2() for _ in range(var_8)]\nvar_10 = var_17[::-1]\nvar_14 = [[0] * var_11 for _ in range(var_8)]\nvar_3 = [[0] * var_11 for _ in range(var_8)]\nfor var_4 in range(var_8 - 1):\n var_16, var_15 = var_17[var_4]\n for var_5 in range(var_11):\n if var_5 < var_16:\n var_14[var_4 + 1][var_5] = var_14[var_4][var_5]\n else:\n var_14[var_4 + 1][var_5] = max(\n var_14[var_4][var_5], var_14[var_4][var_5 - var_16] + var_15\n )\nvar_9 = var_14[var_8 - 1][var_11 - 1] + var_17[var_8 - 1][1]\nfor var_4 in range(var_8 - 1):\n var_16, var_15 = var_10[var_4]\n for var_5 in range(var_11):\n if var_5 < var_16:\n var_3[var_4 + 1][var_5] = var_3[var_4][var_5]\n else:\n var_3[var_4 + 1][var_5] = max(\n var_3[var_4][var_5], var_3[var_4][var_5 - var_16] + var_15\n )\n var_9 = max(var_9, var_3[var_8 - 1][var_11 - 1] + var_17[0][1])\n\nfor var_4 in range(1, var_8 - 1):\n var_13 = var_4\n var_2 = var_8 - var_4 - 1\n var_7 = 0\n for var_5 in range(var_11):\n var_12 = var_14[var_13][var_5] + var_3[var_2][var_11 - 1 - var_5]\n var_7 = max(var_7, var_12)\n var_9 = max(var_9, var_7 + var_17[var_4][1])\nprint(var_9)\n```", "output": "SLOWER 1.4049", "pair_id": "python_p02863_reversed", "problem_id": "p02863", "language": "python", "direction": "reversed", "speedup_ratio": 2.648} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_3 = list(map(int, input().split()))\nvar_2 = 0\nfor var_5 in range(var_3 + 1)[var_1:]:\n if len(str(var_5)) % 2 == 0:\n var_6 = list(str(var_5))[: len(str(var_5)) // 2]\n var_7 = list(reversed(list(str(var_5))[len(str(var_5)) // 2 :]))\n if var_6 == var_7:\n var_2 += 1\n else:\n var_8 = list(str(var_5))[: len(str(var_5)) // 2 + 1]\n var_4 = list(reversed(list(str(var_5))[len(str(var_5)) // 2 :]))\n if var_8 == var_4:\n var_2 += 1\nprint(var_2)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().strip().split(\" \")))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n if str(var_4) == str(var_4)[::-1]:\n var_3 += 1\nprint(var_3)\n```", "output": "FASTER 2.1673", "pair_id": "python_p03416_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 4.4917} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport copy\n\nvar_8 = int(eval(input()))\nvar_10 = set([var_6 for var_6 in range(1, 10**5)])\nvar_5 = []\nvar_11 = {}\nvar_9 = []\nfor var_6 in range(var_8 - 1):\n var_1, var_2 = list(map(int, input().split(\" \")))\n var_5.append([var_1, var_2])\n var_11.setdefault(var_1, []).append(var_2)\n var_9.append([])\nvar_9.append([])\nvar_9.append([])\nvar_7 = 0\nfor var_12 in range(1, var_8 + 1):\n var_14 = var_11.get(var_12, [])\n var_3 = 1\n for var_13 in var_14:\n if var_3 in var_9[var_12]:\n var_3 += 1\n else:\n pass\n var_9[var_13].append(var_3)\n if var_3 >= var_7:\n var_7 = var_3\n var_3 += 1\nprint(var_7)\nfor var_4 in var_5:\n print((var_9[var_4[1]][0]))\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\nfrom collections import deque\n\nvar_13 = sys.stdin.readline\nvar_2 = int(eval(var_13()))\nvar_5 = [deque() for _ in range(var_2)]\nvar_3 = [-1] * var_2\nfor var_12 in range(var_2 - 1):\n var_6, var_8 = list(map(int, var_13().split()))\n var_5[var_6 - 1].append((var_12, var_8 - 1))\n\n\nvar_4 = deque([(0, -1)])\nvar_1 = [-1] * (var_2 - 1)\nvar_11 = 0\nwhile var_4:\n var_14, var_10 = var_4.pop()\n var_9 = 1\n for var_12, var_15 in var_5[var_14]:\n if var_9 == var_10:\n var_9 += 1\n var_1[var_12] = var_9\n var_4.appendleft((var_15, var_9))\n var_9 += 1\n var_11 = max(var_11, var_9 - 1)\nprint(var_11)\nfor var_7 in var_1:\n print(var_7)\n```", "output": "FASTER 4.6519", "pair_id": "python_p02850_forward", "problem_id": "p02850", "language": "python", "direction": "forward", "speedup_ratio": 25.1403} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\ndef func_1():\n var_1, var_2 = list(map(int, input().split()))\n var_3 = 0\n for var_4 in range(var_1, var_2 + 1):\n\n if (var_4 % 10) == (var_4 // 10000 % 10) and (var_4 // 10 % 10) == (\n var_4 // 1000 % 10\n ):\n var_3 += 1\n print(var_3)\n\n\nif __name__ == \"__main__\":\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_6 = str(var_4)\n var_5 = var_6[::-1]\n if var_6 == var_5:\n var_3 += 1\nprint(var_3)\n```", "output": "SLOWER 1.9144", "pair_id": "python_p03416_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 3.7697} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_8 in range(var_1, var_2 + 1):\n var_7 = str(var_8)\n var_6 = len(var_7)\n var_4 = True\n for var_5 in range(var_6 // 2):\n if var_7[var_5] != var_7[var_6 - 1 - var_5]:\n var_4 = False\n break\n if var_4:\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = str(var_4)\n if var_5[0] == var_5[4] and var_5[1] == var_5[3]:\n var_3 += 1\nprint(var_3)\n```", "output": "FASTER 1.3924", "pair_id": "python_p03416_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 2.6251} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport numpy as np\nfrom bisect import bisect_left\n\n\ndef func_1():\n var_4 = []\n var_1 = np.ones(10**5 + 10)\n var_1[0] = var_1[1] = 0\n for var_3, var_2 in enumerate(var_1):\n if var_2:\n var_4.append(var_3)\n var_1[2 * var_3 : 10**5 + 10 : var_3] = 0\n return var_4\n\n\ndef func_2(var_6):\n var_7 = int(var_6)\n var_5 = func_1()\n return str(var_5[bisect_left(var_5, var_7)])\n\n\nif __name__ == \"__main__\":\n import sys\n\n print((func_2(sys.stdin.read().strip())))\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\n\n\ndef func_1():\n return sys.stdin.readline()[:-1]\n\n\nvar_3 = int(eval(func_1()))\nwhile 1:\n var_1 = 0\n for var_2 in range(2, int(var_3 ** (1 / 2))):\n if var_3 % var_2 == 0:\n var_1 = 1\n break\n if var_1 == 0:\n break\n var_3 += 1\nprint(var_3)\n```", "output": "FASTER 7.7323", "pair_id": "python_p02819_forward", "problem_id": "p02819", "language": "python", "direction": "forward", "speedup_ratio": 212.6457} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_6, var_5 = list(map(int, input().split()))\nvar_8 = [[] for _ in range(var_6)]\nfor var_2 in range(var_5):\n var_10, var_11 = input().split()\n var_8[int(var_10) - 1].append(var_11)\n\nvar_1, var_7 = 0, 0\nfor var_3 in range(var_6):\n var_9 = var_8[var_3]\n if \"AC\" in var_9:\n var_1 += 1\n for var_4 in var_9:\n if var_4 == \"WA\":\n var_7 += 1\n else:\n break\nprint((var_1, var_7))\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\n\nvar_2, var_1, *var_3 = sys.stdin.read().strip().split()\nvar_2 = int(var_2)\nvar_5 = [0] * var_2\nvar_10 = [0] * var_2\nfor var_6, var_8 in zip(*[iter(var_3)] * 2):\n var_6 = int(var_6) - 1\n if var_8 == \"AC\":\n var_5[var_6] = 1\n elif var_5[var_6] == 0:\n var_10[var_6] += 1\nvar_7 = sum([var_9 * var_4 for var_4, var_9 in zip(var_5, var_10)])\nprint((\"{} {}\".format(sum(var_5), var_7)))\n```", "output": "FASTER 1.7771", "pair_id": "python_p02802_forward", "problem_id": "p02802", "language": "python", "direction": "forward", "speedup_ratio": 3.4274} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_4 = str(var_4)\n if var_4 == var_4[::-1]:\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\n\n\ndef func_1(var_5):\n var_4 = 0\n for var_3 in range(1, var_5 + 1):\n if str(var_3) == str(var_3)[::-1]:\n var_4 += 1\n return var_4\n\n\nprint((func_1(var_2) - func_1(var_1 - 1)))\n```", "output": "SLOWER 1.4436", "pair_id": "python_p03416_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 2.72} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\nfrom collections import Counter\n\n\ndef func_9():\n return sys.stdin.readline().strip()\n\n\ndef func_10(var_8, var_9, var_10):\n return [[var_10] * var_9 for var_13 in range(var_8)]\n\n\ndef func_11(var_8, var_9, var_10, var_11):\n return [[[var_11] * var_10 for var_14 in range(var_9)] for var_13 in range(var_8)]\n\n\ndef func_12(var_8, var_9, var_10, var_11, var_12):\n return [\n [[[var_12] * var_11 for var_14 in range(var_10)] for var_14 in range(var_9)]\n for var_13 in range(var_8)\n ]\n\n\ndef func_8(var_16, var_17=1):\n return int(-(-var_16 // var_17))\n\n\ndef func_1():\n return int(eval(func_9()))\n\n\ndef func_3():\n return list(map(int, func_9().split()))\n\n\ndef func_2(var_7=None):\n return list(func_3()) if var_7 is None else [func_1() for var_13 in range(var_7)]\n\n\ndef func_7():\n print(\"Yes\")\n\n\ndef func_5():\n print(\"No\")\n\n\ndef func_6():\n print(\"YES\")\n\n\ndef func_4():\n print(\"NO\")\n\n\nsys.setrecursionlimit(10**9)\nvar_3 = 10**18\nvar_6 = 10**9 + 7\nvar_7, var_5, var_4 = func_3()\nvar_1 = func_2()\nvar_2 = func_2()\nvar_15 = min(var_1) + min(var_2)\nfor _ in range(var_4):\n var_16, var_17, var_10 = func_3()\n var_16 -= 1\n var_17 -= 1\n var_15 = min(var_15, var_1[var_16] + var_2[var_17] - var_10)\nprint(var_15)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2, var_3 = list(map(int, input().split()))\nvar_4 = list(map(int, input().split()))\nvar_6 = list(map(int, input().split()))\nvar_5 = min(var_4) + min(var_6)\nfor var_8 in range(var_3):\n var_7 = list(map(int, input().split()))\n var_9 = var_4[var_7[0] - 1] + var_6[var_7[1] - 1] - var_7[2]\n var_5 = min(var_9, var_5)\nprint(var_5)\n```", "output": "FASTER 1.7949", "pair_id": "python_p02748_forward", "problem_id": "p02748", "language": "python", "direction": "forward", "speedup_ratio": 3.47} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\nimport itertools\n\n\ndef func_2(var_4):\n return bin(eval(\"0b\" + str(var_4)))\n\n\ndef func_1():\n var_4 = int(sys.stdin.readline().rstrip())\n var_9 = [\n func_2(\"\".join(str(var_10) for var_10 in sys.stdin.readline().split()))\n for _ in range(var_4)\n ]\n var_8 = [\n [int(var_10) for var_10 in sys.stdin.readline().split()] for _ in range(var_4)\n ]\n var_3 = -(10**10)\n for var_6 in itertools.product(\"01\", repeat=10):\n var_6 = func_2(\"\".join(var_6))\n if var_6 == \"0b0\":\n continue\n var_7 = 0\n for var_2 in range(var_4):\n var_1 = var_9[var_2]\n var_5 = bin(eval(var_1) & eval(var_6)).count(\"1\")\n var_7 += var_8[var_2][var_5]\n var_3 = max(var_3, var_7)\n print(var_3)\n\n\nif __name__ == \"__main__\":\n\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\nimport numpy as np\n\nvar_5 = sys.stdin.readline\n\nvar_7 = int(eval(var_5()))\n\nvar_1 = [var_5().replace(\" \", \"\") for var_4 in range(var_7)]\n\nvar_8 = [list(map(int, var_5().split())) for var_4 in range(var_7)]\n\n\nvar_12 = -999999999999999\n\nfor var_4 in range(1, 1024):\n\n var_3 = format(var_4, \"010b\")\n\n var_10 = 0\n for var_2, var_9 in zip(var_1, var_8):\n\n var_11 = 0\n for var_6 in range(10):\n\n if var_2[var_6] == \"1\" and var_3[var_6] == \"1\":\n\n var_11 += 1\n\n var_10 += var_9[var_11]\n if var_10 > var_12:\n\n var_12 = var_10\nprint(var_12)\n```", "output": "FASTER 2.5695", "pair_id": "python_p03503_forward", "problem_id": "p03503", "language": "python", "direction": "forward", "speedup_ratio": 5.9361} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport copy\n\nvar_8 = int(eval(input()))\nvar_10 = set([var_6 for var_6 in range(1, 10**5)])\nvar_5 = []\nvar_11 = {}\nvar_9 = []\nfor var_6 in range(var_8 - 1):\n var_1, var_2 = list(map(int, input().split(\" \")))\n var_5.append([var_1, var_2])\n var_11.setdefault(var_1, []).append(var_2)\n var_9.append([])\nvar_9.append([])\nvar_9.append([])\nvar_7 = 0\nfor var_12 in range(1, var_8 + 1):\n var_14 = var_11.get(var_12, [])\n var_3 = 1\n for var_13 in var_14:\n if var_3 in var_9[var_12]:\n var_3 += 1\n else:\n pass\n var_9[var_13].append(var_3)\n if var_3 >= var_7:\n var_7 = var_3\n var_3 += 1\nprint(var_7)\nfor var_4 in var_5:\n print((var_9[var_4[1]][0]))\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\nfrom collections import deque\n\nvar_13 = sys.stdin.readline\nvar_2 = int(eval(var_13()))\nvar_5 = [[] for _ in range(var_2)]\nvar_3 = [-1] * var_2\nfor var_12 in range(var_2 - 1):\n var_6, var_8 = list(map(int, var_13().split()))\n var_5[var_6 - 1].append((var_12, var_8 - 1))\n\n\nvar_4 = deque([(0, -1)])\nvar_1 = [-1] * (var_2 - 1)\nvar_11 = 0\nwhile var_4:\n var_14, var_10 = var_4.pop()\n var_9 = 1\n for var_12, var_15 in var_5[var_14]:\n if var_9 == var_10:\n var_9 += 1\n var_1[var_12] = var_9\n var_4.appendleft((var_15, var_9))\n var_9 += 1\n var_11 = max(var_11, var_9 - 1)\nprint(var_11)\nfor var_7 in var_1:\n print(var_7)\n```", "output": "FASTER 4.6753", "pair_id": "python_p02850_forward", "problem_id": "p02850", "language": "python", "direction": "forward", "speedup_ratio": 25.551} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\n\nsys.setrecursionlimit(2147483647)\nvar_2 = float(\"inf\")\nvar_3 = 10**9 + 7\nvar_10 = lambda: sys.stdin.readline().rstrip()\n\n\ndef func_1():\n var_11, var_4 = list(map(int, var_10().split()))\n var_1 = [tuple(map(int, var_10().split())) for _ in range(var_11)]\n var_1.sort()\n var_8 = [0] * var_4\n var_6 = -var_2\n for var_9 in range(var_11):\n var_5, var_7 = var_1[var_9]\n var_12 = var_8[:]\n for var_13 in range(var_4):\n if var_13 + var_5 < var_4:\n var_12[var_13 + var_5] = max(\n var_12[var_13 + var_5], var_8[var_13] + var_7\n )\n else:\n var_6 = max(var_6, var_8[var_13] + var_7)\n var_8 = var_12\n print((max(var_6, max(var_8))))\n\n\nfunc_1()\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\nfrom operator import itemgetter\nfrom heapq import heapify, heappop, heappush\n\nvar_1 = int(10e15)\nvar_2 = -var_1\nvar_11 = 1000000007\nsys.setrecursionlimit(1000000)\n\n\ndef func_2():\n return list(map(int, input().split()))\n\n\ndef func_4():\n return input().split()\n\n\ndef func_1():\n return int(sys.stdin.readline())\n\n\ndef func_3():\n return eval(input())\n\n\nvar_3, var_4 = func_2()\nvar_5 = [func_2() for var_9 in range(var_3)]\nvar_5.sort(key=itemgetter(0))\n\nvar_8 = [[0] * (var_4 + 1 + 3000 + 1) for _ in range(var_3 + 1)]\nvar_6 = 0\nfor var_9 in range(var_3):\n for var_10 in range(var_4 + 1 + 3000 + 1):\n var_12, var_7 = var_5[var_9]\n if 0 <= var_10 - var_12 < var_4:\n var_8[var_9 + 1][var_10] = max(\n var_8[var_9][var_10], var_8[var_9][var_10 - var_12] + var_7\n )\n else:\n var_8[var_9 + 1][var_10] = var_8[var_9][var_10]\n var_6 = max(var_6, var_8[var_9 + 1][var_10])\nprint(var_6)\n```", "output": "SLOWER 5.855", "pair_id": "python_p02863_reversed", "problem_id": "p02863", "language": "python", "direction": "reversed", "speedup_ratio": 57.8788} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_5 in range(10):\n for var_6 in range(10):\n for var_7 in range(10):\n var_3 = 10000 * var_5 + 1000 * var_6 + 100 * var_7 + 10 * var_6 + var_5\n if var_1 <= var_3 <= var_2:\n var_4 += 1\nprint(var_4)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().strip().split(\" \")))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n if str(var_4) == str(var_4)[::-1]:\n var_3 += 1\nprint(var_3)\n```", "output": "SLOWER 4.1328", "pair_id": "python_p03416_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 17.5431} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_4 = {}\nvar_5 = 0\nfor var_6 in range(10000, 100000):\n var_3 = list(str(var_6))\n if var_3 == list(reversed(var_3)):\n var_5 += 1\n var_4[var_6] = var_5\nvar_1, var_2 = list(map(int, input().split()))\nprint((var_4[var_2] - var_4[var_1 - 1] if var_1 > 10000 else var_4[var_2]))\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_5 in range(10):\n for var_6 in range(10):\n for var_7 in range(10):\n var_3 = 10000 * var_5 + 1000 * var_6 + 100 * var_7 + 10 * var_6 + var_5\n if var_1 <= var_3 <= var_2:\n var_4 += 1\nprint(var_4)\n```", "output": "FASTER 7.3992", "pair_id": "python_p03416_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 168.7989} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\n\n\ndef func_1():\n return sys.stdin.readline()[:-1]\n\n\nvar_3 = int(eval(func_1()))\nwhile 1:\n var_1 = 0\n for var_2 in range(2, int(var_3 ** (1 / 2))):\n if var_3 % var_2 == 0:\n var_1 = 1\n break\n if var_1 == 0:\n break\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nimport bisect, copy, heapq, math, sys\nfrom collections import *\nfrom functools import lru_cache\nfrom itertools import accumulate, combinations, permutations, product\n\n\ndef func_2():\n return sys.stdin.readline()[:-1]\n\n\ndef func_4(var_8):\n return [0] + list(accumulate(var_8))\n\n\ndef func_1(var_1, var_4):\n return -(-var_1 // var_4)\n\n\nsys.setrecursionlimit(5000000)\nvar_9 = pow(10, 9) + 7\nvar_2 = [chr(ord(\"a\") + var_6) for var_6 in range(26)]\nvar_5 = [[1, 0], [0, 1], [-1, 0], [0, -1]]\nvar_11 = int(eval(func_2()))\n\n\ndef func_3(var_10):\n if var_10 == 1:\n return False\n for var_7 in range(2, int(math.sqrt(var_10)) + 1):\n if var_10 % var_7 == 0:\n return False\n return True\n\n\nvar_3 = var_11\nwhile not func_3(var_3):\n var_3 += 1\nprint(var_3)\n```", "output": "SLOWER 1.4121", "pair_id": "python_p02819_reversed", "problem_id": "p02819", "language": "python", "direction": "reversed", "speedup_ratio": 2.6613} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_5 in range(10):\n for var_6 in range(10):\n for var_7 in range(10):\n var_3 = 10000 * var_5 + 1000 * var_6 + 100 * var_7 + 10 * var_6 + var_5\n if var_1 <= var_3 <= var_2:\n var_4 += 1\nprint(var_4)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_6 in range(var_1, var_2 + 1):\n var_3 = str(var_6)\n var_5 = True\n for var_7 in range(len(var_3) // 2):\n if var_3[var_7] != var_3[-var_7 - 1] and var_5:\n var_5 = not var_5\n if var_5:\n var_4 += 1\nprint(var_4)\n```", "output": "SLOWER 5.2855", "pair_id": "python_p03416_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 39.0027} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\n\n\ndef func_1(var_5):\n var_4 = 0\n for var_3 in range(1, var_5 + 1):\n if str(var_3) == str(var_3)[::-1]:\n var_4 += 1\n return var_4\n\n\nprint((func_1(var_2) - func_1(var_1 - 1)))\n```\n\n=== Code B (Modified) ===\n```python\nvar_1 = list(map(int, input().split()))\nvar_2 = 0\nfor var_3 in range(var_1[0], var_1[1] + 1):\n var_4 = str(var_3)\n if var_4[0] == var_4[4] and var_4[1] == var_4[3]:\n var_2 += 1\nprint(var_2)\n```", "output": "FASTER 1.8794", "pair_id": "python_p03416_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 3.6793} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = [0] * (var_2 + 1)\nfor var_3 in range(1, var_2 + 1):\n if str(var_3) == str(var_3)[::-1]:\n var_4[var_3] = var_4[var_3 - 1] + 1\n else:\n var_4[var_3] = var_4[var_3 - 1]\nprint((var_4[var_2] - var_4[var_1 - 1]))\n```\n\n=== Code B (Modified) ===\n```python\nvar_4 = {}\nvar_5 = 0\nfor var_6 in range(10000, 100000):\n var_3 = list(str(var_6))\n if var_3 == list(reversed(var_3)):\n var_5 += 1\n var_4[var_6] = var_5\nvar_1, var_2 = list(map(int, input().split()))\nprint((var_4[var_2] - var_4[var_1 - 1] if var_1 > 10000 else var_4[var_2]))\n```", "output": "SLOWER 1.6313", "pair_id": "python_p03416_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 3.098} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\n\n\ndef func_1(var_5):\n var_4 = 0\n for var_3 in range(1, var_5 + 1):\n if str(var_3) == str(var_3)[::-1]:\n var_4 += 1\n return var_4\n\n\nprint((func_1(var_2) - func_1(var_1 - 1)))\n```\n\n=== Code B (Modified) ===\n```python\nvar_4 = {}\nvar_5 = 0\nfor var_6 in range(10000, 100000):\n var_3 = list(str(var_6))\n if var_3 == list(reversed(var_3)):\n var_5 += 1\n var_4[var_6] = var_5\nvar_1, var_2 = list(map(int, input().split()))\nprint((var_4[var_2] - var_4[var_1 - 1] if var_1 > 10000 else var_4[var_2]))\n```", "output": "SLOWER 1.983", "pair_id": "python_p03416_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 3.9531} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\ndef func_1():\n from sys import setrecursionlimit, stdin\n from os import environ\n from collections import defaultdict, deque, Counter\n from math import ceil, floor, gcd\n from itertools import accumulate, combinations, combinations_with_replacement\n\n setrecursionlimit(10**6)\n var_7 = (\n (lambda *var_11: print(*var_11))\n if \"TERM_PROGRAM\" in environ\n else lambda *var_12: 0\n )\n var_8 = lambda: stdin.readline().rstrip()\n var_3 = lambda: list(map(int, var_8().split()))\n var_1 = lambda: int(var_8())\n var_4 = 10**9 + 7\n var_2 = 10**9 + 10\n var_9, var_10 = var_8().split()\n var_5 = int(var_9)\n var_10 = var_10.split(\".\")\n var_6 = int(var_10[0]) * 100\n if len(var_10) == 2:\n var_6 += int(var_10[1])\n print(var_5 * var_6 // 100)\n\n\nfunc_1()\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(str, input().split()))\nvar_1 = int(var_1)\nvar_2 = int(float(var_2) * 1000)\nprint((var_1 * var_2 // 1000))\n```", "output": "FASTER 2.1723", "pair_id": "python_p02659_forward", "problem_id": "p02659", "language": "python", "direction": "forward", "speedup_ratio": 4.5074} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_7, var_6 = list(map(int, input().split()))\nvar_5 = [tuple(input().split()) for _ in range(var_6)]\nvar_9 = [[] for _ in range(var_7)]\nfor var_2 in range(var_6):\n var_9[int(var_5[var_2][0]) - 1].append(var_5[var_2][1])\nvar_1, var_8 = 0, 0\nfor var_3 in range(var_7):\n if \"AC\" in var_9[var_3]:\n var_1 += 1\n for var_4 in range(len(var_9[var_3])):\n if var_9[var_3][var_4] == \"WA\":\n var_8 += 1\n else:\n break\nprint((var_1, var_8))\n```\n\n=== Code B (Modified) ===\n```python\nvar_2, var_1 = list(map(int, input().split()))\nvar_6 = {}\nvar_3 = {}\nfor var_4 in range(var_1):\n var_5, var_7 = input().split()\n var_5 = int(var_5)\n if not var_5 in var_6:\n var_6[var_5] = 0\n var_3[var_5] = 0\n if var_7 == \"WA\" and var_3[var_5] == 0:\n var_6[var_5] += 1\n elif var_7 == \"AC\" and var_3[var_5] == 0:\n var_3[var_5] += 1\nfor var_4 in var_6:\n if var_6[var_4] != 0 and var_3[var_4] == 0:\n var_6[var_4] = 0\nprint((sum(var_3.values()), sum(var_6.values())))\n```", "output": "FASTER 4.1714", "pair_id": "python_p02802_forward", "problem_id": "p02802", "language": "python", "direction": "forward", "speedup_ratio": 18.0189} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\n\n\nclass Class_1:\n \"\"\"\"\"\"\n\n def __init__(self, var_1):\n self.__n = len(var_1)\n self.__node = [0] * (self.__n + 1)\n self.__data = [0] * (self.__n + 1)\n var_7 = [0] * (self.__n + 1)\n for var_11 in range(self.__n):\n var_7[var_11 + 1] = var_7[var_11] + var_1[var_11]\n for var_11 in range(1, self.__n + 1):\n self.__data[var_11] = var_1[var_11 - 1]\n self.__node[var_11] = var_7[var_11] - var_7[var_11 - (var_11 & -var_11)]\n\n def func_1(self, var_11, var_22):\n self.__data[var_11] += var_22\n while var_11 <= self.__n:\n self.__node[var_11] += var_22\n var_11 += var_11 & -var_11\n\n def func_4(self, var_11):\n \"\"\"\"\"\"\n var_19 = 0\n while var_11 > 0:\n var_19 += self.__node[var_11]\n var_11 -= var_11 & -var_11\n return var_19\n\n def func_2(self, var_11, var_12):\n \"\"\"\"\"\"\n if var_11 == var_12:\n return self.__data[var_11]\n else:\n return self.sum(var_12) - self.sum(var_11 - 1)\n\n\ndef func_3():\n var_4, var_6 = map(int, input().split())\n var_3 = list(map(int, input().split()))\n var_5 = [[] for _ in range(var_4)]\n for var_11, var_9 in enumerate(var_3):\n var_5[var_9 - 1].append(var_11)\n var_18 = [0] * var_4\n for var_14 in var_5:\n if len(var_14):\n var_18[var_14.pop()] = 1\n var_2 = Class_1(var_18)\n var_16 = [[] for _ in range(var_4)]\n for var_11, var_20 in enumerate(sys.stdin.readlines()):\n var_13, var_17 = map(int, var_20.split())\n var_16[var_17 - 1].append((var_13 - 1, var_11))\n var_8 = [None] * var_6\n var_10 = var_4 - 1\n for var_17, var_15 in enumerate(reversed(var_16)):\n var_17 = (var_4 - 1) - var_17\n while var_15:\n var_13, var_11 = var_15.pop()\n while var_17 < var_10:\n var_9 = var_3[var_10] - 1\n var_14 = var_5[var_9]\n if len(var_14):\n var_2.add(var_14.pop() + 1, 1)\n var_10 -= 1\n var_21 = var_2.get(var_13 + 1, var_17 + 1)\n var_8[var_11] = var_21\n print(*var_8, sep=\"\\n\")\n\n\nif __name__ == \"__main__\":\n func_3()\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\n\nvar_20 = sys.stdin.read\nvar_21 = sys.stdin.readline\nvar_22 = sys.stdin.readlines\nsys.setrecursionlimit(10**9)\nvar_2 = 1 << 60\nvar_5 = 1000000007\n\n\nvar_4 = 1000001\n\n\nclass Class_1:\n def __init__(self, var_13, var_19, var_12):\n self.l = var_13\n self.r = var_19\n self.idx = var_12\n\n\ndef func_4(var_12, var_24, var_10, var_15):\n while var_12 <= var_15:\n var_10[var_12] += var_24\n var_12 += var_12 & -var_12\n\n\ndef func_3(var_12, var_10, var_15):\n var_23 = 0\n while var_12:\n var_23 += var_10[var_12]\n var_12 -= var_12 & -var_12\n return var_23\n\n\ndef func_1(var_9, var_15, var_17, var_16):\n\n var_10 = [0] * (var_15 + 1)\n\n var_14 = [-1] * var_4\n\n var_8 = [0] * var_16\n var_18 = 0\n for var_11 in range(var_15):\n\n if var_14[var_9[var_11]] != -1:\n func_4(var_14[var_9[var_11]] + 1, -1, var_10, var_15)\n\n var_14[var_9[var_11]] = var_11\n func_4(var_11 + 1, 1, var_10, var_15)\n\n while var_18 < var_16 and var_17[var_18].r == var_11:\n var_8[var_17[var_18].idx] = func_3(\n var_17[var_18].r + 1, var_10, var_15\n ) - func_3(var_17[var_18].l, var_10, var_15)\n var_18 += 1\n\n for var_11 in range(var_16):\n print((var_8[var_11]))\n\n\ndef func_2():\n var_6, var_7 = list(map(int, var_21().split()))\n var_1 = list(map(int, var_21().split()))\n (*var_3,) = list(map(int, var_20().split()))\n var_17 = [0] * var_7\n for var_11, (var_13, var_19) in enumerate(zip(*[iter(var_3)] * 2)):\n var_17[var_11] = Class_1(var_13 - 1, var_19 - 1, var_11)\n var_17.sort(key=lambda var_25: var_25.r)\n func_1(var_1, var_6, var_17, var_7)\n return\n\n\nif __name__ == \"__main__\":\n func_2()\n```", "output": "SLOWER 1.7958", "pair_id": "python_p02599_reversed", "problem_id": "p02599", "language": "python", "direction": "reversed", "speedup_ratio": 3.472} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport math\nimport string\n\n\ndef func_4():\n return list(map(int, input().split()))\n\n\ndef func_3(var_6, var_7):\n return math.factorial(var_6) // (\n math.factorial(var_6 - var_7) * math.factorial(var_7)\n )\n\n\ndef func_2(var_9):\n var_8 = []\n for var_5 in var_9:\n if not (var_5 in var_8):\n var_8.append(var_5)\n return len(var_9) != len(var_8)\n\n\ndef func_1(var_6):\n func_1 = []\n for var_4 in range(1, var_6 + 1):\n if var_6 % var_4 == 0:\n func_1.append(var_4)\n return func_1\n\n\nvar_2 = [-1, -1, -1, 0, 0, 1, 1, 1]\nvar_3 = [-1, 0, 1, -1, 1, -1, 0, 1]\nvar_6 = int(eval(input()))\nvar_1 = func_4()\nvar_10 = 1\nfor var_4 in range(len(var_1)):\n if var_1[var_4] % 2 == 0:\n var_10 *= 2\n else:\n var_10 *= 1\nprint((3 ** len(var_1) - var_10))\n```\n\n=== Code B (Modified) ===\n```python\nvar_4 = int(eval(input()))\nvar_1 = list(map(int, input().split()))\nvar_3 = 1\nfor var_2 in var_1:\n var_3 *= 2 if var_2 % 2 == 0 else 1\nprint((3**var_4 - var_3))\n```", "output": "FASTER 1.8134", "pair_id": "python_p03568_forward", "problem_id": "p03568", "language": "python", "direction": "forward", "speedup_ratio": 3.5147} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nfrom collections import Counter, defaultdict, deque\nfrom heapq import heappop, heappush, heapify\nimport sys, bisect, math, itertools, fractions, pprint\n\nsys.setrecursionlimit(10**8)\nvar_6 = 10**9 + 7\nvar_1 = float(\"inf\")\n\n\ndef func_1():\n return int(sys.stdin.readline())\n\n\ndef func_2():\n return list(map(int, sys.stdin.readline().split()))\n\n\nvar_7, var_9 = func_2()\nvar_13 = [func_2() for _ in range(var_7)]\nvar_13.sort(key=lambda var_14: var_14[1], reverse=True)\nvar_8 = 0\nvar_10 = min(var_7, 5)\nfor var_3 in range(var_10):\n var_2 = [[0] * (var_9 + 5) for _ in range(var_7 + 5)]\n for var_4 in range(var_7):\n var_12, var_11 = var_13[var_4]\n for var_5 in range(var_9):\n if var_5 < var_12 or var_3 == var_4:\n var_2[var_4 + 1][var_5] = var_2[var_4][var_5]\n else:\n var_2[var_4 + 1][var_5] = max(\n var_2[var_4][var_5], var_2[var_4][var_5 - var_12] + var_11\n )\n\n var_8 = max(var_2[var_7][var_9 - 1] + var_13[var_3][1], var_8)\nprint(var_8)\n```\n\n=== Code B (Modified) ===\n```python\nfrom sys import stdin\n\n\ndef func_1():\n\n var_9 = stdin.readline\n var_8, var_10 = list(map(int, var_9().split()))\n var_7 = [list(map(int, var_9().split())) for _ in range(var_8)]\n var_7.sort()\n var_1 = [0] * var_8\n var_2 = [0] * var_8\n for var_4 in range(var_8):\n var_1[var_4], var_2[var_4] = var_7[var_4][0], var_7[var_4][1]\n\n var_5 = -float(\"inf\")\n var_3 = [[var_5] * (var_10 + 1) for _ in range(var_8 + 1)]\n var_3[0][0] = 0\n for var_4 in range(var_8):\n for var_6 in range(var_10 + 1):\n\n if var_6 != var_10:\n var_3[var_4 + 1][min(var_10, var_6 + var_1[var_4])] = max(\n var_3[var_4 + 1][min(var_10, var_6 + var_1[var_4])],\n var_3[var_4][var_6] + var_2[var_4],\n )\n\n var_3[var_4 + 1][var_6] = max(var_3[var_4 + 1][var_6], var_3[var_4][var_6])\n print((max(var_3[var_8])))\n\n\nif __name__ == \"__main__\":\n func_1()\n```", "output": "FASTER 1.7184", "pair_id": "python_p02863_forward", "problem_id": "p02863", "language": "python", "direction": "forward", "speedup_ratio": 3.2907} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\n\nvar_8 = sys.stdin.readline\n\n\ndef func_1():\n var_2 = int(eval(var_8()))\n var_1 = [int(var_8().replace(\" \", \"\"), 2) for _ in range(var_2)]\n var_3 = [list(map(int, var_8().split())) for _ in range(var_2)]\n var_4 = -(10**7) * var_2\n for var_7 in range(1, 1 << 10):\n var_10 = 0\n for var_9, var_6 in enumerate(var_1):\n var_5 = bin(var_7 & var_6).count(\"1\")\n var_10 += var_3[var_9][var_5]\n var_4 = max(var_4, var_10)\n print(var_4)\n\n\nif __name__ == \"__main__\":\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\nimport numpy as np\n\nvar_5 = sys.stdin.readline\n\nvar_7 = int(eval(var_5()))\n\nvar_1 = [var_5().replace(\" \", \"\") for var_4 in range(var_7)]\n\nvar_8 = [list(map(int, var_5().split())) for var_4 in range(var_7)]\n\n\nvar_12 = -999999999999999\n\nfor var_4 in range(1, 1024):\n\n var_3 = format(var_4, \"010b\")\n\n var_10 = 0\n for var_2, var_9 in zip(var_1, var_8):\n\n var_11 = 0\n for var_6 in range(10):\n\n if var_2[var_6] == \"1\" and var_3[var_6] == \"1\":\n\n var_11 += 1\n\n var_10 += var_9[var_11]\n if var_10 > var_12:\n\n var_12 = var_10\nprint(var_12)\n```", "output": "SLOWER 2.7422", "pair_id": "python_p03503_reversed", "problem_id": "p03503", "language": "python", "direction": "reversed", "speedup_ratio": 6.6909} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\nimport itertools\n\n\ndef func_2(var_4):\n return bin(eval(\"0b\" + str(var_4)))\n\n\ndef func_1():\n var_4 = int(sys.stdin.readline().rstrip())\n var_9 = [\n func_2(\"\".join(str(var_10) for var_10 in sys.stdin.readline().split()))\n for _ in range(var_4)\n ]\n var_8 = [\n [int(var_10) for var_10 in sys.stdin.readline().split()] for _ in range(var_4)\n ]\n var_3 = -(10**10)\n for var_6 in itertools.product(\"01\", repeat=10):\n var_6 = func_2(\"\".join(var_6))\n if var_6 == \"0b0\":\n continue\n var_7 = 0\n for var_2 in range(var_4):\n var_1 = var_9[var_2]\n var_5 = bin(eval(var_1) & eval(var_6)).count(\"1\")\n var_7 += var_8[var_2][var_5]\n var_3 = max(var_3, var_7)\n print(var_3)\n\n\nif __name__ == \"__main__\":\n\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nvar_8 = int(eval(input()))\nvar_4 = []\nfor var_5 in range(var_8):\n var_11 = 0\n var_9 = list(map(int, input().split()))\n for var_6 in range(10):\n var_11 += var_9[var_6] << var_6\n var_4.append(var_11)\nvar_10 = []\nfor var_5 in range(var_8):\n var_10.append(list(map(int, input().split())))\nvar_1 = -(10**12)\nfor var_5 in range(1, 1 << 10):\n var_11 = 0\n for var_6 in range(var_8):\n var_3 = var_4[var_6] & var_5\n var_2 = 0\n for var_7 in range(10):\n if (var_3 >> var_7) % 2:\n var_2 += 1\n var_11 += var_10[var_6][var_2]\n var_1 = max(var_1, var_11)\nprint(var_1)\n```", "output": "FASTER 2.7368", "pair_id": "python_p03503_forward", "problem_id": "p03503", "language": "python", "direction": "forward", "speedup_ratio": 6.6658} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\ndef func_1():\n var_2, var_3, *var_1 = list(map(int, open(0).read().split()))\n var_4 = [0] * (var_3 + max(var_1[::2]))\n for var_7, var_6 in sorted(zip(*[iter(var_1)] * 2)):\n for var_5 in reversed(list(range(var_3))):\n var_4[var_5 + var_7] = max(var_4[var_5 + var_7], var_4[var_5] + var_6)\n print((max(var_4)))\n\n\nfunc_1()\n```\n\n=== Code B (Modified) ===\n```python\nimport bisect\nimport sys\n\nsys.setrecursionlimit(10**6)\nvar_17 = sys.stdout.write\nvar_7 = lambda *var_15: print(*var_15) if var_1 else 0\nvar_1 = True\n\n\ndef func_1(var_10=sys.stdin.readline):\n var_12 = lambda: var_10().rstrip()\n var_3 = lambda: list(map(int, var_12().split()))\n var_2 = lambda: int(var_12())\n var_4 = lambda var_18: [var_3() for _ in range(var_18)]\n var_14, var_16 = var_3()\n var_5 = var_4(var_14)\n var_8 = [[0] * var_16 for _ in range(var_14)]\n for var_11 in range(1, var_14):\n for var_13 in range(1, var_16):\n if var_13 < var_5[var_11 - 1][0]:\n var_8[var_11][var_13] = var_8[var_11 - 1][var_13]\n else:\n var_8[var_11][var_13] = max(\n var_8[var_11 - 1][var_13],\n var_8[var_11 - 1][var_13 - var_5[var_11 - 1][0]]\n + var_5[var_11 - 1][1],\n )\n var_9 = [[0] * var_16 for _ in range(var_14)]\n for var_11 in range(1, var_14):\n for var_13 in range(1, var_16):\n if var_13 < var_5[var_14 - var_11][0]:\n var_9[var_11][var_13] = var_9[var_11 - 1][var_13]\n else:\n var_9[var_11][var_13] = max(\n var_9[var_11 - 1][var_13],\n var_9[var_11 - 1][var_13 - var_5[var_14 - var_11][0]]\n + var_5[var_14 - var_11][1],\n )\n var_6 = 0\n for var_11 in range(var_14):\n for var_13 in range(var_16 - 1):\n var_6 = max(\n var_6,\n var_8[var_11][var_13]\n + var_9[var_14 - var_11 - 1][var_16 - var_13 - 1]\n + var_5[var_11][1],\n )\n print(var_6)\n\n\nif __name__ == \"__main__\":\n func_1()\n```", "output": "SLOWER 1.7019", "pair_id": "python_p02863_reversed", "problem_id": "p02863", "language": "python", "direction": "reversed", "speedup_ratio": 3.2534} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_4 = {}\nvar_5 = 0\nfor var_6 in range(10000, 100000):\n var_3 = list(str(var_6))\n if var_3 == list(reversed(var_3)):\n var_5 += 1\n var_4[var_6] = var_5\nvar_1, var_2 = list(map(int, input().split()))\nprint((var_4[var_2] - var_4[var_1 - 1] if var_1 > 10000 else var_4[var_2]))\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_3 in range(var_1, var_2 + 1):\n var_5 = list(str(var_3))\n var_6 = list(reversed(var_5))\n if var_5 == var_6:\n var_4 += 1\nprint(var_4)\n```", "output": "FASTER 2.265", "pair_id": "python_p03416_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 4.8064} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_3 in range(var_1, var_2 + 1):\n var_5 = list(str(var_3))\n var_6 = list(reversed(var_5))\n if var_5 == var_6:\n var_4 += 1\nprint(var_4)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_5 in range(10):\n for var_6 in range(10):\n for var_7 in range(10):\n var_3 = 10000 * var_5 + 1000 * var_6 + 100 * var_7 + 10 * var_6 + var_5\n if var_1 <= var_3 <= var_2:\n var_4 += 1\nprint(var_4)\n```", "output": "FASTER 5.1342", "pair_id": "python_p03416_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 35.1196} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nfrom functools import reduce\nfrom itertools import product\n\nvar_2 = int(eval(input()))\n(*var_1,) = list(map(int, input().split()))\nvar_4 = 0\nfor var_7 in product([-1, 0, 1], repeat=var_2):\n var_6 = reduce(\n lambda var_8, var_9: var_8 * var_9,\n [var_3 + var_7[var_5] for var_5, var_3 in enumerate(var_1)],\n )\n if var_6 % 2 == 0:\n var_4 += 1\nprint(var_4)\n```\n\n=== Code B (Modified) ===\n```python\nvar_4 = int(eval(input()))\nvar_1 = list(map(int, input().split()))\nvar_3 = 1\nfor var_2 in var_1:\n var_3 *= 2 if var_2 % 2 == 0 else 1\nprint((3**var_4 - var_3))\n```", "output": "FASTER 9.8819", "pair_id": "python_p03568_forward", "problem_id": "p03568", "language": "python", "direction": "forward", "speedup_ratio": 943.5387} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_6 in range(var_1, var_2 + 1):\n var_3 = str(var_6)\n var_5 = True\n for var_7 in range(len(var_3) // 2):\n if var_3[var_7] != var_3[-var_7 - 1] and var_5:\n var_5 = not var_5\n if var_5:\n var_4 += 1\nprint(var_4)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().strip().split(\" \")))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n if str(var_4) == str(var_4)[::-1]:\n var_3 += 1\nprint(var_3)\n```", "output": "FASTER 1.1527", "pair_id": "python_p03416_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 2.2233} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\n\n\nclass Class_1:\n \"\"\"\"\"\"\n\n def __init__(self, var_1):\n self.__n = len(var_1)\n self.__node = [0] * (self.__n + 1)\n self.__data = [0] * (self.__n + 1)\n var_7 = [0] * (self.__n + 1)\n for var_11 in range(1, self.__n + 1):\n var_7[var_11] = var_7[var_11 - 1] + var_1[var_11 - 1]\n self.__data[var_11] = var_1[var_11 - 1]\n self.__node[var_11] = var_7[var_11] - var_7[var_11 - (var_11 & -var_11)]\n\n def func_1(self, var_11, var_22):\n self.__data[var_11] += var_22\n while var_11 <= self.__n:\n self.__node[var_11] += var_22\n var_11 += var_11 & -var_11\n\n def func_4(self, var_11):\n \"\"\"\"\"\"\n var_19 = 0\n while var_11 > 0:\n var_19 += self.__node[var_11]\n var_11 -= var_11 & -var_11\n return var_19\n\n def func_2(self, var_11, var_12):\n \"\"\"\"\"\"\n if var_11 == var_12:\n return self.__data[var_11]\n else:\n return self.sum(var_12) - self.sum(var_11 - 1)\n\n\ndef func_3():\n var_4, var_6 = map(int, input().split())\n var_3 = list(map(int, input().split()))\n var_5 = [[] for _ in range(var_4)]\n for var_11, var_9 in enumerate(var_3):\n var_5[var_9 - 1].append(var_11)\n var_18 = [0] * var_4\n for var_14 in var_5:\n if len(var_14):\n var_18[var_14.pop()] = 1\n var_2 = Class_1(var_18)\n var_16 = [[] for _ in range(var_4)]\n for var_11, var_20 in enumerate(sys.stdin.readlines()):\n var_13, var_17 = map(int, var_20.split())\n var_16[var_17 - 1].append((var_13 - 1, var_11))\n var_8 = [None] * var_6\n var_10 = var_4 - 1\n for var_17, var_15 in enumerate(reversed(var_16)):\n var_17 = (var_4 - 1) - var_17\n while var_15:\n var_13, var_11 = var_15.pop()\n while var_17 < var_10:\n var_9 = var_3[var_10] - 1\n var_14 = var_5[var_9]\n if len(var_14):\n var_2.add(var_14.pop() + 1, 1)\n var_10 -= 1\n var_21 = var_2.get(var_13 + 1, var_17 + 1)\n var_8[var_11] = var_21\n print(*var_8, sep=\"\\n\")\n\n\nif __name__ == \"__main__\":\n func_3()\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\n\nvar_20 = sys.stdin.read\nvar_21 = sys.stdin.readline\nvar_22 = sys.stdin.readlines\nsys.setrecursionlimit(10**9)\nvar_2 = 1 << 60\nvar_5 = 1000000007\n\n\nvar_4 = 1000001\n\n\nclass Class_1:\n def __init__(self, var_13, var_19, var_12):\n self.l = var_13\n self.r = var_19\n self.idx = var_12\n\n\ndef func_4(var_12, var_24, var_10, var_15):\n while var_12 <= var_15:\n var_10[var_12] += var_24\n var_12 += var_12 & -var_12\n\n\ndef func_3(var_12, var_10, var_15):\n var_23 = 0\n while var_12:\n var_23 += var_10[var_12]\n var_12 -= var_12 & -var_12\n return var_23\n\n\ndef func_1(var_9, var_15, var_17, var_16):\n\n var_10 = [0] * (var_15 + 1)\n\n var_14 = [-1] * var_4\n\n var_8 = [0] * var_16\n var_18 = 0\n for var_11 in range(var_15):\n\n if var_14[var_9[var_11]] != -1:\n func_4(var_14[var_9[var_11]] + 1, -1, var_10, var_15)\n\n var_14[var_9[var_11]] = var_11\n func_4(var_11 + 1, 1, var_10, var_15)\n\n while var_18 < var_16 and var_17[var_18].r == var_11:\n var_8[var_17[var_18].idx] = func_3(\n var_17[var_18].r + 1, var_10, var_15\n ) - func_3(var_17[var_18].l, var_10, var_15)\n var_18 += 1\n\n for var_11 in range(var_16):\n print((var_8[var_11]))\n\n\ndef func_2():\n var_6, var_7 = list(map(int, var_21().split()))\n var_1 = list(map(int, var_21().split()))\n (*var_3,) = list(map(int, var_20().split()))\n var_17 = [0] * var_7\n for var_11, (var_13, var_19) in enumerate(zip(*[iter(var_3)] * 2)):\n var_17[var_11] = Class_1(var_13 - 1, var_19 - 1, var_11)\n var_17.sort(key=lambda var_25: var_25.r)\n func_1(var_1, var_6, var_17, var_7)\n return\n\n\nif __name__ == \"__main__\":\n func_2()\n```", "output": "SLOWER 1.8099", "pair_id": "python_p02599_reversed", "problem_id": "p02599", "language": "python", "direction": "reversed", "speedup_ratio": 3.5063} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\ndef func_1():\n var_1, var_2 = list(map(int, input().split()))\n var_3 = 0\n for var_4 in range(var_1, var_2 + 1):\n\n if (var_4 % 10) == (var_4 // 10000 % 10) and (var_4 // 10 % 10) == (\n var_4 // 1000 % 10\n ):\n var_3 += 1\n print(var_3)\n\n\nif __name__ == \"__main__\":\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_4 = str(var_4)\n if var_4 == var_4[::-1]:\n var_3 += 1\nprint(var_3)\n```", "output": "SLOWER 1.8111", "pair_id": "python_p03416_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 3.509} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport decimal\n\n\ndef func_1():\n var_1, var_2 = list(map(decimal.Decimal, input().split()))\n print((var_1 * var_2 // 1))\n\n\nif __name__ == \"__main__\":\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\ndef func_1():\n from sys import setrecursionlimit, stdin\n from os import environ\n from collections import defaultdict, deque, Counter\n from math import ceil, floor, gcd\n from itertools import accumulate, combinations, combinations_with_replacement\n\n setrecursionlimit(10**6)\n var_7 = (\n (lambda *var_11: print(*var_11))\n if \"TERM_PROGRAM\" in environ\n else lambda *var_12: 0\n )\n var_8 = lambda: stdin.readline().rstrip()\n var_3 = lambda: list(map(int, var_8().split()))\n var_1 = lambda: int(var_8())\n var_4 = 10**9 + 7\n var_2 = 10**9 + 10\n var_9, var_10 = var_8().split()\n var_5 = int(var_9)\n var_10 = var_10.split(\".\")\n var_6 = int(var_10[0]) * 100\n if len(var_10) == 2:\n var_6 += int(var_10[1])\n print(var_5 * var_6 // 100)\n\n\nfunc_1()\n```", "output": "SLOWER 1.9156", "pair_id": "python_p02659_reversed", "problem_id": "p02659", "language": "python", "direction": "reversed", "speedup_ratio": 3.7726} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = [0] * (var_2 + 1)\nfor var_3 in range(1, var_2 + 1):\n if str(var_3) == str(var_3)[::-1]:\n var_4[var_3] = var_4[var_3 - 1] + 1\n else:\n var_4[var_3] = var_4[var_3 - 1]\nprint((var_4[var_2] - var_4[var_1 - 1]))\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_4 = str(var_4)\n if var_4 == var_4[::-1]:\n var_3 += 1\nprint(var_3)\n```", "output": "FASTER 1.7953", "pair_id": "python_p03416_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 3.4708} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_10 = []\nvar_10 = input().rstrip().split(\" \")\nvar_1 = int(var_10[0])\nvar_3 = int(var_10[1])\nvar_2 = 0\nvar_6 = var_1\nwhile var_6 <= var_3:\n var_4 = var_6 // 10000\n var_5 = (var_6 - var_4 * 10000) // 1000\n var_7 = var_6 // 100\n var_8 = (var_6 - var_7 * 100) // 10\n var_9 = var_6 % 10\n if (var_4 == var_9) and (var_5 == var_8):\n var_2 += 1\n var_6 += 1\nprint(var_2)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = str(var_4)\n if var_5[0] == var_5[4] and var_5[1] == var_5[3]:\n var_3 += 1\nprint(var_3)\n```", "output": "FASTER 1.0752", "pair_id": "python_p03416_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 2.107} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_8 = int(eval(input()))\nvar_4 = []\nfor var_5 in range(var_8):\n var_11 = 0\n var_9 = list(map(int, input().split()))\n for var_6 in range(10):\n var_11 += var_9[var_6] << var_6\n var_4.append(var_11)\nvar_10 = []\nfor var_5 in range(var_8):\n var_10.append(list(map(int, input().split())))\nvar_1 = -(10**12)\nfor var_5 in range(1, 1 << 10):\n var_11 = 0\n for var_6 in range(var_8):\n var_3 = var_4[var_6] & var_5\n var_2 = 0\n for var_7 in range(10):\n if (var_3 >> var_7) % 2:\n var_2 += 1\n var_11 += var_10[var_6][var_2]\n var_1 = max(var_1, var_11)\nprint(var_1)\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\n\nvar_8 = sys.stdin.readline\n\n\ndef func_1():\n var_2 = int(eval(var_8()))\n var_1 = [int(var_8().replace(\" \", \"\"), 2) for _ in range(var_2)]\n var_3 = [list(map(int, var_8().split())) for _ in range(var_2)]\n var_4 = -(10**7) * var_2\n for var_7 in range(1, 1 << 10):\n var_10 = 0\n for var_9, var_6 in enumerate(var_1):\n var_5 = bin(var_7 & var_6).count(\"1\")\n var_10 += var_3[var_9][var_5]\n var_4 = max(var_4, var_10)\n print(var_4)\n\n\nif __name__ == \"__main__\":\n func_1()\n```", "output": "FASTER 2.5749", "pair_id": "python_p03503_forward", "problem_id": "p03503", "language": "python", "direction": "forward", "speedup_ratio": 5.9584} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_8 = int(eval(input()))\nvar_5 = []\nvar_10 = {}\nvar_9 = [0, 0]\nfor var_6 in range(var_8 - 1):\n var_1, var_2 = list(map(int, input().split(\" \")))\n var_5.append([var_1, var_2])\n var_10.setdefault(var_1, []).append(var_2)\n var_9.append(0)\nvar_7 = 0\nfor var_11 in range(1, var_8 + 1):\n var_13 = var_10.get(var_11, [])\n var_3 = 1\n for var_12 in var_13:\n if var_3 == var_9[var_11]:\n var_3 += 1\n else:\n pass\n var_9[var_12] = var_3\n if var_3 >= var_7:\n var_7 = var_3\n var_3 += 1\nprint(var_7)\nfor var_4 in var_5:\n print((var_9[var_4[1]]))\n```\n\n=== Code B (Modified) ===\n```python\nimport copy\n\nvar_8 = int(eval(input()))\nvar_10 = set([var_6 for var_6 in range(1, 10**5)])\nvar_5 = []\nvar_11 = {}\nvar_9 = []\nfor var_6 in range(var_8 - 1):\n var_1, var_2 = list(map(int, input().split(\" \")))\n var_5.append([var_1, var_2])\n var_11.setdefault(var_1, []).append(var_2)\n var_9.append([])\nvar_9.append([])\nvar_9.append([])\nvar_7 = 0\nfor var_12 in range(1, var_8 + 1):\n var_14 = var_11.get(var_12, [])\n var_3 = 1\n for var_13 in var_14:\n if var_3 in var_9[var_12]:\n var_3 += 1\n else:\n pass\n var_9[var_13].append(var_3)\n if var_3 >= var_7:\n var_7 = var_3\n var_3 += 1\nprint(var_7)\nfor var_4 in var_5:\n print((var_9[var_4[1]][0]))\n```", "output": "SLOWER 4.7706", "pair_id": "python_p02850_reversed", "problem_id": "p02850", "language": "python", "direction": "reversed", "speedup_ratio": 27.2957} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\ndef func_1():\n var_1, var_2 = list(map(int, input().rstrip().split()))\n var_3 = 0\n for var_4 in range(var_1, var_2 + 1):\n var_5 = str(var_4)\n if var_5 == var_5[::-1]:\n var_3 += 1\n print(var_3)\n\n\nif __name__ == \"__main__\":\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_5 in range(10):\n for var_6 in range(10):\n for var_7 in range(10):\n var_3 = 10000 * var_5 + 1000 * var_6 + 100 * var_7 + 10 * var_6 + var_5\n if var_1 <= var_3 <= var_2:\n var_4 += 1\nprint(var_4)\n```", "output": "FASTER 3.0796", "pair_id": "python_p03416_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 8.4536} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_5 in range(10):\n for var_6 in range(10):\n for var_7 in range(10):\n var_3 = 10000 * var_5 + 1000 * var_6 + 100 * var_7 + 10 * var_6 + var_5\n if var_1 <= var_3 <= var_2:\n var_4 += 1\nprint(var_4)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_7 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_3 = True\n var_8 = str(var_4)\n var_6 = len(var_8)\n for var_5 in range(var_6 // 2 + 1):\n if var_8[var_5] != var_8[-var_5 - 1]:\n var_3 = False\n break\n if var_3:\n var_7 += 1\nprint(var_7)\n```", "output": "SLOWER 4.9507", "pair_id": "python_p03416_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 30.924} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\ndef func_1():\n from sys import setrecursionlimit, stdin\n from os import environ\n from collections import defaultdict, deque, Counter\n from math import ceil, floor, gcd\n from itertools import accumulate, combinations, combinations_with_replacement\n\n setrecursionlimit(10**6)\n var_7 = (\n (lambda *var_11: print(*var_11))\n if \"TERM_PROGRAM\" in environ\n else lambda *var_12: 0\n )\n var_8 = lambda: stdin.readline().rstrip()\n var_3 = lambda: list(map(int, var_8().split()))\n var_1 = lambda: int(var_8())\n var_4 = 10**9 + 7\n var_2 = 10**9 + 10\n var_9, var_10 = var_8().split()\n var_5 = int(var_9)\n var_10 = var_10.split(\".\")\n var_6 = int(var_10[0]) * 100\n if len(var_10) == 2:\n var_6 += int(var_10[1])\n print(var_5 * var_6 // 100)\n\n\nfunc_1()\n```\n\n=== Code B (Modified) ===\n```python\nimport math\n\nvar_1, var_2 = input().split()\nvar_1 = int(var_1)\nvar_3 = int(var_2[0] + var_2[2] + var_2[3])\nprint((var_1 * var_3 // 100))\n```", "output": "FASTER 2.2041", "pair_id": "python_p02659_forward", "problem_id": "p02659", "language": "python", "direction": "forward", "speedup_ratio": 4.6079} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().strip().split(\" \")))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n if str(var_4) == str(var_4)[::-1]:\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\ndef func_1():\n var_1, var_2 = list(map(int, input().split()))\n var_3 = 0\n for var_4 in range(var_1, var_2 + 1):\n\n if (var_4 % 10) == (var_4 // 10000 % 10) and (var_4 // 10 % 10) == (\n var_4 // 1000 % 10\n ):\n var_3 += 1\n print(var_3)\n\n\nif __name__ == \"__main__\":\n func_1()\n```", "output": "FASTER 1.9713", "pair_id": "python_p03416_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 3.9213} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport math\nfrom decimal import Decimal\n\nvar_1, var_2 = list(map(Decimal, input().split()))\nprint((math.floor(var_1 * var_2)))\n```\n\n=== Code B (Modified) ===\n```python\ndef func_1():\n from sys import setrecursionlimit, stdin\n from os import environ\n from collections import defaultdict, deque, Counter\n from math import ceil, floor, gcd\n from itertools import accumulate, combinations, combinations_with_replacement\n\n setrecursionlimit(10**6)\n var_7 = (\n (lambda *var_11: print(*var_11))\n if \"TERM_PROGRAM\" in environ\n else lambda *var_12: 0\n )\n var_8 = lambda: stdin.readline().rstrip()\n var_3 = lambda: list(map(int, var_8().split()))\n var_1 = lambda: int(var_8())\n var_4 = 10**9 + 7\n var_2 = 10**9 + 10\n var_9, var_10 = var_8().split()\n var_5 = int(var_9)\n var_6 = int(float(var_10) * 100 + 0.5)\n print(var_5 * var_6 // 100)\n\n\nfunc_1()\n```", "output": "SLOWER 2.159", "pair_id": "python_p02659_reversed", "problem_id": "p02659", "language": "python", "direction": "reversed", "speedup_ratio": 4.466} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nfrom sys import stdin\n\nvar_5 = stdin.readline\nvar_2, var_1 = list(map(int, var_5().split()))\nvar_3 = [False] * var_2\nvar_8 = [0] * var_2\nvar_9 = 0\nfor var_4 in range(var_1):\n var_6, var_7 = var_5().split()\n var_6 = int(var_6) - 1\n if var_3[var_6] is False and var_7 == \"AC\":\n var_9 += var_8[var_6]\n var_3[var_6] = True\n elif var_7 == \"WA\":\n var_8[var_6] += 1\nprint((var_3.count(True), var_9))\n```\n\n=== Code B (Modified) ===\n```python\nvar_6, var_5 = list(map(int, input().split()))\nvar_8 = [[] for _ in range(var_6)]\nfor var_2 in range(var_5):\n var_10, var_11 = input().split()\n var_8[int(var_10) - 1].append(var_11)\n\nvar_1, var_7 = 0, 0\nfor var_3 in range(var_6):\n var_9 = var_8[var_3]\n if \"AC\" in var_9:\n var_1 += 1\n for var_4 in var_9:\n if var_4 == \"WA\":\n var_7 += 1\n else:\n break\nprint((var_1, var_7))\n```", "output": "SLOWER 3.2959", "pair_id": "python_p02802_reversed", "problem_id": "p02802", "language": "python", "direction": "reversed", "speedup_ratio": 9.8215} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\ndef func_1():\n var_2 = int(input())\n var_1 = [int(var_6) for var_6 in input().split()]\n if var_2 == 1:\n return print(1 if var_1[0] % 2 == 0 else 2)\n var_3 = 0\n var_5 = (-1, 0, 1)\n from itertools import product\n\n for var_6 in product(range(3), repeat=var_2):\n var_4 = 1\n for var_7 in range(var_2):\n var_4 *= var_1[var_7] + var_5[var_6[var_7]]\n if var_4 % 2 == 0:\n var_3 += 1\n print(var_3)\n\n\nif __name__ == \"__main__\":\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nvar_6 = int(eval(input()))\nvar_2 = list(map(int, input().split()))\nfrom itertools import product\n\nvar_5 = [-1, 0, 1]\nvar_3 = 0\nfor var_7 in product(var_5, repeat=var_6):\n var_1 = []\n for var_4 in range(var_6):\n var_1.append(var_7[var_4] + var_2[var_4])\n if any(var_8 % 2 == 0 for var_8 in var_1):\n var_3 += 1\nprint(var_3)\n```", "output": "SLOWER 1.2741", "pair_id": "python_p03568_reversed", "problem_id": "p03568", "language": "python", "direction": "reversed", "speedup_ratio": 2.4185} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nfrom collections import Counter, defaultdict, deque\nfrom heapq import heappop, heappush, heapify\nimport sys, bisect, math, itertools, fractions, pprint\n\nsys.setrecursionlimit(10**8)\nvar_6 = 10**9 + 7\nvar_1 = float(\"inf\")\n\n\ndef func_1():\n return int(sys.stdin.readline())\n\n\ndef func_2():\n return list(map(int, sys.stdin.readline().split()))\n\n\nvar_7, var_9 = func_2()\nvar_13 = [func_2() for _ in range(var_7)]\nvar_13.sort(key=lambda var_14: var_14[1], reverse=True)\nvar_8 = 0\nvar_10 = min(var_7, 5)\nfor var_3 in range(var_10):\n var_2 = [[0] * (var_9 + 5) for _ in range(var_7 + 5)]\n for var_4 in range(var_7):\n var_12, var_11 = var_13[var_4]\n for var_5 in range(var_9):\n if var_5 < var_12 or var_3 == var_4:\n var_2[var_4 + 1][var_5] = var_2[var_4][var_5]\n else:\n var_2[var_4 + 1][var_5] = max(\n var_2[var_4][var_5], var_2[var_4][var_5 - var_12] + var_11\n )\n\n var_8 = max(var_2[var_7][var_9 - 1] + var_13[var_3][1], var_8)\nprint(var_8)\n```\n\n=== Code B (Modified) ===\n```python\nvar_2, var_3, *var_1 = list(map(int, open(0).read().split()))\nvar_4 = [0] * (var_3 + max(var_1[::2]))\nfor var_7, var_6 in sorted(zip(*[iter(var_1)] * 2)):\n for var_5 in reversed(list(range(var_3))):\n var_4[var_5 + var_7] = max(var_4[var_5 + var_7], var_4[var_5] + var_6)\nprint((max(var_4)))\n```", "output": "FASTER 2.226", "pair_id": "python_p02863_forward", "problem_id": "p02863", "language": "python", "direction": "forward", "speedup_ratio": 4.6782} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_3 = list(map(int, input().split()))\nvar_2 = -1\nfor var_4 in range(10, 12501):\n if int(var_4 * 0.08) == var_1 and int(var_4 * 0.1) == var_3:\n var_2 = var_4\n break\nprint(var_2)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nfor var_3 in range(1, 1009):\n if int(var_3 * 0.08) == var_1 and int(var_3 * 0.1) == var_2:\n print((int(var_3)))\n exit()\nprint(\"-1\")\n```", "output": "FASTER 3.3967", "pair_id": "python_p02755_forward", "problem_id": "p02755", "language": "python", "direction": "forward", "speedup_ratio": 10.5316} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\n\nvar_2, var_1, *var_3 = sys.stdin.read().strip().split()\nvar_2 = int(var_2)\nvar_5 = [0] * var_2\nvar_10 = [0] * var_2\nfor var_6, var_8 in zip(*[iter(var_3)] * 2):\n var_6 = int(var_6) - 1\n if var_8 == \"AC\":\n var_5[var_6] = 1\n elif var_5[var_6] == 0:\n var_10[var_6] += 1\nvar_7 = sum([var_9 * var_4 for var_4, var_9 in zip(var_5, var_10)])\nprint((\"{} {}\".format(sum(var_5), var_7)))\n```\n\n=== Code B (Modified) ===\n```python\nvar_2, var_1 = list(map(int, input().split()))\nvar_3 = 0\nvar_8 = 0\nvar_4 = [0] * (var_2 + 1)\nvar_9 = [0] * (var_2 + 1)\nfor var_5 in range(var_1):\n var_6, var_7 = input().split()\n var_6 = int(var_6)\n if var_7 == \"AC\":\n if var_4[var_6] == 0:\n var_3 += 1\n var_8 += var_9[var_6]\n var_4[var_6] = 1\n else:\n var_9[var_6] += 1\nprint((var_3, var_8))\n```", "output": "FASTER 2.9476", "pair_id": "python_p02802_forward", "problem_id": "p02802", "language": "python", "direction": "forward", "speedup_ratio": 7.7147} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport copy\nimport random\nimport bisect\nimport fractions\nimport math\nimport sys\nimport collections\nfrom decimal import Decimal\n\nvar_5 = 10**9 + 7\nsys.setrecursionlimit(var_5)\nvar_3 = collections.deque()\n\n\ndef func_1():\n return list(map(int, sys.stdin.readline().split()))\n\n\nvar_1 = int(eval(input()))\nvar_6 = [0 for var_4 in range(var_1)]\nfor var_4 in range(var_1):\n var_6[var_4] = int(eval(input()))\nvar_6.sort()\nvar_2 = sum(var_6)\nvar_2 -= var_6[-1] // 2\nprint(var_2)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1 = [int(eval(input())) for _ in range(int(eval(input())))]\nprint((sum(var_1) - max(var_1) // 2))\n```", "output": "FASTER 1.0725", "pair_id": "python_p03207_forward", "problem_id": "p03207", "language": "python", "direction": "forward", "speedup_ratio": 2.1031} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = [\n var_3 for var_3 in map(str, list(range(var_1, var_2 + 1))) if var_3 == var_3[::-1]\n]\nprint((len(var_4)))\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n if list(str(var_4)) == list(reversed(str(var_4))):\n var_3 += 1\nprint(var_3)\n```", "output": "SLOWER 2.0989", "pair_id": "python_p03416_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 4.2839} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport numpy as np\nfrom bisect import bisect_left\n\n\ndef func_1():\n var_4 = []\n var_1 = np.ones(10**5 + 10)\n var_1[0] = var_1[1] = 0\n for var_3, var_2 in enumerate(var_1):\n if var_2:\n var_4.append(var_3)\n var_1[2 * var_3 : 10**5 + 10 : var_3] = 0\n return var_4\n\n\ndef func_2(var_6):\n var_7 = int(var_6)\n var_5 = func_1()\n return str(var_5[bisect_left(var_5, var_7)])\n\n\nif __name__ == \"__main__\":\n import sys\n\n print((func_2(sys.stdin.read().strip())))\n```\n\n=== Code B (Modified) ===\n```python\nfrom math import sqrt\n\nvar_2 = int(eval(input()))\n\n\ndef func_1(var_2):\n if var_2 < 2:\n return False\n for var_1 in range(2, int(sqrt(var_2)) + 1):\n if var_2 % var_1 == 0:\n return False\n return True\n\n\nwhile not func_1(var_2):\n var_2 += 1\nprint(var_2)\n```", "output": "FASTER 7.7622", "pair_id": "python_p02819_forward", "problem_id": "p02819", "language": "python", "direction": "forward", "speedup_ratio": 217.0952} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_6 = 2019\nvar_1 = [0] * var_6\nvar_3 = 1\nvar_5 = var_4 = 0\nfor var_2 in input()[::-1]:\n var_1[var_4] += 1\n var_4 -= int(var_2) * var_3\n var_4 %= var_6\n var_5 += var_1[var_4]\n var_3 *= 10\n var_3 %= var_6\nprint(var_5)\n```\n\n=== Code B (Modified) ===\n```python\nvar_6 = input()[::-1]\nvar_5 = len(var_6)\nvar_1 = [0] * var_5\nvar_3 = [0] * var_5\nvar_2 = [0] * 2019\nvar_7 = 10\nvar_1[0] = int(var_6[0])\nvar_3[0] = var_1[0]\nvar_2[var_3[0]] += 1\nfor var_4 in range(1, var_5):\n var_1[var_4] = int(var_6[var_4]) * var_7 % 2019\n var_3[var_4] = (var_3[var_4 - 1] + var_1[var_4]) % 2019\n var_2[var_3[var_4]] += 1\n var_7 = var_7 * 10 % 2019\nprint(\n (\n int(sum([var_2[var_4] * (var_2[var_4] - 1) for var_4 in range(2019)]) / 2)\n + var_2[0]\n )\n)\n```", "output": "SLOWER 2.581", "pair_id": "python_p02702_reversed", "problem_id": "p02702", "language": "python", "direction": "reversed", "speedup_ratio": 5.9835} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\n\nsys.setrecursionlimit(500000)\nvar_4 = int(eval(input()))\nvar_2 = [[] for _ in range(var_4 + 1)]\nfor var_9 in range(var_4 - 1):\n var_5, var_6 = list(map(int, input().split()))\n var_2[var_5].append((var_6, var_9))\n var_2[var_6].append((var_5, var_9))\nvar_3 = max(len(var_8) for var_8 in var_2)\nprint(var_3)\nvar_1 = [-1] * (var_4 - 1)\n\n\ndef func_1(var_14=1, var_11=0, var_12=-1):\n var_7 = 1\n for var_13, var_10 in var_2[var_14]:\n if var_13 != var_11:\n if var_7 == var_12:\n var_7 += 1\n var_1[var_10] = var_7\n\n func_1(var_13, var_14, var_7)\n var_7 += 1\n\n\nfunc_1()\nprint((\"\\n\".join(map(str, var_1))))\n```\n\n=== Code B (Modified) ===\n```python\nimport copy\n\nvar_8 = int(eval(input()))\nvar_10 = set([var_6 for var_6 in range(1, 10**5)])\nvar_5 = []\nvar_11 = {}\nvar_9 = []\nfor var_6 in range(var_8 - 1):\n var_1, var_2 = list(map(int, input().split(\" \")))\n var_5.append([var_1, var_2])\n var_11.setdefault(var_1, []).append(var_2)\n var_9.append([])\nvar_9.append([])\nvar_9.append([])\nvar_7 = 0\nfor var_12 in range(1, var_8 + 1):\n var_14 = var_11.get(var_12, [])\n var_3 = 1\n for var_13 in var_14:\n if var_3 in var_9[var_12]:\n var_3 += 1\n else:\n pass\n var_9[var_13].append(var_3)\n if var_3 >= var_7:\n var_7 = var_3\n var_3 += 1\nprint(var_7)\nfor var_4 in var_5:\n print((var_9[var_4[1]][0]))\n```", "output": "SLOWER 4.54", "pair_id": "python_p02850_reversed", "problem_id": "p02850", "language": "python", "direction": "reversed", "speedup_ratio": 23.264} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nfrom sys import stdin\n\nvar_5 = stdin.readline\nvar_2, var_1 = list(map(int, var_5().split()))\nvar_3 = [False] * var_2\nvar_8 = [0] * var_2\nvar_9 = 0\nfor var_4 in range(var_1):\n var_6, var_7 = var_5().split()\n var_6 = int(var_6) - 1\n if var_3[var_6] is False and var_7 == \"AC\":\n var_9 += var_8[var_6]\n var_3[var_6] = True\n elif var_7 == \"WA\":\n var_8[var_6] += 1\nprint((var_3.count(True), var_9))\n```\n\n=== Code B (Modified) ===\n```python\nvar_2, var_1 = list(map(int, input().split()))\nvar_3 = 0\nvar_8 = 0\nvar_4 = [0] * (var_2 + 1)\nvar_9 = [0] * (var_2 + 1)\nfor var_5 in range(var_1):\n var_6, var_7 = input().split()\n var_6 = int(var_6)\n if var_7 == \"AC\":\n if var_4[var_6] == 0:\n var_3 += 1\n var_8 += var_9[var_6]\n var_4[var_6] = 1\n else:\n var_9[var_6] += 1\nprint((var_3, var_8))\n```", "output": "FASTER 1.4288", "pair_id": "python_p02802_forward", "problem_id": "p02802", "language": "python", "direction": "forward", "speedup_ratio": 2.6922} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1 = list(map(int, input().split()))\nvar_2 = 0\nfor var_3 in range(var_1[0], var_1[1] + 1):\n var_4 = str(var_3)\n if var_4[0] == var_4[4] and var_4[1] == var_4[3]:\n var_2 += 1\nprint(var_2)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = list(str(var_4))\n if var_5 == list(reversed(var_5)):\n var_3 += 1\nprint(var_3)\n```", "output": "SLOWER 1.521", "pair_id": "python_p03416_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 2.8699} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport bisect\nimport sys\n\nsys.setrecursionlimit(10**6)\nvar_16 = sys.stdout.write\nvar_7 = lambda *var_14: print(*var_14) if var_1 else 0\nvar_1 = True\n\n\ndef func_1(var_9=sys.stdin.readline):\n var_11 = lambda: var_9().rstrip()\n var_3 = lambda: list(map(int, var_11().split()))\n var_2 = lambda: int(var_11())\n var_4 = lambda var_17: [var_3() for _ in range(var_17)]\n var_13, var_15 = var_3()\n var_5 = var_4(var_13)\n var_5.sort()\n var_8 = [[0] * var_15 for _ in range(var_13 + 1)]\n for var_10 in range(1, var_13 + 1):\n for var_12 in range(1, var_15):\n if var_12 < var_5[var_10 - 1][0]:\n var_8[var_10][var_12] = var_8[var_10 - 1][var_12]\n else:\n var_8[var_10][var_12] = max(\n var_8[var_10 - 1][var_12],\n var_8[var_10 - 1][var_12 - var_5[var_10 - 1][0]]\n + var_5[var_10 - 1][1],\n )\n var_6 = 0\n for var_10 in range(var_13):\n var_6 = max(var_6, var_8[var_10][var_15 - 1] + var_5[var_10][1])\n print(var_6)\n\n\nif __name__ == \"__main__\":\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nfrom collections import Counter, defaultdict, deque\nfrom heapq import heappop, heappush, heapify\nimport sys, bisect, math, itertools, fractions, pprint\n\nsys.setrecursionlimit(10**8)\nvar_6 = 10**9 + 7\nvar_1 = float(\"inf\")\n\n\ndef func_1():\n return int(sys.stdin.readline())\n\n\ndef func_2():\n return list(map(int, sys.stdin.readline().split()))\n\n\nvar_7, var_9 = func_2()\nvar_13 = [func_2() for _ in range(var_7)]\nvar_13.sort(key=lambda var_14: var_14[1], reverse=True)\nvar_8 = 0\nvar_10 = min(var_7, 5)\nfor var_3 in range(var_10):\n var_2 = [[0] * (var_9 + 5) for _ in range(var_7 + 5)]\n for var_4 in range(var_7):\n var_12, var_11 = var_13[var_4]\n for var_5 in range(var_9):\n if var_5 < var_12 or var_3 == var_4:\n var_2[var_4 + 1][var_5] = var_2[var_4][var_5]\n else:\n var_2[var_4 + 1][var_5] = max(\n var_2[var_4][var_5], var_2[var_4][var_5 - var_12] + var_11\n )\n\n var_8 = max(var_2[var_7][var_9 - 1] + var_13[var_3][1], var_8)\nprint(var_8)\n```", "output": "SLOWER 2.0434", "pair_id": "python_p02863_reversed", "problem_id": "p02863", "language": "python", "direction": "reversed", "speedup_ratio": 4.1221} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = [\n var_3 for var_3 in map(str, list(range(var_1, var_2 + 1))) if var_3 == var_3[::-1]\n]\nprint((len(var_4)))\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = list(str(var_4))\n if var_5 == list(reversed(var_5)):\n var_3 += 1\nprint(var_3)\n```", "output": "SLOWER 1.9307", "pair_id": "python_p03416_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 3.8125} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_6, var_5 = list(map(int, input().split()))\nvar_8 = [[] for _ in range(var_6)]\nfor var_2 in range(var_5):\n var_10, var_11 = input().split()\n var_8[int(var_10) - 1].append(var_11)\n\nvar_1, var_7 = 0, 0\nfor var_3 in range(var_6):\n var_9 = var_8[var_3]\n if \"AC\" in var_9:\n var_1 += 1\n for var_4 in var_9:\n if var_4 == \"WA\":\n var_7 += 1\n else:\n break\nprint((var_1, var_7))\n```\n\n=== Code B (Modified) ===\n```python\nfrom sys import stdin\n\nvar_5 = stdin.readline\nvar_2, var_1 = list(map(int, var_5().split()))\nvar_3 = [False] * var_2\nvar_8 = [0] * var_2\nvar_9 = 0\nfor var_4 in range(var_1):\n var_6, var_7 = var_5().split()\n var_6 = int(var_6) - 1\n if var_3[var_6] is False and var_7 == \"AC\":\n var_9 += var_8[var_6]\n var_3[var_6] = True\n elif var_7 == \"WA\":\n var_8[var_6] += 1\nprint((var_3.count(True), var_9))\n```", "output": "FASTER 3.2959", "pair_id": "python_p02802_forward", "problem_id": "p02802", "language": "python", "direction": "forward", "speedup_ratio": 9.8215} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\ndef func_1():\n var_2, var_3, *var_1 = list(map(int, open(0).read().split()))\n var_4 = [0] * (var_3 + max(var_1[::2]))\n for var_7, var_6 in sorted(zip(*[iter(var_1)] * 2)):\n for var_5 in reversed(list(range(var_3))):\n var_4[var_5 + var_7] = max(var_4[var_5 + var_7], var_4[var_5] + var_6)\n print((max(var_4)))\n\n\nfunc_1()\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\nfrom operator import itemgetter\nfrom heapq import heapify, heappop, heappush\n\nvar_1 = int(10e15)\nvar_2 = -var_1\nvar_11 = 1000000007\nsys.setrecursionlimit(1000000)\n\n\ndef func_2():\n return list(map(int, input().split()))\n\n\ndef func_4():\n return input().split()\n\n\ndef func_1():\n return int(sys.stdin.readline())\n\n\ndef func_3():\n return eval(input())\n\n\nvar_3, var_4 = func_2()\nvar_5 = [func_2() for var_9 in range(var_3)]\nvar_5.sort(key=itemgetter(0))\n\nvar_8 = [[0] * (var_4 + 1 + 3000 + 1) for _ in range(var_3 + 1)]\nvar_6 = 0\nfor var_9 in range(var_3):\n for var_10 in range(var_4 + 1 + 3000 + 1):\n var_12, var_7 = var_5[var_9]\n if 0 <= var_10 - var_12 < var_4:\n var_8[var_9 + 1][var_10] = max(\n var_8[var_9][var_10], var_8[var_9][var_10 - var_12] + var_7\n )\n else:\n var_8[var_9 + 1][var_10] = var_8[var_9][var_10]\n var_6 = max(var_6, var_8[var_9 + 1][var_10])\nprint(var_6)\n```", "output": "SLOWER 6.1143", "pair_id": "python_p02863_reversed", "problem_id": "p02863", "language": "python", "direction": "reversed", "speedup_ratio": 69.2784} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = input().split()\nvar_1 = int(var_1)\nvar_2 = int(var_2)\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = list(str(var_4))\n if (var_5[0] == var_5[4]) and (var_5[1] == var_5[3]):\n var_3 = var_3 + 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = list(reversed(list(str(var_4))))\n if var_5 == list(str(var_4)):\n var_3 += 1\nprint(var_3)\n```", "output": "SLOWER 1.2527", "pair_id": "python_p03416_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 2.3828} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\n\nvar_7 = sys.stdin.readline\nfrom itertools import combinations\n\n\ndef func_3(var_10):\n for _ in range(var_10):\n yield list(map(int, var_7().split()))\n\n\ndef func_1(var_9, var_5, var_11):\n var_3 = sum(1 if var_5[var_8] == 1 else 0 for var_8 in var_9)\n return var_11[var_3]\n\n\ndef func_2():\n var_10 = int(eval(var_7()))\n var_1 = list(func_3(var_10))\n var_2 = list(func_3(var_10))\n for var_6 in range(1, 11):\n for var_4 in combinations(list(range(10)), var_6):\n yield sum(\n func_1(var_4, var_5, var_11) for var_5, var_11 in zip(var_1, var_2)\n )\n\n\nprint((max(func_2())))\n```\n\n=== Code B (Modified) ===\n```python\nfrom sys import stdin\n\n\ndef func_1():\n\n var_11 = stdin.readline\n var_2 = int(var_11())\n var_1 = []\n for var_6 in range(var_2):\n var_5 = int(\"\".join(var_11().strip().split(\" \")), 2)\n var_1.append(var_5)\n var_3 = []\n for var_6 in range(var_2):\n var_10 = list(map(int, var_11().split()))\n var_3.append(var_10)\n var_8 = float(\"-inf\")\n for var_9 in range(1, 1 << 10):\n var_12 = 0\n for var_7 in range(var_2):\n var_4 = bin(var_9 & var_1[var_7]).count(\"1\")\n var_12 += var_3[var_7][var_4]\n var_8 = max(var_12, var_8)\n print(var_8)\n\n\nif __name__ == \"__main__\":\n func_1()\n```", "output": "FASTER 1.801", "pair_id": "python_p03503_forward", "problem_id": "p03503", "language": "python", "direction": "forward", "speedup_ratio": 3.4845} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_3 in range(var_1, var_2 + 1):\n var_5 = list(str(var_3))\n var_6 = list(reversed(var_5))\n if var_5 == var_6:\n var_4 += 1\nprint(var_4)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = str(var_4)\n if var_5 == var_5[::-1]:\n var_3 += 1\nprint(var_3)\n```", "output": "FASTER 1.3131", "pair_id": "python_p03416_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 2.4848} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\nfrom operator import itemgetter\nfrom heapq import heapify, heappop, heappush\n\nvar_1 = int(10e15)\nvar_2 = -var_1\nvar_11 = 1000000007\nsys.setrecursionlimit(1000000)\n\n\ndef func_2():\n return list(map(int, input().split()))\n\n\ndef func_4():\n return input().split()\n\n\ndef func_1():\n return int(sys.stdin.readline())\n\n\ndef func_3():\n return eval(input())\n\n\nvar_3, var_4 = func_2()\nvar_5 = [func_2() for var_9 in range(var_3)]\nvar_5.sort(key=itemgetter(0))\n\nvar_8 = [[0] * (var_4 + 1 + 3000 + 1) for _ in range(var_3 + 1)]\nvar_6 = 0\nfor var_9 in range(var_3):\n for var_10 in range(var_4 + 1 + 3000 + 1):\n var_12, var_7 = var_5[var_9]\n if 0 <= var_10 - var_12 < var_4:\n var_8[var_9 + 1][var_10] = max(\n var_8[var_9][var_10], var_8[var_9][var_10 - var_12] + var_7\n )\n else:\n var_8[var_9 + 1][var_10] = var_8[var_9][var_10]\n var_6 = max(var_6, var_8[var_9 + 1][var_10])\nprint(var_6)\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\n\nvar_9 = sys.stdin.readline\nfrom operator import itemgetter\n\nvar_3, var_4 = list(map(int, var_9().split()))\nvar_1 = [list(map(int, var_9().split())) for _ in range(var_3)]\nvar_1.sort(key=itemgetter(0))\nvar_8 = [[0 for _ in range(var_3 + 1)] for _ in range(var_4 + 1)]\n\nvar_2 = []\nfor var_10 in range(var_3):\n var_5, var_7 = var_1[var_10]\n for var_11 in range(var_4):\n if var_5 > var_11:\n var_8[var_11][var_10 + 1] = var_8[var_11][var_10]\n else:\n if var_7 + var_8[var_11 - var_5][var_10] >= var_8[var_11][var_10]:\n var_8[var_11][var_10 + 1] = var_8[var_11 - var_5][var_10] + var_7\n else:\n var_8[var_11][var_10 + 1] = var_8[var_11][var_10]\n var_2.append(var_8[var_4 - 1][var_10] + var_7)\nvar_6 = max(var_2)\nprint(var_6)\n```", "output": "FASTER 4.8389", "pair_id": "python_p02863_forward", "problem_id": "p02863", "language": "python", "direction": "forward", "speedup_ratio": 28.619} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport bisect\nimport sys\n\nsys.setrecursionlimit(10**6)\nvar_16 = sys.stdout.write\nvar_7 = lambda *var_14: print(*var_14) if var_1 else 0\nvar_1 = True\n\n\ndef func_1(var_9=sys.stdin.readline):\n var_11 = lambda: var_9().rstrip()\n var_3 = lambda: list(map(int, var_11().split()))\n var_2 = lambda: int(var_11())\n var_4 = lambda var_17: [var_3() for _ in range(var_17)]\n var_13, var_15 = var_3()\n var_5 = var_4(var_13)\n var_5.sort()\n var_8 = [[0] * var_15 for _ in range(var_13 + 1)]\n for var_10 in range(1, var_13 + 1):\n for var_12 in range(1, var_15):\n if var_12 < var_5[var_10 - 1][0]:\n var_8[var_10][var_12] = var_8[var_10 - 1][var_12]\n else:\n var_8[var_10][var_12] = max(\n var_8[var_10 - 1][var_12],\n var_8[var_10 - 1][var_12 - var_5[var_10 - 1][0]]\n + var_5[var_10 - 1][1],\n )\n var_6 = 0\n for var_10 in range(var_13):\n var_6 = max(var_6, var_8[var_10][var_15 - 1] + var_5[var_10][1])\n print(var_6)\n\n\nif __name__ == \"__main__\":\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_6 = sorted([list(map(int, input().split())) for var_5 in range(var_1)])\n\nvar_4 = [[0] * (var_2 + 1) for var_5 in range(var_1 + 1)]\n\nfor var_5 in range(var_1):\n var_9, var_8 = var_6[var_5]\n for var_7 in range(var_2 + 1):\n if var_7 + var_9 <= var_2:\n var_4[var_5 + 1][var_7 + var_9] = max(\n var_4[var_5 + 1][var_7 + var_9], var_4[var_5][var_7] + var_8\n )\n var_4[var_5 + 1][var_7] = max(var_4[var_5][var_7], var_4[var_5 + 1][var_7])\nvar_3 = 0\nfor var_5, (var_9, var_8) in enumerate(var_6):\n for var_7 in range(var_2):\n var_3 = max(var_3, var_4[var_5][var_7] + var_8)\nprint(var_3)\n```", "output": "SLOWER 1.1662", "pair_id": "python_p02863_reversed", "problem_id": "p02863", "language": "python", "direction": "reversed", "speedup_ratio": 2.2442} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport math\nfrom decimal import Decimal\n\nvar_1, var_2 = list(map(Decimal, input().split()))\nprint((math.floor(var_1 * var_2)))\n```\n\n=== Code B (Modified) ===\n```python\ndef func_1():\n from sys import setrecursionlimit, stdin\n from os import environ\n from collections import defaultdict, deque, Counter\n from math import ceil, floor, gcd\n from itertools import accumulate, combinations, combinations_with_replacement\n\n setrecursionlimit(10**6)\n var_7 = (\n (lambda *var_11: print(*var_11))\n if \"TERM_PROGRAM\" in environ\n else lambda *var_12: 0\n )\n var_8 = lambda: stdin.readline().rstrip()\n var_3 = lambda: list(map(int, var_8().split()))\n var_1 = lambda: int(var_8())\n var_4 = 10**9 + 7\n var_2 = 10**9 + 10\n var_9, var_10 = var_8().split()\n var_5 = int(var_9)\n var_10 = var_10.split(\".\")\n var_6 = int(var_10[0]) * 100\n if len(var_10) == 2:\n var_6 += int(var_10[1])\n print(var_5 * var_6 // 100)\n\n\nfunc_1()\n```", "output": "SLOWER 2.3027", "pair_id": "python_p02659_reversed", "problem_id": "p02659", "language": "python", "direction": "reversed", "speedup_ratio": 4.9339} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nfrom sys import stdin\n\n\ndef func_1():\n\n var_11 = stdin.readline\n var_2 = int(var_11())\n var_1 = []\n for var_6 in range(var_2):\n var_5 = int(\"\".join(var_11().strip().split(\" \")), 2)\n var_1.append(var_5)\n var_3 = []\n for var_6 in range(var_2):\n var_10 = list(map(int, var_11().split()))\n var_3.append(var_10)\n var_8 = float(\"-inf\")\n for var_9 in range(1, 1 << 10):\n var_12 = 0\n for var_7 in range(var_2):\n var_4 = bin(var_9 & var_1[var_7]).count(\"1\")\n var_12 += var_3[var_7][var_4]\n var_8 = max(var_12, var_8)\n print(var_8)\n\n\nif __name__ == \"__main__\":\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nvar_8 = int(eval(input()))\nvar_4 = []\nfor var_5 in range(var_8):\n var_11 = 0\n var_9 = list(map(int, input().split()))\n for var_6 in range(10):\n var_11 += var_9[var_6] << var_6\n var_4.append(var_11)\nvar_10 = []\nfor var_5 in range(var_8):\n var_10.append(list(map(int, input().split())))\nvar_1 = -(10**12)\nfor var_5 in range(1, 1 << 10):\n var_11 = 0\n for var_6 in range(var_8):\n var_3 = list(bin(var_4[var_6] & var_5)[2:])\n var_2 = 0\n for var_7 in var_3:\n if var_7 == \"1\":\n var_2 += 1\n var_11 += var_10[var_6][var_2]\n var_1 = max(var_1, var_11)\nprint(var_1)\n```", "output": "SLOWER 2.3449", "pair_id": "python_p03503_reversed", "problem_id": "p03503", "language": "python", "direction": "reversed", "speedup_ratio": 5.0801} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nfrom sys import stdin\n\n\ndef func_1():\n\n var_11 = stdin.readline\n var_2 = int(var_11())\n var_1 = []\n for var_6 in range(var_2):\n var_5 = int(\"\".join(var_11().strip().split(\" \")), 2)\n var_1.append(var_5)\n var_3 = []\n for var_6 in range(var_2):\n var_10 = list(map(int, var_11().split()))\n var_3.append(var_10)\n var_8 = float(\"-inf\")\n for var_9 in range(1, 1 << 10):\n var_12 = 0\n for var_7 in range(var_2):\n var_4 = bin(var_9 & var_1[var_7]).count(\"1\")\n var_12 += var_3[var_7][var_4]\n var_8 = max(var_12, var_8)\n print(var_8)\n\n\nif __name__ == \"__main__\":\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nvar_8 = int(eval(input()))\nvar_4 = []\nfor var_5 in range(var_8):\n var_11 = 0\n var_9 = list(map(int, input().split()))\n for var_6 in range(10):\n var_11 += var_9[var_6] << var_6\n var_4.append(var_11)\nvar_10 = []\nfor var_5 in range(var_8):\n var_10.append(list(map(int, input().split())))\nvar_1 = -(10**12)\nfor var_5 in range(1, 1 << 10):\n var_11 = 0\n for var_6 in range(var_8):\n var_3 = var_4[var_6] & var_5\n var_2 = 0\n for var_7 in range(10):\n if (var_3 >> var_7) % 2:\n var_2 += 1\n var_11 += var_10[var_6][var_2]\n var_1 = max(var_1, var_11)\nprint(var_1)\n```", "output": "SLOWER 2.7133", "pair_id": "python_p03503_reversed", "problem_id": "p03503", "language": "python", "direction": "reversed", "speedup_ratio": 6.558} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n if list(str(var_4)) == list(reversed(str(var_4))):\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = [\n var_3 for var_3 in map(str, list(range(var_1, var_2 + 1))) if var_3 == var_3[::-1]\n]\nprint((len(var_4)))\n```", "output": "FASTER 2.0989", "pair_id": "python_p03416_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 4.2839} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_2, var_1 = list(map(int, input().split()))\nvar_3 = 0\nvar_8 = 0\nvar_4 = [0] * (var_2 + 1)\nvar_9 = [0] * (var_2 + 1)\nfor var_5 in range(var_1):\n var_6, var_7 = input().split()\n var_6 = int(var_6)\n if var_7 == \"AC\":\n if var_4[var_6] == 0:\n var_3 += 1\n var_8 += var_9[var_6]\n var_4[var_6] = 1\n else:\n var_9[var_6] += 1\nprint((var_3, var_8))\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\n\nvar_2, var_1, *var_3 = sys.stdin.read().strip().split()\nvar_2 = int(var_2)\nvar_5 = [0] * var_2\nvar_10 = [0] * var_2\nfor var_6, var_8 in zip(*[iter(var_3)] * 2):\n var_6 = int(var_6) - 1\n if var_8 == \"AC\":\n var_5[var_6] = 1\n elif var_5[var_6] == 0:\n var_10[var_6] += 1\nvar_7 = sum([var_9 * var_4 for var_4, var_9 in zip(var_5, var_10)])\nprint((\"{} {}\".format(sum(var_5), var_7)))\n```", "output": "SLOWER 2.9476", "pair_id": "python_p02802_reversed", "problem_id": "p02802", "language": "python", "direction": "reversed", "speedup_ratio": 7.7147} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\nimport math\nfrom collections import defaultdict\nfrom bisect import bisect_left, bisect_right\n\nsys.setrecursionlimit(10**7)\n\n\ndef func_4():\n return sys.stdin.readline()[:-1]\n\n\nvar_4 = 10**9 + 7\n\n\ndef func_1():\n return int(eval(func_4()))\n\n\ndef func_2():\n return list(map(int, func_4().split()))\n\n\ndef func_3(var_6, var_3):\n if var_6 <= 0:\n return [[] for _ in range(var_3)]\n elif var_3 == 1:\n return [func_1() for _ in range(var_6)]\n else:\n var_5 = [func_2() for _ in range(var_6)]\n return list(map(list, list(zip(*var_5))))\n\n\nvar_1, var_2 = list(map(str, func_4().split()))\nvar_1 = int(var_1)\nvar_2 = 100 * int(var_2[0]) + 10 * int(var_2[2]) + int(var_2[3])\nprint((var_1 * var_2 // 100))\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = input().split()\nvar_1 = int(var_1)\nvar_2 = int(var_2.replace(\".\", \"\"))\nprint((var_1 * var_2 // 100))\n```", "output": "FASTER 2.5828", "pair_id": "python_p02659_forward", "problem_id": "p02659", "language": "python", "direction": "forward", "speedup_ratio": 5.9911} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().rstrip().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = list(map(int, list(str(var_4))))\n if var_5[0] == var_5[4] and var_5[1] == var_5[3]:\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_6 = str(var_4)\n var_5 = var_6[::-1]\n if var_6 == var_5:\n var_3 += 1\nprint(var_3)\n```", "output": "FASTER 1.4326", "pair_id": "python_p03416_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 2.6994} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(str, input().split()))\nvar_1 = int(var_1)\nvar_2 = int(float(var_2) * 1000)\nprint((var_1 * var_2 // 1000))\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\nimport math\nfrom collections import defaultdict\nfrom bisect import bisect_left, bisect_right\n\nsys.setrecursionlimit(10**7)\n\n\ndef func_4():\n return sys.stdin.readline()[:-1]\n\n\nvar_4 = 10**9 + 7\n\n\ndef func_1():\n return int(eval(func_4()))\n\n\ndef func_2():\n return list(map(int, func_4().split()))\n\n\ndef func_3(var_6, var_3):\n if var_6 <= 0:\n return [[] for _ in range(var_3)]\n elif var_3 == 1:\n return [func_1() for _ in range(var_6)]\n else:\n var_5 = [func_2() for _ in range(var_6)]\n return list(map(list, list(zip(*var_5))))\n\n\nfrom decimal import getcontext, Decimal\n\ngetcontext().prec = 28\nvar_1, var_2 = list(map(str, func_4().split()))\nvar_1 = int(var_1)\nvar_2 = Decimal(var_2)\nprint((int(var_1 * var_2)))\n```", "output": "SLOWER 2.3054", "pair_id": "python_p02659_reversed", "problem_id": "p02659", "language": "python", "direction": "reversed", "speedup_ratio": 4.9432} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\ndef func_1():\n var_1, var_3 = input().split()\n var_1 = int(var_1)\n var_3 = int(float(var_3) * 100 + 0.5)\n var_2 = var_1 * var_3\n print((var_2 // 100))\n\n\nif __name__ == \"__main__\":\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\ndef func_1():\n from sys import setrecursionlimit, stdin\n from os import environ\n from collections import defaultdict, deque, Counter\n from math import ceil, floor, gcd\n from itertools import accumulate, combinations, combinations_with_replacement\n\n setrecursionlimit(10**6)\n var_7 = (\n (lambda *var_11: print(*var_11))\n if \"TERM_PROGRAM\" in environ\n else lambda *var_12: 0\n )\n var_8 = lambda: stdin.readline().rstrip()\n var_3 = lambda: list(map(int, var_8().split()))\n var_1 = lambda: int(var_8())\n var_4 = 10**9 + 7\n var_2 = 10**9 + 10\n var_9, var_10 = var_8().split()\n var_5 = int(var_9)\n var_6 = int(float(var_10) * 100 + 0.5)\n print(var_5 * var_6 // 100)\n\n\nfunc_1()\n```", "output": "SLOWER 1.575", "pair_id": "python_p02659_reversed", "problem_id": "p02659", "language": "python", "direction": "reversed", "speedup_ratio": 2.9793} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nfrom sys import stdin\n\n\ndef func_1():\n\n var_9 = stdin.readline\n var_8, var_10 = list(map(int, var_9().split()))\n var_7 = [list(map(int, var_9().split())) for _ in range(var_8)]\n var_7.sort()\n var_1 = [0] * var_8\n var_2 = [0] * var_8\n for var_4 in range(var_8):\n var_1[var_4], var_2[var_4] = var_7[var_4][0], var_7[var_4][1]\n\n var_5 = -(10**9)\n var_3 = [[var_5] * (var_10 + 1) for _ in range(var_8 + 1)]\n var_3[0][0] = 0\n for var_4 in range(var_8):\n for var_6 in range(var_10 + 1):\n\n if var_6 != var_10:\n var_3[var_4 + 1][min(var_10, var_6 + var_1[var_4])] = max(\n var_3[var_4 + 1][min(var_10, var_6 + var_1[var_4])],\n var_3[var_4][var_6] + var_2[var_4],\n )\n\n var_3[var_4 + 1][var_6] = max(var_3[var_4 + 1][var_6], var_3[var_4][var_6])\n print((max(var_3[var_8])))\n\n\nif __name__ == \"__main__\":\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nfrom collections import Counter, defaultdict, deque\nfrom heapq import heappop, heappush, heapify\nimport sys, bisect, math, itertools, fractions, pprint\n\nsys.setrecursionlimit(10**8)\nvar_6 = 10**9 + 7\nvar_1 = float(\"inf\")\n\n\ndef func_1():\n return int(sys.stdin.readline())\n\n\ndef func_2():\n return list(map(int, sys.stdin.readline().split()))\n\n\nvar_8, var_11 = func_2()\nvar_17 = [func_2() for _ in range(var_8)]\nvar_10 = var_17[::-1]\nvar_14 = [[0] * var_11 for _ in range(var_8)]\nvar_3 = [[0] * var_11 for _ in range(var_8)]\nfor var_4 in range(var_8 - 1):\n var_16, var_15 = var_17[var_4]\n for var_5 in range(var_11):\n if var_5 < var_16:\n var_14[var_4 + 1][var_5] = var_14[var_4][var_5]\n else:\n var_14[var_4 + 1][var_5] = max(\n var_14[var_4][var_5], var_14[var_4][var_5 - var_16] + var_15\n )\nvar_9 = var_14[var_8 - 1][var_11 - 1] + var_17[var_8 - 1][1]\nfor var_4 in range(var_8 - 1):\n var_16, var_15 = var_10[var_4]\n for var_5 in range(var_11):\n if var_5 < var_16:\n var_3[var_4 + 1][var_5] = var_3[var_4][var_5]\n else:\n var_3[var_4 + 1][var_5] = max(\n var_3[var_4][var_5], var_3[var_4][var_5 - var_16] + var_15\n )\n var_9 = max(var_9, var_3[var_8 - 1][var_11 - 1] + var_17[0][1])\n\nfor var_4 in range(1, var_8 - 1):\n var_13 = var_4\n var_2 = var_8 - var_4 - 1\n var_7 = 0\n for var_5 in range(var_11):\n var_12 = var_14[var_13][var_5] + var_3[var_2][var_11 - 1 - var_5]\n var_7 = max(var_7, var_12)\n var_9 = max(var_9, var_7 + var_17[var_4][1])\nprint(var_9)\n```", "output": "SLOWER 1.1031", "pair_id": "python_p02863_reversed", "problem_id": "p02863", "language": "python", "direction": "reversed", "speedup_ratio": 2.1481} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\n\nvar_10 = sys.stdin.readline\nvar_2, var_3 = list(map(int, var_10().split()))\nvar_1 = [list(map(int, var_10().split())) for _ in range(var_2)]\nvar_8 = [[0 for _ in range(var_2 + 1)] for _ in range(var_3 + 1)]\n\nvar_13 = [[0 for _ in range(var_2 + 1)] for _ in range(var_3 + 1)]\nfor var_11 in range(var_2):\n var_4, var_6 = var_1[var_11]\n for var_15 in range(var_3):\n if var_4 > var_15:\n var_8[var_15][var_11 + 1] = var_8[var_15][var_11]\n var_13[var_15][var_11 + 1] = var_15\n else:\n if var_6 + var_8[var_15 - var_4][var_11] >= var_8[var_15][var_11]:\n var_8[var_15][var_11 + 1] = var_8[var_15 - var_4][var_11] + var_6\n var_13[var_15][var_11 + 1] = var_15 - var_4\n else:\n var_8[var_15][var_11 + 1] = var_8[var_15][var_11]\n var_13[var_15][var_11 + 1] = var_15\nvar_5 = var_8[var_3 - 1][var_2]\nvar_14 = [False] * var_2\nvar_7 = var_3 - 1\nfor var_9 in reversed(list(range(var_2))):\n if var_13[var_7][var_9 + 1] == var_7 - var_1[var_9][0]:\n var_14[var_9] = True\n var_7 = var_13[var_7][var_9 + 1]\nvar_12 = 0\nfor var_9 in range(var_2):\n if not var_14[var_9] and var_1[var_9][1] > var_12:\n var_12 = var_1[var_9][1]\nprint((var_5 + var_12))\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\nfrom operator import itemgetter\nfrom heapq import heapify, heappop, heappush\n\nvar_1 = int(10e15)\nvar_2 = -var_1\nvar_11 = 1000000007\nsys.setrecursionlimit(1000000)\n\n\ndef func_2():\n return list(map(int, input().split()))\n\n\ndef func_4():\n return input().split()\n\n\ndef func_1():\n return int(sys.stdin.readline())\n\n\ndef func_3():\n return eval(input())\n\n\nvar_3, var_4 = func_2()\nvar_5 = [func_2() for var_9 in range(var_3)]\nvar_5.sort(key=itemgetter(0))\n\nvar_8 = [[0] * (var_4 + 1 + 3000 + 1) for _ in range(var_3 + 1)]\nvar_6 = 0\nfor var_9 in range(var_3):\n for var_10 in range(var_4 + 1 + 3000 + 1):\n var_12, var_7 = var_5[var_9]\n if 0 <= var_10 - var_12 < var_4:\n var_8[var_9 + 1][var_10] = max(\n var_8[var_9][var_10], var_8[var_9][var_10 - var_12] + var_7\n )\n else:\n var_8[var_9 + 1][var_10] = var_8[var_9][var_10]\n var_6 = max(var_6, var_8[var_9 + 1][var_10])\nprint(var_6)\n```", "output": "SLOWER 4.3309", "pair_id": "python_p02863_reversed", "problem_id": "p02863", "language": "python", "direction": "reversed", "speedup_ratio": 20.1241} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\n\"\"\"\"\"\"\n\nfrom collections import deque\n\n\ndef func_1():\n var_5, *var_1 = list(map(int, open(0).read().split()))\n var_2 = var_1[1::2]\n var_4 = [[] for _ in range(var_5 + 1)]\n for var_7, var_8 in zip(*[iter(var_1)] * 2):\n var_4[var_7] += (var_8,)\n var_6 = deque([1])\n var_3 = [0] * (var_5 + 1)\n while var_6:\n var_11 = var_6.popleft()\n var_9 = 0\n for var_10 in var_4[var_11]:\n var_9 += 1 + (var_9 + 1 == var_3[var_11])\n var_3[var_10] = var_9\n var_6 += (var_10,)\n print((max(var_3)))\n for var_8 in var_2:\n print((var_3[var_8]))\n\n\nfunc_1()\n```\n\n=== Code B (Modified) ===\n```python\nvar_11 = int(eval(input()))\nvar_12 = {var_8: [] for var_8 in range(1, var_11 + 1)}\nvar_19 = [False for var_8 in range(var_11 + 1)]\nvar_16 = []\nfor _ in range(var_11 - 1):\n var_2, var_3 = list(map(int, input().split()))\n var_12[var_2].append(var_3)\n var_12[var_3].append(var_2)\n var_16.append((var_2, var_3))\nvar_9 = var_16[0][0]\nvar_19[var_9] = True\nvar_6 = []\nvar_7 = []\nvar_14 = {var_8: {} for var_8 in range(1, var_11 + 1)}\nvar_10 = [0 for var_8 in range(var_11 + 1)]\n\nvar_4 = 1\nfor var_5 in var_12[var_9]:\n var_19[var_5] = True\n var_14[var_9][var_5] = var_4\n var_14[var_5][var_9] = var_4\n var_10[var_5] = var_4\n var_4 += 1\n var_6.append(var_5)\nwhile var_6:\n for var_15 in var_6:\n var_13 = 1\n for var_5 in var_12[var_15]:\n if var_19[var_5] == False:\n var_19[var_5] = True\n if var_13 != var_10[var_15]:\n var_14[var_15][var_5] = var_13\n var_14[var_5][var_15] = var_13\n var_10[var_5] = var_13\n var_13 += 1\n var_7.append(var_5)\n else:\n var_13 += 1\n var_14[var_15][var_5] = var_13\n var_14[var_5][var_15] = var_13\n var_10[var_5] = var_13\n var_13 += 1\n var_7.append(var_5)\n if var_7:\n var_6 = var_7\n var_7 = []\n else:\n var_6 = []\n var_7 = []\nvar_1 = 0\nfor var_8 in range(1, var_11 + 1):\n var_1 = max(var_1, len(var_12[var_8]))\nprint(var_1)\nfor var_8 in range(var_11 - 1):\n var_17, var_18 = var_16[var_8][0], var_16[var_8][1]\n print((var_14[var_17][var_18]))\n```", "output": "SLOWER 1.0038", "pair_id": "python_p02850_reversed", "problem_id": "p02850", "language": "python", "direction": "reversed", "speedup_ratio": 2.0053} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nfrom functools import *\n\n_, var_1 = open(0)\nprint(\n (\n \"YNeos\"[\n var_2(lambda var_3, var_4: var_3 ^ var_4, list(map(int, var_1.split())))\n > 0 :: 2\n ]\n )\n)\n```\n\n=== Code B (Modified) ===\n```python\ndef func_1():\n from collections import Counter\n\n var_4 = int(eval(input()))\n (*var_1,) = list(map(int, input().split()))\n if var_4 % 3 == 0:\n var_2 = Counter(var_1)\n if len(var_2) == 1:\n print((\"Yes\" if 0 in var_2 else \"No\"))\n return\n elif len(var_2) == 2:\n print((\"Yes\" if var_2[0] == var_4 // 3 else \"No\"))\n return\n elif len(var_2) == 3:\n var_7 = 0\n var_5 = None\n for var_3, var_6 in list(var_2.items()):\n if var_5 is None:\n var_5 = var_6\n elif var_5 != var_6:\n print(\"No\")\n return\n var_7 ^= var_3\n print((\"Yes\" if var_7 == 0 else \"No\"))\n return\n else:\n print(\"No\")\n return\n else:\n print((\"Yes\" if all([var_7 == 0 for var_7 in var_1]) else \"No\"))\n return\n\n\nif __name__ == \"__main__\":\n func_1()\n```", "output": "SLOWER 1.4188", "pair_id": "python_p02975_reversed", "problem_id": "p02975", "language": "python", "direction": "reversed", "speedup_ratio": 2.6736} -{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\ndef func_1():\n from sys import setrecursionlimit, stdin\n from os import environ\n from collections import defaultdict, deque, Counter\n from math import ceil, floor, gcd\n from itertools import accumulate, combinations, combinations_with_replacement\n\n setrecursionlimit(10**6)\n var_7 = (\n (lambda *var_11: print(*var_11))\n if \"TERM_PROGRAM\" in environ\n else lambda *var_12: 0\n )\n var_8 = lambda: stdin.readline().rstrip()\n var_3 = lambda: list(map(int, var_8().split()))\n var_1 = lambda: int(var_8())\n var_4 = 10**9 + 7\n var_2 = 10**9 + 10\n var_9, var_10 = var_8().split()\n var_5 = int(var_9)\n var_6 = int(float(var_10) * 100 + 0.5)\n print(var_5 * var_6 // 100)\n\n\nfunc_1()\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\n\nvar_3 = sys.stdin.readline\nif __name__ == \"__main__\":\n var_1, var_2 = var_3().split()\n print((int(var_1) * round(float(var_2) * 100) // 100))\n```", "output": "FASTER 1.9665", "pair_id": "python_p02659_forward", "problem_id": "p02659", "language": "python", "direction": "forward", "speedup_ratio": 3.9083} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_4 = str(var_4)\n if var_4[0] == var_4[-1] and var_4[1] == var_4[-2]:\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_6 in range(var_1, var_2 + 1):\n var_3 = str(var_6)\n var_5 = True\n for var_7 in range(len(var_3) // 2):\n if var_3[var_7] != var_3[-var_7 - 1] and var_5:\n var_5 = not var_5\n if var_5:\n var_4 += 1\nprint(var_4)\n```", "output": "SLOWER 1.6437", "pair_id": "python_p03416_pair0001_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 3.1246} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n if list(str(var_4)) == list(reversed(str(var_4))):\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\ndef func_1():\n var_1, var_2 = list(map(int, input().rstrip().split()))\n var_3 = 0\n for var_4 in range(var_1, var_2 + 1):\n var_5 = str(var_4)\n if var_5 == var_5[::-1]:\n var_3 += 1\n print(var_3)\n\n\nif __name__ == \"__main__\":\n func_1()\n```", "output": "FASTER 2.1464", "pair_id": "python_p03416_pair0002_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 4.4271} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().strip().split(\" \")))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n if str(var_4) == str(var_4)[::-1]:\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n if list(str(var_4)) == list(reversed(str(var_4))):\n var_3 += 1\nprint(var_3)\n```", "output": "SLOWER 1.0931", "pair_id": "python_p03416_pair0003_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 2.1333} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\n\nvar_5 = sys.stdin.readline\n\n\ndef func_1():\n var_3 = var_5().rstrip()\n var_11 = [\"dream\", \"dreamer\", \"erase\", \"eraser\"]\n var_9 = \"YES\"\n var_7 = var_3\n var_6 = var_3\n while True:\n for var_4 in range(4):\n var_10 = var_11[var_4]\n var_2 = len(var_10)\n var_1 = len(var_6)\n if var_2 <= var_1:\n var_8 = var_6[var_1 - var_2 :]\n if var_8 == var_10:\n var_6 = var_6[: var_1 - var_2]\n if var_6 == \"\":\n break\n elif var_6 == var_7:\n var_9 = \"NO\"\n break\n else:\n var_7 = var_6\n print(var_9)\n\n\nfunc_1()\n```\n\n=== Code B (Modified) ===\n```python\nvar_1 = (\n input()\n .replace(\"eraser\", \" \")\n .replace(\"erase\", \" \")\n .replace(\"dreamer\", \" \")\n .replace(\"dream\", \" \")\n .replace(\" \", \"\")\n)\nif var_1:\n print(\"NO\")\nelse:\n print(\"YES\")\n```", "output": "FASTER 1.396", "pair_id": "python_p03854_pair0001_forward", "problem_id": "p03854", "language": "python", "direction": "forward", "speedup_ratio": 2.6318} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_6 = str(var_4)\n var_5 = var_6[::-1]\n if var_6 == var_5:\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_3 in range(var_1, var_2 + 1):\n var_5 = list(str(var_3))\n var_6 = list(reversed(var_5))\n if var_5 == var_6:\n var_4 += 1\nprint(var_4)\n```", "output": "SLOWER 1.0582", "pair_id": "python_p03416_pair0004_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 2.0824} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_6, var_5 = list(map(int, input().split()))\nvar_8 = [[] for _ in range(var_6)]\nfor var_2 in range(var_5):\n var_10, var_11 = input().split()\n var_8[int(var_10) - 1].append(var_11)\n\nvar_1, var_7 = 0, 0\nfor var_3 in range(var_6):\n var_9 = var_8[var_3]\n if \"AC\" in var_9:\n var_1 += 1\n for var_4 in var_9:\n if var_4 == \"WA\":\n var_7 += 1\n else:\n break\nprint((var_1, var_7))\n```\n\n=== Code B (Modified) ===\n```python\nvar_2, var_1 = list(map(int, input().split()))\nvar_6 = {}\nvar_3 = {}\nfor var_4 in range(var_1):\n var_5, var_7 = input().split()\n var_5 = int(var_5)\n if not var_5 in var_6:\n var_6[var_5] = 0\n var_3[var_5] = 0\n if var_7 == \"WA\" and var_3[var_5] == 0:\n var_6[var_5] += 1\n elif var_7 == \"AC\" and var_3[var_5] == 0:\n var_3[var_5] += 1\nfor var_4 in var_6:\n if var_6[var_4] != 0 and var_3[var_4] == 0:\n var_6[var_4] = 0\nprint((sum(var_3.values()), sum(var_6.values())))\n```", "output": "FASTER 4.403", "pair_id": "python_p02802_pair0001_forward", "problem_id": "p02802", "language": "python", "direction": "forward", "speedup_ratio": 21.1554} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\ndef func_1():\n var_1, var_2 = list(map(int, input().split()))\n var_3 = 0\n for var_4 in range(var_1, var_2 + 1):\n\n if (var_4 % 10) == (var_4 // 10000 % 10) and (var_4 // 10 % 10) == (\n var_4 // 1000 % 10\n ):\n var_3 += 1\n print(var_3)\n\n\nif __name__ == \"__main__\":\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\n\n\ndef func_1(var_5, var_6):\n var_4 = 0\n for var_3 in range(var_5, var_6 + 1):\n if str(var_3) == str(var_3)[::-1]:\n var_4 += 1\n return var_4\n\n\nprint((func_1(var_1, var_2)))\n```", "output": "SLOWER 1.3404", "pair_id": "python_p03416_pair0005_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 2.5323} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_5 = input()[::-1]\nvar_2 = [0] * 2019\nvar_2[0] = 1\nvar_4 = 0\nvar_6 = 1\nvar_1 = 0\nfor var_3 in var_5:\n var_4 = (var_4 + int(var_3) * var_6) % 2019\n var_6 = var_6 * 10 % 2019\n var_2[var_4] += 1\nfor var_3 in var_2:\n var_1 += var_3 * (var_3 - 1) // 2\nprint(var_1)\n```\n\n=== Code B (Modified) ===\n```python\nimport numpy as np\n\nvar_7 = input()[::-1]\nvar_6 = len(var_7)\nvar_1 = np.zeros(var_6, dtype=int)\nvar_4 = np.zeros(var_6, dtype=int)\nvar_2 = np.zeros(2019, dtype=int)\nvar_8 = 10\nvar_1[0] = int(var_7[0])\nvar_4[0] = var_1[0]\nvar_2[var_4[0]] += 1\nfor var_5 in range(1, var_6):\n var_1[var_5] = int(var_7[var_5]) * var_8 % 2019\n var_4[var_5] = (var_4[var_5 - 1] + var_1[var_5]) % 2019\n var_2[var_4[var_5]] += 1\n var_8 = var_8 * 10 % 2019\nvar_3 = var_2[np.nonzero(var_2)]\nprint(\n (\n int(\n sum([var_3[var_5] * (var_3[var_5] - 1) for var_5 in range(var_3.shape[0])])\n / 2\n )\n + var_2[0]\n )\n)\n```", "output": "FASTER 1.2996", "pair_id": "python_p02702_pair0001_forward", "problem_id": "p02702", "language": "python", "direction": "forward", "speedup_ratio": 2.4616} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nfrom collections import Counter, defaultdict, deque\nfrom heapq import heappop, heappush, heapify\nimport sys, bisect, math, itertools, fractions, pprint\n\nsys.setrecursionlimit(10**8)\nvar_6 = 10**9 + 7\nvar_1 = float(\"inf\")\n\n\ndef func_1():\n return int(sys.stdin.readline())\n\n\ndef func_2():\n return list(map(int, sys.stdin.readline().split()))\n\n\nvar_7, var_9 = func_2()\nvar_13 = [func_2() for _ in range(var_7)]\nvar_13.sort(key=lambda var_14: var_14[1], reverse=True)\nvar_8 = 0\nvar_10 = min(var_7, 5)\nfor var_3 in range(var_10):\n var_2 = [[0] * (var_9 + 5) for _ in range(var_7 + 5)]\n for var_4 in range(var_7):\n var_12, var_11 = var_13[var_4]\n for var_5 in range(var_9):\n if var_5 < var_12 or var_3 == var_4:\n var_2[var_4 + 1][var_5] = var_2[var_4][var_5]\n else:\n var_2[var_4 + 1][var_5] = max(\n var_2[var_4][var_5], var_2[var_4][var_5 - var_12] + var_11\n )\n\n var_8 = max(var_2[var_7][var_9 - 1] + var_13[var_3][1], var_8)\nprint(var_8)\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\n\nvar_9 = sys.stdin.readline\nfrom operator import itemgetter\n\nvar_3, var_4 = list(map(int, var_9().split()))\nvar_1 = [list(map(int, var_9().split())) for _ in range(var_3)]\nvar_1.sort(key=itemgetter(0))\nvar_8 = [[0 for _ in range(var_3 + 1)] for _ in range(var_4 + 1)]\n\nvar_2 = []\nfor var_10 in range(var_3):\n var_5, var_7 = var_1[var_10]\n for var_11 in range(var_4):\n if var_5 > var_11:\n var_8[var_11][var_10 + 1] = var_8[var_11][var_10]\n else:\n if var_7 + var_8[var_11 - var_5][var_10] >= var_8[var_11][var_10]:\n var_8[var_11][var_10 + 1] = var_8[var_11 - var_5][var_10] + var_7\n else:\n var_8[var_11][var_10 + 1] = var_8[var_11][var_10]\n var_2.append(var_8[var_4 - 1][var_10] + var_7)\nvar_6 = max(var_2)\nprint(var_6)\n```", "output": "FASTER 1.6625", "pair_id": "python_p02863_pair0001_forward", "problem_id": "p02863", "language": "python", "direction": "forward", "speedup_ratio": 3.1657} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_6, var_7 = list(map(int, input().split()))\nvar_1 = [list(map(int, input().split())) for _ in range(var_6)]\nvar_1.sort()\nvar_3 = [(6007) * [0] for _ in range(var_6 + 1)]\nvar_3[0][0] = 0\nvar_2 = 0\nfor var_4 in range(var_6):\n for var_5 in range(6007):\n var_3[var_4 + 1][var_5] = max(var_3[var_4 + 1][var_5], var_3[var_4][var_5])\n if var_5 < var_7:\n var_3[var_4 + 1][var_5 + var_1[var_4][0]] = max(\n var_3[var_4][var_5] + var_1[var_4][1],\n var_3[var_4][var_5 + var_1[var_4][0]],\n )\n var_2 = max(var_2, var_3[var_4 + 1][var_5])\nprint(var_2)\n```\n\n=== Code B (Modified) ===\n```python\nvar_8, var_9 = list(map(int, input().split()))\nvar_5 = [[0] * (var_9 + 3001) for _ in range(var_8 + 1)]\nvar_3 = 0\nvar_2 = [list(map(int, input().split())) for _ in range(var_8)]\nvar_2.sort()\nfor var_6 in range(1, var_8 + 1):\n var_1, var_4 = var_2[var_6 - 1]\n for var_7 in range(var_9):\n var_5[var_6][var_7] = max(var_5[var_6 - 1][var_7], var_5[var_6][var_7])\n var_5[var_6][var_7 + var_1] = var_5[var_6 - 1][var_7] + var_4\n var_3 = max(var_5[var_6][var_7], var_5[var_6][var_7 + var_1], var_3)\nprint(var_3)\n```", "output": "FASTER 5.2101", "pair_id": "python_p02863_pair0002_forward", "problem_id": "p02863", "language": "python", "direction": "forward", "speedup_ratio": 37.0168} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_5 in range(10):\n for var_6 in range(10):\n for var_7 in range(10):\n var_3 = 10000 * var_5 + 1000 * var_6 + 100 * var_7 + 10 * var_6 + var_5\n if var_1 <= var_3 <= var_2:\n var_4 += 1\nprint(var_4)\n```\n\n=== Code B (Modified) ===\n```python\nvar_10 = []\nvar_10 = input().rstrip().split(\" \")\nvar_1 = int(var_10[0])\nvar_3 = int(var_10[1])\nvar_2 = 0\nvar_6 = var_1\nwhile var_6 <= var_3:\n var_4 = var_6 // 10000\n var_5 = (var_6 - var_4 * 10000) // 1000\n var_7 = var_6 // 100\n var_8 = (var_6 - var_7 * 100) // 10\n var_9 = var_6 % 10\n if (var_4 == var_9) and (var_5 == var_8):\n var_2 += 1\n var_6 += 1\nprint(var_2)\n```", "output": "SLOWER 4.6346", "pair_id": "python_p03416_pair0006_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 24.8395} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_3 = list(map(int, input().split()))\nvar_2 = 0\nfor var_5 in range(var_3 + 1)[var_1:]:\n if len(str(var_5)) % 2 == 0:\n var_6 = list(str(var_5))[: len(str(var_5)) // 2]\n var_7 = list(reversed(list(str(var_5))[len(str(var_5)) // 2 :]))\n if var_6 == var_7:\n var_2 += 1\n else:\n var_8 = list(str(var_5))[: len(str(var_5)) // 2 + 1]\n var_4 = list(reversed(list(str(var_5))[len(str(var_5)) // 2 :]))\n if var_8 == var_4:\n var_2 += 1\nprint(var_2)\n```\n\n=== Code B (Modified) ===\n```python\nvar_4, var_3 = list(map(int, input().split()))\nvar_1 = 0\nfor var_2 in range(var_4, var_3 + 1):\n if str(var_2)[0] + str(var_2)[1] == str(var_2)[-1] + str(var_2)[-2]:\n var_1 += 1\nprint(var_1)\n```", "output": "FASTER 1.1334", "pair_id": "python_p03416_pair0007_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 2.1938} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_8, var_9 = list(map(int, input().split()))\nvar_5 = [[0] * (var_9 + 3001) for _ in range(var_8 + 1)]\nvar_3 = 0\nvar_2 = [list(map(int, input().split())) for _ in range(var_8)]\nvar_2.sort()\nfor var_6 in range(1, var_8 + 1):\n var_1, var_4 = var_2[var_6 - 1]\n for var_7 in range(var_9):\n var_5[var_6][var_7] = max(var_5[var_6 - 1][var_7], var_5[var_6][var_7])\n var_5[var_6][var_7 + var_1] = var_5[var_6 - 1][var_7] + var_4\n var_3 = max(var_5[var_6][var_7], var_5[var_6][var_7 + var_1], var_3)\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\n\nsys.setrecursionlimit(2147483647)\nvar_2 = float(\"inf\")\nvar_3 = 10**9 + 7\nvar_10 = lambda: sys.stdin.readline().rstrip()\n\n\ndef func_1():\n var_11, var_4 = list(map(int, var_10().split()))\n var_1 = [tuple(map(int, var_10().split())) for _ in range(var_11)]\n var_1.sort()\n var_8 = [0] * var_4\n var_6 = -var_2\n for var_9 in range(var_11):\n var_5, var_7 = var_1[var_9]\n var_12 = var_8[:]\n for var_13 in range(var_4):\n if var_13 + var_5 < var_4:\n var_12[var_13 + var_5] = max(\n var_12[var_13 + var_5], var_8[var_13] + var_7\n )\n else:\n var_6 = max(var_6, var_8[var_13] + var_7)\n var_8 = var_12\n print((max(var_6, max(var_8))))\n\n\nfunc_1()\n```", "output": "FASTER 1.5497", "pair_id": "python_p02863_pair0003_forward", "problem_id": "p02863", "language": "python", "direction": "forward", "speedup_ratio": 2.9276} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = [\n var_3 for var_3 in map(str, list(range(var_1, var_2 + 1))) if var_3 == var_3[::-1]\n]\nprint((len(var_4)))\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_3 in range(var_1, var_2 + 1):\n var_5 = list(str(var_3))\n var_6 = list(reversed(var_5))\n if var_5 == var_6:\n var_4 += 1\nprint(var_4)\n```", "output": "SLOWER 2.0072", "pair_id": "python_p03416_pair0008_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 4.02} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\nimport math\nfrom collections import defaultdict\nfrom bisect import bisect_left, bisect_right\n\nsys.setrecursionlimit(10**7)\n\n\ndef func_4():\n return sys.stdin.readline()[:-1]\n\n\nvar_4 = 10**9 + 7\n\n\ndef func_1():\n return int(eval(func_4()))\n\n\ndef func_2():\n return list(map(int, func_4().split()))\n\n\ndef func_3(var_6, var_3):\n if var_6 <= 0:\n return [[] for _ in range(var_3)]\n elif var_3 == 1:\n return [func_1() for _ in range(var_6)]\n else:\n var_5 = [func_2() for _ in range(var_6)]\n return list(map(list, list(zip(*var_5))))\n\n\nvar_1, var_2 = list(map(str, func_4().split()))\nvar_1 = int(var_1)\nvar_2 = 100 * int(var_2[0]) + 10 * int(var_2[2]) + int(var_2[3])\nprint((var_1 * var_2 // 100))\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(str, input().split()))\nvar_1 = int(var_1)\nvar_2 = int(float(var_2) * 1000)\nprint((var_1 * var_2 // 1000))\n```", "output": "FASTER 2.3246", "pair_id": "python_p02659_pair0001_forward", "problem_id": "p02659", "language": "python", "direction": "forward", "speedup_ratio": 5.0091} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport bisect, copy, heapq, math, sys\nfrom collections import *\nfrom functools import lru_cache\nfrom itertools import accumulate, combinations, permutations, product\n\n\ndef func_2():\n return sys.stdin.readline()[:-1]\n\n\ndef func_4(var_8):\n return [0] + list(accumulate(var_8))\n\n\ndef func_1(var_1, var_4):\n return -(-var_1 // var_4)\n\n\nsys.setrecursionlimit(5000000)\nvar_9 = pow(10, 9) + 7\nvar_2 = [chr(ord(\"a\") + var_6) for var_6 in range(26)]\nvar_5 = [[1, 0], [0, 1], [-1, 0], [0, -1]]\nvar_11 = int(eval(func_2()))\n\n\ndef func_3(var_10):\n if var_10 == 1:\n return False\n for var_7 in range(2, int(math.sqrt(var_10)) + 1):\n if var_10 % var_7 == 0:\n return False\n return True\n\n\nvar_3 = var_11\nwhile not func_3(var_3):\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_4 = int(eval(input()))\nvar_1 = 0\nif var_4 == 2:\n print((2))\nelse:\n for var_2 in range(var_4, 10**6):\n for var_3 in range(2, var_2 // 2 + 2):\n if var_2 % var_3 == 0:\n break\n else:\n var_1 = var_2\n break\n print(var_1)\n```", "output": "FASTER 1.4219", "pair_id": "python_p02819_pair0001_forward", "problem_id": "p02819", "language": "python", "direction": "forward", "speedup_ratio": 2.6793} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\ndef func_1():\n from sys import setrecursionlimit, stdin\n from os import environ\n from collections import defaultdict, deque, Counter\n from math import ceil, floor, gcd\n from itertools import accumulate, combinations, combinations_with_replacement\n\n setrecursionlimit(10**6)\n var_7 = (\n (lambda *var_11: print(*var_11))\n if \"TERM_PROGRAM\" in environ\n else lambda *var_12: 0\n )\n var_8 = lambda: stdin.readline().rstrip()\n var_3 = lambda: list(map(int, var_8().split()))\n var_1 = lambda: int(var_8())\n var_4 = 10**9 + 7\n var_2 = 10**9 + 10\n var_9, var_10 = var_8().split()\n var_5 = int(var_9)\n var_10 = var_10.split(\".\")\n var_6 = int(var_10[0]) * 100\n if len(var_10) == 2:\n var_6 += int(var_10[1])\n print(var_5 * var_6 // 100)\n\n\nfunc_1()\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = input().split()\nvar_1 = int(var_1)\nvar_3, var_4 = list(map(int, var_2.split(\".\")))\nvar_5 = var_1 * (var_3 * 100 + var_4)\nprint((int(var_5 // 100)))\n```", "output": "FASTER 1.9258", "pair_id": "python_p02659_pair0002_forward", "problem_id": "p02659", "language": "python", "direction": "forward", "speedup_ratio": 3.7995} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_4, var_3 = list(map(int, input().split()))\nvar_1 = 0\nfor var_2 in range(var_4, var_3 + 1):\n if str(var_2)[0] + str(var_2)[1] == str(var_2)[-1] + str(var_2)[-2]:\n var_1 += 1\nprint(var_1)\n```\n\n=== Code B (Modified) ===\n```python\nfrom sys import stdin\n\nvar_6 = lambda: list(map(int, stdin.readline().split()))\nvar_5 = lambda: list(map(int, stdin.readline().split()))\nvar_1, var_3 = var_6()\nvar_2 = 0\nfor var_4 in range(var_1, var_3 + 1):\n var_7 = str(var_4)\n if var_7 == var_7[::-1]:\n var_2 += 1\nprint(var_2)\n```", "output": "FASTER 1.3227", "pair_id": "python_p03416_pair0009_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 2.5013} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\ndef func_1():\n var_2 = int(eval(input()))\n var_1 = [int(var_6) for var_6 in input().split()]\n var_4 = 3**var_2\n var_5 = len([var_3 for var_3 in var_1 if var_3 % 2 == 0])\n var_4 -= 2**var_5\n print(var_4)\n\n\nif __name__ == \"__main__\":\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nimport math\nimport string\n\n\ndef func_5():\n return list(map(int, input().split()))\n\n\ndef func_4(var_7, var_8):\n return math.factorial(var_7) // (\n math.factorial(var_7 - var_8) * math.factorial(var_8)\n )\n\n\ndef func_3(var_10):\n var_9 = []\n for var_5 in var_10:\n if not (var_5 in var_9):\n var_9.append(var_5)\n return len(var_10) != len(var_9)\n\n\ndef func_1(var_7):\n func_1 = []\n for var_4 in range(1, var_7 + 1):\n if var_7 % var_4 == 0:\n func_1.append(var_4)\n return func_1\n\n\nvar_2 = [-1, -1, -1, 0, 0, 1, 1, 1]\nvar_3 = [-1, 0, 1, -1, 1, -1, 0, 1]\nvar_7 = int(eval(input()))\nvar_1 = func_5()\n\n\ndef func_2(var_6):\n if len(var_6) == var_7:\n for var_4 in range(len(var_6)):\n if var_6[var_4] % 2 == 0:\n return 1\n return 0\n return (\n func_2(var_6 + [var_1[len(var_6)]])\n + func_2(var_6 + [var_1[len(var_6)] - 1])\n + func_2(var_6 + [var_1[len(var_6)] + 1])\n )\n\n\nprint((func_2([])))\n```", "output": "SLOWER 7.1332", "pair_id": "python_p03568_pair0001_reversed", "problem_id": "p03568", "language": "python", "direction": "reversed", "speedup_ratio": 140.3806} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_7 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_3 = True\n var_8 = str(var_4)\n var_6 = len(var_8)\n for var_5 in range(var_6 // 2 + 1):\n if var_8[var_5] != var_8[-var_5 - 1]:\n var_3 = False\n break\n if var_3:\n var_7 += 1\nprint(var_7)\n```\n\n=== Code B (Modified) ===\n```python\nvar_4 = {}\nvar_5 = 0\nfor var_6 in range(10000, 100000):\n var_3 = list(str(var_6))\n if var_3 == list(reversed(var_3)):\n var_5 += 1\n var_4[var_6] = var_5\nvar_1, var_2 = list(map(int, input().split()))\nprint((var_4[var_2] - var_4[var_1 - 1] if var_1 > 10000 else var_4[var_2]))\n```", "output": "SLOWER 2.4485", "pair_id": "python_p03416_pair0010_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 5.4585} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_6, var_7 = list(map(int, input().split()))\nvar_1 = [list(map(int, input().split())) for _ in range(var_6)]\nvar_1.sort()\nvar_3 = [(6007) * [0] for _ in range(var_6 + 1)]\nvar_3[0][0] = 0\nvar_2 = 0\nfor var_4 in range(var_6):\n for var_5 in range(6007):\n var_3[var_4 + 1][var_5] = max(var_3[var_4 + 1][var_5], var_3[var_4][var_5])\n if var_5 < var_7:\n var_3[var_4 + 1][var_5 + var_1[var_4][0]] = max(\n var_3[var_4][var_5] + var_1[var_4][1],\n var_3[var_4][var_5 + var_1[var_4][0]],\n )\n var_2 = max(var_2, var_3[var_4 + 1][var_5])\nprint(var_2)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_6 = sorted([list(map(int, input().split())) for var_5 in range(var_1)])\n\nvar_4 = [[0] * (var_2 + 1) for var_5 in range(var_1 + 1)]\n\nfor var_5 in range(var_1):\n var_9, var_8 = var_6[var_5]\n for var_7 in range(var_2 + 1):\n if var_7 + var_9 <= var_2:\n var_4[var_5 + 1][var_7 + var_9] = max(\n var_4[var_5 + 1][var_7 + var_9], var_4[var_5][var_7] + var_8\n )\n var_4[var_5 + 1][var_7] = max(var_4[var_5][var_7], var_4[var_5 + 1][var_7])\nvar_3 = 0\nfor var_5, (var_9, var_8) in enumerate(var_6):\n for var_7 in range(var_2):\n var_3 = max(var_3, var_4[var_5][var_7] + var_8)\nprint(var_3)\n```", "output": "FASTER 4.9584", "pair_id": "python_p02863_pair0004_forward", "problem_id": "p02863", "language": "python", "direction": "forward", "speedup_ratio": 31.0909} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nfrom math import floor\n\nvar_1, var_2 = list(map(int, input().split()))\n\n\nfor var_3 in range(1010):\n if (floor(var_3 * 0.08) == var_1) and (floor(var_3 * 0.1) == var_2):\n\n print(var_3)\n quit()\n\n\nprint((-1))\n```\n\n=== Code B (Modified) ===\n```python\nimport math\n\nvar_1, var_4 = (int(var_10) for var_10 in input().split())\nvar_2 = math.ceil(var_1 / 0.08)\nvar_3 = math.ceil((var_1 + 1) / 0.08)\n\"\"\"\"\"\"\nvar_5 = math.ceil(var_4 / 0.1)\nvar_6 = math.ceil((var_4 + 1) / 0.1)\n\"\"\"\"\"\"\nvar_7 = list(range(var_2, var_3))\nvar_8 = list(range(var_5, var_6))\nvar_9 = set(var_7) & set(var_8)\nif len(var_9) == 0:\n print((-1))\nelse:\n print((min(var_9)))\n```", "output": "FASTER 1.1204", "pair_id": "python_p02755_pair0001_forward", "problem_id": "p02755", "language": "python", "direction": "forward", "speedup_ratio": 2.1741} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nfrom sys import stdin\n\nvar_6 = lambda: list(map(int, stdin.readline().split()))\nvar_5 = lambda: list(map(int, stdin.readline().split()))\nvar_1, var_3 = var_6()\nvar_2 = 0\nfor var_4 in range(var_1, var_3 + 1):\n var_7 = str(var_4)\n if var_7 == var_7[::-1]:\n var_2 += 1\nprint(var_2)\n```\n\n=== Code B (Modified) ===\n```python\ndef func_1():\n var_1, var_2 = list(map(int, input().split()))\n var_3 = 0\n for var_4 in range(var_1, var_2 + 1):\n\n if (var_4 % 10) == (var_4 // 10000 % 10) and (var_4 // 10 % 10) == (\n var_4 // 1000 % 10\n ):\n var_3 += 1\n print(var_3)\n\n\nif __name__ == \"__main__\":\n func_1()\n```", "output": "FASTER 1.6824", "pair_id": "python_p03416_pair0011_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 3.2097} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = list(reversed(list(str(var_4))))\n if var_5 == list(str(var_4)):\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_4 = str(var_4)\n if var_4 == var_4[::-1]:\n var_3 += 1\nprint(var_3)\n```", "output": "FASTER 1.5099", "pair_id": "python_p03416_pair0012_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 2.848} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_7 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_3 = True\n var_8 = str(var_4)\n var_6 = len(var_8)\n for var_5 in range(var_6 // 2 + 1):\n if var_8[var_5] != var_8[-var_5 - 1]:\n var_3 = False\n break\n if var_3:\n var_7 += 1\nprint(var_7)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1 = list(map(int, input().split()))\nvar_2 = 0\nfor var_3 in range(var_1[0], var_1[1] + 1):\n var_4 = str(var_3)\n if var_4[0] == var_4[4] and var_4[1] == var_4[3]:\n var_2 += 1\nprint(var_2)\n```", "output": "FASTER 1.4139", "pair_id": "python_p03416_pair0013_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 2.6646} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_5 in range(10):\n for var_6 in range(10):\n for var_7 in range(10):\n var_3 = 10000 * var_5 + 1000 * var_6 + 100 * var_7 + 10 * var_6 + var_5\n if var_1 <= var_3 <= var_2:\n var_4 += 1\nprint(var_4)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1 = list(map(int, input().split()))\nvar_2 = 0\nfor var_3 in range(var_1[0], var_1[1] + 1):\n var_4 = str(var_3)\n if var_4[0] == var_4[4] and var_4[1] == var_4[3]:\n var_2 += 1\nprint(var_2)\n```", "output": "SLOWER 3.5367", "pair_id": "python_p03416_pair0014_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 11.6056} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nfrom decimal import Decimal\nimport math\n\nvar_1, var_2 = list(map(str, input().split()))\nvar_1 = int(var_1)\nvar_2 = Decimal(var_2)\nvar_3 = math.floor(var_1 * var_2)\nprint((int(var_3)))\n```\n\n=== Code B (Modified) ===\n```python\ndef func_1():\n from sys import setrecursionlimit, stdin\n from os import environ\n from collections import defaultdict, deque, Counter\n from math import ceil, floor, gcd\n from itertools import accumulate, combinations, combinations_with_replacement\n\n setrecursionlimit(10**6)\n var_7 = (\n (lambda *var_11: print(*var_11))\n if \"TERM_PROGRAM\" in environ\n else lambda *var_12: 0\n )\n var_8 = lambda: stdin.readline().rstrip()\n var_3 = lambda: list(map(int, var_8().split()))\n var_1 = lambda: int(var_8())\n var_4 = 10**9 + 7\n var_2 = 10**9 + 10\n var_9, var_10 = var_8().split()\n var_5 = int(var_9)\n var_6 = int(float(var_10) * 100 + 0.5)\n print(var_5 * var_6 // 100)\n\n\nfunc_1()\n```", "output": "SLOWER 1.6812", "pair_id": "python_p02659_pair0003_reversed", "problem_id": "p02659", "language": "python", "direction": "reversed", "speedup_ratio": 3.207} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_4 = int(eval(input()))\nvar_1 = list(map(int, input().split()))\nvar_3 = 1\nfor var_2 in var_1:\n var_3 *= 2 if var_2 % 2 == 0 else 1\nprint((3**var_4 - var_3))\n```\n\n=== Code B (Modified) ===\n```python\nimport numpy as np\nfrom itertools import product\n\nvar_6 = int(eval(input()))\nvar_2 = list(map(int, input().split()))\nvar_2 = np.array(var_2)\nvar_5 = [-1, 0, 1]\nvar_3 = 0\nfor var_7 in product(var_5, repeat=var_6):\n var_7 = np.array(var_7)\n var_1 = var_2 + var_7\n var_4 = var_1.cumprod()\n if var_4[-1] % 2 == 0:\n var_3 += 1\nprint(var_3)\n```", "output": "SLOWER 10.1485", "pair_id": "python_p03568_pair0002_reversed", "problem_id": "p03568", "language": "python", "direction": "reversed", "speedup_ratio": 1134.9796} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2, var_3 = list(map(int, input().split()))\nvar_4 = list(map(int, input().split()))\nvar_6 = list(map(int, input().split()))\nvar_5 = min(var_4) + min(var_6)\nfor var_7 in range(var_3):\n var_9, var_10, var_11 = list(map(int, input().split()))\n var_8 = var_4[var_9 - 1] + var_6[var_10 - 1] - var_11\n var_5 = var_8 if var_8 < var_5 else var_5\nprint(var_5)\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\nfrom collections import Counter\n\n\ndef func_10():\n return sys.stdin.readline().strip()\n\n\ndef func_11(var_12, var_13, var_14):\n return [[var_14] * var_13 for var_17 in range(var_12)]\n\n\ndef func_12(var_12, var_13, var_14, var_15):\n return [[[var_15] * var_14 for var_18 in range(var_13)] for var_17 in range(var_12)]\n\n\ndef func_13(var_12, var_13, var_14, var_15, var_16):\n return [\n [[[var_16] * var_15 for var_18 in range(var_14)] for var_18 in range(var_13)]\n for var_17 in range(var_12)\n ]\n\n\ndef func_8(var_22, var_23=1):\n return int(-(-var_22 // var_23))\n\n\ndef func_1():\n return int(eval(func_10()))\n\n\ndef func_3():\n return list(map(int, func_10().split()))\n\n\ndef func_2(var_11=None):\n return list(func_3()) if var_11 is None else [func_1() for var_17 in range(var_11)]\n\n\ndef func_7():\n print(\"Yes\")\n\n\ndef func_5():\n print(\"No\")\n\n\ndef func_6():\n print(\"YES\")\n\n\ndef func_4():\n print(\"NO\")\n\n\nsys.setrecursionlimit(10**9)\nvar_5 = 10**18\nvar_10 = 10**9 + 7\n\n\ndef func_9(var_1, var_2):\n \"\"\"\"\"\"\n import numpy as np\n from numpy.fft import rfft, irfft\n\n var_8 = max(var_1)\n var_9 = max(var_2)\n var_3 = [0] * (var_8 + 1)\n var_4 = [0] * (var_9 + 1)\n for var_12 in var_1:\n var_3[var_12] += 1\n for var_13 in var_2:\n var_4[var_13] += 1\n\n var_6 = 1\n var_19 = 0\n while var_6 <= var_8 + var_9:\n var_19 += 1\n var_6 = 2**var_19\n\n var_21 = irfft(rfft(var_3, var_6) * rfft(var_4, var_6), var_6)\n\n var_21 = np.rint(var_21).astype(np.int64)\n return var_21\n\n\nvar_11, var_7, var_6 = func_3()\nvar_1 = func_2()\nvar_2 = func_2()\nvar_21 = list(func_9(var_1, var_2))\nvar_20 = var_5\nfor var_17, var_12 in enumerate(var_21):\n if var_12 != 0:\n var_20 = var_17\n break\nfor _ in range(var_6):\n var_22, var_23, var_14 = func_3()\n var_22 -= 1\n var_23 -= 1\n var_20 = min(var_20, var_1[var_22] + var_2[var_23] - var_14)\nprint(var_20)\n```", "output": "SLOWER 3.1814", "pair_id": "python_p02748_pair0001_reversed", "problem_id": "p02748", "language": "python", "direction": "reversed", "speedup_ratio": 9.0716} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = input().split()\nvar_1 = int(var_1)\nvar_2 = int(var_2)\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = list(str(var_4))\n if (var_5[0] == var_5[4]) and (var_5[1] == var_5[3]):\n var_3 = var_3 + 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().rstrip().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = list(map(int, list(str(var_4))))\n if var_5[0] == var_5[4] and var_5[1] == var_5[3]:\n var_3 += 1\nprint(var_3)\n```", "output": "SLOWER 1.2787", "pair_id": "python_p03416_pair0015_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 2.4262} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_5 in range(10):\n for var_6 in range(10):\n for var_7 in range(10):\n var_3 = 10000 * var_5 + 1000 * var_6 + 100 * var_7 + 10 * var_6 + var_5\n if var_1 <= var_3 <= var_2:\n var_4 += 1\nprint(var_4)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = str(var_4)\n if var_5 == var_5[::-1]:\n var_3 += 1\nprint(var_3)\n```", "output": "SLOWER 3.8211", "pair_id": "python_p03416_pair0016_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 14.1339} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = list(reversed(list(str(var_4))))\n if var_5 == list(str(var_4)):\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nfrom sys import stdin\n\nvar_6 = lambda: list(map(int, stdin.readline().split()))\nvar_5 = lambda: list(map(int, stdin.readline().split()))\nvar_1, var_3 = var_6()\nvar_2 = 0\nfor var_4 in range(var_1, var_3 + 1):\n var_7 = str(var_4)\n if var_7 == var_7[::-1]:\n var_2 += 1\nprint(var_2)\n```", "output": "FASTER 1.6385", "pair_id": "python_p03416_pair0017_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 3.1135} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1 = int(eval(input()))\nvar_3 = 0\nfor var_2 in range(1000001):\n var_3 += 7 * pow(10, var_2, var_1)\n var_3 %= var_1\n if var_3 == 0:\n print((var_2 + 1))\n break\nelse:\n print((-1))\n```\n\n=== Code B (Modified) ===\n```python\ndef func_1(*var_2: str) -> str:\n var_3 = int(var_2[0])\n var_4 = 1\n var_1 = 7 % var_3\n while var_1:\n var_1 = (var_1 * 10 + 7) % var_3\n var_4 += 1\n if var_3 < var_4:\n var_4 = -1\n break\n return str(var_4)\n\n\nif __name__ == \"__main__\":\n print((func_1(*(open(0).read().splitlines()))))\n```", "output": "FASTER 3.1368", "pair_id": "python_p02596_pair0001_forward", "problem_id": "p02596", "language": "python", "direction": "forward", "speedup_ratio": 8.7958} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\nfrom operator import itemgetter\nfrom heapq import heapify, heappop, heappush\n\nvar_1 = int(10e15)\nvar_2 = -var_1\nvar_11 = 1000000007\nsys.setrecursionlimit(1000000)\n\n\ndef func_2():\n return list(map(int, input().split()))\n\n\ndef func_4():\n return input().split()\n\n\ndef func_1():\n return int(sys.stdin.readline())\n\n\ndef func_3():\n return eval(input())\n\n\nvar_3, var_4 = func_2()\nvar_5 = [func_2() for var_9 in range(var_3)]\nvar_5.sort(key=itemgetter(0))\n\nvar_8 = [[0] * (var_4 + 1 + 3000 + 1) for _ in range(var_3 + 1)]\nvar_6 = 0\nfor var_9 in range(var_3):\n for var_10 in range(var_4 + 1 + 3000 + 1):\n var_12, var_7 = var_5[var_9]\n if 0 <= var_10 - var_12 < var_4:\n var_8[var_9 + 1][var_10] = max(\n var_8[var_9][var_10], var_8[var_9][var_10 - var_12] + var_7\n )\n else:\n var_8[var_9 + 1][var_10] = var_8[var_9][var_10]\n var_6 = max(var_6, var_8[var_9 + 1][var_10])\nprint(var_6)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_6 = sorted([list(map(int, input().split())) for var_5 in range(var_1)])\n\nvar_4 = [[0] * (var_2 + 1) for var_5 in range(var_1 + 1)]\n\nfor var_5 in range(var_1):\n var_9, var_8 = var_6[var_5]\n for var_7 in range(var_2 + 1):\n if var_7 + var_9 <= var_2:\n var_4[var_5 + 1][var_7 + var_9] = max(\n var_4[var_5 + 1][var_7 + var_9], var_4[var_5][var_7] + var_8\n )\n var_4[var_5 + 1][var_7] = max(var_4[var_5][var_7], var_4[var_5 + 1][var_7])\nvar_3 = 0\nfor var_5, (var_9, var_8) in enumerate(var_6):\n var_3 = max(var_3, var_4[var_5][var_2 - 1] + var_8)\nprint(var_3)\n```", "output": "FASTER 4.4103", "pair_id": "python_p02863_pair0005_forward", "problem_id": "p02863", "language": "python", "direction": "forward", "speedup_ratio": 21.263} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport bisect, copy, heapq, math, sys\nfrom collections import *\nfrom functools import lru_cache\nfrom itertools import accumulate, combinations, permutations, product\n\n\ndef func_2():\n return sys.stdin.readline()[:-1]\n\n\ndef func_4(var_8):\n return [0] + list(accumulate(var_8))\n\n\ndef func_1(var_1, var_4):\n return -(-var_1 // var_4)\n\n\nsys.setrecursionlimit(5000000)\nvar_9 = pow(10, 9) + 7\nvar_2 = [chr(ord(\"a\") + var_6) for var_6 in range(26)]\nvar_5 = [[1, 0], [0, 1], [-1, 0], [0, -1]]\nvar_11 = int(eval(func_2()))\n\n\ndef func_3(var_10):\n if var_10 == 1:\n return False\n for var_7 in range(2, int(math.sqrt(var_10)) + 1):\n if var_10 % var_7 == 0:\n return False\n return True\n\n\nvar_3 = var_11\nwhile not func_3(var_3):\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\ndef func_1(var_3):\n var_4 = int(var_3)\n for var_1 in range(var_4, 2 * var_4):\n for var_2 in range(2, int(var_1**0.5)):\n if var_1 % var_2 == 0:\n break\n else:\n return str(var_1)\n\n\nif __name__ == \"__main__\":\n import sys\n\n print((func_1(sys.stdin.read().strip())))\n```", "output": "FASTER 1.4975", "pair_id": "python_p02819_pair0002_forward", "problem_id": "p02819", "language": "python", "direction": "forward", "speedup_ratio": 2.8236} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n if str(var_4) == \"\".join(reversed(str(var_4))):\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_3 = list(map(int, input().split()))\nvar_2 = 0\nfor var_5 in range(var_3 + 1)[var_1:]:\n if len(str(var_5)) % 2 == 0:\n var_6 = list(str(var_5))[: len(str(var_5)) // 2]\n var_7 = list(reversed(list(str(var_5))[len(str(var_5)) // 2 :]))\n if var_6 == var_7:\n var_2 += 1\n else:\n var_8 = list(str(var_5))[: len(str(var_5)) // 2 + 1]\n var_4 = list(reversed(list(str(var_5))[len(str(var_5)) // 2 :]))\n if var_8 == var_4:\n var_2 += 1\nprint(var_2)\n```", "output": "SLOWER 1.3983", "pair_id": "python_p03416_pair0018_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 2.6359} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_3 = int(input())\nvar_6 = list(map(int, input().split()))\nvar_7 = list(map(int, input().split()))\nvar_1 = [abs(var_4 - var_5) for var_4, var_5 in zip(var_6, var_7)]\nvar_2 = lambda var_3: sum([var_4**var_3 for var_4 in var_1]) ** (1 / var_3)\nprint(var_2(1), var_2(2), var_2(3), max(var_1), sep=\"\\n\")\n```\n\n=== Code B (Modified) ===\n```python\nvar_5 = int(eval(input()))\nvar_7 = list(map(int, input().split()))\nvar_8 = list(map(int, input().split()))\nvar_6 = [[0 for var_2 in range(6)] for var_3 in range(var_5 + 1)]\nvar_1 = abs(var_7[0] - var_8[0])\nvar_6[0][3] = var_6[0][0] = var_1\nvar_6[0][4] = var_6[0][1] = var_1**2\nvar_6[0][5] = var_6[0][2] = var_1**3\nvar_4 = var_1\nfor var_2 in range(1, var_5, 1):\n var_1 = abs(var_7[var_2] - var_8[var_2])\n var_6[var_2][0] = var_1\n var_6[var_2][1] = var_1**2\n var_6[var_2][2] = var_6[var_2][1] * var_1\n var_6[var_2][3] = var_6[var_2 - 1][3] + var_6[var_2][0]\n var_6[var_2][4] = var_6[var_2 - 1][4] + var_6[var_2][1]\n var_6[var_2][5] = var_6[var_2 - 1][5] + var_6[var_2][2]\n if var_1 > var_4:\n var_4 = var_1\nprint((var_6[var_5 - 1][3]))\nprint((var_6[var_5 - 1][4] ** (1 / 2)))\nprint((var_6[var_5 - 1][5] ** (1 / 3)))\nprint(var_4)\n```", "output": "SLOWER 1.2213", "pair_id": "python_p02382_pair0001_reversed", "problem_id": "p02382", "language": "python", "direction": "reversed", "speedup_ratio": 2.3316} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = list(str(var_4))\n if var_5 == list(reversed(var_5)):\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_5 in range(var_1, var_2 + 1):\n var_3 = str(var_5)\n if var_3[0] == var_3[-1] and var_3[1] == var_3[-2]:\n var_4 += 1\nprint(var_4)\n```", "output": "FASTER 1.3238", "pair_id": "python_p03416_pair0019_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 2.5032} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_5 in range(var_1, var_2 + 1):\n var_3 = str(var_5)\n if var_3[0] == var_3[-1] and var_3[1] == var_3[-2]:\n var_4 += 1\nprint(var_4)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\n\n\ndef func_1(var_5):\n var_4 = 0\n for var_3 in range(1, var_5 + 1):\n if str(var_3) == str(var_3)[::-1]:\n var_4 += 1\n return var_4\n\n\nprint((func_1(var_2) - func_1(var_1 - 1)))\n```", "output": "SLOWER 1.6822", "pair_id": "python_p03416_pair0020_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 3.2092} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\ndef func_1():\n var_2, var_3, *var_1 = list(map(int, open(0).read().split()))\n var_4 = [0] * (var_3 + max(var_1[::2]))\n for var_7, var_6 in sorted(zip(*[iter(var_1)] * 2)):\n for var_5 in reversed(list(range(var_3))):\n var_4[var_5 + var_7] = max(var_4[var_5 + var_7], var_4[var_5] + var_6)\n print((max(var_4)))\n\n\nfunc_1()\n```\n\n=== Code B (Modified) ===\n```python\nfrom sys import stdin\n\n\ndef func_1():\n\n var_9 = stdin.readline\n var_8, var_10 = list(map(int, var_9().split()))\n var_7 = [list(map(int, var_9().split())) for _ in range(var_8)]\n var_7.sort()\n var_1 = [0] * var_8\n var_2 = [0] * var_8\n for var_4 in range(var_8):\n var_1[var_4], var_2[var_4] = var_7[var_4][0], var_7[var_4][1]\n\n var_5 = -(10**9)\n var_3 = [[var_5] * (var_10 + 1) for _ in range(var_8 + 1)]\n var_3[0][0] = 0\n for var_4 in range(var_8):\n for var_6 in range(var_10 + 1):\n\n if var_6 != var_10:\n var_3[var_4 + 1][min(var_10, var_6 + var_1[var_4])] = max(\n var_3[var_4 + 1][min(var_10, var_6 + var_1[var_4])],\n var_3[var_4][var_6] + var_2[var_4],\n )\n\n var_3[var_4 + 1][var_6] = max(var_3[var_4 + 1][var_6], var_3[var_4][var_6])\n print((max(var_3[var_8])))\n\n\nif __name__ == \"__main__\":\n func_1()\n```", "output": "SLOWER 1.1965", "pair_id": "python_p02863_pair0006_reversed", "problem_id": "p02863", "language": "python", "direction": "reversed", "speedup_ratio": 2.2918} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport bisect\nimport sys\n\nsys.setrecursionlimit(10**6)\nvar_16 = sys.stdout.write\nvar_7 = lambda *var_14: print(*var_14) if var_1 else 0\nvar_1 = True\n\n\ndef func_1(var_9=sys.stdin.readline):\n var_11 = lambda: var_9().rstrip()\n var_3 = lambda: list(map(int, var_11().split()))\n var_2 = lambda: int(var_11())\n var_4 = lambda var_17: [var_3() for _ in range(var_17)]\n var_13, var_15 = var_3()\n var_5 = var_4(var_13)\n var_5.sort()\n var_8 = [[0] * var_15 for _ in range(var_13 + 1)]\n for var_10 in range(1, var_13 + 1):\n for var_12 in range(1, var_15):\n if var_12 < var_5[var_10 - 1][0]:\n var_8[var_10][var_12] = var_8[var_10 - 1][var_12]\n else:\n var_8[var_10][var_12] = max(\n var_8[var_10 - 1][var_12],\n var_8[var_10 - 1][var_12 - var_5[var_10 - 1][0]]\n + var_5[var_10 - 1][1],\n )\n var_6 = 0\n for var_10 in range(var_13):\n var_6 = max(var_6, var_8[var_10][var_15 - 1] + var_5[var_10][1])\n print(var_6)\n\n\nif __name__ == \"__main__\":\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nvar_6, var_7 = list(map(int, input().split()))\nvar_1 = [list(map(int, input().split())) for _ in range(var_6)]\nvar_1.sort()\nvar_3 = [(6007) * [0] for _ in range(var_6 + 1)]\nvar_3[0][0] = 0\nvar_2 = 0\nfor var_4 in range(var_6):\n for var_5 in range(6007):\n var_3[var_4 + 1][var_5] = max(var_3[var_4 + 1][var_5], var_3[var_4][var_5])\n if var_5 < var_7:\n var_3[var_4 + 1][var_5 + var_1[var_4][0]] = max(\n var_3[var_4][var_5] + var_1[var_4][1],\n var_3[var_4][var_5 + var_1[var_4][0]],\n )\n var_2 = max(var_2, var_3[var_4 + 1][var_5])\nprint(var_2)\n```", "output": "SLOWER 6.1246", "pair_id": "python_p02863_pair0007_reversed", "problem_id": "p02863", "language": "python", "direction": "reversed", "speedup_ratio": 69.7734} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\ndef func_1():\n var_2 = int(eval(input()))\n var_1 = [int(var_6) for var_6 in input().split()]\n var_4 = 3**var_2\n var_5 = len([var_3 for var_3 in var_1 if var_3 % 2 == 0])\n var_4 -= 2**var_5\n print(var_4)\n\n\nif __name__ == \"__main__\":\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nimport math\nimport string\n\n\ndef func_4():\n return list(map(int, input().split()))\n\n\ndef func_3(var_6, var_7):\n return math.factorial(var_6) // (\n math.factorial(var_6 - var_7) * math.factorial(var_7)\n )\n\n\ndef func_2(var_9):\n var_8 = []\n for var_5 in var_9:\n if not (var_5 in var_8):\n var_8.append(var_5)\n return len(var_9) != len(var_8)\n\n\ndef func_1(var_6):\n func_1 = []\n for var_4 in range(1, var_6 + 1):\n if var_6 % var_4 == 0:\n func_1.append(var_4)\n return func_1\n\n\nvar_2 = [-1, -1, -1, 0, 0, 1, 1, 1]\nvar_3 = [-1, 0, 1, -1, 1, -1, 0, 1]\nvar_6 = int(eval(input()))\nvar_1 = func_4()\nvar_10 = 1\nfor var_4 in range(len(var_1)):\n if var_1[var_4] % 2 == 0:\n var_10 *= 2\n else:\n var_10 *= 1\nprint((3 ** len(var_1) - var_10))\n```", "output": "SLOWER 1.1807", "pair_id": "python_p03568_pair0003_reversed", "problem_id": "p03568", "language": "python", "direction": "reversed", "speedup_ratio": 2.2669} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\nimport math\nfrom collections import defaultdict\nfrom bisect import bisect_left, bisect_right\n\nsys.setrecursionlimit(10**7)\n\n\ndef func_4():\n return sys.stdin.readline()[:-1]\n\n\nvar_4 = 10**9 + 7\n\n\ndef func_1():\n return int(eval(func_4()))\n\n\ndef func_2():\n return list(map(int, func_4().split()))\n\n\ndef func_3(var_6, var_3):\n if var_6 <= 0:\n return [[] for _ in range(var_3)]\n elif var_3 == 1:\n return [func_1() for _ in range(var_6)]\n else:\n var_5 = [func_2() for _ in range(var_6)]\n return list(map(list, list(zip(*var_5))))\n\n\nvar_1, var_2 = list(map(str, func_4().split()))\nvar_1 = int(var_1)\nvar_2 = 100 * int(var_2[0]) + 10 * int(var_2[2]) + int(var_2[3])\nprint((var_1 * var_2 // 100))\n```\n\n=== Code B (Modified) ===\n```python\nimport math\n\nvar_1, var_2 = input().split()\nvar_1 = int(var_1)\nvar_3 = int(var_2[0] + var_2[2] + var_2[3])\nprint((var_1 * var_3 // 100))\n```", "output": "FASTER 2.3564", "pair_id": "python_p02659_pair0004_forward", "problem_id": "p02659", "language": "python", "direction": "forward", "speedup_ratio": 5.1208} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = [0] * (var_2 + 1)\nfor var_3 in range(1, var_2 + 1):\n if str(var_3) == str(var_3)[::-1]:\n var_4[var_3] = var_4[var_3 - 1] + 1\n else:\n var_4[var_3] = var_4[var_3 - 1]\nprint((var_4[var_2] - var_4[var_1 - 1]))\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_5 in range(var_1, var_2 + 1):\n var_3 = str(var_5)\n if var_3[0] == var_3[-1] and var_3[1] == var_3[-2]:\n var_4 += 1\nprint(var_4)\n```", "output": "FASTER 2.0339", "pair_id": "python_p03416_pair0021_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 4.095} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_4 = {}\nvar_5 = 0\nfor var_6 in range(10000, 100000):\n var_3 = list(str(var_6))\n if var_3 == list(reversed(var_3)):\n var_5 += 1\n var_4[var_6] = var_5\nvar_1, var_2 = list(map(int, input().split()))\nprint((var_4[var_2] - var_4[var_1 - 1] if var_1 > 10000 else var_4[var_2]))\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n if list(str(var_4)) == list(reversed(str(var_4))):\n var_3 += 1\nprint(var_3)\n```", "output": "FASTER 2.1733", "pair_id": "python_p03416_pair0022_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 4.5104} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_4 = {}\nvar_5 = 0\nfor var_6 in range(10000, 100000):\n var_3 = list(str(var_6))\n if var_3 == list(reversed(var_3)):\n var_5 += 1\n var_4[var_6] = var_5\nvar_1, var_2 = list(map(int, input().split()))\nprint((var_4[var_2] - var_4[var_1 - 1] if var_1 > 10000 else var_4[var_2]))\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_6 in range(var_1, var_2 + 1):\n var_3 = str(var_6)\n var_5 = True\n for var_7 in range(len(var_3) // 2):\n if var_3[var_7] != var_3[-var_7 - 1] and var_5:\n var_5 = not var_5\n if var_5:\n var_4 += 1\nprint(var_4)\n```", "output": "FASTER 2.1137", "pair_id": "python_p03416_pair0023_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 4.3279} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n if str(var_4) == \"\".join(reversed(str(var_4))):\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_5 in range(10):\n for var_6 in range(10):\n for var_7 in range(10):\n var_3 = 10000 * var_5 + 1000 * var_6 + 100 * var_7 + 10 * var_6 + var_5\n if var_1 <= var_3 <= var_2:\n var_4 += 1\nprint(var_4)\n```", "output": "FASTER 4.9018", "pair_id": "python_p03416_pair0024_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 29.8943} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_6 = str(var_4)\n var_5 = var_6[::-1]\n if var_6 == var_5:\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\ndef func_1():\n var_1, var_2 = list(map(int, input().split()))\n var_3 = 0\n for var_4 in range(var_1, var_2 + 1):\n\n if (var_4 % 10) == (var_4 // 10000 % 10) and (var_4 // 10 % 10) == (\n var_4 // 1000 % 10\n ):\n var_3 += 1\n print(var_3)\n\n\nif __name__ == \"__main__\":\n func_1()\n```", "output": "FASTER 1.9144", "pair_id": "python_p03416_pair0025_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 3.7697} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\ndef func_1():\n var_1, var_2 = list(map(int, input().split()))\n var_3 = 0\n for var_4 in range(var_1, var_2 + 1):\n\n if (var_4 % 10) == (var_4 // 10000 % 10) and (var_4 // 10 % 10) == (\n var_4 // 1000 % 10\n ):\n var_3 += 1\n print(var_3)\n\n\nif __name__ == \"__main__\":\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nvar_10 = []\nvar_10 = input().rstrip().split(\" \")\nvar_1 = int(var_10[0])\nvar_3 = int(var_10[1])\nvar_2 = 0\nvar_6 = var_1\nwhile var_6 <= var_3:\n var_4 = var_6 // 10000\n var_5 = (var_6 - var_4 * 10000) // 1000\n var_7 = var_6 // 100\n var_8 = (var_6 - var_7 * 100) // 10\n var_9 = var_6 % 10\n if (var_4 == var_9) and (var_5 == var_8):\n var_2 += 1\n var_6 += 1\nprint(var_2)\n```", "output": "SLOWER 2.4731", "pair_id": "python_p03416_pair0026_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 5.5522} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport itertools\n\nvar_6 = int(eval(input()))\nvar_2 = [[]] * var_6\nfor var_4 in range(var_6):\n var_3 = list(map(int, input().split()))\n\n var_2[var_4] = var_3\nvar_8 = [[]] * var_6\nfor var_4 in range(var_6):\n var_9 = list(map(int, input().split()))\n var_8[var_4] = var_9\nvar_10 = -(10**11)\nfor var_1 in itertools.product([0, 1], repeat=10):\n if sum(var_1) == 0:\n continue\n var_11 = 0\n for var_7 in range(var_6):\n var_5 = 0\n for var_4 in range(10):\n if var_2[var_7][var_4] == 1 and var_1[var_4] == 1:\n var_5 += 1\n var_11 = var_11 + var_8[var_7][var_5]\n var_10 = max(var_10, var_11)\nprint(var_10)\n```\n\n=== Code B (Modified) ===\n```python\nfrom sys import stdin\n\n\ndef func_1():\n\n var_11 = stdin.readline\n var_2 = int(var_11())\n var_1 = []\n for var_6 in range(var_2):\n var_5 = int(\"\".join(var_11().strip().split(\" \")), 2)\n var_1.append(var_5)\n var_3 = []\n for var_6 in range(var_2):\n var_10 = list(map(int, var_11().split()))\n var_3.append(var_10)\n var_8 = float(\"-inf\")\n for var_9 in range(1, 1 << 10):\n var_12 = 0\n for var_7 in range(var_2):\n var_4 = bin(var_9 & var_1[var_7]).count(\"1\")\n var_12 += var_3[var_7][var_4]\n var_8 = max(var_12, var_8)\n print(var_8)\n\n\nif __name__ == \"__main__\":\n func_1()\n```", "output": "FASTER 2.8495", "pair_id": "python_p03503_pair0001_forward", "problem_id": "p03503", "language": "python", "direction": "forward", "speedup_ratio": 7.2074} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_4, var_3 = list(map(int, input().split()))\nvar_1 = 0\nfor var_2 in range(var_4, var_3 + 1):\n if str(var_2)[0] + str(var_2)[1] == str(var_2)[-1] + str(var_2)[-2]:\n var_1 += 1\nprint(var_1)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_5 in range(var_1, var_2 + 1):\n var_3 = str(var_5)\n if var_3[0] == var_3[-1] and var_3[1] == var_3[-2]:\n var_4 += 1\nprint(var_4)\n```", "output": "FASTER 1.4327", "pair_id": "python_p03416_pair0027_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 2.6995} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nfrom math import floor\n\nvar_1, var_2 = list(map(int, input().split()))\n\n\nfor var_3 in range(1010):\n if (floor(var_3 * 0.08) == var_1) and (floor(var_3 * 0.1) == var_2):\n\n print(var_3)\n quit()\n\n\nprint((-1))\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_2 = var_2 / 0.1\nvar_3 = [var_4 + var_2 for var_4 in range(10)]\nfor var_4 in var_3:\n if int(var_4 * 0.08) == var_1:\n print((int(var_4)))\n exit()\nprint(\"-1\")\n```", "output": "FASTER 1.8373", "pair_id": "python_p02755_pair0002_forward", "problem_id": "p02755", "language": "python", "direction": "forward", "speedup_ratio": 3.5734} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_11 = int(eval(input()))\nvar_12 = {var_8: [] for var_8 in range(1, var_11 + 1)}\nvar_19 = [False for var_8 in range(var_11 + 1)]\nvar_16 = []\nfor _ in range(var_11 - 1):\n var_2, var_3 = list(map(int, input().split()))\n var_12[var_2].append(var_3)\n var_12[var_3].append(var_2)\n var_16.append((var_2, var_3))\nvar_9 = var_16[0][0]\nvar_19[var_9] = True\nvar_6 = []\nvar_7 = []\nvar_14 = {var_8: {} for var_8 in range(1, var_11 + 1)}\nvar_10 = [0 for var_8 in range(var_11 + 1)]\n\nvar_4 = 1\nfor var_5 in var_12[var_9]:\n var_19[var_5] = True\n var_14[var_9][var_5] = var_4\n var_14[var_5][var_9] = var_4\n var_10[var_5] = var_4\n var_4 += 1\n var_6.append(var_5)\nwhile var_6:\n for var_15 in var_6:\n var_13 = 1\n for var_5 in var_12[var_15]:\n if var_19[var_5] == False:\n var_19[var_5] = True\n if var_13 != var_10[var_15]:\n var_14[var_15][var_5] = var_13\n var_14[var_5][var_15] = var_13\n var_10[var_5] = var_13\n var_13 += 1\n var_7.append(var_5)\n else:\n var_13 += 1\n var_14[var_15][var_5] = var_13\n var_14[var_5][var_15] = var_13\n var_10[var_5] = var_13\n var_13 += 1\n var_7.append(var_5)\n if var_7:\n var_6 = var_7\n var_7 = []\n else:\n var_6 = []\n var_7 = []\nvar_1 = 0\nfor var_8 in range(1, var_11 + 1):\n var_1 = max(var_1, len(var_12[var_8]))\nprint(var_1)\nfor var_8 in range(var_11 - 1):\n var_17, var_18 = var_16[var_8][0], var_16[var_8][1]\n print((var_14[var_17][var_18]))\n```\n\n=== Code B (Modified) ===\n```python\nvar_8 = int(eval(input()))\nvar_6 = []\nfor var_7 in range(var_8 - 1):\n var_1, var_3 = list(map(int, input().split()))\n var_6.append([var_1 - 1, var_3 - 1, var_7])\nvar_6.sort()\nvar_12 = [0] * (var_8)\nvar_2 = [0] * (var_8 - 1)\nvar_9 = 1\nvar_10 = 0\nfor var_5 in var_6:\n _from, var_11, var_7 = var_5\n if _from != var_10:\n var_9 = 1\n if var_12[_from] == var_9:\n var_9 += 1\n var_2[var_7] = var_9\n var_12[var_11] = var_9\n var_9 += 1\n var_10 = _from\nprint((max(var_2)))\nfor var_4 in var_2:\n print(var_4)\n```", "output": "FASTER 1.2591", "pair_id": "python_p02850_pair0001_forward", "problem_id": "p02850", "language": "python", "direction": "forward", "speedup_ratio": 2.3934} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport bisect\n\nvar_9, var_4, var_1 = list(map(int, input().split()))\nvar_5 = [None] * var_9\nfor var_7 in range(var_9):\n var_11, var_6 = list(map(int, input().split()))\n var_5[var_7] = (var_11, var_6)\nvar_5.sort()\nvar_11 = [int(var_5[var_7][0]) for var_7 in range(var_9)]\nvar_6 = [int(var_5[var_7][1]) for var_7 in range(var_9)]\nvar_2 = 0\nvar_3 = [0] * var_9\nfor var_7 in range(var_9):\n if var_7 != 0:\n var_3[var_7] += var_3[var_7 - 1]\n if var_3[var_7] >= var_6[var_7]:\n continue\n var_10 = (var_6[var_7] - var_3[var_7] - 1) // var_1 + 1\n var_2 += var_10\n var_3[var_7] += var_10 * var_1\n var_8 = bisect.bisect_right(var_11, var_11[var_7] + 2 * var_4)\n if var_8 == var_9:\n continue\n var_3[var_8] -= var_10 * var_1\nprint(var_2)\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\n\nsys.setrecursionlimit(500000)\n\n\ndef func_2():\n return sys.stdin.readline()[:-1]\n\n\nclass Class_1:\n def __init__(self, var_12):\n self.n = var_12\n self.N0 = 1 << var_12.bit_length()\n self.data = [0] * (self.N0 * 2)\n\n def func_5(self, var_11, var_13, var_16):\n var_11 += self.N0\n var_13 += self.N0\n while var_11 < var_13:\n if var_11 & 1:\n self.data[var_11] = self.data[var_11] + var_16\n var_11 += 1\n if var_13 & 1:\n self.data[var_13 - 1] = self.data[var_13 - 1] + var_16\n var_13 -= 1\n var_11 //= 2\n var_13 //= 2\n\n def func_4(self, var_8):\n var_8 += len(self.data) // 2\n var_14 = self.data[var_8]\n while var_8 > 0:\n var_8 //= 2\n var_14 = var_14 + self.data[var_8]\n return var_14\n\n\ndef func_3():\n var_3, var_2, var_1 = list(map(int, func_2().split()))\n var_6 = []\n for var_8 in range(var_3):\n var_17, var_7 = list(map(int, func_2().split()))\n if var_7 % var_1 == 0:\n var_6.append([var_17, var_7 // var_1])\n else:\n var_6.append([var_17, var_7 // var_1 + 1])\n var_6.sort(key=lambda var_17: var_17[0])\n\n def func_1(var_9):\n var_17 = var_6[var_9][0]\n if var_6[var_3 - 1][0] <= var_17 + 2 * var_2:\n return var_3 - 1\n var_11 = var_9\n var_13 = var_3 - 1\n while var_13 - var_11 > 1:\n if var_6[(var_13 + var_11) // 2][0] <= var_17 + 2 * var_2:\n var_11 = (var_13 + var_11) // 2\n else:\n var_13 = (var_13 + var_11) // 2\n return var_11\n\n var_4 = Class_1(var_3)\n for var_8 in range(var_3):\n var_4.update(var_8, var_8 + 1, var_6[var_8][1])\n var_5 = 0\n for var_8 in range(var_3):\n var_15 = var_4.query(var_8)\n if var_15 > 0:\n var_5 += var_15\n var_10 = func_1(var_8)\n var_4.update(var_8, var_10 + 1, -var_15)\n print(var_5)\n\n\nif __name__ == \"__main__\":\n func_3()\n```", "output": "SLOWER 1.0618", "pair_id": "python_p02788_pair0001_reversed", "problem_id": "p02788", "language": "python", "direction": "reversed", "speedup_ratio": 2.0876} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\nfrom collections import Counter\n\n\ndef func_10():\n return sys.stdin.readline().strip()\n\n\ndef func_11(var_12, var_13, var_14):\n return [[var_14] * var_13 for var_17 in range(var_12)]\n\n\ndef func_12(var_12, var_13, var_14, var_15):\n return [[[var_15] * var_14 for var_18 in range(var_13)] for var_17 in range(var_12)]\n\n\ndef func_13(var_12, var_13, var_14, var_15, var_16):\n return [\n [[[var_16] * var_15 for var_18 in range(var_14)] for var_18 in range(var_13)]\n for var_17 in range(var_12)\n ]\n\n\ndef func_8(var_22, var_23=1):\n return int(-(-var_22 // var_23))\n\n\ndef func_1():\n return int(eval(func_10()))\n\n\ndef func_3():\n return list(map(int, func_10().split()))\n\n\ndef func_2(var_11=None):\n return list(func_3()) if var_11 is None else [func_1() for var_17 in range(var_11)]\n\n\ndef func_7():\n print(\"Yes\")\n\n\ndef func_5():\n print(\"No\")\n\n\ndef func_6():\n print(\"YES\")\n\n\ndef func_4():\n print(\"NO\")\n\n\nsys.setrecursionlimit(10**9)\nvar_5 = 10**18\nvar_10 = 10**9 + 7\n\n\ndef func_9(var_1, var_2):\n \"\"\"\"\"\"\n import numpy as np\n from numpy.fft import rfft, irfft\n\n var_8 = max(var_1)\n var_9 = max(var_2)\n var_3 = [0] * (var_8 + 1)\n var_4 = [0] * (var_9 + 1)\n for var_12 in var_1:\n var_3[var_12] += 1\n for var_13 in var_2:\n var_4[var_13] += 1\n\n var_6 = 1\n var_19 = 0\n while var_6 <= var_8 + var_9:\n var_19 += 1\n var_6 = 2**var_19\n\n var_21 = irfft(rfft(var_3, var_6) * rfft(var_4, var_6), var_6)\n\n var_21 = np.rint(var_21).astype(np.int64)\n return var_21\n\n\nvar_11, var_7, var_6 = func_3()\nvar_1 = func_2()\nvar_2 = func_2()\nvar_21 = list(func_9(var_1, var_2))\nvar_20 = var_5\nfor var_17, var_12 in enumerate(var_21):\n if var_12 != 0:\n var_20 = var_17\n break\nfor _ in range(var_6):\n var_22, var_23, var_14 = func_3()\n var_22 -= 1\n var_23 -= 1\n var_20 = min(var_20, var_1[var_22] + var_2[var_23] - var_14)\nprint(var_20)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2, var_3 = list(map(int, input().split()))\nvar_4 = list(map(int, input().split()))\nvar_6 = list(map(int, input().split()))\nvar_5 = min(var_4) + min(var_6)\nfor var_7 in range(var_3):\n var_9, var_10, var_11 = list(map(int, input().split()))\n var_8 = var_4[var_9 - 1] + var_6[var_10 - 1] - var_11\n var_5 = var_8 if var_8 < var_5 else var_5\nprint(var_5)\n```", "output": "FASTER 3.1814", "pair_id": "python_p02748_pair0001_forward", "problem_id": "p02748", "language": "python", "direction": "forward", "speedup_ratio": 9.0716} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = [0] * (var_2 + 1)\nfor var_3 in range(1, var_2 + 1):\n if str(var_3) == str(var_3)[::-1]:\n var_4[var_3] = var_4[var_3 - 1] + 1\n else:\n var_4[var_3] = var_4[var_3 - 1]\nprint((var_4[var_2] - var_4[var_1 - 1]))\n```\n\n=== Code B (Modified) ===\n```python\ndef func_1():\n var_1, var_2 = list(map(int, input().split()))\n var_3 = 0\n for var_4 in range(var_1, var_2 + 1):\n\n if (var_4 % 10) == (var_4 // 10000 % 10) and (var_4 // 10 % 10) == (\n var_4 // 1000 % 10\n ):\n var_3 += 1\n print(var_3)\n\n\nif __name__ == \"__main__\":\n func_1()\n```", "output": "FASTER 3.6063", "pair_id": "python_p03416_pair0028_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 12.1789} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_4 = str(var_4)\n if var_4[0] == var_4[-1] and var_4[1] == var_4[-2]:\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = [0] * (var_2 + 1)\nfor var_3 in range(1, var_2 + 1):\n if str(var_3) == str(var_3)[::-1]:\n var_4[var_3] = var_4[var_3 - 1] + 1\n else:\n var_4[var_3] = var_4[var_3 - 1]\nprint((var_4[var_2] - var_4[var_1 - 1]))\n```", "output": "SLOWER 2.126", "pair_id": "python_p03416_pair0029_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 4.365} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\n\nsys.setrecursionlimit(2147483647)\nvar_2 = float(\"inf\")\nvar_3 = 10**9 + 7\nvar_10 = lambda: sys.stdin.readline().rstrip()\n\n\ndef func_1():\n var_11, var_4 = list(map(int, var_10().split()))\n var_1 = [tuple(map(int, var_10().split())) for _ in range(var_11)]\n var_1.sort()\n var_8 = [0] * var_4\n var_6 = -var_2\n for var_9 in range(var_11):\n var_5, var_7 = var_1[var_9]\n var_12 = var_8[:]\n for var_13 in range(var_4):\n if var_13 + var_5 < var_4:\n var_12[var_13 + var_5] = max(\n var_12[var_13 + var_5], var_8[var_13] + var_7\n )\n else:\n var_6 = max(var_6, var_8[var_13] + var_7)\n var_8 = var_12\n print((max(var_6, max(var_8))))\n\n\nfunc_1()\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_6 = sorted([list(map(int, input().split())) for var_5 in range(var_1)])\n\nvar_4 = [[0] * (var_2 + 1) for var_5 in range(var_1 + 1)]\n\nfor var_5 in range(var_1):\n var_9, var_8 = var_6[var_5]\n for var_7 in range(var_2 + 1):\n if var_7 + var_9 <= var_2:\n var_4[var_5 + 1][var_7 + var_9] = max(\n var_4[var_5 + 1][var_7 + var_9], var_4[var_5][var_7] + var_8\n )\n var_4[var_5 + 1][var_7] = max(var_4[var_5][var_7], var_4[var_5 + 1][var_7])\nvar_3 = 0\nfor var_5, (var_9, var_8) in enumerate(var_6):\n for var_7 in range(var_2):\n var_3 = max(var_3, var_4[var_5][var_7] + var_8)\nprint(var_3)\n```", "output": "SLOWER 1.8014", "pair_id": "python_p02863_pair0008_reversed", "problem_id": "p02863", "language": "python", "direction": "reversed", "speedup_ratio": 3.4856} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_5 in range(var_1, var_2 + 1):\n var_3 = str(var_5)\n if var_3[0] == var_3[-1] and var_3[1] == var_3[-2]:\n var_4 += 1\nprint(var_4)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_8 in range(var_1, var_2 + 1):\n var_7 = str(var_8)\n var_6 = len(var_7)\n var_4 = True\n for var_5 in range(var_6 // 2):\n if var_7[var_5] != var_7[var_6 - 1 - var_5]:\n var_4 = False\n break\n if var_4:\n var_3 += 1\nprint(var_3)\n```", "output": "SLOWER 1.2178", "pair_id": "python_p03416_pair0030_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 2.3259} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\ndef func_1():\n var_1, var_2 = list(map(int, input().rstrip().split()))\n var_3 = 0\n for var_4 in range(var_1, var_2 + 1):\n var_5 = str(var_4)\n if var_5 == var_5[::-1]:\n var_3 += 1\n print(var_3)\n\n\nif __name__ == \"__main__\":\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\n\n\ndef func_1(var_5):\n var_4 = 0\n for var_3 in range(1, var_5 + 1):\n if str(var_3) == str(var_3)[::-1]:\n var_4 += 1\n return var_4\n\n\nprint((func_1(var_2) - func_1(var_1 - 1)))\n```", "output": "SLOWER 2.3366", "pair_id": "python_p03416_pair0031_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 5.0511} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport bisect, copy, heapq, math, sys\nfrom collections import *\nfrom functools import lru_cache\nfrom itertools import accumulate, combinations, permutations, product\n\n\ndef func_2():\n return sys.stdin.readline()[:-1]\n\n\ndef func_4(var_8):\n return [0] + list(accumulate(var_8))\n\n\ndef func_1(var_1, var_4):\n return -(-var_1 // var_4)\n\n\nsys.setrecursionlimit(5000000)\nvar_9 = pow(10, 9) + 7\nvar_2 = [chr(ord(\"a\") + var_6) for var_6 in range(26)]\nvar_5 = [[1, 0], [0, 1], [-1, 0], [0, -1]]\nvar_11 = int(eval(func_2()))\n\n\ndef func_3(var_10):\n if var_10 == 1:\n return False\n for var_7 in range(2, int(math.sqrt(var_10)) + 1):\n if var_10 % var_7 == 0:\n return False\n return True\n\n\nvar_3 = var_11\nwhile not func_3(var_3):\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nimport numpy as np\nfrom bisect import bisect_left\n\n\ndef func_1():\n var_4 = []\n var_1 = np.ones(10**5 + 10)\n var_1[0] = var_1[1] = 0\n for var_3, var_2 in enumerate(var_1):\n if var_2:\n var_4.append(var_3)\n var_1[2 * var_3 : 10**5 + 10 : var_3] = 0\n return var_4\n\n\ndef func_2(var_6):\n var_7 = int(var_6)\n var_5 = func_1()\n return str(var_5[bisect_left(var_5, var_7)])\n\n\nif __name__ == \"__main__\":\n import sys\n\n print((func_2(sys.stdin.read().strip())))\n```", "output": "SLOWER 6.3202", "pair_id": "python_p02819_pair0003_reversed", "problem_id": "p02819", "language": "python", "direction": "reversed", "speedup_ratio": 79.9029} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = list(str(var_4))\n if var_5 == list(reversed(var_5)):\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_4 = str(var_4)\n if var_4 == var_4[::-1]:\n var_3 += 1\nprint(var_3)\n```", "output": "FASTER 1.0852", "pair_id": "python_p03416_pair0032_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 2.1216} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\ndef func_1():\n from sys import setrecursionlimit, stdin\n from os import environ\n from collections import defaultdict, deque, Counter\n from math import ceil, floor, gcd\n from itertools import accumulate, combinations, combinations_with_replacement\n\n setrecursionlimit(10**6)\n var_7 = (\n (lambda *var_11: print(*var_11))\n if \"TERM_PROGRAM\" in environ\n else lambda *var_12: 0\n )\n var_8 = lambda: stdin.readline().rstrip()\n var_3 = lambda: list(map(int, var_8().split()))\n var_1 = lambda: int(var_8())\n var_4 = 10**9 + 7\n var_2 = 10**9 + 10\n var_9, var_10 = var_8().split()\n var_5 = int(var_9)\n var_6 = int(float(var_10) * 100 + 0.5)\n print(var_5 * var_6 // 100)\n\n\nfunc_1()\n```\n\n=== Code B (Modified) ===\n```python\nimport math\n\nvar_1, var_2 = input().split()\nvar_1 = int(var_1)\nvar_3 = int(var_2[0] + var_2[2] + var_2[3])\nprint((int(var_1 * var_3) // 100))\n```", "output": "FASTER 1.9827", "pair_id": "python_p02659_pair0005_forward", "problem_id": "p02659", "language": "python", "direction": "forward", "speedup_ratio": 3.9522} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_4, var_3 = list(map(int, input().split()))\nvar_1 = 0\nfor var_2 in range(var_4, var_3 + 1):\n if str(var_2)[0] + str(var_2)[1] == str(var_2)[-1] + str(var_2)[-2]:\n var_1 += 1\nprint(var_1)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_4 = str(var_4)\n if var_4[0] == var_4[-1] and var_4[1] == var_4[-2]:\n var_3 += 1\nprint(var_3)\n```", "output": "FASTER 1.5248", "pair_id": "python_p03416_pair0033_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 2.8775} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_11 = int(eval(input()))\nvar_12 = {var_8: [] for var_8 in range(1, var_11 + 1)}\nvar_19 = [False for var_8 in range(var_11 + 1)]\nvar_16 = []\nfor _ in range(var_11 - 1):\n var_2, var_3 = list(map(int, input().split()))\n var_12[var_2].append(var_3)\n var_12[var_3].append(var_2)\n var_16.append((var_2, var_3))\nvar_9 = var_16[0][0]\nvar_19[var_9] = True\nvar_6 = []\nvar_7 = []\nvar_14 = {var_8: {} for var_8 in range(1, var_11 + 1)}\nvar_10 = [0 for var_8 in range(var_11 + 1)]\n\nvar_4 = 1\nfor var_5 in var_12[var_9]:\n var_19[var_5] = True\n var_14[var_9][var_5] = var_4\n var_14[var_5][var_9] = var_4\n var_10[var_5] = var_4\n var_4 += 1\n var_6.append(var_5)\nwhile var_6:\n for var_15 in var_6:\n var_13 = 1\n for var_5 in var_12[var_15]:\n if var_19[var_5] == False:\n var_19[var_5] = True\n if var_13 != var_10[var_15]:\n var_14[var_15][var_5] = var_13\n var_14[var_5][var_15] = var_13\n var_10[var_5] = var_13\n var_13 += 1\n var_7.append(var_5)\n else:\n var_13 += 1\n var_14[var_15][var_5] = var_13\n var_14[var_5][var_15] = var_13\n var_10[var_5] = var_13\n var_13 += 1\n var_7.append(var_5)\n if var_7:\n var_6 = var_7\n var_7 = []\n else:\n var_6 = []\n var_7 = []\nvar_1 = 0\nfor var_8 in range(1, var_11 + 1):\n var_1 = max(var_1, len(var_12[var_8]))\nprint(var_1)\nfor var_8 in range(var_11 - 1):\n var_17, var_18 = var_16[var_8][0], var_16[var_8][1]\n print((var_14[var_17][var_18]))\n```\n\n=== Code B (Modified) ===\n```python\n\"\"\"\"\"\"\n\nfrom collections import deque\n\n\ndef func_1():\n var_5, *var_1 = list(map(int, open(0).read().split()))\n var_2 = var_1[1::2]\n var_4 = [[] for _ in range(var_5 + 1)]\n for var_7, var_8 in zip(*[iter(var_1)] * 2):\n var_4[var_7] += (var_8,)\n var_6 = deque([1])\n var_3 = [0] * (var_5 + 1)\n while var_6:\n var_11 = var_6.popleft()\n var_9 = 0\n for var_10 in var_4[var_11]:\n var_9 += 1 + (var_9 + 1 == var_3[var_11])\n var_3[var_10] = var_9\n var_6 += (var_10,)\n print((max(var_3)))\n for var_8 in var_2:\n print((var_3[var_8]))\n\n\nfunc_1()\n```", "output": "FASTER 1.0038", "pair_id": "python_p02850_pair0002_forward", "problem_id": "p02850", "language": "python", "direction": "forward", "speedup_ratio": 2.0053} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_4 = {}\nvar_5 = 0\nfor var_6 in range(10000, 100000):\n var_3 = list(str(var_6))\n if var_3 == list(reversed(var_3)):\n var_5 += 1\n var_4[var_6] = var_5\nvar_1, var_2 = list(map(int, input().split()))\nprint((var_4[var_2] - var_4[var_1 - 1] if var_1 > 10000 else var_4[var_2]))\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_8 in range(var_1, var_2 + 1):\n var_7 = str(var_8)\n var_6 = len(var_7)\n var_4 = True\n for var_5 in range(var_6 // 2):\n if var_7[var_5] != var_7[var_6 - 1 - var_5]:\n var_4 = False\n break\n if var_4:\n var_3 += 1\nprint(var_3)\n```", "output": "FASTER 2.4474", "pair_id": "python_p03416_pair0034_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 5.4542} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_2, var_3, *var_1 = list(map(int, open(0).read().split()))\nvar_4 = [0] * (var_3 + max(var_1[::2]))\nfor var_7, var_6 in sorted(zip(*[iter(var_1)] * 2)):\n for var_5 in reversed(list(range(var_3))):\n var_4[var_5 + var_7] = max(var_4[var_5 + var_7], var_4[var_5] + var_6)\nprint((max(var_4)))\n```\n\n=== Code B (Modified) ===\n```python\nfrom collections import Counter, defaultdict, deque\nfrom heapq import heappop, heappush, heapify\nimport sys, bisect, math, itertools, fractions, pprint\n\nsys.setrecursionlimit(10**8)\nvar_6 = 10**9 + 7\nvar_1 = float(\"inf\")\n\n\ndef func_1():\n return int(sys.stdin.readline())\n\n\ndef func_2():\n return list(map(int, sys.stdin.readline().split()))\n\n\nvar_8, var_11 = func_2()\nvar_17 = [func_2() for _ in range(var_8)]\nvar_10 = var_17[::-1]\nvar_14 = [[0] * var_11 for _ in range(var_8)]\nvar_3 = [[0] * var_11 for _ in range(var_8)]\nfor var_4 in range(var_8 - 1):\n var_16, var_15 = var_17[var_4]\n for var_5 in range(var_11):\n if var_5 < var_16:\n var_14[var_4 + 1][var_5] = var_14[var_4][var_5]\n else:\n var_14[var_4 + 1][var_5] = max(\n var_14[var_4][var_5], var_14[var_4][var_5 - var_16] + var_15\n )\nvar_9 = var_14[var_8 - 1][var_11 - 1] + var_17[var_8 - 1][1]\nfor var_4 in range(var_8 - 1):\n var_16, var_15 = var_10[var_4]\n for var_5 in range(var_11):\n if var_5 < var_16:\n var_3[var_4 + 1][var_5] = var_3[var_4][var_5]\n else:\n var_3[var_4 + 1][var_5] = max(\n var_3[var_4][var_5], var_3[var_4][var_5 - var_16] + var_15\n )\n var_9 = max(var_9, var_3[var_8 - 1][var_11 - 1] + var_17[0][1])\n\nfor var_4 in range(1, var_8 - 1):\n var_13 = var_4\n var_2 = var_8 - var_4 - 1\n var_7 = 0\n for var_5 in range(var_11):\n var_12 = var_14[var_13][var_5] + var_3[var_2][var_11 - 1 - var_5]\n var_7 = max(var_7, var_12)\n var_9 = max(var_9, var_7 + var_17[var_4][1])\nprint(var_9)\n```", "output": "SLOWER 1.5875", "pair_id": "python_p02863_pair0009_reversed", "problem_id": "p02863", "language": "python", "direction": "reversed", "speedup_ratio": 3.0053} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n if str(var_4) == \"\".join(reversed(str(var_4))):\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = str(var_4)\n if var_5 == var_5[::-1]:\n var_3 += 1\nprint(var_3)\n```", "output": "FASTER 1.0807", "pair_id": "python_p03416_pair0035_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 2.1151} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = input().split()\nvar_1 = int(var_1)\nvar_2 = int(var_2)\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = list(str(var_4))\n if (var_5[0] == var_5[4]) and (var_5[1] == var_5[3]):\n var_3 = var_3 + 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_3 = list(map(int, input().split()))\nvar_2 = 0\nfor var_5 in range(var_3 + 1)[var_1:]:\n if len(str(var_5)) % 2 == 0:\n var_6 = list(str(var_5))[: len(str(var_5)) // 2]\n var_7 = list(reversed(list(str(var_5))[len(str(var_5)) // 2 :]))\n if var_6 == var_7:\n var_2 += 1\n else:\n var_8 = list(str(var_5))[: len(str(var_5)) // 2 + 1]\n var_4 = list(reversed(list(str(var_5))[len(str(var_5)) // 2 :]))\n if var_8 == var_4:\n var_2 += 1\nprint(var_2)\n```", "output": "SLOWER 2.0702", "pair_id": "python_p03416_pair0036_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 4.1995} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nfrom collections import Counter\n\nvar_1 = input()[::-1]\nvar_5 = [0]\nvar_4 = 0\nvar_6 = 2019\nfor var_7 in var_1:\n var_8 = int(var_7) * pow(10, var_4, var_6) % var_6\n var_8 = var_5[-1] + var_8\n var_5.append(var_8 % var_6)\n var_4 += 1\nvar_3 = Counter(var_5)\nvar_2 = sum(var_9 * (var_9 - 1) // 2 for var_9 in list(var_3.values()))\nprint(var_2)\n```\n\n=== Code B (Modified) ===\n```python\nvar_5 = input()[::-1]\nvar_2 = [0] * 2019\nvar_2[0] = 1\nvar_4 = 0\nvar_6 = 1\nvar_1 = 0\nfor var_3 in var_5:\n var_4 = (var_4 + int(var_3) * var_6) % 2019\n var_6 = var_6 * 10 % 2019\n var_2[var_4] += 1\nfor var_3 in var_2:\n var_1 += var_3 * (var_3 - 1) // 2\nprint(var_1)\n```", "output": "SLOWER 1.9367", "pair_id": "python_p02702_pair0002_reversed", "problem_id": "p02702", "language": "python", "direction": "reversed", "speedup_ratio": 3.8282} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\n\nvar_7 = sys.stdin.readline\nfrom itertools import combinations\n\n\ndef func_3(var_10):\n for _ in range(var_10):\n yield list(map(int, var_7().split()))\n\n\ndef func_1(var_9, var_5, var_11):\n var_3 = len([0 for var_8 in var_9 if var_5[var_8] == 1])\n return var_11[var_3]\n\n\ndef func_2():\n var_10 = int(eval(var_7()))\n var_1 = list(func_3(var_10))\n var_2 = list(func_3(var_10))\n for var_6 in range(1, 11):\n for var_4 in combinations(list(range(10)), var_6):\n yield sum(\n func_1(var_4, var_5, var_11) for var_5, var_11 in zip(var_1, var_2)\n )\n\n\nprint((max(func_2())))\n```\n\n=== Code B (Modified) ===\n```python\nimport itertools\n\nvar_6 = int(eval(input()))\nvar_2 = [[]] * var_6\nfor var_4 in range(var_6):\n var_3 = list(map(int, input().split()))\n\n var_2[var_4] = var_3\nvar_8 = [[]] * var_6\nfor var_4 in range(var_6):\n var_9 = list(map(int, input().split()))\n var_8[var_4] = var_9\nvar_10 = -(10**11)\nfor var_1 in itertools.product([0, 1], repeat=10):\n if sum(var_1) == 0:\n continue\n var_11 = 0\n for var_7 in range(var_6):\n var_5 = 0\n for var_4 in range(10):\n if var_2[var_7][var_4] == 1 and var_1[var_4] == 1:\n var_5 += 1\n var_11 = var_11 + var_8[var_7][var_5]\n var_10 = max(var_10, var_11)\nprint(var_10)\n```", "output": "SLOWER 1.5941", "pair_id": "python_p03503_pair0002_reversed", "problem_id": "p03503", "language": "python", "direction": "reversed", "speedup_ratio": 3.019} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\ndef func_1():\n var_1, var_2 = list(map(int, input().rstrip().split()))\n var_3 = 0\n for var_4 in range(var_1, var_2 + 1):\n var_5 = str(var_4)\n if var_5 == var_5[::-1]:\n var_3 += 1\n print(var_3)\n\n\nif __name__ == \"__main__\":\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = list(str(var_4))\n if var_5 == list(reversed(var_5)):\n var_3 += 1\nprint(var_3)\n```", "output": "SLOWER 1.9782", "pair_id": "python_p03416_pair0037_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 3.9399} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\n\nsys.setrecursionlimit(2147483647)\nvar_2 = float(\"inf\")\nvar_3 = 10**9 + 7\nvar_10 = lambda: sys.stdin.readline().rstrip()\n\n\ndef func_1():\n var_11, var_4 = list(map(int, var_10().split()))\n var_1 = [tuple(map(int, var_10().split())) for _ in range(var_11)]\n var_1.sort()\n var_8 = [0] * var_4\n var_6 = -var_2\n for var_9 in range(var_11):\n var_5, var_7 = var_1[var_9]\n var_12 = var_8[:]\n for var_13 in range(var_4):\n if var_13 + var_5 < var_4:\n var_12[var_13 + var_5] = max(\n var_12[var_13 + var_5], var_8[var_13] + var_7\n )\n else:\n var_6 = max(var_6, var_8[var_13] + var_7)\n var_8 = var_12\n print((max(var_6, max(var_8))))\n\n\nfunc_1()\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\n\nvar_10 = sys.stdin.readline\nvar_2, var_3 = list(map(int, var_10().split()))\nvar_1 = [list(map(int, var_10().split())) for _ in range(var_2)]\nvar_8 = [[0 for _ in range(var_2 + 1)] for _ in range(var_3 + 1)]\n\nvar_13 = [[0 for _ in range(var_2 + 1)] for _ in range(var_3 + 1)]\nfor var_11 in range(var_2):\n var_4, var_6 = var_1[var_11]\n for var_15 in range(var_3):\n if var_4 > var_15:\n var_8[var_15][var_11 + 1] = var_8[var_15][var_11]\n var_13[var_15][var_11 + 1] = var_15\n else:\n if var_6 + var_8[var_15 - var_4][var_11] >= var_8[var_15][var_11]:\n var_8[var_15][var_11 + 1] = var_8[var_15 - var_4][var_11] + var_6\n var_13[var_15][var_11 + 1] = var_15 - var_4\n else:\n var_8[var_15][var_11 + 1] = var_8[var_15][var_11]\n var_13[var_15][var_11 + 1] = var_15\nvar_5 = var_8[var_3 - 1][var_2]\nvar_14 = [False] * var_2\nvar_7 = var_3 - 1\nfor var_9 in reversed(list(range(var_2))):\n if var_13[var_7][var_9 + 1] == var_7 - var_1[var_9][0]:\n var_14[var_9] = True\n var_7 = var_13[var_7][var_9 + 1]\nvar_12 = 0\nfor var_9 in range(var_2):\n if not var_14[var_9] and var_1[var_9][1] > var_12:\n var_12 = var_1[var_9][1]\nprint((var_5 + var_12))\n```", "output": "SLOWER 1.5241", "pair_id": "python_p02863_pair0010_reversed", "problem_id": "p02863", "language": "python", "direction": "reversed", "speedup_ratio": 2.8761} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nfrom sys import stdin\n\n\ndef func_1():\n\n var_11 = stdin.readline\n var_2 = int(var_11())\n var_1 = []\n for var_6 in range(var_2):\n var_5 = int(\"\".join(var_11().strip().split(\" \")), 2)\n var_1.append(var_5)\n var_3 = []\n for var_6 in range(var_2):\n var_10 = list(map(int, var_11().split()))\n var_3.append(var_10)\n var_8 = float(\"-inf\")\n for var_9 in range(1, 1 << 10):\n var_12 = 0\n for var_7 in range(var_2):\n var_4 = bin(var_9 & var_1[var_7]).count(\"1\")\n var_12 += var_3[var_7][var_4]\n var_8 = max(var_12, var_8)\n print(var_8)\n\n\nif __name__ == \"__main__\":\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\n\nvar_7 = sys.stdin.readline\nfrom itertools import combinations\n\n\ndef func_3(var_10):\n for _ in range(var_10):\n yield list(map(int, var_7().split()))\n\n\ndef func_1(var_9, var_5, var_11):\n var_3 = sum(1 if var_5[var_8] == 1 else 0 for var_8 in var_9)\n return var_11[var_3]\n\n\ndef func_2():\n var_10 = int(eval(var_7()))\n var_1 = list(func_3(var_10))\n var_2 = list(func_3(var_10))\n for var_6 in range(1, 11):\n for var_4 in combinations(list(range(10)), var_6):\n yield sum(\n func_1(var_4, var_5, var_11) for var_5, var_11 in zip(var_1, var_2)\n )\n\n\nprint((max(func_2())))\n```", "output": "SLOWER 1.801", "pair_id": "python_p03503_pair0003_reversed", "problem_id": "p03503", "language": "python", "direction": "reversed", "speedup_ratio": 3.4845} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = [\n var_3 for var_3 in map(str, list(range(var_1, var_2 + 1))) if var_3 == var_3[::-1]\n]\nprint((len(var_4)))\n```\n\n=== Code B (Modified) ===\n```python\nvar_10 = []\nvar_10 = input().rstrip().split(\" \")\nvar_1 = int(var_10[0])\nvar_3 = int(var_10[1])\nvar_2 = 0\nvar_6 = var_1\nwhile var_6 <= var_3:\n var_4 = var_6 // 10000\n var_5 = (var_6 - var_4 * 10000) // 1000\n var_7 = var_6 // 100\n var_8 = (var_6 - var_7 * 100) // 10\n var_9 = var_6 % 10\n if (var_4 == var_9) and (var_5 == var_8):\n var_2 += 1\n var_6 += 1\nprint(var_2)\n```", "output": "SLOWER 1.5076", "pair_id": "python_p03416_pair0038_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 2.8433} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\ndef func_1():\n var_1, var_2 = list(map(int, input().split()))\n var_3 = 0\n for var_4 in range(var_1, var_2 + 1):\n\n if (var_4 % 10) == (var_4 // 10000 % 10) and (var_4 // 10 % 10) == (\n var_4 // 1000 % 10\n ):\n var_3 += 1\n print(var_3)\n\n\nif __name__ == \"__main__\":\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_3 in range(var_1, var_2 + 1):\n var_5 = list(str(var_3))\n var_6 = list(reversed(var_5))\n if var_5 == var_6:\n var_4 += 1\nprint(var_4)\n```", "output": "SLOWER 2.9727", "pair_id": "python_p03416_pair0039_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 7.85} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\nimport math\nfrom collections import defaultdict\nfrom bisect import bisect_left, bisect_right\n\nsys.setrecursionlimit(10**7)\n\n\ndef func_4():\n return sys.stdin.readline()[:-1]\n\n\nvar_4 = 10**9 + 7\n\n\ndef func_1():\n return int(eval(func_4()))\n\n\ndef func_2():\n return list(map(int, func_4().split()))\n\n\ndef func_3(var_6, var_3):\n if var_6 <= 0:\n return [[] for _ in range(var_3)]\n elif var_3 == 1:\n return [func_1() for _ in range(var_6)]\n else:\n var_5 = [func_2() for _ in range(var_6)]\n return list(map(list, list(zip(*var_5))))\n\n\nfrom decimal import getcontext, Decimal\n\ngetcontext().prec = 28\nvar_1, var_2 = list(map(str, func_4().split()))\nvar_1 = int(var_1)\nvar_2 = Decimal(var_2)\nprint((int(var_1 * var_2)))\n```\n\n=== Code B (Modified) ===\n```python\nfrom fractions import Fraction\n\nvar_1, var_2 = input().split()\n\n\nfrom decimal import *\n\nvar_4 = var_3(var_1)\nvar_6 = var_3(var_2)\nvar_7().prec = 28\nvar_5 = var_4 * var_6\nprint((int(var_5)))\n```", "output": "FASTER 1.9011", "pair_id": "python_p02659_pair0006_forward", "problem_id": "p02659", "language": "python", "direction": "forward", "speedup_ratio": 3.7349} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().strip().split(\" \")))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n if str(var_4) == str(var_4)[::-1]:\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_5 in range(10):\n for var_6 in range(10):\n for var_7 in range(10):\n var_3 = 10000 * var_5 + 1000 * var_6 + 100 * var_7 + 10 * var_6 + var_5\n if var_1 <= var_3 <= var_2:\n var_4 += 1\nprint(var_4)\n```", "output": "FASTER 4.1328", "pair_id": "python_p03416_pair0040_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 17.5431} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_4 = {}\nvar_5 = 0\nfor var_6 in range(10000, 100000):\n var_3 = list(str(var_6))\n if var_3 == list(reversed(var_3)):\n var_5 += 1\n var_4[var_6] = var_5\nvar_1, var_2 = list(map(int, input().split()))\nprint((var_4[var_2] - var_4[var_1 - 1] if var_1 > 10000 else var_4[var_2]))\n```\n\n=== Code B (Modified) ===\n```python\nvar_10 = []\nvar_10 = input().rstrip().split(\" \")\nvar_1 = int(var_10[0])\nvar_3 = int(var_10[1])\nvar_2 = 0\nvar_6 = var_1\nwhile var_6 <= var_3:\n var_4 = var_6 // 10000\n var_5 = (var_6 - var_4 * 10000) // 1000\n var_7 = var_6 // 100\n var_8 = (var_6 - var_7 * 100) // 10\n var_9 = var_6 % 10\n if (var_4 == var_9) and (var_5 == var_8):\n var_2 += 1\n var_6 += 1\nprint(var_2)\n```", "output": "FASTER 2.7646", "pair_id": "python_p03416_pair0041_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 6.7956} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\n\n\ndef func_1(var_5, var_6):\n var_4 = 0\n for var_3 in range(var_5, var_6 + 1):\n if str(var_3) == str(var_3)[::-1]:\n var_4 += 1\n return var_4\n\n\nprint((func_1(var_1, var_2)))\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_8 in range(var_1, var_2 + 1):\n var_7 = str(var_8)\n var_6 = len(var_7)\n var_4 = True\n for var_5 in range(var_6 // 2):\n if var_7[var_5] != var_7[var_6 - 1 - var_5]:\n var_4 = False\n break\n if var_4:\n var_3 += 1\nprint(var_3)\n```", "output": "SLOWER 1.4499", "pair_id": "python_p03416_pair0042_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 2.7318} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n if list(str(var_4)) == list(reversed(str(var_4))):\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = str(var_4)\n if var_5 == var_5[::-1]:\n var_3 += 1\nprint(var_3)\n```", "output": "FASTER 1.4048", "pair_id": "python_p03416_pair0043_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 2.6479} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_4 = {}\nvar_5 = 0\nfor var_6 in range(10000, 100000):\n var_3 = list(str(var_6))\n if var_3 == list(reversed(var_3)):\n var_5 += 1\n var_4[var_6] = var_5\nvar_1, var_2 = list(map(int, input().split()))\nprint((var_4[var_2] - var_4[var_1 - 1] if var_1 > 10000 else var_4[var_2]))\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_4 = str(var_4)\n if var_4[0] == var_4[-1] and var_4[1] == var_4[-2]:\n var_3 += 1\nprint(var_3)\n```", "output": "FASTER 3.7573", "pair_id": "python_p03416_pair0044_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 13.5227} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_2 = int(eval(input()))\nvar_1 = list(map(int, input().split()))\nvar_4 = 1\nfor var_3 in range(var_2):\n if var_1[var_3] % 2 == 0:\n var_4 *= 2\nprint((3**var_2 - var_4))\n```\n\n=== Code B (Modified) ===\n```python\nfrom itertools import product\n\nvar_6 = int(eval(input()))\nvar_1 = list(map(int, input().split()))\nvar_5 = 0\nfor var_2 in product((-1, 0, 1), repeat=var_6):\n var_7 = 1\n for var_3, var_4 in zip(var_1, var_2):\n var_7 *= var_3 + var_4\n if var_7 % 2 == 0:\n var_5 += 1\nprint(var_5)\n```", "output": "SLOWER 10.0467", "pair_id": "python_p03568_pair0004_reversed", "problem_id": "p03568", "language": "python", "direction": "reversed", "speedup_ratio": 1057.6766} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_5 in range(var_1, var_2 + 1):\n var_3 = str(var_5)\n if var_3[0] == var_3[-1] and var_3[1] == var_3[-2]:\n var_4 += 1\nprint(var_4)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = [0] * (var_2 + 1)\nfor var_3 in range(1, var_2 + 1):\n if str(var_3) == str(var_3)[::-1]:\n var_4[var_3] = var_4[var_3 - 1] + 1\n else:\n var_4[var_3] = var_4[var_3 - 1]\nprint((var_4[var_2] - var_4[var_1 - 1]))\n```", "output": "SLOWER 2.0339", "pair_id": "python_p03416_pair0021_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 4.095} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_7 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_3 = True\n var_8 = str(var_4)\n var_6 = len(var_8)\n for var_5 in range(var_6 // 2 + 1):\n if var_8[var_5] != var_8[-var_5 - 1]:\n var_3 = False\n break\n if var_3:\n var_7 += 1\nprint(var_7)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_3 = list(map(int, input().split()))\nvar_2 = 0\nfor var_5 in range(var_3 + 1)[var_1:]:\n if len(str(var_5)) % 2 == 0:\n var_6 = list(str(var_5))[: len(str(var_5)) // 2]\n var_7 = list(reversed(list(str(var_5))[len(str(var_5)) // 2 :]))\n if var_6 == var_7:\n var_2 += 1\n else:\n var_8 = list(str(var_5))[: len(str(var_5)) // 2 + 1]\n var_4 = list(reversed(list(str(var_5))[len(str(var_5)) // 2 :]))\n if var_8 == var_4:\n var_2 += 1\nprint(var_2)\n```", "output": "SLOWER 1.3494", "pair_id": "python_p03416_pair0045_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 2.5481} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\n\nvar_7 = sys.stdin.readline\nfrom itertools import combinations\n\n\ndef func_3(var_10):\n for _ in range(var_10):\n yield list(map(int, var_7().split()))\n\n\ndef func_1(var_9, var_5, var_11):\n var_3 = sum(1 if var_5[var_8] == 1 else 0 for var_8 in var_9)\n return var_11[var_3]\n\n\ndef func_2():\n var_10 = int(eval(var_7()))\n var_1 = list(func_3(var_10))\n var_2 = list(func_3(var_10))\n for var_6 in range(1, 11):\n for var_4 in combinations(list(range(10)), var_6):\n yield sum(\n func_1(var_4, var_5, var_11) for var_5, var_11 in zip(var_1, var_2)\n )\n\n\nprint((max(func_2())))\n```\n\n=== Code B (Modified) ===\n```python\nvar_5 = 0\nif var_5 == 0:\n var_8 = int(eval(input()))\n var_2 = []\n for var_4 in range(var_8):\n var_3 = list(map(int, input().split()))\n var_2.append(var_3)\n var_9 = []\n for var_4 in range(var_8):\n var_10 = list(map(int, input().split()))\n var_9.append(var_10)\nelif var_5 == 1:\n var_8 = 1\n var_2 = [[1, 1, 0, 1, 0, 0, 0, 1, 0, 1]]\n var_9 = [[3, 4, 5, 6, 7, 8, 9, -2, -3, 4, -2]]\nelif var_5 == 2:\n var_8 = 2\n var_2 = [[1, 1, 1, 1, 1, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 1, 1, 1, 1, 1]]\n var_9 = [\n [0, -2, -2, -2, -2, -2, -1, -1, -1, -1, -1],\n [0, -2, -2, -2, -2, -2, -1, -1, -1, -1, -1],\n ]\nelif var_5 == 3:\n var_8 = 3\n var_2 = [\n [1, 1, 1, 1, 1, 1, 0, 0, 1, 1],\n [0, 1, 0, 1, 1, 1, 1, 0, 1, 0],\n [1, 0, 1, 1, 0, 1, 0, 1, 0, 1],\n ]\n var_9 = [\n [-8, 6, -2, -8, -8, 4, 8, 7, -6, 2, 2],\n [-9, 2, 0, 1, 7, -5, 0, -2, -6, 5, 5],\n [6, -6, 7, -9, 6, -5, 8, 0, -9, -7, -7],\n ]\nimport itertools\n\nvar_13 = -(10**11)\nfor var_4 in itertools.product([0, 1], repeat=10):\n var_11 = list(var_4)\n var_12 = 0\n if sum(var_11) != 0:\n for var_7 in range(var_8):\n var_1 = 0\n for var_6 in range(10):\n var_1 = var_1 + var_11[var_6] * var_2[var_7][var_6]\n var_12 = var_12 + var_9[var_7][var_1]\n\n var_13 = max(var_12, var_13)\nprint(var_13)\n```", "output": "SLOWER 1.4725", "pair_id": "python_p03503_pair0004_reversed", "problem_id": "p03503", "language": "python", "direction": "reversed", "speedup_ratio": 2.775} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\ndef func_1():\n from sys import setrecursionlimit, stdin\n from os import environ\n from collections import defaultdict, deque, Counter\n from math import ceil, floor, gcd\n from itertools import accumulate, combinations, combinations_with_replacement\n\n setrecursionlimit(10**6)\n var_7 = (\n (lambda *var_11: print(*var_11))\n if \"TERM_PROGRAM\" in environ\n else lambda *var_12: 0\n )\n var_8 = lambda: stdin.readline().rstrip()\n var_3 = lambda: list(map(int, var_8().split()))\n var_1 = lambda: int(var_8())\n var_4 = 10**9 + 7\n var_2 = 10**9 + 10\n var_9, var_10 = var_8().split()\n var_5 = int(var_9)\n var_6 = int(float(var_10) * 100 + 0.5)\n print(var_5 * var_6 // 100)\n\n\nfunc_1()\n```\n\n=== Code B (Modified) ===\n```python\nfrom fractions import Fraction\n\nvar_1, var_2 = input().split()\n\n\nfrom decimal import *\n\nvar_4 = var_3(var_1)\nvar_6 = var_3(var_2)\nvar_7().prec = 28\nvar_5 = var_4 * var_6\nprint((int(var_5)))\n```", "output": "FASTER 1.6242", "pair_id": "python_p02659_pair0007_forward", "problem_id": "p02659", "language": "python", "direction": "forward", "speedup_ratio": 3.0827} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = [\n var_3 for var_3 in map(str, list(range(var_1, var_2 + 1))) if var_3 == var_3[::-1]\n]\nprint((len(var_4)))\n```\n\n=== Code B (Modified) ===\n```python\nvar_4 = {}\nvar_5 = 0\nfor var_6 in range(10000, 100000):\n var_3 = list(str(var_6))\n if var_3 == list(reversed(var_3)):\n var_5 += 1\n var_4[var_6] = var_5\nvar_1, var_2 = list(map(int, input().split()))\nprint((var_4[var_2] - var_4[var_1 - 1] if var_1 > 10000 else var_4[var_2]))\n```", "output": "SLOWER 4.2722", "pair_id": "python_p03416_pair0046_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 19.3219} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\ndef func_1():\n var_2 = int(eval(input()))\n var_1 = [int(var_6) for var_6 in input().split()]\n var_4 = 3**var_2\n var_5 = len([var_3 for var_3 in var_1 if var_3 % 2 == 0])\n var_4 -= 2**var_5\n print(var_4)\n\n\nif __name__ == \"__main__\":\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nimport numpy as np\nfrom itertools import product\n\nvar_6 = int(eval(input()))\nvar_2 = list(map(int, input().split()))\nvar_2 = np.array(var_2)\nvar_5 = [-1, 0, 1]\nvar_3 = 0\nfor var_7 in product(var_5, repeat=var_6):\n var_7 = np.array(var_7)\n var_1 = var_2 + var_7\n var_4 = var_1.cumprod()\n if var_4[-1] % 2 == 0:\n var_3 += 1\nprint(var_3)\n```", "output": "SLOWER 9.5157", "pair_id": "python_p03568_pair0005_reversed", "problem_id": "p03568", "language": "python", "direction": "reversed", "speedup_ratio": 732.014} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = list(reversed(list(str(var_4))))\n if var_5 == list(str(var_4)):\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\n\n\ndef func_1(var_5, var_6):\n var_4 = 0\n for var_3 in range(var_5, var_6 + 1):\n if str(var_3) == str(var_3)[::-1]:\n var_4 += 1\n return var_4\n\n\nprint((func_1(var_1, var_2)))\n```", "output": "FASTER 1.9806", "pair_id": "python_p03416_pair0047_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 3.9465} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = str(var_4)\n if var_5 == var_5[::-1]:\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = [0] * (var_2 + 1)\nfor var_3 in range(1, var_2 + 1):\n if str(var_3) == str(var_3)[::-1]:\n var_4[var_3] = var_4[var_3 - 1] + 1\n else:\n var_4[var_3] = var_4[var_3 - 1]\nprint((var_4[var_2] - var_4[var_1 - 1]))\n```", "output": "SLOWER 1.9467", "pair_id": "python_p03416_pair0048_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 3.855} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_4 = str(var_4)\n if var_4 == var_4[::-1]:\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().rstrip().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = list(map(int, list(str(var_4))))\n if var_5[0] == var_5[4] and var_5[1] == var_5[3]:\n var_3 += 1\nprint(var_3)\n```", "output": "SLOWER 1.536", "pair_id": "python_p03416_pair0049_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 2.8999} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nfor var_3 in range(1, 1009):\n if int(var_3 * 0.08) == var_1 and int(var_3 * 0.1) == var_2:\n print((int(var_3)))\n exit()\nprint(\"-1\")\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_2 = var_2 / 0.1\nvar_3 = [var_4 + var_2 for var_4 in range(10)]\nfor var_4 in var_3:\n if int(var_4 * 0.08) == var_1:\n print((int(var_4)))\n exit()\nprint(\"-1\")\n```", "output": "FASTER 1.9094", "pair_id": "python_p02755_pair0003_forward", "problem_id": "p02755", "language": "python", "direction": "forward", "speedup_ratio": 3.7565} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nfrom collections import Counter, defaultdict, deque\nfrom heapq import heappop, heappush, heapify\nimport sys, bisect, math, itertools, fractions, pprint\n\nsys.setrecursionlimit(10**8)\nvar_6 = 10**9 + 7\nvar_1 = float(\"inf\")\n\n\ndef func_1():\n return int(sys.stdin.readline())\n\n\ndef func_2():\n return list(map(int, sys.stdin.readline().split()))\n\n\nvar_8, var_11 = func_2()\nvar_17 = [func_2() for _ in range(var_8)]\nvar_10 = var_17[::-1]\nvar_14 = [[0] * var_11 for _ in range(var_8)]\nvar_3 = [[0] * var_11 for _ in range(var_8)]\nfor var_4 in range(var_8 - 1):\n var_16, var_15 = var_17[var_4]\n for var_5 in range(var_11):\n if var_5 < var_16:\n var_14[var_4 + 1][var_5] = var_14[var_4][var_5]\n else:\n var_14[var_4 + 1][var_5] = max(\n var_14[var_4][var_5], var_14[var_4][var_5 - var_16] + var_15\n )\nvar_9 = var_14[var_8 - 1][var_11 - 1] + var_17[var_8 - 1][1]\nfor var_4 in range(var_8 - 1):\n var_16, var_15 = var_10[var_4]\n for var_5 in range(var_11):\n if var_5 < var_16:\n var_3[var_4 + 1][var_5] = var_3[var_4][var_5]\n else:\n var_3[var_4 + 1][var_5] = max(\n var_3[var_4][var_5], var_3[var_4][var_5 - var_16] + var_15\n )\n var_9 = max(var_9, var_3[var_8 - 1][var_11 - 1] + var_17[0][1])\n\nfor var_4 in range(1, var_8 - 1):\n var_13 = var_4\n var_2 = var_8 - var_4 - 1\n var_7 = 0\n for var_5 in range(var_11):\n var_12 = var_14[var_13][var_5] + var_3[var_2][var_11 - 1 - var_5]\n var_7 = max(var_7, var_12)\n var_9 = max(var_9, var_7 + var_17[var_4][1])\nprint(var_9)\n```\n\n=== Code B (Modified) ===\n```python\ndef func_1():\n var_2, var_3, *var_1 = list(map(int, open(0).read().split()))\n var_4 = [0] * (var_3 + max(var_1[::2]))\n for var_7, var_6 in sorted(zip(*[iter(var_1)] * 2)):\n for var_5 in reversed(list(range(var_3))):\n var_4[var_5 + var_7] = max(var_4[var_5 + var_7], var_4[var_5] + var_6)\n print((max(var_4)))\n\n\nfunc_1()\n```", "output": "FASTER 2.2995", "pair_id": "python_p02863_pair0011_forward", "problem_id": "p02863", "language": "python", "direction": "forward", "speedup_ratio": 4.9229} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport bisect, copy, heapq, math, sys\nfrom collections import *\nfrom functools import lru_cache\nfrom itertools import accumulate, combinations, permutations, product\n\n\ndef func_2():\n return sys.stdin.readline()[:-1]\n\n\ndef func_4(var_8):\n return [0] + list(accumulate(var_8))\n\n\ndef func_1(var_1, var_4):\n return -(-var_1 // var_4)\n\n\nsys.setrecursionlimit(5000000)\nvar_9 = pow(10, 9) + 7\nvar_2 = [chr(ord(\"a\") + var_6) for var_6 in range(26)]\nvar_5 = [[1, 0], [0, 1], [-1, 0], [0, -1]]\nvar_11 = int(eval(func_2()))\n\n\ndef func_3(var_10):\n if var_10 == 1:\n return False\n for var_7 in range(2, int(math.sqrt(var_10)) + 1):\n if var_10 % var_7 == 0:\n return False\n return True\n\n\nvar_3 = var_11\nwhile not func_3(var_3):\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\n\n\ndef func_1():\n return sys.stdin.readline()[:-1]\n\n\nvar_3 = int(eval(func_1()))\nwhile 1:\n var_1 = 0\n for var_2 in range(2, int(var_3 ** (1 / 2))):\n if var_3 % var_2 == 0:\n var_1 = 1\n break\n if var_1 == 0:\n break\n var_3 += 1\nprint(var_3)\n```", "output": "FASTER 1.4121", "pair_id": "python_p02819_pair0004_forward", "problem_id": "p02819", "language": "python", "direction": "forward", "speedup_ratio": 2.6613} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\nimport math\nfrom collections import defaultdict\nfrom bisect import bisect_left, bisect_right\n\nsys.setrecursionlimit(10**7)\n\n\ndef func_4():\n return sys.stdin.readline()[:-1]\n\n\nvar_4 = 10**9 + 7\n\n\ndef func_1():\n return int(eval(func_4()))\n\n\ndef func_2():\n return list(map(int, func_4().split()))\n\n\ndef func_3(var_6, var_3):\n if var_6 <= 0:\n return [[] for _ in range(var_3)]\n elif var_3 == 1:\n return [func_1() for _ in range(var_6)]\n else:\n var_5 = [func_2() for _ in range(var_6)]\n return list(map(list, list(zip(*var_5))))\n\n\nfrom decimal import getcontext, Decimal\n\ngetcontext().prec = 28\nvar_1, var_2 = list(map(str, func_4().split()))\nvar_1 = int(var_1)\nvar_2 = Decimal(var_2)\nprint((int(var_1 * var_2)))\n```\n\n=== Code B (Modified) ===\n```python\nimport math\nfrom decimal import Decimal\n\nvar_1, var_2 = list(map(Decimal, input().split()))\nprint((math.floor(var_1 * var_2)))\n```", "output": "FASTER 2.4359", "pair_id": "python_p02659_pair0008_forward", "problem_id": "p02659", "language": "python", "direction": "forward", "speedup_ratio": 5.4109} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_3 in range(var_1, var_2 + 1):\n var_5 = list(str(var_3))\n var_6 = list(reversed(var_5))\n if var_5 == var_6:\n var_4 += 1\nprint(var_4)\n```\n\n=== Code B (Modified) ===\n```python\ndef func_1():\n var_1, var_2 = list(map(int, input().split()))\n var_3 = 0\n for var_4 in range(var_1, var_2 + 1):\n\n if (var_4 % 10) == (var_4 // 10000 % 10) and (var_4 // 10 % 10) == (\n var_4 // 1000 % 10\n ):\n var_3 += 1\n print(var_3)\n\n\nif __name__ == \"__main__\":\n func_1()\n```", "output": "FASTER 2.9727", "pair_id": "python_p03416_pair0039_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 7.85} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport bisect\nimport sys\n\nsys.setrecursionlimit(10**6)\nvar_17 = sys.stdout.write\nvar_7 = lambda *var_15: print(*var_15) if var_1 else 0\nvar_1 = True\n\n\ndef func_1(var_10=sys.stdin.readline):\n var_12 = lambda: var_10().rstrip()\n var_3 = lambda: list(map(int, var_12().split()))\n var_2 = lambda: int(var_12())\n var_4 = lambda var_18: [var_3() for _ in range(var_18)]\n var_14, var_16 = var_3()\n var_5 = var_4(var_14)\n var_8 = [[0] * var_16 for _ in range(var_14)]\n for var_11 in range(1, var_14):\n for var_13 in range(1, var_16):\n if var_13 < var_5[var_11 - 1][0]:\n var_8[var_11][var_13] = var_8[var_11 - 1][var_13]\n else:\n var_8[var_11][var_13] = max(\n var_8[var_11 - 1][var_13],\n var_8[var_11 - 1][var_13 - var_5[var_11 - 1][0]]\n + var_5[var_11 - 1][1],\n )\n var_9 = [[0] * var_16 for _ in range(var_14)]\n for var_11 in range(1, var_14):\n for var_13 in range(1, var_16):\n if var_13 < var_5[var_14 - var_11][0]:\n var_9[var_11][var_13] = var_9[var_11 - 1][var_13]\n else:\n var_9[var_11][var_13] = max(\n var_9[var_11 - 1][var_13],\n var_9[var_11 - 1][var_13 - var_5[var_14 - var_11][0]]\n + var_5[var_14 - var_11][1],\n )\n var_6 = 0\n for var_11 in range(var_14):\n for var_13 in range(var_16 - 1):\n var_6 = max(\n var_6,\n var_8[var_11][var_13]\n + var_9[var_14 - var_11 - 1][var_16 - var_13 - 1]\n + var_5[var_11][1],\n )\n print(var_6)\n\n\nif __name__ == \"__main__\":\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\nfrom operator import itemgetter\nfrom heapq import heapify, heappop, heappush\n\nvar_1 = int(10e15)\nvar_2 = -var_1\nvar_11 = 1000000007\nsys.setrecursionlimit(1000000)\n\n\ndef func_2():\n return list(map(int, input().split()))\n\n\ndef func_4():\n return input().split()\n\n\ndef func_1():\n return int(sys.stdin.readline())\n\n\ndef func_3():\n return eval(input())\n\n\nvar_3, var_4 = func_2()\nvar_5 = [func_2() for var_9 in range(var_3)]\nvar_5.sort(key=itemgetter(0))\n\nvar_8 = [[0] * (var_4 + 1 + 3000 + 1) for _ in range(var_3 + 1)]\nvar_6 = 0\nfor var_9 in range(var_3):\n for var_10 in range(var_4 + 1 + 3000 + 1):\n var_12, var_7 = var_5[var_9]\n if 0 <= var_10 - var_12 < var_4:\n var_8[var_9 + 1][var_10] = max(\n var_8[var_9][var_10], var_8[var_9][var_10 - var_12] + var_7\n )\n else:\n var_8[var_9 + 1][var_10] = var_8[var_9][var_10]\n var_6 = max(var_6, var_8[var_9 + 1][var_10])\nprint(var_6)\n```", "output": "SLOWER 4.4124", "pair_id": "python_p02863_pair0012_reversed", "problem_id": "p02863", "language": "python", "direction": "reversed", "speedup_ratio": 21.2943} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\n\n\ndef func_1():\n var_9 = int(sys.stdin.readline().rstrip())\n var_8 = list(map(int, sys.stdin.read().split()))\n var_2 = list(zip(var_8, var_8))\n var_7 = [[] for _ in range(var_9 + 1)]\n for var_1, var_3 in var_2:\n var_7[var_1].append(var_3)\n var_7[var_3].append(var_1)\n var_13 = 1\n var_11 = [None] * (var_9 + 1)\n\n var_5 = []\n var_14 = [var_13]\n\n while var_14:\n var_15 = var_14.pop()\n\n for var_16 in var_7[var_15]:\n if var_16 == var_11[var_15]:\n continue\n\n var_11[var_16] = var_15\n var_14.append(var_16)\n var_5.append(var_15)\n var_6 = [-1] * (var_9 + 1)\n for var_15 in var_5:\n var_10 = var_6[var_15]\n var_4 = 1\n for var_16 in var_7[var_15]:\n if var_16 == var_11[var_15]:\n continue\n if var_4 == var_10:\n var_4 += 1\n var_6[var_16] = var_4\n var_4 += 1\n var_12 = []\n for var_1, var_3 in var_2:\n if var_1 == var_11[var_3]:\n var_12.append(var_6[var_3])\n else:\n var_12.append(var_6[var_1])\n print((max(var_12)))\n print((\"\\n\".join(map(str, var_12))))\n\n\nif __name__ == \"__main__\":\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nimport copy\n\nvar_8 = int(eval(input()))\nvar_10 = set([var_6 for var_6 in range(1, 10**5)])\nvar_5 = []\nvar_11 = {}\nvar_9 = []\nfor var_6 in range(var_8 - 1):\n var_1, var_2 = list(map(int, input().split(\" \")))\n var_5.append([var_1, var_2])\n var_11.setdefault(var_1, []).append(var_2)\n var_9.append([])\nvar_9.append([])\nvar_9.append([])\nvar_7 = 0\nfor var_12 in range(1, var_8 + 1):\n var_14 = var_11.get(var_12, [])\n var_3 = 1\n for var_13 in var_14:\n if var_3 in var_9[var_12]:\n var_3 += 1\n else:\n pass\n var_9[var_13].append(var_3)\n if var_3 >= var_7:\n var_7 = var_3\n var_3 += 1\nprint(var_7)\nfor var_4 in var_5:\n print((var_9[var_4[1]][0]))\n```", "output": "SLOWER 4.1418", "pair_id": "python_p02850_pair0003_reversed", "problem_id": "p02850", "language": "python", "direction": "reversed", "speedup_ratio": 17.653} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = [\n var_3 for var_3 in map(str, list(range(var_1, var_2 + 1))) if var_3 == var_3[::-1]\n]\nprint((len(var_4)))\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_8 in range(var_1, var_2 + 1):\n var_7 = str(var_8)\n var_6 = len(var_7)\n var_4 = True\n for var_5 in range(var_6 // 2):\n if var_7[var_5] != var_7[var_6 - 1 - var_5]:\n var_4 = False\n break\n if var_4:\n var_3 += 1\nprint(var_3)\n```", "output": "SLOWER 1.8248", "pair_id": "python_p03416_pair0050_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 3.5426} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport math\nfrom decimal import Decimal\n\nvar_1, var_2 = list(map(Decimal, input().split()))\nprint((math.floor(var_1 * var_2)))\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\nimport math\nfrom collections import defaultdict\nfrom bisect import bisect_left, bisect_right\n\nsys.setrecursionlimit(10**7)\n\n\ndef func_4():\n return sys.stdin.readline()[:-1]\n\n\nvar_4 = 10**9 + 7\n\n\ndef func_1():\n return int(eval(func_4()))\n\n\ndef func_2():\n return list(map(int, func_4().split()))\n\n\ndef func_3(var_6, var_3):\n if var_6 <= 0:\n return [[] for _ in range(var_3)]\n elif var_3 == 1:\n return [func_1() for _ in range(var_6)]\n else:\n var_5 = [func_2() for _ in range(var_6)]\n return list(map(list, list(zip(*var_5))))\n\n\nvar_1, var_2 = list(map(str, func_4().split()))\nvar_1 = int(var_1)\nvar_2 = 100 * int(var_2[0]) + 10 * int(var_2[2]) + int(var_2[3])\nprint((var_1 * var_2 // 100))\n```", "output": "SLOWER 2.455", "pair_id": "python_p02659_pair0009_reversed", "problem_id": "p02659", "language": "python", "direction": "reversed", "speedup_ratio": 5.4831} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_6 = input()[::-1]\nvar_5 = len(var_6)\nvar_1 = [0] * var_5\nvar_3 = [0] * var_5\nvar_2 = [0] * 2019\nvar_7 = 10\nvar_1[0] = int(var_6[0])\nvar_3[0] = var_1[0]\nvar_2[var_3[0]] += 1\nfor var_4 in range(1, var_5):\n var_1[var_4] = int(var_6[var_4]) * var_7 % 2019\n var_3[var_4] = (var_3[var_4 - 1] + var_1[var_4]) % 2019\n var_2[var_3[var_4]] += 1\n var_7 = var_7 * 10 % 2019\nprint(\n (\n int(sum([var_2[var_4] * (var_2[var_4] - 1) for var_4 in range(2019)]) / 2)\n + var_2[0]\n )\n)\n```\n\n=== Code B (Modified) ===\n```python\nfrom collections import Counter\n\nvar_1 = input()[::-1]\nvar_5 = [0]\nvar_4 = 0\nvar_6 = 2019\nfor var_7 in var_1:\n var_8 = int(var_7) * pow(10, var_4, var_6) % var_6\n var_8 = var_5[-1] + var_8\n var_5.append(var_8 % var_6)\n var_4 += 1\nvar_3 = Counter(var_5)\nvar_2 = sum(var_9 * (var_9 - 1) // 2 for var_9 in list(var_3.values()))\nprint(var_2)\n```", "output": "FASTER 1.6668", "pair_id": "python_p02702_pair0003_forward", "problem_id": "p02702", "language": "python", "direction": "forward", "speedup_ratio": 3.175} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_5 in range(10):\n for var_6 in range(10):\n for var_7 in range(10):\n var_3 = 10000 * var_5 + 1000 * var_6 + 100 * var_7 + 10 * var_6 + var_5\n if var_1 <= var_3 <= var_2:\n var_4 += 1\nprint(var_4)\n```\n\n=== Code B (Modified) ===\n```python\nfrom sys import stdin\n\nvar_6 = lambda: list(map(int, stdin.readline().split()))\nvar_5 = lambda: list(map(int, stdin.readline().split()))\nvar_1, var_3 = var_6()\nvar_2 = 0\nfor var_4 in range(var_1, var_3 + 1):\n var_7 = str(var_4)\n if var_7 == var_7[::-1]:\n var_2 += 1\nprint(var_2)\n```", "output": "SLOWER 3.844", "pair_id": "python_p03416_pair0051_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 14.3598} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_8 = int(eval(input()))\nvar_6 = []\nfor var_7 in range(var_8 - 1):\n var_1, var_3 = list(map(int, input().split()))\n var_6.append([var_1 - 1, var_3 - 1, var_7])\nvar_6.sort()\nvar_12 = [0] * (var_8)\nvar_2 = [0] * (var_8 - 1)\nvar_9 = 1\nvar_10 = 0\nfor var_5 in var_6:\n _from, var_11, var_7 = var_5\n if _from != var_10:\n var_9 = 1\n if var_12[_from] == var_9:\n var_9 += 1\n var_2[var_7] = var_9\n var_12[var_11] = var_9\n var_9 += 1\n var_10 = _from\nprint((max(var_2)))\nfor var_4 in var_2:\n print(var_4)\n```\n\n=== Code B (Modified) ===\n```python\nfrom collections import deque\n\n\ndef func_2(var_9, var_2, var_4):\n\n var_6 = {var_7: dict() for var_7 in range(var_9)}\n for var_7 in range(var_9 - 1):\n var_1, var_3 = var_2[var_7] - 1, var_4[var_7] - 1\n var_6[var_1][var_3] = -1\n var_6[var_3][var_1] = -1\n var_8 = max([len(var_6[var_1]) for var_1 in range(var_9)])\n var_14 = [-1] * var_9\n var_14[0] = var_8 - 1\n\n var_12 = deque([0])\n while len(var_12) > 0:\n var_10 = var_12.popleft()\n var_5 = var_14[var_10]\n for var_11 in list(var_6[var_10].keys()):\n if var_14[var_11] != -1:\n continue\n var_5 += 1\n var_5 %= var_8\n\n var_6[var_10][var_11] = var_5\n var_6[var_11][var_10] = var_5\n var_14[var_11] = var_5\n var_12.append(var_11)\n var_13 = [0] * (var_9 - 1)\n for var_7 in range(var_9 - 1):\n var_13[var_7] = var_6[var_2[var_7] - 1][var_4[var_7] - 1] + 1\n return var_8, var_13\n\n\ndef func_1():\n var_9 = int(eval(input()))\n var_2 = [0] * (var_9 - 1)\n var_4 = [0] * (var_9 - 1)\n for var_7 in range(var_9 - 1):\n var_1, var_3 = list(map(int, input().split()))\n var_2[var_7] = var_1\n var_4[var_7] = var_3\n var_8, var_13 = func_2(var_9, var_2, var_4)\n print(var_8)\n for var_7 in range(var_9 - 1):\n print((var_13[var_7]))\n\n\ndef func_3():\n print((func_2(3, [1, 2], [2, 3])))\n print((func_2(8, [1, 2, 2, 2, 4, 5, 6], [2, 3, 4, 5, 7, 6, 8])))\n\n\nif __name__ == \"__main__\":\n\n func_1()\n```", "output": "SLOWER 1.2239", "pair_id": "python_p02850_pair0004_reversed", "problem_id": "p02850", "language": "python", "direction": "reversed", "speedup_ratio": 2.3358} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\ndef func_1():\n from sys import setrecursionlimit, stdin\n from os import environ\n from collections import defaultdict, deque, Counter\n from math import ceil, floor, gcd\n from itertools import accumulate, combinations, combinations_with_replacement\n\n setrecursionlimit(10**6)\n var_7 = (\n (lambda *var_11: print(*var_11))\n if \"TERM_PROGRAM\" in environ\n else lambda *var_12: 0\n )\n var_8 = lambda: stdin.readline().rstrip()\n var_3 = lambda: list(map(int, var_8().split()))\n var_1 = lambda: int(var_8())\n var_4 = 10**9 + 7\n var_2 = 10**9 + 10\n var_9, var_10 = var_8().split()\n var_5 = int(var_9)\n var_10 = var_10.split(\".\")\n var_6 = int(var_10[0]) * 100\n if len(var_10) == 2:\n var_6 += int(var_10[1])\n print(var_5 * var_6 // 100)\n\n\nfunc_1()\n```\n\n=== Code B (Modified) ===\n```python\ndef func_1():\n var_1, var_3 = input().split()\n var_1 = int(var_1)\n var_3 = int(float(var_3) * 100 + 0.5)\n var_2 = var_1 * var_3\n print((var_2 // 100))\n\n\nif __name__ == \"__main__\":\n func_1()\n```", "output": "FASTER 1.7187", "pair_id": "python_p02659_pair0010_forward", "problem_id": "p02659", "language": "python", "direction": "forward", "speedup_ratio": 3.2915} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nfrom sys import stdin\n\n\ndef func_1():\n\n var_11 = stdin.readline\n var_2 = int(var_11())\n var_1 = []\n for var_6 in range(var_2):\n var_5 = int(\"\".join(var_11().strip().split(\" \")), 2)\n var_1.append(var_5)\n var_3 = []\n for var_6 in range(var_2):\n var_10 = list(map(int, var_11().split()))\n var_3.append(var_10)\n var_8 = float(\"-inf\")\n for var_9 in range(1, 1 << 10):\n var_12 = 0\n for var_7 in range(var_2):\n var_4 = bin(var_9 & var_1[var_7]).count(\"1\")\n var_12 += var_3[var_7][var_4]\n var_8 = max(var_12, var_8)\n print(var_8)\n\n\nif __name__ == \"__main__\":\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nimport itertools\n\nvar_6 = int(eval(input()))\nvar_2 = [[]] * var_6\nfor var_4 in range(var_6):\n var_3 = list(map(int, input().split()))\n\n var_2[var_4] = var_3\nvar_8 = [[]] * var_6\nfor var_4 in range(var_6):\n var_9 = list(map(int, input().split()))\n var_8[var_4] = var_9\nvar_10 = -(10**11)\nfor var_1 in itertools.product([0, 1], repeat=10):\n if sum(var_1) == 0:\n continue\n var_11 = 0\n for var_7 in range(var_6):\n var_5 = 0\n for var_4 in range(10):\n if var_2[var_7][var_4] == 1 and var_1[var_4] == 1:\n var_5 += 1\n var_11 = var_11 + var_8[var_7][var_5]\n var_10 = max(var_10, var_11)\nprint(var_10)\n```", "output": "SLOWER 2.8495", "pair_id": "python_p03503_pair0001_reversed", "problem_id": "p03503", "language": "python", "direction": "reversed", "speedup_ratio": 7.2074} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\ndef func_1():\n var_2 = int(input())\n var_1 = [int(var_6) for var_6 in input().split()]\n if var_2 == 1:\n return print(1 if var_1[0] % 2 == 0 else 2)\n var_3 = 0\n var_5 = (-1, 0, 1)\n from itertools import product\n\n for var_6 in product(range(3), repeat=var_2):\n var_4 = 1\n for var_7 in range(var_2):\n var_4 *= var_1[var_7] + var_5[var_6[var_7]]\n if var_4 % 2 == 0:\n var_3 += 1\n print(var_3)\n\n\nif __name__ == \"__main__\":\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nvar_2 = int(eval(input()))\nvar_1 = list(map(int, input().split()))\nvar_4 = 1\nfor var_3 in range(var_2):\n if var_1[var_3] % 2 == 0:\n var_4 *= 2\nprint((3**var_2 - var_4))\n```", "output": "FASTER 8.5767", "pair_id": "python_p03568_pair0006_forward", "problem_id": "p03568", "language": "python", "direction": "forward", "speedup_ratio": 381.8046} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\n\nvar_8 = sys.stdin.readline\n\n\ndef func_1():\n var_2 = int(eval(var_8()))\n var_1 = []\n for _ in range(var_2):\n var_1.append(list(map(int, var_8().split())))\n var_3 = []\n for _ in range(var_2):\n var_3.append(list(map(int, var_8().split())))\n var_4 = -(10**7) * var_2\n for var_7 in range(1, 1 << 10):\n var_11 = 0\n for var_10, var_6 in enumerate(var_1):\n var_5 = 0\n for var_9 in range(10):\n if (var_7 >> var_9) & 1 & var_6[var_9]:\n var_5 += 1\n var_11 += var_3[var_10][var_5]\n var_4 = max(var_4, var_11)\n print(var_4)\n\n\nif __name__ == \"__main__\":\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nfrom sys import stdin\n\n\ndef func_1():\n\n var_11 = stdin.readline\n var_2 = int(var_11())\n var_1 = []\n for var_6 in range(var_2):\n var_5 = int(\"\".join(var_11().strip().split(\" \")), 2)\n var_1.append(var_5)\n var_3 = []\n for var_6 in range(var_2):\n var_10 = list(map(int, var_11().split()))\n var_3.append(var_10)\n var_8 = float(\"-inf\")\n for var_9 in range(1, 1 << 10):\n var_12 = 0\n for var_7 in range(var_2):\n var_4 = bin(var_9 & var_1[var_7]).count(\"1\")\n var_12 += var_3[var_7][var_4]\n var_8 = max(var_12, var_8)\n print(var_8)\n\n\nif __name__ == \"__main__\":\n func_1()\n```", "output": "FASTER 1.9105", "pair_id": "python_p03503_pair0005_forward", "problem_id": "p03503", "language": "python", "direction": "forward", "speedup_ratio": 3.7593} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_6 = input()[::-1]\nvar_5 = len(var_6)\nvar_1 = [0] * var_5\nvar_3 = [0] * var_5\nvar_2 = [0] * 2019\nvar_7 = 10\nvar_1[0] = int(var_6[0])\nvar_3[0] = var_1[0]\nvar_2[var_3[0]] += 1\nfor var_4 in range(1, var_5):\n var_1[var_4] = int(var_6[var_4]) * var_7 % 2019\n var_3[var_4] = (var_3[var_4 - 1] + var_1[var_4]) % 2019\n var_2[var_3[var_4]] += 1\n var_7 = var_7 * 10 % 2019\nprint(\n (\n int(sum([var_2[var_4] * (var_2[var_4] - 1) for var_4 in range(2019)]) / 2)\n + var_2[0]\n )\n)\n```\n\n=== Code B (Modified) ===\n```python\nvar_6 = 2019\nvar_1 = [0] * var_6\nvar_3 = 1\nvar_5 = var_4 = 0\nfor var_2 in input()[::-1]:\n var_1[var_4] += 1\n var_4 -= int(var_2) * var_3\n var_4 %= var_6\n var_5 += var_1[var_4]\n var_3 *= 10\n var_3 %= var_6\nprint(var_5)\n```", "output": "FASTER 2.581", "pair_id": "python_p02702_pair0004_forward", "problem_id": "p02702", "language": "python", "direction": "forward", "speedup_ratio": 5.9835} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_6 = sorted([list(map(int, input().split())) for var_5 in range(var_1)])\n\nvar_4 = [[0] * (var_2 + 1) for var_5 in range(var_1 + 1)]\n\nfor var_5 in range(var_1):\n var_9, var_8 = var_6[var_5]\n for var_7 in range(var_2 + 1):\n if var_7 + var_9 <= var_2:\n var_4[var_5 + 1][var_7 + var_9] = max(\n var_4[var_5 + 1][var_7 + var_9], var_4[var_5][var_7] + var_8\n )\n var_4[var_5 + 1][var_7] = max(var_4[var_5][var_7], var_4[var_5 + 1][var_7])\nvar_3 = 0\nfor var_5, (var_9, var_8) in enumerate(var_6):\n for var_7 in range(var_2):\n var_3 = max(var_3, var_4[var_5][var_7] + var_8)\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_6, var_7 = list(map(int, input().split()))\nvar_1 = [list(map(int, input().split())) for _ in range(var_6)]\nvar_1.sort()\nvar_3 = [(6007) * [0] for _ in range(var_6 + 1)]\nvar_3[0][0] = 0\nvar_2 = 0\nfor var_4 in range(var_6):\n for var_5 in range(6007):\n var_3[var_4 + 1][var_5] = max(var_3[var_4 + 1][var_5], var_3[var_4][var_5])\n if var_5 < var_7:\n var_3[var_4 + 1][var_5 + var_1[var_4][0]] = max(\n var_3[var_4][var_5] + var_1[var_4][1],\n var_3[var_4][var_5 + var_1[var_4][0]],\n )\n var_2 = max(var_2, var_3[var_4 + 1][var_5])\nprint(var_2)\n```", "output": "SLOWER 4.9584", "pair_id": "python_p02863_pair0004_reversed", "problem_id": "p02863", "language": "python", "direction": "reversed", "speedup_ratio": 31.0909} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\n\n\ndef func_1(var_5, var_6):\n var_4 = 0\n for var_3 in range(var_5, var_6 + 1):\n if str(var_3) == str(var_3)[::-1]:\n var_4 += 1\n return var_4\n\n\nprint((func_1(var_1, var_2)))\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = list(reversed(list(str(var_4))))\n if var_5 == list(str(var_4)):\n var_3 += 1\nprint(var_3)\n```", "output": "SLOWER 1.9806", "pair_id": "python_p03416_pair0047_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 3.9465} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_6 = int(eval(input()))\nvar_2 = list(map(int, input().split()))\nfrom itertools import product\n\nvar_5 = [-1, 0, 1]\nvar_3 = 0\nfor var_7 in product(var_5, repeat=var_6):\n var_1 = []\n for var_4 in range(var_6):\n var_1.append(var_7[var_4] + var_2[var_4])\n if any(var_8 % 2 == 0 for var_8 in var_1):\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\ndef func_1():\n var_2 = int(input())\n var_1 = [int(var_6) for var_6 in input().split()]\n if var_2 == 1:\n return print(1 if var_1[0] % 2 == 0 else 2)\n var_3 = 0\n var_5 = (-1, 0, 1)\n from itertools import product\n\n for var_6 in product(range(3), repeat=var_2):\n var_4 = 1\n for var_7 in range(var_2):\n var_4 *= var_1[var_7] + var_5[var_6[var_7]]\n if var_4 % 2 == 0:\n var_3 += 1\n print(var_3)\n\n\nif __name__ == \"__main__\":\n func_1()\n```", "output": "FASTER 1.2741", "pair_id": "python_p03568_pair0007_forward", "problem_id": "p03568", "language": "python", "direction": "forward", "speedup_ratio": 2.4185} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_3 = list(map(int, input().split()))\nvar_2 = -1\nfor var_4 in range(10, 12501):\n if int(var_4 * 0.08) == var_1 and int(var_4 * 0.1) == var_3:\n var_2 = var_4\n break\nprint(var_2)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nimport math\n\nif math.ceil((var_1 + 1) * 12.5) <= math.ceil(var_2 * 10) or math.ceil(\n var_1 * 12.5\n) >= math.ceil((var_2 + 1) * 10):\n print((-1))\nelse:\n print((max(math.ceil(var_1 * 12.5), math.ceil(var_2 * 10))))\n```", "output": "FASTER 5.3196", "pair_id": "python_p02755_pair0004_forward", "problem_id": "p02755", "language": "python", "direction": "forward", "speedup_ratio": 39.9354} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_2, var_1 = [int(var_12) for var_12 in input().split()]\nvar_3 = []\nfor var_8 in range(var_1):\n var_5, var_6 = [int(var_12) for var_12 in input().split()]\n var_3.append((var_5, var_6))\nvar_3.sort()\nvar_9 = float(\"inf\")\nvar_4 = [var_9 for var_5 in range(var_2 + 1)]\nfor var_5, var_6 in var_3:\n var_4[var_5] = min(var_4[var_5], var_6)\nvar_3 = [\n (var_5, var_4[var_5]) for var_5 in range(1, var_2 + 1) if var_4[var_5] != var_9\n]\nvar_3.sort(key=lambda var_11: var_11[1])\nvar_7 = [True] * (var_2)\nvar_10 = None\nfor var_5, var_6 in var_3:\n if var_10 == None or var_10 < var_5:\n var_7[var_6 - 1] = False\n var_10 = var_6 - 1\nprint((sum(1 for var_6 in var_7 if not var_6)))\n```\n\n=== Code B (Modified) ===\n```python\nvar_6, var_5 = list(map(int, input().split(\" \")))\nvar_2 = [list(map(int, input().split(\" \"))) for _ in range(var_5)]\nvar_2.sort(key=lambda var_7: var_7[1])\nvar_4 = 0\nvar_7 = 0\nfor var_1, var_3 in var_2:\n if var_1 <= var_7 < var_3:\n continue\n var_7 = var_3 - 1\n var_4 += 1\nprint(var_4)\n```", "output": "FASTER 1.0353", "pair_id": "python_p03295_pair0001_forward", "problem_id": "p03295", "language": "python", "direction": "forward", "speedup_ratio": 2.0495} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1 = list(map(int, input().split()))\nvar_2 = 0\nfor var_3 in range(var_1[0], var_1[1] + 1):\n var_4 = str(var_3)\n if var_4[0] == var_4[4] and var_4[1] == var_4[3]:\n var_2 += 1\nprint(var_2)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().rstrip().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = list(map(int, list(str(var_4))))\n if var_5[0] == var_5[4] and var_5[1] == var_5[3]:\n var_3 += 1\nprint(var_3)\n```", "output": "SLOWER 1.9718", "pair_id": "python_p03416_pair0052_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 3.9226} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\nfrom collections import deque\n\nvar_13 = sys.stdin.readline\nvar_2 = int(eval(var_13()))\nvar_5 = [[] for _ in range(var_2)]\nvar_3 = [-1] * var_2\nfor var_12 in range(var_2 - 1):\n var_6, var_8 = list(map(int, var_13().split()))\n var_5[var_6 - 1].append((var_12, var_8 - 1))\n\n\nvar_4 = deque([(0, -1)])\nvar_1 = [-1] * (var_2 - 1)\nvar_11 = 0\nwhile var_4:\n var_14, var_10 = var_4.pop()\n var_9 = 1\n for var_12, var_15 in var_5[var_14]:\n if var_9 == var_10:\n var_9 += 1\n var_1[var_12] = var_9\n var_4.appendleft((var_15, var_9))\n var_9 += 1\n var_11 = max(var_11, var_9 - 1)\nprint(var_11)\nfor var_7 in var_1:\n print(var_7)\n```\n\n=== Code B (Modified) ===\n```python\nimport copy\n\nvar_8 = int(eval(input()))\nvar_10 = set([var_6 for var_6 in range(1, 10**5)])\nvar_5 = []\nvar_11 = {}\nvar_9 = []\nfor var_6 in range(var_8 - 1):\n var_1, var_2 = list(map(int, input().split(\" \")))\n var_5.append([var_1, var_2])\n var_11.setdefault(var_1, []).append(var_2)\n var_9.append([])\nvar_9.append([])\nvar_9.append([])\nvar_7 = 0\nfor var_12 in range(1, var_8 + 1):\n var_14 = var_11.get(var_12, [])\n var_3 = 1\n for var_13 in var_14:\n if var_3 in var_9[var_12]:\n var_3 += 1\n else:\n pass\n var_9[var_13].append(var_3)\n if var_3 >= var_7:\n var_7 = var_3\n var_3 += 1\nprint(var_7)\nfor var_4 in var_5:\n print((var_9[var_4[1]][0]))\n```", "output": "SLOWER 4.6753", "pair_id": "python_p02850_pair0005_reversed", "problem_id": "p02850", "language": "python", "direction": "reversed", "speedup_ratio": 25.551} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\ndef func_1():\n var_1, var_2 = list(map(int, input().split()))\n var_3 = 0\n for var_4 in range(var_1, var_2 + 1):\n\n if (var_4 % 10) == (var_4 // 10000 % 10) and (var_4 // 10 % 10) == (\n var_4 // 1000 % 10\n ):\n var_3 += 1\n print(var_3)\n\n\nif __name__ == \"__main__\":\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nvar_1 = list(map(int, input().split()))\nvar_2 = 0\nfor var_3 in range(var_1[0], var_1[1] + 1):\n var_4 = str(var_3)\n if var_4[0] == var_4[4] and var_4[1] == var_4[3]:\n var_2 += 1\nprint(var_2)\n```", "output": "SLOWER 1.3752", "pair_id": "python_p03416_pair0053_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 2.5941} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\nimport itertools\n\n\ndef func_2(var_4):\n return bin(eval(\"0b\" + str(var_4)))\n\n\ndef func_1():\n var_4 = int(sys.stdin.readline().rstrip())\n var_9 = [\n func_2(\"\".join(str(var_10) for var_10 in sys.stdin.readline().split()))\n for _ in range(var_4)\n ]\n var_8 = [\n [int(var_10) for var_10 in sys.stdin.readline().split()] for _ in range(var_4)\n ]\n var_3 = -(10**10)\n for var_6 in itertools.product(\"01\", repeat=10):\n var_6 = func_2(\"\".join(var_6))\n if var_6 == \"0b0\":\n continue\n var_7 = 0\n for var_2 in range(var_4):\n var_1 = var_9[var_2]\n var_5 = bin(eval(var_1) & eval(var_6)).count(\"1\")\n var_7 += var_8[var_2][var_5]\n var_3 = max(var_3, var_7)\n print(var_3)\n\n\nif __name__ == \"__main__\":\n\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nvar_5 = 0\nif var_5 == 0:\n var_8 = int(eval(input()))\n var_2 = []\n for var_4 in range(var_8):\n var_3 = list(map(int, input().split()))\n var_2.append(var_3)\n var_9 = []\n for var_4 in range(var_8):\n var_10 = list(map(int, input().split()))\n var_9.append(var_10)\nelif var_5 == 1:\n var_8 = 1\n var_2 = [[1, 1, 0, 1, 0, 0, 0, 1, 0, 1]]\n var_9 = [[3, 4, 5, 6, 7, 8, 9, -2, -3, 4, -2]]\nelif var_5 == 2:\n var_8 = 2\n var_2 = [[1, 1, 1, 1, 1, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 1, 1, 1, 1, 1]]\n var_9 = [\n [0, -2, -2, -2, -2, -2, -1, -1, -1, -1, -1],\n [0, -2, -2, -2, -2, -2, -1, -1, -1, -1, -1],\n ]\nelif var_5 == 3:\n var_8 = 3\n var_2 = [\n [1, 1, 1, 1, 1, 1, 0, 0, 1, 1],\n [0, 1, 0, 1, 1, 1, 1, 0, 1, 0],\n [1, 0, 1, 1, 0, 1, 0, 1, 0, 1],\n ]\n var_9 = [\n [-8, 6, -2, -8, -8, 4, 8, 7, -6, 2, 2],\n [-9, 2, 0, 1, 7, -5, 0, -2, -6, 5, 5],\n [6, -6, 7, -9, 6, -5, 8, 0, -9, -7, -7],\n ]\nimport itertools\n\nvar_13 = -(10**11)\nfor var_4 in itertools.product([0, 1], repeat=10):\n var_11 = list(var_4)\n var_12 = 0\n if sum(var_11) != 0:\n for var_7 in range(var_8):\n var_1 = 0\n for var_6 in range(10):\n var_1 = var_1 + var_11[var_6] * var_2[var_7][var_6]\n var_12 = var_12 + var_9[var_7][var_1]\n\n var_13 = max(var_12, var_13)\nprint(var_13)\n```", "output": "FASTER 2.1766", "pair_id": "python_p03503_pair0006_forward", "problem_id": "p03503", "language": "python", "direction": "forward", "speedup_ratio": 4.5208} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_6 in range(var_1, var_2 + 1):\n var_3 = str(var_6)\n var_5 = True\n for var_7 in range(len(var_3) // 2):\n if var_3[var_7] != var_3[-var_7 - 1] and var_5:\n var_5 = not var_5\n if var_5:\n var_4 += 1\nprint(var_4)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_6 = str(var_4)\n var_5 = var_6[::-1]\n if var_6 == var_5:\n var_3 += 1\nprint(var_3)\n```", "output": "FASTER 1.2096", "pair_id": "python_p03416_pair0054_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 2.3127} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_6 = int(eval(input()))\nvar_2 = list(map(int, input().split()))\nfrom itertools import product\n\nvar_5 = [-1, 0, 1]\nvar_3 = 0\nfor var_7 in product(var_5, repeat=var_6):\n var_1 = []\n for var_4 in range(var_6):\n var_1.append(var_7[var_4] + var_2[var_4])\n if any(var_8 % 2 == 0 for var_8 in var_1):\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_2 = int(eval(input()))\nvar_1 = list(map(int, input().split()))\nvar_4 = 1\nfor var_3 in range(var_2):\n if var_1[var_3] % 2 == 0:\n var_4 *= 2\nprint((3**var_2 - var_4))\n```", "output": "FASTER 9.8508", "pair_id": "python_p03568_pair0008_forward", "problem_id": "p03568", "language": "python", "direction": "forward", "speedup_ratio": 923.3817} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nfrom functools import *\n\n_, var_1 = open(0)\nprint(\n (\n \"YNeos\"[\n var_2(lambda var_3, var_4: var_3 ^ var_4, list(map(int, var_1.split())))\n > 0 :: 2\n ]\n )\n)\n```\n\n=== Code B (Modified) ===\n```python\nfrom collections import Counter\n\nvar_4 = int(eval(input()))\nvar_1 = list(map(int, input().split()))\nvar_2 = Counter(var_1)\nvar_3 = list(var_2)\nif sum(var_1) == 0:\n print(\"Yes\")\nelif len(var_1) % 3 != 0:\n print(\"No\")\nelif len(var_2) > 3 or len(var_2) <= 1:\n print(\"No\")\nelif len(var_2) == 3:\n if (\n var_2[var_3[0]] == var_4 // 3\n and var_2[var_3[1]] == var_4 // 3\n and var_2[var_3[2]] == var_4 // 3\n ):\n if var_3[0] ^ var_3[1] ^ var_3[2] == 0:\n print(\"Yes\")\n else:\n print(\"No\")\n else:\n print(\"No\")\nelse:\n var_3.sort()\n if var_3[0] == 0 and var_2[var_3[0]] == var_4 // 3:\n print(\"Yes\")\n else:\n print(\"No\")\n```", "output": "SLOWER 1.3002", "pair_id": "python_p02975_pair0001_reversed", "problem_id": "p02975", "language": "python", "direction": "reversed", "speedup_ratio": 2.4627} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\ndef func_1():\n var_1, var_2 = list(map(int, input().rstrip().split()))\n var_3 = 0\n for var_4 in range(var_1, var_2 + 1):\n var_5 = str(var_4)\n if var_5 == var_5[::-1]:\n var_3 += 1\n print(var_3)\n\n\nif __name__ == \"__main__\":\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_3 = list(map(int, input().split()))\nvar_2 = 0\nfor var_5 in range(var_3 + 1)[var_1:]:\n if len(str(var_5)) % 2 == 0:\n var_6 = list(str(var_5))[: len(str(var_5)) // 2]\n var_7 = list(reversed(list(str(var_5))[len(str(var_5)) // 2 :]))\n if var_6 == var_7:\n var_2 += 1\n else:\n var_8 = list(str(var_5))[: len(str(var_5)) // 2 + 1]\n var_4 = list(reversed(list(str(var_5))[len(str(var_5)) // 2 :]))\n if var_8 == var_4:\n var_2 += 1\nprint(var_2)\n```", "output": "SLOWER 3.2205", "pair_id": "python_p03416_pair0055_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 9.3213} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\ndef func_1():\n from sys import setrecursionlimit, stdin\n from os import environ\n from collections import defaultdict, deque, Counter\n from math import ceil, floor, gcd\n from itertools import accumulate, combinations, combinations_with_replacement\n\n setrecursionlimit(10**6)\n var_7 = (\n (lambda *var_11: print(*var_11))\n if \"TERM_PROGRAM\" in environ\n else lambda *var_12: 0\n )\n var_8 = lambda: stdin.readline().rstrip()\n var_3 = lambda: list(map(int, var_8().split()))\n var_1 = lambda: int(var_8())\n var_4 = 10**9 + 7\n var_2 = 10**9 + 10\n var_9, var_10 = var_8().split()\n var_5 = int(var_9)\n var_10 = var_10.split(\".\")\n var_6 = int(var_10[0]) * 100\n if len(var_10) == 2:\n var_6 += int(var_10[1])\n print(var_5 * var_6 // 100)\n\n\nfunc_1()\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\n\nvar_3 = sys.stdin.readline\nvar_1, var_2 = var_3().split()\nvar_1 = int(var_1)\nvar_2 = int(float(var_2) * 100 + 0.5)\nprint((var_1 * var_2 // 100))\n```", "output": "FASTER 2.1571", "pair_id": "python_p02659_pair0011_forward", "problem_id": "p02659", "language": "python", "direction": "forward", "speedup_ratio": 4.4601} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\ndef func_1():\n var_1, var_3 = input().split()\n var_1 = int(var_1)\n var_3 = int(float(var_3) * 100 + 0.5)\n var_2 = var_1 * var_3\n print((var_2 // 100))\n\n\nif __name__ == \"__main__\":\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\nimport math\nfrom collections import defaultdict\nfrom bisect import bisect_left, bisect_right\n\nsys.setrecursionlimit(10**7)\n\n\ndef func_4():\n return sys.stdin.readline()[:-1]\n\n\nvar_4 = 10**9 + 7\n\n\ndef func_1():\n return int(eval(func_4()))\n\n\ndef func_2():\n return list(map(int, func_4().split()))\n\n\ndef func_3(var_6, var_3):\n if var_6 <= 0:\n return [[] for _ in range(var_3)]\n elif var_3 == 1:\n return [func_1() for _ in range(var_6)]\n else:\n var_5 = [func_2() for _ in range(var_6)]\n return list(map(list, list(zip(*var_5))))\n\n\nfrom decimal import getcontext, Decimal\n\ngetcontext().prec = 28\nvar_1, var_2 = list(map(str, func_4().split()))\nvar_1 = int(var_1)\nvar_2 = Decimal(var_2)\nprint((int(var_1 * var_2)))\n```", "output": "SLOWER 1.8519", "pair_id": "python_p02659_pair0012_reversed", "problem_id": "p02659", "language": "python", "direction": "reversed", "speedup_ratio": 3.6097} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_11 = int(eval(input()))\nvar_12 = {var_8: [] for var_8 in range(1, var_11 + 1)}\nvar_19 = [False for var_8 in range(var_11 + 1)]\nvar_16 = []\nfor _ in range(var_11 - 1):\n var_2, var_3 = list(map(int, input().split()))\n var_12[var_2].append(var_3)\n var_12[var_3].append(var_2)\n var_16.append((var_2, var_3))\nvar_9 = var_16[0][0]\nvar_19[var_9] = True\nvar_6 = []\nvar_7 = []\nvar_14 = {var_8: {} for var_8 in range(1, var_11 + 1)}\nvar_10 = [0 for var_8 in range(var_11 + 1)]\n\nvar_4 = 1\nfor var_5 in var_12[var_9]:\n var_19[var_5] = True\n var_14[var_9][var_5] = var_4\n var_14[var_5][var_9] = var_4\n var_10[var_5] = var_4\n var_4 += 1\n var_6.append(var_5)\nwhile var_6:\n for var_15 in var_6:\n var_13 = 1\n for var_5 in var_12[var_15]:\n if var_19[var_5] == False:\n var_19[var_5] = True\n if var_13 != var_10[var_15]:\n var_14[var_15][var_5] = var_13\n var_14[var_5][var_15] = var_13\n var_10[var_5] = var_13\n var_13 += 1\n var_7.append(var_5)\n else:\n var_13 += 1\n var_14[var_15][var_5] = var_13\n var_14[var_5][var_15] = var_13\n var_10[var_5] = var_13\n var_13 += 1\n var_7.append(var_5)\n if var_7:\n var_6 = var_7\n var_7 = []\n else:\n var_6 = []\n var_7 = []\nvar_1 = 0\nfor var_8 in range(1, var_11 + 1):\n var_1 = max(var_1, len(var_12[var_8]))\nprint(var_1)\nfor var_8 in range(var_11 - 1):\n var_17, var_18 = var_16[var_8][0], var_16[var_8][1]\n print((var_14[var_17][var_18]))\n```\n\n=== Code B (Modified) ===\n```python\nimport copy\n\nvar_8 = int(eval(input()))\nvar_10 = set([var_6 for var_6 in range(1, 10**5)])\nvar_5 = []\nvar_11 = {}\nvar_9 = []\nfor var_6 in range(var_8 - 1):\n var_1, var_2 = list(map(int, input().split(\" \")))\n var_5.append([var_1, var_2])\n var_11.setdefault(var_1, []).append(var_2)\n var_9.append([])\nvar_9.append([])\nvar_9.append([])\nvar_7 = 0\nfor var_12 in range(1, var_8 + 1):\n var_14 = var_11.get(var_12, [])\n var_3 = 1\n for var_13 in var_14:\n if var_3 in var_9[var_12]:\n var_3 += 1\n else:\n pass\n var_9[var_13].append(var_3)\n if var_3 >= var_7:\n var_7 = var_3\n var_3 += 1\nprint(var_7)\nfor var_4 in var_5:\n print((var_9[var_4[1]][0]))\n```", "output": "SLOWER 3.6078", "pair_id": "python_p02850_pair0006_reversed", "problem_id": "p02850", "language": "python", "direction": "reversed", "speedup_ratio": 12.1912} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nfrom collections import Counter, defaultdict, deque\nfrom heapq import heappop, heappush, heapify\nimport sys, bisect, math, itertools, fractions, pprint\n\nsys.setrecursionlimit(10**8)\nvar_6 = 10**9 + 7\nvar_1 = float(\"inf\")\n\n\ndef func_1():\n return int(sys.stdin.readline())\n\n\ndef func_2():\n return list(map(int, sys.stdin.readline().split()))\n\n\nvar_7, var_9 = func_2()\nvar_13 = [func_2() for _ in range(var_7)]\nvar_13.sort(key=lambda var_14: var_14[1], reverse=True)\nvar_8 = 0\nvar_10 = min(var_7, 5)\nfor var_3 in range(var_10):\n var_2 = [[0] * (var_9 + 5) for _ in range(var_7 + 5)]\n for var_4 in range(var_7):\n var_12, var_11 = var_13[var_4]\n for var_5 in range(var_9):\n if var_5 < var_12 or var_3 == var_4:\n var_2[var_4 + 1][var_5] = var_2[var_4][var_5]\n else:\n var_2[var_4 + 1][var_5] = max(\n var_2[var_4][var_5], var_2[var_4][var_5 - var_12] + var_11\n )\n\n var_8 = max(var_2[var_7][var_9 - 1] + var_13[var_3][1], var_8)\nprint(var_8)\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\n\nsys.setrecursionlimit(2147483647)\nvar_2 = float(\"inf\")\nvar_3 = 10**9 + 7\nvar_10 = lambda: sys.stdin.readline().rstrip()\n\n\ndef func_1():\n var_11, var_4 = list(map(int, var_10().split()))\n var_1 = [tuple(map(int, var_10().split())) for _ in range(var_11)]\n var_1.sort()\n var_8 = [0] * var_4\n var_6 = -var_2\n for var_9 in range(var_11):\n var_5, var_7 = var_1[var_9]\n var_12 = var_8[:]\n for var_13 in range(var_4):\n if var_13 + var_5 < var_4:\n var_12[var_13 + var_5] = max(\n var_12[var_13 + var_5], var_8[var_13] + var_7\n )\n else:\n var_6 = max(var_6, var_8[var_13] + var_7)\n var_8 = var_12\n print((max(var_6, max(var_8))))\n\n\nfunc_1()\n```", "output": "FASTER 2.6786", "pair_id": "python_p02863_pair0013_forward", "problem_id": "p02863", "language": "python", "direction": "forward", "speedup_ratio": 6.4023} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = str(var_4)\n if var_5 == var_5[::-1]:\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_3 = list(map(int, input().split()))\nvar_2 = 0\nfor var_5 in range(var_3 + 1)[var_1:]:\n if len(str(var_5)) % 2 == 0:\n var_6 = list(str(var_5))[: len(str(var_5)) // 2]\n var_7 = list(reversed(list(str(var_5))[len(str(var_5)) // 2 :]))\n if var_6 == var_7:\n var_2 += 1\n else:\n var_8 = list(str(var_5))[: len(str(var_5)) // 2 + 1]\n var_4 = list(reversed(list(str(var_5))[len(str(var_5)) // 2 :]))\n if var_8 == var_4:\n var_2 += 1\nprint(var_2)\n```", "output": "SLOWER 2.479", "pair_id": "python_p03416_pair0056_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 5.5752} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\n\nvar_8 = sys.stdin.readline\n\n\ndef func_1():\n var_2 = int(eval(var_8()))\n var_1 = [int(var_8().replace(\" \", \"\"), 2) for _ in range(var_2)]\n var_3 = [list(map(int, var_8().split())) for _ in range(var_2)]\n var_4 = -(10**7) * var_2\n for var_7 in range(1, 1 << 10):\n var_10 = 0\n for var_9, var_6 in enumerate(var_1):\n var_5 = bin(var_7 & var_6).count(\"1\")\n var_10 += var_3[var_9][var_5]\n var_4 = max(var_4, var_10)\n print(var_4)\n\n\nif __name__ == \"__main__\":\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\n\nvar_8 = sys.stdin.readline\n\n\ndef func_1():\n var_2 = int(eval(var_8()))\n var_1 = []\n for _ in range(var_2):\n var_1.append(list(map(int, var_8().split())))\n var_3 = []\n for _ in range(var_2):\n var_3.append(list(map(int, var_8().split())))\n var_4 = -(10**7) * var_2\n for var_7 in range(1, 1 << 10):\n var_11 = 0\n for var_10, var_6 in enumerate(var_1):\n var_5 = 0\n for var_9 in range(10):\n if (var_7 >> var_9) & 1 & var_6[var_9]:\n var_5 += 1\n var_11 += var_3[var_10][var_5]\n var_4 = max(var_4, var_11)\n print(var_4)\n\n\nif __name__ == \"__main__\":\n func_1()\n```", "output": "SLOWER 1.7721", "pair_id": "python_p03503_pair0007_reversed", "problem_id": "p03503", "language": "python", "direction": "reversed", "speedup_ratio": 3.4156} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_6 = 2019\nvar_1 = [0] * var_6\nvar_3 = 1\nvar_5 = var_4 = 0\nfor var_2 in input()[::-1]:\n var_1[var_4] += 1\n var_4 -= int(var_2) * var_3\n var_4 %= var_6\n var_5 += var_1[var_4]\n var_3 *= 10\n var_3 %= var_6\nprint(var_5)\n```\n\n=== Code B (Modified) ===\n```python\nimport numpy as np\n\nvar_7 = input()[::-1]\nvar_6 = len(var_7)\nvar_1 = np.zeros(var_6, dtype=int)\nvar_4 = np.zeros(var_6, dtype=int)\nvar_2 = np.zeros(2019, dtype=int)\nvar_8 = 10\nvar_1[0] = int(var_7[0])\nvar_4[0] = var_1[0]\nvar_2[var_4[0]] += 1\nfor var_5 in range(1, var_6):\n var_1[var_5] = int(var_7[var_5]) * var_8 % 2019\n var_4[var_5] = (var_4[var_5 - 1] + var_1[var_5]) % 2019\n var_2[var_4[var_5]] += 1\n var_8 = var_8 * 10 % 2019\nvar_3 = var_2[np.nonzero(var_2)]\nprint(\n (\n int(\n sum([var_3[var_5] * (var_3[var_5] - 1) for var_5 in range(var_3.shape[0])])\n / 2\n )\n + var_2[0]\n )\n)\n```", "output": "SLOWER 1.5513", "pair_id": "python_p02702_pair0005_reversed", "problem_id": "p02702", "language": "python", "direction": "reversed", "speedup_ratio": 2.9308} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_4 = int(eval(input()))\nvar_1 = list(map(int, input().split()))\nvar_3 = 1\nfor var_2 in var_1:\n var_3 *= 2 if var_2 % 2 == 0 else 1\nprint((3**var_4 - var_3))\n```\n\n=== Code B (Modified) ===\n```python\nvar_6 = int(eval(input()))\nvar_2 = list(map(int, input().split()))\nfrom itertools import product\n\nvar_5 = [-1, 0, 1]\nvar_3 = 0\nfor var_7 in product(var_5, repeat=var_6):\n var_1 = []\n for var_4 in range(var_6):\n var_1.append(var_7[var_4] + var_2[var_4])\n if any(var_8 % 2 == 0 for var_8 in var_1):\n var_3 += 1\nprint(var_3)\n```", "output": "SLOWER 9.9565", "pair_id": "python_p03568_pair0009_reversed", "problem_id": "p03568", "language": "python", "direction": "reversed", "speedup_ratio": 993.5967} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = str(var_4)\n if var_5[0] == var_5[4] and var_5[1] == var_5[3]:\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = [0] * (var_2 + 1)\nfor var_3 in range(1, var_2 + 1):\n if str(var_3) == str(var_3)[::-1]:\n var_4[var_3] = var_4[var_3 - 1] + 1\n else:\n var_4[var_3] = var_4[var_3 - 1]\nprint((var_4[var_2] - var_4[var_1 - 1]))\n```", "output": "SLOWER 2.2084", "pair_id": "python_p03416_pair0057_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 4.6217} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nfrom fractions import Fraction\n\nvar_1, var_2 = input().split()\n\n\nfrom decimal import *\n\nvar_4 = var_3(var_1)\nvar_6 = var_3(var_2)\nvar_7().prec = 28\nvar_5 = var_4 * var_6\nprint((int(var_5)))\n```\n\n=== Code B (Modified) ===\n```python\ndef func_1():\n from sys import setrecursionlimit, stdin\n from os import environ\n from collections import defaultdict, deque, Counter\n from math import ceil, floor, gcd\n from itertools import accumulate, combinations, combinations_with_replacement\n\n setrecursionlimit(10**6)\n var_7 = (\n (lambda *var_11: print(*var_11))\n if \"TERM_PROGRAM\" in environ\n else lambda *var_12: 0\n )\n var_8 = lambda: stdin.readline().rstrip()\n var_3 = lambda: list(map(int, var_8().split()))\n var_1 = lambda: int(var_8())\n var_4 = 10**9 + 7\n var_2 = 10**9 + 10\n var_9, var_10 = var_8().split()\n var_5 = int(var_9)\n var_6 = int(float(var_10) * 100 + 0.5)\n print(var_5 * var_6 // 100)\n\n\nfunc_1()\n```", "output": "SLOWER 1.6242", "pair_id": "python_p02659_pair0007_reversed", "problem_id": "p02659", "language": "python", "direction": "reversed", "speedup_ratio": 3.0827} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\ndef func_1():\n var_1, var_2 = list(map(int, input().split()))\n var_3 = 0\n for var_4 in range(var_1, var_2 + 1):\n\n if (var_4 % 10) == (var_4 // 10000 % 10) and (var_4 // 10 % 10) == (\n var_4 // 1000 % 10\n ):\n var_3 += 1\n print(var_3)\n\n\nif __name__ == \"__main__\":\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n if list(str(var_4)) == list(reversed(str(var_4))):\n var_3 += 1\nprint(var_3)\n```", "output": "SLOWER 3.0644", "pair_id": "python_p03416_pair0058_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 8.3652} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_6 = sorted([list(map(int, input().split())) for var_5 in range(var_1)])\n\nvar_4 = [[0] * (var_2 + 1) for var_5 in range(var_1 + 1)]\n\nfor var_5 in range(var_1):\n var_9, var_8 = var_6[var_5]\n for var_7 in range(var_2 + 1):\n if var_7 + var_9 <= var_2:\n var_4[var_5 + 1][var_7 + var_9] = max(\n var_4[var_5 + 1][var_7 + var_9], var_4[var_5][var_7] + var_8\n )\n var_4[var_5 + 1][var_7] = max(var_4[var_5][var_7], var_4[var_5 + 1][var_7])\nvar_3 = 0\nfor var_5, (var_9, var_8) in enumerate(var_6):\n var_3 = max(var_3, var_4[var_5][var_2 - 1] + var_8)\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\nfrom operator import itemgetter\nfrom heapq import heapify, heappop, heappush\n\nvar_1 = int(10e15)\nvar_2 = -var_1\nvar_11 = 1000000007\nsys.setrecursionlimit(1000000)\n\n\ndef func_2():\n return list(map(int, input().split()))\n\n\ndef func_4():\n return input().split()\n\n\ndef func_1():\n return int(sys.stdin.readline())\n\n\ndef func_3():\n return eval(input())\n\n\nvar_3, var_4 = func_2()\nvar_5 = [func_2() for var_9 in range(var_3)]\nvar_5.sort(key=itemgetter(0))\n\nvar_8 = [[0] * (var_4 + 1 + 3000 + 1) for _ in range(var_3 + 1)]\nvar_6 = 0\nfor var_9 in range(var_3):\n for var_10 in range(var_4 + 1 + 3000 + 1):\n var_12, var_7 = var_5[var_9]\n if 0 <= var_10 - var_12 < var_4:\n var_8[var_9 + 1][var_10] = max(\n var_8[var_9][var_10], var_8[var_9][var_10 - var_12] + var_7\n )\n else:\n var_8[var_9 + 1][var_10] = var_8[var_9][var_10]\n var_6 = max(var_6, var_8[var_9 + 1][var_10])\nprint(var_6)\n```", "output": "SLOWER 4.4103", "pair_id": "python_p02863_pair0005_reversed", "problem_id": "p02863", "language": "python", "direction": "reversed", "speedup_ratio": 21.263} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\ndef func_1():\n var_1, var_3 = input().split()\n var_1 = int(var_1)\n var_3 = int(float(var_3) * 100 + 0.5)\n var_2 = var_1 * var_3\n print((var_2 // 100))\n\n\nif __name__ == \"__main__\":\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\ndef func_1():\n from sys import setrecursionlimit, stdin\n from os import environ\n from collections import defaultdict, deque, Counter\n from math import ceil, floor, gcd\n from itertools import accumulate, combinations, combinations_with_replacement\n\n setrecursionlimit(10**6)\n var_7 = (\n (lambda *var_11: print(*var_11))\n if \"TERM_PROGRAM\" in environ\n else lambda *var_12: 0\n )\n var_8 = lambda: stdin.readline().rstrip()\n var_3 = lambda: list(map(int, var_8().split()))\n var_1 = lambda: int(var_8())\n var_4 = 10**9 + 7\n var_2 = 10**9 + 10\n var_9, var_10 = var_8().split()\n var_5 = int(var_9)\n var_10 = var_10.split(\".\")\n var_6 = int(var_10[0]) * 100\n if len(var_10) == 2:\n var_6 += int(var_10[1])\n print(var_5 * var_6 // 100)\n\n\nfunc_1()\n```", "output": "SLOWER 1.7187", "pair_id": "python_p02659_pair0010_reversed", "problem_id": "p02659", "language": "python", "direction": "reversed", "speedup_ratio": 3.2915} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n if str(var_4) == \"\".join(reversed(str(var_4))):\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1 = list(map(int, input().split()))\nvar_2 = 0\nfor var_3 in range(var_1[0], var_1[1] + 1):\n var_4 = str(var_3)\n if var_4[0] == var_4[4] and var_4[1] == var_4[3]:\n var_2 += 1\nprint(var_2)\n```", "output": "FASTER 1.365", "pair_id": "python_p03416_pair0059_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 2.5758} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().strip().split(\" \")))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n if str(var_4) == str(var_4)[::-1]:\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_4, var_3 = list(map(int, input().split()))\nvar_1 = 0\nfor var_2 in range(var_4, var_3 + 1):\n if str(var_2)[0] + str(var_2)[1] == str(var_2)[-1] + str(var_2)[-2]:\n var_1 += 1\nprint(var_1)\n```", "output": "SLOWER 1.0338", "pair_id": "python_p03416_pair0060_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 2.0474} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_4, var_3 = list(map(int, input().split()))\nvar_1 = 0\nfor var_2 in range(var_4, var_3 + 1):\n if str(var_2)[0] + str(var_2)[1] == str(var_2)[-1] + str(var_2)[-2]:\n var_1 += 1\nprint(var_1)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_3 = list(map(int, input().split()))\nvar_2 = 0\nfor var_5 in range(var_3 + 1)[var_1:]:\n if len(str(var_5)) % 2 == 0:\n var_6 = list(str(var_5))[: len(str(var_5)) // 2]\n var_7 = list(reversed(list(str(var_5))[len(str(var_5)) // 2 :]))\n if var_6 == var_7:\n var_2 += 1\n else:\n var_8 = list(str(var_5))[: len(str(var_5)) // 2 + 1]\n var_4 = list(reversed(list(str(var_5))[len(str(var_5)) // 2 :]))\n if var_8 == var_4:\n var_2 += 1\nprint(var_2)\n```", "output": "SLOWER 1.1334", "pair_id": "python_p03416_pair0007_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 2.1938} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\nfrom collections import deque\n\nvar_13 = sys.stdin.readline\nvar_2 = int(eval(var_13()))\nvar_5 = [[] for _ in range(var_2)]\nvar_3 = [-1] * var_2\nfor var_12 in range(var_2 - 1):\n var_6, var_8 = list(map(int, var_13().split()))\n var_5[var_6 - 1].append((var_12, var_8 - 1))\n\n\nvar_4 = deque([(0, -1)])\nvar_1 = [-1] * (var_2 - 1)\nvar_11 = 0\nwhile var_4:\n var_14, var_10 = var_4.pop()\n var_9 = 1\n for var_12, var_15 in var_5[var_14]:\n if var_9 == var_10:\n var_9 += 1\n var_1[var_12] = var_9\n var_4.appendleft((var_15, var_9))\n var_9 += 1\n var_11 = max(var_11, var_9 - 1)\nprint(var_11)\nfor var_7 in var_1:\n print(var_7)\n```\n\n=== Code B (Modified) ===\n```python\nvar_11 = int(eval(input()))\nvar_12 = {var_8: [] for var_8 in range(1, var_11 + 1)}\nvar_19 = [False for var_8 in range(var_11 + 1)]\nvar_16 = []\nfor _ in range(var_11 - 1):\n var_2, var_3 = list(map(int, input().split()))\n var_12[var_2].append(var_3)\n var_12[var_3].append(var_2)\n var_16.append((var_2, var_3))\nvar_9 = var_16[0][0]\nvar_19[var_9] = True\nvar_6 = []\nvar_7 = []\nvar_14 = {var_8: {} for var_8 in range(1, var_11 + 1)}\nvar_10 = [0 for var_8 in range(var_11 + 1)]\n\nvar_4 = 1\nfor var_5 in var_12[var_9]:\n var_19[var_5] = True\n var_14[var_9][var_5] = var_4\n var_14[var_5][var_9] = var_4\n var_10[var_5] = var_4\n var_4 += 1\n var_6.append(var_5)\nwhile var_6:\n for var_15 in var_6:\n var_13 = 1\n for var_5 in var_12[var_15]:\n if var_19[var_5] == False:\n var_19[var_5] = True\n if var_13 != var_10[var_15]:\n var_14[var_15][var_5] = var_13\n var_14[var_5][var_15] = var_13\n var_10[var_5] = var_13\n var_13 += 1\n var_7.append(var_5)\n else:\n var_13 += 1\n var_14[var_15][var_5] = var_13\n var_14[var_5][var_15] = var_13\n var_10[var_5] = var_13\n var_13 += 1\n var_7.append(var_5)\n if var_7:\n var_6 = var_7\n var_7 = []\n else:\n var_6 = []\n var_7 = []\nvar_1 = 0\nfor var_8 in range(1, var_11 + 1):\n var_1 = max(var_1, len(var_12[var_8]))\nprint(var_1)\nfor var_8 in range(var_11 - 1):\n var_17, var_18 = var_16[var_8][0], var_16[var_8][1]\n print((var_14[var_17][var_18]))\n```", "output": "SLOWER 1.0676", "pair_id": "python_p02850_pair0007_reversed", "problem_id": "p02850", "language": "python", "direction": "reversed", "speedup_ratio": 2.0959} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_4 = {}\nvar_5 = 0\nfor var_6 in range(10000, 100000):\n var_3 = list(str(var_6))\n if var_3 == list(reversed(var_3)):\n var_5 += 1\n var_4[var_6] = var_5\nvar_1, var_2 = list(map(int, input().split()))\nprint((var_4[var_2] - var_4[var_1 - 1] if var_1 > 10000 else var_4[var_2]))\n```\n\n=== Code B (Modified) ===\n```python\ndef func_1():\n var_1, var_2 = list(map(int, input().rstrip().split()))\n var_3 = 0\n for var_4 in range(var_1, var_2 + 1):\n var_5 = str(var_4)\n if var_5 == var_5[::-1]:\n var_3 += 1\n print(var_3)\n\n\nif __name__ == \"__main__\":\n func_1()\n```", "output": "FASTER 4.3196", "pair_id": "python_p03416_pair0061_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 19.9676} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_7 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_3 = True\n var_8 = str(var_4)\n var_6 = len(var_8)\n for var_5 in range(var_6 // 2 + 1):\n if var_8[var_5] != var_8[-var_5 - 1]:\n var_3 = False\n break\n if var_3:\n var_7 += 1\nprint(var_7)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = [\n var_3 for var_3 in map(str, list(range(var_1, var_2 + 1))) if var_3 == var_3[::-1]\n]\nprint((len(var_4)))\n```", "output": "FASTER 1.8237", "pair_id": "python_p03416_pair0062_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 3.5398} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_6 in range(var_1, var_2 + 1):\n var_3 = str(var_6)\n var_5 = True\n for var_7 in range(len(var_3) // 2):\n if var_3[var_7] != var_3[-var_7 - 1] and var_5:\n var_5 = not var_5\n if var_5:\n var_4 += 1\nprint(var_4)\n```\n\n=== Code B (Modified) ===\n```python\ndef func_1():\n var_1, var_2 = list(map(int, input().rstrip().split()))\n var_3 = 0\n for var_4 in range(var_1, var_2 + 1):\n var_5 = str(var_4)\n if var_5 == var_5[::-1]:\n var_3 += 1\n print(var_3)\n\n\nif __name__ == \"__main__\":\n func_1()\n```", "output": "FASTER 2.2059", "pair_id": "python_p03416_pair0063_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 4.6137} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().rstrip().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = list(map(int, list(str(var_4))))\n if var_5[0] == var_5[4] and var_5[1] == var_5[3]:\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_5 in range(var_1, var_2 + 1):\n var_3 = str(var_5)\n if var_3[0] == var_3[-1] and var_3[1] == var_3[-2]:\n var_4 += 1\nprint(var_4)\n```", "output": "FASTER 1.7746", "pair_id": "python_p03416_pair0064_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 3.4214} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\n\nsys.setrecursionlimit(2147483647)\nvar_2 = float(\"inf\")\nvar_3 = 10**9 + 7\nvar_10 = lambda: sys.stdin.readline().rstrip()\n\n\ndef func_1():\n var_11, var_4 = list(map(int, var_10().split()))\n var_1 = [tuple(map(int, var_10().split())) for _ in range(var_11)]\n var_1.sort()\n var_8 = [0] * var_4\n var_6 = -var_2\n for var_9 in range(var_11):\n var_5, var_7 = var_1[var_9]\n var_12 = var_8[:]\n for var_13 in range(var_4):\n if var_13 + var_5 < var_4:\n var_12[var_13 + var_5] = max(\n var_12[var_13 + var_5], var_8[var_13] + var_7\n )\n else:\n var_6 = max(var_6, var_8[var_13] + var_7)\n var_8 = var_12\n print((max(var_6, max(var_8))))\n\n\nfunc_1()\n```\n\n=== Code B (Modified) ===\n```python\nfrom collections import Counter, defaultdict, deque\nfrom heapq import heappop, heappush, heapify\nimport sys, bisect, math, itertools, fractions, pprint\n\nsys.setrecursionlimit(10**8)\nvar_6 = 10**9 + 7\nvar_1 = float(\"inf\")\n\n\ndef func_1():\n return int(sys.stdin.readline())\n\n\ndef func_2():\n return list(map(int, sys.stdin.readline().split()))\n\n\nvar_7, var_9 = func_2()\nvar_13 = [func_2() for _ in range(var_7)]\nvar_13.sort(key=lambda var_14: var_14[1], reverse=True)\nvar_8 = 0\nvar_10 = min(var_7, 5)\nfor var_3 in range(var_10):\n var_2 = [[0] * (var_9 + 5) for _ in range(var_7 + 5)]\n for var_4 in range(var_7):\n var_12, var_11 = var_13[var_4]\n for var_5 in range(var_9):\n if var_5 < var_12 or var_3 == var_4:\n var_2[var_4 + 1][var_5] = var_2[var_4][var_5]\n else:\n var_2[var_4 + 1][var_5] = max(\n var_2[var_4][var_5], var_2[var_4][var_5 - var_12] + var_11\n )\n\n var_8 = max(var_2[var_7][var_9 - 1] + var_13[var_3][1], var_8)\nprint(var_8)\n```", "output": "SLOWER 2.6786", "pair_id": "python_p02863_pair0013_reversed", "problem_id": "p02863", "language": "python", "direction": "reversed", "speedup_ratio": 6.4023} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\n\nvar_10 = sys.stdin.readline\nvar_2, var_3 = list(map(int, var_10().split()))\nvar_1 = [list(map(int, var_10().split())) for _ in range(var_2)]\nvar_8 = [[0 for _ in range(var_2 + 1)] for _ in range(var_3 + 1)]\n\nvar_13 = [[0 for _ in range(var_2 + 1)] for _ in range(var_3 + 1)]\nfor var_11 in range(var_2):\n var_4, var_6 = var_1[var_11]\n for var_15 in range(var_3):\n if var_4 > var_15:\n var_8[var_15][var_11 + 1] = var_8[var_15][var_11]\n var_13[var_15][var_11 + 1] = var_15\n else:\n if var_6 + var_8[var_15 - var_4][var_11] >= var_8[var_15][var_11]:\n var_8[var_15][var_11 + 1] = var_8[var_15 - var_4][var_11] + var_6\n var_13[var_15][var_11 + 1] = var_15 - var_4\n else:\n var_8[var_15][var_11 + 1] = var_8[var_15][var_11]\n var_13[var_15][var_11 + 1] = var_15\nvar_5 = var_8[var_3 - 1][var_2]\nvar_14 = [False] * var_2\nvar_7 = var_3 - 1\nfor var_9 in reversed(list(range(var_2))):\n if var_13[var_7][var_9 + 1] == var_7 - var_1[var_9][0]:\n var_14[var_9] = True\n var_7 = var_13[var_7][var_9 + 1]\nvar_12 = 0\nfor var_9 in range(var_2):\n if not var_14[var_9] and var_1[var_9][1] > var_12:\n var_12 = var_1[var_9][1]\nprint((var_5 + var_12))\n```\n\n=== Code B (Modified) ===\n```python\nvar_6, var_7 = list(map(int, input().split()))\nvar_1 = [list(map(int, input().split())) for _ in range(var_6)]\nvar_1.sort()\nvar_3 = [(6007) * [0] for _ in range(var_6 + 1)]\nvar_3[0][0] = 0\nvar_2 = 0\nfor var_4 in range(var_6):\n for var_5 in range(6007):\n var_3[var_4 + 1][var_5] = max(var_3[var_4 + 1][var_5], var_3[var_4][var_5])\n if var_5 < var_7:\n var_3[var_4 + 1][var_5 + var_1[var_4][0]] = max(\n var_3[var_4][var_5] + var_1[var_4][1],\n var_3[var_4][var_5 + var_1[var_4][0]],\n )\n var_2 = max(var_2, var_3[var_4 + 1][var_5])\nprint(var_2)\n```", "output": "SLOWER 5.2357", "pair_id": "python_p02863_pair0014_reversed", "problem_id": "p02863", "language": "python", "direction": "reversed", "speedup_ratio": 37.6794} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nfrom collections import Counter, defaultdict, deque\nfrom heapq import heappop, heappush, heapify\nimport sys, bisect, math, itertools, fractions, pprint\n\nsys.setrecursionlimit(10**8)\nvar_6 = 10**9 + 7\nvar_1 = float(\"inf\")\n\n\ndef func_1():\n return int(sys.stdin.readline())\n\n\ndef func_2():\n return list(map(int, sys.stdin.readline().split()))\n\n\nvar_7, var_9 = func_2()\nvar_13 = [func_2() for _ in range(var_7)]\nvar_13.sort(key=lambda var_14: var_14[1], reverse=True)\nvar_8 = 0\nvar_10 = min(var_7, 5)\nfor var_3 in range(var_10):\n var_2 = [[0] * (var_9 + 5) for _ in range(var_7 + 5)]\n for var_4 in range(var_7):\n var_12, var_11 = var_13[var_4]\n for var_5 in range(var_9):\n if var_5 < var_12 or var_3 == var_4:\n var_2[var_4 + 1][var_5] = var_2[var_4][var_5]\n else:\n var_2[var_4 + 1][var_5] = max(\n var_2[var_4][var_5], var_2[var_4][var_5 - var_12] + var_11\n )\n\n var_8 = max(var_2[var_7][var_9 - 1] + var_13[var_3][1], var_8)\nprint(var_8)\n```\n\n=== Code B (Modified) ===\n```python\ndef func_1():\n var_2, var_3, *var_1 = list(map(int, open(0).read().split()))\n var_4 = [0] * (var_3 + max(var_1[::2]))\n for var_7, var_6 in sorted(zip(*[iter(var_1)] * 2)):\n for var_5 in reversed(list(range(var_3))):\n var_4[var_5 + var_7] = max(var_4[var_5 + var_7], var_4[var_5] + var_6)\n print((max(var_4)))\n\n\nfunc_1()\n```", "output": "FASTER 2.938", "pair_id": "python_p02863_pair0015_forward", "problem_id": "p02863", "language": "python", "direction": "forward", "speedup_ratio": 7.6633} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\ndef func_1():\n from sys import setrecursionlimit, stdin\n from os import environ\n from collections import defaultdict, deque, Counter\n from math import ceil, floor, gcd\n from itertools import accumulate, combinations, combinations_with_replacement\n\n setrecursionlimit(10**6)\n var_7 = (\n (lambda *var_11: print(*var_11))\n if \"TERM_PROGRAM\" in environ\n else lambda *var_12: 0\n )\n var_8 = lambda: stdin.readline().rstrip()\n var_3 = lambda: list(map(int, var_8().split()))\n var_1 = lambda: int(var_8())\n var_4 = 10**9 + 7\n var_2 = 10**9 + 10\n var_9, var_10 = var_8().split()\n var_5 = int(var_9)\n var_6 = int(float(var_10) * 100 + 0.5)\n print(var_5 * var_6 // 100)\n\n\nfunc_1()\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\n\nvar_3 = sys.stdin.readline\nvar_1, var_2 = var_3().split()\nvar_1 = int(var_1)\nvar_2 = int(float(var_2) * 100 + 0.5)\nprint((var_1 * var_2 // 100))\n```", "output": "FASTER 2.0133", "pair_id": "python_p02659_pair0013_forward", "problem_id": "p02659", "language": "python", "direction": "forward", "speedup_ratio": 4.0371} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_6, var_7 = list(map(int, input().split()))\nvar_1 = [list(map(int, input().split())) for _ in range(var_6)]\nvar_1.sort()\nvar_3 = [(6007) * [0] for _ in range(var_6 + 1)]\nvar_3[0][0] = 0\nvar_2 = 0\nfor var_4 in range(var_6):\n for var_5 in range(6007):\n var_3[var_4 + 1][var_5] = max(var_3[var_4 + 1][var_5], var_3[var_4][var_5])\n if var_5 < var_7:\n var_3[var_4 + 1][var_5 + var_1[var_4][0]] = max(\n var_3[var_4][var_5] + var_1[var_4][1],\n var_3[var_4][var_5 + var_1[var_4][0]],\n )\n var_2 = max(var_2, var_3[var_4 + 1][var_5])\nprint(var_2)\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\n\nvar_10 = sys.stdin.readline\nvar_2, var_3 = list(map(int, var_10().split()))\nvar_1 = [list(map(int, var_10().split())) for _ in range(var_2)]\nvar_8 = [[0 for _ in range(var_2 + 1)] for _ in range(var_3 + 1)]\n\nvar_13 = [[0 for _ in range(var_2 + 1)] for _ in range(var_3 + 1)]\nfor var_11 in range(var_2):\n var_4, var_6 = var_1[var_11]\n for var_15 in range(var_3):\n if var_4 > var_15:\n var_8[var_15][var_11 + 1] = var_8[var_15][var_11]\n var_13[var_15][var_11 + 1] = var_15\n else:\n if var_6 + var_8[var_15 - var_4][var_11] >= var_8[var_15][var_11]:\n var_8[var_15][var_11 + 1] = var_8[var_15 - var_4][var_11] + var_6\n var_13[var_15][var_11 + 1] = var_15 - var_4\n else:\n var_8[var_15][var_11 + 1] = var_8[var_15][var_11]\n var_13[var_15][var_11 + 1] = var_15\nvar_5 = var_8[var_3 - 1][var_2]\nvar_14 = [False] * var_2\nvar_7 = var_3 - 1\nfor var_9 in reversed(list(range(var_2))):\n if var_13[var_7][var_9 + 1] == var_7 - var_1[var_9][0]:\n var_14[var_9] = True\n var_7 = var_13[var_7][var_9 + 1]\nvar_12 = 0\nfor var_9 in range(var_2):\n if not var_14[var_9] and var_1[var_9][1] > var_12:\n var_12 = var_1[var_9][1]\nprint((var_5 + var_12))\n```", "output": "FASTER 5.2357", "pair_id": "python_p02863_pair0014_forward", "problem_id": "p02863", "language": "python", "direction": "forward", "speedup_ratio": 37.6794} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\nfrom collections import Counter\n\n\ndef func_9():\n return sys.stdin.readline().strip()\n\n\ndef func_10(var_8, var_9, var_10):\n return [[var_10] * var_9 for var_13 in range(var_8)]\n\n\ndef func_11(var_8, var_9, var_10, var_11):\n return [[[var_11] * var_10 for var_14 in range(var_9)] for var_13 in range(var_8)]\n\n\ndef func_12(var_8, var_9, var_10, var_11, var_12):\n return [\n [[[var_12] * var_11 for var_14 in range(var_10)] for var_14 in range(var_9)]\n for var_13 in range(var_8)\n ]\n\n\ndef func_8(var_16, var_17=1):\n return int(-(-var_16 // var_17))\n\n\ndef func_1():\n return int(eval(func_9()))\n\n\ndef func_3():\n return list(map(int, func_9().split()))\n\n\ndef func_2(var_7=None):\n return list(func_3()) if var_7 is None else [func_1() for var_13 in range(var_7)]\n\n\ndef func_7():\n print(\"Yes\")\n\n\ndef func_5():\n print(\"No\")\n\n\ndef func_6():\n print(\"YES\")\n\n\ndef func_4():\n print(\"NO\")\n\n\nsys.setrecursionlimit(10**9)\nvar_3 = 10**18\nvar_6 = 10**9 + 7\nvar_7, var_5, var_4 = func_3()\nvar_1 = func_2()\nvar_2 = func_2()\nvar_15 = min(var_1) + min(var_2)\nfor _ in range(var_4):\n var_16, var_17, var_10 = func_3()\n var_16 -= 1\n var_17 -= 1\n var_15 = min(var_15, var_1[var_16] + var_2[var_17] - var_10)\nprint(var_15)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2, var_3 = list(map(int, input().split()))\nvar_4 = list(map(int, input().split()))\nvar_6 = list(map(int, input().split()))\nvar_5 = min(var_4) + min(var_6)\nfor var_7 in range(var_3):\n var_9, var_10, var_11 = list(map(int, input().split()))\n var_8 = var_4[var_9 - 1] + var_6[var_10 - 1] - var_11\n var_5 = var_8 if var_8 < var_5 else var_5\nprint(var_5)\n```", "output": "FASTER 1.8148", "pair_id": "python_p02748_pair0002_forward", "problem_id": "p02748", "language": "python", "direction": "forward", "speedup_ratio": 3.5181} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\n\nvar_8 = sys.stdin.readline\n\n\ndef func_1():\n var_2 = int(eval(var_8()))\n var_1 = [int(var_8().replace(\" \", \"\"), 2) for _ in range(var_2)]\n var_3 = [list(map(int, var_8().split())) for _ in range(var_2)]\n var_4 = -(10**7) * var_2\n for var_7 in range(1, 1 << 10):\n var_10 = 0\n for var_9, var_6 in enumerate(var_1):\n var_5 = bin(var_7 & var_6).count(\"1\")\n var_10 += var_3[var_9][var_5]\n var_4 = max(var_4, var_10)\n print(var_4)\n\n\nif __name__ == \"__main__\":\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\nimport numpy as np\n\nvar_6 = int(eval(input()))\n\nvar_1 = [input().replace(\" \", \"\") for var_4 in range(var_6)]\n\nvar_7 = [list(map(int, input().split())) for var_4 in range(var_6)]\nvar_11 = -999999999999999\nfor var_4 in range(1, 1024):\n var_3 = format(var_4, \"010b\")\n var_9 = 0\n for var_2, var_8 in zip(var_1, var_7):\n var_10 = 0\n for var_5 in range(10):\n if var_2[var_5] == \"1\" and var_3[var_5] == \"1\":\n var_10 += 1\n var_9 += var_8[var_10]\n if var_9 > var_11:\n if var_9 == 0:\n print((str(var_4)))\n break\n var_11 = var_9\nprint(var_11)\n```", "output": "SLOWER 2.2365", "pair_id": "python_p03503_pair0008_reversed", "problem_id": "p03503", "language": "python", "direction": "reversed", "speedup_ratio": 4.7126} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\ndef func_1():\n from sys import setrecursionlimit, stdin\n from os import environ\n from collections import defaultdict, deque, Counter\n from math import ceil, floor, gcd\n from itertools import accumulate, combinations, combinations_with_replacement\n\n setrecursionlimit(10**6)\n var_7 = (\n (lambda *var_11: print(*var_11))\n if \"TERM_PROGRAM\" in environ\n else lambda *var_12: 0\n )\n var_8 = lambda: stdin.readline().rstrip()\n var_3 = lambda: list(map(int, var_8().split()))\n var_1 = lambda: int(var_8())\n var_4 = 10**9 + 7\n var_2 = 10**9 + 10\n var_9, var_10 = var_8().split()\n var_5 = int(var_9)\n var_6 = int(float(var_10) * 100 + 0.5)\n print(var_5 * var_6 // 100)\n\n\nfunc_1()\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = input().split()\nprint((int(var_1) * int(var_2[:-3] + var_2[-2:]) // 100))\n```", "output": "FASTER 2.4305", "pair_id": "python_p02659_pair0014_forward", "problem_id": "p02659", "language": "python", "direction": "forward", "speedup_ratio": 5.3907} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport math\nimport string\n\n\ndef func_4():\n return list(map(int, input().split()))\n\n\ndef func_3(var_6, var_7):\n return math.factorial(var_6) // (\n math.factorial(var_6 - var_7) * math.factorial(var_7)\n )\n\n\ndef func_2(var_9):\n var_8 = []\n for var_5 in var_9:\n if not (var_5 in var_8):\n var_8.append(var_5)\n return len(var_9) != len(var_8)\n\n\ndef func_1(var_6):\n func_1 = []\n for var_4 in range(1, var_6 + 1):\n if var_6 % var_4 == 0:\n func_1.append(var_4)\n return func_1\n\n\nvar_2 = [-1, -1, -1, 0, 0, 1, 1, 1]\nvar_3 = [-1, 0, 1, -1, 1, -1, 0, 1]\nvar_6 = int(eval(input()))\nvar_1 = func_4()\nvar_10 = 1\nfor var_4 in range(len(var_1)):\n if var_1[var_4] % 2 == 0:\n var_10 *= 2\n else:\n var_10 *= 1\nprint((3 ** len(var_1) - var_10))\n```\n\n=== Code B (Modified) ===\n```python\ndef func_1():\n var_2 = int(eval(input()))\n var_1 = [int(var_6) for var_6 in input().split()]\n var_4 = 3**var_2\n var_5 = len([var_3 for var_3 in var_1 if var_3 % 2 == 0])\n var_4 -= 2**var_5\n print(var_4)\n\n\nif __name__ == \"__main__\":\n func_1()\n```", "output": "FASTER 1.1807", "pair_id": "python_p03568_pair0003_forward", "problem_id": "p03568", "language": "python", "direction": "forward", "speedup_ratio": 2.2669} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_6 = 2019\nvar_1 = [0] * var_6\nvar_3 = 1\nvar_5 = var_4 = 0\nfor var_2 in input()[::-1]:\n var_1[var_4] += 1\n var_4 -= int(var_2) * var_3\n var_4 %= var_6\n var_5 += var_1[var_4]\n var_3 *= 10\n var_3 %= var_6\nprint(var_5)\n```\n\n=== Code B (Modified) ===\n```python\nvar_6 = input()[::-1]\nvar_4 = len(var_6)\nvar_2 = [0] * 2019\nvar_2[0] = 1\nvar_7 = 1\nvar_5 = 0\nvar_1 = 0\nfor var_3 in range(var_4):\n var_5 = (var_5 + int(var_6[var_3]) * var_7) % 2019\n var_7 = var_7 * 10 % 2019\n var_2[var_5] += 1\nfor var_3 in var_2:\n var_1 += var_3 * (var_3 - 1) // 2\nprint(var_1)\n```", "output": "SLOWER 2.8807", "pair_id": "python_p02702_pair0006_reversed", "problem_id": "p02702", "language": "python", "direction": "reversed", "speedup_ratio": 7.3649} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_6 = input()[::-1]\nvar_4 = len(var_6)\nvar_2 = [0] * 2019\nvar_2[0] = 1\nvar_7 = 1\nvar_5 = 0\nvar_1 = 0\nfor var_3 in range(var_4):\n var_5 = (var_5 + int(var_6[var_3]) * var_7) % 2019\n var_7 = var_7 * 10 % 2019\n var_2[var_5] += 1\nfor var_3 in var_2:\n var_1 += var_3 * (var_3 - 1) // 2\nprint(var_1)\n```\n\n=== Code B (Modified) ===\n```python\nimport numpy as np\n\nvar_7 = input()[::-1]\nvar_6 = len(var_7)\nvar_1 = np.zeros(var_6, dtype=int)\nvar_4 = np.zeros(var_6, dtype=int)\nvar_2 = np.zeros(2019, dtype=int)\nvar_8 = 10\nvar_1[0] = int(var_7[0])\nvar_4[0] = var_1[0]\nvar_2[var_4[0]] += 1\nfor var_5 in range(1, var_6):\n var_1[var_5] = int(var_7[var_5]) * var_8 % 2019\n var_4[var_5] = (var_4[var_5 - 1] + var_1[var_5]) % 2019\n var_2[var_4[var_5]] += 1\n var_8 = var_8 * 10 % 2019\nvar_3 = var_2[np.nonzero(var_2)]\nprint(\n (\n int(\n sum([var_3[var_5] * (var_3[var_5] - 1) for var_5 in range(var_3.shape[0])])\n / 2\n )\n + var_2[0]\n )\n)\n```", "output": "FASTER 1.3294", "pair_id": "python_p02702_pair0007_forward", "problem_id": "p02702", "language": "python", "direction": "forward", "speedup_ratio": 2.5129} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\ndef func_1(var_1):\n var_2 = 0\n var_4 = 1\n for var_3 in range(1_000_001):\n var_2 += 7 * var_4\n var_2 %= var_1\n if var_2 == 0:\n return var_3 + 1\n var_4 *= 10\n var_4 %= var_1\n else:\n return -1\n\n\nprint((func_1(int(eval(input())))))\n```\n\n=== Code B (Modified) ===\n```python\nvar_1 = int(eval(input()))\nvar_3 = 0\nfor var_2 in range(1000001):\n var_3 += 7 * pow(10, var_2, var_1)\n var_3 %= var_1\n if var_3 == 0:\n print((var_2 + 1))\n break\nelse:\n print((-1))\n```", "output": "SLOWER 2.9835", "pair_id": "python_p02596_pair0002_reversed", "problem_id": "p02596", "language": "python", "direction": "reversed", "speedup_ratio": 7.9088} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\n\n\ndef func_6():\n return sys.stdin.readline()[:-1]\n\n\ndef func_2():\n return int(eval(func_6()))\n\n\ndef func_3():\n return list(map(int, func_6().split()))\n\n\ndef func_1():\n return list(func_3())\n\n\nvar_10, var_11 = func_3()\nvar_5 = [0] + func_1()\nvar_3 = [func_1() + [var_6] for var_6 in range(var_11)]\nvar_3.sort(key=lambda var_15: var_15[1])\nvar_4 = [0] * (var_11)\nvar_9 = [0 for var_6 in range(var_10 + 1)]\nvar_2 = 2\nwhile var_2 <= var_10:\n var_2 *= 2\nvar_1 = [0] * (var_2 + 1)\n\n\ndef func_4(var_6, var_15):\n while var_6 <= var_2:\n var_1[var_6] += var_15\n var_6 += var_6 & -var_6\n\n\ndef func_5(var_6):\n var_13 = 0\n while var_6:\n var_13 += var_1[var_6]\n var_6 -= var_6 & -var_6\n return var_13\n\n\ndef func_7(var_8, var_12):\n return func_5(var_12) - func_5(var_8 - 1)\n\n\nvar_7 = 1\nfor var_8, var_12, var_6 in var_3:\n while var_7 <= var_12:\n var_14 = var_5[var_7]\n if var_9[var_14]:\n func_4(var_9[var_14], -1)\n func_4(var_7, 1)\n var_9[var_14] = var_7\n var_7 += 1\n var_4[var_6] = func_7(var_8, var_12)\nfor var_6 in var_4:\n print(var_6)\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\n\nvar_20 = sys.stdin.read\nvar_21 = sys.stdin.readline\nvar_22 = sys.stdin.readlines\nsys.setrecursionlimit(10**9)\nvar_2 = 1 << 60\nvar_5 = 1000000007\n\n\nvar_4 = 1000001\n\n\nclass Class_1:\n def __init__(self, var_13, var_19, var_12):\n self.l = var_13\n self.r = var_19\n self.idx = var_12\n\n\ndef func_4(var_12, var_24, var_10, var_15):\n while var_12 <= var_15:\n var_10[var_12] += var_24\n var_12 += var_12 & -var_12\n\n\ndef func_3(var_12, var_10, var_15):\n var_23 = 0\n while var_12:\n var_23 += var_10[var_12]\n var_12 -= var_12 & -var_12\n return var_23\n\n\ndef func_1(var_9, var_15, var_17, var_16):\n\n var_10 = [0] * (var_15 + 1)\n\n var_14 = [-1] * var_4\n\n var_8 = [0] * var_16\n var_18 = 0\n for var_11 in range(var_15):\n\n if var_14[var_9[var_11]] != -1:\n func_4(var_14[var_9[var_11]] + 1, -1, var_10, var_15)\n\n var_14[var_9[var_11]] = var_11\n func_4(var_11 + 1, 1, var_10, var_15)\n\n while var_18 < var_16 and var_17[var_18].r == var_11:\n var_8[var_17[var_18].idx] = func_3(\n var_17[var_18].r + 1, var_10, var_15\n ) - func_3(var_17[var_18].l, var_10, var_15)\n var_18 += 1\n\n for var_11 in range(var_16):\n print((var_8[var_11]))\n\n\ndef func_2():\n var_6, var_7 = list(map(int, var_21().split()))\n var_1 = list(map(int, var_21().split()))\n (*var_3,) = list(map(int, var_20().split()))\n var_17 = [0] * var_7\n for var_11, (var_13, var_19) in enumerate(zip(*[iter(var_3)] * 2)):\n var_17[var_11] = Class_1(var_13 - 1, var_19 - 1, var_11)\n var_17.sort(key=lambda var_25: var_25.r)\n func_1(var_1, var_6, var_17, var_7)\n return\n\n\nif __name__ == \"__main__\":\n func_2()\n```", "output": "SLOWER 2.4053", "pair_id": "python_p02599_pair0001_reversed", "problem_id": "p02599", "language": "python", "direction": "reversed", "speedup_ratio": 5.2974} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nfrom collections import Counter, defaultdict, deque\nfrom heapq import heappop, heappush, heapify\nimport sys, bisect, math, itertools, fractions, pprint\n\nsys.setrecursionlimit(10**8)\nvar_6 = 10**9 + 7\nvar_1 = float(\"inf\")\n\n\ndef func_1():\n return int(sys.stdin.readline())\n\n\ndef func_2():\n return list(map(int, sys.stdin.readline().split()))\n\n\nvar_7, var_9 = func_2()\nvar_13 = [func_2() for _ in range(var_7)]\nvar_13.sort(key=lambda var_14: var_14[1], reverse=True)\nvar_8 = 0\nvar_10 = min(var_7, 5)\nfor var_3 in range(var_10):\n var_2 = [[0] * (var_9 + 5) for _ in range(var_7 + 5)]\n for var_4 in range(var_7):\n var_12, var_11 = var_13[var_4]\n for var_5 in range(var_9):\n if var_5 < var_12 or var_3 == var_4:\n var_2[var_4 + 1][var_5] = var_2[var_4][var_5]\n else:\n var_2[var_4 + 1][var_5] = max(\n var_2[var_4][var_5], var_2[var_4][var_5 - var_12] + var_11\n )\n\n var_8 = max(var_2[var_7][var_9 - 1] + var_13[var_3][1], var_8)\nprint(var_8)\n```\n\n=== Code B (Modified) ===\n```python\nfrom sys import stdin\n\n\ndef func_1():\n\n var_9 = stdin.readline\n var_8, var_10 = list(map(int, var_9().split()))\n var_7 = [list(map(int, var_9().split())) for _ in range(var_8)]\n var_7.sort()\n var_1 = [0] * var_8\n var_2 = [0] * var_8\n for var_4 in range(var_8):\n var_1[var_4], var_2[var_4] = var_7[var_4][0], var_7[var_4][1]\n\n var_5 = -(10**9)\n var_3 = [[var_5] * (var_10 + 1) for _ in range(var_8 + 1)]\n var_3[0][0] = 0\n for var_4 in range(var_8):\n for var_6 in range(var_10 + 1):\n\n if var_6 != var_10:\n var_3[var_4 + 1][min(var_10, var_6 + var_1[var_4])] = max(\n var_3[var_4 + 1][min(var_10, var_6 + var_1[var_4])],\n var_3[var_4][var_6] + var_2[var_4],\n )\n\n var_3[var_4 + 1][var_6] = max(var_3[var_4 + 1][var_6], var_3[var_4][var_6])\n print((max(var_3[var_8])))\n\n\nif __name__ == \"__main__\":\n func_1()\n```", "output": "FASTER 1.7415", "pair_id": "python_p02863_pair0016_forward", "problem_id": "p02863", "language": "python", "direction": "forward", "speedup_ratio": 3.3438} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nfrom sys import stdin\n\n\ndef func_1():\n\n var_9 = stdin.readline\n var_8, var_10 = list(map(int, var_9().split()))\n var_7 = [list(map(int, var_9().split())) for _ in range(var_8)]\n var_7.sort()\n var_1 = [0] * var_8\n var_2 = [0] * var_8\n for var_4 in range(var_8):\n var_1[var_4], var_2[var_4] = var_7[var_4][0], var_7[var_4][1]\n\n var_5 = -float(\"inf\")\n var_3 = [[var_5] * (var_10 + 1) for _ in range(var_8 + 1)]\n var_3[0][0] = 0\n for var_4 in range(var_8):\n for var_6 in range(var_10 + 1):\n\n if var_6 != var_10:\n var_3[var_4 + 1][min(var_10, var_6 + var_1[var_4])] = max(\n var_3[var_4 + 1][min(var_10, var_6 + var_1[var_4])],\n var_3[var_4][var_6] + var_2[var_4],\n )\n\n var_3[var_4 + 1][var_6] = max(var_3[var_4 + 1][var_6], var_3[var_4][var_6])\n print((max(var_3[var_8])))\n\n\nif __name__ == \"__main__\":\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\ndef func_1():\n var_2, var_3, *var_1 = list(map(int, open(0).read().split()))\n var_4 = [0] * (var_3 + max(var_1[::2]))\n for var_7, var_6 in sorted(zip(*[iter(var_1)] * 2)):\n for var_5 in reversed(list(range(var_3))):\n var_4[var_5 + var_7] = max(var_4[var_5 + var_7], var_4[var_5] + var_6)\n print((max(var_4)))\n\n\nfunc_1()\n```", "output": "FASTER 1.2195", "pair_id": "python_p02863_pair0017_forward", "problem_id": "p02863", "language": "python", "direction": "forward", "speedup_ratio": 2.3287} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\ndef func_1():\n var_1, var_2 = list(map(int, input().split()))\n var_3 = 0\n for var_4 in range(var_1, var_2 + 1):\n\n if (var_4 % 10) == (var_4 // 10000 % 10) and (var_4 // 10 % 10) == (\n var_4 // 1000 % 10\n ):\n var_3 += 1\n print(var_3)\n\n\nif __name__ == \"__main__\":\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nvar_4, var_3 = list(map(int, input().split()))\nvar_1 = 0\nfor var_2 in range(var_4, var_3 + 1):\n if str(var_2)[0] + str(var_2)[1] == str(var_2)[-1] + str(var_2)[-2]:\n var_1 += 1\nprint(var_1)\n```", "output": "SLOWER 3.0051", "pair_id": "python_p03416_pair0065_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 8.0286} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_2 = var_2 / 0.1\nvar_3 = [var_4 + var_2 for var_4 in range(10)]\nfor var_4 in var_3:\n if int(var_4 * 0.08) == var_1:\n print((int(var_4)))\n exit()\nprint(\"-1\")\n```\n\n=== Code B (Modified) ===\n```python\nfrom math import floor\n\nvar_1, var_2 = list(map(int, input().split()))\n\n\nfor var_3 in range(1010):\n if (floor(var_3 * 0.08) == var_1) and (floor(var_3 * 0.1) == var_2):\n\n print(var_3)\n quit()\n\n\nprint((-1))\n```", "output": "SLOWER 1.8373", "pair_id": "python_p02755_pair0002_reversed", "problem_id": "p02755", "language": "python", "direction": "reversed", "speedup_ratio": 3.5734} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_6 = sorted([list(map(int, input().split())) for var_5 in range(var_1)])\n\nvar_4 = [[0] * (var_2 + 1) for var_5 in range(var_1 + 1)]\n\nfor var_5 in range(var_1):\n var_9, var_8 = var_6[var_5]\n for var_7 in range(var_2 + 1):\n if var_7 + var_9 <= var_2:\n var_4[var_5 + 1][var_7 + var_9] = max(\n var_4[var_5 + 1][var_7 + var_9], var_4[var_5][var_7] + var_8\n )\n var_4[var_5 + 1][var_7] = max(var_4[var_5][var_7], var_4[var_5 + 1][var_7])\nvar_3 = 0\nfor var_5, (var_9, var_8) in enumerate(var_6):\n for var_7 in range(var_2):\n var_3 = max(var_3, var_4[var_5][var_7] + var_8)\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\nfrom operator import itemgetter\nfrom heapq import heapify, heappop, heappush\n\nvar_1 = int(10e15)\nvar_2 = -var_1\nvar_11 = 1000000007\nsys.setrecursionlimit(1000000)\n\n\ndef func_2():\n return list(map(int, input().split()))\n\n\ndef func_4():\n return input().split()\n\n\ndef func_1():\n return int(sys.stdin.readline())\n\n\ndef func_3():\n return eval(input())\n\n\nvar_3, var_4 = func_2()\nvar_5 = [func_2() for var_9 in range(var_3)]\nvar_5.sort(key=itemgetter(0))\n\nvar_8 = [[0] * (var_4 + 1 + 3000 + 1) for _ in range(var_3 + 1)]\nvar_6 = 0\nfor var_9 in range(var_3):\n for var_10 in range(var_4 + 1 + 3000 + 1):\n var_12, var_7 = var_5[var_9]\n if 0 <= var_10 - var_12 < var_4:\n var_8[var_9 + 1][var_10] = max(\n var_8[var_9][var_10], var_8[var_9][var_10 - var_12] + var_7\n )\n else:\n var_8[var_9 + 1][var_10] = var_8[var_9][var_10]\n var_6 = max(var_6, var_8[var_9 + 1][var_10])\nprint(var_6)\n```", "output": "SLOWER 4.0536", "pair_id": "python_p02863_pair0018_reversed", "problem_id": "p02863", "language": "python", "direction": "reversed", "speedup_ratio": 16.6053} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = str(var_4)\n if var_5[0] == var_5[4] and var_5[1] == var_5[3]:\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = list(reversed(list(str(var_4))))\n if var_5 == list(str(var_4)):\n var_3 += 1\nprint(var_3)\n```", "output": "SLOWER 1.9231", "pair_id": "python_p03416_pair0066_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 3.7924} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport decimal\n\nvar_1, var_2 = (decimal.Decimal(var_3) for var_3 in input().split())\nprint((int(var_1 * var_2)))\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\nimport math\nfrom collections import defaultdict\nfrom bisect import bisect_left, bisect_right\n\nsys.setrecursionlimit(10**7)\n\n\ndef func_4():\n return sys.stdin.readline()[:-1]\n\n\nvar_4 = 10**9 + 7\n\n\ndef func_1():\n return int(eval(func_4()))\n\n\ndef func_2():\n return list(map(int, func_4().split()))\n\n\ndef func_3(var_6, var_3):\n if var_6 <= 0:\n return [[] for _ in range(var_3)]\n elif var_3 == 1:\n return [func_1() for _ in range(var_6)]\n else:\n var_5 = [func_2() for _ in range(var_6)]\n return list(map(list, list(zip(*var_5))))\n\n\nfrom decimal import getcontext, Decimal\n\ngetcontext().prec = 28\nvar_1, var_2 = list(map(str, func_4().split()))\nvar_1 = int(var_1)\nvar_2 = Decimal(var_2)\nprint((int(var_1 * var_2)))\n```", "output": "SLOWER 2.232", "pair_id": "python_p02659_pair0015_reversed", "problem_id": "p02659", "language": "python", "direction": "reversed", "speedup_ratio": 4.6978} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport copy\n\nvar_8 = int(eval(input()))\nvar_10 = set([var_6 for var_6 in range(1, 10**5)])\nvar_5 = []\nvar_11 = {}\nvar_9 = []\nfor var_6 in range(var_8 - 1):\n var_1, var_2 = list(map(int, input().split(\" \")))\n var_5.append([var_1, var_2])\n var_11.setdefault(var_1, []).append(var_2)\n var_9.append([])\nvar_9.append([])\nvar_9.append([])\nvar_7 = 0\nfor var_12 in range(1, var_8 + 1):\n var_14 = var_11.get(var_12, [])\n var_3 = 1\n for var_13 in var_14:\n if var_3 in var_9[var_12]:\n var_3 += 1\n else:\n pass\n var_9[var_13].append(var_3)\n if var_3 >= var_7:\n var_7 = var_3\n var_3 += 1\nprint(var_7)\nfor var_4 in var_5:\n print((var_9[var_4[1]][0]))\n```\n\n=== Code B (Modified) ===\n```python\nfrom collections import deque\n\nvar_9 = deque()\nvar_11 = deque()\nvar_4 = int(eval(input()))\nvar_12 = [[] for var_13 in range(var_4 + 1)]\nvar_2 = []\nfor _ in range(var_4 - 1):\n var_5, var_6 = list(map(int, input().split()))\n var_12[var_5].append(var_6)\n var_12[var_6].append(var_5)\n var_2.append((var_5, var_6))\n\nvar_3 = 0\nvar_9.append(1)\nvar_17 = [False for var_13 in range(var_4 + 1)]\nvar_8 = [-1 for var_13 in range(var_4 + 1)]\nvar_17[1] = True\nvar_8[1] = -1\nvar_10 = {}\nwhile var_9:\n while var_9:\n var_18 = var_9.popleft()\n var_15 = var_8[var_18]\n var_7 = 1\n for var_14 in var_12[var_18]:\n if var_17[var_14] == False:\n var_17[var_14] = True\n var_11.append(var_14)\n if var_7 != var_15:\n var_8[var_14] = var_7\n var_10[(var_18, var_14)] = var_7\n elif var_7 == var_15:\n var_7 += 1\n var_8[var_14] = var_7\n var_10[(var_18, var_14)] = var_7\n var_7 += 1\n if var_11:\n var_9 = var_11\n var_11 = deque()\nvar_1 = max(var_8)\nprint(var_1)\nfor var_16 in var_2:\n var_5, var_6 = var_16\n if (var_5, var_6) in list(var_10.keys()):\n print((var_10[var_16]))\n else:\n print((var_10[(var_6, var_5)]))\n```", "output": "FASTER 3.8829", "pair_id": "python_p02850_pair0008_forward", "problem_id": "p02850", "language": "python", "direction": "forward", "speedup_ratio": 14.7526} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1 = [int(eval(input())) for _ in range(int(eval(input())))]\nprint((sum(var_1) - int(max(var_1) / 2)))\n```\n\n=== Code B (Modified) ===\n```python\nimport copy\nimport random\nimport bisect\nimport fractions\nimport math\nimport sys\nimport collections\nfrom decimal import Decimal\n\nvar_5 = 10**9 + 7\nsys.setrecursionlimit(var_5)\nvar_3 = collections.deque()\n\n\ndef func_1():\n return list(map(int, sys.stdin.readline().split()))\n\n\nvar_1 = int(eval(input()))\nvar_6 = [0 for var_4 in range(var_1)]\nfor var_4 in range(var_1):\n var_6[var_4] = int(eval(input()))\nvar_6.sort()\nvar_2 = sum(var_6)\nvar_2 -= var_6[-1] // 2\nprint(var_2)\n```", "output": "SLOWER 1.0343", "pair_id": "python_p03207_pair0001_reversed", "problem_id": "p03207", "language": "python", "direction": "reversed", "speedup_ratio": 2.0481} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n if str(var_4) == \"\".join(reversed(str(var_4))):\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = str(var_4)\n if var_5[0] == var_5[4] and var_5[1] == var_5[3]:\n var_3 += 1\nprint(var_3)\n```", "output": "FASTER 1.3424", "pair_id": "python_p03416_pair0067_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 2.5357} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nfrom collections import deque\n\nvar_4, *var_2 = list(map(int, open(0).read().split()))\nvar_3 = [set() for _ in range(var_4 + 1)]\nfor var_9, (var_6, var_7) in enumerate(zip(*[iter(var_2)] * 2)):\n var_3[var_6].add((var_7, var_9))\n var_3[var_7].add((var_6, var_9))\nvar_1 = [0] * (var_4 - 1)\nvar_5 = deque([1])\nwhile var_5:\n var_10, var_12 = divmod(var_5.popleft(), var_4 + 1)\n var_8 = 0\n for var_11, var_9 in var_3[var_12]:\n var_3[var_11].remove((var_12, var_9))\n var_8 += 1 + (var_8 + 1 == var_10)\n var_5.append(var_8 * (var_4 + 1) + var_11)\n var_1[var_9] = var_8\nprint((max(var_1)))\nprint((\"\\n\".join(map(str, var_1))))\n```\n\n=== Code B (Modified) ===\n```python\nimport copy\n\nvar_8 = int(eval(input()))\nvar_10 = set([var_6 for var_6 in range(1, 10**5)])\nvar_5 = []\nvar_11 = {}\nvar_9 = []\nfor var_6 in range(var_8 - 1):\n var_1, var_2 = list(map(int, input().split(\" \")))\n var_5.append([var_1, var_2])\n var_11.setdefault(var_1, []).append(var_2)\n var_9.append([])\nvar_9.append([])\nvar_9.append([])\nvar_7 = 0\nfor var_12 in range(1, var_8 + 1):\n var_14 = var_11.get(var_12, [])\n var_3 = 1\n for var_13 in var_14:\n if var_3 in var_9[var_12]:\n var_3 += 1\n else:\n pass\n var_9[var_13].append(var_3)\n if var_3 >= var_7:\n var_7 = var_3\n var_3 += 1\nprint(var_7)\nfor var_4 in var_5:\n print((var_9[var_4[1]][0]))\n```", "output": "SLOWER 4.4548", "pair_id": "python_p02850_pair0009_reversed", "problem_id": "p02850", "language": "python", "direction": "reversed", "speedup_ratio": 21.93} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport math\nimport string\n\n\ndef func_4():\n return list(map(int, input().split()))\n\n\ndef func_3(var_6, var_7):\n return math.factorial(var_6) // (\n math.factorial(var_6 - var_7) * math.factorial(var_7)\n )\n\n\ndef func_2(var_9):\n var_8 = []\n for var_5 in var_9:\n if not (var_5 in var_8):\n var_8.append(var_5)\n return len(var_9) != len(var_8)\n\n\ndef func_1(var_6):\n func_1 = []\n for var_4 in range(1, var_6 + 1):\n if var_6 % var_4 == 0:\n func_1.append(var_4)\n return func_1\n\n\nvar_2 = [-1, -1, -1, 0, 0, 1, 1, 1]\nvar_3 = [-1, 0, 1, -1, 1, -1, 0, 1]\nvar_6 = int(eval(input()))\nvar_1 = func_4()\nvar_10 = 1\nfor var_4 in range(len(var_1)):\n if var_1[var_4] % 2 == 0:\n var_10 *= 2\n else:\n var_10 *= 1\nprint((3 ** len(var_1) - var_10))\n```\n\n=== Code B (Modified) ===\n```python\nvar_6 = int(eval(input()))\nvar_2 = list(map(int, input().split()))\nfrom itertools import product\n\nvar_5 = [-1, 0, 1]\nvar_3 = 0\nfor var_7 in product(var_5, repeat=var_6):\n var_1 = []\n for var_4 in range(var_6):\n var_1.append(var_7[var_4] + var_2[var_4])\n if any(var_8 % 2 == 0 for var_8 in var_1):\n var_3 += 1\nprint(var_3)\n```", "output": "SLOWER 8.1431", "pair_id": "python_p03568_pair0010_reversed", "problem_id": "p03568", "language": "python", "direction": "reversed", "speedup_ratio": 282.6949} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\nimport math\nfrom collections import defaultdict\nfrom bisect import bisect_left, bisect_right\n\nsys.setrecursionlimit(10**7)\n\n\ndef func_4():\n return sys.stdin.readline()[:-1]\n\n\nvar_4 = 10**9 + 7\n\n\ndef func_1():\n return int(eval(func_4()))\n\n\ndef func_2():\n return list(map(int, func_4().split()))\n\n\ndef func_3(var_6, var_3):\n if var_6 <= 0:\n return [[] for _ in range(var_3)]\n elif var_3 == 1:\n return [func_1() for _ in range(var_6)]\n else:\n var_5 = [func_2() for _ in range(var_6)]\n return list(map(list, list(zip(*var_5))))\n\n\nfrom decimal import getcontext, Decimal\n\ngetcontext().prec = 28\nvar_1, var_2 = list(map(str, func_4().split()))\nvar_1 = int(var_1)\nvar_2 = Decimal(var_2)\nprint((int(var_1 * var_2)))\n```\n\n=== Code B (Modified) ===\n```python\nimport math\n\nvar_1, var_2 = input().split()\nvar_1 = int(var_1)\nvar_3 = int(var_2[0] + var_2[2] + var_2[3])\nprint((var_1 * var_3 // 100))\n```", "output": "FASTER 2.3373", "pair_id": "python_p02659_pair0016_forward", "problem_id": "p02659", "language": "python", "direction": "forward", "speedup_ratio": 5.0534} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_5 in range(10):\n for var_6 in range(10):\n for var_7 in range(10):\n var_3 = 10000 * var_5 + 1000 * var_6 + 100 * var_7 + 10 * var_6 + var_5\n if var_1 <= var_3 <= var_2:\n var_4 += 1\nprint(var_4)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = [0] * (var_2 + 1)\nfor var_3 in range(1, var_2 + 1):\n if str(var_3) == str(var_3)[::-1]:\n var_4[var_3] = var_4[var_3 - 1] + 1\n else:\n var_4[var_3] = var_4[var_3 - 1]\nprint((var_4[var_2] - var_4[var_1 - 1]))\n```", "output": "SLOWER 5.7678", "pair_id": "python_p03416_pair0068_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 54.4866} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\n\nvar_5 = sys.stdin.readline\nif __name__ == \"__main__\":\n var_1, var_3 = var_5().split()\n var_2 = int(var_1)\n var_4 = round(float(var_3) * 100)\n print((var_2 * var_4 // 100))\n```\n\n=== Code B (Modified) ===\n```python\ndef func_1():\n from sys import setrecursionlimit, stdin\n from os import environ\n from collections import defaultdict, deque, Counter\n from math import ceil, floor, gcd\n from itertools import accumulate, combinations, combinations_with_replacement\n\n setrecursionlimit(10**6)\n var_7 = (\n (lambda *var_11: print(*var_11))\n if \"TERM_PROGRAM\" in environ\n else lambda *var_12: 0\n )\n var_8 = lambda: stdin.readline().rstrip()\n var_3 = lambda: list(map(int, var_8().split()))\n var_1 = lambda: int(var_8())\n var_4 = 10**9 + 7\n var_2 = 10**9 + 10\n var_9, var_10 = var_8().split()\n var_5 = int(var_9)\n var_10 = var_10.split(\".\")\n var_6 = int(var_10[0]) * 100\n if len(var_10) == 2:\n var_6 += int(var_10[1])\n print(var_5 * var_6 // 100)\n\n\nfunc_1()\n```", "output": "SLOWER 1.8866", "pair_id": "python_p02659_pair0017_reversed", "problem_id": "p02659", "language": "python", "direction": "reversed", "speedup_ratio": 3.6977} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport copy\n\nvar_8 = int(eval(input()))\nvar_10 = set([var_6 for var_6 in range(1, 10**5)])\nvar_5 = []\nvar_11 = {}\nvar_9 = []\nfor var_6 in range(var_8 - 1):\n var_1, var_2 = list(map(int, input().split(\" \")))\n var_5.append([var_1, var_2])\n var_11.setdefault(var_1, []).append(var_2)\n var_9.append([])\nvar_9.append([])\nvar_9.append([])\nvar_7 = 0\nfor var_12 in range(1, var_8 + 1):\n var_14 = var_11.get(var_12, [])\n var_3 = 1\n for var_13 in var_14:\n if var_3 in var_9[var_12]:\n var_3 += 1\n else:\n pass\n var_9[var_13].append(var_3)\n if var_3 >= var_7:\n var_7 = var_3\n var_3 += 1\nprint(var_7)\nfor var_4 in var_5:\n print((var_9[var_4[1]][0]))\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\n\n\ndef func_1():\n var_8 = int(sys.stdin.readline().rstrip())\n var_7 = list(map(int, sys.stdin.read().split()))\n var_2 = list(zip(var_7, var_7))\n var_6 = [[] for _ in range(var_8 + 1)]\n for var_1, var_3 in var_2:\n var_6[var_1].append(var_3)\n var_6[var_3].append(var_1)\n var_13 = 1\n var_11 = [0] * (var_8 + 1)\n var_10 = []\n var_14 = [var_13]\n while var_14:\n var_15 = var_14.pop()\n var_10.append(var_15)\n for var_16 in var_6[var_15]:\n if var_16 == var_11[var_15]:\n continue\n var_11[var_16] = var_15\n var_14.append(var_16)\n var_5 = [-1] * (var_8 + 1)\n for var_15 in var_10:\n var_9 = var_5[var_15]\n var_4 = 1\n for var_16 in var_6[var_15]:\n if var_16 == var_11[var_15]:\n continue\n if var_4 == var_9:\n var_4 += 1\n var_5[var_16] = var_4\n var_4 += 1\n var_12 = []\n for var_1, var_3 in var_2:\n if var_11[var_1] == var_3:\n var_12.append(var_5[var_1])\n else:\n var_12.append(var_5[var_3])\n print((max(var_12)))\n print((\"\\n\".join(map(str, var_12))))\n\n\nif __name__ == \"__main__\":\n func_1()\n```", "output": "FASTER 4.1752", "pair_id": "python_p02850_pair0010_forward", "problem_id": "p02850", "language": "python", "direction": "forward", "speedup_ratio": 18.0665} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_3 = list(map(int, input().split()))\nvar_2 = 0\nfor var_5 in range(var_3 + 1)[var_1:]:\n if len(str(var_5)) % 2 == 0:\n var_6 = list(str(var_5))[: len(str(var_5)) // 2]\n var_7 = list(reversed(list(str(var_5))[len(str(var_5)) // 2 :]))\n if var_6 == var_7:\n var_2 += 1\n else:\n var_8 = list(str(var_5))[: len(str(var_5)) // 2 + 1]\n var_4 = list(reversed(list(str(var_5))[len(str(var_5)) // 2 :]))\n if var_8 == var_4:\n var_2 += 1\nprint(var_2)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n if str(var_4) == \"\".join(reversed(str(var_4))):\n var_3 += 1\nprint(var_3)\n```", "output": "FASTER 1.3983", "pair_id": "python_p03416_pair0018_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 2.6359} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_6 = int(eval(input()))\nimport sys\n\nsys.setrecursionlimit(10**6)\nvar_11 = [[] for _ in range(var_6)]\nfor var_4 in range(var_6 - 1):\n var_1, var_2 = list(map(int, input().split()))\n var_11[var_1 - 1].append((var_2 - 1, var_4))\n var_11[var_2 - 1].append((var_1 - 1, var_4))\nvar_5 = [0] * (var_6 - 1)\n\n\ndef func_1(var_8, var_10, var_9):\n var_3 = 1\n for var_7, var_4 in var_11[var_8]:\n if var_7 == var_9:\n continue\n if var_3 == var_10:\n var_3 += 1\n var_5[var_4] = var_3\n func_1(var_7, var_3, var_8)\n var_3 += 1\n\n\nfunc_1(0, -1, -1)\nprint((max(var_5)))\nfor var_4 in var_5:\n print(var_4)\n```\n\n=== Code B (Modified) ===\n```python\nimport copy\n\nvar_8 = int(eval(input()))\nvar_10 = set([var_6 for var_6 in range(1, 10**5)])\nvar_5 = []\nvar_11 = {}\nvar_9 = []\nfor var_6 in range(var_8 - 1):\n var_1, var_2 = list(map(int, input().split(\" \")))\n var_5.append([var_1, var_2])\n var_11.setdefault(var_1, []).append(var_2)\n var_9.append([])\nvar_9.append([])\nvar_9.append([])\nvar_7 = 0\nfor var_12 in range(1, var_8 + 1):\n var_14 = var_11.get(var_12, [])\n var_3 = 1\n for var_13 in var_14:\n if var_3 in var_9[var_12]:\n var_3 += 1\n else:\n pass\n var_9[var_13].append(var_3)\n if var_3 >= var_7:\n var_7 = var_3\n var_3 += 1\nprint(var_7)\nfor var_4 in var_5:\n print((var_9[var_4[1]][0]))\n```", "output": "SLOWER 4.64", "pair_id": "python_p02850_pair0011_reversed", "problem_id": "p02850", "language": "python", "direction": "reversed", "speedup_ratio": 24.934} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nfrom sys import stdin\n\n\ndef func_1():\n\n var_11 = stdin.readline\n var_2 = int(var_11())\n var_1 = []\n for var_6 in range(var_2):\n var_5 = int(\"\".join(var_11().strip().split(\" \")), 2)\n var_1.append(var_5)\n var_3 = []\n for var_6 in range(var_2):\n var_10 = list(map(int, var_11().split()))\n var_3.append(var_10)\n var_8 = float(\"-inf\")\n for var_9 in range(1, 1 << 10):\n var_12 = 0\n for var_7 in range(var_2):\n var_4 = bin(var_9 & var_1[var_7]).count(\"1\")\n var_12 += var_3[var_7][var_4]\n var_8 = max(var_12, var_8)\n print(var_8)\n\n\nif __name__ == \"__main__\":\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\n\nvar_8 = sys.stdin.readline\n\n\ndef func_1():\n var_2 = int(eval(var_8()))\n var_1 = []\n for _ in range(var_2):\n var_1.append(list(map(int, var_8().split())))\n var_3 = []\n for _ in range(var_2):\n var_3.append(list(map(int, var_8().split())))\n var_4 = -(10**7) * var_2\n for var_7 in range(1, 1 << 10):\n var_11 = 0\n for var_10, var_6 in enumerate(var_1):\n var_5 = 0\n for var_9 in range(10):\n if (var_7 >> var_9) & 1 & var_6[var_9]:\n var_5 += 1\n var_11 += var_3[var_10][var_5]\n var_4 = max(var_4, var_11)\n print(var_4)\n\n\nif __name__ == \"__main__\":\n func_1()\n```", "output": "SLOWER 1.9105", "pair_id": "python_p03503_pair0005_reversed", "problem_id": "p03503", "language": "python", "direction": "reversed", "speedup_ratio": 3.7593} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().rstrip().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = list(map(int, list(str(var_4))))\n if var_5[0] == var_5[4] and var_5[1] == var_5[3]:\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_4 = str(var_4)\n if var_4[0] == var_4[-1] and var_4[1] == var_4[-2]:\n var_3 += 1\nprint(var_3)\n```", "output": "FASTER 1.8667", "pair_id": "python_p03416_pair0069_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 3.6471} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\nfrom collections import Counter\n\n\ndef func_9():\n return sys.stdin.readline().strip()\n\n\ndef func_10(var_8, var_9, var_10):\n return [[var_10] * var_9 for var_13 in range(var_8)]\n\n\ndef func_11(var_8, var_9, var_10, var_11):\n return [[[var_11] * var_10 for var_14 in range(var_9)] for var_13 in range(var_8)]\n\n\ndef func_12(var_8, var_9, var_10, var_11, var_12):\n return [\n [[[var_12] * var_11 for var_14 in range(var_10)] for var_14 in range(var_9)]\n for var_13 in range(var_8)\n ]\n\n\ndef func_8(var_16, var_17=1):\n return int(-(-var_16 // var_17))\n\n\ndef func_1():\n return int(eval(func_9()))\n\n\ndef func_3():\n return list(map(int, func_9().split()))\n\n\ndef func_2(var_7=None):\n return list(func_3()) if var_7 is None else [func_1() for var_13 in range(var_7)]\n\n\ndef func_7():\n print(\"Yes\")\n\n\ndef func_5():\n print(\"No\")\n\n\ndef func_6():\n print(\"YES\")\n\n\ndef func_4():\n print(\"NO\")\n\n\nsys.setrecursionlimit(10**9)\nvar_3 = 10**18\nvar_6 = 10**9 + 7\nvar_7, var_5, var_4 = func_3()\nvar_1 = func_2()\nvar_2 = func_2()\nvar_15 = min(var_1) + min(var_2)\nfor _ in range(var_4):\n var_16, var_17, var_10 = func_3()\n var_16 -= 1\n var_17 -= 1\n var_15 = min(var_15, var_1[var_16] + var_2[var_17] - var_10)\nprint(var_15)\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\nfrom collections import Counter\n\n\ndef func_10():\n return sys.stdin.readline().strip()\n\n\ndef func_11(var_12, var_13, var_14):\n return [[var_14] * var_13 for var_17 in range(var_12)]\n\n\ndef func_12(var_12, var_13, var_14, var_15):\n return [[[var_15] * var_14 for var_18 in range(var_13)] for var_17 in range(var_12)]\n\n\ndef func_13(var_12, var_13, var_14, var_15, var_16):\n return [\n [[[var_16] * var_15 for var_18 in range(var_14)] for var_18 in range(var_13)]\n for var_17 in range(var_12)\n ]\n\n\ndef func_8(var_22, var_23=1):\n return int(-(-var_22 // var_23))\n\n\ndef func_1():\n return int(eval(func_10()))\n\n\ndef func_3():\n return list(map(int, func_10().split()))\n\n\ndef func_2(var_11=None):\n return list(func_3()) if var_11 is None else [func_1() for var_17 in range(var_11)]\n\n\ndef func_7():\n print(\"Yes\")\n\n\ndef func_5():\n print(\"No\")\n\n\ndef func_6():\n print(\"YES\")\n\n\ndef func_4():\n print(\"NO\")\n\n\nsys.setrecursionlimit(10**9)\nvar_5 = 10**18\nvar_10 = 10**9 + 7\n\n\ndef func_9(var_1, var_2):\n \"\"\"\"\"\"\n import numpy as np\n from numpy.fft import rfft, irfft\n\n var_8 = max(var_1)\n var_9 = max(var_2)\n var_3 = [0] * (var_8 + 1)\n var_4 = [0] * (var_9 + 1)\n for var_12 in var_1:\n var_3[var_12] += 1\n for var_13 in var_2:\n var_4[var_13] += 1\n\n var_6 = 1\n var_19 = 0\n while var_6 <= var_8 + var_9:\n var_19 += 1\n var_6 = 2**var_19\n\n var_21 = irfft(rfft(var_3, var_6) * rfft(var_4, var_6), var_6)\n\n var_21 = np.rint(var_21).astype(np.int64)\n return var_21\n\n\nvar_11, var_7, var_6 = func_3()\nvar_1 = func_2()\nvar_2 = func_2()\nvar_21 = list(func_9(var_1, var_2))\nvar_20 = var_5\nfor var_17, var_12 in enumerate(var_21):\n if var_12 != 0:\n var_20 = var_17\n break\nfor _ in range(var_6):\n var_22, var_23, var_14 = func_3()\n var_22 -= 1\n var_23 -= 1\n var_20 = min(var_20, var_1[var_22] + var_2[var_23] - var_14)\nprint(var_20)\n```", "output": "SLOWER 1.3665", "pair_id": "python_p02748_pair0003_reversed", "problem_id": "p02748", "language": "python", "direction": "reversed", "speedup_ratio": 2.5785} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = input().split()\nvar_1 = int(var_1)\nvar_2 = int(var_2.replace(\".\", \"\"))\nprint((var_1 * var_2 // 100))\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\nimport math\nfrom collections import defaultdict\nfrom bisect import bisect_left, bisect_right\n\nsys.setrecursionlimit(10**7)\n\n\ndef func_4():\n return sys.stdin.readline()[:-1]\n\n\nvar_4 = 10**9 + 7\n\n\ndef func_1():\n return int(eval(func_4()))\n\n\ndef func_2():\n return list(map(int, func_4().split()))\n\n\ndef func_3(var_6, var_3):\n if var_6 <= 0:\n return [[] for _ in range(var_3)]\n elif var_3 == 1:\n return [func_1() for _ in range(var_6)]\n else:\n var_5 = [func_2() for _ in range(var_6)]\n return list(map(list, list(zip(*var_5))))\n\n\nvar_1, var_2 = list(map(str, func_4().split()))\nvar_1 = int(var_1)\nvar_2 = 100 * int(var_2[0]) + 10 * int(var_2[2]) + int(var_2[3])\nprint((var_1 * var_2 // 100))\n```", "output": "SLOWER 2.5828", "pair_id": "python_p02659_pair0018_reversed", "problem_id": "p02659", "language": "python", "direction": "reversed", "speedup_ratio": 5.9911} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().strip().split(\" \")))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n if str(var_4) == str(var_4)[::-1]:\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = [\n var_3 for var_3 in map(str, list(range(var_1, var_2 + 1))) if var_3 == var_3[::-1]\n]\nprint((len(var_4)))\n```", "output": "FASTER 1.0058", "pair_id": "python_p03416_pair0070_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 2.0081} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_5 = int(eval(input()))\nvar_7 = list(map(int, input().split()))\nvar_8 = list(map(int, input().split()))\nvar_6 = [[0 for var_2 in range(6)] for var_3 in range(var_5 + 1)]\nvar_1 = abs(var_7[0] - var_8[0])\nvar_6[0][3] = var_6[0][0] = var_1\nvar_6[0][4] = var_6[0][1] = var_1**2\nvar_6[0][5] = var_6[0][2] = var_1**3\nvar_4 = var_1\nfor var_2 in range(1, var_5, 1):\n var_1 = abs(var_7[var_2] - var_8[var_2])\n var_6[var_2][0] = var_1\n var_6[var_2][1] = var_1**2\n var_6[var_2][2] = var_6[var_2][1] * var_1\n var_6[var_2][3] = var_6[var_2 - 1][3] + var_6[var_2][0]\n var_6[var_2][4] = var_6[var_2 - 1][4] + var_6[var_2][1]\n var_6[var_2][5] = var_6[var_2 - 1][5] + var_6[var_2][2]\n if var_1 > var_4:\n var_4 = var_1\nprint((var_6[var_5 - 1][3]))\nprint((var_6[var_5 - 1][4] ** (1 / 2)))\nprint((var_6[var_5 - 1][5] ** (1 / 3)))\nprint(var_4)\n```\n\n=== Code B (Modified) ===\n```python\nvar_3 = int(input())\nvar_6 = list(map(int, input().split()))\nvar_7 = list(map(int, input().split()))\nvar_1 = [abs(var_4 - var_5) for var_4, var_5 in zip(var_6, var_7)]\nvar_2 = lambda var_3: sum([var_4**var_3 for var_4 in var_1]) ** (1 / var_3)\nprint(var_2(1), var_2(2), var_2(3), max(var_1), sep=\"\\n\")\n```", "output": "FASTER 1.2213", "pair_id": "python_p02382_pair0001_forward", "problem_id": "p02382", "language": "python", "direction": "forward", "speedup_ratio": 2.3316} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_6 = str(var_4)\n var_5 = var_6[::-1]\n if var_6 == var_5:\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_4 = {}\nvar_5 = 0\nfor var_6 in range(10000, 100000):\n var_3 = list(str(var_6))\n if var_3 == list(reversed(var_3)):\n var_5 += 1\n var_4[var_6] = var_5\nvar_1, var_2 = list(map(int, input().split()))\nprint((var_4[var_2] - var_4[var_1 - 1] if var_1 > 10000 else var_4[var_2]))\n```", "output": "SLOWER 3.3232", "pair_id": "python_p03416_pair0071_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 10.0089} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_10 = []\nvar_10 = input().rstrip().split(\" \")\nvar_1 = int(var_10[0])\nvar_3 = int(var_10[1])\nvar_2 = 0\nvar_6 = var_1\nwhile var_6 <= var_3:\n var_4 = var_6 // 10000\n var_5 = (var_6 - var_4 * 10000) // 1000\n var_7 = var_6 // 100\n var_8 = (var_6 - var_7 * 100) // 10\n var_9 = var_6 % 10\n if (var_4 == var_9) and (var_5 == var_8):\n var_2 += 1\n var_6 += 1\nprint(var_2)\n```\n\n=== Code B (Modified) ===\n```python\ndef func_1():\n var_1, var_2 = list(map(int, input().rstrip().split()))\n var_3 = 0\n for var_4 in range(var_1, var_2 + 1):\n var_5 = str(var_4)\n if var_5 == var_5[::-1]:\n var_3 += 1\n print(var_3)\n\n\nif __name__ == \"__main__\":\n func_1()\n```", "output": "FASTER 1.555", "pair_id": "python_p03416_pair0072_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 2.9383} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\n\n\ndef func_1(var_5, var_6):\n var_4 = 0\n for var_3 in range(var_5, var_6 + 1):\n if str(var_3) == str(var_3)[::-1]:\n var_4 += 1\n return var_4\n\n\nprint((func_1(var_1, var_2)))\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = list(str(var_4))\n if var_5 == list(reversed(var_5)):\n var_3 += 1\nprint(var_3)\n```", "output": "SLOWER 1.5558", "pair_id": "python_p03416_pair0073_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 2.94} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_7 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_3 = True\n var_8 = str(var_4)\n var_6 = len(var_8)\n for var_5 in range(var_6 // 2 + 1):\n if var_8[var_5] != var_8[-var_5 - 1]:\n var_3 = False\n break\n if var_3:\n var_7 += 1\nprint(var_7)\n```\n\n=== Code B (Modified) ===\n```python\ndef func_1():\n var_1, var_2 = list(map(int, input().split()))\n var_3 = 0\n for var_4 in range(var_1, var_2 + 1):\n\n if (var_4 % 10) == (var_4 // 10000 % 10) and (var_4 // 10 % 10) == (\n var_4 // 1000 % 10\n ):\n var_3 += 1\n print(var_3)\n\n\nif __name__ == \"__main__\":\n func_1()\n```", "output": "FASTER 2.7891", "pair_id": "python_p03416_pair0074_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 6.9122} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\nimport math\nfrom collections import defaultdict\nfrom bisect import bisect_left, bisect_right\n\nsys.setrecursionlimit(10**7)\n\n\ndef func_4():\n return sys.stdin.readline()[:-1]\n\n\nvar_4 = 10**9 + 7\n\n\ndef func_1():\n return int(eval(func_4()))\n\n\ndef func_2():\n return list(map(int, func_4().split()))\n\n\ndef func_3(var_6, var_3):\n if var_6 <= 0:\n return [[] for _ in range(var_3)]\n elif var_3 == 1:\n return [func_1() for _ in range(var_6)]\n else:\n var_5 = [func_2() for _ in range(var_6)]\n return list(map(list, list(zip(*var_5))))\n\n\nfrom decimal import getcontext, Decimal\n\ngetcontext().prec = 28\nvar_1, var_2 = list(map(str, func_4().split()))\nvar_1 = int(var_1)\nvar_2 = Decimal(var_2)\nprint((int(var_1 * var_2)))\n```\n\n=== Code B (Modified) ===\n```python\nfrom decimal import Decimal\nimport math\n\nvar_1, var_2 = list(map(str, input().split()))\nvar_1 = int(var_1)\nvar_2 = Decimal(var_2)\nvar_3 = math.floor(var_1 * var_2)\nprint((int(var_3)))\n```", "output": "FASTER 1.9581", "pair_id": "python_p02659_pair0019_forward", "problem_id": "p02659", "language": "python", "direction": "forward", "speedup_ratio": 3.8855} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().rstrip().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = list(map(int, list(str(var_4))))\n if var_5[0] == var_5[4] and var_5[1] == var_5[3]:\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1 = list(map(int, input().split()))\nvar_2 = 0\nfor var_3 in range(var_1[0], var_1[1] + 1):\n var_4 = str(var_3)\n if var_4[0] == var_4[4] and var_4[1] == var_4[3]:\n var_2 += 1\nprint(var_2)\n```", "output": "FASTER 1.9718", "pair_id": "python_p03416_pair0052_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 3.9226} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n if list(str(var_4)) == list(reversed(str(var_4))):\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_5 in range(10):\n for var_6 in range(10):\n for var_7 in range(10):\n var_3 = 10000 * var_5 + 1000 * var_6 + 100 * var_7 + 10 * var_6 + var_5\n if var_1 <= var_3 <= var_2:\n var_4 += 1\nprint(var_4)\n```", "output": "FASTER 5.2259", "pair_id": "python_p03416_pair0075_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 37.4247} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\n\n\ndef func_1(var_5, var_6):\n var_4 = 0\n for var_3 in range(var_5, var_6 + 1):\n if str(var_3) == str(var_3)[::-1]:\n var_4 += 1\n return var_4\n\n\nprint((func_1(var_1, var_2)))\n```\n\n=== Code B (Modified) ===\n```python\nvar_10 = []\nvar_10 = input().rstrip().split(\" \")\nvar_1 = int(var_10[0])\nvar_3 = int(var_10[1])\nvar_2 = 0\nvar_6 = var_1\nwhile var_6 <= var_3:\n var_4 = var_6 // 10000\n var_5 = (var_6 - var_4 * 10000) // 1000\n var_7 = var_6 // 100\n var_8 = (var_6 - var_7 * 100) // 10\n var_9 = var_6 % 10\n if (var_4 == var_9) and (var_5 == var_8):\n var_2 += 1\n var_6 += 1\nprint(var_2)\n```", "output": "SLOWER 1.1326", "pair_id": "python_p03416_pair0076_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 2.1926} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\ndef func_1():\n var_1, var_2 = list(map(int, input().split()))\n var_3 = 0\n for var_4 in range(var_1, var_2 + 1):\n\n if (var_4 % 10) == (var_4 // 10000 % 10) and (var_4 // 10 % 10) == (\n var_4 // 1000 % 10\n ):\n var_3 += 1\n print(var_3)\n\n\nif __name__ == \"__main__\":\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_5 in range(10):\n for var_6 in range(10):\n for var_7 in range(10):\n var_3 = 10000 * var_5 + 1000 * var_6 + 100 * var_7 + 10 * var_6 + var_5\n if var_1 <= var_3 <= var_2:\n var_4 += 1\nprint(var_4)\n```", "output": "FASTER 2.1615", "pair_id": "python_p03416_pair0077_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 4.4738} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = [\n var_3 for var_3 in map(str, list(range(var_1, var_2 + 1))) if var_3 == var_3[::-1]\n]\nprint((len(var_4)))\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_5 in range(10):\n for var_6 in range(10):\n for var_7 in range(10):\n var_3 = 10000 * var_5 + 1000 * var_6 + 100 * var_7 + 10 * var_6 + var_5\n if var_1 <= var_3 <= var_2:\n var_4 += 1\nprint(var_4)\n```", "output": "FASTER 3.127", "pair_id": "python_p03416_pair0078_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 8.7361} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\nimport itertools\n\n\ndef func_2(var_4):\n return eval(\"0b\" + var_4)\n\n\ndef func_1():\n var_4 = int(sys.stdin.readline().rstrip())\n var_9 = [\n func_2(\"\".join(str(var_10) for var_10 in sys.stdin.readline().split()))\n for _ in range(var_4)\n ]\n var_8 = [\n [int(var_10) for var_10 in sys.stdin.readline().split()] for _ in range(var_4)\n ]\n var_3 = -(10**10)\n for var_6 in itertools.product(\"01\", repeat=10):\n var_6 = func_2(\"\".join(var_6))\n if var_6 == 0:\n continue\n var_7 = 0\n for var_2 in range(var_4):\n var_1 = var_9[var_2]\n var_5 = bin(var_1 & var_6).count(\"1\")\n var_7 += var_8[var_2][var_5]\n var_3 = max(var_3, var_7)\n print(var_3)\n\n\nif __name__ == \"__main__\":\n\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\n\nvar_7 = sys.stdin.readline\nfrom itertools import combinations\n\n\ndef func_3(var_10):\n for _ in range(var_10):\n yield list(map(int, var_7().split()))\n\n\ndef func_1(var_9, var_5, var_11):\n var_3 = len([0 for var_8 in var_9 if var_5[var_8] == 1])\n return var_11[var_3]\n\n\ndef func_2():\n var_10 = int(eval(var_7()))\n var_1 = list(func_3(var_10))\n var_2 = list(func_3(var_10))\n for var_6 in range(1, 11):\n for var_4 in combinations(list(range(10)), var_6):\n yield sum(\n func_1(var_4, var_5, var_11) for var_5, var_11 in zip(var_1, var_2)\n )\n\n\nprint((max(func_2())))\n```", "output": "FASTER 2.0211", "pair_id": "python_p03503_pair0009_forward", "problem_id": "p03503", "language": "python", "direction": "forward", "speedup_ratio": 4.0589} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_10 = []\nvar_10 = input().rstrip().split(\" \")\nvar_1 = int(var_10[0])\nvar_3 = int(var_10[1])\nvar_2 = 0\nvar_6 = var_1\nwhile var_6 <= var_3:\n var_4 = var_6 // 10000\n var_5 = (var_6 - var_4 * 10000) // 1000\n var_7 = var_6 // 100\n var_8 = (var_6 - var_7 * 100) // 10\n var_9 = var_6 % 10\n if (var_4 == var_9) and (var_5 == var_8):\n var_2 += 1\n var_6 += 1\nprint(var_2)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = [0] * (var_2 + 1)\nfor var_3 in range(1, var_2 + 1):\n if str(var_3) == str(var_3)[::-1]:\n var_4[var_3] = var_4[var_3 - 1] + 1\n else:\n var_4[var_3] = var_4[var_3 - 1]\nprint((var_4[var_2] - var_4[var_1 - 1]))\n```", "output": "SLOWER 1.1332", "pair_id": "python_p03416_pair0079_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 2.1935} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_2 = int(eval(input()))\nvar_1 = list(map(int, input().split()))\nvar_4 = 1\nfor var_3 in range(var_2):\n if var_1[var_3] % 2 == 0:\n var_4 *= 2\nprint((3**var_2 - var_4))\n```\n\n=== Code B (Modified) ===\n```python\ndef func_1():\n var_2 = int(input())\n var_1 = [int(var_6) for var_6 in input().split()]\n if var_2 == 1:\n return print(1 if var_1[0] % 2 == 0 else 2)\n var_3 = 0\n var_5 = (-1, 0, 1)\n from itertools import product\n\n for var_6 in product(range(3), repeat=var_2):\n var_4 = 1\n for var_7 in range(var_2):\n var_4 *= var_1[var_7] + var_5[var_6[var_7]]\n if var_4 % 2 == 0:\n var_3 += 1\n print(var_3)\n\n\nif __name__ == \"__main__\":\n func_1()\n```", "output": "SLOWER 8.5767", "pair_id": "python_p03568_pair0006_reversed", "problem_id": "p03568", "language": "python", "direction": "reversed", "speedup_ratio": 381.8046} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\n\nvar_8 = sys.stdin.readline\nvar_9 = int(eval(var_8()))\nvar_6 = []\nfor var_7 in range(var_9 - 1):\n var_1, var_3 = list(map(int, var_8().split()))\n var_6.append([var_1 - 1, var_3 - 1, var_7])\nvar_6.sort()\nvar_13 = [0] * (var_9)\nvar_2 = [0] * (var_9 - 1)\nvar_10 = 1\nvar_11 = 0\nfor var_5 in var_6:\n _from, var_12, var_7 = var_5\n if _from != var_11:\n var_10 = 1\n if var_13[_from] == var_10:\n var_10 += 1\n var_2[var_7] = var_10\n var_13[var_12] = var_10\n var_10 += 1\n var_11 = _from\nprint((max(var_2)))\nfor var_4 in var_2:\n print(var_4)\n```\n\n=== Code B (Modified) ===\n```python\nfrom collections import deque\n\n\ndef func_2(var_9, var_2, var_4):\n\n var_6 = {var_7: dict() for var_7 in range(var_9)}\n for var_7 in range(var_9 - 1):\n var_1, var_3 = var_2[var_7] - 1, var_4[var_7] - 1\n var_6[var_1][var_3] = -1\n var_6[var_3][var_1] = -1\n var_8 = max([len(var_6[var_1]) for var_1 in range(var_9)])\n var_14 = [-1] * var_9\n var_14[0] = var_8 - 1\n\n var_12 = deque([0])\n while len(var_12) > 0:\n var_10 = var_12.popleft()\n var_5 = var_14[var_10]\n for var_11 in list(var_6[var_10].keys()):\n if var_14[var_11] != -1:\n continue\n var_5 += 1\n var_5 %= var_8\n\n var_6[var_10][var_11] = var_5\n var_6[var_11][var_10] = var_5\n var_14[var_11] = var_5\n var_12.append(var_11)\n var_13 = [0] * (var_9 - 1)\n for var_7 in range(var_9 - 1):\n var_13[var_7] = var_6[var_2[var_7] - 1][var_4[var_7] - 1] + 1\n return var_8, var_13\n\n\ndef func_1():\n var_9 = int(eval(input()))\n var_2 = [0] * (var_9 - 1)\n var_4 = [0] * (var_9 - 1)\n for var_7 in range(var_9 - 1):\n var_1, var_3 = list(map(int, input().split()))\n var_2[var_7] = var_1\n var_4[var_7] = var_3\n var_8, var_13 = func_2(var_9, var_2, var_4)\n print(var_8)\n for var_7 in range(var_9 - 1):\n print((var_13[var_7]))\n\n\ndef func_3():\n print((func_2(3, [1, 2], [2, 3])))\n print((func_2(8, [1, 2, 2, 2, 4, 5, 6], [2, 3, 4, 5, 7, 6, 8])))\n\n\nif __name__ == \"__main__\":\n\n func_1()\n```", "output": "SLOWER 1.2025", "pair_id": "python_p02850_pair0012_reversed", "problem_id": "p02850", "language": "python", "direction": "reversed", "speedup_ratio": 2.3014} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\nimport numpy as np\n\nvar_5 = sys.stdin.readline\n\nvar_7 = int(eval(var_5()))\n\nvar_1 = [var_5().replace(\" \", \"\") for var_4 in range(var_7)]\n\nvar_8 = [list(map(int, var_5().split())) for var_4 in range(var_7)]\n\n\nvar_12 = -999999999999999\n\nfor var_4 in range(1, 1024):\n\n var_3 = format(var_4, \"010b\")\n\n var_10 = 0\n for var_2, var_9 in zip(var_1, var_8):\n\n var_11 = 0\n for var_6 in range(10):\n\n if var_2[var_6] == \"1\" and var_3[var_6] == \"1\":\n\n var_11 += 1\n\n var_10 += var_9[var_11]\n if var_10 > var_12:\n\n var_12 = var_10\nprint(var_12)\n```\n\n=== Code B (Modified) ===\n```python\nfrom sys import stdin\n\n\ndef func_1():\n\n var_11 = stdin.readline\n var_2 = int(var_11())\n var_1 = []\n for var_6 in range(var_2):\n var_5 = int(\"\".join(var_11().strip().split(\" \")), 2)\n var_1.append(var_5)\n var_3 = []\n for var_6 in range(var_2):\n var_10 = list(map(int, var_11().split()))\n var_3.append(var_10)\n var_8 = float(\"-inf\")\n for var_9 in range(1, 1 << 10):\n var_12 = 0\n for var_7 in range(var_2):\n var_4 = bin(var_9 & var_1[var_7]).count(\"1\")\n var_12 += var_3[var_7][var_4]\n var_8 = max(var_12, var_8)\n print(var_8)\n\n\nif __name__ == \"__main__\":\n func_1()\n```", "output": "FASTER 2.8805", "pair_id": "python_p03503_pair0010_forward", "problem_id": "p03503", "language": "python", "direction": "forward", "speedup_ratio": 7.3642} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\nfrom collections import Counter\n\n\ndef func_10():\n return sys.stdin.readline().strip()\n\n\ndef func_11(var_12, var_13, var_14):\n return [[var_14] * var_13 for var_17 in range(var_12)]\n\n\ndef func_12(var_12, var_13, var_14, var_15):\n return [[[var_15] * var_14 for var_18 in range(var_13)] for var_17 in range(var_12)]\n\n\ndef func_13(var_12, var_13, var_14, var_15, var_16):\n return [\n [[[var_16] * var_15 for var_18 in range(var_14)] for var_18 in range(var_13)]\n for var_17 in range(var_12)\n ]\n\n\ndef func_8(var_22, var_23=1):\n return int(-(-var_22 // var_23))\n\n\ndef func_1():\n return int(eval(func_10()))\n\n\ndef func_3():\n return list(map(int, func_10().split()))\n\n\ndef func_2(var_11=None):\n return list(func_3()) if var_11 is None else [func_1() for var_17 in range(var_11)]\n\n\ndef func_7():\n print(\"Yes\")\n\n\ndef func_5():\n print(\"No\")\n\n\ndef func_6():\n print(\"YES\")\n\n\ndef func_4():\n print(\"NO\")\n\n\nsys.setrecursionlimit(10**9)\nvar_5 = 10**18\nvar_10 = 10**9 + 7\n\n\ndef func_9(var_1, var_2):\n \"\"\"\"\"\"\n import numpy as np\n from numpy.fft import rfft, irfft\n\n var_8 = max(var_1)\n var_9 = max(var_2)\n var_3 = [0] * (var_8 + 1)\n var_4 = [0] * (var_9 + 1)\n for var_12 in var_1:\n var_3[var_12] += 1\n for var_13 in var_2:\n var_4[var_13] += 1\n\n var_6 = 1\n var_19 = 0\n while var_6 <= var_8 + var_9:\n var_19 += 1\n var_6 = 2**var_19\n\n var_21 = irfft(rfft(var_3, var_6) * rfft(var_4, var_6), var_6)\n\n var_21 = np.rint(var_21).astype(np.int64)\n return var_21\n\n\nvar_11, var_7, var_6 = func_3()\nvar_1 = func_2()\nvar_2 = func_2()\nvar_21 = list(func_9(var_1, var_2))\nvar_20 = var_5\nfor var_17, var_12 in enumerate(var_21):\n if var_12 != 0:\n var_20 = var_17\n break\nfor _ in range(var_6):\n var_22, var_23, var_14 = func_3()\n var_22 -= 1\n var_23 -= 1\n var_20 = min(var_20, var_1[var_22] + var_2[var_23] - var_14)\nprint(var_20)\n```\n\n=== Code B (Modified) ===\n```python\ndef func_1():\n return list(map(int, input().split()))\n\n\nimport numpy as np\n\nvar_1, var_2, var_3 = func_1()\nvar_4 = np.array(list(func_1()))\nvar_6 = np.array(list(func_1()))\nvar_9 = min(var_4) + min(var_6)\nvar_5 = float(\"inf\")\nfor var_8 in range(var_3):\n var_11, var_12, var_7 = func_1()\n var_10 = var_4[var_11 - 1] + var_6[var_12 - 1] - var_7\n var_5 = min(var_5, var_10)\nprint((min(var_5, var_9)))\n```", "output": "FASTER 2.9536", "pair_id": "python_p02748_pair0004_forward", "problem_id": "p02748", "language": "python", "direction": "forward", "speedup_ratio": 7.7468} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_2, var_1 = list(map(int, input().split()))\nvar_6 = {}\nvar_3 = {}\nfor var_4 in range(var_1):\n var_5, var_7 = input().split()\n var_5 = int(var_5)\n if not var_5 in var_6:\n var_6[var_5] = 0\n var_3[var_5] = 0\n if var_7 == \"WA\" and var_3[var_5] == 0:\n var_6[var_5] += 1\n elif var_7 == \"AC\" and var_3[var_5] == 0:\n var_3[var_5] += 1\nfor var_4 in var_6:\n if var_6[var_4] != 0 and var_3[var_4] == 0:\n var_6[var_4] = 0\nprint((sum(var_3.values()), sum(var_6.values())))\n```\n\n=== Code B (Modified) ===\n```python\nvar_7, var_6 = list(map(int, input().split()))\nvar_5 = [tuple(input().split()) for _ in range(var_6)]\nvar_9 = [[] for _ in range(var_7)]\nfor var_2 in range(var_6):\n var_9[int(var_5[var_2][0]) - 1].append(var_5[var_2][1])\nvar_1, var_8 = 0, 0\nfor var_3 in range(var_7):\n if \"AC\" in var_9[var_3]:\n var_1 += 1\n for var_4 in range(len(var_9[var_3])):\n if var_9[var_3][var_4] == \"WA\":\n var_8 += 1\n else:\n break\nprint((var_1, var_8))\n```", "output": "SLOWER 4.1714", "pair_id": "python_p02802_pair0002_reversed", "problem_id": "p02802", "language": "python", "direction": "reversed", "speedup_ratio": 18.0189} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\n\n\ndef func_1(var_5, var_6):\n var_4 = 0\n for var_3 in range(var_5, var_6 + 1):\n if str(var_3) == str(var_3)[::-1]:\n var_4 += 1\n return var_4\n\n\nprint((func_1(var_1, var_2)))\n```\n\n=== Code B (Modified) ===\n```python\nvar_4 = {}\nvar_5 = 0\nfor var_6 in range(10000, 100000):\n var_3 = list(str(var_6))\n if var_3 == list(reversed(var_3)):\n var_5 += 1\n var_4[var_6] = var_5\nvar_1, var_2 = list(map(int, input().split()))\nprint((var_4[var_2] - var_4[var_1 - 1] if var_1 > 10000 else var_4[var_2]))\n```", "output": "SLOWER 3.8972", "pair_id": "python_p03416_pair0080_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 14.8999} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\ndef func_1():\n var_1, var_2 = list(map(int, input().rstrip().split()))\n var_3 = 0\n for var_4 in range(var_1, var_2 + 1):\n var_5 = str(var_4)\n if var_5 == var_5[::-1]:\n var_3 += 1\n print(var_3)\n\n\nif __name__ == \"__main__\":\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nvar_4 = {}\nvar_5 = 0\nfor var_6 in range(10000, 100000):\n var_3 = list(str(var_6))\n if var_3 == list(reversed(var_3)):\n var_5 += 1\n var_4[var_6] = var_5\nvar_1, var_2 = list(map(int, input().split()))\nprint((var_4[var_2] - var_4[var_1 - 1] if var_1 > 10000 else var_4[var_2]))\n```", "output": "SLOWER 4.3196", "pair_id": "python_p03416_pair0061_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 19.9676} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\n\nvar_20 = sys.stdin.read\nvar_21 = sys.stdin.readline\nvar_22 = sys.stdin.readlines\nsys.setrecursionlimit(10**9)\nvar_2 = 1 << 60\nvar_5 = 1000000007\n\n\nvar_4 = 1000001\n\n\nclass Class_1:\n def __init__(self, var_13, var_19, var_12):\n self.l = var_13\n self.r = var_19\n self.idx = var_12\n\n\ndef func_4(var_12, var_24, var_10, var_15):\n while var_12 <= var_15:\n var_10[var_12] += var_24\n var_12 += var_12 & -var_12\n\n\ndef func_3(var_12, var_10, var_15):\n var_23 = 0\n while var_12:\n var_23 += var_10[var_12]\n var_12 -= var_12 & -var_12\n return var_23\n\n\ndef func_1(var_9, var_15, var_17, var_16):\n\n var_10 = [0] * (var_15 + 1)\n\n var_14 = [-1] * var_4\n\n var_8 = [0] * var_16\n var_18 = 0\n for var_11 in range(var_15):\n\n if var_14[var_9[var_11]] != -1:\n func_4(var_14[var_9[var_11]] + 1, -1, var_10, var_15)\n\n var_14[var_9[var_11]] = var_11\n func_4(var_11 + 1, 1, var_10, var_15)\n\n while var_18 < var_16 and var_17[var_18].r == var_11:\n var_8[var_17[var_18].idx] = func_3(\n var_17[var_18].r + 1, var_10, var_15\n ) - func_3(var_17[var_18].l, var_10, var_15)\n var_18 += 1\n\n for var_11 in range(var_16):\n print((var_8[var_11]))\n\n\ndef func_2():\n var_6, var_7 = list(map(int, var_21().split()))\n var_1 = list(map(int, var_21().split()))\n (*var_3,) = list(map(int, var_20().split()))\n var_17 = [0] * var_7\n for var_11, (var_13, var_19) in enumerate(zip(*[iter(var_3)] * 2)):\n var_17[var_11] = Class_1(var_13 - 1, var_19 - 1, var_11)\n var_17.sort(key=lambda var_25: var_25.r)\n func_1(var_1, var_6, var_17, var_7)\n return\n\n\nif __name__ == \"__main__\":\n func_2()\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\n\n\nclass Class_1:\n \"\"\"\"\"\"\n\n def __init__(self, var_1):\n self.__n = len(var_1)\n self.__node = [0] * (self.__n + 1)\n self.__data = [0] * (self.__n + 1)\n var_7 = [0] * (self.__n + 1)\n for var_11 in range(1, self.__n + 1):\n var_7[var_11] = var_7[var_11 - 1] + var_1[var_11 - 1]\n self.__data[var_11] = var_1[var_11 - 1]\n self.__node[var_11] = var_7[var_11] - var_7[var_11 - (var_11 & -var_11)]\n\n def func_1(self, var_11, var_22):\n self.__data[var_11] += var_22\n while var_11 <= self.__n:\n self.__node[var_11] += var_22\n var_11 += var_11 & -var_11\n\n def func_4(self, var_11):\n \"\"\"\"\"\"\n var_19 = 0\n while var_11 > 0:\n var_19 += self.__node[var_11]\n var_11 -= var_11 & -var_11\n return var_19\n\n def func_2(self, var_11, var_12):\n \"\"\"\"\"\"\n if var_11 == var_12:\n return self.__data[var_11]\n else:\n return self.sum(var_12) - self.sum(var_11 - 1)\n\n\ndef func_3():\n var_4, var_6 = map(int, input().split())\n var_3 = list(map(int, input().split()))\n var_5 = [[] for _ in range(var_4)]\n for var_11, var_9 in enumerate(var_3):\n var_5[var_9 - 1].append(var_11)\n var_18 = [0] * var_4\n for var_14 in var_5:\n if len(var_14):\n var_18[var_14.pop()] = 1\n var_2 = Class_1(var_18)\n var_16 = [[] for _ in range(var_4)]\n for var_11, var_20 in enumerate(sys.stdin.readlines()):\n var_13, var_17 = map(int, var_20.split())\n var_16[var_17 - 1].append((var_13 - 1, var_11))\n var_8 = [None] * var_6\n var_10 = var_4 - 1\n for var_17, var_15 in enumerate(reversed(var_16)):\n var_17 = (var_4 - 1) - var_17\n while var_15:\n var_13, var_11 = var_15.pop()\n while var_17 < var_10:\n var_9 = var_3[var_10] - 1\n var_14 = var_5[var_9]\n if len(var_14):\n var_2.add(var_14.pop() + 1, 1)\n var_10 -= 1\n var_21 = var_2.get(var_13 + 1, var_17 + 1)\n var_8[var_11] = var_21\n print(*var_8, sep=\"\\n\")\n\n\nif __name__ == \"__main__\":\n func_3()\n```", "output": "FASTER 1.8099", "pair_id": "python_p02599_pair0002_forward", "problem_id": "p02599", "language": "python", "direction": "forward", "speedup_ratio": 3.5063} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_4 = int(eval(input()))\nvar_2 = list(map(int, input().split()))\n\n\ndef func_1(var_1, var_8, var_3):\n if var_8 == var_4:\n var_9 = 1\n for var_5 in var_3:\n var_9 *= var_5\n return 1 if var_9 % 2 == 0 else 0\n var_6 = var_3.copy()\n var_6.append(var_1[var_8] - 1)\n var_5 = var_3.copy()\n var_5.append(var_1[var_8])\n var_7 = var_3.copy()\n var_7.append(var_1[var_8] + 1)\n return (\n func_1(var_1, var_8 + 1, var_6)\n + func_1(var_1, var_8 + 1, var_5)\n + func_1(var_1, var_8 + 1, var_7)\n )\n\n\nprint((func_1(var_2, 0, [])))\n```\n\n=== Code B (Modified) ===\n```python\nimport math\nimport string\n\n\ndef func_4():\n return list(map(int, input().split()))\n\n\ndef func_3(var_6, var_7):\n return math.factorial(var_6) // (\n math.factorial(var_6 - var_7) * math.factorial(var_7)\n )\n\n\ndef func_2(var_9):\n var_8 = []\n for var_5 in var_9:\n if not (var_5 in var_8):\n var_8.append(var_5)\n return len(var_9) != len(var_8)\n\n\ndef func_1(var_6):\n func_1 = []\n for var_4 in range(1, var_6 + 1):\n if var_6 % var_4 == 0:\n func_1.append(var_4)\n return func_1\n\n\nvar_2 = [-1, -1, -1, 0, 0, 1, 1, 1]\nvar_3 = [-1, 0, 1, -1, 1, -1, 0, 1]\nvar_6 = int(eval(input()))\nvar_1 = func_4()\nvar_10 = 1\nfor var_4 in range(len(var_1)):\n if var_1[var_4] % 2 == 0:\n var_10 *= 2\n else:\n var_10 *= 1\nprint((3 ** len(var_1) - var_10))\n```", "output": "FASTER 6.5932", "pair_id": "python_p03568_pair0011_forward", "problem_id": "p03568", "language": "python", "direction": "forward", "speedup_ratio": 96.5479} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = list(reversed(list(str(var_4))))\n if var_5 == list(str(var_4)):\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_6 = str(var_4)\n var_5 = var_6[::-1]\n if var_6 == var_5:\n var_3 += 1\nprint(var_3)\n```", "output": "FASTER 1.4065", "pair_id": "python_p03416_pair0081_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 2.651} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = str(var_4)\n if var_5 == var_5[::-1]:\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_3 in range(var_1, var_2 + 1):\n var_5 = list(str(var_3))\n var_6 = list(reversed(var_5))\n if var_5 == var_6:\n var_4 += 1\nprint(var_4)\n```", "output": "SLOWER 1.3131", "pair_id": "python_p03416_pair0082_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 2.4848} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\nimport numpy as np\n\nvar_5 = sys.stdin.readline\n\nvar_7 = int(eval(var_5()))\n\nvar_1 = [var_5().replace(\" \", \"\") for var_4 in range(var_7)]\n\nvar_8 = [list(map(int, var_5().split())) for var_4 in range(var_7)]\n\n\nvar_12 = -999999999999999\n\nfor var_4 in range(1, 1024):\n\n var_3 = format(var_4, \"010b\")\n\n var_10 = 0\n for var_2, var_9 in zip(var_1, var_8):\n\n var_11 = 0\n for var_6 in range(10):\n\n if var_2[var_6] == \"1\" and var_3[var_6] == \"1\":\n\n var_11 += 1\n\n var_10 += var_9[var_11]\n if var_10 > var_12:\n\n var_12 = var_10\nprint(var_12)\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\n\nvar_8 = sys.stdin.readline\n\n\ndef func_1():\n var_2 = int(eval(var_8()))\n var_1 = [int(var_8().replace(\" \", \"\"), 2) for _ in range(var_2)]\n var_3 = [list(map(int, var_8().split())) for _ in range(var_2)]\n var_4 = -(10**7) * var_2\n for var_7 in range(1, 1 << 10):\n var_10 = 0\n for var_9, var_6 in enumerate(var_1):\n var_5 = bin(var_7 & var_6).count(\"1\")\n var_10 += var_3[var_9][var_5]\n var_4 = max(var_4, var_10)\n print(var_4)\n\n\nif __name__ == \"__main__\":\n func_1()\n```", "output": "FASTER 2.7422", "pair_id": "python_p03503_pair0011_forward", "problem_id": "p03503", "language": "python", "direction": "forward", "speedup_ratio": 6.6909} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_6, var_7 = list(map(int, input().split()))\nvar_1 = [list(map(int, input().split())) for _ in range(var_6)]\nvar_1.sort()\nvar_3 = [(6007) * [0] for _ in range(var_6 + 1)]\nvar_3[0][0] = 0\nvar_2 = 0\nfor var_4 in range(var_6):\n for var_5 in range(6007):\n var_3[var_4 + 1][var_5] = max(var_3[var_4 + 1][var_5], var_3[var_4][var_5])\n if var_5 < var_7:\n var_3[var_4 + 1][var_5 + var_1[var_4][0]] = max(\n var_3[var_4][var_5] + var_1[var_4][1],\n var_3[var_4][var_5 + var_1[var_4][0]],\n )\n var_2 = max(var_2, var_3[var_4 + 1][var_5])\nprint(var_2)\n```\n\n=== Code B (Modified) ===\n```python\nimport bisect\nimport sys\n\nsys.setrecursionlimit(10**6)\nvar_16 = sys.stdout.write\nvar_7 = lambda *var_14: print(*var_14) if var_1 else 0\nvar_1 = True\n\n\ndef func_1(var_9=sys.stdin.readline):\n var_11 = lambda: var_9().rstrip()\n var_3 = lambda: list(map(int, var_11().split()))\n var_2 = lambda: int(var_11())\n var_4 = lambda var_17: [var_3() for _ in range(var_17)]\n var_13, var_15 = var_3()\n var_5 = var_4(var_13)\n var_5.sort()\n var_8 = [[0] * var_15 for _ in range(var_13 + 1)]\n for var_10 in range(1, var_13 + 1):\n for var_12 in range(1, var_15):\n if var_12 < var_5[var_10 - 1][0]:\n var_8[var_10][var_12] = var_8[var_10 - 1][var_12]\n else:\n var_8[var_10][var_12] = max(\n var_8[var_10 - 1][var_12],\n var_8[var_10 - 1][var_12 - var_5[var_10 - 1][0]]\n + var_5[var_10 - 1][1],\n )\n var_6 = 0\n for var_10 in range(var_13):\n var_6 = max(var_6, var_8[var_10][var_15 - 1] + var_5[var_10][1])\n print(var_6)\n\n\nif __name__ == \"__main__\":\n func_1()\n```", "output": "FASTER 6.1246", "pair_id": "python_p02863_pair0007_forward", "problem_id": "p02863", "language": "python", "direction": "forward", "speedup_ratio": 69.7734} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nfrom collections import Counter\n\nvar_4 = int(eval(input()))\nvar_1 = list(map(int, input().split()))\nvar_2 = Counter(var_1)\nvar_3 = list(var_2)\nif sum(var_1) == 0:\n print(\"Yes\")\nelif len(var_1) % 3 != 0:\n print(\"No\")\nelif len(var_2) > 3 or len(var_2) <= 1:\n print(\"No\")\nelif len(var_2) == 3:\n if (\n var_2[var_3[0]] == var_4 // 3\n and var_2[var_3[1]] == var_4 // 3\n and var_2[var_3[2]] == var_4 // 3\n ):\n if var_3[0] ^ var_3[1] ^ var_3[2] == 0:\n print(\"Yes\")\n else:\n print(\"No\")\n else:\n print(\"No\")\nelse:\n var_3.sort()\n if var_3[0] == 0 and var_2[var_3[0]] == var_4 // 3:\n print(\"Yes\")\n else:\n print(\"No\")\n```\n\n=== Code B (Modified) ===\n```python\nfrom functools import *\n\n_, var_1 = open(0)\nprint(\n (\n \"YNeos\"[\n var_2(lambda var_3, var_4: var_3 ^ var_4, list(map(int, var_1.split())))\n > 0 :: 2\n ]\n )\n)\n```", "output": "FASTER 1.3002", "pair_id": "python_p02975_pair0001_forward", "problem_id": "p02975", "language": "python", "direction": "forward", "speedup_ratio": 2.4627} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\n\nvar_5 = sys.stdin.readline\nif __name__ == \"__main__\":\n var_1, var_3 = var_5().split()\n var_2 = int(var_1)\n var_4 = round(float(var_3) * 100)\n print((var_2 * var_4 // 100))\n```\n\n=== Code B (Modified) ===\n```python\ndef func_1():\n from sys import setrecursionlimit, stdin\n from os import environ\n from collections import defaultdict, deque, Counter\n from math import ceil, floor, gcd\n from itertools import accumulate, combinations, combinations_with_replacement\n\n setrecursionlimit(10**6)\n var_7 = (\n (lambda *var_11: print(*var_11))\n if \"TERM_PROGRAM\" in environ\n else lambda *var_12: 0\n )\n var_8 = lambda: stdin.readline().rstrip()\n var_3 = lambda: list(map(int, var_8().split()))\n var_1 = lambda: int(var_8())\n var_4 = 10**9 + 7\n var_2 = 10**9 + 10\n var_9, var_10 = var_8().split()\n var_5 = int(var_9)\n var_6 = int(float(var_10) * 100 + 0.5)\n print(var_5 * var_6 // 100)\n\n\nfunc_1()\n```", "output": "SLOWER 1.7429", "pair_id": "python_p02659_pair0020_reversed", "problem_id": "p02659", "language": "python", "direction": "reversed", "speedup_ratio": 3.347} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\n\nvar_3 = sys.stdin.readline\nif __name__ == \"__main__\":\n var_1, var_2 = var_3().split()\n print((int(var_1) * round(float(var_2) * 100) // 100))\n```\n\n=== Code B (Modified) ===\n```python\ndef func_1():\n from sys import setrecursionlimit, stdin\n from os import environ\n from collections import defaultdict, deque, Counter\n from math import ceil, floor, gcd\n from itertools import accumulate, combinations, combinations_with_replacement\n\n setrecursionlimit(10**6)\n var_7 = (\n (lambda *var_11: print(*var_11))\n if \"TERM_PROGRAM\" in environ\n else lambda *var_12: 0\n )\n var_8 = lambda: stdin.readline().rstrip()\n var_3 = lambda: list(map(int, var_8().split()))\n var_1 = lambda: int(var_8())\n var_4 = 10**9 + 7\n var_2 = 10**9 + 10\n var_9, var_10 = var_8().split()\n var_5 = int(var_9)\n var_10 = var_10.split(\".\")\n var_6 = int(var_10[0]) * 100\n if len(var_10) == 2:\n var_6 += int(var_10[1])\n print(var_5 * var_6 // 100)\n\n\nfunc_1()\n```", "output": "SLOWER 2.1103", "pair_id": "python_p02659_pair0021_reversed", "problem_id": "p02659", "language": "python", "direction": "reversed", "speedup_ratio": 4.3177} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\nfrom operator import itemgetter\nfrom heapq import heapify, heappop, heappush\n\nvar_1 = int(10e15)\nvar_2 = -var_1\nvar_11 = 1000000007\nsys.setrecursionlimit(1000000)\n\n\ndef func_2():\n return list(map(int, input().split()))\n\n\ndef func_4():\n return input().split()\n\n\ndef func_1():\n return int(sys.stdin.readline())\n\n\ndef func_3():\n return eval(input())\n\n\nvar_3, var_4 = func_2()\nvar_5 = [func_2() for var_9 in range(var_3)]\nvar_5.sort(key=itemgetter(0))\n\nvar_8 = [[0] * (var_4 + 1 + 3000 + 1) for _ in range(var_3 + 1)]\nvar_6 = 0\nfor var_9 in range(var_3):\n for var_10 in range(var_4 + 1 + 3000 + 1):\n var_12, var_7 = var_5[var_9]\n if 0 <= var_10 - var_12 < var_4:\n var_8[var_9 + 1][var_10] = max(\n var_8[var_9][var_10], var_8[var_9][var_10 - var_12] + var_7\n )\n else:\n var_8[var_9 + 1][var_10] = var_8[var_9][var_10]\n var_6 = max(var_6, var_8[var_9 + 1][var_10])\nprint(var_6)\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\nfrom collections import deque\n\nvar_1 = int(10e10)\nvar_2 = -var_1\nvar_12 = 1000000007\nsys.setrecursionlimit(1000000)\n\n\ndef func_2():\n return list(map(int, input().split()))\n\n\ndef func_4():\n return input().split()\n\n\ndef func_1():\n return int(sys.stdin.readline())\n\n\ndef func_3():\n return eval(input())\n\n\nvar_3, var_4 = func_2()\nvar_6 = [func_2() for var_10 in range(var_3)]\nvar_6.sort()\nvar_7 = 0\nvar_9 = [[0] * var_4 for var_10 in range(var_3 + 1)]\nfor var_10 in range(1, var_3 + 1):\n var_5, var_8 = var_6[var_10 - 1]\n for var_11 in range(var_4):\n if 0 <= var_11 - var_5 < var_4:\n var_9[var_10][var_11] = max(\n var_9[var_10 - 1][var_11], var_9[var_10 - 1][var_11 - var_5] + var_8\n )\n else:\n var_9[var_10][var_11] = var_9[var_10 - 1][var_11]\n else:\n var_7 = max(var_7, var_9[var_10 - 1][-1] + var_8)\nprint(var_7)\n```", "output": "FASTER 4.73", "pair_id": "python_p02863_pair0019_forward", "problem_id": "p02863", "language": "python", "direction": "forward", "speedup_ratio": 26.5378} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nfrom collections import deque\n\nvar_9 = deque()\nvar_11 = deque()\nvar_4 = int(eval(input()))\nvar_12 = [[] for var_13 in range(var_4 + 1)]\nvar_2 = []\nfor _ in range(var_4 - 1):\n var_5, var_6 = list(map(int, input().split()))\n var_12[var_5].append(var_6)\n var_12[var_6].append(var_5)\n var_2.append((var_5, var_6))\n\nvar_3 = 0\nvar_9.append(1)\nvar_17 = [False for var_13 in range(var_4 + 1)]\nvar_8 = [-1 for var_13 in range(var_4 + 1)]\nvar_17[1] = True\nvar_8[1] = -1\nvar_10 = {}\nwhile var_9:\n while var_9:\n var_18 = var_9.popleft()\n var_15 = var_8[var_18]\n var_7 = 1\n for var_14 in var_12[var_18]:\n if var_17[var_14] == False:\n var_17[var_14] = True\n var_11.append(var_14)\n if var_7 != var_15:\n var_8[var_14] = var_7\n var_10[(var_18, var_14)] = var_7\n elif var_7 == var_15:\n var_7 += 1\n var_8[var_14] = var_7\n var_10[(var_18, var_14)] = var_7\n var_7 += 1\n if var_11:\n var_9 = var_11\n var_11 = deque()\nvar_1 = max(var_8)\nprint(var_1)\nfor var_16 in var_2:\n var_5, var_6 = var_16\n if (var_5, var_6) in list(var_10.keys()):\n print((var_10[var_16]))\n else:\n print((var_10[(var_6, var_5)]))\n```\n\n=== Code B (Modified) ===\n```python\nimport copy\n\nvar_8 = int(eval(input()))\nvar_10 = set([var_6 for var_6 in range(1, 10**5)])\nvar_5 = []\nvar_11 = {}\nvar_9 = []\nfor var_6 in range(var_8 - 1):\n var_1, var_2 = list(map(int, input().split(\" \")))\n var_5.append([var_1, var_2])\n var_11.setdefault(var_1, []).append(var_2)\n var_9.append([])\nvar_9.append([])\nvar_9.append([])\nvar_7 = 0\nfor var_12 in range(1, var_8 + 1):\n var_14 = var_11.get(var_12, [])\n var_3 = 1\n for var_13 in var_14:\n if var_3 in var_9[var_12]:\n var_3 += 1\n else:\n pass\n var_9[var_13].append(var_3)\n if var_3 >= var_7:\n var_7 = var_3\n var_3 += 1\nprint(var_7)\nfor var_4 in var_5:\n print((var_9[var_4[1]][0]))\n```", "output": "SLOWER 3.8829", "pair_id": "python_p02850_pair0008_reversed", "problem_id": "p02850", "language": "python", "direction": "reversed", "speedup_ratio": 14.7526} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_4 = str(var_4)\n if var_4[0] == var_4[-1] and var_4[1] == var_4[-2]:\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\n\n\ndef func_1(var_5):\n var_4 = 0\n for var_3 in range(1, var_5 + 1):\n if str(var_3) == str(var_3)[::-1]:\n var_4 += 1\n return var_4\n\n\nprint((func_1(var_2) - func_1(var_1 - 1)))\n```", "output": "SLOWER 1.7743", "pair_id": "python_p03416_pair0083_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 3.4208} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport copy\nimport random\nimport bisect\nimport fractions\nimport math\nimport sys\nimport collections\nfrom decimal import Decimal\n\nvar_5 = 10**9 + 7\nsys.setrecursionlimit(var_5)\nvar_3 = collections.deque()\n\n\ndef func_1():\n return list(map(int, sys.stdin.readline().split()))\n\n\nvar_1 = int(eval(input()))\nvar_6 = [0 for var_4 in range(var_1)]\nfor var_4 in range(var_1):\n var_6[var_4] = int(eval(input()))\nvar_6.sort()\nvar_2 = sum(var_6)\nvar_2 -= var_6[-1] // 2\nprint(var_2)\n```\n\n=== Code B (Modified) ===\n```python\nvar_2 = int(eval(input()))\nvar_3 = [int(eval(input())) for var_1 in range(var_2)]\nprint((sum(var_3) - max(var_3) // 2))\n```", "output": "FASTER 1.0159", "pair_id": "python_p03207_pair0002_forward", "problem_id": "p03207", "language": "python", "direction": "forward", "speedup_ratio": 2.0221} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_6 in range(var_1, var_2 + 1):\n var_3 = str(var_6)\n var_5 = True\n for var_7 in range(len(var_3) // 2):\n if var_3[var_7] != var_3[-var_7 - 1] and var_5:\n var_5 = not var_5\n if var_5:\n var_4 += 1\nprint(var_4)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1 = list(map(int, input().split()))\nvar_2 = 0\nfor var_3 in range(var_1[0], var_1[1] + 1):\n var_4 = str(var_3)\n if var_4[0] == var_4[4] and var_4[1] == var_4[3]:\n var_2 += 1\nprint(var_2)\n```", "output": "FASTER 1.7488", "pair_id": "python_p03416_pair0084_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 3.3607} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_3 in range(var_1, var_2 + 1):\n var_5 = list(str(var_3))\n var_6 = list(reversed(var_5))\n if var_5 == var_6:\n var_4 += 1\nprint(var_4)\n```\n\n=== Code B (Modified) ===\n```python\nfrom sys import stdin\n\nvar_6 = lambda: list(map(int, stdin.readline().split()))\nvar_5 = lambda: list(map(int, stdin.readline().split()))\nvar_1, var_3 = var_6()\nvar_2 = 0\nfor var_4 in range(var_1, var_3 + 1):\n var_7 = str(var_4)\n if var_7 == var_7[::-1]:\n var_2 += 1\nprint(var_2)\n```", "output": "FASTER 1.2902", "pair_id": "python_p03416_pair0085_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 2.4457} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\n\nvar_7 = sys.stdin.readline\nfrom itertools import combinations\n\n\ndef func_3(var_10):\n for _ in range(var_10):\n yield list(map(int, var_7().split()))\n\n\ndef func_1(var_9, var_5, var_11):\n var_3 = len([0 for var_8 in var_9 if var_5[var_8] == 1])\n return var_11[var_3]\n\n\ndef func_2():\n var_10 = int(eval(var_7()))\n var_1 = list(func_3(var_10))\n var_2 = list(func_3(var_10))\n for var_6 in range(1, 11):\n for var_4 in combinations(list(range(10)), var_6):\n yield sum(\n func_1(var_4, var_5, var_11) for var_5, var_11 in zip(var_1, var_2)\n )\n\n\nprint((max(func_2())))\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\nimport numpy as np\n\nvar_6 = int(eval(input()))\n\nvar_1 = [input().replace(\" \", \"\") for var_4 in range(var_6)]\n\nvar_7 = [list(map(int, input().split())) for var_4 in range(var_6)]\nvar_11 = -999999999999999\nfor var_4 in range(1, 1024):\n var_3 = format(var_4, \"010b\")\n var_9 = 0\n for var_2, var_8 in zip(var_1, var_7):\n var_10 = 0\n for var_5 in range(10):\n if var_2[var_5] == \"1\" and var_3[var_5] == \"1\":\n var_10 += 1\n var_9 += var_8[var_10]\n if var_9 > var_11:\n if var_9 == 0:\n print((str(var_4)))\n break\n var_11 = var_9\nprint(var_11)\n```", "output": "SLOWER 1.1194", "pair_id": "python_p03503_pair0012_reversed", "problem_id": "p03503", "language": "python", "direction": "reversed", "speedup_ratio": 2.1726} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_4 = str(var_4)\n if var_4 == var_4[::-1]:\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\ndef func_1():\n var_1, var_2 = list(map(int, input().split()))\n var_3 = 0\n for var_4 in range(var_1, var_2 + 1):\n\n if (var_4 % 10) == (var_4 // 10000 % 10) and (var_4 // 10 % 10) == (\n var_4 // 1000 % 10\n ):\n var_3 += 1\n print(var_3)\n\n\nif __name__ == \"__main__\":\n func_1()\n```", "output": "FASTER 1.8111", "pair_id": "python_p03416_pair0086_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 3.509} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\n\nvar_10 = sys.stdin.readline\nvar_4 = int(eval(var_10()))\nvar_9 = [[] for _ in range(var_4)]\nvar_3 = []\nfor _ in range(var_4 - 1):\n var_5, var_6 = list(map(int, var_10().split()))\n var_9[var_5 - 1].append(var_6 - 1)\n var_9[var_6 - 1].append(var_5 - 1)\n var_3.append((var_5 - 1, var_6 - 1))\nvar_1 = 0\nfor var_11 in range(var_4):\n var_1 = max(var_1, len(var_9[var_11]))\nvar_2 = dict()\nvar_8 = [-1] * var_4\nvar_14 = [0]\nvar_8[0] = var_1 + 1\nwhile var_14:\n var_15 = []\n for var_13 in var_14:\n var_7 = var_8[var_13]\n var_16 = 0\n for var_12 in var_9[var_13]:\n if var_8[var_12] == -1:\n if var_16 == var_7:\n var_16 += 1\n var_8[var_12] = var_16\n var_2[(var_13, var_12)] = var_16\n var_2[(var_12, var_13)] = var_16\n var_16 += 1\n var_15.append(var_12)\n var_14 = var_15\nprint(var_1)\nfor var_5, var_6 in var_3:\n print((var_2[(var_5, var_6)] + 1))\n```\n\n=== Code B (Modified) ===\n```python\nimport copy\n\nvar_8 = int(eval(input()))\nvar_10 = set([var_6 for var_6 in range(1, 10**5)])\nvar_5 = []\nvar_11 = {}\nvar_9 = []\nfor var_6 in range(var_8 - 1):\n var_1, var_2 = list(map(int, input().split(\" \")))\n var_5.append([var_1, var_2])\n var_11.setdefault(var_1, []).append(var_2)\n var_9.append([])\nvar_9.append([])\nvar_9.append([])\nvar_7 = 0\nfor var_12 in range(1, var_8 + 1):\n var_14 = var_11.get(var_12, [])\n var_3 = 1\n for var_13 in var_14:\n if var_3 in var_9[var_12]:\n var_3 += 1\n else:\n pass\n var_9[var_13].append(var_3)\n if var_3 >= var_7:\n var_7 = var_3\n var_3 += 1\nprint(var_7)\nfor var_4 in var_5:\n print((var_9[var_4[1]][0]))\n```", "output": "SLOWER 4.2291", "pair_id": "python_p02850_pair0013_reversed", "problem_id": "p02850", "language": "python", "direction": "reversed", "speedup_ratio": 18.7534} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nfrom sys import stdin\n\n\ndef func_1():\n\n var_9 = stdin.readline\n var_8, var_10 = list(map(int, var_9().split()))\n var_7 = [list(map(int, var_9().split())) for _ in range(var_8)]\n var_7.sort()\n var_1 = [0] * var_8\n var_2 = [0] * var_8\n for var_4 in range(var_8):\n var_1[var_4], var_2[var_4] = var_7[var_4][0], var_7[var_4][1]\n\n var_5 = -(10**9)\n var_3 = [[var_5] * (var_10 + 1) for _ in range(var_8 + 1)]\n var_3[0][0] = 0\n for var_4 in range(var_8):\n for var_6 in range(var_10 + 1):\n\n if var_6 != var_10:\n var_3[var_4 + 1][min(var_10, var_6 + var_1[var_4])] = max(\n var_3[var_4 + 1][min(var_10, var_6 + var_1[var_4])],\n var_3[var_4][var_6] + var_2[var_4],\n )\n\n var_3[var_4 + 1][var_6] = max(var_3[var_4 + 1][var_6], var_3[var_4][var_6])\n print((max(var_3[var_8])))\n\n\nif __name__ == \"__main__\":\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\nfrom operator import itemgetter\nfrom heapq import heapify, heappop, heappush\n\nvar_1 = int(10e15)\nvar_2 = -var_1\nvar_11 = 1000000007\nsys.setrecursionlimit(1000000)\n\n\ndef func_2():\n return list(map(int, input().split()))\n\n\ndef func_4():\n return input().split()\n\n\ndef func_1():\n return int(sys.stdin.readline())\n\n\ndef func_3():\n return eval(input())\n\n\nvar_3, var_4 = func_2()\nvar_5 = [func_2() for var_9 in range(var_3)]\nvar_5.sort(key=itemgetter(0))\n\nvar_8 = [[0] * (var_4 + 1 + 3000 + 1) for _ in range(var_3 + 1)]\nvar_6 = 0\nfor var_9 in range(var_3):\n for var_10 in range(var_4 + 1 + 3000 + 1):\n var_12, var_7 = var_5[var_9]\n if 0 <= var_10 - var_12 < var_4:\n var_8[var_9 + 1][var_10] = max(\n var_8[var_9][var_10], var_8[var_9][var_10 - var_12] + var_7\n )\n else:\n var_8[var_9 + 1][var_10] = var_8[var_9][var_10]\n var_6 = max(var_6, var_8[var_9 + 1][var_10])\nprint(var_6)\n```", "output": "SLOWER 4.9179", "pair_id": "python_p02863_pair0020_reversed", "problem_id": "p02863", "language": "python", "direction": "reversed", "speedup_ratio": 30.2293} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\ndef func_1():\n var_2, var_3, *var_1 = list(map(int, open(0).read().split()))\n var_4 = [0] * (var_3 + max(var_1[::2]))\n for var_7, var_6 in sorted(zip(*[iter(var_1)] * 2)):\n for var_5 in reversed(list(range(var_3))):\n var_4[var_5 + var_7] = max(var_4[var_5 + var_7], var_4[var_5] + var_6)\n print((max(var_4)))\n\n\nfunc_1()\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_6 = sorted([list(map(int, input().split())) for var_5 in range(var_1)])\n\nvar_4 = [[0] * (var_2 + 1) for var_5 in range(var_1 + 1)]\n\nfor var_5 in range(var_1):\n var_9, var_8 = var_6[var_5]\n for var_7 in range(var_2 + 1):\n if var_7 + var_9 <= var_2:\n var_4[var_5 + 1][var_7 + var_9] = max(\n var_4[var_5 + 1][var_7 + var_9], var_4[var_5][var_7] + var_8\n )\n var_4[var_5 + 1][var_7] = max(var_4[var_5][var_7], var_4[var_5 + 1][var_7])\nvar_3 = 0\nfor var_5, (var_9, var_8) in enumerate(var_6):\n for var_7 in range(var_2):\n var_3 = max(var_3, var_4[var_5][var_7] + var_8)\nprint(var_3)\n```", "output": "SLOWER 2.0608", "pair_id": "python_p02863_pair0021_reversed", "problem_id": "p02863", "language": "python", "direction": "reversed", "speedup_ratio": 4.1721} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_4 = str(var_4)\n if var_4[0] == var_4[-1] and var_4[1] == var_4[-2]:\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_5 in range(10):\n for var_6 in range(10):\n for var_7 in range(10):\n var_3 = 10000 * var_5 + 1000 * var_6 + 100 * var_7 + 10 * var_6 + var_5\n if var_1 <= var_3 <= var_2:\n var_4 += 1\nprint(var_4)\n```", "output": "FASTER 3.6418", "pair_id": "python_p03416_pair0087_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 12.4826} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_6 = input()[::-1]\nvar_4 = len(var_6)\nvar_2 = [0] * 2019\nvar_2[0] = 1\nvar_7 = 1\nvar_5 = 0\nvar_1 = 0\nfor var_3 in range(var_4):\n var_5 = (var_5 + int(var_6[var_3]) * var_7) % 2019\n var_7 = var_7 * 10 % 2019\n var_2[var_5] += 1\nfor var_3 in var_2:\n var_1 += var_3 * (var_3 - 1) // 2\nprint(var_1)\n```\n\n=== Code B (Modified) ===\n```python\nfrom collections import Counter\n\nvar_1 = input()[::-1]\nvar_5 = [0]\nvar_4 = 0\nvar_6 = 2019\nfor var_7 in var_1:\n var_8 = int(var_7) * pow(10, var_4, var_6) % var_6\n var_8 = var_5[-1] + var_8\n var_5.append(var_8 % var_6)\n var_4 += 1\nvar_3 = Counter(var_5)\nvar_2 = sum(var_9 * (var_9 - 1) // 2 for var_9 in list(var_3.values()))\nprint(var_2)\n```", "output": "FASTER 1.9664", "pair_id": "python_p02702_pair0008_forward", "problem_id": "p02702", "language": "python", "direction": "forward", "speedup_ratio": 3.908} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n if str(var_4) == \"\".join(reversed(str(var_4))):\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\ndef func_1():\n var_1, var_2 = list(map(int, input().rstrip().split()))\n var_3 = 0\n for var_4 in range(var_1, var_2 + 1):\n var_5 = str(var_4)\n if var_5 == var_5[::-1]:\n var_3 += 1\n print(var_3)\n\n\nif __name__ == \"__main__\":\n func_1()\n```", "output": "FASTER 1.8222", "pair_id": "python_p03416_pair0088_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 3.5363} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = str(var_4)\n if var_5 == var_5[::-1]:\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_6 in range(var_1, var_2 + 1):\n var_3 = str(var_6)\n var_5 = True\n for var_7 in range(len(var_3) // 2):\n if var_3[var_7] != var_3[-var_7 - 1] and var_5:\n var_5 = not var_5\n if var_5:\n var_4 += 1\nprint(var_4)\n```", "output": "SLOWER 1.4644", "pair_id": "python_p03416_pair0089_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 2.7595} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().strip().split(\" \")))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n if str(var_4) == str(var_4)[::-1]:\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().rstrip().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = list(map(int, list(str(var_4))))\n if var_5[0] == var_5[4] and var_5[1] == var_5[3]:\n var_3 += 1\nprint(var_3)\n```", "output": "SLOWER 1.3757", "pair_id": "python_p03416_pair0090_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 2.595} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\nfrom operator import itemgetter\nfrom heapq import heapify, heappop, heappush\n\nvar_1 = int(10e15)\nvar_2 = -var_1\nvar_11 = 1000000007\nsys.setrecursionlimit(1000000)\n\n\ndef func_2():\n return list(map(int, input().split()))\n\n\ndef func_4():\n return input().split()\n\n\ndef func_1():\n return int(sys.stdin.readline())\n\n\ndef func_3():\n return eval(input())\n\n\nvar_3, var_4 = func_2()\nvar_5 = [func_2() for var_9 in range(var_3)]\nvar_5.sort(key=itemgetter(0))\n\nvar_8 = [[0] * (var_4 + 1 + 3000 + 1) for _ in range(var_3 + 1)]\nvar_6 = 0\nfor var_9 in range(var_3):\n for var_10 in range(var_4 + 1 + 3000 + 1):\n var_12, var_7 = var_5[var_9]\n if 0 <= var_10 - var_12 < var_4:\n var_8[var_9 + 1][var_10] = max(\n var_8[var_9][var_10], var_8[var_9][var_10 - var_12] + var_7\n )\n else:\n var_8[var_9 + 1][var_10] = var_8[var_9][var_10]\n var_6 = max(var_6, var_8[var_9 + 1][var_10])\nprint(var_6)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_6 = sorted([list(map(int, input().split())) for var_5 in range(var_1)])\n\nvar_4 = [[0] * (var_2 + 1) for var_5 in range(var_1 + 1)]\n\nfor var_5 in range(var_1):\n var_9, var_8 = var_6[var_5]\n for var_7 in range(var_2 + 1):\n if var_7 + var_9 <= var_2:\n var_4[var_5 + 1][var_7 + var_9] = max(\n var_4[var_5 + 1][var_7 + var_9], var_4[var_5][var_7] + var_8\n )\n var_4[var_5 + 1][var_7] = max(var_4[var_5][var_7], var_4[var_5 + 1][var_7])\nvar_3 = 0\nfor var_5, (var_9, var_8) in enumerate(var_6):\n for var_7 in range(var_2):\n var_3 = max(var_3, var_4[var_5][var_7] + var_8)\nprint(var_3)\n```", "output": "FASTER 4.0536", "pair_id": "python_p02863_pair0018_forward", "problem_id": "p02863", "language": "python", "direction": "forward", "speedup_ratio": 16.6053} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_11 = int(eval(input()))\nvar_12 = {var_8: [] for var_8 in range(1, var_11 + 1)}\nvar_19 = [False for var_8 in range(var_11 + 1)]\nvar_16 = []\nfor _ in range(var_11 - 1):\n var_2, var_3 = list(map(int, input().split()))\n var_12[var_2].append(var_3)\n var_12[var_3].append(var_2)\n var_16.append((var_2, var_3))\nvar_9 = var_16[0][0]\nvar_19[var_9] = True\nvar_6 = []\nvar_7 = []\nvar_14 = {var_8: {} for var_8 in range(1, var_11 + 1)}\nvar_10 = [0 for var_8 in range(var_11 + 1)]\n\nvar_4 = 1\nfor var_5 in var_12[var_9]:\n var_19[var_5] = True\n var_14[var_9][var_5] = var_4\n var_14[var_5][var_9] = var_4\n var_10[var_5] = var_4\n var_4 += 1\n var_6.append(var_5)\nwhile var_6:\n for var_15 in var_6:\n var_13 = 1\n for var_5 in var_12[var_15]:\n if var_19[var_5] == False:\n var_19[var_5] = True\n if var_13 != var_10[var_15]:\n var_14[var_15][var_5] = var_13\n var_14[var_5][var_15] = var_13\n var_10[var_5] = var_13\n var_13 += 1\n var_7.append(var_5)\n else:\n var_13 += 1\n var_14[var_15][var_5] = var_13\n var_14[var_5][var_15] = var_13\n var_10[var_5] = var_13\n var_13 += 1\n var_7.append(var_5)\n if var_7:\n var_6 = var_7\n var_7 = []\n else:\n var_6 = []\n var_7 = []\nvar_1 = 0\nfor var_8 in range(1, var_11 + 1):\n var_1 = max(var_1, len(var_12[var_8]))\nprint(var_1)\nfor var_8 in range(var_11 - 1):\n var_17, var_18 = var_16[var_8][0], var_16[var_8][1]\n print((var_14[var_17][var_18]))\n```\n\n=== Code B (Modified) ===\n```python\nvar_6 = int(eval(input()))\nimport sys\n\nsys.setrecursionlimit(10**6)\nvar_11 = [[] for _ in range(var_6)]\nfor var_4 in range(var_6 - 1):\n var_1, var_2 = list(map(int, input().split()))\n var_11[var_1 - 1].append((var_2 - 1, var_4))\n var_11[var_2 - 1].append((var_1 - 1, var_4))\nvar_5 = [0] * (var_6 - 1)\n\n\ndef func_1(var_8, var_10, var_9):\n var_3 = 1\n for var_7, var_4 in var_11[var_8]:\n if var_7 == var_9:\n continue\n if var_3 == var_10:\n var_3 += 1\n var_5[var_4] = var_3\n func_1(var_7, var_3, var_8)\n var_3 += 1\n\n\nfunc_1(0, -1, -1)\nprint((max(var_5)))\nfor var_4 in var_5:\n print(var_4)\n```", "output": "FASTER 1.0322", "pair_id": "python_p02850_pair0014_forward", "problem_id": "p02850", "language": "python", "direction": "forward", "speedup_ratio": 2.0452} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().rstrip().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = list(map(int, list(str(var_4))))\n if var_5[0] == var_5[4] and var_5[1] == var_5[3]:\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\n\n\ndef func_1(var_5, var_6):\n var_4 = 0\n for var_3 in range(var_5, var_6 + 1):\n if str(var_3) == str(var_3)[::-1]:\n var_4 += 1\n return var_4\n\n\nprint((func_1(var_1, var_2)))\n```", "output": "FASTER 2.0067", "pair_id": "python_p03416_pair0091_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 4.0185} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport copy\n\nvar_8 = int(eval(input()))\nvar_10 = set([var_6 for var_6 in range(1, 10**5)])\nvar_5 = []\nvar_11 = {}\nvar_9 = []\nfor var_6 in range(var_8 - 1):\n var_1, var_2 = list(map(int, input().split(\" \")))\n var_5.append([var_1, var_2])\n var_11.setdefault(var_1, []).append(var_2)\n var_9.append([])\nvar_9.append([])\nvar_9.append([])\nvar_7 = 0\nfor var_12 in range(1, var_8 + 1):\n var_14 = var_11.get(var_12, [])\n var_3 = 1\n for var_13 in var_14:\n if var_3 in var_9[var_12]:\n var_3 += 1\n else:\n pass\n var_9[var_13].append(var_3)\n if var_3 >= var_7:\n var_7 = var_3\n var_3 += 1\nprint(var_7)\nfor var_4 in var_5:\n print((var_9[var_4[1]][0]))\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\n\nsys.setrecursionlimit(500000)\nvar_4 = int(eval(input()))\nvar_2 = [[] for _ in range(var_4 + 1)]\nfor var_9 in range(var_4 - 1):\n var_5, var_6 = list(map(int, input().split()))\n var_2[var_5].append((var_6, var_9))\n var_2[var_6].append((var_5, var_9))\nvar_3 = max(len(var_8) for var_8 in var_2)\nprint(var_3)\nvar_1 = [-1] * (var_4 - 1)\n\n\ndef func_1(var_14=1, var_11=0, var_12=-1):\n var_7 = 1\n for var_13, var_10 in var_2[var_14]:\n if var_13 != var_11:\n if var_7 == var_12:\n var_7 += 1\n var_1[var_10] = var_7\n\n func_1(var_13, var_14, var_7)\n var_7 += 1\n\n\nfunc_1()\nprint((\"\\n\".join(map(str, var_1))))\n```", "output": "FASTER 4.54", "pair_id": "python_p02850_pair0015_forward", "problem_id": "p02850", "language": "python", "direction": "forward", "speedup_ratio": 23.264} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nfrom sys import stdin\n\n\ndef func_1():\n\n var_11 = stdin.readline\n var_2 = int(var_11())\n var_1 = []\n for var_6 in range(var_2):\n var_5 = int(\"\".join(var_11().strip().split(\" \")), 2)\n var_1.append(var_5)\n var_3 = []\n for var_6 in range(var_2):\n var_10 = list(map(int, var_11().split()))\n var_3.append(var_10)\n var_8 = float(\"-inf\")\n for var_9 in range(1, 1 << 10):\n var_12 = 0\n for var_7 in range(var_2):\n var_4 = bin(var_9 & var_1[var_7]).count(\"1\")\n var_12 += var_3[var_7][var_4]\n var_8 = max(var_12, var_8)\n print(var_8)\n\n\nif __name__ == \"__main__\":\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\nimport itertools\n\n\ndef func_2(var_4):\n return eval(\"0b\" + var_4)\n\n\ndef func_1():\n var_4 = int(sys.stdin.readline().rstrip())\n var_9 = [\n func_2(\"\".join(str(var_10) for var_10 in sys.stdin.readline().split()))\n for _ in range(var_4)\n ]\n var_8 = [\n [int(var_10) for var_10 in sys.stdin.readline().split()] for _ in range(var_4)\n ]\n var_3 = -(10**10)\n for var_6 in itertools.product(\"01\", repeat=10):\n var_6 = func_2(\"\".join(var_6))\n if var_6 == 0:\n continue\n var_7 = 0\n for var_2 in range(var_4):\n var_1 = var_9[var_2]\n var_5 = bin(var_1 & var_6).count(\"1\")\n var_7 += var_8[var_2][var_5]\n var_3 = max(var_3, var_7)\n print(var_3)\n\n\nif __name__ == \"__main__\":\n\n func_1()\n```", "output": "SLOWER 3.2765", "pair_id": "python_p03503_pair0013_reversed", "problem_id": "p03503", "language": "python", "direction": "reversed", "speedup_ratio": 9.6901} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_5 = 0\nif var_5 == 0:\n var_8 = int(eval(input()))\n var_2 = []\n for var_4 in range(var_8):\n var_3 = list(map(int, input().split()))\n var_2.append(var_3)\n var_9 = []\n for var_4 in range(var_8):\n var_10 = list(map(int, input().split()))\n var_9.append(var_10)\nelif var_5 == 1:\n var_8 = 1\n var_2 = [[1, 1, 0, 1, 0, 0, 0, 1, 0, 1]]\n var_9 = [[3, 4, 5, 6, 7, 8, 9, -2, -3, 4, -2]]\nelif var_5 == 2:\n var_8 = 2\n var_2 = [[1, 1, 1, 1, 1, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 1, 1, 1, 1, 1]]\n var_9 = [\n [0, -2, -2, -2, -2, -2, -1, -1, -1, -1, -1],\n [0, -2, -2, -2, -2, -2, -1, -1, -1, -1, -1],\n ]\nelif var_5 == 3:\n var_8 = 3\n var_2 = [\n [1, 1, 1, 1, 1, 1, 0, 0, 1, 1],\n [0, 1, 0, 1, 1, 1, 1, 0, 1, 0],\n [1, 0, 1, 1, 0, 1, 0, 1, 0, 1],\n ]\n var_9 = [\n [-8, 6, -2, -8, -8, 4, 8, 7, -6, 2, 2],\n [-9, 2, 0, 1, 7, -5, 0, -2, -6, 5, 5],\n [6, -6, 7, -9, 6, -5, 8, 0, -9, -7, -7],\n ]\nimport itertools\n\nvar_13 = -(10**11)\nfor var_4 in itertools.product([0, 1], repeat=10):\n var_11 = list(var_4)\n var_12 = 0\n if sum(var_11) != 0:\n for var_7 in range(var_8):\n var_1 = 0\n for var_6 in range(10):\n var_1 = var_1 + var_11[var_6] * var_2[var_7][var_6]\n var_12 = var_12 + var_9[var_7][var_1]\n\n var_13 = max(var_12, var_13)\nprint(var_13)\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\n\nvar_8 = sys.stdin.readline\n\n\ndef func_1():\n var_2 = int(eval(var_8()))\n var_1 = []\n for _ in range(var_2):\n var_1.append(list(map(int, var_8().split())))\n var_3 = []\n for _ in range(var_2):\n var_3.append(list(map(int, var_8().split())))\n var_4 = -(10**7) * var_2\n for var_7 in range(1, 1 << 10):\n var_11 = 0\n for var_10, var_6 in enumerate(var_1):\n var_5 = 0\n for var_9 in range(10):\n if (var_7 >> var_9) & 1 & var_6[var_9]:\n var_5 += 1\n var_11 += var_3[var_10][var_5]\n var_4 = max(var_4, var_11)\n print(var_4)\n\n\nif __name__ == \"__main__\":\n func_1()\n```", "output": "FASTER 1.363", "pair_id": "python_p03503_pair0014_forward", "problem_id": "p03503", "language": "python", "direction": "forward", "speedup_ratio": 2.5722} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = input().split()\nvar_1 = int(var_1)\nvar_2 = int(var_2.replace(\".\", \"\"))\nprint((var_1 * var_2 // 100))\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\nimport math\nfrom collections import defaultdict\nfrom bisect import bisect_left, bisect_right\n\nsys.setrecursionlimit(10**7)\n\n\ndef func_4():\n return sys.stdin.readline()[:-1]\n\n\nvar_4 = 10**9 + 7\n\n\ndef func_1():\n return int(eval(func_4()))\n\n\ndef func_2():\n return list(map(int, func_4().split()))\n\n\ndef func_3(var_6, var_3):\n if var_6 <= 0:\n return [[] for _ in range(var_3)]\n elif var_3 == 1:\n return [func_1() for _ in range(var_6)]\n else:\n var_5 = [func_2() for _ in range(var_6)]\n return list(map(list, list(zip(*var_5))))\n\n\nfrom decimal import getcontext, Decimal\n\ngetcontext().prec = 28\nvar_1, var_2 = list(map(str, func_4().split()))\nvar_1 = int(var_1)\nvar_2 = Decimal(var_2)\nprint((int(var_1 * var_2)))\n```", "output": "SLOWER 2.5637", "pair_id": "python_p02659_pair0022_reversed", "problem_id": "p02659", "language": "python", "direction": "reversed", "speedup_ratio": 5.9123} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().strip().split(\" \")))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n if str(var_4) == str(var_4)[::-1]:\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_4 = {}\nvar_5 = 0\nfor var_6 in range(10000, 100000):\n var_3 = list(str(var_6))\n if var_3 == list(reversed(var_3)):\n var_5 += 1\n var_4[var_6] = var_5\nvar_1, var_2 = list(map(int, input().split()))\nprint((var_4[var_2] - var_4[var_1 - 1] if var_1 > 10000 else var_4[var_2]))\n```", "output": "SLOWER 3.2663", "pair_id": "python_p03416_pair0092_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 9.622} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nfrom sys import stdin\n\nvar_6 = lambda: list(map(int, stdin.readline().split()))\nvar_5 = lambda: list(map(int, stdin.readline().split()))\nvar_1, var_3 = var_6()\nvar_2 = 0\nfor var_4 in range(var_1, var_3 + 1):\n var_7 = str(var_4)\n if var_7 == var_7[::-1]:\n var_2 += 1\nprint(var_2)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = list(str(var_4))\n if var_5 == list(reversed(var_5)):\n var_3 += 1\nprint(var_3)\n```", "output": "SLOWER 1.2138", "pair_id": "python_p03416_pair0093_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 2.3194} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport copy\n\nvar_8 = int(eval(input()))\nvar_10 = set([var_6 for var_6 in range(1, 10**5)])\nvar_5 = []\nvar_11 = {}\nvar_9 = []\nfor var_6 in range(var_8 - 1):\n var_1, var_2 = list(map(int, input().split(\" \")))\n var_5.append([var_1, var_2])\n var_11.setdefault(var_1, []).append(var_2)\n var_9.append([])\nvar_9.append([])\nvar_9.append([])\nvar_7 = 0\nfor var_12 in range(1, var_8 + 1):\n var_14 = var_11.get(var_12, [])\n var_3 = 1\n for var_13 in var_14:\n if var_3 in var_9[var_12]:\n var_3 += 1\n else:\n pass\n var_9[var_13].append(var_3)\n if var_3 >= var_7:\n var_7 = var_3\n var_3 += 1\nprint(var_7)\nfor var_4 in var_5:\n print((var_9[var_4[1]][0]))\n```\n\n=== Code B (Modified) ===\n```python\n\"\"\"\"\"\"\n\nfrom collections import deque\n\n\ndef func_1():\n var_5, *var_1 = list(map(int, open(0).read().split()))\n var_2 = var_1[1::2]\n var_4 = [[] for _ in range(var_5 + 1)]\n for var_7, var_8 in zip(*[iter(var_1)] * 2):\n var_4[var_7].append(var_8)\n var_6 = deque([1])\n var_3 = [0] * (var_5 + 1)\n while var_6:\n var_11 = var_6.popleft()\n var_9 = 0\n for var_10 in var_4[var_11]:\n var_9 += 1 + (var_9 + 1 == var_3[var_11])\n var_3[var_10] = var_9\n var_6.append(var_10)\n print((max(var_3)))\n for var_8 in var_2:\n print((var_3[var_8]))\n\n\nfunc_1()\n```", "output": "FASTER 4.6186", "pair_id": "python_p02850_pair0016_forward", "problem_id": "p02850", "language": "python", "direction": "forward", "speedup_ratio": 24.5662} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nfrom itertools import product\n\nvar_6 = int(eval(input()))\nvar_1 = list(map(int, input().split()))\nvar_5 = 0\nfor var_2 in product((-1, 0, 1), repeat=var_6):\n var_7 = 1\n for var_3, var_4 in zip(var_1, var_2):\n var_7 *= var_3 + var_4\n if var_7 % 2 == 0:\n var_5 += 1\nprint(var_5)\n```\n\n=== Code B (Modified) ===\n```python\nvar_4 = int(eval(input()))\nvar_2 = list(map(int, input().split()))\n\n\ndef func_1(var_1, var_8, var_3):\n if var_8 == var_4:\n var_9 = 1\n for var_5 in var_3:\n var_9 *= var_5\n return 1 if var_9 % 2 == 0 else 0\n var_6 = var_3.copy()\n var_6.append(var_1[var_8] - 1)\n var_5 = var_3.copy()\n var_5.append(var_1[var_8])\n var_7 = var_3.copy()\n var_7.append(var_1[var_8] + 1)\n return (\n func_1(var_1, var_8 + 1, var_6)\n + func_1(var_1, var_8 + 1, var_5)\n + func_1(var_1, var_8 + 1, var_7)\n )\n\n\nprint((func_1(var_2, 0, [])))\n```", "output": "FASTER 1.7458", "pair_id": "python_p03568_pair0012_forward", "problem_id": "p03568", "language": "python", "direction": "forward", "speedup_ratio": 3.3539} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2, var_3 = list(map(int, input().split()))\nvar_4 = list(map(int, input().split()))\nvar_6 = list(map(int, input().split()))\nvar_5 = min(var_4) + min(var_6)\nfor var_7 in range(var_3):\n var_9, var_10, var_11 = list(map(int, input().split()))\n var_8 = var_4[var_9 - 1] + var_6[var_10 - 1] - var_11\n var_5 = var_8 if var_8 < var_5 else var_5\nprint(var_5)\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\nfrom collections import Counter\n\n\ndef func_9():\n return sys.stdin.readline().strip()\n\n\ndef func_10(var_8, var_9, var_10):\n return [[var_10] * var_9 for var_13 in range(var_8)]\n\n\ndef func_11(var_8, var_9, var_10, var_11):\n return [[[var_11] * var_10 for var_14 in range(var_9)] for var_13 in range(var_8)]\n\n\ndef func_12(var_8, var_9, var_10, var_11, var_12):\n return [\n [[[var_12] * var_11 for var_14 in range(var_10)] for var_14 in range(var_9)]\n for var_13 in range(var_8)\n ]\n\n\ndef func_8(var_16, var_17=1):\n return int(-(-var_16 // var_17))\n\n\ndef func_1():\n return int(eval(func_9()))\n\n\ndef func_3():\n return list(map(int, func_9().split()))\n\n\ndef func_2(var_7=None):\n return list(func_3()) if var_7 is None else [func_1() for var_13 in range(var_7)]\n\n\ndef func_7():\n print(\"Yes\")\n\n\ndef func_5():\n print(\"No\")\n\n\ndef func_6():\n print(\"YES\")\n\n\ndef func_4():\n print(\"NO\")\n\n\nsys.setrecursionlimit(10**9)\nvar_3 = 10**18\nvar_6 = 10**9 + 7\nvar_7, var_5, var_4 = func_3()\nvar_1 = func_2()\nvar_2 = func_2()\nvar_15 = min(var_1) + min(var_2)\nfor _ in range(var_4):\n var_16, var_17, var_10 = func_3()\n var_16 -= 1\n var_17 -= 1\n var_15 = min(var_15, var_1[var_16] + var_2[var_17] - var_10)\nprint(var_15)\n```", "output": "SLOWER 1.8148", "pair_id": "python_p02748_pair0002_reversed", "problem_id": "p02748", "language": "python", "direction": "reversed", "speedup_ratio": 3.5181} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport copy\n\nvar_8 = int(eval(input()))\nvar_10 = set([var_6 for var_6 in range(1, 10**5)])\nvar_5 = []\nvar_11 = {}\nvar_9 = []\nfor var_6 in range(var_8 - 1):\n var_1, var_2 = list(map(int, input().split(\" \")))\n var_5.append([var_1, var_2])\n var_11.setdefault(var_1, []).append(var_2)\n var_9.append([])\nvar_9.append([])\nvar_9.append([])\nvar_7 = 0\nfor var_12 in range(1, var_8 + 1):\n var_14 = var_11.get(var_12, [])\n var_3 = 1\n for var_13 in var_14:\n if var_3 in var_9[var_12]:\n var_3 += 1\n else:\n pass\n var_9[var_13].append(var_3)\n if var_3 >= var_7:\n var_7 = var_3\n var_3 += 1\nprint(var_7)\nfor var_4 in var_5:\n print((var_9[var_4[1]][0]))\n```\n\n=== Code B (Modified) ===\n```python\nvar_8 = int(eval(input()))\nvar_6 = []\nfor var_7 in range(var_8 - 1):\n var_1, var_3 = list(map(int, input().split()))\n var_6.append([var_1 - 1, var_3 - 1, var_7])\nvar_6.sort()\nvar_12 = [0] * (var_8)\nvar_2 = [0] * (var_8 - 1)\nvar_9 = 1\nvar_10 = 0\nfor var_5 in var_6:\n _from, var_11, var_7 = var_5\n if _from != var_10:\n var_9 = 1\n if var_12[_from] == var_9:\n var_9 += 1\n var_2[var_7] = var_9\n var_12[var_11] = var_9\n var_9 += 1\n var_10 = _from\nprint((max(var_2)))\nfor var_4 in var_2:\n print(var_4)\n```", "output": "FASTER 4.8668", "pair_id": "python_p02850_pair0017_forward", "problem_id": "p02850", "language": "python", "direction": "forward", "speedup_ratio": 29.178} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_4 = int(eval(input()))\nvar_2 = list(map(int, input().split()))\n\n\ndef func_1(var_1, var_8, var_3):\n if var_8 == var_4:\n var_9 = 1\n for var_5 in var_3:\n var_9 *= var_5\n return 1 if var_9 % 2 == 0 else 0\n var_6 = var_3.copy()\n var_6.append(var_1[var_8] - 1)\n var_5 = var_3.copy()\n var_5.append(var_1[var_8])\n var_7 = var_3.copy()\n var_7.append(var_1[var_8] + 1)\n return (\n func_1(var_1, var_8 + 1, var_6)\n + func_1(var_1, var_8 + 1, var_5)\n + func_1(var_1, var_8 + 1, var_7)\n )\n\n\nprint((func_1(var_2, 0, [])))\n```\n\n=== Code B (Modified) ===\n```python\nvar_2 = int(eval(input()))\nvar_1 = list(map(int, input().split()))\nvar_4 = 1\nfor var_3 in range(var_2):\n if var_1[var_3] % 2 == 0:\n var_4 *= 2\nprint((3**var_2 - var_4))\n```", "output": "FASTER 8.3009", "pair_id": "python_p03568_pair0013_forward", "problem_id": "p03568", "language": "python", "direction": "forward", "speedup_ratio": 315.3596} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\n\n\ndef func_1(var_5):\n var_4 = 0\n for var_3 in range(1, var_5 + 1):\n if str(var_3) == str(var_3)[::-1]:\n var_4 += 1\n return var_4\n\n\nprint((func_1(var_2) - func_1(var_1 - 1)))\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = [\n var_3 for var_3 in map(str, list(range(var_1, var_2 + 1))) if var_3 == var_3[::-1]\n]\nprint((len(var_4)))\n```", "output": "FASTER 2.2892", "pair_id": "python_p03416_pair0094_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 4.8878} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nfrom functools import reduce\nfrom itertools import product\n\nvar_2 = int(eval(input()))\n(*var_1,) = list(map(int, input().split()))\nvar_4 = 0\nfor var_7 in product([-1, 0, 1], repeat=var_2):\n var_6 = reduce(\n lambda var_8, var_9: var_8 * var_9,\n [var_3 + var_7[var_5] for var_5, var_3 in enumerate(var_1)],\n )\n if var_6 % 2 == 0:\n var_4 += 1\nprint(var_4)\n```\n\n=== Code B (Modified) ===\n```python\nvar_4 = int(eval(input()))\nvar_2 = list(map(int, input().split()))\n\n\ndef func_1(var_1, var_8, var_3):\n if var_8 == var_4:\n var_9 = 1\n for var_5 in var_3:\n var_9 *= var_5\n return 1 if var_9 % 2 == 0 else 0\n var_6 = var_3.copy()\n var_6.append(var_1[var_8] - 1)\n var_5 = var_3.copy()\n var_5.append(var_1[var_8])\n var_7 = var_3.copy()\n var_7.append(var_1[var_8] + 1)\n return (\n func_1(var_1, var_8 + 1, var_6)\n + func_1(var_1, var_8 + 1, var_5)\n + func_1(var_1, var_8 + 1, var_7)\n )\n\n\nprint((func_1(var_2, 0, [])))\n```", "output": "FASTER 1.4753", "pair_id": "python_p03568_pair0014_forward", "problem_id": "p03568", "language": "python", "direction": "forward", "speedup_ratio": 2.7805} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\ndef func_1():\n var_2 = int(eval(input()))\n var_1 = [int(var_6) for var_6 in input().split()]\n var_4 = 3**var_2\n var_5 = len([var_3 for var_3 in var_1 if var_3 % 2 == 0])\n var_4 -= 2**var_5\n print(var_4)\n\n\nif __name__ == \"__main__\":\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nvar_4 = int(eval(input()))\nvar_2 = list(map(int, input().split()))\n\n\ndef func_1(var_1, var_8, var_3):\n if var_8 == var_4:\n var_9 = 1\n for var_5 in var_3:\n var_9 *= var_5\n return 1 if var_9 % 2 == 0 else 0\n var_6 = var_3.copy()\n var_6.append(var_1[var_8] - 1)\n var_5 = var_3.copy()\n var_5.append(var_1[var_8])\n var_7 = var_3.copy()\n var_7.append(var_1[var_8] + 1)\n return (\n func_1(var_1, var_8 + 1, var_6)\n + func_1(var_1, var_8 + 1, var_5)\n + func_1(var_1, var_8 + 1, var_7)\n )\n\n\nprint((func_1(var_2, 0, [])))\n```", "output": "SLOWER 7.7739", "pair_id": "python_p03568_pair0015_reversed", "problem_id": "p03568", "language": "python", "direction": "reversed", "speedup_ratio": 218.8599} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\ndef func_1():\n var_1, var_2 = list(map(int, input().split()))\n var_3 = 0\n for var_4 in range(var_1, var_2 + 1):\n\n if (var_4 % 10) == (var_4 // 10000 % 10) and (var_4 // 10 % 10) == (\n var_4 // 1000 % 10\n ):\n var_3 += 1\n print(var_3)\n\n\nif __name__ == \"__main__\":\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = list(str(var_4))\n if var_5 == list(reversed(var_5)):\n var_3 += 1\nprint(var_3)\n```", "output": "SLOWER 2.8962", "pair_id": "python_p03416_pair0095_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 7.4448} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_10 = []\nvar_10 = input().rstrip().split(\" \")\nvar_1 = int(var_10[0])\nvar_3 = int(var_10[1])\nvar_2 = 0\nvar_6 = var_1\nwhile var_6 <= var_3:\n var_4 = var_6 // 10000\n var_5 = (var_6 - var_4 * 10000) // 1000\n var_7 = var_6 // 100\n var_8 = (var_6 - var_7 * 100) // 10\n var_9 = var_6 % 10\n if (var_4 == var_9) and (var_5 == var_8):\n var_2 += 1\n var_6 += 1\nprint(var_2)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1 = list(map(int, input().split()))\nvar_2 = 0\nfor var_3 in range(var_1[0], var_1[1] + 1):\n var_4 = str(var_3)\n if var_4[0] == var_4[4] and var_4[1] == var_4[3]:\n var_2 += 1\nprint(var_2)\n```", "output": "FASTER 1.0978", "pair_id": "python_p03416_pair0096_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 2.1403} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\n\n\ndef func_1(var_5, var_6):\n var_4 = 0\n for var_3 in range(var_5, var_6 + 1):\n if str(var_3) == str(var_3)[::-1]:\n var_4 += 1\n return var_4\n\n\nprint((func_1(var_1, var_2)))\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = [0] * (var_2 + 1)\nfor var_3 in range(1, var_2 + 1):\n if str(var_3) == str(var_3)[::-1]:\n var_4[var_3] = var_4[var_3 - 1] + 1\n else:\n var_4[var_3] = var_4[var_3 - 1]\nprint((var_4[var_2] - var_4[var_1 - 1]))\n```", "output": "SLOWER 2.2659", "pair_id": "python_p03416_pair0097_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 4.8095} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_10 = []\nvar_10 = input().rstrip().split(\" \")\nvar_1 = int(var_10[0])\nvar_3 = int(var_10[1])\nvar_2 = 0\nvar_6 = var_1\nwhile var_6 <= var_3:\n var_4 = var_6 // 10000\n var_5 = (var_6 - var_4 * 10000) // 1000\n var_7 = var_6 // 100\n var_8 = (var_6 - var_7 * 100) // 10\n var_9 = var_6 % 10\n if (var_4 == var_9) and (var_5 == var_8):\n var_2 += 1\n var_6 += 1\nprint(var_2)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = [\n var_3 for var_3 in map(str, list(range(var_1, var_2 + 1))) if var_3 == var_3[::-1]\n]\nprint((len(var_4)))\n```", "output": "FASTER 1.5076", "pair_id": "python_p03416_pair0038_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 2.8433} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_5 in range(10):\n for var_6 in range(10):\n for var_7 in range(10):\n var_3 = 10000 * var_5 + 1000 * var_6 + 100 * var_7 + 10 * var_6 + var_5\n if var_1 <= var_3 <= var_2:\n var_4 += 1\nprint(var_4)\n```\n\n=== Code B (Modified) ===\n```python\ndef func_1():\n var_1, var_2 = list(map(int, input().rstrip().split()))\n var_3 = 0\n for var_4 in range(var_1, var_2 + 1):\n var_5 = str(var_4)\n if var_5 == var_5[::-1]:\n var_3 += 1\n print(var_3)\n\n\nif __name__ == \"__main__\":\n func_1()\n```", "output": "SLOWER 3.0796", "pair_id": "python_p03416_pair0098_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 8.4536} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n if list(str(var_4)) == list(reversed(str(var_4))):\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\ndef func_1():\n var_1, var_2 = list(map(int, input().split()))\n var_3 = 0\n for var_4 in range(var_1, var_2 + 1):\n\n if (var_4 % 10) == (var_4 // 10000 % 10) and (var_4 // 10 % 10) == (\n var_4 // 1000 % 10\n ):\n var_3 += 1\n print(var_3)\n\n\nif __name__ == \"__main__\":\n func_1()\n```", "output": "FASTER 3.0644", "pair_id": "python_p03416_pair0058_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 8.3652} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_5 in range(var_1, var_2 + 1):\n var_3 = str(var_5)\n if var_3[0] == var_3[-1] and var_3[1] == var_3[-2]:\n var_4 += 1\nprint(var_4)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_5 in range(10):\n for var_6 in range(10):\n for var_7 in range(10):\n var_3 = 10000 * var_5 + 1000 * var_6 + 100 * var_7 + 10 * var_6 + var_5\n if var_1 <= var_3 <= var_2:\n var_4 += 1\nprint(var_4)\n```", "output": "FASTER 3.734", "pair_id": "python_p03416_pair0099_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 13.3058} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().strip().split(\" \")))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n if str(var_4) == str(var_4)[::-1]:\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\n\n\ndef func_1(var_5):\n var_4 = 0\n for var_3 in range(1, var_5 + 1):\n if str(var_3) == str(var_3)[::-1]:\n var_4 += 1\n return var_4\n\n\nprint((func_1(var_2) - func_1(var_1 - 1)))\n```", "output": "SLOWER 1.2833", "pair_id": "python_p03416_pair0100_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 2.434} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_5 in range(10):\n for var_6 in range(10):\n for var_7 in range(10):\n var_3 = 10000 * var_5 + 1000 * var_6 + 100 * var_7 + 10 * var_6 + var_5\n if var_1 <= var_3 <= var_2:\n var_4 += 1\nprint(var_4)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = input().split()\nvar_1 = int(var_1)\nvar_2 = int(var_2)\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = list(str(var_4))\n if (var_5[0] == var_5[4]) and (var_5[1] == var_5[3]):\n var_3 = var_3 + 1\nprint(var_3)\n```", "output": "SLOWER 4.2299", "pair_id": "python_p03416_pair0101_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 18.7637} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_6 = str(var_4)\n var_5 = var_6[::-1]\n if var_6 == var_5:\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = list(reversed(list(str(var_4))))\n if var_5 == list(str(var_4)):\n var_3 += 1\nprint(var_3)\n```", "output": "SLOWER 1.4065", "pair_id": "python_p03416_pair0081_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 2.651} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_6 = str(var_4)\n var_5 = var_6[::-1]\n if var_6 == var_5:\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_3 = list(map(int, input().split()))\nvar_2 = 0\nfor var_5 in range(var_3 + 1)[var_1:]:\n if len(str(var_5)) % 2 == 0:\n var_6 = list(str(var_5))[: len(str(var_5)) // 2]\n var_7 = list(reversed(list(str(var_5))[len(str(var_5)) // 2 :]))\n if var_6 == var_7:\n var_2 += 1\n else:\n var_8 = list(str(var_5))[: len(str(var_5)) // 2 + 1]\n var_4 = list(reversed(list(str(var_5))[len(str(var_5)) // 2 :]))\n if var_8 == var_4:\n var_2 += 1\nprint(var_2)\n```", "output": "SLOWER 2.2242", "pair_id": "python_p03416_pair0102_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 4.6724} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_4 = {}\nvar_5 = 0\nfor var_6 in range(10000, 100000):\n var_3 = list(str(var_6))\n if var_3 == list(reversed(var_3)):\n var_5 += 1\n var_4[var_6] = var_5\nvar_1, var_2 = list(map(int, input().split()))\nprint((var_4[var_2] - var_4[var_1 - 1] if var_1 > 10000 else var_4[var_2]))\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().rstrip().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = list(map(int, list(str(var_4))))\n if var_5[0] == var_5[4] and var_5[1] == var_5[3]:\n var_3 += 1\nprint(var_3)\n```", "output": "FASTER 1.8906", "pair_id": "python_p03416_pair0103_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 3.7079} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\nfrom collections import deque\nimport numpy as np\n\n\ndef func_1():\n var_7 = int(sys.stdin.readline().rstrip())\n var_3 = np.array(sys.stdin.read().split(), dtype=np.int64).reshape(-1, 2)\n var_1 = [[] for _ in range(var_7 + 1)]\n for var_2, var_4 in var_3:\n var_1[var_2].append(var_4)\n var_1[var_4].append(var_2)\n var_9 = np.zeros(var_7 + 1, dtype=np.int64)\n var_6 = np.zeros(var_7 + 1, dtype=np.int64)\n var_10 = deque([1])\n while var_10:\n var_11 = var_10.popleft()\n var_8 = var_6[var_11]\n var_5 = 1\n for var_12 in var_1[var_11]:\n if var_12 == var_9[var_11]:\n continue\n var_9[var_12] = var_11\n if var_5 == var_8:\n var_5 += 1\n var_6[var_12] = var_5\n var_10.append(var_12)\n var_5 += 1\n print((np.amax(var_6)))\n for var_2, var_4 in var_3:\n if var_2 == var_9[var_4]:\n print((var_6[var_4]))\n else:\n print((var_6[var_2]))\n\n\nif __name__ == \"__main__\":\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nimport copy\n\nvar_8 = int(eval(input()))\nvar_10 = set([var_6 for var_6 in range(1, 10**5)])\nvar_5 = []\nvar_11 = {}\nvar_9 = []\nfor var_6 in range(var_8 - 1):\n var_1, var_2 = list(map(int, input().split(\" \")))\n var_5.append([var_1, var_2])\n var_11.setdefault(var_1, []).append(var_2)\n var_9.append([])\nvar_9.append([])\nvar_9.append([])\nvar_7 = 0\nfor var_12 in range(1, var_8 + 1):\n var_14 = var_11.get(var_12, [])\n var_3 = 1\n for var_13 in var_14:\n if var_3 in var_9[var_12]:\n var_3 += 1\n else:\n pass\n var_9[var_13].append(var_3)\n if var_3 >= var_7:\n var_7 = var_3\n var_3 += 1\nprint(var_7)\nfor var_4 in var_5:\n print((var_9[var_4[1]][0]))\n```", "output": "SLOWER 4.2049", "pair_id": "python_p02850_pair0018_reversed", "problem_id": "p02850", "language": "python", "direction": "reversed", "speedup_ratio": 18.4421} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nfrom sys import stdin\n\nvar_6 = lambda: list(map(int, stdin.readline().split()))\nvar_5 = lambda: list(map(int, stdin.readline().split()))\nvar_1, var_3 = var_6()\nvar_2 = 0\nfor var_4 in range(var_1, var_3 + 1):\n var_7 = str(var_4)\n if var_7 == var_7[::-1]:\n var_2 += 1\nprint(var_2)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n if str(var_4) == \"\".join(reversed(str(var_4))):\n var_3 += 1\nprint(var_3)\n```", "output": "SLOWER 1.0578", "pair_id": "python_p03416_pair0104_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 2.0818} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\n\nvar_8 = sys.stdin.readline\n\n\ndef func_1():\n var_2 = int(eval(var_8()))\n var_1 = [int(var_8().replace(\" \", \"\"), 2) for _ in range(var_2)]\n var_3 = [list(map(int, var_8().split())) for _ in range(var_2)]\n var_4 = -(10**7) * var_2\n for var_7 in range(1, 1 << 10):\n var_10 = 0\n for var_9, var_6 in enumerate(var_1):\n var_5 = bin(var_7 & var_6).count(\"1\")\n var_10 += var_3[var_9][var_5]\n var_4 = max(var_4, var_10)\n print(var_4)\n\n\nif __name__ == \"__main__\":\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nvar_8 = int(eval(input()))\nvar_4 = []\nfor var_5 in range(var_8):\n var_11 = 0\n var_9 = list(map(int, input().split()))\n for var_6 in range(10):\n var_11 += var_9[var_6] << var_6\n var_4.append(var_11)\nvar_10 = []\nfor var_5 in range(var_8):\n var_10.append(list(map(int, input().split())))\nvar_1 = -(10**12)\nfor var_5 in range(1, 1 << 10):\n var_11 = 0\n for var_6 in range(var_8):\n var_3 = var_4[var_6] & var_5\n var_2 = 0\n for var_7 in range(10):\n if (var_3 >> var_7) % 2:\n var_2 += 1\n var_11 += var_10[var_6][var_2]\n var_1 = max(var_1, var_11)\nprint(var_1)\n```", "output": "SLOWER 2.5749", "pair_id": "python_p03503_pair0015_reversed", "problem_id": "p03503", "language": "python", "direction": "reversed", "speedup_ratio": 5.9584} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\ndef func_1():\n var_1, var_2 = list(map(int, input().split()))\n var_3 = 0\n for var_4 in range(var_1, var_2 + 1):\n\n if (var_4 % 10) == (var_4 // 10000 % 10) and (var_4 // 10 % 10) == (\n var_4 // 1000 % 10\n ):\n var_3 += 1\n print(var_3)\n\n\nif __name__ == \"__main__\":\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().rstrip().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = list(map(int, list(str(var_4))))\n if var_5[0] == var_5[4] and var_5[1] == var_5[3]:\n var_3 += 1\nprint(var_3)\n```", "output": "SLOWER 3.3471", "pair_id": "python_p03416_pair0105_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 10.1758} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_5 in range(var_1, var_2 + 1):\n var_3 = str(var_5)\n if var_3[0] == var_3[-1] and var_3[1] == var_3[-2]:\n var_4 += 1\nprint(var_4)\n```\n\n=== Code B (Modified) ===\n```python\nvar_4, var_3 = list(map(int, input().split()))\nvar_1 = 0\nfor var_2 in range(var_4, var_3 + 1):\n if str(var_2)[0] + str(var_2)[1] == str(var_2)[-1] + str(var_2)[-2]:\n var_1 += 1\nprint(var_1)\n```", "output": "SLOWER 1.4327", "pair_id": "python_p03416_pair0027_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 2.6995} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport numpy as np\n\nvar_7 = input()[::-1]\nvar_6 = len(var_7)\nvar_1 = np.zeros(var_6, dtype=int)\nvar_4 = np.zeros(var_6, dtype=int)\nvar_2 = np.zeros(2019, dtype=int)\nvar_8 = 10\nvar_1[0] = int(var_7[0])\nvar_4[0] = var_1[0]\nvar_2[var_4[0]] += 1\nfor var_5 in range(1, var_6):\n var_1[var_5] = int(var_7[var_5]) * var_8 % 2019\n var_4[var_5] = (var_4[var_5 - 1] + var_1[var_5]) % 2019\n var_2[var_4[var_5]] += 1\n var_8 = var_8 * 10 % 2019\nvar_3 = var_2[np.nonzero(var_2)]\nprint(\n (\n int(\n sum([var_3[var_5] * (var_3[var_5] - 1) for var_5 in range(var_3.shape[0])])\n / 2\n )\n + var_2[0]\n )\n)\n```\n\n=== Code B (Modified) ===\n```python\nvar_6 = 2019\nvar_1 = [0] * var_6\nvar_3 = 1\nvar_5 = var_4 = 0\nfor var_2 in input()[::-1]:\n var_1[var_4] += 1\n var_4 -= int(var_2) * var_3\n var_4 %= var_6\n var_5 += var_1[var_4]\n var_3 *= 10\n var_3 %= var_6\nprint(var_5)\n```", "output": "FASTER 1.5513", "pair_id": "python_p02702_pair0005_forward", "problem_id": "p02702", "language": "python", "direction": "forward", "speedup_ratio": 2.9308} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_4 = int(eval(input()))\nvar_2 = list(map(int, input().split()))\n\n\ndef func_1(var_1, var_8, var_3):\n if var_8 == var_4:\n var_9 = 1\n for var_5 in var_3:\n var_9 *= var_5\n return 1 if var_9 % 2 == 0 else 0\n var_6 = var_3.copy()\n var_6.append(var_1[var_8] - 1)\n var_5 = var_3.copy()\n var_5.append(var_1[var_8])\n var_7 = var_3.copy()\n var_7.append(var_1[var_8] + 1)\n return (\n func_1(var_1, var_8 + 1, var_6)\n + func_1(var_1, var_8 + 1, var_5)\n + func_1(var_1, var_8 + 1, var_7)\n )\n\n\nprint((func_1(var_2, 0, [])))\n```\n\n=== Code B (Modified) ===\n```python\nvar_6 = int(eval(input()))\nvar_2 = list(map(int, input().split()))\nfrom itertools import product\n\nvar_5 = [-1, 0, 1]\nvar_3 = 0\nfor var_7 in product(var_5, repeat=var_6):\n var_1 = []\n for var_4 in range(var_6):\n var_1.append(var_7[var_4] + var_2[var_4])\n if any(var_8 % 2 == 0 for var_8 in var_1):\n var_3 += 1\nprint(var_3)\n```", "output": "SLOWER 1.5499", "pair_id": "python_p03568_pair0016_reversed", "problem_id": "p03568", "language": "python", "direction": "reversed", "speedup_ratio": 2.928} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nfrom collections import defaultdict\n\nvar_8 = int(eval(input()))\nvar_1 = tuple(map(int, input().split()))\nvar_3 = True\nif var_8 % 3 == 0:\n var_5 = defaultdict(int)\n for var_2 in var_1:\n var_5[var_2] += 1\n var_7 = var_8 // 3\n var_10 = []\n for var_9, var_4 in list(var_5.items()):\n if var_4 % var_7 != 0:\n var_3 = False\n break\n else:\n for _ in range(var_4 // var_7):\n var_10.append(var_9)\n else:\n if any(\n var_10[(0 + var_6) % 3] ^ var_10[(1 + var_6) % 3] != var_10[(2 + var_6) % 3]\n for var_6 in range(3)\n ):\n var_3 = False\nelse:\n if any(var_2 != 0 for var_2 in var_1):\n var_3 = False\nprint((\"Yes\" if var_3 else \"No\"))\n```\n\n=== Code B (Modified) ===\n```python\nfrom functools import *\n\n_, var_1 = open(0)\nprint(\n (\n \"YNeos\"[\n var_2(lambda var_3, var_4: var_3 ^ var_4, list(map(int, var_1.split())))\n > 0 :: 2\n ]\n )\n)\n```", "output": "FASTER 1.1419", "pair_id": "python_p02975_pair0002_forward", "problem_id": "p02975", "language": "python", "direction": "forward", "speedup_ratio": 2.2067} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_2, var_1 = list(map(int, input().split()))\nvar_3 = 0\nvar_8 = 0\nvar_4 = [0] * (var_2 + 1)\nvar_9 = [0] * (var_2 + 1)\nfor var_5 in range(var_1):\n var_6, var_7 = input().split()\n var_6 = int(var_6)\n if var_7 == \"AC\":\n if var_4[var_6] == 0:\n var_3 += 1\n var_8 += var_9[var_6]\n var_4[var_6] = 1\n else:\n var_9[var_6] += 1\nprint((var_3, var_8))\n```\n\n=== Code B (Modified) ===\n```python\nfrom sys import stdin\n\nvar_5 = stdin.readline\nvar_2, var_1 = list(map(int, var_5().split()))\nvar_3 = [False] * var_2\nvar_8 = [0] * var_2\nvar_9 = 0\nfor var_4 in range(var_1):\n var_6, var_7 = var_5().split()\n var_6 = int(var_6) - 1\n if var_3[var_6] is False and var_7 == \"AC\":\n var_9 += var_8[var_6]\n var_3[var_6] = True\n elif var_7 == \"WA\":\n var_8[var_6] += 1\nprint((var_3.count(True), var_9))\n```", "output": "SLOWER 1.4288", "pair_id": "python_p02802_pair0003_reversed", "problem_id": "p02802", "language": "python", "direction": "reversed", "speedup_ratio": 2.6922} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\ndef func_1():\n var_2, var_3, *var_1 = list(map(int, open(0).read().split()))\n var_4 = [0] * (var_3 + max(var_1[::2]))\n for var_7, var_6 in sorted(zip(*[iter(var_1)] * 2)):\n for var_5 in reversed(list(range(var_3))):\n var_4[var_5 + var_7] = max(var_4[var_5 + var_7], var_4[var_5] + var_6)\n print((max(var_4)))\n\n\nfunc_1()\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\n\nvar_10 = sys.stdin.readline\nvar_2, var_3 = list(map(int, var_10().split()))\nvar_1 = [list(map(int, var_10().split())) for _ in range(var_2)]\nvar_8 = [[0 for _ in range(var_2 + 1)] for _ in range(var_3 + 1)]\n\nvar_13 = [[0 for _ in range(var_2 + 1)] for _ in range(var_3 + 1)]\nfor var_11 in range(var_2):\n var_4, var_6 = var_1[var_11]\n for var_15 in range(var_3):\n if var_4 > var_15:\n var_8[var_15][var_11 + 1] = var_8[var_15][var_11]\n var_13[var_15][var_11 + 1] = var_15\n else:\n if var_6 + var_8[var_15 - var_4][var_11] >= var_8[var_15][var_11]:\n var_8[var_15][var_11 + 1] = var_8[var_15 - var_4][var_11] + var_6\n var_13[var_15][var_11 + 1] = var_15 - var_4\n else:\n var_8[var_15][var_11 + 1] = var_8[var_15][var_11]\n var_13[var_15][var_11 + 1] = var_15\nvar_5 = var_8[var_3 - 1][var_2]\nvar_14 = [False] * var_2\nvar_7 = var_3 - 1\nfor var_9 in reversed(list(range(var_2))):\n if var_13[var_7][var_9 + 1] == var_7 - var_1[var_9][0]:\n var_14[var_9] = True\n var_7 = var_13[var_7][var_9 + 1]\nvar_12 = 0\nfor var_9 in range(var_2):\n if not var_14[var_9] and var_1[var_9][1] > var_12:\n var_12 = var_1[var_9][1]\nprint((var_5 + var_12))\n```", "output": "SLOWER 1.7835", "pair_id": "python_p02863_pair0022_reversed", "problem_id": "p02863", "language": "python", "direction": "reversed", "speedup_ratio": 3.4426} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_3 = list(map(int, input().split()))\nvar_2 = 0\nfor var_5 in range(var_3 + 1)[var_1:]:\n if len(str(var_5)) % 2 == 0:\n var_6 = list(str(var_5))[: len(str(var_5)) // 2]\n var_7 = list(reversed(list(str(var_5))[len(str(var_5)) // 2 :]))\n if var_6 == var_7:\n var_2 += 1\n else:\n var_8 = list(str(var_5))[: len(str(var_5)) // 2 + 1]\n var_4 = list(reversed(list(str(var_5))[len(str(var_5)) // 2 :]))\n if var_8 == var_4:\n var_2 += 1\nprint(var_2)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_6 = str(var_4)\n var_5 = var_6[::-1]\n if var_6 == var_5:\n var_3 += 1\nprint(var_3)\n```", "output": "FASTER 2.2242", "pair_id": "python_p03416_pair0102_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 4.6724} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n if str(var_4) == \"\".join(reversed(str(var_4))):\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_4 = str(var_4)\n if var_4[0] == var_4[-1] and var_4[1] == var_4[-2]:\n var_3 += 1\nprint(var_3)\n```", "output": "FASTER 1.26", "pair_id": "python_p03416_pair0106_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 2.3949} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().rstrip().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = list(map(int, list(str(var_4))))\n if var_5[0] == var_5[4] and var_5[1] == var_5[3]:\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().strip().split(\" \")))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n if str(var_4) == str(var_4)[::-1]:\n var_3 += 1\nprint(var_3)\n```", "output": "FASTER 1.3757", "pair_id": "python_p03416_pair0090_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 2.595} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nfrom collections import Counter, defaultdict, deque\nfrom heapq import heappop, heappush, heapify\nimport sys, bisect, math, itertools, fractions, pprint\n\nsys.setrecursionlimit(10**8)\nvar_6 = 10**9 + 7\nvar_1 = float(\"inf\")\n\n\ndef func_1():\n return int(sys.stdin.readline())\n\n\ndef func_2():\n return list(map(int, sys.stdin.readline().split()))\n\n\nvar_8, var_11 = func_2()\nvar_17 = [func_2() for _ in range(var_8)]\nvar_10 = var_17[::-1]\nvar_14 = [[0] * var_11 for _ in range(var_8)]\nvar_3 = [[0] * var_11 for _ in range(var_8)]\nfor var_4 in range(var_8 - 1):\n var_16, var_15 = var_17[var_4]\n for var_5 in range(var_11):\n if var_5 < var_16:\n var_14[var_4 + 1][var_5] = var_14[var_4][var_5]\n else:\n var_14[var_4 + 1][var_5] = max(\n var_14[var_4][var_5], var_14[var_4][var_5 - var_16] + var_15\n )\nvar_9 = var_14[var_8 - 1][var_11 - 1] + var_17[var_8 - 1][1]\nfor var_4 in range(var_8 - 1):\n var_16, var_15 = var_10[var_4]\n for var_5 in range(var_11):\n if var_5 < var_16:\n var_3[var_4 + 1][var_5] = var_3[var_4][var_5]\n else:\n var_3[var_4 + 1][var_5] = max(\n var_3[var_4][var_5], var_3[var_4][var_5 - var_16] + var_15\n )\n var_9 = max(var_9, var_3[var_8 - 1][var_11 - 1] + var_17[0][1])\n\nfor var_4 in range(1, var_8 - 1):\n var_13 = var_4\n var_2 = var_8 - var_4 - 1\n var_7 = 0\n for var_5 in range(var_11):\n var_12 = var_14[var_13][var_5] + var_3[var_2][var_11 - 1 - var_5]\n var_7 = max(var_7, var_12)\n var_9 = max(var_9, var_7 + var_17[var_4][1])\nprint(var_9)\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\nfrom operator import itemgetter\nfrom heapq import heapify, heappop, heappush\n\nvar_1 = int(10e15)\nvar_2 = -var_1\nvar_11 = 1000000007\nsys.setrecursionlimit(1000000)\n\n\ndef func_2():\n return list(map(int, input().split()))\n\n\ndef func_4():\n return input().split()\n\n\ndef func_1():\n return int(sys.stdin.readline())\n\n\ndef func_3():\n return eval(input())\n\n\nvar_3, var_4 = func_2()\nvar_5 = [func_2() for var_9 in range(var_3)]\nvar_5.sort(key=itemgetter(0))\n\nvar_8 = [[0] * (var_4 + 1 + 3000 + 1) for _ in range(var_3 + 1)]\nvar_6 = 0\nfor var_9 in range(var_3):\n for var_10 in range(var_4 + 1 + 3000 + 1):\n var_12, var_7 = var_5[var_9]\n if 0 <= var_10 - var_12 < var_4:\n var_8[var_9 + 1][var_10] = max(\n var_8[var_9][var_10], var_8[var_9][var_10 - var_12] + var_7\n )\n else:\n var_8[var_9 + 1][var_10] = var_8[var_9][var_10]\n var_6 = max(var_6, var_8[var_9 + 1][var_10])\nprint(var_6)\n```", "output": "SLOWER 3.8148", "pair_id": "python_p02863_pair0023_reversed", "problem_id": "p02863", "language": "python", "direction": "reversed", "speedup_ratio": 14.0727} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nfrom collections import Counter, defaultdict, deque\nfrom heapq import heappop, heappush, heapify\nimport sys, bisect, math, itertools, fractions, pprint\n\nsys.setrecursionlimit(10**8)\nvar_6 = 10**9 + 7\nvar_1 = float(\"inf\")\n\n\ndef func_1():\n return int(sys.stdin.readline())\n\n\ndef func_2():\n return list(map(int, sys.stdin.readline().split()))\n\n\nvar_7, var_9 = func_2()\nvar_13 = [func_2() for _ in range(var_7)]\nvar_13.sort(key=lambda var_14: var_14[1], reverse=True)\nvar_8 = 0\nvar_10 = min(var_7, 5)\nfor var_3 in range(var_10):\n var_2 = [[0] * (var_9 + 5) for _ in range(var_7 + 5)]\n for var_4 in range(var_7):\n var_12, var_11 = var_13[var_4]\n for var_5 in range(var_9):\n if var_5 < var_12 or var_3 == var_4:\n var_2[var_4 + 1][var_5] = var_2[var_4][var_5]\n else:\n var_2[var_4 + 1][var_5] = max(\n var_2[var_4][var_5], var_2[var_4][var_5 - var_12] + var_11\n )\n\n var_8 = max(var_2[var_7][var_9 - 1] + var_13[var_3][1], var_8)\nprint(var_8)\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\nfrom collections import deque\n\nvar_1 = int(10e10)\nvar_2 = -var_1\nvar_12 = 1000000007\nsys.setrecursionlimit(1000000)\n\n\ndef func_2():\n return list(map(int, input().split()))\n\n\ndef func_4():\n return input().split()\n\n\ndef func_1():\n return int(sys.stdin.readline())\n\n\ndef func_3():\n return eval(input())\n\n\nvar_3, var_4 = func_2()\nvar_6 = [func_2() for var_10 in range(var_3)]\nvar_6.sort()\nvar_7 = 0\nvar_9 = [[0] * var_4 for var_10 in range(var_3 + 1)]\nfor var_10 in range(1, var_3 + 1):\n var_5, var_8 = var_6[var_10 - 1]\n for var_11 in range(var_4):\n if 0 <= var_11 - var_5 < var_4:\n var_9[var_10][var_11] = max(\n var_9[var_10 - 1][var_11], var_9[var_10 - 1][var_11 - var_5] + var_8\n )\n else:\n var_9[var_10][var_11] = var_9[var_10 - 1][var_11]\n else:\n var_7 = max(var_7, var_9[var_10 - 1][-1] + var_8)\nprint(var_7)\n```", "output": "FASTER 1.5536", "pair_id": "python_p02863_pair0024_forward", "problem_id": "p02863", "language": "python", "direction": "forward", "speedup_ratio": 2.9355} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = [0] * (var_2 + 1)\nfor var_3 in range(1, var_2 + 1):\n if str(var_3) == str(var_3)[::-1]:\n var_4[var_3] = var_4[var_3 - 1] + 1\n else:\n var_4[var_3] = var_4[var_3 - 1]\nprint((var_4[var_2] - var_4[var_1 - 1]))\n```\n\n=== Code B (Modified) ===\n```python\nvar_1 = list(map(int, input().split()))\nvar_2 = 0\nfor var_3 in range(var_1[0], var_1[1] + 1):\n var_4 = str(var_3)\n if var_4[0] == var_4[4] and var_4[1] == var_4[3]:\n var_2 += 1\nprint(var_2)\n```", "output": "FASTER 2.2311", "pair_id": "python_p03416_pair0107_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 4.6949} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\nimport math\nfrom collections import defaultdict\nfrom bisect import bisect_left, bisect_right\n\nsys.setrecursionlimit(10**7)\n\n\ndef func_4():\n return sys.stdin.readline()[:-1]\n\n\nvar_4 = 10**9 + 7\n\n\ndef func_1():\n return int(eval(func_4()))\n\n\ndef func_2():\n return list(map(int, func_4().split()))\n\n\ndef func_3(var_6, var_3):\n if var_6 <= 0:\n return [[] for _ in range(var_3)]\n elif var_3 == 1:\n return [func_1() for _ in range(var_6)]\n else:\n var_5 = [func_2() for _ in range(var_6)]\n return list(map(list, list(zip(*var_5))))\n\n\nfrom decimal import getcontext, Decimal\n\ngetcontext().prec = 28\nvar_1, var_2 = list(map(str, func_4().split()))\nvar_1 = int(var_1)\nvar_2 = Decimal(var_2)\nprint((int(var_1 * var_2)))\n```\n\n=== Code B (Modified) ===\n```python\nimport decimal\n\n\ndef func_1():\n var_1, var_2 = list(map(decimal.Decimal, input().split()))\n print((var_1 * var_2 // 1))\n\n\nif __name__ == \"__main__\":\n func_1()\n```", "output": "FASTER 2.0487", "pair_id": "python_p02659_pair0023_forward", "problem_id": "p02659", "language": "python", "direction": "forward", "speedup_ratio": 4.1373} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_8 = int(eval(input()))\nvar_4 = []\nfor var_5 in range(var_8):\n var_11 = 0\n var_9 = list(map(int, input().split()))\n for var_6 in range(10):\n var_11 += var_9[var_6] << var_6\n var_4.append(var_11)\nvar_10 = []\nfor var_5 in range(var_8):\n var_10.append(list(map(int, input().split())))\nvar_1 = -(10**12)\nfor var_5 in range(1, 1 << 10):\n var_11 = 0\n for var_6 in range(var_8):\n var_3 = list(bin(var_4[var_6] & var_5)[2:])\n var_2 = 0\n for var_7 in var_3:\n if var_7 == \"1\":\n var_2 += 1\n var_11 += var_10[var_6][var_2]\n var_1 = max(var_1, var_11)\nprint(var_1)\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\nimport itertools\n\n\ndef func_2(var_4):\n return bin(eval(\"0b\" + str(var_4)))\n\n\ndef func_1():\n var_4 = int(sys.stdin.readline().rstrip())\n var_9 = [\n func_2(\"\".join(str(var_10) for var_10 in sys.stdin.readline().split()))\n for _ in range(var_4)\n ]\n var_8 = [\n [int(var_10) for var_10 in sys.stdin.readline().split()] for _ in range(var_4)\n ]\n var_3 = -(10**10)\n for var_6 in itertools.product(\"01\", repeat=10):\n var_6 = func_2(\"\".join(var_6))\n if var_6 == \"0b0\":\n continue\n var_7 = 0\n for var_2 in range(var_4):\n var_1 = var_9[var_2]\n var_5 = bin(eval(var_1) & eval(var_6)).count(\"1\")\n var_7 += var_8[var_2][var_5]\n var_3 = max(var_3, var_7)\n print(var_3)\n\n\nif __name__ == \"__main__\":\n\n func_1()\n```", "output": "SLOWER 3.1052", "pair_id": "python_p03503_pair0016_reversed", "problem_id": "p03503", "language": "python", "direction": "reversed", "speedup_ratio": 8.605} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_8 in range(var_1, var_2 + 1):\n var_7 = str(var_8)\n var_6 = len(var_7)\n var_4 = True\n for var_5 in range(var_6 // 2):\n if var_7[var_5] != var_7[var_6 - 1 - var_5]:\n var_4 = False\n break\n if var_4:\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_4 = {}\nvar_5 = 0\nfor var_6 in range(10000, 100000):\n var_3 = list(str(var_6))\n if var_3 == list(reversed(var_3)):\n var_5 += 1\n var_4[var_6] = var_5\nvar_1, var_2 = list(map(int, input().split()))\nprint((var_4[var_2] - var_4[var_1 - 1] if var_1 > 10000 else var_4[var_2]))\n```", "output": "SLOWER 2.4474", "pair_id": "python_p03416_pair0034_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 5.4542} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\nfrom collections import deque\n\nvar_1 = int(10e10)\nvar_2 = -var_1\nvar_12 = 1000000007\nsys.setrecursionlimit(1000000)\n\n\ndef func_2():\n return list(map(int, input().split()))\n\n\ndef func_4():\n return input().split()\n\n\ndef func_1():\n return int(sys.stdin.readline())\n\n\ndef func_3():\n return eval(input())\n\n\nvar_3, var_4 = func_2()\nvar_6 = [func_2() for var_10 in range(var_3)]\nvar_6.sort()\nvar_7 = 0\nvar_9 = [[0] * var_4 for var_10 in range(var_3 + 1)]\nfor var_10 in range(1, var_3 + 1):\n var_5, var_8 = var_6[var_10 - 1]\n for var_11 in range(var_4):\n if 0 <= var_11 - var_5 < var_4:\n var_9[var_10][var_11] = max(\n var_9[var_10 - 1][var_11], var_9[var_10 - 1][var_11 - var_5] + var_8\n )\n else:\n var_9[var_10][var_11] = var_9[var_10 - 1][var_11]\n else:\n var_7 = max(var_7, var_9[var_10 - 1][-1] + var_8)\nprint(var_7)\n```\n\n=== Code B (Modified) ===\n```python\nvar_6, var_7 = list(map(int, input().split()))\nvar_1 = [list(map(int, input().split())) for _ in range(var_6)]\nvar_1.sort()\nvar_3 = [(6007) * [0] for _ in range(var_6 + 1)]\nvar_3[0][0] = 0\nvar_2 = 0\nfor var_4 in range(var_6):\n for var_5 in range(6007):\n var_3[var_4 + 1][var_5] = max(var_3[var_4 + 1][var_5], var_3[var_4][var_5])\n if var_5 < var_7:\n var_3[var_4 + 1][var_5 + var_1[var_4][0]] = max(\n var_3[var_4][var_5] + var_1[var_4][1],\n var_3[var_4][var_5 + var_1[var_4][0]],\n )\n var_2 = max(var_2, var_3[var_4 + 1][var_5])\nprint(var_2)\n```", "output": "SLOWER 5.6348", "pair_id": "python_p02863_pair0025_reversed", "problem_id": "p02863", "language": "python", "direction": "reversed", "speedup_ratio": 49.688} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport decimal\n\nvar_1, var_2 = (decimal.Decimal(var_3) for var_3 in input().split())\nprint((int(var_1 * var_2)))\n```\n\n=== Code B (Modified) ===\n```python\ndef func_1():\n from sys import setrecursionlimit, stdin\n from os import environ\n from collections import defaultdict, deque, Counter\n from math import ceil, floor, gcd\n from itertools import accumulate, combinations, combinations_with_replacement\n\n setrecursionlimit(10**6)\n var_7 = (\n (lambda *var_11: print(*var_11))\n if \"TERM_PROGRAM\" in environ\n else lambda *var_12: 0\n )\n var_8 = lambda: stdin.readline().rstrip()\n var_3 = lambda: list(map(int, var_8().split()))\n var_1 = lambda: int(var_8())\n var_4 = 10**9 + 7\n var_2 = 10**9 + 10\n var_9, var_10 = var_8().split()\n var_5 = int(var_9)\n var_10 = var_10.split(\".\")\n var_6 = int(var_10[0]) * 100\n if len(var_10) == 2:\n var_6 += int(var_10[1])\n print(var_5 * var_6 // 100)\n\n\nfunc_1()\n```", "output": "SLOWER 2.0989", "pair_id": "python_p02659_pair0024_reversed", "problem_id": "p02659", "language": "python", "direction": "reversed", "speedup_ratio": 4.2837} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = str(var_4)\n if var_5 == var_5[::-1]:\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = list(str(var_4))\n if var_5 == list(reversed(var_5)):\n var_3 += 1\nprint(var_3)\n```", "output": "SLOWER 1.2366", "pair_id": "python_p03416_pair0108_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 2.3565} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\n\n\ndef func_1():\n var_8 = int(sys.stdin.readline().rstrip())\n var_7 = list(map(int, sys.stdin.read().split()))\n var_2 = list(zip(var_7, var_7))\n var_6 = [[] for _ in range(var_8 + 1)]\n for var_1, var_3 in var_2:\n var_6[var_1].append(var_3)\n var_6[var_3].append(var_1)\n var_13 = 1\n var_11 = [0] * (var_8 + 1)\n var_10 = []\n var_14 = [var_13]\n while var_14:\n var_15 = var_14.pop()\n var_10.append(var_15)\n for var_16 in var_6[var_15]:\n if var_16 == var_11[var_15]:\n continue\n var_11[var_16] = var_15\n var_14.append(var_16)\n var_5 = [-1] * (var_8 + 1)\n for var_15 in var_10:\n var_9 = var_5[var_15]\n var_4 = 1\n for var_16 in var_6[var_15]:\n if var_16 == var_11[var_15]:\n continue\n if var_4 == var_9:\n var_4 += 1\n var_5[var_16] = var_4\n var_4 += 1\n var_12 = []\n for var_1, var_3 in var_2:\n if var_11[var_1] == var_3:\n var_12.append(var_5[var_1])\n else:\n var_12.append(var_5[var_3])\n print((max(var_12)))\n print((\"\\n\".join(map(str, var_12))))\n\n\nif __name__ == \"__main__\":\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nimport copy\n\nvar_8 = int(eval(input()))\nvar_10 = set([var_6 for var_6 in range(1, 10**5)])\nvar_5 = []\nvar_11 = {}\nvar_9 = []\nfor var_6 in range(var_8 - 1):\n var_1, var_2 = list(map(int, input().split(\" \")))\n var_5.append([var_1, var_2])\n var_11.setdefault(var_1, []).append(var_2)\n var_9.append([])\nvar_9.append([])\nvar_9.append([])\nvar_7 = 0\nfor var_12 in range(1, var_8 + 1):\n var_14 = var_11.get(var_12, [])\n var_3 = 1\n for var_13 in var_14:\n if var_3 in var_9[var_12]:\n var_3 += 1\n else:\n pass\n var_9[var_13].append(var_3)\n if var_3 >= var_7:\n var_7 = var_3\n var_3 += 1\nprint(var_7)\nfor var_4 in var_5:\n print((var_9[var_4[1]][0]))\n```", "output": "SLOWER 4.1752", "pair_id": "python_p02850_pair0010_reversed", "problem_id": "p02850", "language": "python", "direction": "reversed", "speedup_ratio": 18.0665} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nfor var_3 in range(1, 1009):\n if int(var_3 * 0.08) == var_1 and int(var_3 * 0.1) == var_2:\n print((int(var_3)))\n exit()\nprint(\"-1\")\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nimport math\n\nif math.ceil((var_1 + 1) * 12.5) <= math.ceil(var_2 * 10) or math.ceil(\n var_1 * 12.5\n) >= math.ceil((var_2 + 1) * 10):\n print((-1))\nelse:\n print((max(math.ceil(var_1 * 12.5), math.ceil(var_2 * 10))))\n```", "output": "FASTER 1.923", "pair_id": "python_p02755_pair0005_forward", "problem_id": "p02755", "language": "python", "direction": "forward", "speedup_ratio": 3.792} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\n\nvar_17 = sys.stdin.read\nvar_18 = sys.stdin.readline\nvar_19 = sys.stdin.readlines\nsys.setrecursionlimit(10**9)\nvar_2 = 1 << 60\nvar_4 = 1000000007\n\n\nclass Class_1:\n def __init__(self, var_12):\n self.n = var_12\n self.data = [0] * (var_12 + 1)\n\n def func_1(self, var_10, var_20=1):\n var_10 += 1\n while var_10 <= self.n:\n self.data[var_10] += var_20\n var_10 += var_10 & -var_10\n\n def func_2(self, var_10):\n var_10 += 1\n var_20 = 0\n while var_10 > 0:\n var_20 += self.data[var_10]\n var_10 -= var_10 & -var_10\n return var_20\n\n def func_3(self, var_11, var_16):\n return self.get_sum(var_16 - 1) - self.get_sum(var_11 - 1)\n\n\ndef func_4():\n var_5, var_6 = map(int, var_18().split())\n var_1 = list(map(int, var_18().split()))\n var_3 = map(int, var_17().split())\n var_13 = [-1] * (var_5 + 1)\n var_14 = [[] for _ in range(var_5)]\n for var_10, var_9 in enumerate(var_1):\n if var_13[var_9] != -1:\n var_14[var_13[var_9]].append(var_10)\n var_13[var_9] = var_10\n var_15 = [[] for _ in range(var_5 + 1)]\n for var_10, (var_11, var_16) in enumerate(zip(*[iter(var_3)] * 2)):\n var_11 -= 1\n var_16 -= 1\n var_15[var_11].append((var_16, var_10))\n var_7 = [0] * var_6\n var_8 = Class_1(var_5)\n for var_11 in range(var_5 - 1, -1, -1):\n for var_16 in var_14[var_11]:\n var_8.add(var_16)\n for var_16, var_10 in var_15[var_11]:\n var_7[var_10] = (var_16 - var_11 + 1) - var_8.get_sum(var_16)\n print(*var_7, sep=\"\\n\")\n return\n\n\nif __name__ == \"__main__\":\n func_4()\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\n\nvar_20 = sys.stdin.read\nvar_21 = sys.stdin.readline\nvar_22 = sys.stdin.readlines\nsys.setrecursionlimit(10**9)\nvar_2 = 1 << 60\nvar_5 = 1000000007\n\n\nvar_4 = 1000001\n\n\nclass Class_1:\n def __init__(self, var_13, var_19, var_12):\n self.l = var_13\n self.r = var_19\n self.idx = var_12\n\n\ndef func_4(var_12, var_24, var_10, var_15):\n while var_12 <= var_15:\n var_10[var_12] += var_24\n var_12 += var_12 & -var_12\n\n\ndef func_3(var_12, var_10, var_15):\n var_23 = 0\n while var_12:\n var_23 += var_10[var_12]\n var_12 -= var_12 & -var_12\n return var_23\n\n\ndef func_1(var_9, var_15, var_17, var_16):\n\n var_10 = [0] * (var_15 + 1)\n\n var_14 = [-1] * var_4\n\n var_8 = [0] * var_16\n var_18 = 0\n for var_11 in range(var_15):\n\n if var_14[var_9[var_11]] != -1:\n func_4(var_14[var_9[var_11]] + 1, -1, var_10, var_15)\n\n var_14[var_9[var_11]] = var_11\n func_4(var_11 + 1, 1, var_10, var_15)\n\n while var_18 < var_16 and var_17[var_18].r == var_11:\n var_8[var_17[var_18].idx] = func_3(\n var_17[var_18].r + 1, var_10, var_15\n ) - func_3(var_17[var_18].l, var_10, var_15)\n var_18 += 1\n\n for var_11 in range(var_16):\n print((var_8[var_11]))\n\n\ndef func_2():\n var_6, var_7 = list(map(int, var_21().split()))\n var_1 = list(map(int, var_21().split()))\n (*var_3,) = list(map(int, var_20().split()))\n var_17 = [0] * var_7\n for var_11, (var_13, var_19) in enumerate(zip(*[iter(var_3)] * 2)):\n var_17[var_11] = Class_1(var_13 - 1, var_19 - 1, var_11)\n var_17.sort(key=lambda var_25: var_25.r)\n func_1(var_1, var_6, var_17, var_7)\n return\n\n\nif __name__ == \"__main__\":\n func_2()\n```", "output": "SLOWER 2.1032", "pair_id": "python_p02599_pair0003_reversed", "problem_id": "p02599", "language": "python", "direction": "reversed", "speedup_ratio": 4.2966} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_8 = int(eval(input()))\nvar_4 = []\nfor var_5 in range(var_8):\n var_11 = 0\n var_9 = list(map(int, input().split()))\n for var_6 in range(10):\n var_11 += var_9[var_6] << var_6\n var_4.append(var_11)\nvar_10 = []\nfor var_5 in range(var_8):\n var_10.append(list(map(int, input().split())))\nvar_1 = -(10**12)\nfor var_5 in range(1, 1 << 10):\n var_11 = 0\n for var_6 in range(var_8):\n var_3 = list(bin(var_4[var_6] & var_5)[2:])\n var_2 = 0\n for var_7 in var_3:\n if var_7 == \"1\":\n var_2 += 1\n var_11 += var_10[var_6][var_2]\n var_1 = max(var_1, var_11)\nprint(var_1)\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\n\nvar_8 = sys.stdin.readline\n\n\ndef func_1():\n var_2 = int(eval(var_8()))\n var_1 = [int(var_8().replace(\" \", \"\"), 2) for _ in range(var_2)]\n var_3 = [list(map(int, var_8().split())) for _ in range(var_2)]\n var_4 = -(10**7) * var_2\n for var_7 in range(1, 1 << 10):\n var_10 = 0\n for var_9, var_6 in enumerate(var_1):\n var_5 = bin(var_7 & var_6).count(\"1\")\n var_10 += var_3[var_9][var_5]\n var_4 = max(var_4, var_10)\n print(var_4)\n\n\nif __name__ == \"__main__\":\n func_1()\n```", "output": "FASTER 2.2065", "pair_id": "python_p03503_pair0017_forward", "problem_id": "p03503", "language": "python", "direction": "forward", "speedup_ratio": 4.6157} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_3 = list(map(int, input().split()))\nvar_2 = -1\nfor var_4 in range(10, 12501):\n if int(var_4 * 0.08) == var_1 and int(var_4 * 0.1) == var_3:\n var_2 = var_4\n break\nprint(var_2)\n```\n\n=== Code B (Modified) ===\n```python\nimport math\n\n\ndef func_1():\n var_1, var_2 = list(map(int, input().split()))\n\n var_5 = max(math.ceil(var_1 / 0.08), math.ceil(var_2 / 0.1))\n\n var_4 = min((math.ceil((var_1 + 1) / 0.08), math.ceil((var_2 + 1) / 0.1)))\n\n for var_3 in range(var_5, var_4 + 1):\n if (math.floor(var_3 * 0.08) == var_1) and (math.floor(var_3 * 0.1) == var_2):\n print(var_3)\n quit()\n\n print((-1))\n\n\nif __name__ == \"__main__\":\n func_1()\n```", "output": "FASTER 4.5761", "pair_id": "python_p02755_pair0006_forward", "problem_id": "p02755", "language": "python", "direction": "forward", "speedup_ratio": 23.8532} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\nfrom collections import deque\n\nvar_1 = int(10e10)\nvar_2 = -var_1\nvar_12 = 1000000007\nsys.setrecursionlimit(1000000)\n\n\ndef func_2():\n return list(map(int, input().split()))\n\n\ndef func_4():\n return input().split()\n\n\ndef func_1():\n return int(sys.stdin.readline())\n\n\ndef func_3():\n return eval(input())\n\n\nvar_3, var_4 = func_2()\nvar_6 = [func_2() for var_10 in range(var_3)]\nvar_6.sort()\nvar_7 = 0\nvar_9 = [[0] * var_4 for var_10 in range(var_3 + 1)]\nfor var_10 in range(1, var_3 + 1):\n var_5, var_8 = var_6[var_10 - 1]\n for var_11 in range(var_4):\n if 0 <= var_11 - var_5 < var_4:\n var_9[var_10][var_11] = max(\n var_9[var_10 - 1][var_11], var_9[var_10 - 1][var_11 - var_5] + var_8\n )\n else:\n var_9[var_10][var_11] = var_9[var_10 - 1][var_11]\n else:\n var_7 = max(var_7, var_9[var_10 - 1][-1] + var_8)\nprint(var_7)\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\nfrom operator import itemgetter\nfrom heapq import heapify, heappop, heappush\n\nvar_1 = int(10e15)\nvar_2 = -var_1\nvar_11 = 1000000007\nsys.setrecursionlimit(1000000)\n\n\ndef func_2():\n return list(map(int, input().split()))\n\n\ndef func_4():\n return input().split()\n\n\ndef func_1():\n return int(sys.stdin.readline())\n\n\ndef func_3():\n return eval(input())\n\n\nvar_3, var_4 = func_2()\nvar_5 = [func_2() for var_9 in range(var_3)]\nvar_5.sort(key=itemgetter(0))\n\nvar_8 = [[0] * (var_4 + 1 + 3000 + 1) for _ in range(var_3 + 1)]\nvar_6 = 0\nfor var_9 in range(var_3):\n for var_10 in range(var_4 + 1 + 3000 + 1):\n var_12, var_7 = var_5[var_9]\n if 0 <= var_10 - var_12 < var_4:\n var_8[var_9 + 1][var_10] = max(\n var_8[var_9][var_10], var_8[var_9][var_10 - var_12] + var_7\n )\n else:\n var_8[var_9 + 1][var_10] = var_8[var_9][var_10]\n var_6 = max(var_6, var_8[var_9 + 1][var_10])\nprint(var_6)\n```", "output": "SLOWER 4.73", "pair_id": "python_p02863_pair0019_reversed", "problem_id": "p02863", "language": "python", "direction": "reversed", "speedup_ratio": 26.5378} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\nimport itertools\n\n\ndef func_2(var_4):\n return eval(\"0b\" + var_4)\n\n\ndef func_1():\n var_4 = int(sys.stdin.readline().rstrip())\n var_9 = [\n func_2(\"\".join(str(var_10) for var_10 in sys.stdin.readline().split()))\n for _ in range(var_4)\n ]\n var_8 = [\n [int(var_10) for var_10 in sys.stdin.readline().split()] for _ in range(var_4)\n ]\n var_3 = -(10**10)\n for var_6 in itertools.product(\"01\", repeat=10):\n var_6 = func_2(\"\".join(var_6))\n if var_6 == 0:\n continue\n var_7 = 0\n for var_2 in range(var_4):\n var_1 = var_9[var_2]\n var_5 = bin(var_1 & var_6).count(\"1\")\n var_7 += var_8[var_2][var_5]\n var_3 = max(var_3, var_7)\n print(var_3)\n\n\nif __name__ == \"__main__\":\n\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nfrom sys import stdin\n\n\ndef func_1():\n\n var_11 = stdin.readline\n var_2 = int(var_11())\n var_1 = []\n for var_6 in range(var_2):\n var_5 = int(\"\".join(var_11().strip().split(\" \")), 2)\n var_1.append(var_5)\n var_3 = []\n for var_6 in range(var_2):\n var_10 = list(map(int, var_11().split()))\n var_3.append(var_10)\n var_8 = float(\"-inf\")\n for var_9 in range(1, 1 << 10):\n var_12 = 0\n for var_7 in range(var_2):\n var_4 = bin(var_9 & var_1[var_7]).count(\"1\")\n var_12 += var_3[var_7][var_4]\n var_8 = max(var_12, var_8)\n print(var_8)\n\n\nif __name__ == \"__main__\":\n func_1()\n```", "output": "FASTER 3.2765", "pair_id": "python_p03503_pair0013_forward", "problem_id": "p03503", "language": "python", "direction": "forward", "speedup_ratio": 9.6901} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport math\nimport string\n\n\ndef func_5():\n return list(map(int, input().split()))\n\n\ndef func_4(var_7, var_8):\n return math.factorial(var_7) // (\n math.factorial(var_7 - var_8) * math.factorial(var_8)\n )\n\n\ndef func_3(var_10):\n var_9 = []\n for var_5 in var_10:\n if not (var_5 in var_9):\n var_9.append(var_5)\n return len(var_10) != len(var_9)\n\n\ndef func_1(var_7):\n func_1 = []\n for var_4 in range(1, var_7 + 1):\n if var_7 % var_4 == 0:\n func_1.append(var_4)\n return func_1\n\n\nvar_2 = [-1, -1, -1, 0, 0, 1, 1, 1]\nvar_3 = [-1, 0, 1, -1, 1, -1, 0, 1]\nvar_7 = int(eval(input()))\nvar_1 = func_5()\n\n\ndef func_2(var_6):\n if len(var_6) == var_7:\n for var_4 in range(len(var_6)):\n if var_6[var_4] % 2 == 0:\n return 1\n return 0\n return (\n func_2(var_6 + [var_1[len(var_6)]])\n + func_2(var_6 + [var_1[len(var_6)] - 1])\n + func_2(var_6 + [var_1[len(var_6)] + 1])\n )\n\n\nprint((func_2([])))\n```\n\n=== Code B (Modified) ===\n```python\ndef func_1():\n var_2 = int(eval(input()))\n var_1 = [int(var_6) for var_6 in input().split()]\n var_4 = 3**var_2\n var_5 = len([var_3 for var_3 in var_1 if var_3 % 2 == 0])\n var_4 -= 2**var_5\n print(var_4)\n\n\nif __name__ == \"__main__\":\n func_1()\n```", "output": "FASTER 7.1332", "pair_id": "python_p03568_pair0001_forward", "problem_id": "p03568", "language": "python", "direction": "forward", "speedup_ratio": 140.3806} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_4, var_3 = list(map(int, input().split()))\nvar_1 = 0\nfor var_2 in range(var_4, var_3 + 1):\n if str(var_2)[0] + str(var_2)[1] == str(var_2)[-1] + str(var_2)[-2]:\n var_1 += 1\nprint(var_1)\n```\n\n=== Code B (Modified) ===\n```python\ndef func_1():\n var_1, var_2 = list(map(int, input().rstrip().split()))\n var_3 = 0\n for var_4 in range(var_1, var_2 + 1):\n var_5 = str(var_4)\n if var_5 == var_5[::-1]:\n var_3 += 1\n print(var_3)\n\n\nif __name__ == \"__main__\":\n func_1()\n```", "output": "FASTER 2.0871", "pair_id": "python_p03416_pair0109_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 4.2489} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_2 = int(eval(input()))\n(*var_1,) = list(map(int, input().split()))\nvar_5 = 0\nfor var_3 in var_1:\n if var_3 % 2 == 0:\n var_5 += 1\nvar_4 = 3**var_2 - 2**var_5\nprint(var_4)\n```\n\n=== Code B (Modified) ===\n```python\nimport numpy as np\nfrom itertools import product\n\nvar_6 = int(eval(input()))\nvar_2 = list(map(int, input().split()))\nvar_2 = np.array(var_2)\nvar_5 = [-1, 0, 1]\nvar_3 = 0\nfor var_7 in product(var_5, repeat=var_6):\n var_7 = np.array(var_7)\n var_1 = var_2 + var_7\n var_4 = var_1.cumprod()\n if var_4[-1] % 2 == 0:\n var_3 += 1\nprint(var_3)\n```", "output": "SLOWER 10.028", "pair_id": "python_p03568_pair0017_reversed", "problem_id": "p03568", "language": "python", "direction": "reversed", "speedup_ratio": 1044.0343} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nfrom functools import reduce\nfrom itertools import product\n\nvar_2 = int(eval(input()))\n(*var_1,) = list(map(int, input().split()))\nvar_4 = 0\nfor var_7 in product([-1, 0, 1], repeat=var_2):\n var_6 = reduce(\n lambda var_8, var_9: var_8 * var_9,\n [var_3 + var_7[var_5] for var_5, var_3 in enumerate(var_1)],\n )\n if var_6 % 2 == 0:\n var_4 += 1\nprint(var_4)\n```\n\n=== Code B (Modified) ===\n```python\nvar_2 = int(eval(input()))\nvar_1 = list(map(int, input().split()))\nvar_4 = 1\nfor var_3 in range(var_2):\n if var_1[var_3] % 2 == 0:\n var_4 *= 2\nprint((3**var_2 - var_4))\n```", "output": "FASTER 9.7762", "pair_id": "python_p03568_pair0018_forward", "problem_id": "p03568", "language": "python", "direction": "forward", "speedup_ratio": 876.8612} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\n\nvar_12 = sys.stdin.readline\nvar_2 = int(eval(var_12()))\nvar_9 = [[] for _ in range(var_2)]\nvar_1 = {}\nfor var_10 in range(var_2 - 1):\n var_4, var_6 = list(map(int, var_12().split()))\n var_9[var_4 - 1].append(var_6 - 1)\n var_9[var_6 - 1].append(var_4 - 1)\n var_1[(var_4 - 1) * var_2 + var_6 - 1] = var_10\n var_1[(var_6 - 1) * var_2 + var_4 - 1] = var_10\nvar_15 = [0]\nvar_8 = [False] * var_2\nvar_8[0] = True\nvar_3 = [None] * var_2\nvar_3[0] = 0\nvar_5 = [None] * (var_2 - 1)\nwhile var_15:\n var_16 = []\n for var_14 in var_15:\n var_7 = var_3[var_14]\n var_17 = 1\n for var_13 in var_9[var_14]:\n if not var_8[var_13]:\n var_8[var_13] = True\n var_16.append(var_13)\n var_11 = var_1[var_14 * var_2 + var_13]\n if var_17 == var_7:\n var_17 += 1\n var_5[var_11] = var_17\n var_3[var_13] = var_17\n var_17 += 1\n var_15 = var_16\nprint((max(var_5)))\nfor var_4 in var_5:\n print(var_4)\n```\n\n=== Code B (Modified) ===\n```python\nimport copy\n\nvar_8 = int(eval(input()))\nvar_10 = set([var_6 for var_6 in range(1, 10**5)])\nvar_5 = []\nvar_11 = {}\nvar_9 = []\nfor var_6 in range(var_8 - 1):\n var_1, var_2 = list(map(int, input().split(\" \")))\n var_5.append([var_1, var_2])\n var_11.setdefault(var_1, []).append(var_2)\n var_9.append([])\nvar_9.append([])\nvar_9.append([])\nvar_7 = 0\nfor var_12 in range(1, var_8 + 1):\n var_14 = var_11.get(var_12, [])\n var_3 = 1\n for var_13 in var_14:\n if var_3 in var_9[var_12]:\n var_3 += 1\n else:\n pass\n var_9[var_13].append(var_3)\n if var_3 >= var_7:\n var_7 = var_3\n var_3 += 1\nprint(var_7)\nfor var_4 in var_5:\n print((var_9[var_4[1]][0]))\n```", "output": "SLOWER 4.2702", "pair_id": "python_p02850_pair0019_reversed", "problem_id": "p02850", "language": "python", "direction": "reversed", "speedup_ratio": 19.2961} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n if list(str(var_4)) == list(reversed(str(var_4))):\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_4 = str(var_4)\n if var_4[0] == var_4[-1] and var_4[1] == var_4[-2]:\n var_3 += 1\nprint(var_3)\n```", "output": "FASTER 1.584", "pair_id": "python_p03416_pair0110_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 2.9981} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\n\nvar_7 = sys.stdin.readline\nfrom itertools import combinations\n\n\ndef func_3(var_10):\n for _ in range(var_10):\n yield list(map(int, var_7().split()))\n\n\ndef func_1(var_9, var_5, var_11):\n var_3 = len([0 for var_8 in var_9 if var_5[var_8] == 1])\n return var_11[var_3]\n\n\ndef func_2():\n var_10 = int(eval(var_7()))\n var_1 = list(func_3(var_10))\n var_2 = list(func_3(var_10))\n for var_6 in range(1, 11):\n for var_4 in combinations(list(range(10)), var_6):\n yield sum(\n func_1(var_4, var_5, var_11) for var_5, var_11 in zip(var_1, var_2)\n )\n\n\nprint((max(func_2())))\n```\n\n=== Code B (Modified) ===\n```python\nvar_8 = int(eval(input()))\nvar_4 = []\nfor var_5 in range(var_8):\n var_11 = 0\n var_9 = list(map(int, input().split()))\n for var_6 in range(10):\n var_11 += var_9[var_6] << var_6\n var_4.append(var_11)\nvar_10 = []\nfor var_5 in range(var_8):\n var_10.append(list(map(int, input().split())))\nvar_1 = -(10**12)\nfor var_5 in range(1, 1 << 10):\n var_11 = 0\n for var_6 in range(var_8):\n var_3 = list(bin(var_4[var_6] & var_5)[2:])\n var_2 = 0\n for var_7 in var_3:\n if var_7 == \"1\":\n var_2 += 1\n var_11 += var_10[var_6][var_2]\n var_1 = max(var_1, var_11)\nprint(var_1)\n```", "output": "SLOWER 1.0894", "pair_id": "python_p03503_pair0018_reversed", "problem_id": "p03503", "language": "python", "direction": "reversed", "speedup_ratio": 2.1279} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_4 = str(var_4)\n if var_4[0] == var_4[-1] and var_4[1] == var_4[-2]:\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().rstrip().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = list(map(int, list(str(var_4))))\n if var_5[0] == var_5[4] and var_5[1] == var_5[3]:\n var_3 += 1\nprint(var_3)\n```", "output": "SLOWER 1.8667", "pair_id": "python_p03416_pair0069_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 3.6471} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\n\nvar_7 = sys.stdin.readline\nfrom itertools import combinations\n\n\ndef func_3(var_10):\n for _ in range(var_10):\n yield list(map(int, var_7().split()))\n\n\ndef func_1(var_9, var_5, var_11):\n var_3 = sum(1 if var_5[var_8] == 1 else 0 for var_8 in var_9)\n return var_11[var_3]\n\n\ndef func_2():\n var_10 = int(eval(var_7()))\n var_1 = list(func_3(var_10))\n var_2 = list(func_3(var_10))\n for var_6 in range(1, 11):\n for var_4 in combinations(list(range(10)), var_6):\n yield sum(\n func_1(var_4, var_5, var_11) for var_5, var_11 in zip(var_1, var_2)\n )\n\n\nprint((max(func_2())))\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\nimport numpy as np\n\nvar_5 = sys.stdin.readline\n\nvar_7 = int(eval(var_5()))\n\nvar_1 = [var_5().replace(\" \", \"\") for var_4 in range(var_7)]\n\nvar_8 = [list(map(int, var_5().split())) for var_4 in range(var_7)]\n\n\nvar_12 = -999999999999999\n\nfor var_4 in range(1, 1024):\n\n var_3 = format(var_4, \"010b\")\n\n var_10 = 0\n for var_2, var_9 in zip(var_1, var_8):\n\n var_11 = 0\n for var_6 in range(10):\n\n if var_2[var_6] == \"1\" and var_3[var_6] == \"1\":\n\n var_11 += 1\n\n var_10 += var_9[var_11]\n if var_10 > var_12:\n\n var_12 = var_10\nprint(var_12)\n```", "output": "SLOWER 1.0796", "pair_id": "python_p03503_pair0019_reversed", "problem_id": "p03503", "language": "python", "direction": "reversed", "speedup_ratio": 2.1134} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_6 in range(var_1, var_2 + 1):\n var_3 = str(var_6)\n var_5 = True\n for var_7 in range(len(var_3) // 2):\n if var_3[var_7] != var_3[-var_7 - 1] and var_5:\n var_5 = not var_5\n if var_5:\n var_4 += 1\nprint(var_4)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_5 in range(var_1, var_2 + 1):\n var_3 = str(var_5)\n if var_3[0] == var_3[-1] and var_3[1] == var_3[-2]:\n var_4 += 1\nprint(var_4)\n```", "output": "FASTER 1.5515", "pair_id": "python_p03416_pair0111_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 2.9313} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_6 = sorted([list(map(int, input().split())) for var_5 in range(var_1)])\n\nvar_4 = [[0] * (var_2 + 1) for var_5 in range(var_1 + 1)]\n\nfor var_5 in range(var_1):\n var_9, var_8 = var_6[var_5]\n for var_7 in range(var_2 + 1):\n if var_7 + var_9 <= var_2:\n var_4[var_5 + 1][var_7 + var_9] = max(\n var_4[var_5 + 1][var_7 + var_9], var_4[var_5][var_7] + var_8\n )\n var_4[var_5 + 1][var_7] = max(var_4[var_5][var_7], var_4[var_5 + 1][var_7])\nvar_3 = 0\nfor var_5, (var_9, var_8) in enumerate(var_6):\n for var_7 in range(var_2):\n var_3 = max(var_3, var_4[var_5][var_7] + var_8)\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\ndef func_1():\n var_2, var_3, *var_1 = list(map(int, open(0).read().split()))\n var_4 = [0] * (var_3 + max(var_1[::2]))\n for var_7, var_6 in sorted(zip(*[iter(var_1)] * 2)):\n for var_5 in reversed(list(range(var_3))):\n var_4[var_5 + var_7] = max(var_4[var_5 + var_7], var_4[var_5] + var_6)\n print((max(var_4)))\n\n\nfunc_1()\n```", "output": "FASTER 2.0608", "pair_id": "python_p02863_pair0021_forward", "problem_id": "p02863", "language": "python", "direction": "forward", "speedup_ratio": 4.1721} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_8 = int(eval(input()))\nvar_6 = []\nfor var_7 in range(var_8 - 1):\n var_1, var_3 = list(map(int, input().split()))\n var_6.append([var_1 - 1, var_3 - 1, var_7])\nvar_6.sort()\nvar_12 = [0] * (var_8)\nvar_2 = [0] * (var_8 - 1)\nvar_9 = 1\nvar_10 = 0\nfor var_5 in var_6:\n _from, var_11, var_7 = var_5\n if _from != var_10:\n var_9 = 1\n if var_12[_from] == var_9:\n var_9 += 1\n var_2[var_7] = var_9\n var_12[var_11] = var_9\n var_9 += 1\n var_10 = _from\nprint((max(var_2)))\nfor var_4 in var_2:\n print(var_4)\n```\n\n=== Code B (Modified) ===\n```python\nimport copy\n\nvar_8 = int(eval(input()))\nvar_10 = set([var_6 for var_6 in range(1, 10**5)])\nvar_5 = []\nvar_11 = {}\nvar_9 = []\nfor var_6 in range(var_8 - 1):\n var_1, var_2 = list(map(int, input().split(\" \")))\n var_5.append([var_1, var_2])\n var_11.setdefault(var_1, []).append(var_2)\n var_9.append([])\nvar_9.append([])\nvar_9.append([])\nvar_7 = 0\nfor var_12 in range(1, var_8 + 1):\n var_14 = var_11.get(var_12, [])\n var_3 = 1\n for var_13 in var_14:\n if var_3 in var_9[var_12]:\n var_3 += 1\n else:\n pass\n var_9[var_13].append(var_3)\n if var_3 >= var_7:\n var_7 = var_3\n var_3 += 1\nprint(var_7)\nfor var_4 in var_5:\n print((var_9[var_4[1]][0]))\n```", "output": "SLOWER 4.8668", "pair_id": "python_p02850_pair0017_reversed", "problem_id": "p02850", "language": "python", "direction": "reversed", "speedup_ratio": 29.178} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\nimport numpy as np\n\nvar_5 = sys.stdin.readline\n\nvar_7 = int(eval(var_5()))\n\nvar_1 = [var_5().replace(\" \", \"\") for var_4 in range(var_7)]\n\nvar_8 = [list(map(int, var_5().split())) for var_4 in range(var_7)]\n\n\nvar_12 = -999999999999999\n\nfor var_4 in range(1, 1024):\n\n var_3 = format(var_4, \"010b\")\n\n var_10 = 0\n for var_2, var_9 in zip(var_1, var_8):\n\n var_11 = 0\n for var_6 in range(10):\n\n if var_2[var_6] == \"1\" and var_3[var_6] == \"1\":\n\n var_11 += 1\n\n var_10 += var_9[var_11]\n if var_10 > var_12:\n\n var_12 = var_10\nprint(var_12)\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\nimport itertools\n\n\ndef func_2(var_4):\n return bin(eval(\"0b\" + str(var_4)))\n\n\ndef func_1():\n var_4 = int(sys.stdin.readline().rstrip())\n var_9 = [\n func_2(\"\".join(str(var_10) for var_10 in sys.stdin.readline().split()))\n for _ in range(var_4)\n ]\n var_8 = [\n [int(var_10) for var_10 in sys.stdin.readline().split()] for _ in range(var_4)\n ]\n var_3 = -(10**10)\n for var_6 in itertools.product(\"01\", repeat=10):\n var_6 = func_2(\"\".join(var_6))\n if var_6 == \"0b0\":\n continue\n var_7 = 0\n for var_2 in range(var_4):\n var_1 = var_9[var_2]\n var_5 = bin(eval(var_1) & eval(var_6)).count(\"1\")\n var_7 += var_8[var_2][var_5]\n var_3 = max(var_3, var_7)\n print(var_3)\n\n\nif __name__ == \"__main__\":\n\n func_1()\n```", "output": "SLOWER 2.5695", "pair_id": "python_p03503_pair0020_reversed", "problem_id": "p03503", "language": "python", "direction": "reversed", "speedup_ratio": 5.9361} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\n\nvar_9 = sys.stdin.readline\nfrom operator import itemgetter\n\nvar_3, var_4 = list(map(int, var_9().split()))\nvar_1 = [list(map(int, var_9().split())) for _ in range(var_3)]\nvar_1.sort(key=itemgetter(0))\nvar_8 = [[0 for _ in range(var_3 + 1)] for _ in range(var_4 + 1)]\n\nvar_2 = []\nfor var_10 in range(var_3):\n var_5, var_7 = var_1[var_10]\n for var_11 in range(var_4):\n if var_5 > var_11:\n var_8[var_11][var_10 + 1] = var_8[var_11][var_10]\n else:\n if var_7 + var_8[var_11 - var_5][var_10] >= var_8[var_11][var_10]:\n var_8[var_11][var_10 + 1] = var_8[var_11 - var_5][var_10] + var_7\n else:\n var_8[var_11][var_10 + 1] = var_8[var_11][var_10]\n var_2.append(var_8[var_4 - 1][var_10] + var_7)\nvar_6 = max(var_2)\nprint(var_6)\n```\n\n=== Code B (Modified) ===\n```python\nvar_6, var_7 = list(map(int, input().split()))\nvar_1 = [list(map(int, input().split())) for _ in range(var_6)]\nvar_1.sort()\nvar_3 = [(6007) * [0] for _ in range(var_6 + 1)]\nvar_3[0][0] = 0\nvar_2 = 0\nfor var_4 in range(var_6):\n for var_5 in range(6007):\n var_3[var_4 + 1][var_5] = max(var_3[var_4 + 1][var_5], var_3[var_4][var_5])\n if var_5 < var_7:\n var_3[var_4 + 1][var_5 + var_1[var_4][0]] = max(\n var_3[var_4][var_5] + var_1[var_4][1],\n var_3[var_4][var_5 + var_1[var_4][0]],\n )\n var_2 = max(var_2, var_3[var_4 + 1][var_5])\nprint(var_2)\n```", "output": "SLOWER 5.7437", "pair_id": "python_p02863_pair0026_reversed", "problem_id": "p02863", "language": "python", "direction": "reversed", "speedup_ratio": 53.5847} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_6 = input()[::-1]\nvar_4 = len(var_6)\nvar_2 = [0] * 2019\nvar_2[0] = 1\nvar_7 = 1\nvar_5 = 0\nvar_1 = 0\nfor var_3 in range(var_4):\n var_5 = (var_5 + int(var_6[var_3]) * var_7) % 2019\n var_7 = var_7 * 10 % 2019\n var_2[var_5] += 1\nfor var_3 in var_2:\n var_1 += var_3 * (var_3 - 1) // 2\nprint(var_1)\n```\n\n=== Code B (Modified) ===\n```python\nvar_6 = 2019\nvar_1 = [0] * var_6\nvar_3 = 1\nvar_5 = var_4 = 0\nfor var_2 in input()[::-1]:\n var_1[var_4] += 1\n var_4 -= int(var_2) * var_3\n var_4 %= var_6\n var_5 += var_1[var_4]\n var_3 *= 10\n var_3 %= var_6\nprint(var_5)\n```", "output": "FASTER 2.8807", "pair_id": "python_p02702_pair0006_forward", "problem_id": "p02702", "language": "python", "direction": "forward", "speedup_ratio": 7.3649} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_3, var_8 = list(map(int, input().split()))\nvar_2 = list(map(int, input().split()))\nvar_4 = list(map(int, input().split()))\nvar_7 = min(var_2) + min(var_4)\nvar_9 = [0] * var_8\nvar_10 = [0] * var_8\nvar_5 = [0] * var_8\nfor var_6 in range(var_8):\n var_9[var_6], var_10[var_6], var_5[var_6] = list(map(int, input().split()))\n var_9[var_6] -= 1\n var_10[var_6] -= 1\nfor var_6 in range(var_8):\n var_7 = min(var_7, var_2[var_9[var_6]] + var_4[var_10[var_6]] - var_5[var_6])\nprint(var_7)\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\nfrom collections import Counter\n\n\ndef func_10():\n return sys.stdin.readline().strip()\n\n\ndef func_11(var_12, var_13, var_14):\n return [[var_14] * var_13 for var_17 in range(var_12)]\n\n\ndef func_12(var_12, var_13, var_14, var_15):\n return [[[var_15] * var_14 for var_18 in range(var_13)] for var_17 in range(var_12)]\n\n\ndef func_13(var_12, var_13, var_14, var_15, var_16):\n return [\n [[[var_16] * var_15 for var_18 in range(var_14)] for var_18 in range(var_13)]\n for var_17 in range(var_12)\n ]\n\n\ndef func_8(var_22, var_23=1):\n return int(-(-var_22 // var_23))\n\n\ndef func_1():\n return int(eval(func_10()))\n\n\ndef func_3():\n return list(map(int, func_10().split()))\n\n\ndef func_2(var_11=None):\n return list(func_3()) if var_11 is None else [func_1() for var_17 in range(var_11)]\n\n\ndef func_7():\n print(\"Yes\")\n\n\ndef func_5():\n print(\"No\")\n\n\ndef func_6():\n print(\"YES\")\n\n\ndef func_4():\n print(\"NO\")\n\n\nsys.setrecursionlimit(10**9)\nvar_5 = 10**18\nvar_10 = 10**9 + 7\n\n\ndef func_9(var_1, var_2):\n \"\"\"\"\"\"\n import numpy as np\n from numpy.fft import rfft, irfft\n\n var_8 = max(var_1)\n var_9 = max(var_2)\n var_3 = [0] * (var_8 + 1)\n var_4 = [0] * (var_9 + 1)\n for var_12 in var_1:\n var_3[var_12] += 1\n for var_13 in var_2:\n var_4[var_13] += 1\n\n var_6 = 1\n var_19 = 0\n while var_6 <= var_8 + var_9:\n var_19 += 1\n var_6 = 2**var_19\n\n var_21 = irfft(rfft(var_3, var_6) * rfft(var_4, var_6), var_6)\n\n var_21 = np.rint(var_21).astype(np.int64)\n return var_21\n\n\nvar_11, var_7, var_6 = func_3()\nvar_1 = func_2()\nvar_2 = func_2()\nvar_21 = list(func_9(var_1, var_2))\nvar_20 = var_5\nfor var_17, var_12 in enumerate(var_21):\n if var_12 != 0:\n var_20 = var_17\n break\nfor _ in range(var_6):\n var_22, var_23, var_14 = func_3()\n var_22 -= 1\n var_23 -= 1\n var_20 = min(var_20, var_1[var_22] + var_2[var_23] - var_14)\nprint(var_20)\n```", "output": "SLOWER 2.762", "pair_id": "python_p02748_pair0005_reversed", "problem_id": "p02748", "language": "python", "direction": "reversed", "speedup_ratio": 6.7835} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\nfrom collections import Counter\n\n\ndef func_10():\n return sys.stdin.readline().strip()\n\n\ndef func_11(var_12, var_13, var_14):\n return [[var_14] * var_13 for var_17 in range(var_12)]\n\n\ndef func_12(var_12, var_13, var_14, var_15):\n return [[[var_15] * var_14 for var_18 in range(var_13)] for var_17 in range(var_12)]\n\n\ndef func_13(var_12, var_13, var_14, var_15, var_16):\n return [\n [[[var_16] * var_15 for var_18 in range(var_14)] for var_18 in range(var_13)]\n for var_17 in range(var_12)\n ]\n\n\ndef func_8(var_22, var_23=1):\n return int(-(-var_22 // var_23))\n\n\ndef func_1():\n return int(eval(func_10()))\n\n\ndef func_3():\n return list(map(int, func_10().split()))\n\n\ndef func_2(var_11=None):\n return list(func_3()) if var_11 is None else [func_1() for var_17 in range(var_11)]\n\n\ndef func_7():\n print(\"Yes\")\n\n\ndef func_5():\n print(\"No\")\n\n\ndef func_6():\n print(\"YES\")\n\n\ndef func_4():\n print(\"NO\")\n\n\nsys.setrecursionlimit(10**9)\nvar_5 = 10**18\nvar_10 = 10**9 + 7\n\n\ndef func_9(var_1, var_2):\n \"\"\"\"\"\"\n import numpy as np\n from numpy.fft import rfft, irfft\n\n var_8 = max(var_1)\n var_9 = max(var_2)\n var_3 = [0] * (var_8 + 1)\n var_4 = [0] * (var_9 + 1)\n for var_12 in var_1:\n var_3[var_12] += 1\n for var_13 in var_2:\n var_4[var_13] += 1\n\n var_6 = 1\n var_19 = 0\n while var_6 <= var_8 + var_9:\n var_19 += 1\n var_6 = 2**var_19\n\n var_21 = irfft(rfft(var_3, var_6) * rfft(var_4, var_6), var_6)\n\n var_21 = np.rint(var_21).astype(np.int64)\n return var_21\n\n\nvar_11, var_7, var_6 = func_3()\nvar_1 = func_2()\nvar_2 = func_2()\nvar_21 = list(func_9(var_1, var_2))\nvar_20 = var_5\nfor var_17, var_12 in enumerate(var_21):\n if var_12 != 0:\n var_20 = var_17\n break\nfor _ in range(var_6):\n var_22, var_23, var_14 = func_3()\n var_22 -= 1\n var_23 -= 1\n var_20 = min(var_20, var_1[var_22] + var_2[var_23] - var_14)\nprint(var_20)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2, var_3 = list(map(int, input().split()))\nvar_4 = list(map(int, input().split()))\nvar_6 = list(map(int, input().split()))\nvar_5 = min(var_4) + min(var_6)\nfor var_8 in range(var_3):\n var_7 = list(map(int, input().split()))\n var_9 = var_4[var_7[0] - 1] + var_6[var_7[1] - 1] - var_7[2]\n var_5 = min(var_9, var_5)\nprint(var_5)\n```", "output": "FASTER 3.1615", "pair_id": "python_p02748_pair0006_forward", "problem_id": "p02748", "language": "python", "direction": "forward", "speedup_ratio": 8.9474} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_5 in range(10):\n for var_6 in range(10):\n for var_7 in range(10):\n var_3 = 10000 * var_5 + 1000 * var_6 + 100 * var_7 + 10 * var_6 + var_5\n if var_1 <= var_3 <= var_2:\n var_4 += 1\nprint(var_4)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = list(str(var_4))\n if var_5 == list(reversed(var_5)):\n var_3 += 1\nprint(var_3)\n```", "output": "SLOWER 5.0577", "pair_id": "python_p03416_pair0112_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 33.3066} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1 = list(map(int, input().split()))\nvar_2 = 0\nfor var_3 in range(var_1[0], var_1[1] + 1):\n var_4 = str(var_3)\n if var_4[0] == var_4[4] and var_4[1] == var_4[3]:\n var_2 += 1\nprint(var_2)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_3 in range(var_1, var_2 + 1):\n var_5 = list(str(var_3))\n var_6 = list(reversed(var_5))\n if var_5 == var_6:\n var_4 += 1\nprint(var_4)\n```", "output": "SLOWER 1.5975", "pair_id": "python_p03416_pair0113_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 3.0261} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_5 in range(10):\n for var_6 in range(10):\n for var_7 in range(10):\n var_3 = 10000 * var_5 + 1000 * var_6 + 100 * var_7 + 10 * var_6 + var_5\n if var_1 <= var_3 <= var_2:\n var_4 += 1\nprint(var_4)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_8 in range(var_1, var_2 + 1):\n var_7 = str(var_8)\n var_6 = len(var_7)\n var_4 = True\n for var_5 in range(var_6 // 2):\n if var_7[var_5] != var_7[var_6 - 1 - var_5]:\n var_4 = False\n break\n if var_4:\n var_3 += 1\nprint(var_3)\n```", "output": "SLOWER 4.9518", "pair_id": "python_p03416_pair0114_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 30.9483} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_4 = {}\nvar_5 = 0\nfor var_6 in range(10000, 100000):\n var_3 = list(str(var_6))\n if var_3 == list(reversed(var_3)):\n var_5 += 1\n var_4[var_6] = var_5\nvar_1, var_2 = list(map(int, input().split()))\nprint((var_4[var_2] - var_4[var_1 - 1] if var_1 > 10000 else var_4[var_2]))\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = [\n var_3 for var_3 in map(str, list(range(var_1, var_2 + 1))) if var_3 == var_3[::-1]\n]\nprint((len(var_4)))\n```", "output": "FASTER 4.2722", "pair_id": "python_p03416_pair0046_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 19.3219} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nfrom collections import Counter\n\nvar_4 = int(eval(input()))\nvar_1 = list(map(int, input().split()))\nvar_2 = Counter(var_1)\nvar_3 = list(var_2.keys())\nvar_5 = list(var_2.values())\nif (\n len(var_2) == 3\n and var_3[0] ^ var_3[1] ^ var_3[2] == 0\n and var_5[0] == var_5[1] == var_5[2]\n):\n print(\"Yes\")\nelif (\n len(var_2) == 2\n and 0 in var_3\n and (var_5[0] == var_5[1] * 2 or var_5[1] == var_5[0] * 2)\n):\n print(\"Yes\")\nelif len(var_2) == 1 and 0 in var_3:\n print(\"Yes\")\nelse:\n print(\"No\")\n```\n\n=== Code B (Modified) ===\n```python\n_, var_1 = open(0)\nvar_1, *var_2 = list(map(int, var_1.split()))\nfor var_2 in var_2:\n var_1 ^= var_2\nprint((\"YNeos\"[var_1 > 0 :: 2]))\n```", "output": "FASTER 1.0753", "pair_id": "python_p02975_pair0003_forward", "problem_id": "p02975", "language": "python", "direction": "forward", "speedup_ratio": 2.1071} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\nimport math\nfrom collections import defaultdict\nfrom bisect import bisect_left, bisect_right\n\nsys.setrecursionlimit(10**7)\n\n\ndef func_4():\n return sys.stdin.readline()[:-1]\n\n\nvar_4 = 10**9 + 7\n\n\ndef func_1():\n return int(eval(func_4()))\n\n\ndef func_2():\n return list(map(int, func_4().split()))\n\n\ndef func_3(var_6, var_3):\n if var_6 <= 0:\n return [[] for _ in range(var_3)]\n elif var_3 == 1:\n return [func_1() for _ in range(var_6)]\n else:\n var_5 = [func_2() for _ in range(var_6)]\n return list(map(list, list(zip(*var_5))))\n\n\nvar_1, var_2 = list(map(str, func_4().split()))\nvar_1 = int(var_1)\nvar_2 = 100 * int(var_2[0]) + 10 * int(var_2[2]) + int(var_2[3])\nprint((var_1 * var_2 // 100))\n```\n\n=== Code B (Modified) ===\n```python\nfrom fractions import Fraction\n\nvar_1, var_2 = input().split()\n\n\nfrom decimal import *\n\nvar_4 = var_3(var_1)\nvar_6 = var_3(var_2)\nvar_7().prec = 28\nvar_5 = var_4 * var_6\nprint((int(var_5)))\n```", "output": "FASTER 1.9202", "pair_id": "python_p02659_pair0025_forward", "problem_id": "p02659", "language": "python", "direction": "forward", "speedup_ratio": 3.7848} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_3 = list(map(int, input().split()))\nvar_2 = 0\nfor var_5 in range(var_3 + 1)[var_1:]:\n if len(str(var_5)) % 2 == 0:\n var_6 = list(str(var_5))[: len(str(var_5)) // 2]\n var_7 = list(reversed(list(str(var_5))[len(str(var_5)) // 2 :]))\n if var_6 == var_7:\n var_2 += 1\n else:\n var_8 = list(str(var_5))[: len(str(var_5)) // 2 + 1]\n var_4 = list(reversed(list(str(var_5))[len(str(var_5)) // 2 :]))\n if var_8 == var_4:\n var_2 += 1\nprint(var_2)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_6 in range(var_1, var_2 + 1):\n var_3 = str(var_6)\n var_5 = True\n for var_7 in range(len(var_3) // 2):\n if var_3[var_7] != var_3[-var_7 - 1] and var_5:\n var_5 = not var_5\n if var_5:\n var_4 += 1\nprint(var_4)\n```", "output": "FASTER 1.0146", "pair_id": "python_p03416_pair0115_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 2.0203} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1 = list(map(int, input().split()))\nvar_2 = 0\nfor var_3 in range(var_1[0], var_1[1] + 1):\n var_4 = str(var_3)\n if var_4[0] == var_4[4] and var_4[1] == var_4[3]:\n var_2 += 1\nprint(var_2)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_3 = list(map(int, input().split()))\nvar_2 = 0\nfor var_5 in range(var_3 + 1)[var_1:]:\n if len(str(var_5)) % 2 == 0:\n var_6 = list(str(var_5))[: len(str(var_5)) // 2]\n var_7 = list(reversed(list(str(var_5))[len(str(var_5)) // 2 :]))\n if var_6 == var_7:\n var_2 += 1\n else:\n var_8 = list(str(var_5))[: len(str(var_5)) // 2 + 1]\n var_4 = list(reversed(list(str(var_5))[len(str(var_5)) // 2 :]))\n if var_8 == var_4:\n var_2 += 1\nprint(var_2)\n```", "output": "SLOWER 2.7633", "pair_id": "python_p03416_pair0116_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 6.7897} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\n\nvar_8 = sys.stdin.readline\n\n\ndef func_1():\n var_2 = int(eval(var_8()))\n var_1 = []\n for _ in range(var_2):\n var_1.append(list(map(int, var_8().split())))\n var_3 = []\n for _ in range(var_2):\n var_3.append(list(map(int, var_8().split())))\n var_4 = -(10**7) * var_2\n for var_7 in range(1, 1 << 10):\n var_11 = 0\n for var_10, var_6 in enumerate(var_1):\n var_5 = 0\n for var_9 in range(10):\n if (var_7 >> var_9) & 1 & var_6[var_9]:\n var_5 += 1\n var_11 += var_3[var_10][var_5]\n var_4 = max(var_4, var_11)\n print(var_4)\n\n\nif __name__ == \"__main__\":\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\n\nvar_8 = sys.stdin.readline\n\n\ndef func_1():\n var_2 = int(eval(var_8()))\n var_1 = [int(var_8().replace(\" \", \"\"), 2) for _ in range(var_2)]\n var_3 = [list(map(int, var_8().split())) for _ in range(var_2)]\n var_4 = -(10**7) * var_2\n for var_7 in range(1, 1 << 10):\n var_10 = 0\n for var_9, var_6 in enumerate(var_1):\n var_5 = bin(var_7 & var_6).count(\"1\")\n var_10 += var_3[var_9][var_5]\n var_4 = max(var_4, var_10)\n print(var_4)\n\n\nif __name__ == \"__main__\":\n func_1()\n```", "output": "FASTER 1.7721", "pair_id": "python_p03503_pair0007_forward", "problem_id": "p03503", "language": "python", "direction": "forward", "speedup_ratio": 3.4156} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nfrom sys import stdin\n\nvar_6 = lambda: list(map(int, stdin.readline().split()))\nvar_5 = lambda: list(map(int, stdin.readline().split()))\nvar_1, var_3 = var_6()\nvar_2 = 0\nfor var_4 in range(var_1, var_3 + 1):\n var_7 = str(var_4)\n if var_7 == var_7[::-1]:\n var_2 += 1\nprint(var_2)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().rstrip().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = list(map(int, list(str(var_4))))\n if var_5[0] == var_5[4] and var_5[1] == var_5[3]:\n var_3 += 1\nprint(var_3)\n```", "output": "SLOWER 1.6646", "pair_id": "python_p03416_pair0117_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 3.1703} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_6 in range(var_1, var_2 + 1):\n var_3 = str(var_6)\n var_5 = True\n for var_7 in range(len(var_3) // 2):\n if var_3[var_7] != var_3[-var_7 - 1] and var_5:\n var_5 = not var_5\n if var_5:\n var_4 += 1\nprint(var_4)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\n\n\ndef func_1(var_5, var_6):\n var_4 = 0\n for var_3 in range(var_5, var_6 + 1):\n if str(var_3) == str(var_3)[::-1]:\n var_4 += 1\n return var_4\n\n\nprint((func_1(var_1, var_2)))\n```", "output": "FASTER 1.7836", "pair_id": "python_p03416_pair0118_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 3.4428} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\n\n\ndef func_1(var_5):\n var_4 = 0\n for var_3 in range(1, var_5 + 1):\n if str(var_3) == str(var_3)[::-1]:\n var_4 += 1\n return var_4\n\n\nprint((func_1(var_2) - func_1(var_1 - 1)))\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().strip().split(\" \")))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n if str(var_4) == str(var_4)[::-1]:\n var_3 += 1\nprint(var_3)\n```", "output": "FASTER 1.2833", "pair_id": "python_p03416_pair0100_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 2.434} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = [0] * (var_2 + 1)\nfor var_3 in range(1, var_2 + 1):\n if str(var_3) == str(var_3)[::-1]:\n var_4[var_3] = var_4[var_3 - 1] + 1\n else:\n var_4[var_3] = var_4[var_3 - 1]\nprint((var_4[var_2] - var_4[var_1 - 1]))\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = [\n var_3 for var_3 in map(str, list(range(var_1, var_2 + 1))) if var_3 == var_3[::-1]\n]\nprint((len(var_4)))\n```", "output": "FASTER 2.6408", "pair_id": "python_p03416_pair0119_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 6.2369} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\ndef func_1():\n from collections import Counter\n\n var_4 = int(eval(input()))\n (*var_1,) = list(map(int, input().split()))\n if var_4 % 3 == 0:\n var_2 = Counter(var_1)\n if len(var_2) == 1:\n print((\"Yes\" if 0 in var_2 else \"No\"))\n return\n elif len(var_2) == 2:\n print((\"Yes\" if var_2[0] == var_4 // 3 else \"No\"))\n return\n elif len(var_2) == 3:\n var_7 = 0\n var_5 = None\n for var_3, var_6 in list(var_2.items()):\n if var_5 is None:\n var_5 = var_6\n elif var_5 != var_6:\n print(\"No\")\n return\n var_7 ^= var_3\n print((\"Yes\" if var_7 == 0 else \"No\"))\n return\n else:\n print(\"No\")\n return\n else:\n print((\"Yes\" if all([var_7 == 0 for var_7 in var_1]) else \"No\"))\n return\n\n\nif __name__ == \"__main__\":\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nfrom functools import *\n\n_, var_1 = open(0)\nprint(\n (\n \"YNeos\"[\n var_2(lambda var_3, var_4: var_3 ^ var_4, list(map(int, var_1.split())))\n > 0 :: 2\n ]\n )\n)\n```", "output": "FASTER 1.4188", "pair_id": "python_p02975_pair0004_forward", "problem_id": "p02975", "language": "python", "direction": "forward", "speedup_ratio": 2.6736} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nfrom sys import stdin\n\n\ndef func_1():\n\n var_9 = stdin.readline\n var_8, var_10 = list(map(int, var_9().split()))\n var_7 = [list(map(int, var_9().split())) for _ in range(var_8)]\n var_7.sort()\n var_1 = [0] * var_8\n var_2 = [0] * var_8\n for var_4 in range(var_8):\n var_1[var_4], var_2[var_4] = var_7[var_4][0], var_7[var_4][1]\n\n var_5 = -(10**9)\n var_3 = [[var_5] * (var_10 + 1) for _ in range(var_8 + 1)]\n var_3[0][0] = 0\n for var_4 in range(var_8):\n for var_6 in range(var_10 + 1):\n\n if var_6 != var_10:\n var_3[var_4 + 1][min(var_10, var_6 + var_1[var_4])] = max(\n var_3[var_4 + 1][min(var_10, var_6 + var_1[var_4])],\n var_3[var_4][var_6] + var_2[var_4],\n )\n\n var_3[var_4 + 1][var_6] = max(var_3[var_4 + 1][var_6], var_3[var_4][var_6])\n print((max(var_3[var_8])))\n\n\nif __name__ == \"__main__\":\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nfrom collections import Counter, defaultdict, deque\nfrom heapq import heappop, heappush, heapify\nimport sys, bisect, math, itertools, fractions, pprint\n\nsys.setrecursionlimit(10**8)\nvar_6 = 10**9 + 7\nvar_1 = float(\"inf\")\n\n\ndef func_1():\n return int(sys.stdin.readline())\n\n\ndef func_2():\n return list(map(int, sys.stdin.readline().split()))\n\n\nvar_7, var_9 = func_2()\nvar_13 = [func_2() for _ in range(var_7)]\nvar_13.sort(key=lambda var_14: var_14[1], reverse=True)\nvar_8 = 0\nvar_10 = min(var_7, 5)\nfor var_3 in range(var_10):\n var_2 = [[0] * (var_9 + 5) for _ in range(var_7 + 5)]\n for var_4 in range(var_7):\n var_12, var_11 = var_13[var_4]\n for var_5 in range(var_9):\n if var_5 < var_12 or var_3 == var_4:\n var_2[var_4 + 1][var_5] = var_2[var_4][var_5]\n else:\n var_2[var_4 + 1][var_5] = max(\n var_2[var_4][var_5], var_2[var_4][var_5 - var_12] + var_11\n )\n\n var_8 = max(var_2[var_7][var_9 - 1] + var_13[var_3][1], var_8)\nprint(var_8)\n```", "output": "SLOWER 1.7415", "pair_id": "python_p02863_pair0016_reversed", "problem_id": "p02863", "language": "python", "direction": "reversed", "speedup_ratio": 3.3438} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_6 = input()[::-1]\nvar_5 = len(var_6)\nvar_1 = [0] * var_5\nvar_3 = [0] * var_5\nvar_2 = [0] * 2019\nvar_7 = 10\nvar_1[0] = int(var_6[0])\nvar_3[0] = var_1[0]\nvar_2[var_3[0]] += 1\nfor var_4 in range(1, var_5):\n var_1[var_4] = int(var_6[var_4]) * var_7 % 2019\n var_3[var_4] = (var_3[var_4 - 1] + var_1[var_4]) % 2019\n var_2[var_3[var_4]] += 1\n var_7 = var_7 * 10 % 2019\nprint(\n (\n int(sum([var_2[var_4] * (var_2[var_4] - 1) for var_4 in range(2019)]) / 2)\n + var_2[0]\n )\n)\n```\n\n=== Code B (Modified) ===\n```python\nimport numpy as np\n\nvar_7 = input()[::-1]\nvar_6 = len(var_7)\nvar_1 = np.zeros(var_6, dtype=int)\nvar_4 = np.zeros(var_6, dtype=int)\nvar_2 = np.zeros(2019, dtype=int)\nvar_8 = 10\nvar_1[0] = int(var_7[0])\nvar_4[0] = var_1[0]\nvar_2[var_4[0]] += 1\nfor var_5 in range(1, var_6):\n var_1[var_5] = int(var_7[var_5]) * var_8 % 2019\n var_4[var_5] = (var_4[var_5 - 1] + var_1[var_5]) % 2019\n var_2[var_4[var_5]] += 1\n var_8 = var_8 * 10 % 2019\nvar_3 = var_2[np.nonzero(var_2)]\nprint(\n (\n int(\n sum([var_3[var_5] * (var_3[var_5] - 1) for var_5 in range(var_3.shape[0])])\n / 2\n )\n + var_2[0]\n )\n)\n```", "output": "FASTER 1.0297", "pair_id": "python_p02702_pair0009_forward", "problem_id": "p02702", "language": "python", "direction": "forward", "speedup_ratio": 2.0416} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_4 = int(eval(input()))\nvar_2 = list(map(int, input().split()))\n\n\ndef func_1(var_1, var_8, var_3):\n if var_8 == var_4:\n var_9 = 1\n for var_5 in var_3:\n var_9 *= var_5\n return 1 if var_9 % 2 == 0 else 0\n var_6 = var_3.copy()\n var_6.append(var_1[var_8] - 1)\n var_5 = var_3.copy()\n var_5.append(var_1[var_8])\n var_7 = var_3.copy()\n var_7.append(var_1[var_8] + 1)\n return (\n func_1(var_1, var_8 + 1, var_6)\n + func_1(var_1, var_8 + 1, var_5)\n + func_1(var_1, var_8 + 1, var_7)\n )\n\n\nprint((func_1(var_2, 0, [])))\n```\n\n=== Code B (Modified) ===\n```python\nvar_2 = int(eval(input()))\n(*var_1,) = list(map(int, input().split()))\nvar_5 = 0\nfor var_3 in var_1:\n if var_3 % 2 == 0:\n var_5 += 1\nvar_4 = 3**var_2 - 2**var_5\nprint(var_4)\n```", "output": "FASTER 8.2861", "pair_id": "python_p03568_pair0019_forward", "problem_id": "p03568", "language": "python", "direction": "forward", "speedup_ratio": 312.1488} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\n\n\ndef func_1(var_5, var_6):\n var_4 = 0\n for var_3 in range(var_5, var_6 + 1):\n if str(var_3) == str(var_3)[::-1]:\n var_4 += 1\n return var_4\n\n\nprint((func_1(var_1, var_2)))\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().rstrip().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = list(map(int, list(str(var_4))))\n if var_5[0] == var_5[4] and var_5[1] == var_5[3]:\n var_3 += 1\nprint(var_3)\n```", "output": "SLOWER 2.0067", "pair_id": "python_p03416_pair0091_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 4.0185} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nfrom itertools import product\n\nvar_6 = int(eval(input()))\nvar_1 = list(map(int, input().split()))\nvar_5 = 0\nfor var_2 in product((-1, 0, 1), repeat=var_6):\n var_7 = 1\n for var_3, var_4 in zip(var_1, var_2):\n var_7 *= var_3 + var_4\n if var_7 % 2 == 0:\n var_5 += 1\nprint(var_5)\n```\n\n=== Code B (Modified) ===\n```python\nvar_4 = int(eval(input()))\nvar_1 = list(map(int, input().split()))\nvar_3 = 1\nfor var_2 in var_1:\n var_3 *= 2 if var_2 % 2 == 0 else 1\nprint((3**var_4 - var_3))\n```", "output": "FASTER 10.1524", "pair_id": "python_p03568_pair0020_forward", "problem_id": "p03568", "language": "python", "direction": "forward", "speedup_ratio": 1138.1035} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\nfrom collections import deque\n\nvar_1 = int(10e10)\nvar_2 = -var_1\nvar_12 = 1000000007\nsys.setrecursionlimit(1000000)\n\n\ndef func_2():\n return list(map(int, input().split()))\n\n\ndef func_4():\n return input().split()\n\n\ndef func_1():\n return int(sys.stdin.readline())\n\n\ndef func_3():\n return eval(input())\n\n\nvar_3, var_4 = func_2()\nvar_6 = [func_2() for var_10 in range(var_3)]\nvar_6.sort()\nvar_7 = 0\nvar_9 = [[0] * var_4 for var_10 in range(var_3 + 1)]\nfor var_10 in range(1, var_3 + 1):\n var_5, var_8 = var_6[var_10 - 1]\n for var_11 in range(var_4):\n if 0 <= var_11 - var_5 < var_4:\n var_9[var_10][var_11] = max(\n var_9[var_10 - 1][var_11], var_9[var_10 - 1][var_11 - var_5] + var_8\n )\n else:\n var_9[var_10][var_11] = var_9[var_10 - 1][var_11]\n else:\n var_7 = max(var_7, var_9[var_10 - 1][-1] + var_8)\nprint(var_7)\n```\n\n=== Code B (Modified) ===\n```python\ndef func_1():\n var_2, var_3, *var_1 = list(map(int, open(0).read().split()))\n var_4 = [0] * (var_3 + max(var_1[::2]))\n for var_7, var_6 in sorted(zip(*[iter(var_1)] * 2)):\n for var_5 in reversed(list(range(var_3))):\n var_4[var_5 + var_7] = max(var_4[var_5 + var_7], var_4[var_5] + var_6)\n print((max(var_4)))\n\n\nfunc_1()\n```", "output": "FASTER 1.3844", "pair_id": "python_p02863_pair0027_forward", "problem_id": "p02863", "language": "python", "direction": "forward", "speedup_ratio": 2.6106} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\ndef func_1():\n var_1, var_2 = list(map(int, input().rstrip().split()))\n var_3 = 0\n for var_4 in range(var_1, var_2 + 1):\n var_5 = str(var_4)\n if var_5 == var_5[::-1]:\n var_3 += 1\n print(var_3)\n\n\nif __name__ == \"__main__\":\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nvar_4, var_3 = list(map(int, input().split()))\nvar_1 = 0\nfor var_2 in range(var_4, var_3 + 1):\n if str(var_2)[0] + str(var_2)[1] == str(var_2)[-1] + str(var_2)[-2]:\n var_1 += 1\nprint(var_1)\n```", "output": "SLOWER 2.0871", "pair_id": "python_p03416_pair0109_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 4.2489} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\nimport math\nfrom collections import defaultdict\nfrom bisect import bisect_left, bisect_right\n\nsys.setrecursionlimit(10**7)\n\n\ndef func_4():\n return sys.stdin.readline()[:-1]\n\n\nvar_4 = 10**9 + 7\n\n\ndef func_1():\n return int(eval(func_4()))\n\n\ndef func_2():\n return list(map(int, func_4().split()))\n\n\ndef func_3(var_6, var_3):\n if var_6 <= 0:\n return [[] for _ in range(var_3)]\n elif var_3 == 1:\n return [func_1() for _ in range(var_6)]\n else:\n var_5 = [func_2() for _ in range(var_6)]\n return list(map(list, list(zip(*var_5))))\n\n\nvar_1, var_2 = list(map(str, func_4().split()))\nvar_1 = int(var_1)\nvar_2 = 100 * int(var_2[0]) + 10 * int(var_2[2]) + int(var_2[3])\nprint((var_1 * var_2 // 100))\n```\n\n=== Code B (Modified) ===\n```python\nimport math\n\nvar_1, var_2 = input().split()\nvar_1 = int(var_1)\nvar_3 = int(var_2[0] + var_2[2] + var_2[3])\nprint((int(var_1 * var_3) // 100))\n```", "output": "FASTER 2.2787", "pair_id": "python_p02659_pair0026_forward", "problem_id": "p02659", "language": "python", "direction": "forward", "speedup_ratio": 4.8523} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nfrom collections import Counter, defaultdict, deque\nfrom heapq import heappop, heappush, heapify\nimport sys, bisect, math, itertools, fractions, pprint\n\nsys.setrecursionlimit(10**8)\nvar_6 = 10**9 + 7\nvar_1 = float(\"inf\")\n\n\ndef func_1():\n return int(sys.stdin.readline())\n\n\ndef func_2():\n return list(map(int, sys.stdin.readline().split()))\n\n\nvar_8, var_11 = func_2()\nvar_17 = [func_2() for _ in range(var_8)]\nvar_10 = var_17[::-1]\nvar_14 = [[0] * var_11 for _ in range(var_8)]\nvar_3 = [[0] * var_11 for _ in range(var_8)]\nfor var_4 in range(var_8 - 1):\n var_16, var_15 = var_17[var_4]\n for var_5 in range(var_11):\n if var_5 < var_16:\n var_14[var_4 + 1][var_5] = var_14[var_4][var_5]\n else:\n var_14[var_4 + 1][var_5] = max(\n var_14[var_4][var_5], var_14[var_4][var_5 - var_16] + var_15\n )\nvar_9 = var_14[var_8 - 1][var_11 - 1] + var_17[var_8 - 1][1]\nfor var_4 in range(var_8 - 1):\n var_16, var_15 = var_10[var_4]\n for var_5 in range(var_11):\n if var_5 < var_16:\n var_3[var_4 + 1][var_5] = var_3[var_4][var_5]\n else:\n var_3[var_4 + 1][var_5] = max(\n var_3[var_4][var_5], var_3[var_4][var_5 - var_16] + var_15\n )\n var_9 = max(var_9, var_3[var_8 - 1][var_11 - 1] + var_17[0][1])\n\nfor var_4 in range(1, var_8 - 1):\n var_13 = var_4\n var_2 = var_8 - var_4 - 1\n var_7 = 0\n for var_5 in range(var_11):\n var_12 = var_14[var_13][var_5] + var_3[var_2][var_11 - 1 - var_5]\n var_7 = max(var_7, var_12)\n var_9 = max(var_9, var_7 + var_17[var_4][1])\nprint(var_9)\n```\n\n=== Code B (Modified) ===\n```python\nfrom sys import stdin\n\n\ndef func_1():\n\n var_9 = stdin.readline\n var_8, var_10 = list(map(int, var_9().split()))\n var_7 = [list(map(int, var_9().split())) for _ in range(var_8)]\n var_7.sort()\n var_1 = [0] * var_8\n var_2 = [0] * var_8\n for var_4 in range(var_8):\n var_1[var_4], var_2[var_4] = var_7[var_4][0], var_7[var_4][1]\n\n var_5 = -float(\"inf\")\n var_3 = [[var_5] * (var_10 + 1) for _ in range(var_8 + 1)]\n var_3[0][0] = 0\n for var_4 in range(var_8):\n for var_6 in range(var_10 + 1):\n\n if var_6 != var_10:\n var_3[var_4 + 1][min(var_10, var_6 + var_1[var_4])] = max(\n var_3[var_4 + 1][min(var_10, var_6 + var_1[var_4])],\n var_3[var_4][var_6] + var_2[var_4],\n )\n\n var_3[var_4 + 1][var_6] = max(var_3[var_4 + 1][var_6], var_3[var_4][var_6])\n print((max(var_3[var_8])))\n\n\nif __name__ == \"__main__\":\n func_1()\n```", "output": "FASTER 1.08", "pair_id": "python_p02863_pair0028_forward", "problem_id": "p02863", "language": "python", "direction": "forward", "speedup_ratio": 2.114} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\n\nvar_2, var_1, *var_3 = sys.stdin.read().strip().split()\nvar_2 = int(var_2)\nvar_5 = [0] * var_2\nvar_10 = [0] * var_2\nfor var_6, var_8 in zip(*[iter(var_3)] * 2):\n var_6 = int(var_6) - 1\n if var_8 == \"AC\":\n var_5[var_6] = 1\n elif var_5[var_6] == 0:\n var_10[var_6] += 1\nvar_7 = sum([var_9 * var_4 for var_4, var_9 in zip(var_5, var_10)])\nprint((\"{} {}\".format(sum(var_5), var_7)))\n```\n\n=== Code B (Modified) ===\n```python\nvar_7, var_6 = list(map(int, input().split()))\nvar_5 = [tuple(input().split()) for _ in range(var_6)]\nvar_9 = [[] for _ in range(var_7)]\nfor var_2 in range(var_6):\n var_9[int(var_5[var_2][0]) - 1].append(var_5[var_2][1])\nvar_1, var_8 = 0, 0\nfor var_3 in range(var_7):\n if \"AC\" in var_9[var_3]:\n var_1 += 1\n for var_4 in range(len(var_9[var_3])):\n if var_9[var_3][var_4] == \"WA\":\n var_8 += 1\n else:\n break\nprint((var_1, var_8))\n```", "output": "SLOWER 1.5456", "pair_id": "python_p02802_pair0004_reversed", "problem_id": "p02802", "language": "python", "direction": "reversed", "speedup_ratio": 2.9193} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_4 = str(var_4)\n if var_4 == var_4[::-1]:\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_4, var_3 = list(map(int, input().split()))\nvar_1 = 0\nfor var_2 in range(var_4, var_3 + 1):\n if str(var_2)[0] + str(var_2)[1] == str(var_2)[-1] + str(var_2)[-2]:\n var_1 += 1\nprint(var_1)\n```", "output": "SLOWER 1.1941", "pair_id": "python_p03416_pair0120_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 2.288} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\n\nvar_7 = sys.stdin.readline\nfrom itertools import combinations\n\n\ndef func_3(var_10):\n for _ in range(var_10):\n yield list(map(int, var_7().split()))\n\n\ndef func_1(var_9, var_5, var_11):\n var_3 = len([0 for var_8 in var_9 if var_5[var_8] == 1])\n return var_11[var_3]\n\n\ndef func_2():\n var_10 = int(eval(var_7()))\n var_1 = list(func_3(var_10))\n var_2 = list(func_3(var_10))\n for var_6 in range(1, 11):\n for var_4 in combinations(list(range(10)), var_6):\n yield sum(\n func_1(var_4, var_5, var_11) for var_5, var_11 in zip(var_1, var_2)\n )\n\n\nprint((max(func_2())))\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\nimport itertools\n\n\ndef func_2(var_4):\n return bin(eval(\"0b\" + str(var_4)))\n\n\ndef func_1():\n var_4 = int(sys.stdin.readline().rstrip())\n var_9 = [\n func_2(\"\".join(str(var_10) for var_10 in sys.stdin.readline().split()))\n for _ in range(var_4)\n ]\n var_8 = [\n [int(var_10) for var_10 in sys.stdin.readline().split()] for _ in range(var_4)\n ]\n var_3 = -(10**10)\n for var_6 in itertools.product(\"01\", repeat=10):\n var_6 = func_2(\"\".join(var_6))\n if var_6 == \"0b0\":\n continue\n var_7 = 0\n for var_2 in range(var_4):\n var_1 = var_9[var_2]\n var_5 = bin(eval(var_1) & eval(var_6)).count(\"1\")\n var_7 += var_8[var_2][var_5]\n var_3 = max(var_3, var_7)\n print(var_3)\n\n\nif __name__ == \"__main__\":\n\n func_1()\n```", "output": "SLOWER 4.1946", "pair_id": "python_p03503_pair0021_reversed", "problem_id": "p03503", "language": "python", "direction": "reversed", "speedup_ratio": 18.3107} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_8 in range(var_1, var_2 + 1):\n var_7 = str(var_8)\n var_6 = len(var_7)\n var_4 = True\n for var_5 in range(var_6 // 2):\n if var_7[var_5] != var_7[var_6 - 1 - var_5]:\n var_4 = False\n break\n if var_4:\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\n\n\ndef func_1(var_5, var_6):\n var_4 = 0\n for var_3 in range(var_5, var_6 + 1):\n if str(var_3) == str(var_3)[::-1]:\n var_4 += 1\n return var_4\n\n\nprint((func_1(var_1, var_2)))\n```", "output": "FASTER 1.4499", "pair_id": "python_p03416_pair0042_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 2.7318} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_6, var_7 = list(map(int, input().split()))\nvar_1 = [list(map(int, input().split())) for _ in range(var_6)]\nvar_1.sort()\nvar_3 = [(6007) * [0] for _ in range(var_6 + 1)]\nvar_3[0][0] = 0\nvar_2 = 0\nfor var_4 in range(var_6):\n for var_5 in range(6007):\n var_3[var_4 + 1][var_5] = max(var_3[var_4 + 1][var_5], var_3[var_4][var_5])\n if var_5 < var_7:\n var_3[var_4 + 1][var_5 + var_1[var_4][0]] = max(\n var_3[var_4][var_5] + var_1[var_4][1],\n var_3[var_4][var_5 + var_1[var_4][0]],\n )\n var_2 = max(var_2, var_3[var_4 + 1][var_5])\nprint(var_2)\n```\n\n=== Code B (Modified) ===\n```python\nfrom sys import stdin\n\n\ndef func_1():\n\n var_9 = stdin.readline\n var_8, var_10 = list(map(int, var_9().split()))\n var_7 = [list(map(int, var_9().split())) for _ in range(var_8)]\n var_7.sort()\n var_1 = [0] * var_8\n var_2 = [0] * var_8\n for var_4 in range(var_8):\n var_1[var_4], var_2[var_4] = var_7[var_4][0], var_7[var_4][1]\n\n var_5 = -(10**9)\n var_3 = [[var_5] * (var_10 + 1) for _ in range(var_8 + 1)]\n var_3[0][0] = 0\n for var_4 in range(var_8):\n for var_6 in range(var_10 + 1):\n\n if var_6 != var_10:\n var_3[var_4 + 1][min(var_10, var_6 + var_1[var_4])] = max(\n var_3[var_4 + 1][min(var_10, var_6 + var_1[var_4])],\n var_3[var_4][var_6] + var_2[var_4],\n )\n\n var_3[var_4 + 1][var_6] = max(var_3[var_4 + 1][var_6], var_3[var_4][var_6])\n print((max(var_3[var_8])))\n\n\nif __name__ == \"__main__\":\n func_1()\n```", "output": "FASTER 5.8227", "pair_id": "python_p02863_pair0029_forward", "problem_id": "p02863", "language": "python", "direction": "forward", "speedup_ratio": 56.5998} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nfrom math import floor\n\nvar_1, var_2 = list(map(int, input().split()))\n\n\nfor var_3 in range(1010):\n if (floor(var_3 * 0.08) == var_1) and (floor(var_3 * 0.1) == var_2):\n\n print(var_3)\n quit()\n\n\nprint((-1))\n```\n\n=== Code B (Modified) ===\n```python\nimport math\n\n\ndef func_1():\n var_1, var_2 = list(map(int, input().split()))\n\n var_5 = max(math.ceil(var_1 / 0.08), math.ceil(var_2 / 0.1))\n\n var_4 = min((math.ceil((var_1 + 1) / 0.08), math.ceil((var_2 + 1) / 0.1)))\n\n for var_3 in range(var_5, var_4 + 1):\n if (math.floor(var_3 * 0.08) == var_1) and (math.floor(var_3 * 0.1) == var_2):\n print(var_3)\n quit()\n\n print((-1))\n\n\nif __name__ == \"__main__\":\n func_1()\n```", "output": "FASTER 1.1074", "pair_id": "python_p02755_pair0007_forward", "problem_id": "p02755", "language": "python", "direction": "forward", "speedup_ratio": 2.1545} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\n\nvar_3 = sys.stdin.readline\nvar_1, var_2 = var_3().split()\nvar_1 = int(var_1)\nvar_2 = int(float(var_2) * 100 + 0.5)\nprint((var_1 * var_2 // 100))\n```\n\n=== Code B (Modified) ===\n```python\ndef func_1():\n from sys import setrecursionlimit, stdin\n from os import environ\n from collections import defaultdict, deque, Counter\n from math import ceil, floor, gcd\n from itertools import accumulate, combinations, combinations_with_replacement\n\n setrecursionlimit(10**6)\n var_7 = (\n (lambda *var_11: print(*var_11))\n if \"TERM_PROGRAM\" in environ\n else lambda *var_12: 0\n )\n var_8 = lambda: stdin.readline().rstrip()\n var_3 = lambda: list(map(int, var_8().split()))\n var_1 = lambda: int(var_8())\n var_4 = 10**9 + 7\n var_2 = 10**9 + 10\n var_9, var_10 = var_8().split()\n var_5 = int(var_9)\n var_6 = int(float(var_10) * 100 + 0.5)\n print(var_5 * var_6 // 100)\n\n\nfunc_1()\n```", "output": "SLOWER 2.0133", "pair_id": "python_p02659_pair0013_reversed", "problem_id": "p02659", "language": "python", "direction": "reversed", "speedup_ratio": 4.0371} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_4 = {}\nvar_5 = 0\nfor var_6 in range(10000, 100000):\n var_3 = list(str(var_6))\n if var_3 == list(reversed(var_3)):\n var_5 += 1\n var_4[var_6] = var_5\nvar_1, var_2 = list(map(int, input().split()))\nprint((var_4[var_2] - var_4[var_1 - 1] if var_1 > 10000 else var_4[var_2]))\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\n\n\ndef func_1(var_5, var_6):\n var_4 = 0\n for var_3 in range(var_5, var_6 + 1):\n if str(var_3) == str(var_3)[::-1]:\n var_4 += 1\n return var_4\n\n\nprint((func_1(var_1, var_2)))\n```", "output": "FASTER 3.8972", "pair_id": "python_p03416_pair0080_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 14.8999} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = list(reversed(list(str(var_4))))\n if var_5 == list(str(var_4)):\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_4 = str(var_4)\n if var_4[0] == var_4[-1] and var_4[1] == var_4[-2]:\n var_3 += 1\nprint(var_3)\n```", "output": "FASTER 1.8406", "pair_id": "python_p03416_pair0121_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 3.5817} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_5 in range(10):\n for var_6 in range(10):\n for var_7 in range(10):\n var_3 = 10000 * var_5 + 1000 * var_6 + 100 * var_7 + 10 * var_6 + var_5\n if var_1 <= var_3 <= var_2:\n var_4 += 1\nprint(var_4)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_4 = str(var_4)\n if var_4 == var_4[::-1]:\n var_3 += 1\nprint(var_3)\n```", "output": "SLOWER 3.9726", "pair_id": "python_p03416_pair0122_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 15.6985} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_2, var_1 = list(map(int, input().split()))\nvar_6 = {}\nvar_3 = {}\nfor var_4 in range(var_1):\n var_5, var_7 = input().split()\n var_5 = int(var_5)\n if not var_5 in var_6:\n var_6[var_5] = 0\n var_3[var_5] = 0\n if var_7 == \"WA\" and var_3[var_5] == 0:\n var_6[var_5] += 1\n elif var_7 == \"AC\" and var_3[var_5] == 0:\n var_3[var_5] += 1\nfor var_4 in var_6:\n if var_6[var_4] != 0 and var_3[var_4] == 0:\n var_6[var_4] = 0\nprint((sum(var_3.values()), sum(var_6.values())))\n```\n\n=== Code B (Modified) ===\n```python\nfrom sys import stdin\n\nvar_5 = stdin.readline\nvar_2, var_1 = list(map(int, var_5().split()))\nvar_3 = [False] * var_2\nvar_8 = [0] * var_2\nvar_9 = 0\nfor var_4 in range(var_1):\n var_6, var_7 = var_5().split()\n var_6 = int(var_6) - 1\n if var_3[var_6] is False and var_7 == \"AC\":\n var_9 += var_8[var_6]\n var_3[var_6] = True\n elif var_7 == \"WA\":\n var_8[var_6] += 1\nprint((var_3.count(True), var_9))\n```", "output": "SLOWER 1.107", "pair_id": "python_p02802_pair0005_reversed", "problem_id": "p02802", "language": "python", "direction": "reversed", "speedup_ratio": 2.154} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\n\n\ndef func_5():\n return sys.stdin.readline()[:-1]\n\n\ndef func_2():\n return int(eval(func_5()))\n\n\ndef func_3():\n return list(map(int, func_5().split()))\n\n\ndef func_1():\n return list(func_3())\n\n\nvar_11, var_12 = func_3()\nvar_5 = [0] + func_1()\nvar_2 = [func_1() + [var_6] for var_6 in range(var_12)]\nvar_2.sort(key=lambda var_17: var_17[1])\nvar_4 = [0] * (var_12)\nvar_10 = [0 for var_6 in range(var_11 + 1)]\nvar_1 = 2\nwhile var_1 <= var_11:\n var_1 *= 2\nvar_16 = [0] * (2 * var_1)\n\n\ndef func_7(var_8, var_17):\n var_8 += var_1 - 1\n var_16[var_8] = var_17\n while var_8 > 0:\n var_8 = (var_8 - 1) // 2\n var_16[var_8] = var_16[var_8 * 2 + 1] + var_16[var_8 * 2 + 2]\n\n\ndef func_4(var_8, var_17):\n var_8 += var_1 - 1\n while var_8 >= 0:\n var_16[var_8] += var_17\n var_8 = (var_8 - 1) // 2\n\n\ndef func_6(var_9, var_13):\n func_1 = var_9 + var_1 - 1\n var_3 = var_13 + var_1 - 1\n var_14 = 0\n while func_1 <= var_3:\n if var_3 & 1:\n var_14 += var_16[var_3]\n var_3 -= 2\n else:\n var_3 -= 1\n if func_1 & 1:\n func_1 -= 1\n else:\n var_14 += var_16[func_1]\n func_1 >>= 1\n var_3 >>= 1\n return var_14\n\n\nvar_7 = 1\nfor var_9, var_13, var_6 in var_2:\n while var_7 <= var_13:\n var_15 = var_5[var_7]\n func_4(var_10[var_15], -1)\n func_4(var_7, 1)\n var_10[var_15] = var_7\n var_7 += 1\n var_4[var_6] = func_6(var_9, var_13)\nfor var_6 in var_4:\n print(var_6)\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\n\nvar_20 = sys.stdin.read\nvar_21 = sys.stdin.readline\nvar_22 = sys.stdin.readlines\nsys.setrecursionlimit(10**9)\nvar_2 = 1 << 60\nvar_5 = 1000000007\n\n\nvar_4 = 1000001\n\n\nclass Class_1:\n def __init__(self, var_13, var_19, var_12):\n self.l = var_13\n self.r = var_19\n self.idx = var_12\n\n\ndef func_4(var_12, var_24, var_10, var_15):\n while var_12 <= var_15:\n var_10[var_12] += var_24\n var_12 += var_12 & -var_12\n\n\ndef func_3(var_12, var_10, var_15):\n var_23 = 0\n while var_12:\n var_23 += var_10[var_12]\n var_12 -= var_12 & -var_12\n return var_23\n\n\ndef func_1(var_9, var_15, var_17, var_16):\n\n var_10 = [0] * (var_15 + 1)\n\n var_14 = [-1] * var_4\n\n var_8 = [0] * var_16\n var_18 = 0\n for var_11 in range(var_15):\n\n if var_14[var_9[var_11]] != -1:\n func_4(var_14[var_9[var_11]] + 1, -1, var_10, var_15)\n\n var_14[var_9[var_11]] = var_11\n func_4(var_11 + 1, 1, var_10, var_15)\n\n while var_18 < var_16 and var_17[var_18].r == var_11:\n var_8[var_17[var_18].idx] = func_3(\n var_17[var_18].r + 1, var_10, var_15\n ) - func_3(var_17[var_18].l, var_10, var_15)\n var_18 += 1\n\n for var_11 in range(var_16):\n print((var_8[var_11]))\n\n\ndef func_2():\n var_6, var_7 = list(map(int, var_21().split()))\n var_1 = list(map(int, var_21().split()))\n (*var_3,) = list(map(int, var_20().split()))\n var_17 = [0] * var_7\n for var_11, (var_13, var_19) in enumerate(zip(*[iter(var_3)] * 2)):\n var_17[var_11] = Class_1(var_13 - 1, var_19 - 1, var_11)\n var_17.sort(key=lambda var_25: var_25.r)\n func_1(var_1, var_6, var_17, var_7)\n return\n\n\nif __name__ == \"__main__\":\n func_2()\n```", "output": "SLOWER 2.1494", "pair_id": "python_p02599_pair0004_reversed", "problem_id": "p02599", "language": "python", "direction": "reversed", "speedup_ratio": 4.4365} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_3 = list(map(int, input().split()))\nvar_2 = 0\nfor var_5 in range(var_3 + 1)[var_1:]:\n if len(str(var_5)) % 2 == 0:\n var_6 = list(str(var_5))[: len(str(var_5)) // 2]\n var_7 = list(reversed(list(str(var_5))[len(str(var_5)) // 2 :]))\n if var_6 == var_7:\n var_2 += 1\n else:\n var_8 = list(str(var_5))[: len(str(var_5)) // 2 + 1]\n var_4 = list(reversed(list(str(var_5))[len(str(var_5)) // 2 :]))\n if var_8 == var_4:\n var_2 += 1\nprint(var_2)\n```\n\n=== Code B (Modified) ===\n```python\nvar_4 = {}\nvar_5 = 0\nfor var_6 in range(10000, 100000):\n var_3 = list(str(var_6))\n if var_3 == list(reversed(var_3)):\n var_5 += 1\n var_4[var_6] = var_5\nvar_1, var_2 = list(map(int, input().split()))\nprint((var_4[var_2] - var_4[var_1 - 1] if var_1 > 10000 else var_4[var_2]))\n```", "output": "SLOWER 1.0991", "pair_id": "python_p03416_pair0123_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 2.1422} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\n\nvar_7 = sys.stdin.readline\nfrom itertools import combinations\n\n\ndef func_3(var_10):\n for _ in range(var_10):\n yield list(map(int, var_7().split()))\n\n\ndef func_1(var_9, var_5, var_11):\n var_3 = len([0 for var_8 in var_9 if var_5[var_8] == 1])\n return var_11[var_3]\n\n\ndef func_2():\n var_10 = int(eval(var_7()))\n var_1 = list(func_3(var_10))\n var_2 = list(func_3(var_10))\n for var_6 in range(1, 11):\n for var_4 in combinations(list(range(10)), var_6):\n yield sum(\n func_1(var_4, var_5, var_11) for var_5, var_11 in zip(var_1, var_2)\n )\n\n\nprint((max(func_2())))\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\n\nvar_8 = sys.stdin.readline\n\n\ndef func_1():\n var_2 = int(eval(var_8()))\n var_1 = [int(var_8().replace(\" \", \"\"), 2) for _ in range(var_2)]\n var_3 = [list(map(int, var_8().split())) for _ in range(var_2)]\n var_4 = -(10**7) * var_2\n for var_7 in range(1, 1 << 10):\n var_10 = 0\n for var_9, var_6 in enumerate(var_1):\n var_5 = bin(var_7 & var_6).count(\"1\")\n var_10 += var_3[var_9][var_5]\n var_4 = max(var_4, var_10)\n print(var_4)\n\n\nif __name__ == \"__main__\":\n func_1()\n```", "output": "FASTER 1.1171", "pair_id": "python_p03503_pair0022_forward", "problem_id": "p03503", "language": "python", "direction": "forward", "speedup_ratio": 2.1691} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\n\n\ndef func_1(var_5):\n var_4 = 0\n for var_3 in range(1, var_5 + 1):\n if str(var_3) == str(var_3)[::-1]:\n var_4 += 1\n return var_4\n\n\nprint((func_1(var_2) - func_1(var_1 - 1)))\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\n\n\ndef func_1(var_5, var_6):\n var_4 = 0\n for var_3 in range(var_5, var_6 + 1):\n if str(var_3) == str(var_3)[::-1]:\n var_4 += 1\n return var_4\n\n\nprint((func_1(var_1, var_2)))\n```", "output": "FASTER 1.9143", "pair_id": "python_p03416_pair0124_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 3.7692} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2, var_8 = list(map(int, input().split()))\nvar_4 = list(map(int, input().split()))\nvar_9 = list(map(int, input().split()))\nvar_10 = [list(map(int, input().split())) for var_6 in range(var_8)]\nvar_7 = 200001\nfor var_6 in range(var_8):\n var_5 = var_10[var_6][0] - 1\n var_3 = var_10[var_6][1] - 1\n if var_7 >= var_4[var_5] + var_9[var_3] - var_10[var_6][2]:\n var_7 = var_4[var_5] + var_9[var_3] - var_10[var_6][2]\nvar_4.sort()\nvar_9.sort()\nif var_7 >= (var_4[0] + var_9[0]):\n print((var_4[0] + var_9[0]))\nelse:\n print(var_7)\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\nfrom collections import Counter\n\n\ndef func_9():\n return sys.stdin.readline().strip()\n\n\ndef func_10(var_8, var_9, var_10):\n return [[var_10] * var_9 for var_13 in range(var_8)]\n\n\ndef func_11(var_8, var_9, var_10, var_11):\n return [[[var_11] * var_10 for var_14 in range(var_9)] for var_13 in range(var_8)]\n\n\ndef func_12(var_8, var_9, var_10, var_11, var_12):\n return [\n [[[var_12] * var_11 for var_14 in range(var_10)] for var_14 in range(var_9)]\n for var_13 in range(var_8)\n ]\n\n\ndef func_8(var_16, var_17=1):\n return int(-(-var_16 // var_17))\n\n\ndef func_1():\n return int(eval(func_9()))\n\n\ndef func_3():\n return list(map(int, func_9().split()))\n\n\ndef func_2(var_7=None):\n return list(func_3()) if var_7 is None else [func_1() for var_13 in range(var_7)]\n\n\ndef func_7():\n print(\"Yes\")\n\n\ndef func_5():\n print(\"No\")\n\n\ndef func_6():\n print(\"YES\")\n\n\ndef func_4():\n print(\"NO\")\n\n\nsys.setrecursionlimit(10**9)\nvar_3 = 10**18\nvar_6 = 10**9 + 7\nvar_7, var_5, var_4 = func_3()\nvar_1 = func_2()\nvar_2 = func_2()\nvar_15 = min(var_1) + min(var_2)\nfor _ in range(var_4):\n var_16, var_17, var_10 = func_3()\n var_16 -= 1\n var_17 -= 1\n var_15 = min(var_15, var_1[var_16] + var_2[var_17] - var_10)\nprint(var_15)\n```", "output": "SLOWER 1.1425", "pair_id": "python_p02748_pair0007_reversed", "problem_id": "p02748", "language": "python", "direction": "reversed", "speedup_ratio": 2.2077} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport numpy as np\nfrom bisect import bisect_left\n\n\ndef func_1():\n var_4 = []\n var_1 = np.ones(10**5 + 10)\n var_1[0] = var_1[1] = 0\n for var_3, var_2 in enumerate(var_1):\n if var_2:\n var_4.append(var_3)\n var_1[2 * var_3 : 10**5 + 10 : var_3] = 0\n return var_4\n\n\ndef func_2(var_6):\n var_7 = int(var_6)\n var_5 = func_1()\n return str(var_5[bisect_left(var_5, var_7)])\n\n\nif __name__ == \"__main__\":\n import sys\n\n print((func_2(sys.stdin.read().strip())))\n```\n\n=== Code B (Modified) ===\n```python\ndef func_1(var_3):\n var_4 = int(var_3)\n for var_1 in range(var_4, 2 * var_4):\n for var_2 in range(2, int(var_1**0.5)):\n if var_1 % var_2 == 0:\n break\n else:\n return str(var_1)\n\n\nif __name__ == \"__main__\":\n import sys\n\n print((func_1(sys.stdin.read().strip())))\n```", "output": "FASTER 7.8177", "pair_id": "python_p02819_pair0005_forward", "problem_id": "p02819", "language": "python", "direction": "forward", "speedup_ratio": 225.6147} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nimport math\n\nif math.ceil((var_1 + 1) * 12.5) <= math.ceil(var_2 * 10) or math.ceil(\n var_1 * 12.5\n) >= math.ceil((var_2 + 1) * 10):\n print((-1))\nelse:\n print((max(math.ceil(var_1 * 12.5), math.ceil(var_2 * 10))))\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nfor var_3 in range(1, 1009):\n if int(var_3 * 0.08) == var_1 and int(var_3 * 0.1) == var_2:\n print((int(var_3)))\n exit()\nprint(\"-1\")\n```", "output": "SLOWER 1.923", "pair_id": "python_p02755_pair0005_reversed", "problem_id": "p02755", "language": "python", "direction": "reversed", "speedup_ratio": 3.792} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_3, var_1 = int(eval(input())), 0\nfor var_2 in list(map(int, input().split())):\n var_1 ^= var_2\nprint((\"Yes\" if var_1 == 0 else \"No\"))\n```\n\n=== Code B (Modified) ===\n```python\nvar_1 = lambda: list(map(int, input().split()))\nvar_6 = int(eval(input()))\nif var_6 % 3:\n var_3 = \"YNeos\"[any(var_1()) :: 2]\nelse:\n var_2 = sorted(var_1())\n var_5 = var_6 // 3\n if var_2[0] ^ var_2[var_5] ^ var_2[2 * var_5]:\n var_3 = \"No\"\n elif any(\n len(set(var_2[var_4 : var_4 + var_5])) > 1 for var_4 in range(0, var_6, var_5)\n ):\n var_3 = \"No\"\n else:\n var_3 = \"Yes\"\nprint(var_3)\n```", "output": "SLOWER 1.2261", "pair_id": "python_p02975_pair0005_reversed", "problem_id": "p02975", "language": "python", "direction": "reversed", "speedup_ratio": 2.3393} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nfrom sys import stdin\n\nvar_6 = lambda: list(map(int, stdin.readline().split()))\nvar_5 = lambda: list(map(int, stdin.readline().split()))\nvar_1, var_3 = var_6()\nvar_2 = 0\nfor var_4 in range(var_1, var_3 + 1):\n var_7 = str(var_4)\n if var_7 == var_7[::-1]:\n var_2 += 1\nprint(var_2)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_6 in range(var_1, var_2 + 1):\n var_3 = str(var_6)\n var_5 = True\n for var_7 in range(len(var_3) // 2):\n if var_3[var_7] != var_3[-var_7 - 1] and var_5:\n var_5 = not var_5\n if var_5:\n var_4 += 1\nprint(var_4)\n```", "output": "SLOWER 1.4415", "pair_id": "python_p03416_pair0125_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 2.7161} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(str, input().split()))\nvar_1 = int(var_1)\nvar_2 = int(float(var_2) * 1000)\nprint((var_1 * var_2 // 1000))\n```\n\n=== Code B (Modified) ===\n```python\ndef func_1():\n from sys import setrecursionlimit, stdin\n from os import environ\n from collections import defaultdict, deque, Counter\n from math import ceil, floor, gcd\n from itertools import accumulate, combinations, combinations_with_replacement\n\n setrecursionlimit(10**6)\n var_7 = (\n (lambda *var_11: print(*var_11))\n if \"TERM_PROGRAM\" in environ\n else lambda *var_12: 0\n )\n var_8 = lambda: stdin.readline().rstrip()\n var_3 = lambda: list(map(int, var_8().split()))\n var_1 = lambda: int(var_8())\n var_4 = 10**9 + 7\n var_2 = 10**9 + 10\n var_9, var_10 = var_8().split()\n var_5 = int(var_9)\n var_6 = int(float(var_10) * 100 + 0.5)\n print(var_5 * var_6 // 100)\n\n\nfunc_1()\n```", "output": "SLOWER 2.0285", "pair_id": "python_p02659_pair0027_reversed", "problem_id": "p02659", "language": "python", "direction": "reversed", "speedup_ratio": 4.0799} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport numpy as np\n\nvar_7 = input()[::-1]\nvar_6 = len(var_7)\nvar_1 = np.zeros(var_6, dtype=int)\nvar_4 = np.zeros(var_6, dtype=int)\nvar_2 = np.zeros(2019, dtype=int)\nvar_8 = 10\nvar_1[0] = int(var_7[0])\nvar_4[0] = var_1[0]\nvar_2[var_4[0]] += 1\nfor var_5 in range(1, var_6):\n var_1[var_5] = int(var_7[var_5]) * var_8 % 2019\n var_4[var_5] = (var_4[var_5 - 1] + var_1[var_5]) % 2019\n var_2[var_4[var_5]] += 1\n var_8 = var_8 * 10 % 2019\nvar_3 = var_2[np.nonzero(var_2)]\nprint(\n (\n int(\n sum([var_3[var_5] * (var_3[var_5] - 1) for var_5 in range(var_3.shape[0])])\n / 2\n )\n + var_2[0]\n )\n)\n```\n\n=== Code B (Modified) ===\n```python\nvar_5 = input()[::-1]\nvar_2 = [0] * 2019\nvar_2[0] = 1\nvar_4 = 0\nvar_6 = 1\nvar_1 = 0\nfor var_3 in var_5:\n var_4 = (var_4 + int(var_3) * var_6) % 2019\n var_6 = var_6 * 10 % 2019\n var_2[var_4] += 1\nfor var_3 in var_2:\n var_1 += var_3 * (var_3 - 1) // 2\nprint(var_1)\n```", "output": "SLOWER 1.2996", "pair_id": "python_p02702_pair0001_reversed", "problem_id": "p02702", "language": "python", "direction": "reversed", "speedup_ratio": 2.4616} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = str(var_4)\n if var_5[0] == var_5[4] and var_5[1] == var_5[3]:\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = list(str(var_4))\n if var_5 == list(reversed(var_5)):\n var_3 += 1\nprint(var_3)\n```", "output": "SLOWER 1.4984", "pair_id": "python_p03416_pair0126_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 2.8252} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nfrom collections import deque\n\n\ndef func_2(var_9, var_2, var_4):\n\n var_6 = {var_7: dict() for var_7 in range(var_9)}\n for var_7 in range(var_9 - 1):\n var_1, var_3 = var_2[var_7] - 1, var_4[var_7] - 1\n var_6[var_1][var_3] = -1\n var_6[var_3][var_1] = -1\n var_8 = max([len(var_6[var_1]) for var_1 in range(var_9)])\n var_14 = [-1] * var_9\n var_14[0] = var_8 - 1\n\n var_12 = deque([0])\n while len(var_12) > 0:\n var_10 = var_12.popleft()\n var_5 = var_14[var_10]\n for var_11 in list(var_6[var_10].keys()):\n if var_14[var_11] != -1:\n continue\n var_5 += 1\n var_5 %= var_8\n\n var_6[var_10][var_11] = var_5\n var_6[var_11][var_10] = var_5\n var_14[var_11] = var_5\n var_12.append(var_11)\n var_13 = [0] * (var_9 - 1)\n for var_7 in range(var_9 - 1):\n var_13[var_7] = var_6[var_2[var_7] - 1][var_4[var_7] - 1] + 1\n return var_8, var_13\n\n\ndef func_1():\n var_9 = int(eval(input()))\n var_2 = [0] * (var_9 - 1)\n var_4 = [0] * (var_9 - 1)\n for var_7 in range(var_9 - 1):\n var_1, var_3 = list(map(int, input().split()))\n var_2[var_7] = var_1\n var_4[var_7] = var_3\n var_8, var_13 = func_2(var_9, var_2, var_4)\n print(var_8)\n for var_7 in range(var_9 - 1):\n print((var_13[var_7]))\n\n\ndef func_3():\n print((func_2(3, [1, 2], [2, 3])))\n print((func_2(8, [1, 2, 2, 2, 4, 5, 6], [2, 3, 4, 5, 7, 6, 8])))\n\n\nif __name__ == \"__main__\":\n\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nvar_8 = int(eval(input()))\nvar_5 = []\nvar_10 = {}\nvar_9 = [0, 0]\nfor var_6 in range(var_8 - 1):\n var_1, var_2 = list(map(int, input().split(\" \")))\n var_5.append([var_1, var_2])\n var_10.setdefault(var_1, []).append(var_2)\n var_9.append(0)\nvar_7 = 0\nfor var_11 in range(1, var_8 + 1):\n var_13 = var_10.get(var_11, [])\n var_3 = 1\n for var_12 in var_13:\n if var_3 == var_9[var_11]:\n var_3 += 1\n else:\n pass\n var_9[var_12] = var_3\n if var_3 >= var_7:\n var_7 = var_3\n var_3 += 1\nprint(var_7)\nfor var_4 in var_5:\n print((var_9[var_4[1]]))\n```", "output": "FASTER 1.1277", "pair_id": "python_p02850_pair0020_forward", "problem_id": "p02850", "language": "python", "direction": "forward", "speedup_ratio": 2.1851} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_4 = str(var_4)\n if var_4[0] == var_4[-1] and var_4[1] == var_4[-2]:\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = list(reversed(list(str(var_4))))\n if var_5 == list(str(var_4)):\n var_3 += 1\nprint(var_3)\n```", "output": "SLOWER 1.8406", "pair_id": "python_p03416_pair0121_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 3.5817} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1 = list(map(int, input().split()))\nvar_2 = 0\nfor var_3 in range(var_1[0], var_1[1] + 1):\n var_4 = str(var_3)\n if var_4[0] == var_4[4] and var_4[1] == var_4[3]:\n var_2 += 1\nprint(var_2)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n if str(var_4) == \"\".join(reversed(str(var_4))):\n var_3 += 1\nprint(var_3)\n```", "output": "SLOWER 1.365", "pair_id": "python_p03416_pair0059_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 2.5758} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\ndef func_1():\n var_2, var_3, *var_1 = list(map(int, open(0).read().split()))\n var_4 = [0] * (var_3 + max(var_1[::2]))\n for var_7, var_6 in sorted(zip(*[iter(var_1)] * 2)):\n for var_5 in reversed(list(range(var_3))):\n var_4[var_5 + var_7] = max(var_4[var_5 + var_7], var_4[var_5] + var_6)\n print((max(var_4)))\n\n\nfunc_1()\n```\n\n=== Code B (Modified) ===\n```python\nfrom sys import stdin\n\n\ndef func_1():\n\n var_9 = stdin.readline\n var_8, var_10 = list(map(int, var_9().split()))\n var_7 = [list(map(int, var_9().split())) for _ in range(var_8)]\n var_7.sort()\n var_1 = [0] * var_8\n var_2 = [0] * var_8\n for var_4 in range(var_8):\n var_1[var_4], var_2[var_4] = var_7[var_4][0], var_7[var_4][1]\n\n var_5 = -float(\"inf\")\n var_3 = [[var_5] * (var_10 + 1) for _ in range(var_8 + 1)]\n var_3[0][0] = 0\n for var_4 in range(var_8):\n for var_6 in range(var_10 + 1):\n\n if var_6 != var_10:\n var_3[var_4 + 1][min(var_10, var_6 + var_1[var_4])] = max(\n var_3[var_4 + 1][min(var_10, var_6 + var_1[var_4])],\n var_3[var_4][var_6] + var_2[var_4],\n )\n\n var_3[var_4 + 1][var_6] = max(var_3[var_4 + 1][var_6], var_3[var_4][var_6])\n print((max(var_3[var_8])))\n\n\nif __name__ == \"__main__\":\n func_1()\n```", "output": "SLOWER 1.2195", "pair_id": "python_p02863_pair0017_reversed", "problem_id": "p02863", "language": "python", "direction": "reversed", "speedup_ratio": 2.3287} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_2, var_3, *var_1 = list(map(int, open(0).read().split()))\nvar_4 = [0] * (var_3 + max(var_1[::2]))\nfor var_7, var_6 in sorted(zip(*[iter(var_1)] * 2)):\n for var_5 in reversed(list(range(var_3))):\n var_4[var_5 + var_7] = max(var_4[var_5 + var_7], var_4[var_5] + var_6)\nprint((max(var_4)))\n```\n\n=== Code B (Modified) ===\n```python\nvar_6, var_7 = list(map(int, input().split()))\nvar_1 = [list(map(int, input().split())) for _ in range(var_6)]\nvar_1.sort()\nvar_3 = [(6007) * [0] for _ in range(var_6 + 1)]\nvar_3[0][0] = 0\nvar_2 = 0\nfor var_4 in range(var_6):\n for var_5 in range(6007):\n var_3[var_4 + 1][var_5] = max(var_3[var_4 + 1][var_5], var_3[var_4][var_5])\n if var_5 < var_7:\n var_3[var_4 + 1][var_5 + var_1[var_4][0]] = max(\n var_3[var_4][var_5] + var_1[var_4][1],\n var_3[var_4][var_5 + var_1[var_4][0]],\n )\n var_2 = max(var_2, var_3[var_4 + 1][var_5])\nprint(var_2)\n```", "output": "SLOWER 6.3072", "pair_id": "python_p02863_pair0030_reversed", "problem_id": "p02863", "language": "python", "direction": "reversed", "speedup_ratio": 79.1867} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1 = list(map(int, input().split()))\nvar_2 = 0\nfor var_3 in range(var_1[0], var_1[1] + 1):\n var_4 = str(var_3)\n if var_4[0] == var_4[4] and var_4[1] == var_4[3]:\n var_2 += 1\nprint(var_2)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = [0] * (var_2 + 1)\nfor var_3 in range(1, var_2 + 1):\n if str(var_3) == str(var_3)[::-1]:\n var_4[var_3] = var_4[var_3 - 1] + 1\n else:\n var_4[var_3] = var_4[var_3 - 1]\nprint((var_4[var_2] - var_4[var_1 - 1]))\n```", "output": "SLOWER 2.2311", "pair_id": "python_p03416_pair0107_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 4.6949} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = input().split()\nvar_1 = int(var_1)\nvar_3, var_4 = list(map(int, var_2.split(\".\")))\nvar_5 = var_1 * (var_3 * 100 + var_4)\nprint((int(var_5 // 100)))\n```\n\n=== Code B (Modified) ===\n```python\ndef func_1():\n from sys import setrecursionlimit, stdin\n from os import environ\n from collections import defaultdict, deque, Counter\n from math import ceil, floor, gcd\n from itertools import accumulate, combinations, combinations_with_replacement\n\n setrecursionlimit(10**6)\n var_7 = (\n (lambda *var_11: print(*var_11))\n if \"TERM_PROGRAM\" in environ\n else lambda *var_12: 0\n )\n var_8 = lambda: stdin.readline().rstrip()\n var_3 = lambda: list(map(int, var_8().split()))\n var_1 = lambda: int(var_8())\n var_4 = 10**9 + 7\n var_2 = 10**9 + 10\n var_9, var_10 = var_8().split()\n var_5 = int(var_9)\n var_6 = int(float(var_10) * 100 + 0.5)\n print(var_5 * var_6 // 100)\n\n\nfunc_1()\n```", "output": "SLOWER 1.782", "pair_id": "python_p02659_pair0028_reversed", "problem_id": "p02659", "language": "python", "direction": "reversed", "speedup_ratio": 3.4391} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_2 = int(eval(input()))\nvar_1 = list(map(int, input().split()))\nvar_4 = 1\nfor var_3 in range(var_2):\n if var_1[var_3] % 2 == 0:\n var_4 *= 2\nprint((3**var_2 - var_4))\n```\n\n=== Code B (Modified) ===\n```python\nfrom functools import reduce\nfrom itertools import product\n\nvar_2 = int(eval(input()))\n(*var_1,) = list(map(int, input().split()))\nvar_4 = 0\nfor var_7 in product([-1, 0, 1], repeat=var_2):\n var_6 = reduce(\n lambda var_8, var_9: var_8 * var_9,\n [var_3 + var_7[var_5] for var_5, var_3 in enumerate(var_1)],\n )\n if var_6 % 2 == 0:\n var_4 += 1\nprint(var_4)\n```", "output": "SLOWER 9.7762", "pair_id": "python_p03568_pair0018_reversed", "problem_id": "p03568", "language": "python", "direction": "reversed", "speedup_ratio": 876.8612} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_3 = list(map(int, input().split()))\nvar_2 = 0\nfor var_5 in range(var_3 + 1)[var_1:]:\n if len(str(var_5)) % 2 == 0:\n var_6 = list(str(var_5))[: len(str(var_5)) // 2]\n var_7 = list(reversed(list(str(var_5))[len(str(var_5)) // 2 :]))\n if var_6 == var_7:\n var_2 += 1\n else:\n var_8 = list(str(var_5))[: len(str(var_5)) // 2 + 1]\n var_4 = list(reversed(list(str(var_5))[len(str(var_5)) // 2 :]))\n if var_8 == var_4:\n var_2 += 1\nprint(var_2)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = str(var_4)\n if var_5 == var_5[::-1]:\n var_3 += 1\nprint(var_3)\n```", "output": "FASTER 2.479", "pair_id": "python_p03416_pair0056_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 5.5752} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\ndef func_1():\n var_1, var_2 = list(map(int, input().rstrip().split()))\n var_3 = 0\n for var_4 in range(var_1, var_2 + 1):\n var_5 = str(var_4)\n if var_5 == var_5[::-1]:\n var_3 += 1\n print(var_3)\n\n\nif __name__ == \"__main__\":\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().strip().split(\" \")))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n if str(var_4) == str(var_4)[::-1]:\n var_3 += 1\nprint(var_3)\n```", "output": "SLOWER 1.0533", "pair_id": "python_p03416_pair0127_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 2.0752} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nfrom collections import Counter, defaultdict, deque\nfrom heapq import heappop, heappush, heapify\nimport sys, bisect, math, itertools, fractions, pprint\n\nsys.setrecursionlimit(10**8)\nvar_6 = 10**9 + 7\nvar_1 = float(\"inf\")\n\n\ndef func_1():\n return int(sys.stdin.readline())\n\n\ndef func_2():\n return list(map(int, sys.stdin.readline().split()))\n\n\nvar_7, var_9 = func_2()\nvar_13 = [func_2() for _ in range(var_7)]\nvar_13.sort(key=lambda var_14: var_14[1], reverse=True)\nvar_8 = 0\nvar_10 = min(var_7, 5)\nfor var_3 in range(var_10):\n var_2 = [[0] * (var_9 + 5) for _ in range(var_7 + 5)]\n for var_4 in range(var_7):\n var_12, var_11 = var_13[var_4]\n for var_5 in range(var_9):\n if var_5 < var_12 or var_3 == var_4:\n var_2[var_4 + 1][var_5] = var_2[var_4][var_5]\n else:\n var_2[var_4 + 1][var_5] = max(\n var_2[var_4][var_5], var_2[var_4][var_5 - var_12] + var_11\n )\n\n var_8 = max(var_2[var_7][var_9 - 1] + var_13[var_3][1], var_8)\nprint(var_8)\n```\n\n=== Code B (Modified) ===\n```python\nvar_8, var_9 = list(map(int, input().split()))\nvar_5 = [[0] * (var_9 + 3001) for _ in range(var_8 + 1)]\nvar_3 = 0\nvar_2 = [list(map(int, input().split())) for _ in range(var_8)]\nvar_2.sort()\nfor var_6 in range(1, var_8 + 1):\n var_1, var_4 = var_2[var_6 - 1]\n for var_7 in range(var_9):\n var_5[var_6][var_7] = max(var_5[var_6 - 1][var_7], var_5[var_6][var_7])\n var_5[var_6][var_7 + var_1] = var_5[var_6 - 1][var_7] + var_4\n var_3 = max(var_5[var_6][var_7], var_5[var_6][var_7 + var_1], var_3)\nprint(var_3)\n```", "output": "FASTER 1.1289", "pair_id": "python_p02863_pair0031_forward", "problem_id": "p02863", "language": "python", "direction": "forward", "speedup_ratio": 2.1869} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = list(str(var_4))\n if var_5 == list(reversed(var_5)):\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\n\n\ndef func_1(var_5, var_6):\n var_4 = 0\n for var_3 in range(var_5, var_6 + 1):\n if str(var_3) == str(var_3)[::-1]:\n var_4 += 1\n return var_4\n\n\nprint((func_1(var_1, var_2)))\n```", "output": "FASTER 1.5558", "pair_id": "python_p03416_pair0073_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 2.94} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_3 in range(var_1, var_2 + 1):\n var_5 = list(str(var_3))\n var_6 = list(reversed(var_5))\n if var_5 == var_6:\n var_4 += 1\nprint(var_4)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_4 = str(var_4)\n if var_4 == var_4[::-1]:\n var_3 += 1\nprint(var_3)\n```", "output": "FASTER 1.1616", "pair_id": "python_p03416_pair0128_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 2.2371} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_7, var_6 = list(map(int, input().split()))\nvar_5 = [tuple(input().split()) for _ in range(var_6)]\nvar_9 = [[] for _ in range(var_7)]\nfor var_2 in range(var_6):\n var_9[int(var_5[var_2][0]) - 1].append(var_5[var_2][1])\nvar_1, var_8 = 0, 0\nfor var_3 in range(var_7):\n if \"AC\" in var_9[var_3]:\n var_1 += 1\n for var_4 in range(len(var_9[var_3])):\n if var_9[var_3][var_4] == \"WA\":\n var_8 += 1\n else:\n break\nprint((var_1, var_8))\n```\n\n=== Code B (Modified) ===\n```python\nfrom sys import stdin\n\nvar_5 = stdin.readline\nvar_2, var_1 = list(map(int, var_5().split()))\nvar_3 = [False] * var_2\nvar_8 = [0] * var_2\nvar_9 = 0\nfor var_4 in range(var_1):\n var_6, var_7 = var_5().split()\n var_6 = int(var_6) - 1\n if var_3[var_6] is False and var_7 == \"AC\":\n var_9 += var_8[var_6]\n var_3[var_6] = True\n elif var_7 == \"WA\":\n var_8[var_6] += 1\nprint((var_3.count(True), var_9))\n```", "output": "FASTER 3.0644", "pair_id": "python_p02802_pair0006_forward", "problem_id": "p02802", "language": "python", "direction": "forward", "speedup_ratio": 8.3654} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\n\n\ndef func_1(var_5):\n var_4 = 0\n for var_3 in range(1, var_5 + 1):\n if str(var_3) == str(var_3)[::-1]:\n var_4 += 1\n return var_4\n\n\nprint((func_1(var_2) - func_1(var_1 - 1)))\n```\n\n=== Code B (Modified) ===\n```python\nfrom sys import stdin\n\nvar_6 = lambda: list(map(int, stdin.readline().split()))\nvar_5 = lambda: list(map(int, stdin.readline().split()))\nvar_1, var_3 = var_6()\nvar_2 = 0\nfor var_4 in range(var_1, var_3 + 1):\n var_7 = str(var_4)\n if var_7 == var_7[::-1]:\n var_2 += 1\nprint(var_2)\n```", "output": "FASTER 1.5722", "pair_id": "python_p03416_pair0129_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 2.9736} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = list(reversed(list(str(var_4))))\n if var_5 == list(str(var_4)):\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_5 in range(var_1, var_2 + 1):\n var_3 = str(var_5)\n if var_3[0] == var_3[-1] and var_3[1] == var_3[-2]:\n var_4 += 1\nprint(var_4)\n```", "output": "FASTER 1.7485", "pair_id": "python_p03416_pair0130_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 3.3602} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_5 = 0\nif var_5 == 0:\n var_8 = int(eval(input()))\n var_2 = []\n for var_4 in range(var_8):\n var_3 = list(map(int, input().split()))\n var_2.append(var_3)\n var_9 = []\n for var_4 in range(var_8):\n var_10 = list(map(int, input().split()))\n var_9.append(var_10)\nelif var_5 == 1:\n var_8 = 1\n var_2 = [[1, 1, 0, 1, 0, 0, 0, 1, 0, 1]]\n var_9 = [[3, 4, 5, 6, 7, 8, 9, -2, -3, 4, -2]]\nelif var_5 == 2:\n var_8 = 2\n var_2 = [[1, 1, 1, 1, 1, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 1, 1, 1, 1, 1]]\n var_9 = [\n [0, -2, -2, -2, -2, -2, -1, -1, -1, -1, -1],\n [0, -2, -2, -2, -2, -2, -1, -1, -1, -1, -1],\n ]\nelif var_5 == 3:\n var_8 = 3\n var_2 = [\n [1, 1, 1, 1, 1, 1, 0, 0, 1, 1],\n [0, 1, 0, 1, 1, 1, 1, 0, 1, 0],\n [1, 0, 1, 1, 0, 1, 0, 1, 0, 1],\n ]\n var_9 = [\n [-8, 6, -2, -8, -8, 4, 8, 7, -6, 2, 2],\n [-9, 2, 0, 1, 7, -5, 0, -2, -6, 5, 5],\n [6, -6, 7, -9, 6, -5, 8, 0, -9, -7, -7],\n ]\nimport itertools\n\nvar_13 = -(10**11)\nfor var_4 in itertools.product([0, 1], repeat=10):\n var_11 = list(var_4)\n var_12 = 0\n if sum(var_11) != 0:\n for var_7 in range(var_8):\n var_1 = 0\n for var_6 in range(10):\n var_1 = var_1 + var_11[var_6] * var_2[var_7][var_6]\n var_12 = var_12 + var_9[var_7][var_1]\n\n var_13 = max(var_12, var_13)\nprint(var_13)\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\nimport itertools\n\n\ndef func_2(var_4):\n return bin(eval(\"0b\" + str(var_4)))\n\n\ndef func_1():\n var_4 = int(sys.stdin.readline().rstrip())\n var_9 = [\n func_2(\"\".join(str(var_10) for var_10 in sys.stdin.readline().split()))\n for _ in range(var_4)\n ]\n var_8 = [\n [int(var_10) for var_10 in sys.stdin.readline().split()] for _ in range(var_4)\n ]\n var_3 = -(10**10)\n for var_6 in itertools.product(\"01\", repeat=10):\n var_6 = func_2(\"\".join(var_6))\n if var_6 == \"0b0\":\n continue\n var_7 = 0\n for var_2 in range(var_4):\n var_1 = var_9[var_2]\n var_5 = bin(eval(var_1) & eval(var_6)).count(\"1\")\n var_7 += var_8[var_2][var_5]\n var_3 = max(var_3, var_7)\n print(var_3)\n\n\nif __name__ == \"__main__\":\n\n func_1()\n```", "output": "SLOWER 2.1766", "pair_id": "python_p03503_pair0006_reversed", "problem_id": "p03503", "language": "python", "direction": "reversed", "speedup_ratio": 4.5208} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport math\nimport string\n\n\ndef func_4():\n return list(map(int, input().split()))\n\n\ndef func_3(var_6, var_7):\n return math.factorial(var_6) // (\n math.factorial(var_6 - var_7) * math.factorial(var_7)\n )\n\n\ndef func_2(var_9):\n var_8 = []\n for var_5 in var_9:\n if not (var_5 in var_8):\n var_8.append(var_5)\n return len(var_9) != len(var_8)\n\n\ndef func_1(var_6):\n func_1 = []\n for var_4 in range(1, var_6 + 1):\n if var_6 % var_4 == 0:\n func_1.append(var_4)\n return func_1\n\n\nvar_2 = [-1, -1, -1, 0, 0, 1, 1, 1]\nvar_3 = [-1, 0, 1, -1, 1, -1, 0, 1]\nvar_6 = int(eval(input()))\nvar_1 = func_4()\nvar_10 = 1\nfor var_4 in range(len(var_1)):\n if var_1[var_4] % 2 == 0:\n var_10 *= 2\n else:\n var_10 *= 1\nprint((3 ** len(var_1) - var_10))\n```\n\n=== Code B (Modified) ===\n```python\nimport math\nimport string\n\n\ndef func_5():\n return list(map(int, input().split()))\n\n\ndef func_4(var_7, var_8):\n return math.factorial(var_7) // (\n math.factorial(var_7 - var_8) * math.factorial(var_8)\n )\n\n\ndef func_3(var_10):\n var_9 = []\n for var_5 in var_10:\n if not (var_5 in var_9):\n var_9.append(var_5)\n return len(var_10) != len(var_9)\n\n\ndef func_1(var_7):\n func_1 = []\n for var_4 in range(1, var_7 + 1):\n if var_7 % var_4 == 0:\n func_1.append(var_4)\n return func_1\n\n\nvar_2 = [-1, -1, -1, 0, 0, 1, 1, 1]\nvar_3 = [-1, 0, 1, -1, 1, -1, 0, 1]\nvar_7 = int(eval(input()))\nvar_1 = func_5()\n\n\ndef func_2(var_6):\n if len(var_6) == var_7:\n for var_4 in range(len(var_6)):\n if var_6[var_4] % 2 == 0:\n return 1\n return 0\n return (\n func_2(var_6 + [var_1[len(var_6)]])\n + func_2(var_6 + [var_1[len(var_6)] - 1])\n + func_2(var_6 + [var_1[len(var_6)] + 1])\n )\n\n\nprint((func_2([])))\n```", "output": "SLOWER 5.9525", "pair_id": "python_p03568_pair0021_reversed", "problem_id": "p03568", "language": "python", "direction": "reversed", "speedup_ratio": 61.9275} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_5 in range(10):\n for var_6 in range(10):\n for var_7 in range(10):\n var_3 = 10000 * var_5 + 1000 * var_6 + 100 * var_7 + 10 * var_6 + var_5\n if var_1 <= var_3 <= var_2:\n var_4 += 1\nprint(var_4)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_4 = str(var_4)\n if var_4[0] == var_4[-1] and var_4[1] == var_4[-2]:\n var_3 += 1\nprint(var_3)\n```", "output": "SLOWER 3.6418", "pair_id": "python_p03416_pair0087_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 12.4826} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_2, var_1 = list(map(int, input().split()))\nvar_3 = 0\nvar_8 = 0\nvar_4 = [0] * (var_2 + 1)\nvar_9 = [0] * (var_2 + 1)\nfor var_5 in range(var_1):\n var_6, var_7 = input().split()\n var_6 = int(var_6)\n if var_7 == \"AC\":\n if var_4[var_6] == 0:\n var_3 += 1\n var_8 += var_9[var_6]\n var_4[var_6] = 1\n else:\n var_9[var_6] += 1\nprint((var_3, var_8))\n```\n\n=== Code B (Modified) ===\n```python\nvar_6, var_5 = list(map(int, input().split()))\nvar_8 = [[] for _ in range(var_6)]\nfor var_2 in range(var_5):\n var_10, var_11 = input().split()\n var_8[int(var_10) - 1].append(var_11)\n\nvar_1, var_7 = 0, 0\nfor var_3 in range(var_6):\n var_9 = var_8[var_3]\n if \"AC\" in var_9:\n var_1 += 1\n for var_4 in var_9:\n if var_4 == \"WA\":\n var_7 += 1\n else:\n break\nprint((var_1, var_7))\n```", "output": "SLOWER 4.7247", "pair_id": "python_p02802_pair0007_reversed", "problem_id": "p02802", "language": "python", "direction": "reversed", "speedup_ratio": 26.4418} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\nimport itertools\n\n\ndef func_2(var_4):\n return bin(eval(\"0b\" + str(var_4)))\n\n\ndef func_1():\n var_4 = int(sys.stdin.readline().rstrip())\n var_9 = [\n func_2(\"\".join(str(var_10) for var_10 in sys.stdin.readline().split()))\n for _ in range(var_4)\n ]\n var_8 = [\n [int(var_10) for var_10 in sys.stdin.readline().split()] for _ in range(var_4)\n ]\n var_3 = -(10**10)\n for var_6 in itertools.product(\"01\", repeat=10):\n var_6 = func_2(\"\".join(var_6))\n if var_6 == \"0b0\":\n continue\n var_7 = 0\n for var_2 in range(var_4):\n var_1 = var_9[var_2]\n var_5 = bin(eval(var_1) & eval(var_6)).count(\"1\")\n var_7 += var_8[var_2][var_5]\n var_3 = max(var_3, var_7)\n print(var_3)\n\n\nif __name__ == \"__main__\":\n\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\nimport numpy as np\n\nvar_6 = int(eval(input()))\n\nvar_1 = [input().replace(\" \", \"\") for var_4 in range(var_6)]\n\nvar_7 = [list(map(int, input().split())) for var_4 in range(var_6)]\nvar_11 = -999999999999999\nfor var_4 in range(1, 1024):\n var_3 = format(var_4, \"010b\")\n var_9 = 0\n for var_2, var_8 in zip(var_1, var_7):\n var_10 = 0\n for var_5 in range(10):\n if var_2[var_5] == \"1\" and var_3[var_5] == \"1\":\n var_10 += 1\n var_9 += var_8[var_10]\n if var_9 > var_11:\n if var_9 == 0:\n print((str(var_4)))\n break\n var_11 = var_9\nprint(var_11)\n```", "output": "FASTER 3.0752", "pair_id": "python_p03503_pair0023_forward", "problem_id": "p03503", "language": "python", "direction": "forward", "speedup_ratio": 8.4281} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_4 = {}\nvar_5 = 0\nfor var_6 in range(10000, 100000):\n var_3 = list(str(var_6))\n if var_3 == list(reversed(var_3)):\n var_5 += 1\n var_4[var_6] = var_5\nvar_1, var_2 = list(map(int, input().split()))\nprint((var_4[var_2] - var_4[var_1 - 1] if var_1 > 10000 else var_4[var_2]))\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = str(var_4)\n if var_5 == var_5[::-1]:\n var_3 += 1\nprint(var_3)\n```", "output": "FASTER 3.5781", "pair_id": "python_p03416_pair0131_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 11.9428} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = list(str(var_4))\n if var_5 == list(reversed(var_5)):\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\ndef func_1():\n var_1, var_2 = list(map(int, input().split()))\n var_3 = 0\n for var_4 in range(var_1, var_2 + 1):\n\n if (var_4 % 10) == (var_4 // 10000 % 10) and (var_4 // 10 % 10) == (\n var_4 // 1000 % 10\n ):\n var_3 += 1\n print(var_3)\n\n\nif __name__ == \"__main__\":\n func_1()\n```", "output": "FASTER 2.8962", "pair_id": "python_p03416_pair0095_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 7.4448} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1 = list(map(int, input().split()))\nvar_2 = 0\nfor var_3 in range(var_1[0], var_1[1] + 1):\n var_4 = str(var_3)\n if var_4[0] == var_4[4] and var_4[1] == var_4[3]:\n var_2 += 1\nprint(var_2)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n if list(str(var_4)) == list(reversed(str(var_4))):\n var_3 += 1\nprint(var_3)\n```", "output": "SLOWER 1.6892", "pair_id": "python_p03416_pair0132_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 3.2247} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_4, var_3 = list(map(int, input().split()))\nvar_1 = [tuple(map(int, input().split())) for _ in range(var_3)]\nvar_1.sort(key=lambda var_8: var_8[0])\nvar_7 = 1\nvar_2 = 10**9\nfor var_5, var_6 in var_1:\n if var_5 < var_2:\n var_2 = min(var_2, var_6)\n else:\n var_7 += 1\n var_2 = var_6\nprint(var_7)\n```\n\n=== Code B (Modified) ===\n```python\nvar_2, var_1 = [int(var_12) for var_12 in input().split()]\nvar_3 = []\nfor var_8 in range(var_1):\n var_5, var_6 = [int(var_12) for var_12 in input().split()]\n var_3.append((var_5, var_6))\nvar_3.sort()\nvar_9 = float(\"inf\")\nvar_4 = [var_9 for var_5 in range(var_2 + 1)]\nfor var_5, var_6 in var_3:\n var_4[var_5] = min(var_4[var_5], var_6)\nvar_3 = [\n (var_5, var_4[var_5]) for var_5 in range(1, var_2 + 1) if var_4[var_5] != var_9\n]\nvar_3.sort(key=lambda var_11: var_11[1])\nvar_7 = [True] * (var_2)\nvar_10 = None\nfor var_5, var_6 in var_3:\n if var_10 == None or var_10 < var_5:\n var_7[var_6 - 1] = False\n var_10 = var_6 - 1\nprint((sum(1 for var_6 in var_7 if not var_6)))\n```", "output": "SLOWER 1.0247", "pair_id": "python_p03295_pair0002_reversed", "problem_id": "p03295", "language": "python", "direction": "reversed", "speedup_ratio": 2.0345} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = str(var_4)\n if var_5[0] == var_5[4] and var_5[1] == var_5[3]:\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().rstrip().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = list(map(int, list(str(var_4))))\n if var_5[0] == var_5[4] and var_5[1] == var_5[3]:\n var_3 += 1\nprint(var_3)\n```", "output": "SLOWER 1.9492", "pair_id": "python_p03416_pair0133_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 3.8615} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\n\nvar_8 = sys.stdin.readline\n\n\ndef func_1():\n var_2 = int(eval(var_8()))\n var_1 = [int(var_8().replace(\" \", \"\"), 2) for _ in range(var_2)]\n var_3 = [list(map(int, var_8().split())) for _ in range(var_2)]\n var_4 = -(10**7) * var_2\n for var_7 in range(1, 1 << 10):\n var_10 = 0\n for var_9, var_6 in enumerate(var_1):\n var_5 = bin(var_7 & var_6).count(\"1\")\n var_10 += var_3[var_9][var_5]\n var_4 = max(var_4, var_10)\n print(var_4)\n\n\nif __name__ == \"__main__\":\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nimport itertools\n\nvar_6 = int(eval(input()))\nvar_2 = [[]] * var_6\nfor var_4 in range(var_6):\n var_3 = list(map(int, input().split()))\n\n var_2[var_4] = var_3\nvar_8 = [[]] * var_6\nfor var_4 in range(var_6):\n var_9 = list(map(int, input().split()))\n var_8[var_4] = var_9\nvar_10 = -(10**11)\nfor var_1 in itertools.product([0, 1], repeat=10):\n if sum(var_1) == 0:\n continue\n var_11 = 0\n for var_7 in range(var_6):\n var_5 = 0\n for var_4 in range(10):\n if var_2[var_7][var_4] == 1 and var_1[var_4] == 1:\n var_5 += 1\n var_11 = var_11 + var_8[var_7][var_5]\n var_10 = max(var_10, var_11)\nprint(var_10)\n```", "output": "SLOWER 2.7112", "pair_id": "python_p03503_pair0024_reversed", "problem_id": "p03503", "language": "python", "direction": "reversed", "speedup_ratio": 6.5485} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\nimport math\nfrom collections import defaultdict\nfrom bisect import bisect_left, bisect_right\n\nsys.setrecursionlimit(10**7)\n\n\ndef func_4():\n return sys.stdin.readline()[:-1]\n\n\nvar_4 = 10**9 + 7\n\n\ndef func_1():\n return int(eval(func_4()))\n\n\ndef func_2():\n return list(map(int, func_4().split()))\n\n\ndef func_3(var_6, var_3):\n if var_6 <= 0:\n return [[] for _ in range(var_3)]\n elif var_3 == 1:\n return [func_1() for _ in range(var_6)]\n else:\n var_5 = [func_2() for _ in range(var_6)]\n return list(map(list, list(zip(*var_5))))\n\n\nfrom decimal import getcontext, Decimal\n\ngetcontext().prec = 28\nvar_1, var_2 = list(map(str, func_4().split()))\nvar_1 = int(var_1)\nvar_2 = Decimal(var_2)\nprint((int(var_1 * var_2)))\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = input().split()\nvar_1 = int(var_1)\nvar_2 = int(\"\".join(var_2.split(\".\")))\nprint(((var_1 * var_2) // 100))\n```", "output": "FASTER 2.485", "pair_id": "python_p02659_pair0029_forward", "problem_id": "p02659", "language": "python", "direction": "forward", "speedup_ratio": 5.5983} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport itertools\n\nvar_6 = int(eval(input()))\nvar_2 = [[]] * var_6\nfor var_4 in range(var_6):\n var_3 = list(map(int, input().split()))\n\n var_2[var_4] = var_3\nvar_8 = [[]] * var_6\nfor var_4 in range(var_6):\n var_9 = list(map(int, input().split()))\n var_8[var_4] = var_9\nvar_10 = -(10**11)\nfor var_1 in itertools.product([0, 1], repeat=10):\n if sum(var_1) == 0:\n continue\n var_11 = 0\n for var_7 in range(var_6):\n var_5 = 0\n for var_4 in range(10):\n if var_2[var_7][var_4] == 1 and var_1[var_4] == 1:\n var_5 += 1\n var_11 = var_11 + var_8[var_7][var_5]\n var_10 = max(var_10, var_11)\nprint(var_10)\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\n\nvar_7 = sys.stdin.readline\nfrom itertools import combinations\n\n\ndef func_3(var_10):\n for _ in range(var_10):\n yield list(map(int, var_7().split()))\n\n\ndef func_1(var_9, var_5, var_11):\n var_3 = sum(1 if var_5[var_8] == 1 else 0 for var_8 in var_9)\n return var_11[var_3]\n\n\ndef func_2():\n var_10 = int(eval(var_7()))\n var_1 = list(func_3(var_10))\n var_2 = list(func_3(var_10))\n for var_6 in range(1, 11):\n for var_4 in combinations(list(range(10)), var_6):\n yield sum(\n func_1(var_4, var_5, var_11) for var_5, var_11 in zip(var_1, var_2)\n )\n\n\nprint((max(func_2())))\n```", "output": "FASTER 1.0485", "pair_id": "python_p03503_pair0025_forward", "problem_id": "p03503", "language": "python", "direction": "forward", "speedup_ratio": 2.0684} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\ndef func_1():\n var_2 = int(eval(input()))\n var_1 = [int(var_6) for var_6 in input().split()]\n var_4 = 3**var_2\n var_5 = len([var_3 for var_3 in var_1 if var_3 % 2 == 0])\n var_4 -= 2**var_5\n print(var_4)\n\n\nif __name__ == \"__main__\":\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nfrom itertools import product\n\nvar_6 = int(eval(input()))\nvar_1 = list(map(int, input().split()))\nvar_5 = 0\nfor var_2 in product((-1, 0, 1), repeat=var_6):\n var_7 = 1\n for var_3, var_4 in zip(var_1, var_2):\n var_7 *= var_3 + var_4\n if var_7 % 2 == 0:\n var_5 += 1\nprint(var_5)\n```", "output": "SLOWER 9.5197", "pair_id": "python_p03568_pair0022_reversed", "problem_id": "p03568", "language": "python", "direction": "reversed", "speedup_ratio": 734.0288} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\n\nvar_8 = sys.stdin.readline\n\n\ndef func_1():\n var_2 = int(eval(var_8()))\n var_1 = [int(var_8().replace(\" \", \"\"), 2) for _ in range(var_2)]\n var_3 = [list(map(int, var_8().split())) for _ in range(var_2)]\n var_4 = -(10**7) * var_2\n for var_7 in range(1, 1 << 10):\n var_10 = 0\n for var_9, var_6 in enumerate(var_1):\n var_5 = bin(var_7 & var_6).count(\"1\")\n var_10 += var_3[var_9][var_5]\n var_4 = max(var_4, var_10)\n print(var_4)\n\n\nif __name__ == \"__main__\":\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\nimport itertools\n\n\ndef func_2(var_4):\n return bin(eval(\"0b\" + str(var_4)))\n\n\ndef func_1():\n var_4 = int(sys.stdin.readline().rstrip())\n var_9 = [\n func_2(\"\".join(str(var_10) for var_10 in sys.stdin.readline().split()))\n for _ in range(var_4)\n ]\n var_8 = [\n [int(var_10) for var_10 in sys.stdin.readline().split()] for _ in range(var_4)\n ]\n var_3 = -(10**10)\n for var_6 in itertools.product(\"01\", repeat=10):\n var_6 = func_2(\"\".join(var_6))\n if var_6 == \"0b0\":\n continue\n var_7 = 0\n for var_2 in range(var_4):\n var_1 = var_9[var_2]\n var_5 = bin(eval(var_1) & eval(var_6)).count(\"1\")\n var_7 += var_8[var_2][var_5]\n var_3 = max(var_3, var_7)\n print(var_3)\n\n\nif __name__ == \"__main__\":\n\n func_1()\n```", "output": "SLOWER 5.3117", "pair_id": "python_p03503_pair0026_reversed", "problem_id": "p03503", "language": "python", "direction": "reversed", "speedup_ratio": 39.7178} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nfrom functools import reduce\nfrom itertools import product\n\nvar_2 = int(eval(input()))\n(*var_1,) = list(map(int, input().split()))\nvar_4 = 0\nfor var_7 in product([-1, 0, 1], repeat=var_2):\n var_6 = reduce(\n lambda var_8, var_9: var_8 * var_9,\n [var_3 + var_7[var_5] for var_5, var_3 in enumerate(var_1)],\n )\n if var_6 % 2 == 0:\n var_4 += 1\nprint(var_4)\n```\n\n=== Code B (Modified) ===\n```python\nvar_2 = int(eval(input()))\n(*var_1,) = list(map(int, input().split()))\nvar_5 = 0\nfor var_3 in var_1:\n if var_3 % 2 == 0:\n var_5 += 1\nvar_4 = 3**var_2 - 2**var_5\nprint(var_4)\n```", "output": "FASTER 9.7614", "pair_id": "python_p03568_pair0023_forward", "problem_id": "p03568", "language": "python", "direction": "forward", "speedup_ratio": 867.9334} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\nimport itertools\n\n\ndef func_2(var_4):\n return bin(eval(\"0b\" + str(var_4)))\n\n\ndef func_1():\n var_4 = int(sys.stdin.readline().rstrip())\n var_9 = [\n func_2(\"\".join(str(var_10) for var_10 in sys.stdin.readline().split()))\n for _ in range(var_4)\n ]\n var_8 = [\n [int(var_10) for var_10 in sys.stdin.readline().split()] for _ in range(var_4)\n ]\n var_3 = -(10**10)\n for var_6 in itertools.product(\"01\", repeat=10):\n var_6 = func_2(\"\".join(var_6))\n if var_6 == \"0b0\":\n continue\n var_7 = 0\n for var_2 in range(var_4):\n var_1 = var_9[var_2]\n var_5 = bin(eval(var_1) & eval(var_6)).count(\"1\")\n var_7 += var_8[var_2][var_5]\n var_3 = max(var_3, var_7)\n print(var_3)\n\n\nif __name__ == \"__main__\":\n\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nimport itertools\n\nvar_6 = int(eval(input()))\nvar_2 = [[]] * var_6\nfor var_4 in range(var_6):\n var_3 = list(map(int, input().split()))\n\n var_2[var_4] = var_3\nvar_8 = [[]] * var_6\nfor var_4 in range(var_6):\n var_9 = list(map(int, input().split()))\n var_8[var_4] = var_9\nvar_10 = -(10**11)\nfor var_1 in itertools.product([0, 1], repeat=10):\n if sum(var_1) == 0:\n continue\n var_11 = 0\n for var_7 in range(var_6):\n var_5 = 0\n for var_4 in range(10):\n if var_2[var_7][var_4] == 1 and var_1[var_4] == 1:\n var_5 += 1\n var_11 = var_11 + var_8[var_7][var_5]\n var_10 = max(var_10, var_11)\nprint(var_10)\n```", "output": "FASTER 2.6006", "pair_id": "python_p03503_pair0027_forward", "problem_id": "p03503", "language": "python", "direction": "forward", "speedup_ratio": 6.0652} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_2, var_3, *var_1 = list(map(int, open(0).read().split()))\nvar_4 = [0] * (var_3 + max(var_1[::2]))\nfor var_7, var_6 in sorted(zip(*[iter(var_1)] * 2)):\n for var_5 in reversed(list(range(var_3))):\n var_4[var_5 + var_7] = max(var_4[var_5 + var_7], var_4[var_5] + var_6)\nprint((max(var_4)))\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\nfrom operator import itemgetter\nfrom heapq import heapify, heappop, heappush\n\nvar_1 = int(10e15)\nvar_2 = -var_1\nvar_11 = 1000000007\nsys.setrecursionlimit(1000000)\n\n\ndef func_2():\n return list(map(int, input().split()))\n\n\ndef func_4():\n return input().split()\n\n\ndef func_1():\n return int(sys.stdin.readline())\n\n\ndef func_3():\n return eval(input())\n\n\nvar_3, var_4 = func_2()\nvar_5 = [func_2() for var_9 in range(var_3)]\nvar_5.sort(key=itemgetter(0))\n\nvar_8 = [[0] * (var_4 + 1 + 3000 + 1) for _ in range(var_3 + 1)]\nvar_6 = 0\nfor var_9 in range(var_3):\n for var_10 in range(var_4 + 1 + 3000 + 1):\n var_12, var_7 = var_5[var_9]\n if 0 <= var_10 - var_12 < var_4:\n var_8[var_9 + 1][var_10] = max(\n var_8[var_9][var_10], var_8[var_9][var_10 - var_12] + var_7\n )\n else:\n var_8[var_9 + 1][var_10] = var_8[var_9][var_10]\n var_6 = max(var_6, var_8[var_9 + 1][var_10])\nprint(var_6)\n```", "output": "SLOWER 5.4023", "pair_id": "python_p02863_pair0032_reversed", "problem_id": "p02863", "language": "python", "direction": "reversed", "speedup_ratio": 42.2927} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_2, var_1 = list(map(int, input().split()))\nvar_6 = {}\nvar_3 = {}\nfor var_4 in range(var_1):\n var_5, var_7 = input().split()\n var_5 = int(var_5)\n if not var_5 in var_6:\n var_6[var_5] = 0\n var_3[var_5] = 0\n if var_7 == \"WA\" and var_3[var_5] == 0:\n var_6[var_5] += 1\n elif var_7 == \"AC\" and var_3[var_5] == 0:\n var_3[var_5] += 1\nfor var_4 in var_6:\n if var_6[var_4] != 0 and var_3[var_4] == 0:\n var_6[var_4] = 0\nprint((sum(var_3.values()), sum(var_6.values())))\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\n\nvar_2, var_1, *var_3 = sys.stdin.read().strip().split()\nvar_2 = int(var_2)\nvar_5 = [0] * var_2\nvar_10 = [0] * var_2\nfor var_6, var_8 in zip(*[iter(var_3)] * 2):\n var_6 = int(var_6) - 1\n if var_8 == \"AC\":\n var_5[var_6] = 1\n elif var_5[var_6] == 0:\n var_10[var_6] += 1\nvar_7 = sum([var_9 * var_4 for var_4, var_9 in zip(var_5, var_10)])\nprint((\"{} {}\".format(sum(var_5), var_7)))\n```", "output": "SLOWER 2.6258", "pair_id": "python_p02802_pair0008_reversed", "problem_id": "p02802", "language": "python", "direction": "reversed", "speedup_ratio": 6.1723} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_2 = var_2 / 0.1\nvar_3 = [var_4 + var_2 for var_4 in range(10)]\nfor var_4 in var_3:\n if int(var_4 * 0.08) == var_1:\n print((int(var_4)))\n exit()\nprint(\"-1\")\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nfor var_3 in range(1, 1009):\n if int(var_3 * 0.08) == var_1 and int(var_3 * 0.1) == var_2:\n print((int(var_3)))\n exit()\nprint(\"-1\")\n```", "output": "SLOWER 1.9094", "pair_id": "python_p02755_pair0003_reversed", "problem_id": "p02755", "language": "python", "direction": "reversed", "speedup_ratio": 3.7565} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\n\nsys.setrecursionlimit(500000)\n\n\ndef func_2():\n return sys.stdin.readline()[:-1]\n\n\nclass Class_1:\n def __init__(self, var_12):\n self.n = var_12\n self.N0 = 1 << var_12.bit_length()\n self.data = [0] * (self.N0 * 2)\n\n def func_5(self, var_11, var_13, var_16):\n var_11 += self.N0\n var_13 += self.N0\n while var_11 < var_13:\n if var_11 & 1:\n self.data[var_11] = self.data[var_11] + var_16\n var_11 += 1\n if var_13 & 1:\n self.data[var_13 - 1] = self.data[var_13 - 1] + var_16\n var_13 -= 1\n var_11 //= 2\n var_13 //= 2\n\n def func_4(self, var_8):\n var_8 += len(self.data) // 2\n var_14 = self.data[var_8]\n while var_8 > 0:\n var_8 //= 2\n var_14 = var_14 + self.data[var_8]\n return var_14\n\n\ndef func_3():\n var_3, var_2, var_1 = list(map(int, func_2().split()))\n var_6 = []\n for var_8 in range(var_3):\n var_17, var_7 = list(map(int, func_2().split()))\n if var_7 % var_1 == 0:\n var_6.append([var_17, var_7 // var_1])\n else:\n var_6.append([var_17, var_7 // var_1 + 1])\n var_6.sort(key=lambda var_17: var_17[0])\n\n def func_1(var_9):\n var_17 = var_6[var_9][0]\n if var_6[var_3 - 1][0] <= var_17 + 2 * var_2:\n return var_3 - 1\n var_11 = var_9\n var_13 = var_3 - 1\n while var_13 - var_11 > 1:\n if var_6[(var_13 + var_11) // 2][0] <= var_17 + 2 * var_2:\n var_11 = (var_13 + var_11) // 2\n else:\n var_13 = (var_13 + var_11) // 2\n return var_11\n\n var_4 = Class_1(var_3)\n for var_8 in range(var_3):\n var_4.update(var_8, var_8 + 1, var_6[var_8][1])\n var_5 = 0\n for var_8 in range(var_3):\n var_15 = var_4.query(var_8)\n if var_15 > 0:\n var_5 += var_15\n var_10 = func_1(var_8)\n var_4.update(var_8, var_10 + 1, -var_15)\n print(var_5)\n\n\nif __name__ == \"__main__\":\n func_3()\n```\n\n=== Code B (Modified) ===\n```python\nimport bisect\n\nvar_9, var_4, var_1 = list(map(int, input().split()))\nvar_5 = [None] * var_9\nfor var_7 in range(var_9):\n var_11, var_6 = list(map(int, input().split()))\n var_5[var_7] = (var_11, var_6)\nvar_5.sort()\nvar_11 = [int(var_5[var_7][0]) for var_7 in range(var_9)]\nvar_6 = [int(var_5[var_7][1]) for var_7 in range(var_9)]\nvar_2 = 0\nvar_3 = [0] * var_9\nfor var_7 in range(var_9):\n if var_7 != 0:\n var_3[var_7] += var_3[var_7 - 1]\n if var_3[var_7] >= var_6[var_7]:\n continue\n var_10 = (var_6[var_7] - var_3[var_7] - 1) // var_1 + 1\n var_2 += var_10\n var_3[var_7] += var_10 * var_1\n var_8 = bisect.bisect_right(var_11, var_11[var_7] + 2 * var_4)\n if var_8 == var_9:\n continue\n var_3[var_8] -= var_10 * var_1\nprint(var_2)\n```", "output": "FASTER 1.0618", "pair_id": "python_p02788_pair0001_forward", "problem_id": "p02788", "language": "python", "direction": "forward", "speedup_ratio": 2.0876} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_10 = []\nvar_10 = input().rstrip().split(\" \")\nvar_1 = int(var_10[0])\nvar_3 = int(var_10[1])\nvar_2 = 0\nvar_6 = var_1\nwhile var_6 <= var_3:\n var_4 = var_6 // 10000\n var_5 = (var_6 - var_4 * 10000) // 1000\n var_7 = var_6 // 100\n var_8 = (var_6 - var_7 * 100) // 10\n var_9 = var_6 % 10\n if (var_4 == var_9) and (var_5 == var_8):\n var_2 += 1\n var_6 += 1\nprint(var_2)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_5 in range(10):\n for var_6 in range(10):\n for var_7 in range(10):\n var_3 = 10000 * var_5 + 1000 * var_6 + 100 * var_7 + 10 * var_6 + var_5\n if var_1 <= var_3 <= var_2:\n var_4 += 1\nprint(var_4)\n```", "output": "FASTER 4.6346", "pair_id": "python_p03416_pair0006_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 24.8395} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_2 = int(eval(input()))\n(*var_1,) = list(map(int, input().split()))\nvar_5 = 0\nfor var_3 in var_1:\n if var_3 % 2 == 0:\n var_5 += 1\nvar_4 = 3**var_2 - 2**var_5\nprint(var_4)\n```\n\n=== Code B (Modified) ===\n```python\nfrom itertools import product\n\nvar_6 = int(eval(input()))\nvar_1 = list(map(int, input().split()))\nvar_5 = 0\nfor var_2 in product((-1, 0, 1), repeat=var_6):\n var_7 = 1\n for var_3, var_4 in zip(var_1, var_2):\n var_7 *= var_3 + var_4\n if var_7 % 2 == 0:\n var_5 += 1\nprint(var_5)\n```", "output": "SLOWER 10.0319", "pair_id": "python_p03568_pair0024_reversed", "problem_id": "p03568", "language": "python", "direction": "reversed", "speedup_ratio": 1046.9079} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\n\n\ndef func_1(var_5, var_6):\n var_4 = 0\n for var_3 in range(var_5, var_6 + 1):\n if str(var_3) == str(var_3)[::-1]:\n var_4 += 1\n return var_4\n\n\nprint((func_1(var_1, var_2)))\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n if str(var_4) == \"\".join(reversed(str(var_4))):\n var_3 += 1\nprint(var_3)\n```", "output": "SLOWER 1.3999", "pair_id": "python_p03416_pair0134_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 2.6388} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nfrom collections import deque\n\n\ndef func_2(var_9, var_2, var_4):\n\n var_6 = {var_7: dict() for var_7 in range(var_9)}\n for var_7 in range(var_9 - 1):\n var_1, var_3 = var_2[var_7] - 1, var_4[var_7] - 1\n var_6[var_1][var_3] = -1\n var_6[var_3][var_1] = -1\n var_8 = max([len(var_6[var_1]) for var_1 in range(var_9)])\n var_14 = [-1] * var_9\n var_14[0] = var_8 - 1\n\n var_12 = deque([0])\n while len(var_12) > 0:\n var_10 = var_12.popleft()\n var_5 = var_14[var_10]\n for var_11 in list(var_6[var_10].keys()):\n if var_14[var_11] != -1:\n continue\n var_5 += 1\n var_5 %= var_8\n\n var_6[var_10][var_11] = var_5\n var_6[var_11][var_10] = var_5\n var_14[var_11] = var_5\n var_12.append(var_11)\n var_13 = [0] * (var_9 - 1)\n for var_7 in range(var_9 - 1):\n var_13[var_7] = var_6[var_2[var_7] - 1][var_4[var_7] - 1] + 1\n return var_8, var_13\n\n\ndef func_1():\n var_9 = int(eval(input()))\n var_2 = [0] * (var_9 - 1)\n var_4 = [0] * (var_9 - 1)\n for var_7 in range(var_9 - 1):\n var_1, var_3 = list(map(int, input().split()))\n var_2[var_7] = var_1\n var_4[var_7] = var_3\n var_8, var_13 = func_2(var_9, var_2, var_4)\n print(var_8)\n for var_7 in range(var_9 - 1):\n print((var_13[var_7]))\n\n\ndef func_3():\n print((func_2(3, [1, 2], [2, 3])))\n print((func_2(8, [1, 2, 2, 2, 4, 5, 6], [2, 3, 4, 5, 7, 6, 8])))\n\n\nif __name__ == \"__main__\":\n\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nvar_8 = int(eval(input()))\nvar_6 = []\nfor var_7 in range(var_8 - 1):\n var_1, var_3 = list(map(int, input().split()))\n var_6.append([var_1 - 1, var_3 - 1, var_7])\nvar_6.sort()\nvar_12 = [0] * (var_8)\nvar_2 = [0] * (var_8 - 1)\nvar_9 = 1\nvar_10 = 0\nfor var_5 in var_6:\n _from, var_11, var_7 = var_5\n if _from != var_10:\n var_9 = 1\n if var_12[_from] == var_9:\n var_9 += 1\n var_2[var_7] = var_9\n var_12[var_11] = var_9\n var_9 += 1\n var_10 = _from\nprint((max(var_2)))\nfor var_4 in var_2:\n print(var_4)\n```", "output": "FASTER 1.2239", "pair_id": "python_p02850_pair0004_forward", "problem_id": "p02850", "language": "python", "direction": "forward", "speedup_ratio": 2.3358} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport math\nimport string\n\n\ndef func_4():\n return list(map(int, input().split()))\n\n\ndef func_3(var_6, var_7):\n return math.factorial(var_6) // (\n math.factorial(var_6 - var_7) * math.factorial(var_7)\n )\n\n\ndef func_2(var_9):\n var_8 = []\n for var_5 in var_9:\n if not (var_5 in var_8):\n var_8.append(var_5)\n return len(var_9) != len(var_8)\n\n\ndef func_1(var_6):\n func_1 = []\n for var_4 in range(1, var_6 + 1):\n if var_6 % var_4 == 0:\n func_1.append(var_4)\n return func_1\n\n\nvar_2 = [-1, -1, -1, 0, 0, 1, 1, 1]\nvar_3 = [-1, 0, 1, -1, 1, -1, 0, 1]\nvar_6 = int(eval(input()))\nvar_1 = func_4()\nvar_10 = 1\nfor var_4 in range(len(var_1)):\n if var_1[var_4] % 2 == 0:\n var_10 *= 2\n else:\n var_10 *= 1\nprint((3 ** len(var_1) - var_10))\n```\n\n=== Code B (Modified) ===\n```python\nvar_4 = int(eval(input()))\nvar_2 = list(map(int, input().split()))\n\n\ndef func_1(var_1, var_8, var_3):\n if var_8 == var_4:\n var_9 = 1\n for var_5 in var_3:\n var_9 *= var_5\n return 1 if var_9 % 2 == 0 else 0\n var_6 = var_3.copy()\n var_6.append(var_1[var_8] - 1)\n var_5 = var_3.copy()\n var_5.append(var_1[var_8])\n var_7 = var_3.copy()\n var_7.append(var_1[var_8] + 1)\n return (\n func_1(var_1, var_8 + 1, var_6)\n + func_1(var_1, var_8 + 1, var_5)\n + func_1(var_1, var_8 + 1, var_7)\n )\n\n\nprint((func_1(var_2, 0, [])))\n```", "output": "SLOWER 6.5932", "pair_id": "python_p03568_pair0011_reversed", "problem_id": "p03568", "language": "python", "direction": "reversed", "speedup_ratio": 96.5479} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n if str(var_4) == \"\".join(reversed(str(var_4))):\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = [\n var_3 for var_3 in map(str, list(range(var_1, var_2 + 1))) if var_3 == var_3[::-1]\n]\nprint((len(var_4)))\n```", "output": "FASTER 1.7748", "pair_id": "python_p03416_pair0135_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 3.4219} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\nfrom operator import itemgetter\nfrom heapq import heapify, heappop, heappush\n\nvar_1 = int(10e15)\nvar_2 = -var_1\nvar_11 = 1000000007\nsys.setrecursionlimit(1000000)\n\n\ndef func_2():\n return list(map(int, input().split()))\n\n\ndef func_4():\n return input().split()\n\n\ndef func_1():\n return int(sys.stdin.readline())\n\n\ndef func_3():\n return eval(input())\n\n\nvar_3, var_4 = func_2()\nvar_5 = [func_2() for var_9 in range(var_3)]\nvar_5.sort(key=itemgetter(0))\n\nvar_8 = [[0] * (var_4 + 1 + 3000 + 1) for _ in range(var_3 + 1)]\nvar_6 = 0\nfor var_9 in range(var_3):\n for var_10 in range(var_4 + 1 + 3000 + 1):\n var_12, var_7 = var_5[var_9]\n if 0 <= var_10 - var_12 < var_4:\n var_8[var_9 + 1][var_10] = max(\n var_8[var_9][var_10], var_8[var_9][var_10 - var_12] + var_7\n )\n else:\n var_8[var_9 + 1][var_10] = var_8[var_9][var_10]\n var_6 = max(var_6, var_8[var_9 + 1][var_10])\nprint(var_6)\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\n\nsys.setrecursionlimit(2147483647)\nvar_2 = float(\"inf\")\nvar_3 = 10**9 + 7\nvar_10 = lambda: sys.stdin.readline().rstrip()\n\n\ndef func_1():\n var_11, var_4 = list(map(int, var_10().split()))\n var_1 = [tuple(map(int, var_10().split())) for _ in range(var_11)]\n var_1.sort()\n var_8 = [0] * var_4\n var_6 = -var_2\n for var_9 in range(var_11):\n var_5, var_7 = var_1[var_9]\n var_12 = var_8[:]\n for var_13 in range(var_4):\n if var_13 + var_5 < var_4:\n var_12[var_13 + var_5] = max(\n var_12[var_13 + var_5], var_8[var_13] + var_7\n )\n else:\n var_6 = max(var_6, var_8[var_13] + var_7)\n var_8 = var_12\n print((max(var_6, max(var_8))))\n\n\nfunc_1()\n```", "output": "FASTER 5.855", "pair_id": "python_p02863_pair0033_forward", "problem_id": "p02863", "language": "python", "direction": "forward", "speedup_ratio": 57.8788} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\nimport math\nfrom collections import defaultdict\nfrom bisect import bisect_left, bisect_right\n\nsys.setrecursionlimit(10**7)\n\n\ndef func_4():\n return sys.stdin.readline()[:-1]\n\n\nvar_4 = 10**9 + 7\n\n\ndef func_1():\n return int(eval(func_4()))\n\n\ndef func_2():\n return list(map(int, func_4().split()))\n\n\ndef func_3(var_6, var_3):\n if var_6 <= 0:\n return [[] for _ in range(var_3)]\n elif var_3 == 1:\n return [func_1() for _ in range(var_6)]\n else:\n var_5 = [func_2() for _ in range(var_6)]\n return list(map(list, list(zip(*var_5))))\n\n\nvar_1, var_2 = list(map(str, func_4().split()))\nvar_1 = int(var_1)\nvar_2 = 100 * int(var_2[0]) + 10 * int(var_2[2]) + int(var_2[3])\nprint((var_1 * var_2 // 100))\n```\n\n=== Code B (Modified) ===\n```python\nfrom decimal import Decimal\nimport math\n\nvar_1, var_2 = list(map(str, input().split()))\nvar_1 = int(var_1)\nvar_2 = Decimal(var_2)\nvar_3 = math.floor(var_1 * var_2)\nprint((int(var_3)))\n```", "output": "FASTER 1.9772", "pair_id": "python_p02659_pair0030_forward", "problem_id": "p02659", "language": "python", "direction": "forward", "speedup_ratio": 3.9373} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_5 = int(eval(input()))\nvar_7 = list(map(int, input().split()))\nvar_8 = list(map(int, input().split()))\nvar_6 = [[0 for var_2 in range(6)] for var_3 in range(var_5 + 1)]\nvar_1 = abs(var_7[0] - var_8[0])\nvar_6[0][3] = var_6[0][0] = var_1\nvar_6[0][4] = var_6[0][1] = var_1**2\nvar_6[0][5] = var_6[0][2] = var_1**3\nvar_4 = var_1\nfor var_2 in range(1, var_5, 1):\n var_1 = abs(var_7[var_2] - var_8[var_2])\n var_6[var_2][0] = var_1\n var_6[var_2][1] = var_1**2\n var_6[var_2][2] = var_1**3\n var_6[var_2][3] = var_6[var_2 - 1][3] + var_6[var_2][0]\n var_6[var_2][4] = var_6[var_2 - 1][4] + var_6[var_2][1]\n var_6[var_2][5] = var_6[var_2 - 1][5] + var_6[var_2][2]\n if var_1 > var_4:\n var_4 = var_1\nprint((var_6[var_5 - 1][3]))\nprint((var_6[var_5 - 1][4] ** (1 / 2)))\nprint((var_6[var_5 - 1][5] ** (1 / 3)))\nprint(var_4)\n```\n\n=== Code B (Modified) ===\n```python\nvar_3 = int(input())\nvar_6 = list(map(int, input().split()))\nvar_7 = list(map(int, input().split()))\nvar_1 = [abs(var_4 - var_5) for var_4, var_5 in zip(var_6, var_7)]\nvar_2 = lambda var_3: sum([var_4**var_3 for var_4 in var_1]) ** (1 / var_3)\nprint(var_2(1), var_2(2), var_2(3), max(var_1), sep=\"\\n\")\n```", "output": "FASTER 1.2024", "pair_id": "python_p02382_pair0002_forward", "problem_id": "p02382", "language": "python", "direction": "forward", "speedup_ratio": 2.3013} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\ndef func_1():\n var_2, var_3, *var_1 = list(map(int, open(0).read().split()))\n var_4 = [0] * (var_3 + max(var_1[::2]))\n for var_7, var_6 in sorted(zip(*[iter(var_1)] * 2)):\n for var_5 in reversed(list(range(var_3))):\n var_4[var_5 + var_7] = max(var_4[var_5 + var_7], var_4[var_5] + var_6)\n print((max(var_4)))\n\n\nfunc_1()\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_6 = sorted([list(map(int, input().split())) for var_5 in range(var_1)])\n\nvar_4 = [[0] * (var_2 + 1) for var_5 in range(var_1 + 1)]\n\nfor var_5 in range(var_1):\n var_9, var_8 = var_6[var_5]\n for var_7 in range(var_2 + 1):\n if var_7 + var_9 <= var_2:\n var_4[var_5 + 1][var_7 + var_9] = max(\n var_4[var_5 + 1][var_7 + var_9], var_4[var_5][var_7] + var_8\n )\n var_4[var_5 + 1][var_7] = max(var_4[var_5][var_7], var_4[var_5 + 1][var_7])\nvar_3 = 0\nfor var_5, (var_9, var_8) in enumerate(var_6):\n var_3 = max(var_3, var_4[var_5][var_2 - 1] + var_8)\nprint(var_3)\n```", "output": "SLOWER 1.7041", "pair_id": "python_p02863_pair0034_reversed", "problem_id": "p02863", "language": "python", "direction": "reversed", "speedup_ratio": 3.2582} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_6 = str(var_4)\n var_5 = var_6[::-1]\n if var_6 == var_5:\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n if list(str(var_4)) == list(reversed(str(var_4))):\n var_3 += 1\nprint(var_3)\n```", "output": "SLOWER 1.15", "pair_id": "python_p03416_pair0136_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 2.2191} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\nimport itertools\n\n\ndef func_2(var_4):\n return bin(eval(\"0b\" + str(var_4)))\n\n\ndef func_1():\n var_4 = int(sys.stdin.readline().rstrip())\n var_9 = [\n func_2(\"\".join(str(var_10) for var_10 in sys.stdin.readline().split()))\n for _ in range(var_4)\n ]\n var_8 = [\n [int(var_10) for var_10 in sys.stdin.readline().split()] for _ in range(var_4)\n ]\n var_3 = -(10**10)\n for var_6 in itertools.product(\"01\", repeat=10):\n var_6 = func_2(\"\".join(var_6))\n if var_6 == \"0b0\":\n continue\n var_7 = 0\n for var_2 in range(var_4):\n var_1 = var_9[var_2]\n var_5 = bin(eval(var_1) & eval(var_6)).count(\"1\")\n var_7 += var_8[var_2][var_5]\n var_3 = max(var_3, var_7)\n print(var_3)\n\n\nif __name__ == \"__main__\":\n\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\n\nvar_8 = sys.stdin.readline\n\n\ndef func_1():\n var_2 = int(eval(var_8()))\n var_1 = [int(var_8().replace(\" \", \"\"), 2) for _ in range(var_2)]\n var_3 = [list(map(int, var_8().split())) for _ in range(var_2)]\n var_4 = -(10**7) * var_2\n for var_7 in range(1, 1 << 10):\n var_10 = 0\n for var_9, var_6 in enumerate(var_1):\n var_5 = bin(var_7 & var_6).count(\"1\")\n var_10 += var_3[var_9][var_5]\n var_4 = max(var_4, var_10)\n print(var_4)\n\n\nif __name__ == \"__main__\":\n func_1()\n```", "output": "FASTER 5.3117", "pair_id": "python_p03503_pair0026_forward", "problem_id": "p03503", "language": "python", "direction": "forward", "speedup_ratio": 39.7178} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_5, var_4 = map(int, input().split())\nvar_1 = [-1] * var_5\nfor var_3 in range(var_4):\n var_6, var_2 = map(int, input().split())\n if var_6 == 1 and var_2 == 0 and var_5 != 1:\n print(-1)\n exit()\n if var_1[var_6 - 1] == -1 or var_1[var_6 - 1] == var_2:\n var_1[var_6 - 1] = var_2\n else:\n print(-1)\n exit()\nif var_1[0] == -1 and var_5 != 1:\n var_1[0] = 1\nfor var_3 in range(var_5):\n if var_1[var_3] == -1:\n var_1[var_3] = 0\nprint(*var_1, sep=\"\")\n```\n\n=== Code B (Modified) ===\n```python\nimport bisect\nimport copy\nimport heapq\nimport math\nimport sys\nfrom collections import *\nfrom functools import lru_cache\nfrom itertools import accumulate, combinations, permutations, product\n\n\ndef func_1():\n return sys.stdin.readline()[:-1]\n\n\ndef func_2(var_5):\n return [0] + list(accumulate(var_5))\n\n\nsys.setrecursionlimit(500000)\nvar_7 = pow(10, 9) + 7\nvar_1 = [chr(ord(\"a\") + var_4) for var_4 in range(26)]\nvar_3 = [[1, 0], [0, 1], [-1, 0], [0, -1]]\nvar_8, var_6 = list(map(int, func_1().split()))\nvar_10 = [list(map(int, func_1().split())) for var_4 in range(var_6)]\nvar_5 = [-1] * var_8\nfor var_4 in range(var_6):\n var_9, var_2 = var_10[var_4]\n if var_5[var_9 - 1] == -1 or var_5[var_9 - 1] == var_2:\n var_5[var_9 - 1] = var_2\n else:\n print((-1))\n quit()\n\nfor var_4 in range(var_8):\n if var_4 == 0:\n if var_5[var_4] == 0 and var_8 != 1:\n print((-1))\n quit()\n elif var_5[var_4] == -1:\n if var_8 == 1:\n var_5[var_4] = 0\n else:\n var_5[var_4] = 1\n elif var_5[var_4] == -1:\n var_5[var_4] = 0\nprint((\"\".join(map(str, var_5))))\n```", "output": "SLOWER 1.1812", "pair_id": "python_p02761_pair0001_reversed", "problem_id": "p02761", "language": "python", "direction": "reversed", "speedup_ratio": 2.2676} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_2, var_1 = list(map(int, input().split()))\nvar_6 = {}\nvar_3 = {}\nfor var_4 in range(var_1):\n var_5, var_7 = input().split()\n var_5 = int(var_5)\n if not var_5 in var_6:\n var_6[var_5] = 0\n var_3[var_5] = 0\n if var_7 == \"WA\" and var_3[var_5] == 0:\n var_6[var_5] += 1\n elif var_7 == \"AC\" and var_3[var_5] == 0:\n var_3[var_5] += 1\nfor var_4 in var_6:\n if var_6[var_4] != 0 and var_3[var_4] == 0:\n var_6[var_4] = 0\nprint((sum(var_3.values()), sum(var_6.values())))\n```\n\n=== Code B (Modified) ===\n```python\nvar_6, var_5 = list(map(int, input().split()))\nvar_8 = [[] for _ in range(var_6)]\nfor var_2 in range(var_5):\n var_10, var_11 = input().split()\n var_8[int(var_10) - 1].append(var_11)\n\nvar_1, var_7 = 0, 0\nfor var_3 in range(var_6):\n var_9 = var_8[var_3]\n if \"AC\" in var_9:\n var_1 += 1\n for var_4 in var_9:\n if var_4 == \"WA\":\n var_7 += 1\n else:\n break\nprint((var_1, var_7))\n```", "output": "SLOWER 4.403", "pair_id": "python_p02802_pair0001_reversed", "problem_id": "p02802", "language": "python", "direction": "reversed", "speedup_ratio": 21.1554} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_5 in range(10):\n for var_6 in range(10):\n for var_7 in range(10):\n var_3 = 10000 * var_5 + 1000 * var_6 + 100 * var_7 + 10 * var_6 + var_5\n if var_1 <= var_3 <= var_2:\n var_4 += 1\nprint(var_4)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n if list(str(var_4)) == list(reversed(str(var_4))):\n var_3 += 1\nprint(var_3)\n```", "output": "SLOWER 5.2259", "pair_id": "python_p03416_pair0075_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 37.4247} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\nimport itertools\n\n\ndef func_2(var_4):\n return eval(\"0b\" + var_4)\n\n\ndef func_1():\n var_4 = int(sys.stdin.readline().rstrip())\n var_9 = [\n func_2(\"\".join(str(var_10) for var_10 in sys.stdin.readline().split()))\n for _ in range(var_4)\n ]\n var_8 = [\n [int(var_10) for var_10 in sys.stdin.readline().split()] for _ in range(var_4)\n ]\n var_3 = -(10**10)\n for var_6 in itertools.product(\"01\", repeat=10):\n var_6 = func_2(\"\".join(var_6))\n if var_6 == 0:\n continue\n var_7 = 0\n for var_2 in range(var_4):\n var_1 = var_9[var_2]\n var_5 = bin(var_1 & var_6).count(\"1\")\n var_7 += var_8[var_2][var_5]\n var_3 = max(var_3, var_7)\n print(var_3)\n\n\nif __name__ == \"__main__\":\n\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\n\nvar_8 = sys.stdin.readline\n\n\ndef func_1():\n var_2 = int(eval(var_8()))\n var_1 = []\n for _ in range(var_2):\n var_1.append(list(map(int, var_8().split())))\n var_3 = []\n for _ in range(var_2):\n var_3.append(list(map(int, var_8().split())))\n var_4 = -(10**7) * var_2\n for var_7 in range(1, 1 << 10):\n var_11 = 0\n for var_10, var_6 in enumerate(var_1):\n var_5 = 0\n for var_9 in range(10):\n if (var_7 >> var_9) & 1 & var_6[var_9]:\n var_5 += 1\n var_11 += var_3[var_10][var_5]\n var_4 = max(var_4, var_11)\n print(var_4)\n\n\nif __name__ == \"__main__\":\n func_1()\n```", "output": "FASTER 1.366", "pair_id": "python_p03503_pair0028_forward", "problem_id": "p03503", "language": "python", "direction": "forward", "speedup_ratio": 2.5776} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\n\n\ndef func_1(var_5):\n var_4 = 0\n for var_3 in range(1, var_5 + 1):\n if str(var_3) == str(var_3)[::-1]:\n var_4 += 1\n return var_4\n\n\nprint((func_1(var_2) - func_1(var_1 - 1)))\n```\n\n=== Code B (Modified) ===\n```python\ndef func_1():\n var_1, var_2 = list(map(int, input().rstrip().split()))\n var_3 = 0\n for var_4 in range(var_1, var_2 + 1):\n var_5 = str(var_4)\n if var_5 == var_5[::-1]:\n var_3 += 1\n print(var_3)\n\n\nif __name__ == \"__main__\":\n func_1()\n```", "output": "FASTER 2.3366", "pair_id": "python_p03416_pair0031_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 5.0511} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport copy\n\nvar_8 = int(eval(input()))\nvar_10 = set([var_6 for var_6 in range(1, 10**5)])\nvar_5 = []\nvar_11 = {}\nvar_9 = []\nfor var_6 in range(var_8 - 1):\n var_1, var_2 = list(map(int, input().split(\" \")))\n var_5.append([var_1, var_2])\n var_11.setdefault(var_1, []).append(var_2)\n var_9.append([])\nvar_9.append([])\nvar_9.append([])\nvar_7 = 0\nfor var_12 in range(1, var_8 + 1):\n var_14 = var_11.get(var_12, [])\n var_3 = 1\n for var_13 in var_14:\n if var_3 in var_9[var_12]:\n var_3 += 1\n else:\n pass\n var_9[var_13].append(var_3)\n if var_3 >= var_7:\n var_7 = var_3\n var_3 += 1\nprint(var_7)\nfor var_4 in var_5:\n print((var_9[var_4[1]][0]))\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\n\nvar_8 = sys.stdin.readline\nvar_9 = int(eval(var_8()))\nvar_6 = []\nfor var_7 in range(var_9 - 1):\n var_1, var_3 = list(map(int, var_8().split()))\n var_6.append([var_1 - 1, var_3 - 1, var_7])\nvar_6.sort()\nvar_13 = [0] * (var_9)\nvar_2 = [0] * (var_9 - 1)\nvar_10 = 1\nvar_11 = 0\nfor var_5 in var_6:\n _from, var_12, var_7 = var_5\n if _from != var_11:\n var_10 = 1\n if var_13[_from] == var_10:\n var_10 += 1\n var_2[var_7] = var_10\n var_13[var_12] = var_10\n var_10 += 1\n var_11 = _from\nprint((max(var_2)))\nfor var_4 in var_2:\n print(var_4)\n```", "output": "FASTER 4.8454", "pair_id": "python_p02850_pair0021_forward", "problem_id": "p02850", "language": "python", "direction": "forward", "speedup_ratio": 28.7486} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\nimport math\nfrom collections import defaultdict\nfrom bisect import bisect_left, bisect_right\n\nsys.setrecursionlimit(10**7)\n\n\ndef func_4():\n return sys.stdin.readline()[:-1]\n\n\nvar_4 = 10**9 + 7\n\n\ndef func_1():\n return int(eval(func_4()))\n\n\ndef func_2():\n return list(map(int, func_4().split()))\n\n\ndef func_3(var_6, var_3):\n if var_6 <= 0:\n return [[] for _ in range(var_3)]\n elif var_3 == 1:\n return [func_1() for _ in range(var_6)]\n else:\n var_5 = [func_2() for _ in range(var_6)]\n return list(map(list, list(zip(*var_5))))\n\n\nfrom decimal import getcontext, Decimal\n\ngetcontext().prec = 28\nvar_1, var_2 = list(map(str, func_4().split()))\nvar_1 = int(var_1)\nvar_2 = Decimal(var_2)\nprint((int(var_1 * var_2)))\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\n\nvar_3 = sys.stdin.readline\nif __name__ == \"__main__\":\n var_1, var_2 = var_3().split()\n print((int(var_1) * round(float(var_2) * 100) // 100))\n```", "output": "FASTER 2.2434", "pair_id": "python_p02659_pair0031_forward", "problem_id": "p02659", "language": "python", "direction": "forward", "speedup_ratio": 4.7352} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\nfrom operator import itemgetter\nfrom heapq import heapify, heappop, heappush\n\nvar_1 = int(10e15)\nvar_2 = -var_1\nvar_11 = 1000000007\nsys.setrecursionlimit(1000000)\n\n\ndef func_2():\n return list(map(int, input().split()))\n\n\ndef func_4():\n return input().split()\n\n\ndef func_1():\n return int(sys.stdin.readline())\n\n\ndef func_3():\n return eval(input())\n\n\nvar_3, var_4 = func_2()\nvar_5 = [func_2() for var_9 in range(var_3)]\nvar_5.sort(key=itemgetter(0))\n\nvar_8 = [[0] * (var_4 + 1 + 3000 + 1) for _ in range(var_3 + 1)]\nvar_6 = 0\nfor var_9 in range(var_3):\n for var_10 in range(var_4 + 1 + 3000 + 1):\n var_12, var_7 = var_5[var_9]\n if 0 <= var_10 - var_12 < var_4:\n var_8[var_9 + 1][var_10] = max(\n var_8[var_9][var_10], var_8[var_9][var_10 - var_12] + var_7\n )\n else:\n var_8[var_9 + 1][var_10] = var_8[var_9][var_10]\n var_6 = max(var_6, var_8[var_9 + 1][var_10])\nprint(var_6)\n```\n\n=== Code B (Modified) ===\n```python\nvar_2, var_3, *var_1 = list(map(int, open(0).read().split()))\nvar_4 = [0] * (var_3 + max(var_1[::2]))\nfor var_7, var_6 in sorted(zip(*[iter(var_1)] * 2)):\n for var_5 in reversed(list(range(var_3))):\n var_4[var_5 + var_7] = max(var_4[var_5 + var_7], var_4[var_5] + var_6)\nprint((max(var_4)))\n```", "output": "FASTER 5.4023", "pair_id": "python_p02863_pair0032_forward", "problem_id": "p02863", "language": "python", "direction": "forward", "speedup_ratio": 42.2927} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_6 = int(eval(input()))\nvar_2 = list(map(int, input().split()))\nfrom itertools import product\n\nvar_5 = [-1, 0, 1]\nvar_3 = 0\nfor var_7 in product(var_5, repeat=var_6):\n var_1 = []\n for var_4 in range(var_6):\n var_1.append(var_7[var_4] + var_2[var_4])\n if any(var_8 % 2 == 0 for var_8 in var_1):\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\ndef func_1():\n var_2 = int(eval(input()))\n var_1 = [int(var_6) for var_6 in input().split()]\n var_4 = 3**var_2\n var_5 = len([var_3 for var_3 in var_1 if var_3 % 2 == 0])\n var_4 -= 2**var_5\n print(var_4)\n\n\nif __name__ == \"__main__\":\n func_1()\n```", "output": "FASTER 9.3238", "pair_id": "python_p03568_pair0025_forward", "problem_id": "p03568", "language": "python", "direction": "forward", "speedup_ratio": 640.828} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\ndef func_1():\n var_1, var_2 = list(map(int, input().split()))\n var_3 = 0\n for var_4 in range(var_1, var_2 + 1):\n\n if (var_4 % 10) == (var_4 // 10000 % 10) and (var_4 // 10 % 10) == (\n var_4 // 1000 % 10\n ):\n var_3 += 1\n print(var_3)\n\n\nif __name__ == \"__main__\":\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = [0] * (var_2 + 1)\nfor var_3 in range(1, var_2 + 1):\n if str(var_3) == str(var_3)[::-1]:\n var_4[var_3] = var_4[var_3 - 1] + 1\n else:\n var_4[var_3] = var_4[var_3 - 1]\nprint((var_4[var_2] - var_4[var_1 - 1]))\n```", "output": "SLOWER 3.6063", "pair_id": "python_p03416_pair0028_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 12.1789} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_7 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_3 = True\n var_8 = str(var_4)\n var_6 = len(var_8)\n for var_5 in range(var_6 // 2 + 1):\n if var_8[var_5] != var_8[-var_5 - 1]:\n var_3 = False\n break\n if var_3:\n var_7 += 1\nprint(var_7)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = str(var_4)\n if var_5 == var_5[::-1]:\n var_3 += 1\nprint(var_3)\n```", "output": "FASTER 1.1295", "pair_id": "python_p03416_pair0137_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 2.1879} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_3 = int(input())\nvar_6 = list(map(int, input().split()))\nvar_7 = list(map(int, input().split()))\nvar_1 = [abs(var_4 - var_5) for var_4, var_5 in zip(var_6, var_7)]\nvar_2 = lambda var_3: sum([var_4**var_3 for var_4 in var_1]) ** (1 / var_3)\nprint(var_2(1), var_2(2), var_2(3), max(var_1), sep=\"\\n\")\n```\n\n=== Code B (Modified) ===\n```python\nvar_5 = int(eval(input()))\nvar_7 = list(map(int, input().split()))\nvar_8 = list(map(int, input().split()))\nvar_6 = [[0 for var_2 in range(6)] for var_3 in range(var_5 + 1)]\nvar_1 = abs(var_7[0] - var_8[0])\nvar_6[0][3] = var_6[0][0] = var_1\nvar_6[0][4] = var_6[0][1] = var_1**2\nvar_6[0][5] = var_6[0][2] = var_1**3\nvar_4 = var_1\nfor var_2 in range(1, var_5, 1):\n var_1 = abs(var_7[var_2] - var_8[var_2])\n var_6[var_2][0] = var_1\n var_6[var_2][1] = var_1**2\n var_6[var_2][2] = var_1**3\n var_6[var_2][3] = var_6[var_2 - 1][3] + var_6[var_2][0]\n var_6[var_2][4] = var_6[var_2 - 1][4] + var_6[var_2][1]\n var_6[var_2][5] = var_6[var_2 - 1][5] + var_6[var_2][2]\n if var_1 > var_4:\n var_4 = var_1\nprint((var_6[var_5 - 1][3]))\nprint((var_6[var_5 - 1][4] ** (1 / 2)))\nprint((var_6[var_5 - 1][5] ** (1 / 3)))\nprint(var_4)\n```", "output": "SLOWER 1.2024", "pair_id": "python_p02382_pair0002_reversed", "problem_id": "p02382", "language": "python", "direction": "reversed", "speedup_ratio": 2.3013} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_4 = str(var_4)\n if var_4 == var_4[::-1]:\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_3 = list(map(int, input().split()))\nvar_2 = 0\nfor var_5 in range(var_3 + 1)[var_1:]:\n if len(str(var_5)) % 2 == 0:\n var_6 = list(str(var_5))[: len(str(var_5)) // 2]\n var_7 = list(reversed(list(str(var_5))[len(str(var_5)) // 2 :]))\n if var_6 == var_7:\n var_2 += 1\n else:\n var_8 = list(str(var_5))[: len(str(var_5)) // 2 + 1]\n var_4 = list(reversed(list(str(var_5))[len(str(var_5)) // 2 :]))\n if var_8 == var_4:\n var_2 += 1\nprint(var_2)\n```", "output": "SLOWER 2.3275", "pair_id": "python_p03416_pair0138_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 5.0195} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\nimport math\nfrom collections import defaultdict\nfrom bisect import bisect_left, bisect_right\n\nsys.setrecursionlimit(10**7)\n\n\ndef func_4():\n return sys.stdin.readline()[:-1]\n\n\nvar_4 = 10**9 + 7\n\n\ndef func_1():\n return int(eval(func_4()))\n\n\ndef func_2():\n return list(map(int, func_4().split()))\n\n\ndef func_3(var_6, var_3):\n if var_6 <= 0:\n return [[] for _ in range(var_3)]\n elif var_3 == 1:\n return [func_1() for _ in range(var_6)]\n else:\n var_5 = [func_2() for _ in range(var_6)]\n return list(map(list, list(zip(*var_5))))\n\n\nfrom decimal import getcontext, Decimal\n\ngetcontext().prec = 28\nvar_1, var_2 = list(map(str, func_4().split()))\nvar_1 = int(var_1)\nvar_2 = Decimal(var_2)\nprint((int(var_1 * var_2)))\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = input().split()\nvar_1 = int(var_1)\nvar_2 = int(var_2.replace(\".\", \"\"))\nprint((var_1 * var_2 // 100))\n```", "output": "FASTER 2.5637", "pair_id": "python_p02659_pair0022_forward", "problem_id": "p02659", "language": "python", "direction": "forward", "speedup_ratio": 5.9123} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_3 = list(map(int, input().split()))\nvar_2 = 0\nfor var_5 in range(var_3 + 1)[var_1:]:\n if len(str(var_5)) % 2 == 0:\n var_6 = list(str(var_5))[: len(str(var_5)) // 2]\n var_7 = list(reversed(list(str(var_5))[len(str(var_5)) // 2 :]))\n if var_6 == var_7:\n var_2 += 1\n else:\n var_8 = list(str(var_5))[: len(str(var_5)) // 2 + 1]\n var_4 = list(reversed(list(str(var_5))[len(str(var_5)) // 2 :]))\n if var_8 == var_4:\n var_2 += 1\nprint(var_2)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_5 in range(10):\n for var_6 in range(10):\n for var_7 in range(10):\n var_3 = 10000 * var_5 + 1000 * var_6 + 100 * var_7 + 10 * var_6 + var_5\n if var_1 <= var_3 <= var_2:\n var_4 += 1\nprint(var_4)\n```", "output": "FASTER 6.3001", "pair_id": "python_p03416_pair0139_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 78.7987} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport numpy as np\nfrom itertools import product\n\nvar_6 = int(eval(input()))\nvar_2 = list(map(int, input().split()))\nvar_2 = np.array(var_2)\nvar_5 = [-1, 0, 1]\nvar_3 = 0\nfor var_7 in product(var_5, repeat=var_6):\n var_7 = np.array(var_7)\n var_1 = var_2 + var_7\n var_4 = var_1.cumprod()\n if var_4[-1] % 2 == 0:\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nimport math\nimport string\n\n\ndef func_4():\n return list(map(int, input().split()))\n\n\ndef func_3(var_6, var_7):\n return math.factorial(var_6) // (\n math.factorial(var_6 - var_7) * math.factorial(var_7)\n )\n\n\ndef func_2(var_9):\n var_8 = []\n for var_5 in var_9:\n if not (var_5 in var_8):\n var_8.append(var_5)\n return len(var_9) != len(var_8)\n\n\ndef func_1(var_6):\n func_1 = []\n for var_4 in range(1, var_6 + 1):\n if var_6 % var_4 == 0:\n func_1.append(var_4)\n return func_1\n\n\nvar_2 = [-1, -1, -1, 0, 0, 1, 1, 1]\nvar_3 = [-1, 0, 1, -1, 1, -1, 0, 1]\nvar_6 = int(eval(input()))\nvar_1 = func_4()\nvar_10 = 1\nfor var_4 in range(len(var_1)):\n if var_1[var_4] % 2 == 0:\n var_10 *= 2\n else:\n var_10 *= 1\nprint((3 ** len(var_1) - var_10))\n```", "output": "FASTER 8.335", "pair_id": "python_p03568_pair0026_forward", "problem_id": "p03568", "language": "python", "direction": "forward", "speedup_ratio": 322.9207} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_8 in range(var_1, var_2 + 1):\n var_7 = str(var_8)\n var_6 = len(var_7)\n var_4 = True\n for var_5 in range(var_6 // 2):\n if var_7[var_5] != var_7[var_6 - 1 - var_5]:\n var_4 = False\n break\n if var_4:\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_4 = str(var_4)\n if var_4[0] == var_4[-1] and var_4[1] == var_4[-2]:\n var_3 += 1\nprint(var_3)\n```", "output": "FASTER 1.3099", "pair_id": "python_p03416_pair0140_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 2.4793} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\ndef func_1():\n from sys import setrecursionlimit, stdin\n from os import environ\n from collections import defaultdict, deque, Counter\n from math import ceil, floor, gcd\n from itertools import accumulate, combinations, combinations_with_replacement\n\n setrecursionlimit(10**6)\n var_7 = (\n (lambda *var_11: print(*var_11))\n if \"TERM_PROGRAM\" in environ\n else lambda *var_12: 0\n )\n var_8 = lambda: stdin.readline().rstrip()\n var_3 = lambda: list(map(int, var_8().split()))\n var_1 = lambda: int(var_8())\n var_4 = 10**9 + 7\n var_2 = 10**9 + 10\n var_9, var_10 = var_8().split()\n var_5 = int(var_9)\n var_6 = int(float(var_10) * 100 + 0.5)\n print(var_5 * var_6 // 100)\n\n\nfunc_1()\n```\n\n=== Code B (Modified) ===\n```python\nimport math\nfrom decimal import Decimal\n\nvar_1, var_2 = list(map(Decimal, input().split()))\nprint((math.floor(var_1 * var_2)))\n```", "output": "FASTER 2.159", "pair_id": "python_p02659_pair0032_forward", "problem_id": "p02659", "language": "python", "direction": "forward", "speedup_ratio": 4.466} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nimport math\n\nif math.ceil((var_1 + 1) * 12.5) <= math.ceil(var_2 * 10) or math.ceil(\n var_1 * 12.5\n) >= math.ceil((var_2 + 1) * 10):\n print((-1))\nelse:\n print((max(math.ceil(var_1 * 12.5), math.ceil(var_2 * 10))))\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_3 = list(map(int, input().split()))\nvar_2 = -1\nfor var_4 in range(10, 12501):\n if int(var_4 * 0.08) == var_1 and int(var_4 * 0.1) == var_3:\n var_2 = var_4\n break\nprint(var_2)\n```", "output": "SLOWER 5.3196", "pair_id": "python_p02755_pair0004_reversed", "problem_id": "p02755", "language": "python", "direction": "reversed", "speedup_ratio": 39.9354} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1 = list(map(int, input().split()))\nvar_2 = 0\nfor var_3 in range(var_1[0], var_1[1] + 1):\n var_4 = str(var_3)\n if var_4[0] == var_4[4] and var_4[1] == var_4[3]:\n var_2 += 1\nprint(var_2)\n```\n\n=== Code B (Modified) ===\n```python\ndef func_1():\n var_1, var_2 = list(map(int, input().split()))\n var_3 = 0\n for var_4 in range(var_1, var_2 + 1):\n\n if (var_4 % 10) == (var_4 // 10000 % 10) and (var_4 // 10 % 10) == (\n var_4 // 1000 % 10\n ):\n var_3 += 1\n print(var_3)\n\n\nif __name__ == \"__main__\":\n func_1()\n```", "output": "FASTER 1.3752", "pair_id": "python_p03416_pair0053_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 2.5941} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_8 = int(eval(input()))\nvar_5 = []\nvar_10 = {}\nvar_9 = [0, 0]\nfor var_6 in range(var_8 - 1):\n var_1, var_2 = list(map(int, input().split(\" \")))\n var_5.append([var_1, var_2])\n var_10.setdefault(var_1, []).append(var_2)\n var_9.append(0)\nvar_7 = 0\nfor var_11 in range(1, var_8 + 1):\n var_13 = var_10.get(var_11, [])\n var_3 = 1\n for var_12 in var_13:\n if var_3 == var_9[var_11]:\n var_3 += 1\n else:\n pass\n var_9[var_12] = var_3\n if var_3 >= var_7:\n var_7 = var_3\n var_3 += 1\nprint(var_7)\nfor var_4 in var_5:\n print((var_9[var_4[1]]))\n```\n\n=== Code B (Modified) ===\n```python\nfrom collections import deque\n\n\ndef func_2(var_9, var_2, var_4):\n\n var_6 = {var_7: dict() for var_7 in range(var_9)}\n for var_7 in range(var_9 - 1):\n var_1, var_3 = var_2[var_7] - 1, var_4[var_7] - 1\n var_6[var_1][var_3] = -1\n var_6[var_3][var_1] = -1\n var_8 = max([len(var_6[var_1]) for var_1 in range(var_9)])\n var_14 = [-1] * var_9\n var_14[0] = var_8 - 1\n\n var_12 = deque([0])\n while len(var_12) > 0:\n var_10 = var_12.popleft()\n var_5 = var_14[var_10]\n for var_11 in list(var_6[var_10].keys()):\n if var_14[var_11] != -1:\n continue\n var_5 += 1\n var_5 %= var_8\n\n var_6[var_10][var_11] = var_5\n var_6[var_11][var_10] = var_5\n var_14[var_11] = var_5\n var_12.append(var_11)\n var_13 = [0] * (var_9 - 1)\n for var_7 in range(var_9 - 1):\n var_13[var_7] = var_6[var_2[var_7] - 1][var_4[var_7] - 1] + 1\n return var_8, var_13\n\n\ndef func_1():\n var_9 = int(eval(input()))\n var_2 = [0] * (var_9 - 1)\n var_4 = [0] * (var_9 - 1)\n for var_7 in range(var_9 - 1):\n var_1, var_3 = list(map(int, input().split()))\n var_2[var_7] = var_1\n var_4[var_7] = var_3\n var_8, var_13 = func_2(var_9, var_2, var_4)\n print(var_8)\n for var_7 in range(var_9 - 1):\n print((var_13[var_7]))\n\n\ndef func_3():\n print((func_2(3, [1, 2], [2, 3])))\n print((func_2(8, [1, 2, 2, 2, 4, 5, 6], [2, 3, 4, 5, 7, 6, 8])))\n\n\nif __name__ == \"__main__\":\n\n func_1()\n```", "output": "SLOWER 1.1277", "pair_id": "python_p02850_pair0020_reversed", "problem_id": "p02850", "language": "python", "direction": "reversed", "speedup_ratio": 2.1851} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nfrom sys import stdin\n\n\ndef func_1():\n\n var_9 = stdin.readline\n var_8, var_10 = list(map(int, var_9().split()))\n var_7 = [list(map(int, var_9().split())) for _ in range(var_8)]\n var_7.sort()\n var_1 = [0] * var_8\n var_2 = [0] * var_8\n for var_4 in range(var_8):\n var_1[var_4], var_2[var_4] = var_7[var_4][0], var_7[var_4][1]\n\n var_5 = -(10**9)\n var_3 = [[var_5] * (var_10 + 1) for _ in range(var_8 + 1)]\n var_3[0][0] = 0\n for var_4 in range(var_8):\n for var_6 in range(var_10 + 1):\n\n if var_6 != var_10:\n var_3[var_4 + 1][min(var_10, var_6 + var_1[var_4])] = max(\n var_3[var_4 + 1][min(var_10, var_6 + var_1[var_4])],\n var_3[var_4][var_6] + var_2[var_4],\n )\n\n var_3[var_4 + 1][var_6] = max(var_3[var_4 + 1][var_6], var_3[var_4][var_6])\n print((max(var_3[var_8])))\n\n\nif __name__ == \"__main__\":\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nvar_6, var_7 = list(map(int, input().split()))\nvar_1 = [list(map(int, input().split())) for _ in range(var_6)]\nvar_1.sort()\nvar_3 = [(6007) * [0] for _ in range(var_6 + 1)]\nvar_3[0][0] = 0\nvar_2 = 0\nfor var_4 in range(var_6):\n for var_5 in range(6007):\n var_3[var_4 + 1][var_5] = max(var_3[var_4 + 1][var_5], var_3[var_4][var_5])\n if var_5 < var_7:\n var_3[var_4 + 1][var_5 + var_1[var_4][0]] = max(\n var_3[var_4][var_5] + var_1[var_4][1],\n var_3[var_4][var_5 + var_1[var_4][0]],\n )\n var_2 = max(var_2, var_3[var_4 + 1][var_5])\nprint(var_2)\n```", "output": "SLOWER 5.8227", "pair_id": "python_p02863_pair0029_reversed", "problem_id": "p02863", "language": "python", "direction": "reversed", "speedup_ratio": 56.5998} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\nfrom collections import Counter\n\n\ndef func_9():\n return sys.stdin.readline().strip()\n\n\ndef func_10(var_8, var_9, var_10):\n return [[var_10] * var_9 for var_13 in range(var_8)]\n\n\ndef func_11(var_8, var_9, var_10, var_11):\n return [[[var_11] * var_10 for var_14 in range(var_9)] for var_13 in range(var_8)]\n\n\ndef func_12(var_8, var_9, var_10, var_11, var_12):\n return [\n [[[var_12] * var_11 for var_14 in range(var_10)] for var_14 in range(var_9)]\n for var_13 in range(var_8)\n ]\n\n\ndef func_8(var_16, var_17=1):\n return int(-(-var_16 // var_17))\n\n\ndef func_1():\n return int(eval(func_9()))\n\n\ndef func_3():\n return list(map(int, func_9().split()))\n\n\ndef func_2(var_7=None):\n return list(func_3()) if var_7 is None else [func_1() for var_13 in range(var_7)]\n\n\ndef func_7():\n print(\"Yes\")\n\n\ndef func_5():\n print(\"No\")\n\n\ndef func_6():\n print(\"YES\")\n\n\ndef func_4():\n print(\"NO\")\n\n\nsys.setrecursionlimit(10**9)\nvar_3 = 10**18\nvar_6 = 10**9 + 7\nvar_7, var_5, var_4 = func_3()\nvar_1 = func_2()\nvar_2 = func_2()\nvar_15 = min(var_1) + min(var_2)\nfor _ in range(var_4):\n var_16, var_17, var_10 = func_3()\n var_16 -= 1\n var_17 -= 1\n var_15 = min(var_15, var_1[var_16] + var_2[var_17] - var_10)\nprint(var_15)\n```\n\n=== Code B (Modified) ===\n```python\ndef func_1():\n return list(map(int, input().split()))\n\n\nimport numpy as np\n\nvar_1, var_2, var_3 = func_1()\nvar_4 = np.array(list(func_1()))\nvar_6 = np.array(list(func_1()))\nvar_9 = min(var_4) + min(var_6)\nvar_5 = float(\"inf\")\nfor var_8 in range(var_3):\n var_11, var_12, var_7 = func_1()\n var_10 = var_4[var_11 - 1] + var_6[var_12 - 1] - var_7\n var_5 = min(var_5, var_10)\nprint((min(var_5, var_9)))\n```", "output": "FASTER 1.587", "pair_id": "python_p02748_pair0008_forward", "problem_id": "p02748", "language": "python", "direction": "forward", "speedup_ratio": 3.0043} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(str, input().split()))\nvar_1 = int(var_1)\nvar_2 = int(float(var_2) * 1000)\nprint((var_1 * var_2 // 1000))\n```\n\n=== Code B (Modified) ===\n```python\ndef func_1():\n from sys import setrecursionlimit, stdin\n from os import environ\n from collections import defaultdict, deque, Counter\n from math import ceil, floor, gcd\n from itertools import accumulate, combinations, combinations_with_replacement\n\n setrecursionlimit(10**6)\n var_7 = (\n (lambda *var_11: print(*var_11))\n if \"TERM_PROGRAM\" in environ\n else lambda *var_12: 0\n )\n var_8 = lambda: stdin.readline().rstrip()\n var_3 = lambda: list(map(int, var_8().split()))\n var_1 = lambda: int(var_8())\n var_4 = 10**9 + 7\n var_2 = 10**9 + 10\n var_9, var_10 = var_8().split()\n var_5 = int(var_9)\n var_10 = var_10.split(\".\")\n var_6 = int(var_10[0]) * 100\n if len(var_10) == 2:\n var_6 += int(var_10[1])\n print(var_5 * var_6 // 100)\n\n\nfunc_1()\n```", "output": "SLOWER 2.1723", "pair_id": "python_p02659_pair0033_reversed", "problem_id": "p02659", "language": "python", "direction": "reversed", "speedup_ratio": 4.5074} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\n\nvar_7 = sys.stdin.readline\nfrom itertools import combinations\n\n\ndef func_3(var_10):\n for _ in range(var_10):\n yield list(map(int, var_7().split()))\n\n\ndef func_1(var_9, var_5, var_11):\n var_3 = len([0 for var_8 in var_9 if var_5[var_8] == 1])\n return var_11[var_3]\n\n\ndef func_2():\n var_10 = int(eval(var_7()))\n var_1 = list(func_3(var_10))\n var_2 = list(func_3(var_10))\n for var_6 in range(1, 11):\n for var_4 in combinations(list(range(10)), var_6):\n yield sum(\n func_1(var_4, var_5, var_11) for var_5, var_11 in zip(var_1, var_2)\n )\n\n\nprint((max(func_2())))\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\nimport itertools\n\n\ndef func_2(var_4):\n return eval(\"0b\" + var_4)\n\n\ndef func_1():\n var_4 = int(sys.stdin.readline().rstrip())\n var_9 = [\n func_2(\"\".join(str(var_10) for var_10 in sys.stdin.readline().split()))\n for _ in range(var_4)\n ]\n var_8 = [\n [int(var_10) for var_10 in sys.stdin.readline().split()] for _ in range(var_4)\n ]\n var_3 = -(10**10)\n for var_6 in itertools.product(\"01\", repeat=10):\n var_6 = func_2(\"\".join(var_6))\n if var_6 == 0:\n continue\n var_7 = 0\n for var_2 in range(var_4):\n var_1 = var_9[var_2]\n var_5 = bin(var_1 & var_6).count(\"1\")\n var_7 += var_8[var_2][var_5]\n var_3 = max(var_3, var_7)\n print(var_3)\n\n\nif __name__ == \"__main__\":\n\n func_1()\n```", "output": "SLOWER 2.0211", "pair_id": "python_p03503_pair0009_reversed", "problem_id": "p03503", "language": "python", "direction": "reversed", "speedup_ratio": 4.0589} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport math\nimport string\n\n\ndef func_5():\n return list(map(int, input().split()))\n\n\ndef func_4(var_7, var_8):\n return math.factorial(var_7) // (\n math.factorial(var_7 - var_8) * math.factorial(var_8)\n )\n\n\ndef func_3(var_10):\n var_9 = []\n for var_5 in var_10:\n if not (var_5 in var_9):\n var_9.append(var_5)\n return len(var_10) != len(var_9)\n\n\ndef func_1(var_7):\n func_1 = []\n for var_4 in range(1, var_7 + 1):\n if var_7 % var_4 == 0:\n func_1.append(var_4)\n return func_1\n\n\nvar_2 = [-1, -1, -1, 0, 0, 1, 1, 1]\nvar_3 = [-1, 0, 1, -1, 1, -1, 0, 1]\nvar_7 = int(eval(input()))\nvar_1 = func_5()\n\n\ndef func_2(var_6):\n if len(var_6) == var_7:\n for var_4 in range(len(var_6)):\n if var_6[var_4] % 2 == 0:\n return 1\n return 0\n return (\n func_2(var_6 + [var_1[len(var_6)]])\n + func_2(var_6 + [var_1[len(var_6)] - 1])\n + func_2(var_6 + [var_1[len(var_6)] + 1])\n )\n\n\nprint((func_2([])))\n```\n\n=== Code B (Modified) ===\n```python\nfrom functools import reduce\nfrom itertools import product\n\nvar_2 = int(eval(input()))\n(*var_1,) = list(map(int, input().split()))\nvar_4 = 0\nfor var_7 in product([-1, 0, 1], repeat=var_2):\n var_6 = reduce(\n lambda var_8, var_9: var_8 * var_9,\n [var_3 + var_7[var_5] for var_5, var_3 in enumerate(var_1)],\n )\n if var_6 % 2 == 0:\n var_4 += 1\nprint(var_4)\n```", "output": "SLOWER 2.116", "pair_id": "python_p03568_pair0027_reversed", "problem_id": "p03568", "language": "python", "direction": "reversed", "speedup_ratio": 4.3349} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n if list(str(var_4)) == list(reversed(str(var_4))):\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_4 = {}\nvar_5 = 0\nfor var_6 in range(10000, 100000):\n var_3 = list(str(var_6))\n if var_3 == list(reversed(var_3)):\n var_5 += 1\n var_4[var_6] = var_5\nvar_1, var_2 = list(map(int, input().split()))\nprint((var_4[var_2] - var_4[var_1 - 1] if var_1 > 10000 else var_4[var_2]))\n```", "output": "SLOWER 2.1733", "pair_id": "python_p03416_pair0022_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 4.5104} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_10 = []\nvar_10 = input().rstrip().split(\" \")\nvar_1 = int(var_10[0])\nvar_3 = int(var_10[1])\nvar_2 = 0\nvar_6 = var_1\nwhile var_6 <= var_3:\n var_4 = var_6 // 10000\n var_5 = (var_6 - var_4 * 10000) // 1000\n var_7 = var_6 // 100\n var_8 = (var_6 - var_7 * 100) // 10\n var_9 = var_6 % 10\n if (var_4 == var_9) and (var_5 == var_8):\n var_2 += 1\n var_6 += 1\nprint(var_2)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\n\n\ndef func_1(var_5, var_6):\n var_4 = 0\n for var_3 in range(var_5, var_6 + 1):\n if str(var_3) == str(var_3)[::-1]:\n var_4 += 1\n return var_4\n\n\nprint((func_1(var_1, var_2)))\n```", "output": "FASTER 1.1326", "pair_id": "python_p03416_pair0076_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 2.1926} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1 = list(map(int, input().split()))\nvar_2 = 0\nfor var_3 in range(var_1[0], var_1[1] + 1):\n var_4 = str(var_3)\n if var_4[0] == var_4[4] and var_4[1] == var_4[3]:\n var_2 += 1\nprint(var_2)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_7 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_3 = True\n var_8 = str(var_4)\n var_6 = len(var_8)\n for var_5 in range(var_6 // 2 + 1):\n if var_8[var_5] != var_8[-var_5 - 1]:\n var_3 = False\n break\n if var_3:\n var_7 += 1\nprint(var_7)\n```", "output": "SLOWER 1.4139", "pair_id": "python_p03416_pair0013_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 2.6646} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_11 = int(eval(input()))\nvar_12 = {var_8: [] for var_8 in range(1, var_11 + 1)}\nvar_19 = [False for var_8 in range(var_11 + 1)]\nvar_16 = []\nfor _ in range(var_11 - 1):\n var_2, var_3 = list(map(int, input().split()))\n var_12[var_2].append(var_3)\n var_12[var_3].append(var_2)\n var_16.append((var_2, var_3))\nvar_9 = var_16[0][0]\nvar_19[var_9] = True\nvar_6 = []\nvar_7 = []\nvar_14 = {var_8: {} for var_8 in range(1, var_11 + 1)}\nvar_10 = [0 for var_8 in range(var_11 + 1)]\n\nvar_4 = 1\nfor var_5 in var_12[var_9]:\n var_19[var_5] = True\n var_14[var_9][var_5] = var_4\n var_14[var_5][var_9] = var_4\n var_10[var_5] = var_4\n var_4 += 1\n var_6.append(var_5)\nwhile var_6:\n for var_15 in var_6:\n var_13 = 1\n for var_5 in var_12[var_15]:\n if var_19[var_5] == False:\n var_19[var_5] = True\n if var_13 != var_10[var_15]:\n var_14[var_15][var_5] = var_13\n var_14[var_5][var_15] = var_13\n var_10[var_5] = var_13\n var_13 += 1\n var_7.append(var_5)\n else:\n var_13 += 1\n var_14[var_15][var_5] = var_13\n var_14[var_5][var_15] = var_13\n var_10[var_5] = var_13\n var_13 += 1\n var_7.append(var_5)\n if var_7:\n var_6 = var_7\n var_7 = []\n else:\n var_6 = []\n var_7 = []\nvar_1 = 0\nfor var_8 in range(1, var_11 + 1):\n var_1 = max(var_1, len(var_12[var_8]))\nprint(var_1)\nfor var_8 in range(var_11 - 1):\n var_17, var_18 = var_16[var_8][0], var_16[var_8][1]\n print((var_14[var_17][var_18]))\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\nfrom collections import deque\n\nvar_13 = sys.stdin.readline\nvar_2 = int(eval(var_13()))\nvar_5 = [[] for _ in range(var_2)]\nvar_3 = [-1] * var_2\nfor var_12 in range(var_2 - 1):\n var_6, var_8 = list(map(int, var_13().split()))\n var_5[var_6 - 1].append((var_12, var_8 - 1))\n\n\nvar_4 = deque([(0, -1)])\nvar_1 = [-1] * (var_2 - 1)\nvar_11 = 0\nwhile var_4:\n var_14, var_10 = var_4.pop()\n var_9 = 1\n for var_12, var_15 in var_5[var_14]:\n if var_9 == var_10:\n var_9 += 1\n var_1[var_12] = var_9\n var_4.appendleft((var_15, var_9))\n var_9 += 1\n var_11 = max(var_11, var_9 - 1)\nprint(var_11)\nfor var_7 in var_1:\n print(var_7)\n```", "output": "FASTER 1.0676", "pair_id": "python_p02850_pair0007_forward", "problem_id": "p02850", "language": "python", "direction": "forward", "speedup_ratio": 2.0959} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = input().split()\nvar_1 = int(var_1)\nvar_3, var_4 = list(map(int, var_2.split(\".\")))\nvar_5 = var_1 * (var_3 * 100 + var_4)\nprint((int(var_5 // 100)))\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\nimport math\nfrom collections import defaultdict\nfrom bisect import bisect_left, bisect_right\n\nsys.setrecursionlimit(10**7)\n\n\ndef func_4():\n return sys.stdin.readline()[:-1]\n\n\nvar_4 = 10**9 + 7\n\n\ndef func_1():\n return int(eval(func_4()))\n\n\ndef func_2():\n return list(map(int, func_4().split()))\n\n\ndef func_3(var_6, var_3):\n if var_6 <= 0:\n return [[] for _ in range(var_3)]\n elif var_3 == 1:\n return [func_1() for _ in range(var_6)]\n else:\n var_5 = [func_2() for _ in range(var_6)]\n return list(map(list, list(zip(*var_5))))\n\n\nvar_1, var_2 = list(map(str, func_4().split()))\nvar_1 = int(var_1)\nvar_2 = 100 * int(var_2[0]) + 10 * int(var_2[2]) + int(var_2[3])\nprint((var_1 * var_2 // 100))\n```", "output": "SLOWER 2.0781", "pair_id": "python_p02659_pair0034_reversed", "problem_id": "p02659", "language": "python", "direction": "reversed", "speedup_ratio": 4.2224} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\nfrom collections import Counter\n\n\ndef func_10():\n return sys.stdin.readline().strip()\n\n\ndef func_11(var_12, var_13, var_14):\n return [[var_14] * var_13 for var_17 in range(var_12)]\n\n\ndef func_12(var_12, var_13, var_14, var_15):\n return [[[var_15] * var_14 for var_18 in range(var_13)] for var_17 in range(var_12)]\n\n\ndef func_13(var_12, var_13, var_14, var_15, var_16):\n return [\n [[[var_16] * var_15 for var_18 in range(var_14)] for var_18 in range(var_13)]\n for var_17 in range(var_12)\n ]\n\n\ndef func_8(var_22, var_23=1):\n return int(-(-var_22 // var_23))\n\n\ndef func_1():\n return int(eval(func_10()))\n\n\ndef func_3():\n return list(map(int, func_10().split()))\n\n\ndef func_2(var_11=None):\n return list(func_3()) if var_11 is None else [func_1() for var_17 in range(var_11)]\n\n\ndef func_7():\n print(\"Yes\")\n\n\ndef func_5():\n print(\"No\")\n\n\ndef func_6():\n print(\"YES\")\n\n\ndef func_4():\n print(\"NO\")\n\n\nsys.setrecursionlimit(10**9)\nvar_5 = 10**18\nvar_10 = 10**9 + 7\n\n\ndef func_9(var_1, var_2):\n \"\"\"\"\"\"\n import numpy as np\n from numpy.fft import rfft, irfft\n\n var_8 = max(var_1)\n var_9 = max(var_2)\n var_3 = [0] * (var_8 + 1)\n var_4 = [0] * (var_9 + 1)\n for var_12 in var_1:\n var_3[var_12] += 1\n for var_13 in var_2:\n var_4[var_13] += 1\n\n var_6 = 1\n var_19 = 0\n while var_6 <= var_8 + var_9:\n var_19 += 1\n var_6 = 2**var_19\n\n var_21 = irfft(rfft(var_3, var_6) * rfft(var_4, var_6), var_6)\n\n var_21 = np.rint(var_21).astype(np.int64)\n return var_21\n\n\nvar_11, var_7, var_6 = func_3()\nvar_1 = func_2()\nvar_2 = func_2()\nvar_21 = list(func_9(var_1, var_2))\nvar_20 = var_5\nfor var_17, var_12 in enumerate(var_21):\n if var_12 != 0:\n var_20 = var_17\n break\nfor _ in range(var_6):\n var_22, var_23, var_14 = func_3()\n var_22 -= 1\n var_23 -= 1\n var_20 = min(var_20, var_1[var_22] + var_2[var_23] - var_14)\nprint(var_20)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2, var_8 = list(map(int, input().split()))\nvar_4 = list(map(int, input().split()))\nvar_9 = list(map(int, input().split()))\nvar_10 = [list(map(int, input().split())) for var_6 in range(var_8)]\nvar_7 = 200001\nfor var_6 in range(var_8):\n var_5 = var_10[var_6][0] - 1\n var_3 = var_10[var_6][1] - 1\n if var_7 >= var_4[var_5] + var_9[var_3] - var_10[var_6][2]:\n var_7 = var_4[var_5] + var_9[var_3] - var_10[var_6][2]\nvar_4.sort()\nvar_9.sort()\nif var_7 >= (var_4[0] + var_9[0]):\n print((var_4[0] + var_9[0]))\nelse:\n print(var_7)\n```", "output": "FASTER 2.5091", "pair_id": "python_p02748_pair0009_forward", "problem_id": "p02748", "language": "python", "direction": "forward", "speedup_ratio": 5.6927} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_4 = str(var_4)\n if var_4 == var_4[::-1]:\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = list(reversed(list(str(var_4))))\n if var_5 == list(str(var_4)):\n var_3 += 1\nprint(var_3)\n```", "output": "SLOWER 1.5099", "pair_id": "python_p03416_pair0012_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 2.848} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport decimal\n\nvar_1, var_2 = (decimal.Decimal(var_3) for var_3 in input().split())\nprint((int(var_1 * var_2)))\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\nimport math\nfrom collections import defaultdict\nfrom bisect import bisect_left, bisect_right\n\nsys.setrecursionlimit(10**7)\n\n\ndef func_4():\n return sys.stdin.readline()[:-1]\n\n\nvar_4 = 10**9 + 7\n\n\ndef func_1():\n return int(eval(func_4()))\n\n\ndef func_2():\n return list(map(int, func_4().split()))\n\n\ndef func_3(var_6, var_3):\n if var_6 <= 0:\n return [[] for _ in range(var_3)]\n elif var_3 == 1:\n return [func_1() for _ in range(var_6)]\n else:\n var_5 = [func_2() for _ in range(var_6)]\n return list(map(list, list(zip(*var_5))))\n\n\nvar_1, var_2 = list(map(str, func_4().split()))\nvar_1 = int(var_1)\nvar_2 = 100 * int(var_2[0]) + 10 * int(var_2[2]) + int(var_2[3])\nprint((var_1 * var_2 // 100))\n```", "output": "SLOWER 2.2511", "pair_id": "python_p02659_pair0035_reversed", "problem_id": "p02659", "language": "python", "direction": "reversed", "speedup_ratio": 4.7605} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_5 in range(10):\n for var_6 in range(10):\n for var_7 in range(10):\n var_3 = 10000 * var_5 + 1000 * var_6 + 100 * var_7 + 10 * var_6 + var_5\n if var_1 <= var_3 <= var_2:\n var_4 += 1\nprint(var_4)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = list(reversed(list(str(var_4))))\n if var_5 == list(str(var_4)):\n var_3 += 1\nprint(var_3)\n```", "output": "SLOWER 5.4825", "pair_id": "python_p03416_pair0141_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 44.7094} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = [0] * (var_2 + 1)\nfor var_3 in range(1, var_2 + 1):\n if str(var_3) == str(var_3)[::-1]:\n var_4[var_3] = var_4[var_3 - 1] + 1\n else:\n var_4[var_3] = var_4[var_3 - 1]\nprint((var_4[var_2] - var_4[var_1 - 1]))\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\n\n\ndef func_1(var_5, var_6):\n var_4 = 0\n for var_3 in range(var_5, var_6 + 1):\n if str(var_3) == str(var_3)[::-1]:\n var_4 += 1\n return var_4\n\n\nprint((func_1(var_1, var_2)))\n```", "output": "FASTER 2.2659", "pair_id": "python_p03416_pair0097_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 4.8095} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_2 = int(eval(input()))\nvar_1 = list(map(int, input().split()))\nvar_4 = 1\nfor var_3 in range(var_2):\n if var_1[var_3] % 2 == 0:\n var_4 *= 2\nprint((3**var_2 - var_4))\n```\n\n=== Code B (Modified) ===\n```python\nvar_4 = int(eval(input()))\nvar_2 = list(map(int, input().split()))\n\n\ndef func_1(var_1, var_8, var_3):\n if var_8 == var_4:\n var_9 = 1\n for var_5 in var_3:\n var_9 *= var_5\n return 1 if var_9 % 2 == 0 else 0\n var_6 = var_3.copy()\n var_6.append(var_1[var_8] - 1)\n var_5 = var_3.copy()\n var_5.append(var_1[var_8])\n var_7 = var_3.copy()\n var_7.append(var_1[var_8] + 1)\n return (\n func_1(var_1, var_8 + 1, var_6)\n + func_1(var_1, var_8 + 1, var_5)\n + func_1(var_1, var_8 + 1, var_7)\n )\n\n\nprint((func_1(var_2, 0, [])))\n```", "output": "SLOWER 8.3009", "pair_id": "python_p03568_pair0013_reversed", "problem_id": "p03568", "language": "python", "direction": "reversed", "speedup_ratio": 315.3596} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\n\n\ndef func_1(var_5):\n var_4 = 0\n for var_3 in range(1, var_5 + 1):\n if str(var_3) == str(var_3)[::-1]:\n var_4 += 1\n return var_4\n\n\nprint((func_1(var_2) - func_1(var_1 - 1)))\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_6 = str(var_4)\n var_5 = var_6[::-1]\n if var_6 == var_5:\n var_3 += 1\nprint(var_3)\n```", "output": "FASTER 1.3402", "pair_id": "python_p03416_pair0142_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 2.5319} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = [\n var_3 for var_3 in map(str, list(range(var_1, var_2 + 1))) if var_3 == var_3[::-1]\n]\nprint((len(var_4)))\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_7 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_3 = True\n var_8 = str(var_4)\n var_6 = len(var_8)\n for var_5 in range(var_6 // 2 + 1):\n if var_8[var_5] != var_8[-var_5 - 1]:\n var_3 = False\n break\n if var_3:\n var_7 += 1\nprint(var_7)\n```", "output": "SLOWER 1.8237", "pair_id": "python_p03416_pair0062_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 3.5398} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_3 in range(var_1, var_2 + 1):\n var_5 = list(str(var_3))\n var_6 = list(reversed(var_5))\n if var_5 == var_6:\n var_4 += 1\nprint(var_4)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = [\n var_3 for var_3 in map(str, list(range(var_1, var_2 + 1))) if var_3 == var_3[::-1]\n]\nprint((len(var_4)))\n```", "output": "FASTER 2.0072", "pair_id": "python_p03416_pair0008_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 4.02} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport bisect\nimport copy\nimport heapq\nimport math\nimport sys\nfrom collections import *\nfrom functools import lru_cache\nfrom itertools import accumulate, combinations, permutations, product\n\n\ndef func_1():\n return sys.stdin.readline()[:-1]\n\n\ndef func_2(var_5):\n return [0] + list(accumulate(var_5))\n\n\nsys.setrecursionlimit(500000)\nvar_7 = pow(10, 9) + 7\nvar_1 = [chr(ord(\"a\") + var_4) for var_4 in range(26)]\nvar_3 = [[1, 0], [0, 1], [-1, 0], [0, -1]]\nvar_8, var_6 = list(map(int, func_1().split()))\nvar_10 = [list(map(int, func_1().split())) for var_4 in range(var_6)]\nvar_5 = [-1] * var_8\nfor var_4 in range(var_6):\n var_9, var_2 = var_10[var_4]\n if var_5[var_9 - 1] == -1 or var_5[var_9 - 1] == var_2:\n var_5[var_9 - 1] = var_2\n else:\n print((-1))\n quit()\n\nfor var_4 in range(var_8):\n if var_4 == 0:\n if var_5[var_4] == 0 and var_8 != 1:\n print((-1))\n quit()\n elif var_5[var_4] == -1:\n if var_8 == 1:\n var_5[var_4] = 0\n else:\n var_5[var_4] = 1\n elif var_5[var_4] == -1:\n var_5[var_4] = 0\nprint((\"\".join(map(str, var_5))))\n```\n\n=== Code B (Modified) ===\n```python\nvar_5, var_4 = map(int, input().split())\nvar_1 = [-1] * var_5\nfor var_3 in range(var_4):\n var_6, var_2 = map(int, input().split())\n if var_6 == 1 and var_2 == 0 and var_5 != 1:\n print(-1)\n exit()\n if var_1[var_6 - 1] == -1 or var_1[var_6 - 1] == var_2:\n var_1[var_6 - 1] = var_2\n else:\n print(-1)\n exit()\nif var_1[0] == -1 and var_5 != 1:\n var_1[0] = 1\nfor var_3 in range(var_5):\n if var_1[var_3] == -1:\n var_1[var_3] = 0\nprint(*var_1, sep=\"\")\n```", "output": "FASTER 1.1812", "pair_id": "python_p02761_pair0001_forward", "problem_id": "p02761", "language": "python", "direction": "forward", "speedup_ratio": 2.2676} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n if list(str(var_4)) == list(reversed(str(var_4))):\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = str(var_4)\n if var_5[0] == var_5[4] and var_5[1] == var_5[3]:\n var_3 += 1\nprint(var_3)\n```", "output": "FASTER 1.6665", "pair_id": "python_p03416_pair0143_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 3.1745} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = list(str(var_4))\n if var_5 == list(reversed(var_5)):\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nfrom sys import stdin\n\nvar_6 = lambda: list(map(int, stdin.readline().split()))\nvar_5 = lambda: list(map(int, stdin.readline().split()))\nvar_1, var_3 = var_6()\nvar_2 = 0\nfor var_4 in range(var_1, var_3 + 1):\n var_7 = str(var_4)\n if var_7 == var_7[::-1]:\n var_2 += 1\nprint(var_2)\n```", "output": "FASTER 1.2138", "pair_id": "python_p03416_pair0093_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 2.3194} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\n\nvar_8 = sys.stdin.readline\n\n\ndef func_1():\n var_2 = int(eval(var_8()))\n var_1 = [int(var_8().replace(\" \", \"\"), 2) for _ in range(var_2)]\n var_3 = [list(map(int, var_8().split())) for _ in range(var_2)]\n var_4 = -(10**7) * var_2\n for var_7 in range(1, 1 << 10):\n var_10 = 0\n for var_9, var_6 in enumerate(var_1):\n var_5 = bin(var_7 & var_6).count(\"1\")\n var_10 += var_3[var_9][var_5]\n var_4 = max(var_4, var_10)\n print(var_4)\n\n\nif __name__ == \"__main__\":\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\nimport itertools\n\n\ndef func_2(var_4):\n return eval(\"0b\" + var_4)\n\n\ndef func_1():\n var_4 = int(sys.stdin.readline().rstrip())\n var_9 = [\n func_2(\"\".join(str(var_10) for var_10 in sys.stdin.readline().split()))\n for _ in range(var_4)\n ]\n var_8 = [\n [int(var_10) for var_10 in sys.stdin.readline().split()] for _ in range(var_4)\n ]\n var_3 = -(10**10)\n for var_6 in itertools.product(\"01\", repeat=10):\n var_6 = func_2(\"\".join(var_6))\n if var_6 == 0:\n continue\n var_7 = 0\n for var_2 in range(var_4):\n var_1 = var_9[var_2]\n var_5 = bin(var_1 & var_6).count(\"1\")\n var_7 += var_8[var_2][var_5]\n var_3 = max(var_3, var_7)\n print(var_3)\n\n\nif __name__ == \"__main__\":\n\n func_1()\n```", "output": "SLOWER 3.1382", "pair_id": "python_p03503_pair0029_reversed", "problem_id": "p03503", "language": "python", "direction": "reversed", "speedup_ratio": 8.8042} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\nimport math\nfrom collections import defaultdict\nfrom bisect import bisect_left, bisect_right\n\nsys.setrecursionlimit(10**7)\n\n\ndef func_4():\n return sys.stdin.readline()[:-1]\n\n\nvar_4 = 10**9 + 7\n\n\ndef func_1():\n return int(eval(func_4()))\n\n\ndef func_2():\n return list(map(int, func_4().split()))\n\n\ndef func_3(var_6, var_3):\n if var_6 <= 0:\n return [[] for _ in range(var_3)]\n elif var_3 == 1:\n return [func_1() for _ in range(var_6)]\n else:\n var_5 = [func_2() for _ in range(var_6)]\n return list(map(list, list(zip(*var_5))))\n\n\nfrom decimal import getcontext, Decimal\n\ngetcontext().prec = 28\nvar_1, var_2 = list(map(str, func_4().split()))\nvar_1 = int(var_1)\nvar_2 = Decimal(var_2)\nprint((int(var_1 * var_2)))\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\n\nvar_5 = sys.stdin.readline\nif __name__ == \"__main__\":\n var_1, var_3 = var_5().split()\n var_2 = int(var_1)\n var_4 = round(float(var_3) * 100)\n print((var_2 * var_4 // 100))\n```", "output": "FASTER 2.0198", "pair_id": "python_p02659_pair0036_forward", "problem_id": "p02659", "language": "python", "direction": "forward", "speedup_ratio": 4.0552} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nfrom itertools import product\n\nvar_6 = int(eval(input()))\nvar_1 = list(map(int, input().split()))\nvar_5 = 0\nfor var_2 in product((-1, 0, 1), repeat=var_6):\n var_7 = 1\n for var_3, var_4 in zip(var_1, var_2):\n var_7 *= var_3 + var_4\n if var_7 % 2 == 0:\n var_5 += 1\nprint(var_5)\n```\n\n=== Code B (Modified) ===\n```python\ndef func_1():\n var_2 = int(eval(input()))\n var_1 = [int(var_6) for var_6 in input().split()]\n var_4 = 3**var_2\n var_5 = len([var_3 for var_3 in var_1 if var_3 % 2 == 0])\n var_4 -= 2**var_5\n print(var_4)\n\n\nif __name__ == \"__main__\":\n func_1()\n```", "output": "FASTER 9.5197", "pair_id": "python_p03568_pair0022_forward", "problem_id": "p03568", "language": "python", "direction": "forward", "speedup_ratio": 734.0288} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = [0] * (var_2 + 1)\nfor var_3 in range(1, var_2 + 1):\n if str(var_3) == str(var_3)[::-1]:\n var_4[var_3] = var_4[var_3 - 1] + 1\n else:\n var_4[var_3] = var_4[var_3 - 1]\nprint((var_4[var_2] - var_4[var_1 - 1]))\n```\n\n=== Code B (Modified) ===\n```python\nvar_10 = []\nvar_10 = input().rstrip().split(\" \")\nvar_1 = int(var_10[0])\nvar_3 = int(var_10[1])\nvar_2 = 0\nvar_6 = var_1\nwhile var_6 <= var_3:\n var_4 = var_6 // 10000\n var_5 = (var_6 - var_4 * 10000) // 1000\n var_7 = var_6 // 100\n var_8 = (var_6 - var_7 * 100) // 10\n var_9 = var_6 % 10\n if (var_4 == var_9) and (var_5 == var_8):\n var_2 += 1\n var_6 += 1\nprint(var_2)\n```", "output": "FASTER 1.1332", "pair_id": "python_p03416_pair0079_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 2.1935} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_3 = list(map(int, input().split()))\nvar_2 = 0\nfor var_5 in range(var_3 + 1)[var_1:]:\n if len(str(var_5)) % 2 == 0:\n var_6 = list(str(var_5))[: len(str(var_5)) // 2]\n var_7 = list(reversed(list(str(var_5))[len(str(var_5)) // 2 :]))\n if var_6 == var_7:\n var_2 += 1\n else:\n var_8 = list(str(var_5))[: len(str(var_5)) // 2 + 1]\n var_4 = list(reversed(list(str(var_5))[len(str(var_5)) // 2 :]))\n if var_8 == var_4:\n var_2 += 1\nprint(var_2)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_4 = str(var_4)\n if var_4 == var_4[::-1]:\n var_3 += 1\nprint(var_3)\n```", "output": "FASTER 2.3275", "pair_id": "python_p03416_pair0138_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 5.0195} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_5 in range(var_1, var_2 + 1):\n var_3 = str(var_5)\n if var_3[0] == var_3[-1] and var_3[1] == var_3[-2]:\n var_4 += 1\nprint(var_4)\n```\n\n=== Code B (Modified) ===\n```python\ndef func_1():\n var_1, var_2 = list(map(int, input().split()))\n var_3 = 0\n for var_4 in range(var_1, var_2 + 1):\n\n if (var_4 % 10) == (var_4 // 10000 % 10) and (var_4 // 10 % 10) == (\n var_4 // 1000 % 10\n ):\n var_3 += 1\n print(var_3)\n\n\nif __name__ == \"__main__\":\n func_1()\n```", "output": "FASTER 1.5725", "pair_id": "python_p03416_pair0144_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 2.9741} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport copy\n\nvar_8 = int(eval(input()))\nvar_10 = set([var_6 for var_6 in range(1, 10**5)])\nvar_5 = []\nvar_11 = {}\nvar_9 = []\nfor var_6 in range(var_8 - 1):\n var_1, var_2 = list(map(int, input().split(\" \")))\n var_5.append([var_1, var_2])\n var_11.setdefault(var_1, []).append(var_2)\n var_9.append([])\nvar_9.append([])\nvar_9.append([])\nvar_7 = 0\nfor var_12 in range(1, var_8 + 1):\n var_14 = var_11.get(var_12, [])\n var_3 = 1\n for var_13 in var_14:\n if var_3 in var_9[var_12]:\n var_3 += 1\n else:\n pass\n var_9[var_13].append(var_3)\n if var_3 >= var_7:\n var_7 = var_3\n var_3 += 1\nprint(var_7)\nfor var_4 in var_5:\n print((var_9[var_4[1]][0]))\n```\n\n=== Code B (Modified) ===\n```python\nfrom collections import deque\n\n\ndef func_2(var_9, var_2, var_4):\n\n var_6 = {var_7: dict() for var_7 in range(var_9)}\n for var_7 in range(var_9 - 1):\n var_1, var_3 = var_2[var_7] - 1, var_4[var_7] - 1\n var_6[var_1][var_3] = -1\n var_6[var_3][var_1] = -1\n var_8 = max([len(var_6[var_1]) for var_1 in range(var_9)])\n var_14 = [-1] * var_9\n var_14[0] = var_8 - 1\n\n var_12 = deque([0])\n while len(var_12) > 0:\n var_10 = var_12.popleft()\n var_5 = var_14[var_10]\n for var_11 in list(var_6[var_10].keys()):\n if var_14[var_11] != -1:\n continue\n var_5 += 1\n var_5 %= var_8\n\n var_6[var_10][var_11] = var_5\n var_6[var_11][var_10] = var_5\n var_14[var_11] = var_5\n var_12.append(var_11)\n var_13 = [0] * (var_9 - 1)\n for var_7 in range(var_9 - 1):\n var_13[var_7] = var_6[var_2[var_7] - 1][var_4[var_7] - 1] + 1\n return var_8, var_13\n\n\ndef func_1():\n var_9 = int(eval(input()))\n var_2 = [0] * (var_9 - 1)\n var_4 = [0] * (var_9 - 1)\n for var_7 in range(var_9 - 1):\n var_1, var_3 = list(map(int, input().split()))\n var_2[var_7] = var_1\n var_4[var_7] = var_3\n var_8, var_13 = func_2(var_9, var_2, var_4)\n print(var_8)\n for var_7 in range(var_9 - 1):\n print((var_13[var_7]))\n\n\ndef func_3():\n print((func_2(3, [1, 2], [2, 3])))\n print((func_2(8, [1, 2, 2, 2, 4, 5, 6], [2, 3, 4, 5, 7, 6, 8])))\n\n\nif __name__ == \"__main__\":\n\n func_1()\n```", "output": "FASTER 3.6429", "pair_id": "python_p02850_pair0022_forward", "problem_id": "p02850", "language": "python", "direction": "forward", "speedup_ratio": 12.4917} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_6 in range(var_1, var_2 + 1):\n var_3 = str(var_6)\n var_5 = True\n for var_7 in range(len(var_3) // 2):\n if var_3[var_7] != var_3[-var_7 - 1] and var_5:\n var_5 = not var_5\n if var_5:\n var_4 += 1\nprint(var_4)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = input().split()\nvar_1 = int(var_1)\nvar_2 = int(var_2)\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = list(str(var_4))\n if (var_5[0] == var_5[4]) and (var_5[1] == var_5[3]):\n var_3 = var_3 + 1\nprint(var_3)\n```", "output": "FASTER 1.0556", "pair_id": "python_p03416_pair0145_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 2.0786} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = [0] * (var_2 + 1)\nfor var_3 in range(1, var_2 + 1):\n if str(var_3) == str(var_3)[::-1]:\n var_4[var_3] = var_4[var_3 - 1] + 1\n else:\n var_4[var_3] = var_4[var_3 - 1]\nprint((var_4[var_2] - var_4[var_1 - 1]))\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().strip().split(\" \")))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n if str(var_4) == str(var_4)[::-1]:\n var_3 += 1\nprint(var_3)\n```", "output": "FASTER 1.635", "pair_id": "python_p03416_pair0146_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 3.1059} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_5 = 0\nif var_5 == 0:\n var_8 = int(eval(input()))\n var_2 = []\n for var_4 in range(var_8):\n var_3 = list(map(int, input().split()))\n var_2.append(var_3)\n var_9 = []\n for var_4 in range(var_8):\n var_10 = list(map(int, input().split()))\n var_9.append(var_10)\nelif var_5 == 1:\n var_8 = 1\n var_2 = [[1, 1, 0, 1, 0, 0, 0, 1, 0, 1]]\n var_9 = [[3, 4, 5, 6, 7, 8, 9, -2, -3, 4, -2]]\nelif var_5 == 2:\n var_8 = 2\n var_2 = [[1, 1, 1, 1, 1, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 1, 1, 1, 1, 1]]\n var_9 = [\n [0, -2, -2, -2, -2, -2, -1, -1, -1, -1, -1],\n [0, -2, -2, -2, -2, -2, -1, -1, -1, -1, -1],\n ]\nelif var_5 == 3:\n var_8 = 3\n var_2 = [\n [1, 1, 1, 1, 1, 1, 0, 0, 1, 1],\n [0, 1, 0, 1, 1, 1, 1, 0, 1, 0],\n [1, 0, 1, 1, 0, 1, 0, 1, 0, 1],\n ]\n var_9 = [\n [-8, 6, -2, -8, -8, 4, 8, 7, -6, 2, 2],\n [-9, 2, 0, 1, 7, -5, 0, -2, -6, 5, 5],\n [6, -6, 7, -9, 6, -5, 8, 0, -9, -7, -7],\n ]\nimport itertools\n\nvar_13 = -(10**11)\nfor var_4 in itertools.product([0, 1], repeat=10):\n var_11 = list(var_4)\n var_12 = 0\n if sum(var_11) != 0:\n for var_7 in range(var_8):\n var_1 = 0\n for var_6 in range(10):\n var_1 = var_1 + var_11[var_6] * var_2[var_7][var_6]\n var_12 = var_12 + var_9[var_7][var_1]\n\n var_13 = max(var_12, var_13)\nprint(var_13)\n```\n\n=== Code B (Modified) ===\n```python\nfrom sys import stdin\n\n\ndef func_1():\n\n var_13 = stdin.readline\n var_2 = int(var_13())\n var_1 = []\n for var_6 in range(var_2):\n var_5 = list(map(int, var_13().split()))\n var_1.append(var_5)\n var_3 = []\n for var_6 in range(var_2):\n var_12 = list(map(int, var_13().split()))\n var_3.append(var_12)\n var_9 = -float(\"inf\")\n for var_6 in range(1 << 10):\n if var_6 == 0:\n continue\n else:\n var_11 = []\n for var_7 in range(10):\n if (var_6 >> var_7) & 1:\n var_11.append(var_7)\n var_10 = [0] * 10\n for var_7 in var_11:\n var_10[var_7] = 1\n var_14 = 0\n for var_7 in range(var_2):\n var_4 = 0\n for var_8 in range(10):\n if var_10[var_8] == 1 and var_1[var_7][var_8] == 1:\n var_4 += 1\n var_14 += var_3[var_7][var_4]\n var_9 = max(var_14, var_9)\n print(var_9)\n\n\nif __name__ == \"__main__\":\n func_1()\n```", "output": "FASTER 1.1878", "pair_id": "python_p03503_pair0030_forward", "problem_id": "p03503", "language": "python", "direction": "forward", "speedup_ratio": 2.2781} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\ndef func_1():\n var_1, var_2 = list(map(int, input().split()))\n var_3 = 0\n for var_4 in range(var_1, var_2 + 1):\n\n if (var_4 % 10) == (var_4 // 10000 % 10) and (var_4 // 10 % 10) == (\n var_4 // 1000 % 10\n ):\n var_3 += 1\n print(var_3)\n\n\nif __name__ == \"__main__\":\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nfrom sys import stdin\n\nvar_6 = lambda: list(map(int, stdin.readline().split()))\nvar_5 = lambda: list(map(int, stdin.readline().split()))\nvar_1, var_3 = var_6()\nvar_2 = 0\nfor var_4 in range(var_1, var_3 + 1):\n var_7 = str(var_4)\n if var_7 == var_7[::-1]:\n var_2 += 1\nprint(var_2)\n```", "output": "SLOWER 1.6824", "pair_id": "python_p03416_pair0011_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 3.2097} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\n\n\ndef func_1(var_5):\n var_4 = 0\n for var_3 in range(1, var_5 + 1):\n if str(var_3) == str(var_3)[::-1]:\n var_4 += 1\n return var_4\n\n\nprint((func_1(var_2) - func_1(var_1 - 1)))\n```\n\n=== Code B (Modified) ===\n```python\ndef func_1():\n var_1, var_2 = list(map(int, input().split()))\n var_3 = 0\n for var_4 in range(var_1, var_2 + 1):\n\n if (var_4 % 10) == (var_4 // 10000 % 10) and (var_4 // 10 % 10) == (\n var_4 // 1000 % 10\n ):\n var_3 += 1\n print(var_3)\n\n\nif __name__ == \"__main__\":\n func_1()\n```", "output": "FASTER 3.2547", "pair_id": "python_p03416_pair0147_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 9.5445} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\nimport numpy as np\n\nvar_5 = sys.stdin.readline\n\nvar_7 = int(eval(var_5()))\n\nvar_1 = [var_5().replace(\" \", \"\") for var_4 in range(var_7)]\n\nvar_8 = [list(map(int, var_5().split())) for var_4 in range(var_7)]\n\n\nvar_12 = -999999999999999\n\nfor var_4 in range(1, 1024):\n\n var_3 = format(var_4, \"010b\")\n\n var_10 = 0\n for var_2, var_9 in zip(var_1, var_8):\n\n var_11 = 0\n for var_6 in range(10):\n\n if var_2[var_6] == \"1\" and var_3[var_6] == \"1\":\n\n var_11 += 1\n\n var_10 += var_9[var_11]\n if var_10 > var_12:\n\n var_12 = var_10\nprint(var_12)\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\n\nvar_7 = sys.stdin.readline\nfrom itertools import combinations\n\n\ndef func_3(var_10):\n for _ in range(var_10):\n yield list(map(int, var_7().split()))\n\n\ndef func_1(var_9, var_5, var_11):\n var_3 = len([0 for var_8 in var_9 if var_5[var_8] == 1])\n return var_11[var_3]\n\n\ndef func_2():\n var_10 = int(eval(var_7()))\n var_1 = list(func_3(var_10))\n var_2 = list(func_3(var_10))\n for var_6 in range(1, 11):\n for var_4 in combinations(list(range(10)), var_6):\n yield sum(\n func_1(var_4, var_5, var_11) for var_5, var_11 in zip(var_1, var_2)\n )\n\n\nprint((max(func_2())))\n```", "output": "FASTER 1.6251", "pair_id": "python_p03503_pair0031_forward", "problem_id": "p03503", "language": "python", "direction": "forward", "speedup_ratio": 3.0846} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().rstrip().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = list(map(int, list(str(var_4))))\n if var_5[0] == var_5[4] and var_5[1] == var_5[3]:\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\ndef func_1():\n var_1, var_2 = list(map(int, input().split()))\n var_3 = 0\n for var_4 in range(var_1, var_2 + 1):\n\n if (var_4 % 10) == (var_4 // 10000 % 10) and (var_4 // 10 % 10) == (\n var_4 // 1000 % 10\n ):\n var_3 += 1\n print(var_3)\n\n\nif __name__ == \"__main__\":\n func_1()\n```", "output": "FASTER 3.3471", "pair_id": "python_p03416_pair0105_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 10.1758} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_3 = list(map(int, input().split()))\nvar_2 = 0\nfor var_5 in range(var_3 + 1)[var_1:]:\n if len(str(var_5)) % 2 == 0:\n var_6 = list(str(var_5))[: len(str(var_5)) // 2]\n var_7 = list(reversed(list(str(var_5))[len(str(var_5)) // 2 :]))\n if var_6 == var_7:\n var_2 += 1\n else:\n var_8 = list(str(var_5))[: len(str(var_5)) // 2 + 1]\n var_4 = list(reversed(list(str(var_5))[len(str(var_5)) // 2 :]))\n if var_8 == var_4:\n var_2 += 1\nprint(var_2)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_3 in range(var_1, var_2 + 1):\n var_5 = list(str(var_3))\n var_6 = list(reversed(var_5))\n if var_5 == var_6:\n var_4 += 1\nprint(var_4)\n```", "output": "FASTER 1.1659", "pair_id": "python_p03416_pair0148_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 2.2437} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\ndef func_1():\n var_1, var_2 = list(map(int, input().split()))\n var_3 = 0\n for var_4 in range(var_1, var_2 + 1):\n\n if (var_4 % 10) == (var_4 // 10000 % 10) and (var_4 // 10 % 10) == (\n var_4 // 1000 % 10\n ):\n var_3 += 1\n print(var_3)\n\n\nif __name__ == \"__main__\":\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\n\n\ndef func_1(var_5):\n var_4 = 0\n for var_3 in range(1, var_5 + 1):\n if str(var_3) == str(var_3)[::-1]:\n var_4 += 1\n return var_4\n\n\nprint((func_1(var_2) - func_1(var_1 - 1)))\n```", "output": "SLOWER 3.2547", "pair_id": "python_p03416_pair0147_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 9.5445} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_3 = list(map(int, input().split()))\nvar_2 = 0\nfor var_5 in range(var_3 + 1)[var_1:]:\n if len(str(var_5)) % 2 == 0:\n var_6 = list(str(var_5))[: len(str(var_5)) // 2]\n var_7 = list(reversed(list(str(var_5))[len(str(var_5)) // 2 :]))\n if var_6 == var_7:\n var_2 += 1\n else:\n var_8 = list(str(var_5))[: len(str(var_5)) // 2 + 1]\n var_4 = list(reversed(list(str(var_5))[len(str(var_5)) // 2 :]))\n if var_8 == var_4:\n var_2 += 1\nprint(var_2)\n```\n\n=== Code B (Modified) ===\n```python\ndef func_1():\n var_1, var_2 = list(map(int, input().rstrip().split()))\n var_3 = 0\n for var_4 in range(var_1, var_2 + 1):\n var_5 = str(var_4)\n if var_5 == var_5[::-1]:\n var_3 += 1\n print(var_3)\n\n\nif __name__ == \"__main__\":\n func_1()\n```", "output": "FASTER 3.2205", "pair_id": "python_p03416_pair0055_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 9.3213} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport copy\n\nvar_8 = int(eval(input()))\nvar_10 = set([var_6 for var_6 in range(1, 10**5)])\nvar_5 = []\nvar_11 = {}\nvar_9 = []\nfor var_6 in range(var_8 - 1):\n var_1, var_2 = list(map(int, input().split(\" \")))\n var_5.append([var_1, var_2])\n var_11.setdefault(var_1, []).append(var_2)\n var_9.append([])\nvar_9.append([])\nvar_9.append([])\nvar_7 = 0\nfor var_12 in range(1, var_8 + 1):\n var_14 = var_11.get(var_12, [])\n var_3 = 1\n for var_13 in var_14:\n if var_3 in var_9[var_12]:\n var_3 += 1\n else:\n pass\n var_9[var_13].append(var_3)\n if var_3 >= var_7:\n var_7 = var_3\n var_3 += 1\nprint(var_7)\nfor var_4 in var_5:\n print((var_9[var_4[1]][0]))\n```\n\n=== Code B (Modified) ===\n```python\nvar_8 = int(eval(input()))\nvar_5 = []\nvar_10 = {}\nvar_9 = [0, 0]\nfor var_6 in range(var_8 - 1):\n var_1, var_2 = list(map(int, input().split(\" \")))\n var_5.append([var_1, var_2])\n var_10.setdefault(var_1, []).append(var_2)\n var_9.append(0)\nvar_7 = 0\nfor var_11 in range(1, var_8 + 1):\n var_13 = var_10.get(var_11, [])\n var_3 = 1\n for var_12 in var_13:\n if var_3 == var_9[var_11]:\n var_3 += 1\n else:\n pass\n var_9[var_12] = var_3\n if var_3 >= var_7:\n var_7 = var_3\n var_3 += 1\nprint(var_7)\nfor var_4 in var_5:\n print((var_9[var_4[1]]))\n```", "output": "FASTER 4.7706", "pair_id": "python_p02850_pair0023_forward", "problem_id": "p02850", "language": "python", "direction": "forward", "speedup_ratio": 27.2957} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nfrom sys import stdin\n\nvar_6 = lambda: list(map(int, stdin.readline().split()))\nvar_5 = lambda: list(map(int, stdin.readline().split()))\nvar_1, var_3 = var_6()\nvar_2 = 0\nfor var_4 in range(var_1, var_3 + 1):\n var_7 = str(var_4)\n if var_7 == var_7[::-1]:\n var_2 += 1\nprint(var_2)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_7 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_3 = True\n var_8 = str(var_4)\n var_6 = len(var_8)\n for var_5 in range(var_6 // 2 + 1):\n if var_8[var_5] != var_8[-var_5 - 1]:\n var_3 = False\n break\n if var_3:\n var_7 += 1\nprint(var_7)\n```", "output": "SLOWER 1.1067", "pair_id": "python_p03416_pair0149_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 2.1535} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\ndef func_1():\n from sys import setrecursionlimit, stdin\n from os import environ\n from collections import defaultdict, deque, Counter\n from math import ceil, floor, gcd\n from itertools import accumulate, combinations, combinations_with_replacement\n\n setrecursionlimit(10**6)\n var_7 = (\n (lambda *var_11: print(*var_11))\n if \"TERM_PROGRAM\" in environ\n else lambda *var_12: 0\n )\n var_8 = lambda: stdin.readline().rstrip()\n var_3 = lambda: list(map(int, var_8().split()))\n var_1 = lambda: int(var_8())\n var_4 = 10**9 + 7\n var_2 = 10**9 + 10\n var_9, var_10 = var_8().split()\n var_5 = int(var_9)\n var_6 = int(float(var_10) * 100 + 0.5)\n print(var_5 * var_6 // 100)\n\n\nfunc_1()\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = input().split()\nvar_1 = int(var_1)\nvar_2 = int(var_2.replace(\".\", \"\"))\nprint((var_1 * var_2 // 100))\n```", "output": "FASTER 2.2868", "pair_id": "python_p02659_pair0037_forward", "problem_id": "p02659", "language": "python", "direction": "forward", "speedup_ratio": 4.8798} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_4, var_3 = list(map(int, input().split()))\nvar_1 = 0\nfor var_2 in range(var_4, var_3 + 1):\n if str(var_2)[0] + str(var_2)[1] == str(var_2)[-1] + str(var_2)[-2]:\n var_1 += 1\nprint(var_1)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_5 in range(10):\n for var_6 in range(10):\n for var_7 in range(10):\n var_3 = 10000 * var_5 + 1000 * var_6 + 100 * var_7 + 10 * var_6 + var_5\n if var_1 <= var_3 <= var_2:\n var_4 += 1\nprint(var_4)\n```", "output": "FASTER 5.1667", "pair_id": "python_p03416_pair0150_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 35.9185} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\nfrom collections import Counter\n\n\ndef func_9():\n return sys.stdin.readline().strip()\n\n\ndef func_10(var_8, var_9, var_10):\n return [[var_10] * var_9 for var_13 in range(var_8)]\n\n\ndef func_11(var_8, var_9, var_10, var_11):\n return [[[var_11] * var_10 for var_14 in range(var_9)] for var_13 in range(var_8)]\n\n\ndef func_12(var_8, var_9, var_10, var_11, var_12):\n return [\n [[[var_12] * var_11 for var_14 in range(var_10)] for var_14 in range(var_9)]\n for var_13 in range(var_8)\n ]\n\n\ndef func_8(var_16, var_17=1):\n return int(-(-var_16 // var_17))\n\n\ndef func_1():\n return int(eval(func_9()))\n\n\ndef func_3():\n return list(map(int, func_9().split()))\n\n\ndef func_2(var_7=None):\n return list(func_3()) if var_7 is None else [func_1() for var_13 in range(var_7)]\n\n\ndef func_7():\n print(\"Yes\")\n\n\ndef func_5():\n print(\"No\")\n\n\ndef func_6():\n print(\"YES\")\n\n\ndef func_4():\n print(\"NO\")\n\n\nsys.setrecursionlimit(10**9)\nvar_3 = 10**18\nvar_6 = 10**9 + 7\nvar_7, var_5, var_4 = func_3()\nvar_1 = func_2()\nvar_2 = func_2()\nvar_15 = min(var_1) + min(var_2)\nfor _ in range(var_4):\n var_16, var_17, var_10 = func_3()\n var_16 -= 1\n var_17 -= 1\n var_15 = min(var_15, var_1[var_16] + var_2[var_17] - var_10)\nprint(var_15)\n```\n\n=== Code B (Modified) ===\n```python\ndef func_1():\n return list(map(int, input().split()))\n\n\nvar_1, var_2, var_3 = func_1()\nvar_4 = list(func_1())\nvar_6 = list(func_1())\nvar_5 = min(var_4) + min(var_6)\nfor _ in range(var_3):\n var_8, var_9, var_7 = func_1()\n var_5 = min(var_5, var_4[var_8 - 1] + var_6[var_9 - 1] - var_7)\nprint(var_5)\n```", "output": "FASTER 2.0028", "pair_id": "python_p02748_pair0010_forward", "problem_id": "p02748", "language": "python", "direction": "forward", "speedup_ratio": 4.0077} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\ndef func_1():\n var_1, var_2 = list(map(int, input().split()))\n var_3 = 0\n for var_4 in range(var_1, var_2 + 1):\n\n if (var_4 % 10) == (var_4 // 10000 % 10) and (var_4 // 10 % 10) == (\n var_4 // 1000 % 10\n ):\n var_3 += 1\n print(var_3)\n\n\nif __name__ == \"__main__\":\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().strip().split(\" \")))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n if str(var_4) == str(var_4)[::-1]:\n var_3 += 1\nprint(var_3)\n```", "output": "SLOWER 1.9713", "pair_id": "python_p03416_pair0151_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 3.9213} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\n\n\ndef func_1(var_5, var_6):\n var_4 = 0\n for var_3 in range(var_5, var_6 + 1):\n if str(var_3) == str(var_3)[::-1]:\n var_4 += 1\n return var_4\n\n\nprint((func_1(var_1, var_2)))\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_3 in range(var_1, var_2 + 1):\n var_5 = list(str(var_3))\n var_6 = list(reversed(var_5))\n if var_5 == var_6:\n var_4 += 1\nprint(var_4)\n```", "output": "SLOWER 1.6323", "pair_id": "python_p03416_pair0152_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 3.1} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport decimal\n\nvar_1, var_2 = (decimal.Decimal(var_3) for var_3 in input().split())\nprint((int(var_1 * var_2)))\n```\n\n=== Code B (Modified) ===\n```python\ndef func_1():\n from sys import setrecursionlimit, stdin\n from os import environ\n from collections import defaultdict, deque, Counter\n from math import ceil, floor, gcd\n from itertools import accumulate, combinations, combinations_with_replacement\n\n setrecursionlimit(10**6)\n var_7 = (\n (lambda *var_11: print(*var_11))\n if \"TERM_PROGRAM\" in environ\n else lambda *var_12: 0\n )\n var_8 = lambda: stdin.readline().rstrip()\n var_3 = lambda: list(map(int, var_8().split()))\n var_1 = lambda: int(var_8())\n var_4 = 10**9 + 7\n var_2 = 10**9 + 10\n var_9, var_10 = var_8().split()\n var_5 = int(var_9)\n var_6 = int(float(var_10) * 100 + 0.5)\n print(var_5 * var_6 // 100)\n\n\nfunc_1()\n```", "output": "SLOWER 1.9551", "pair_id": "python_p02659_pair0038_reversed", "problem_id": "p02659", "language": "python", "direction": "reversed", "speedup_ratio": 3.8775} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_4 = str(var_4)\n if var_4[0] == var_4[-1] and var_4[1] == var_4[-2]:\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\ndef func_1():\n var_1, var_2 = list(map(int, input().split()))\n var_3 = 0\n for var_4 in range(var_1, var_2 + 1):\n\n if (var_4 % 10) == (var_4 // 10000 % 10) and (var_4 // 10 % 10) == (\n var_4 // 1000 % 10\n ):\n var_3 += 1\n print(var_3)\n\n\nif __name__ == \"__main__\":\n func_1()\n```", "output": "FASTER 1.4803", "pair_id": "python_p03416_pair0153_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 2.7901} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nfrom functools import reduce\nfrom itertools import product\n\nvar_2 = int(eval(input()))\n(*var_1,) = list(map(int, input().split()))\nvar_4 = 0\nfor var_7 in product([-1, 0, 1], repeat=var_2):\n var_6 = reduce(\n lambda var_8, var_9: var_8 * var_9,\n [var_3 + var_7[var_5] for var_5, var_3 in enumerate(var_1)],\n )\n if var_6 % 2 == 0:\n var_4 += 1\nprint(var_4)\n```\n\n=== Code B (Modified) ===\n```python\nimport math\nimport string\n\n\ndef func_4():\n return list(map(int, input().split()))\n\n\ndef func_3(var_6, var_7):\n return math.factorial(var_6) // (\n math.factorial(var_6 - var_7) * math.factorial(var_7)\n )\n\n\ndef func_2(var_9):\n var_8 = []\n for var_5 in var_9:\n if not (var_5 in var_8):\n var_8.append(var_5)\n return len(var_9) != len(var_8)\n\n\ndef func_1(var_6):\n func_1 = []\n for var_4 in range(1, var_6 + 1):\n if var_6 % var_4 == 0:\n func_1.append(var_4)\n return func_1\n\n\nvar_2 = [-1, -1, -1, 0, 0, 1, 1, 1]\nvar_3 = [-1, 0, 1, -1, 1, -1, 0, 1]\nvar_6 = int(eval(input()))\nvar_1 = func_4()\nvar_10 = 1\nfor var_4 in range(len(var_1)):\n if var_1[var_4] % 2 == 0:\n var_10 *= 2\n else:\n var_10 *= 1\nprint((3 ** len(var_1) - var_10))\n```", "output": "FASTER 8.0685", "pair_id": "python_p03568_pair0028_forward", "problem_id": "p03568", "language": "python", "direction": "forward", "speedup_ratio": 268.4525} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1 = list(map(int, input().split()))\nvar_2 = 0\nfor var_3 in range(var_1[0], var_1[1] + 1):\n var_4 = str(var_3)\n if var_4[0] == var_4[4] and var_4[1] == var_4[3]:\n var_2 += 1\nprint(var_2)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_6 in range(var_1, var_2 + 1):\n var_3 = str(var_6)\n var_5 = True\n for var_7 in range(len(var_3) // 2):\n if var_3[var_7] != var_3[-var_7 - 1] and var_5:\n var_5 = not var_5\n if var_5:\n var_4 += 1\nprint(var_4)\n```", "output": "SLOWER 1.7488", "pair_id": "python_p03416_pair0084_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 3.3607} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_8 in range(var_1, var_2 + 1):\n var_7 = str(var_8)\n var_6 = len(var_7)\n var_4 = True\n for var_5 in range(var_6 // 2):\n if var_7[var_5] != var_7[var_6 - 1 - var_5]:\n var_4 = False\n break\n if var_4:\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nfrom sys import stdin\n\nvar_6 = lambda: list(map(int, stdin.readline().split()))\nvar_5 = lambda: list(map(int, stdin.readline().split()))\nvar_1, var_3 = var_6()\nvar_2 = 0\nfor var_4 in range(var_1, var_3 + 1):\n var_7 = str(var_4)\n if var_7 == var_7[::-1]:\n var_2 += 1\nprint(var_2)\n```", "output": "FASTER 1.1078", "pair_id": "python_p03416_pair0154_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 2.1552} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_3 in range(var_1, var_2 + 1):\n var_5 = list(str(var_3))\n var_6 = list(reversed(var_5))\n if var_5 == var_6:\n var_4 += 1\nprint(var_4)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_3 = list(map(int, input().split()))\nvar_2 = 0\nfor var_5 in range(var_3 + 1)[var_1:]:\n if len(str(var_5)) % 2 == 0:\n var_6 = list(str(var_5))[: len(str(var_5)) // 2]\n var_7 = list(reversed(list(str(var_5))[len(str(var_5)) // 2 :]))\n if var_6 == var_7:\n var_2 += 1\n else:\n var_8 = list(str(var_5))[: len(str(var_5)) // 2 + 1]\n var_4 = list(reversed(list(str(var_5))[len(str(var_5)) // 2 :]))\n if var_8 == var_4:\n var_2 += 1\nprint(var_2)\n```", "output": "SLOWER 1.1659", "pair_id": "python_p03416_pair0148_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 2.2437} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\ndef func_1():\n from collections import Counter\n\n var_4 = int(eval(input()))\n (*var_1,) = list(map(int, input().split()))\n if var_4 % 3 == 0:\n var_2 = Counter(var_1)\n if len(var_2) == 1:\n print((\"Yes\" if 0 in var_2 else \"No\"))\n return\n elif len(var_2) == 2:\n print((\"Yes\" if var_2[0] == var_4 // 3 else \"No\"))\n return\n elif len(var_2) == 3:\n var_7 = 0\n var_5 = None\n for var_3, var_6 in list(var_2.items()):\n if var_5 is None:\n var_5 = var_6\n elif var_5 != var_6:\n print(\"No\")\n return\n var_7 ^= var_3\n print((\"Yes\" if var_7 == 0 else \"No\"))\n return\n else:\n print(\"No\")\n return\n else:\n print((\"Yes\" if all([var_7 == 0 for var_7 in var_1]) else \"No\"))\n return\n\n\nif __name__ == \"__main__\":\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\n_, var_1 = open(0)\nvar_1, *var_2 = list(map(int, var_1.split()))\nfor var_2 in var_2:\n var_1 ^= var_2\nprint((\"YNeos\"[var_1 > 0 :: 2]))\n```", "output": "FASTER 1.5263", "pair_id": "python_p02975_pair0006_forward", "problem_id": "p02975", "language": "python", "direction": "forward", "speedup_ratio": 2.8805} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_4 = int(eval(input()))\nvar_1 = list(map(int, input().split()))\nvar_3 = 1\nfor var_2 in var_1:\n var_3 *= 2 if var_2 % 2 == 0 else 1\nprint((3**var_4 - var_3))\n```\n\n=== Code B (Modified) ===\n```python\ndef func_1():\n var_2 = int(input())\n var_1 = [int(var_6) for var_6 in input().split()]\n if var_2 == 1:\n return print(1 if var_1[0] % 2 == 0 else 2)\n var_3 = 0\n var_5 = (-1, 0, 1)\n from itertools import product\n\n for var_6 in product(range(3), repeat=var_2):\n var_4 = 1\n for var_7 in range(var_2):\n var_4 *= var_1[var_7] + var_5[var_6[var_7]]\n if var_4 % 2 == 0:\n var_3 += 1\n print(var_3)\n\n\nif __name__ == \"__main__\":\n func_1()\n```", "output": "SLOWER 8.6824", "pair_id": "python_p03568_pair0029_reversed", "problem_id": "p03568", "language": "python", "direction": "reversed", "speedup_ratio": 410.8374} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\n\nvar_7 = sys.stdin.readline\nfrom itertools import combinations\n\n\ndef func_3(var_10):\n for _ in range(var_10):\n yield list(map(int, var_7().split()))\n\n\ndef func_1(var_9, var_5, var_11):\n var_3 = sum(1 if var_5[var_8] == 1 else 0 for var_8 in var_9)\n return var_11[var_3]\n\n\ndef func_2():\n var_10 = int(eval(var_7()))\n var_1 = list(func_3(var_10))\n var_2 = list(func_3(var_10))\n for var_6 in range(1, 11):\n for var_4 in combinations(list(range(10)), var_6):\n yield sum(\n func_1(var_4, var_5, var_11) for var_5, var_11 in zip(var_1, var_2)\n )\n\n\nprint((max(func_2())))\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\nimport itertools\n\n\ndef func_2(var_4):\n return bin(eval(\"0b\" + str(var_4)))\n\n\ndef func_1():\n var_4 = int(sys.stdin.readline().rstrip())\n var_9 = [\n func_2(\"\".join(str(var_10) for var_10 in sys.stdin.readline().split()))\n for _ in range(var_4)\n ]\n var_8 = [\n [int(var_10) for var_10 in sys.stdin.readline().split()] for _ in range(var_4)\n ]\n var_3 = -(10**10)\n for var_6 in itertools.product(\"01\", repeat=10):\n var_6 = func_2(\"\".join(var_6))\n if var_6 == \"0b0\":\n continue\n var_7 = 0\n for var_2 in range(var_4):\n var_1 = var_9[var_2]\n var_5 = bin(eval(var_1) & eval(var_6)).count(\"1\")\n var_7 += var_8[var_2][var_5]\n var_3 = max(var_3, var_7)\n print(var_3)\n\n\nif __name__ == \"__main__\":\n\n func_1()\n```", "output": "SLOWER 3.6491", "pair_id": "python_p03503_pair0032_reversed", "problem_id": "p03503", "language": "python", "direction": "reversed", "speedup_ratio": 12.5454} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_2 = int(eval(input()))\n(*var_1,) = list(map(int, input().split()))\nvar_5 = 0\nfor var_3 in var_1:\n if var_3 % 2 == 0:\n var_5 += 1\nvar_4 = 3**var_2 - 2**var_5\nprint(var_4)\n```\n\n=== Code B (Modified) ===\n```python\nfrom functools import reduce\nfrom itertools import product\n\nvar_2 = int(eval(input()))\n(*var_1,) = list(map(int, input().split()))\nvar_4 = 0\nfor var_7 in product([-1, 0, 1], repeat=var_2):\n var_6 = reduce(\n lambda var_8, var_9: var_8 * var_9,\n [var_3 + var_7[var_5] for var_5, var_3 in enumerate(var_1)],\n )\n if var_6 % 2 == 0:\n var_4 += 1\nprint(var_4)\n```", "output": "SLOWER 9.7614", "pair_id": "python_p03568_pair0023_reversed", "problem_id": "p03568", "language": "python", "direction": "reversed", "speedup_ratio": 867.9334} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = [0] * (var_2 + 1)\nfor var_3 in range(1, var_2 + 1):\n if str(var_3) == str(var_3)[::-1]:\n var_4[var_3] = var_4[var_3 - 1] + 1\n else:\n var_4[var_3] = var_4[var_3 - 1]\nprint((var_4[var_2] - var_4[var_1 - 1]))\n```\n\n=== Code B (Modified) ===\n```python\ndef func_1():\n var_1, var_2 = list(map(int, input().rstrip().split()))\n var_3 = 0\n for var_4 in range(var_1, var_2 + 1):\n var_5 = str(var_4)\n if var_5 == var_5[::-1]:\n var_3 += 1\n print(var_3)\n\n\nif __name__ == \"__main__\":\n func_1()\n```", "output": "FASTER 2.6882", "pair_id": "python_p03416_pair0155_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 6.4453} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_4, var_3 = list(map(int, input().split()))\nvar_1 = 0\nfor var_2 in range(var_4, var_3 + 1):\n if str(var_2)[0] + str(var_2)[1] == str(var_2)[-1] + str(var_2)[-2]:\n var_1 += 1\nprint(var_1)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = str(var_4)\n if var_5[0] == var_5[4] and var_5[1] == var_5[3]:\n var_3 += 1\nprint(var_3)\n```", "output": "FASTER 1.6072", "pair_id": "python_p03416_pair0156_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 3.0467} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = str(var_4)\n if var_5[0] == var_5[4] and var_5[1] == var_5[3]:\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_3 = list(map(int, input().split()))\nvar_2 = 0\nfor var_5 in range(var_3 + 1)[var_1:]:\n if len(str(var_5)) % 2 == 0:\n var_6 = list(str(var_5))[: len(str(var_5)) // 2]\n var_7 = list(reversed(list(str(var_5))[len(str(var_5)) // 2 :]))\n if var_6 == var_7:\n var_2 += 1\n else:\n var_8 = list(str(var_5))[: len(str(var_5)) // 2 + 1]\n var_4 = list(reversed(list(str(var_5))[len(str(var_5)) // 2 :]))\n if var_8 == var_4:\n var_2 += 1\nprint(var_2)\n```", "output": "SLOWER 2.7407", "pair_id": "python_p03416_pair0157_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 6.6839} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\n\nsys.setrecursionlimit(500000)\n\n\ndef func_3():\n return sys.stdin.readline()[:-1]\n\n\nclass Class_1:\n def __init__(self, var_3):\n self.N = len(var_3)\n self.bit = [0] * self.N\n for var_11, var_14 in enumerate(var_3):\n self.add(var_11, var_14)\n\n def func_1(self, var_5, var_18):\n var_19 = var_5 + 1\n for var_11 in range(1000):\n self.bit[var_19 - 1] += var_18\n var_19 += var_19 & -var_19\n if var_19 > self.N:\n break\n\n def func_5(self, var_5):\n var_19 = var_5 + 1\n var_16 = 0\n for var_11 in range(1000):\n var_16 += self.bit[var_19 - 1]\n var_19 -= var_19 & -var_19\n if var_19 <= 0:\n break\n return var_16\n\n\ndef func_4():\n var_4, var_2, var_1 = list(map(int, func_3().split()))\n var_9 = []\n for var_11 in range(var_4):\n var_19, var_10 = list(map(int, func_3().split()))\n if var_10 % var_1 == 0:\n var_9.append([var_19, var_10 // var_1])\n else:\n var_9.append([var_19, var_10 // var_1 + 1])\n var_9.sort(key=lambda var_19: var_19[0])\n\n def func_2(var_12):\n var_19 = var_9[var_12][0]\n if var_9[var_4 - 1][0] <= var_19 + 2 * var_2:\n return var_4 - 1\n var_14 = var_12\n var_15 = var_4 - 1\n while var_15 - var_14 > 1:\n if var_9[(var_15 + var_14) // 2][0] <= var_19 + 2 * var_2:\n var_14 = (var_15 + var_14) // 2\n else:\n var_15 = (var_15 + var_14) // 2\n return var_14\n\n var_6 = Class_1([0] * var_4)\n var_7 = 0\n for var_11 in range(var_4):\n if var_11 > 0:\n var_17 = var_6.sum(var_4 - 1) - var_6.sum(var_11 - 1)\n else:\n var_17 = 0\n if var_9[var_11][1] - var_17 > 0:\n var_7 += var_9[var_11][1] - var_17\n var_13 = func_2(var_11)\n var_6.add(var_13, var_9[var_11][1] - var_17)\n var_9 = var_9[::-1]\n for var_11 in range(var_4):\n var_9[var_11][0] = -var_9[var_11][0]\n var_6 = Class_1([0] * var_4)\n var_8 = 0\n for var_11 in range(var_4):\n if var_11 > 0:\n var_17 = var_6.sum(var_4 - 1) - var_6.sum(var_11 - 1)\n else:\n var_17 = 0\n if var_9[var_11][1] - var_17 > 0:\n var_8 += var_9[var_11][1] - var_17\n var_13 = func_2(var_11)\n var_6.add(var_13, var_9[var_11][1] - var_17)\n print((min(var_7, var_8)))\n\n\nif __name__ == \"__main__\":\n func_4()\n```\n\n=== Code B (Modified) ===\n```python\nimport bisect\nimport sys\n\n\ndef func_1():\n var_9 = sys.stdin.readline\n var_10, var_4, var_1 = list(map(int, var_9().split()))\n var_5 = [None] * var_10\n for var_7 in range(var_10):\n var_12, var_6 = list(map(int, var_9().split()))\n var_5[var_7] = (var_12, var_6)\n var_5.sort()\n var_12 = [int(var_5[var_7][0]) for var_7 in range(var_10)]\n var_6 = [int(var_5[var_7][1]) for var_7 in range(var_10)]\n var_2 = 0\n var_3 = [0] * var_10\n for var_7 in range(var_10):\n if var_7 != 0:\n var_3[var_7] += var_3[var_7 - 1]\n var_11 = max([(var_6[var_7] - var_3[var_7] - 1) // var_1 + 1, 0])\n var_2 += var_11\n var_3[var_7] += var_11 * var_1\n var_8 = bisect.bisect_right(var_12, var_12[var_7] + 2 * var_4)\n if var_8 != var_10:\n var_3[var_8] -= var_11 * var_1\n print(var_2)\n\n\nif __name__ == \"__main__\":\n func_1()\n```", "output": "FASTER 1.2733", "pair_id": "python_p02788_pair0002_forward", "problem_id": "p02788", "language": "python", "direction": "forward", "speedup_ratio": 2.4172} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\ndef func_1():\n var_1, var_2 = list(map(int, input().split()))\n var_3 = 0\n for var_4 in range(var_1, var_2 + 1):\n\n if (var_4 % 10) == (var_4 // 10000 % 10) and (var_4 // 10 % 10) == (\n var_4 // 1000 % 10\n ):\n var_3 += 1\n print(var_3)\n\n\nif __name__ == \"__main__\":\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_6 in range(var_1, var_2 + 1):\n var_3 = str(var_6)\n var_5 = True\n for var_7 in range(len(var_3) // 2):\n if var_3[var_7] != var_3[-var_7 - 1] and var_5:\n var_5 = not var_5\n if var_5:\n var_4 += 1\nprint(var_4)\n```", "output": "SLOWER 3.124", "pair_id": "python_p03416_pair0158_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 8.718} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_8 in range(var_1, var_2 + 1):\n var_7 = str(var_8)\n var_6 = len(var_7)\n var_4 = True\n for var_5 in range(var_6 // 2):\n if var_7[var_5] != var_7[var_6 - 1 - var_5]:\n var_4 = False\n break\n if var_4:\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_5 in range(10):\n for var_6 in range(10):\n for var_7 in range(10):\n var_3 = 10000 * var_5 + 1000 * var_6 + 100 * var_7 + 10 * var_6 + var_5\n if var_1 <= var_3 <= var_2:\n var_4 += 1\nprint(var_4)\n```", "output": "FASTER 4.9518", "pair_id": "python_p03416_pair0114_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 30.9483} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\ndef func_1():\n from sys import setrecursionlimit, stdin\n from os import environ\n from collections import defaultdict, deque, Counter\n from math import ceil, floor, gcd\n from itertools import accumulate, combinations, combinations_with_replacement\n\n setrecursionlimit(10**6)\n var_7 = (\n (lambda *var_11: print(*var_11))\n if \"TERM_PROGRAM\" in environ\n else lambda *var_12: 0\n )\n var_8 = lambda: stdin.readline().rstrip()\n var_3 = lambda: list(map(int, var_8().split()))\n var_1 = lambda: int(var_8())\n var_4 = 10**9 + 7\n var_2 = 10**9 + 10\n var_9, var_10 = var_8().split()\n var_5 = int(var_9)\n var_10 = var_10.split(\".\")\n var_6 = int(var_10[0]) * 100\n if len(var_10) == 2:\n var_6 += int(var_10[1])\n print(var_5 * var_6 // 100)\n\n\nfunc_1()\n```\n\n=== Code B (Modified) ===\n```python\nimport decimal\n\nvar_1, var_2 = (decimal.Decimal(var_3) for var_3 in input().split())\nprint((int(var_1 * var_2)))\n```", "output": "FASTER 2.0989", "pair_id": "python_p02659_pair0024_forward", "problem_id": "p02659", "language": "python", "direction": "forward", "speedup_ratio": 4.2837} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nfrom sys import stdin\n\nvar_6 = lambda: list(map(int, stdin.readline().split()))\nvar_5 = lambda: list(map(int, stdin.readline().split()))\nvar_1, var_3 = var_6()\nvar_2 = 0\nfor var_4 in range(var_1, var_3 + 1):\n var_7 = str(var_4)\n if var_7 == var_7[::-1]:\n var_2 += 1\nprint(var_2)\n```\n\n=== Code B (Modified) ===\n```python\nvar_4, var_3 = list(map(int, input().split()))\nvar_1 = 0\nfor var_2 in range(var_4, var_3 + 1):\n if str(var_2)[0] + str(var_2)[1] == str(var_2)[-1] + str(var_2)[-2]:\n var_1 += 1\nprint(var_1)\n```", "output": "SLOWER 1.3227", "pair_id": "python_p03416_pair0009_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 2.5013} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\n\nvar_10 = sys.stdin.readline\nvar_2, var_3 = list(map(int, var_10().split()))\nvar_1 = [list(map(int, var_10().split())) for _ in range(var_2)]\nvar_8 = [[0 for _ in range(var_2 + 1)] for _ in range(var_3 + 1)]\n\nvar_13 = [[0 for _ in range(var_2 + 1)] for _ in range(var_3 + 1)]\nfor var_11 in range(var_2):\n var_4, var_6 = var_1[var_11]\n for var_15 in range(var_3):\n if var_4 > var_15:\n var_8[var_15][var_11 + 1] = var_8[var_15][var_11]\n var_13[var_15][var_11 + 1] = var_15\n else:\n if var_6 + var_8[var_15 - var_4][var_11] >= var_8[var_15][var_11]:\n var_8[var_15][var_11 + 1] = var_8[var_15 - var_4][var_11] + var_6\n var_13[var_15][var_11 + 1] = var_15 - var_4\n else:\n var_8[var_15][var_11 + 1] = var_8[var_15][var_11]\n var_13[var_15][var_11 + 1] = var_15\nvar_5 = var_8[var_3 - 1][var_2]\nvar_14 = [False] * var_2\nvar_7 = var_3 - 1\nfor var_9 in reversed(list(range(var_2))):\n if var_13[var_7][var_9 + 1] == var_7 - var_1[var_9][0]:\n var_14[var_9] = True\n var_7 = var_13[var_7][var_9 + 1]\nvar_12 = 0\nfor var_9 in range(var_2):\n if not var_14[var_9] and var_1[var_9][1] > var_12:\n var_12 = var_1[var_9][1]\nprint((var_5 + var_12))\n```\n\n=== Code B (Modified) ===\n```python\ndef func_1():\n var_2, var_3, *var_1 = list(map(int, open(0).read().split()))\n var_4 = [0] * (var_3 + max(var_1[::2]))\n for var_7, var_6 in sorted(zip(*[iter(var_1)] * 2)):\n for var_5 in reversed(list(range(var_3))):\n var_4[var_5 + var_7] = max(var_4[var_5 + var_7], var_4[var_5] + var_6)\n print((max(var_4)))\n\n\nfunc_1()\n```", "output": "FASTER 1.7835", "pair_id": "python_p02863_pair0022_forward", "problem_id": "p02863", "language": "python", "direction": "forward", "speedup_ratio": 3.4426} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nfrom decimal import Decimal\nimport math\n\nvar_1, var_2 = list(map(str, input().split()))\nvar_1 = int(var_1)\nvar_2 = Decimal(var_2)\nvar_3 = math.floor(var_1 * var_2)\nprint((int(var_3)))\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\nimport math\nfrom collections import defaultdict\nfrom bisect import bisect_left, bisect_right\n\nsys.setrecursionlimit(10**7)\n\n\ndef func_4():\n return sys.stdin.readline()[:-1]\n\n\nvar_4 = 10**9 + 7\n\n\ndef func_1():\n return int(eval(func_4()))\n\n\ndef func_2():\n return list(map(int, func_4().split()))\n\n\ndef func_3(var_6, var_3):\n if var_6 <= 0:\n return [[] for _ in range(var_3)]\n elif var_3 == 1:\n return [func_1() for _ in range(var_6)]\n else:\n var_5 = [func_2() for _ in range(var_6)]\n return list(map(list, list(zip(*var_5))))\n\n\nvar_1, var_2 = list(map(str, func_4().split()))\nvar_1 = int(var_1)\nvar_2 = 100 * int(var_2[0]) + 10 * int(var_2[2]) + int(var_2[3])\nprint((var_1 * var_2 // 100))\n```", "output": "SLOWER 1.9772", "pair_id": "python_p02659_pair0030_reversed", "problem_id": "p02659", "language": "python", "direction": "reversed", "speedup_ratio": 3.9373} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_6, var_7 = list(map(int, input().split()))\nvar_1 = [list(map(int, input().split())) for _ in range(var_6)]\nvar_1.sort()\nvar_3 = [(6007) * [0] for _ in range(var_6 + 1)]\nvar_3[0][0] = 0\nvar_2 = 0\nfor var_4 in range(var_6):\n for var_5 in range(6007):\n var_3[var_4 + 1][var_5] = max(var_3[var_4 + 1][var_5], var_3[var_4][var_5])\n if var_5 < var_7:\n var_3[var_4 + 1][var_5 + var_1[var_4][0]] = max(\n var_3[var_4][var_5] + var_1[var_4][1],\n var_3[var_4][var_5 + var_1[var_4][0]],\n )\n var_2 = max(var_2, var_3[var_4 + 1][var_5])\nprint(var_2)\n```\n\n=== Code B (Modified) ===\n```python\nfrom sys import stdin\n\n\ndef func_1():\n\n var_9 = stdin.readline\n var_8, var_10 = list(map(int, var_9().split()))\n var_7 = [list(map(int, var_9().split())) for _ in range(var_8)]\n var_7.sort()\n var_1 = [0] * var_8\n var_2 = [0] * var_8\n for var_4 in range(var_8):\n var_1[var_4], var_2[var_4] = var_7[var_4][0], var_7[var_4][1]\n\n var_5 = -float(\"inf\")\n var_3 = [[var_5] * (var_10 + 1) for _ in range(var_8 + 1)]\n var_3[0][0] = 0\n for var_4 in range(var_8):\n for var_6 in range(var_10 + 1):\n\n if var_6 != var_10:\n var_3[var_4 + 1][min(var_10, var_6 + var_1[var_4])] = max(\n var_3[var_4 + 1][min(var_10, var_6 + var_1[var_4])],\n var_3[var_4][var_6] + var_2[var_4],\n )\n\n var_3[var_4 + 1][var_6] = max(var_3[var_4 + 1][var_6], var_3[var_4][var_6])\n print((max(var_3[var_8])))\n\n\nif __name__ == \"__main__\":\n func_1()\n```", "output": "FASTER 5.7996", "pair_id": "python_p02863_pair0035_forward", "problem_id": "p02863", "language": "python", "direction": "forward", "speedup_ratio": 55.7009} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_4 = {}\nvar_5 = 0\nfor var_6 in range(10000, 100000):\n var_3 = list(str(var_6))\n if var_3 == list(reversed(var_3)):\n var_5 += 1\n var_4[var_6] = var_5\nvar_1, var_2 = list(map(int, input().split()))\nprint((var_4[var_2] - var_4[var_1 - 1] if var_1 > 10000 else var_4[var_2]))\n```\n\n=== Code B (Modified) ===\n```python\nvar_1 = list(map(int, input().split()))\nvar_2 = 0\nfor var_3 in range(var_1[0], var_1[1] + 1):\n var_4 = str(var_3)\n if var_4[0] == var_4[4] and var_4[1] == var_4[3]:\n var_2 += 1\nprint(var_2)\n```", "output": "FASTER 3.8624", "pair_id": "python_p03416_pair0159_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 14.5446} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\ndef func_1():\n var_1, var_2 = list(map(int, input().rstrip().split()))\n var_3 = 0\n for var_4 in range(var_1, var_2 + 1):\n var_5 = str(var_4)\n if var_5 == var_5[::-1]:\n var_3 += 1\n print(var_3)\n\n\nif __name__ == \"__main__\":\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n if str(var_4) == \"\".join(reversed(str(var_4))):\n var_3 += 1\nprint(var_3)\n```", "output": "SLOWER 1.8222", "pair_id": "python_p03416_pair0088_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 3.5363} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\ndef func_1():\n var_1, var_2 = list(map(int, input().rstrip().split()))\n var_3 = 0\n for var_4 in range(var_1, var_2 + 1):\n var_5 = str(var_4)\n if var_5 == var_5[::-1]:\n var_3 += 1\n print(var_3)\n\n\nif __name__ == \"__main__\":\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = list(reversed(list(str(var_4))))\n if var_5 == list(str(var_4)):\n var_3 += 1\nprint(var_3)\n```", "output": "SLOWER 2.4029", "pair_id": "python_p03416_pair0160_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 5.2888} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_4 = {}\nvar_5 = 0\nfor var_6 in range(10000, 100000):\n var_3 = list(str(var_6))\n if var_3 == list(reversed(var_3)):\n var_5 += 1\n var_4[var_6] = var_5\nvar_1, var_2 = list(map(int, input().split()))\nprint((var_4[var_2] - var_4[var_1 - 1] if var_1 > 10000 else var_4[var_2]))\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_7 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_3 = True\n var_8 = str(var_4)\n var_6 = len(var_8)\n for var_5 in range(var_6 // 2 + 1):\n if var_8[var_5] != var_8[-var_5 - 1]:\n var_3 = False\n break\n if var_3:\n var_7 += 1\nprint(var_7)\n```", "output": "FASTER 2.4485", "pair_id": "python_p03416_pair0010_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 5.4585} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\ndef func_1():\n var_1, var_2 = list(map(int, input().rstrip().split()))\n var_3 = 0\n for var_4 in range(var_1, var_2 + 1):\n var_5 = str(var_4)\n if var_5 == var_5[::-1]:\n var_3 += 1\n print(var_3)\n\n\nif __name__ == \"__main__\":\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().rstrip().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = list(map(int, list(str(var_4))))\n if var_5[0] == var_5[4] and var_5[1] == var_5[3]:\n var_3 += 1\nprint(var_3)\n```", "output": "SLOWER 2.429", "pair_id": "python_p03416_pair0161_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 5.3852} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport bisect\nimport sys\n\n\ndef func_1():\n var_9 = sys.stdin.readline\n var_10, var_4, var_1 = list(map(int, var_9().split()))\n var_5 = [None] * var_10\n for var_7 in range(var_10):\n var_12, var_6 = list(map(int, var_9().split()))\n var_5[var_7] = (var_12, var_6)\n var_5.sort()\n var_12 = [int(var_5[var_7][0]) for var_7 in range(var_10)]\n var_6 = [int(var_5[var_7][1]) for var_7 in range(var_10)]\n var_2 = 0\n var_3 = [0] * var_10\n for var_7 in range(var_10):\n if var_7 != 0:\n var_3[var_7] += var_3[var_7 - 1]\n var_11 = max([(var_6[var_7] - var_3[var_7] - 1) // var_1 + 1, 0])\n var_2 += var_11\n var_3[var_7] += var_11 * var_1\n var_8 = bisect.bisect_right(var_12, var_12[var_7] + 2 * var_4)\n if var_8 != var_10:\n var_3[var_8] -= var_11 * var_1\n print(var_2)\n\n\nif __name__ == \"__main__\":\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\n\nsys.setrecursionlimit(500000)\n\n\ndef func_3():\n return sys.stdin.readline()[:-1]\n\n\nclass Class_1:\n def __init__(self, var_3):\n self.N = len(var_3)\n self.bit = [0] * self.N\n for var_11, var_14 in enumerate(var_3):\n self.add(var_11, var_14)\n\n def func_1(self, var_5, var_18):\n var_19 = var_5 + 1\n for var_11 in range(1000):\n self.bit[var_19 - 1] += var_18\n var_19 += var_19 & -var_19\n if var_19 > self.N:\n break\n\n def func_5(self, var_5):\n var_19 = var_5 + 1\n var_16 = 0\n for var_11 in range(1000):\n var_16 += self.bit[var_19 - 1]\n var_19 -= var_19 & -var_19\n if var_19 <= 0:\n break\n return var_16\n\n\ndef func_4():\n var_4, var_2, var_1 = list(map(int, func_3().split()))\n var_9 = []\n for var_11 in range(var_4):\n var_19, var_10 = list(map(int, func_3().split()))\n if var_10 % var_1 == 0:\n var_9.append([var_19, var_10 // var_1])\n else:\n var_9.append([var_19, var_10 // var_1 + 1])\n var_9.sort(key=lambda var_19: var_19[0])\n\n def func_2(var_12):\n var_19 = var_9[var_12][0]\n if var_9[var_4 - 1][0] <= var_19 + 2 * var_2:\n return var_4 - 1\n var_14 = var_12\n var_15 = var_4 - 1\n while var_15 - var_14 > 1:\n if var_9[(var_15 + var_14) // 2][0] <= var_19 + 2 * var_2:\n var_14 = (var_15 + var_14) // 2\n else:\n var_15 = (var_15 + var_14) // 2\n return var_14\n\n var_6 = Class_1([0] * var_4)\n var_7 = 0\n for var_11 in range(var_4):\n if var_11 > 0:\n var_17 = var_6.sum(var_4 - 1) - var_6.sum(var_11 - 1)\n else:\n var_17 = 0\n if var_9[var_11][1] - var_17 > 0:\n var_7 += var_9[var_11][1] - var_17\n var_13 = func_2(var_11)\n var_6.add(var_13, var_9[var_11][1] - var_17)\n var_9 = var_9[::-1]\n for var_11 in range(var_4):\n var_9[var_11][0] = -var_9[var_11][0]\n var_6 = Class_1([0] * var_4)\n var_8 = 0\n for var_11 in range(var_4):\n if var_11 > 0:\n var_17 = var_6.sum(var_4 - 1) - var_6.sum(var_11 - 1)\n else:\n var_17 = 0\n if var_9[var_11][1] - var_17 > 0:\n var_8 += var_9[var_11][1] - var_17\n var_13 = func_2(var_11)\n var_6.add(var_13, var_9[var_11][1] - var_17)\n print((min(var_7, var_8)))\n\n\nif __name__ == \"__main__\":\n func_4()\n```", "output": "SLOWER 1.2733", "pair_id": "python_p02788_pair0002_reversed", "problem_id": "p02788", "language": "python", "direction": "reversed", "speedup_ratio": 2.4172} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport itertools\n\nvar_6 = int(eval(input()))\nvar_2 = [[]] * var_6\nfor var_4 in range(var_6):\n var_3 = list(map(int, input().split()))\n\n var_2[var_4] = var_3\nvar_8 = [[]] * var_6\nfor var_4 in range(var_6):\n var_9 = list(map(int, input().split()))\n var_8[var_4] = var_9\nvar_10 = -(10**11)\nfor var_1 in itertools.product([0, 1], repeat=10):\n if sum(var_1) == 0:\n continue\n var_11 = 0\n for var_7 in range(var_6):\n var_5 = 0\n for var_4 in range(10):\n if var_2[var_7][var_4] == 1 and var_1[var_4] == 1:\n var_5 += 1\n var_11 = var_11 + var_8[var_7][var_5]\n var_10 = max(var_10, var_11)\nprint(var_10)\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\n\nvar_8 = sys.stdin.readline\n\n\ndef func_1():\n var_2 = int(eval(var_8()))\n var_1 = [int(var_8().replace(\" \", \"\"), 2) for _ in range(var_2)]\n var_3 = [list(map(int, var_8().split())) for _ in range(var_2)]\n var_4 = -(10**7) * var_2\n for var_7 in range(1, 1 << 10):\n var_10 = 0\n for var_9, var_6 in enumerate(var_1):\n var_5 = bin(var_7 & var_6).count(\"1\")\n var_10 += var_3[var_9][var_5]\n var_4 = max(var_4, var_10)\n print(var_4)\n\n\nif __name__ == \"__main__\":\n func_1()\n```", "output": "FASTER 2.7112", "pair_id": "python_p03503_pair0024_forward", "problem_id": "p03503", "language": "python", "direction": "forward", "speedup_ratio": 6.5485} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_3 = list(map(int, input().split()))\nvar_2 = 0\nfor var_5 in range(var_3 + 1)[var_1:]:\n if len(str(var_5)) % 2 == 0:\n var_6 = list(str(var_5))[: len(str(var_5)) // 2]\n var_7 = list(reversed(list(str(var_5))[len(str(var_5)) // 2 :]))\n if var_6 == var_7:\n var_2 += 1\n else:\n var_8 = list(str(var_5))[: len(str(var_5)) // 2 + 1]\n var_4 = list(reversed(list(str(var_5))[len(str(var_5)) // 2 :]))\n if var_8 == var_4:\n var_2 += 1\nprint(var_2)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = str(var_4)\n if var_5[0] == var_5[4] and var_5[1] == var_5[3]:\n var_3 += 1\nprint(var_3)\n```", "output": "FASTER 2.7407", "pair_id": "python_p03416_pair0157_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 6.6839} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\n\nvar_7 = sys.stdin.readline\nfrom itertools import combinations\n\n\ndef func_3(var_10):\n for _ in range(var_10):\n yield list(map(int, var_7().split()))\n\n\ndef func_1(var_9, var_5, var_11):\n var_3 = sum(1 if var_5[var_8] == 1 else 0 for var_8 in var_9)\n return var_11[var_3]\n\n\ndef func_2():\n var_10 = int(eval(var_7()))\n var_1 = list(func_3(var_10))\n var_2 = list(func_3(var_10))\n for var_6 in range(1, 11):\n for var_4 in combinations(list(range(10)), var_6):\n yield sum(\n func_1(var_4, var_5, var_11) for var_5, var_11 in zip(var_1, var_2)\n )\n\n\nprint((max(func_2())))\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\n\nvar_8 = sys.stdin.readline\n\n\ndef func_1():\n var_2 = int(eval(var_8()))\n var_1 = [int(var_8().replace(\" \", \"\"), 2) for _ in range(var_2)]\n var_3 = [list(map(int, var_8().split())) for _ in range(var_2)]\n var_4 = -(10**7) * var_2\n for var_7 in range(1, 1 << 10):\n var_10 = 0\n for var_9, var_6 in enumerate(var_1):\n var_5 = bin(var_7 & var_6).count(\"1\")\n var_10 += var_3[var_9][var_5]\n var_4 = max(var_4, var_10)\n print(var_4)\n\n\nif __name__ == \"__main__\":\n func_1()\n```", "output": "FASTER 1.6626", "pair_id": "python_p03503_pair0033_forward", "problem_id": "p03503", "language": "python", "direction": "forward", "speedup_ratio": 3.1659} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\ndef func_1():\n var_1, var_2 = list(map(int, input().split()))\n var_3 = 0\n for var_4 in range(var_1, var_2 + 1):\n\n if (var_4 % 10) == (var_4 // 10000 % 10) and (var_4 // 10 % 10) == (\n var_4 // 1000 % 10\n ):\n var_3 += 1\n print(var_3)\n\n\nif __name__ == \"__main__\":\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_3 = list(map(int, input().split()))\nvar_2 = 0\nfor var_5 in range(var_3 + 1)[var_1:]:\n if len(str(var_5)) % 2 == 0:\n var_6 = list(str(var_5))[: len(str(var_5)) // 2]\n var_7 = list(reversed(list(str(var_5))[len(str(var_5)) // 2 :]))\n if var_6 == var_7:\n var_2 += 1\n else:\n var_8 = list(str(var_5))[: len(str(var_5)) // 2 + 1]\n var_4 = list(reversed(list(str(var_5))[len(str(var_5)) // 2 :]))\n if var_8 == var_4:\n var_2 += 1\nprint(var_2)\n```", "output": "SLOWER 4.1386", "pair_id": "python_p03416_pair0162_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 17.6132} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\n\nvar_3 = sys.stdin.readline\nif __name__ == \"__main__\":\n var_1, var_2 = var_3().split()\n print((int(var_1) * round(float(var_2) * 100) // 100))\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\nimport math\nfrom collections import defaultdict\nfrom bisect import bisect_left, bisect_right\n\nsys.setrecursionlimit(10**7)\n\n\ndef func_4():\n return sys.stdin.readline()[:-1]\n\n\nvar_4 = 10**9 + 7\n\n\ndef func_1():\n return int(eval(func_4()))\n\n\ndef func_2():\n return list(map(int, func_4().split()))\n\n\ndef func_3(var_6, var_3):\n if var_6 <= 0:\n return [[] for _ in range(var_3)]\n elif var_3 == 1:\n return [func_1() for _ in range(var_6)]\n else:\n var_5 = [func_2() for _ in range(var_6)]\n return list(map(list, list(zip(*var_5))))\n\n\nvar_1, var_2 = list(map(str, func_4().split()))\nvar_1 = int(var_1)\nvar_2 = 100 * int(var_2[0]) + 10 * int(var_2[2]) + int(var_2[3])\nprint((var_1 * var_2 // 100))\n```", "output": "SLOWER 2.2625", "pair_id": "python_p02659_pair0039_reversed", "problem_id": "p02659", "language": "python", "direction": "reversed", "speedup_ratio": 4.7983} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport numpy as np\nfrom itertools import product\n\nvar_6 = int(eval(input()))\nvar_2 = list(map(int, input().split()))\nvar_2 = np.array(var_2)\nvar_5 = [-1, 0, 1]\nvar_3 = 0\nfor var_7 in product(var_5, repeat=var_6):\n var_7 = np.array(var_7)\n var_1 = var_2 + var_7\n var_4 = var_1.cumprod()\n if var_4[-1] % 2 == 0:\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_4 = int(eval(input()))\nvar_1 = list(map(int, input().split()))\nvar_3 = 1\nfor var_2 in var_1:\n var_3 *= 2 if var_2 % 2 == 0 else 1\nprint((3**var_4 - var_3))\n```", "output": "FASTER 10.1485", "pair_id": "python_p03568_pair0002_forward", "problem_id": "p03568", "language": "python", "direction": "forward", "speedup_ratio": 1134.9796} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_2 = int(eval(input()))\n(*var_1,) = list(map(int, input().split()))\nvar_5 = 0\nfor var_3 in var_1:\n if var_3 % 2 == 0:\n var_5 += 1\nvar_4 = 3**var_2 - 2**var_5\nprint(var_4)\n```\n\n=== Code B (Modified) ===\n```python\ndef func_1():\n var_2 = int(input())\n var_1 = [int(var_6) for var_6 in input().split()]\n if var_2 == 1:\n return print(1 if var_1[0] % 2 == 0 else 2)\n var_3 = 0\n var_5 = (-1, 0, 1)\n from itertools import product\n\n for var_6 in product(range(3), repeat=var_2):\n var_4 = 1\n for var_7 in range(var_2):\n var_4 *= var_1[var_7] + var_5[var_6[var_7]]\n if var_4 % 2 == 0:\n var_3 += 1\n print(var_3)\n\n\nif __name__ == \"__main__\":\n func_1()\n```", "output": "SLOWER 8.5619", "pair_id": "python_p03568_pair0030_reversed", "problem_id": "p03568", "language": "python", "direction": "reversed", "speedup_ratio": 377.9172} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nfrom math import sqrt\n\nvar_2 = int(eval(input()))\n\n\ndef func_1(var_2):\n if var_2 < 2:\n return False\n for var_1 in range(2, int(sqrt(var_2)) + 1):\n if var_2 % var_1 == 0:\n return False\n return True\n\n\nwhile not func_1(var_2):\n var_2 += 1\nprint(var_2)\n```\n\n=== Code B (Modified) ===\n```python\nimport bisect, copy, heapq, math, sys\nfrom collections import *\nfrom functools import lru_cache\nfrom itertools import accumulate, combinations, permutations, product\n\n\ndef func_2():\n return sys.stdin.readline()[:-1]\n\n\ndef func_4(var_8):\n return [0] + list(accumulate(var_8))\n\n\ndef func_1(var_1, var_4):\n return -(-var_1 // var_4)\n\n\nsys.setrecursionlimit(5000000)\nvar_9 = pow(10, 9) + 7\nvar_2 = [chr(ord(\"a\") + var_6) for var_6 in range(26)]\nvar_5 = [[1, 0], [0, 1], [-1, 0], [0, -1]]\nvar_11 = int(eval(func_2()))\n\n\ndef func_3(var_10):\n if var_10 == 1:\n return False\n for var_7 in range(2, int(math.sqrt(var_10)) + 1):\n if var_10 % var_7 == 0:\n return False\n return True\n\n\nvar_3 = var_11\nwhile not func_3(var_3):\n var_3 += 1\nprint(var_3)\n```", "output": "SLOWER 1.442", "pair_id": "python_p02819_pair0006_reversed", "problem_id": "p02819", "language": "python", "direction": "reversed", "speedup_ratio": 2.717} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = input().split()\nvar_1 = int(var_1)\nvar_2 = int(\"\".join(var_2.split(\".\")))\nprint(((var_1 * var_2) // 100))\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\nimport math\nfrom collections import defaultdict\nfrom bisect import bisect_left, bisect_right\n\nsys.setrecursionlimit(10**7)\n\n\ndef func_4():\n return sys.stdin.readline()[:-1]\n\n\nvar_4 = 10**9 + 7\n\n\ndef func_1():\n return int(eval(func_4()))\n\n\ndef func_2():\n return list(map(int, func_4().split()))\n\n\ndef func_3(var_6, var_3):\n if var_6 <= 0:\n return [[] for _ in range(var_3)]\n elif var_3 == 1:\n return [func_1() for _ in range(var_6)]\n else:\n var_5 = [func_2() for _ in range(var_6)]\n return list(map(list, list(zip(*var_5))))\n\n\nfrom decimal import getcontext, Decimal\n\ngetcontext().prec = 28\nvar_1, var_2 = list(map(str, func_4().split()))\nvar_1 = int(var_1)\nvar_2 = Decimal(var_2)\nprint((int(var_1 * var_2)))\n```", "output": "SLOWER 2.485", "pair_id": "python_p02659_pair0029_reversed", "problem_id": "p02659", "language": "python", "direction": "reversed", "speedup_ratio": 5.5983} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport bisect\nimport sys\n\nsys.setrecursionlimit(10**6)\nvar_17 = sys.stdout.write\nvar_7 = lambda *var_15: print(*var_15) if var_1 else 0\nvar_1 = True\n\n\ndef func_1(var_10=sys.stdin.readline):\n var_12 = lambda: var_10().rstrip()\n var_3 = lambda: list(map(int, var_12().split()))\n var_2 = lambda: int(var_12())\n var_4 = lambda var_18: [var_3() for _ in range(var_18)]\n var_14, var_16 = var_3()\n var_5 = var_4(var_14)\n var_8 = [[0] * var_16 for _ in range(var_14)]\n for var_11 in range(1, var_14):\n for var_13 in range(1, var_16):\n if var_13 < var_5[var_11 - 1][0]:\n var_8[var_11][var_13] = var_8[var_11 - 1][var_13]\n else:\n var_8[var_11][var_13] = max(\n var_8[var_11 - 1][var_13],\n var_8[var_11 - 1][var_13 - var_5[var_11 - 1][0]]\n + var_5[var_11 - 1][1],\n )\n var_9 = [[0] * var_16 for _ in range(var_14)]\n for var_11 in range(1, var_14):\n for var_13 in range(1, var_16):\n if var_13 < var_5[var_14 - var_11][0]:\n var_9[var_11][var_13] = var_9[var_11 - 1][var_13]\n else:\n var_9[var_11][var_13] = max(\n var_9[var_11 - 1][var_13],\n var_9[var_11 - 1][var_13 - var_5[var_14 - var_11][0]]\n + var_5[var_14 - var_11][1],\n )\n var_6 = 0\n for var_11 in range(var_14):\n for var_13 in range(var_16 - 1):\n var_6 = max(\n var_6,\n var_8[var_11][var_13]\n + var_9[var_14 - var_11 - 1][var_16 - var_13 - 1]\n + var_5[var_11][1],\n )\n print(var_6)\n\n\nif __name__ == \"__main__\":\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nvar_6, var_7 = list(map(int, input().split()))\nvar_1 = [list(map(int, input().split())) for _ in range(var_6)]\nvar_1.sort()\nvar_3 = [(6007) * [0] for _ in range(var_6 + 1)]\nvar_3[0][0] = 0\nvar_2 = 0\nfor var_4 in range(var_6):\n for var_5 in range(6007):\n var_3[var_4 + 1][var_5] = max(var_3[var_4 + 1][var_5], var_3[var_4][var_5])\n if var_5 < var_7:\n var_3[var_4 + 1][var_5 + var_1[var_4][0]] = max(\n var_3[var_4][var_5] + var_1[var_4][1],\n var_3[var_4][var_5 + var_1[var_4][0]],\n )\n var_2 = max(var_2, var_3[var_4 + 1][var_5])\nprint(var_2)\n```", "output": "SLOWER 5.3172", "pair_id": "python_p02863_pair0036_reversed", "problem_id": "p02863", "language": "python", "direction": "reversed", "speedup_ratio": 39.8704} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport math\n\nvar_1, var_2 = input().split()\nvar_1 = int(var_1)\nvar_3 = int(var_2[0] + var_2[2] + var_2[3])\nprint((int(var_1 * var_3) // 100))\n```\n\n=== Code B (Modified) ===\n```python\ndef func_1():\n from sys import setrecursionlimit, stdin\n from os import environ\n from collections import defaultdict, deque, Counter\n from math import ceil, floor, gcd\n from itertools import accumulate, combinations, combinations_with_replacement\n\n setrecursionlimit(10**6)\n var_7 = (\n (lambda *var_11: print(*var_11))\n if \"TERM_PROGRAM\" in environ\n else lambda *var_12: 0\n )\n var_8 = lambda: stdin.readline().rstrip()\n var_3 = lambda: list(map(int, var_8().split()))\n var_1 = lambda: int(var_8())\n var_4 = 10**9 + 7\n var_2 = 10**9 + 10\n var_9, var_10 = var_8().split()\n var_5 = int(var_9)\n var_6 = int(float(var_10) * 100 + 0.5)\n print(var_5 * var_6 // 100)\n\n\nfunc_1()\n```", "output": "SLOWER 1.9827", "pair_id": "python_p02659_pair0005_reversed", "problem_id": "p02659", "language": "python", "direction": "reversed", "speedup_ratio": 3.9522} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\n\nvar_2, var_1, *var_3 = sys.stdin.read().strip().split()\nvar_2 = int(var_2)\nvar_5 = [0] * var_2\nvar_10 = [0] * var_2\nfor var_6, var_8 in zip(*[iter(var_3)] * 2):\n var_6 = int(var_6) - 1\n if var_8 == \"AC\":\n var_5[var_6] = 1\n elif var_5[var_6] == 0:\n var_10[var_6] += 1\nvar_7 = sum([var_9 * var_4 for var_4, var_9 in zip(var_5, var_10)])\nprint((\"{} {}\".format(sum(var_5), var_7)))\n```\n\n=== Code B (Modified) ===\n```python\nvar_2, var_1 = list(map(int, input().split()))\nvar_6 = {}\nvar_3 = {}\nfor var_4 in range(var_1):\n var_5, var_7 = input().split()\n var_5 = int(var_5)\n if not var_5 in var_6:\n var_6[var_5] = 0\n var_3[var_5] = 0\n if var_7 == \"WA\" and var_3[var_5] == 0:\n var_6[var_5] += 1\n elif var_7 == \"AC\" and var_3[var_5] == 0:\n var_3[var_5] += 1\nfor var_4 in var_6:\n if var_6[var_4] != 0 and var_3[var_4] == 0:\n var_6[var_4] = 0\nprint((sum(var_3.values()), sum(var_6.values())))\n```", "output": "FASTER 2.6258", "pair_id": "python_p02802_pair0008_forward", "problem_id": "p02802", "language": "python", "direction": "forward", "speedup_ratio": 6.1723} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nfrom itertools import product\n\nvar_6 = int(eval(input()))\nvar_1 = list(map(int, input().split()))\nvar_5 = 0\nfor var_2 in product((-1, 0, 1), repeat=var_6):\n var_7 = 1\n for var_3, var_4 in zip(var_1, var_2):\n var_7 *= var_3 + var_4\n if var_7 % 2 == 0:\n var_5 += 1\nprint(var_5)\n```\n\n=== Code B (Modified) ===\n```python\nimport math\nimport string\n\n\ndef func_4():\n return list(map(int, input().split()))\n\n\ndef func_3(var_6, var_7):\n return math.factorial(var_6) // (\n math.factorial(var_6 - var_7) * math.factorial(var_7)\n )\n\n\ndef func_2(var_9):\n var_8 = []\n for var_5 in var_9:\n if not (var_5 in var_8):\n var_8.append(var_5)\n return len(var_9) != len(var_8)\n\n\ndef func_1(var_6):\n func_1 = []\n for var_4 in range(1, var_6 + 1):\n if var_6 % var_4 == 0:\n func_1.append(var_4)\n return func_1\n\n\nvar_2 = [-1, -1, -1, 0, 0, 1, 1, 1]\nvar_3 = [-1, 0, 1, -1, 1, -1, 0, 1]\nvar_6 = int(eval(input()))\nvar_1 = func_4()\nvar_10 = 1\nfor var_4 in range(len(var_1)):\n if var_1[var_4] % 2 == 0:\n var_10 *= 2\n else:\n var_10 *= 1\nprint((3 ** len(var_1) - var_10))\n```", "output": "FASTER 8.339", "pair_id": "python_p03568_pair0031_forward", "problem_id": "p03568", "language": "python", "direction": "forward", "speedup_ratio": 323.8095} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_4, var_3 = list(map(int, input().split()))\nvar_1 = 0\nfor var_2 in range(var_4, var_3 + 1):\n if str(var_2)[0] + str(var_2)[1] == str(var_2)[-1] + str(var_2)[-2]:\n var_1 += 1\nprint(var_1)\n```\n\n=== Code B (Modified) ===\n```python\ndef func_1():\n var_1, var_2 = list(map(int, input().split()))\n var_3 = 0\n for var_4 in range(var_1, var_2 + 1):\n\n if (var_4 % 10) == (var_4 // 10000 % 10) and (var_4 // 10 % 10) == (\n var_4 // 1000 % 10\n ):\n var_3 += 1\n print(var_3)\n\n\nif __name__ == \"__main__\":\n func_1()\n```", "output": "FASTER 3.0051", "pair_id": "python_p03416_pair0065_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 8.0286} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1 = [int(eval(input())) for _ in range(int(eval(input())))]\nprint((sum(var_1) - max(var_1) // 2))\n```\n\n=== Code B (Modified) ===\n```python\nimport copy\nimport random\nimport bisect\nimport fractions\nimport math\nimport sys\nimport collections\nfrom decimal import Decimal\n\nvar_5 = 10**9 + 7\nsys.setrecursionlimit(var_5)\nvar_3 = collections.deque()\n\n\ndef func_1():\n return list(map(int, sys.stdin.readline().split()))\n\n\nvar_1 = int(eval(input()))\nvar_6 = [0 for var_4 in range(var_1)]\nfor var_4 in range(var_1):\n var_6[var_4] = int(eval(input()))\nvar_6.sort()\nvar_2 = sum(var_6)\nvar_2 -= var_6[-1] // 2\nprint(var_2)\n```", "output": "SLOWER 1.0725", "pair_id": "python_p03207_pair0003_reversed", "problem_id": "p03207", "language": "python", "direction": "reversed", "speedup_ratio": 2.1031} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_8, var_9 = list(map(int, input().split()))\nvar_5 = [[0] * (var_9 + 3001) for _ in range(var_8 + 1)]\nvar_3 = 0\nvar_2 = [list(map(int, input().split())) for _ in range(var_8)]\nvar_2.sort()\nfor var_6 in range(1, var_8 + 1):\n var_1, var_4 = var_2[var_6 - 1]\n for var_7 in range(var_9):\n var_5[var_6][var_7] = max(var_5[var_6 - 1][var_7], var_5[var_6][var_7])\n var_5[var_6][var_7 + var_1] = var_5[var_6 - 1][var_7] + var_4\n var_3 = max(var_5[var_6][var_7], var_5[var_6][var_7 + var_1], var_3)\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_2, var_3, *var_1 = list(map(int, open(0).read().split()))\nvar_4 = [0] * (var_3 + max(var_1[::2]))\nfor var_7, var_6 in sorted(zip(*[iter(var_1)] * 2)):\n for var_5 in reversed(list(range(var_3))):\n var_4[var_5 + var_7] = max(var_4[var_5 + var_7], var_4[var_5] + var_6)\nprint((max(var_4)))\n```", "output": "FASTER 1.0971", "pair_id": "python_p02863_pair0037_forward", "problem_id": "p02863", "language": "python", "direction": "forward", "speedup_ratio": 2.1392} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n if list(str(var_4)) == list(reversed(str(var_4))):\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_4 = str(var_4)\n if var_4 == var_4[::-1]:\n var_3 += 1\nprint(var_3)\n```", "output": "FASTER 1.2534", "pair_id": "python_p03416_pair0163_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 2.384} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\ndef func_1():\n from sys import setrecursionlimit, stdin\n from os import environ\n from collections import defaultdict, deque, Counter\n from math import ceil, floor, gcd\n from itertools import accumulate, combinations, combinations_with_replacement\n\n setrecursionlimit(10**6)\n var_7 = (\n (lambda *var_11: print(*var_11))\n if \"TERM_PROGRAM\" in environ\n else lambda *var_12: 0\n )\n var_8 = lambda: stdin.readline().rstrip()\n var_3 = lambda: list(map(int, var_8().split()))\n var_1 = lambda: int(var_8())\n var_4 = 10**9 + 7\n var_2 = 10**9 + 10\n var_9, var_10 = var_8().split()\n var_5 = int(var_9)\n var_10 = var_10.split(\".\")\n var_6 = int(var_10[0]) * 100\n if len(var_10) == 2:\n var_6 += int(var_10[1])\n print(var_5 * var_6 // 100)\n\n\nfunc_1()\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = input().split()\nvar_1 = int(var_1)\nvar_2 = int(var_2.replace(\".\", \"\"))\nprint((var_1 * var_2 // 100))\n```", "output": "FASTER 2.4306", "pair_id": "python_p02659_pair0040_forward", "problem_id": "p02659", "language": "python", "direction": "forward", "speedup_ratio": 5.3911} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_4 = int(eval(input()))\nvar_1 = 0\nif var_4 == 2:\n print((2))\nelse:\n for var_2 in range(var_4, 10**6):\n for var_3 in range(2, var_2 // 2 + 2):\n if var_2 % var_3 == 0:\n break\n else:\n var_1 = var_2\n break\n print(var_1)\n```\n\n=== Code B (Modified) ===\n```python\nimport numpy as np\nfrom bisect import bisect_left\n\n\ndef func_1():\n var_4 = []\n var_1 = np.ones(10**5 + 10)\n var_1[0] = var_1[1] = 0\n for var_3, var_2 in enumerate(var_1):\n if var_2:\n var_4.append(var_3)\n var_1[2 * var_3 : 10**5 + 10 : var_3] = 0\n return var_4\n\n\ndef func_2(var_6):\n var_7 = int(var_6)\n var_5 = func_1()\n return str(var_5[bisect_left(var_5, var_7)])\n\n\nif __name__ == \"__main__\":\n import sys\n\n print((func_2(sys.stdin.read().strip())))\n```", "output": "SLOWER 7.742", "pair_id": "python_p02819_pair0007_reversed", "problem_id": "p02819", "language": "python", "direction": "reversed", "speedup_ratio": 214.0828} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport decimal\n\n\ndef func_1():\n var_1, var_2 = list(map(decimal.Decimal, input().split()))\n print((var_1 * var_2 // 1))\n\n\nif __name__ == \"__main__\":\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\nimport math\nfrom collections import defaultdict\nfrom bisect import bisect_left, bisect_right\n\nsys.setrecursionlimit(10**7)\n\n\ndef func_4():\n return sys.stdin.readline()[:-1]\n\n\nvar_4 = 10**9 + 7\n\n\ndef func_1():\n return int(eval(func_4()))\n\n\ndef func_2():\n return list(map(int, func_4().split()))\n\n\ndef func_3(var_6, var_3):\n if var_6 <= 0:\n return [[] for _ in range(var_3)]\n elif var_3 == 1:\n return [func_1() for _ in range(var_6)]\n else:\n var_5 = [func_2() for _ in range(var_6)]\n return list(map(list, list(zip(*var_5))))\n\n\nvar_1, var_2 = list(map(str, func_4().split()))\nvar_1 = int(var_1)\nvar_2 = 100 * int(var_2[0]) + 10 * int(var_2[2]) + int(var_2[3])\nprint((var_1 * var_2 // 100))\n```", "output": "SLOWER 2.0678", "pair_id": "python_p02659_pair0041_reversed", "problem_id": "p02659", "language": "python", "direction": "reversed", "speedup_ratio": 4.1925} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport numpy as np\n\nvar_7 = input()[::-1]\nvar_6 = len(var_7)\nvar_1 = np.zeros(var_6, dtype=int)\nvar_4 = np.zeros(var_6, dtype=int)\nvar_2 = np.zeros(2019, dtype=int)\nvar_8 = 10\nvar_1[0] = int(var_7[0])\nvar_4[0] = var_1[0]\nvar_2[var_4[0]] += 1\nfor var_5 in range(1, var_6):\n var_1[var_5] = int(var_7[var_5]) * var_8 % 2019\n var_4[var_5] = (var_4[var_5 - 1] + var_1[var_5]) % 2019\n var_2[var_4[var_5]] += 1\n var_8 = var_8 * 10 % 2019\nvar_3 = var_2[np.nonzero(var_2)]\nprint(\n (\n int(\n sum([var_3[var_5] * (var_3[var_5] - 1) for var_5 in range(var_3.shape[0])])\n / 2\n )\n + var_2[0]\n )\n)\n```\n\n=== Code B (Modified) ===\n```python\nvar_6 = input()[::-1]\nvar_4 = len(var_6)\nvar_2 = [0] * 2019\nvar_2[0] = 1\nvar_7 = 1\nvar_5 = 0\nvar_1 = 0\nfor var_3 in range(var_4):\n var_5 = (var_5 + int(var_6[var_3]) * var_7) % 2019\n var_7 = var_7 * 10 % 2019\n var_2[var_5] += 1\nfor var_3 in var_2:\n var_1 += var_3 * (var_3 - 1) // 2\nprint(var_1)\n```", "output": "SLOWER 1.3294", "pair_id": "python_p02702_pair0007_reversed", "problem_id": "p02702", "language": "python", "direction": "reversed", "speedup_ratio": 2.5129} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_4 = {}\nvar_5 = 0\nfor var_6 in range(10000, 100000):\n var_3 = list(str(var_6))\n if var_3 == list(reversed(var_3)):\n var_5 += 1\n var_4[var_6] = var_5\nvar_1, var_2 = list(map(int, input().split()))\nprint((var_4[var_2] - var_4[var_1 - 1] if var_1 > 10000 else var_4[var_2]))\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = list(reversed(list(str(var_4))))\n if var_5 == list(str(var_4)):\n var_3 += 1\nprint(var_3)\n```", "output": "FASTER 1.9167", "pair_id": "python_p03416_pair0164_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 3.7755} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_6 = int(eval(input()))\nvar_2 = list(map(int, input().split()))\nfrom itertools import product\n\nvar_5 = [-1, 0, 1]\nvar_3 = 0\nfor var_7 in product(var_5, repeat=var_6):\n var_1 = []\n for var_4 in range(var_6):\n var_1.append(var_7[var_4] + var_2[var_4])\n if any(var_8 % 2 == 0 for var_8 in var_1):\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_4 = int(eval(input()))\nvar_1 = list(map(int, input().split()))\nvar_3 = 1\nfor var_2 in var_1:\n var_3 *= 2 if var_2 % 2 == 0 else 1\nprint((3**var_4 - var_3))\n```", "output": "FASTER 9.9565", "pair_id": "python_p03568_pair0009_forward", "problem_id": "p03568", "language": "python", "direction": "forward", "speedup_ratio": 993.5967} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = str(var_4)\n if var_5 == var_5[::-1]:\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_7 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_3 = True\n var_8 = str(var_4)\n var_6 = len(var_8)\n for var_5 in range(var_6 // 2 + 1):\n if var_8[var_5] != var_8[-var_5 - 1]:\n var_3 = False\n break\n if var_3:\n var_7 += 1\nprint(var_7)\n```", "output": "SLOWER 1.1295", "pair_id": "python_p03416_pair0137_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 2.1879} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\ndef func_1():\n return list(map(int, input().split()))\n\n\nimport numpy as np\n\nvar_1, var_2, var_3 = func_1()\nvar_4 = np.array(list(func_1()))\nvar_6 = np.array(list(func_1()))\nvar_9 = min(var_4) + min(var_6)\nvar_5 = float(\"inf\")\nfor var_8 in range(var_3):\n var_11, var_12, var_7 = func_1()\n var_10 = var_4[var_11 - 1] + var_6[var_12 - 1] - var_7\n var_5 = min(var_5, var_10)\nprint((min(var_5, var_9)))\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\nfrom collections import Counter\n\n\ndef func_9():\n return sys.stdin.readline().strip()\n\n\ndef func_10(var_8, var_9, var_10):\n return [[var_10] * var_9 for var_13 in range(var_8)]\n\n\ndef func_11(var_8, var_9, var_10, var_11):\n return [[[var_11] * var_10 for var_14 in range(var_9)] for var_13 in range(var_8)]\n\n\ndef func_12(var_8, var_9, var_10, var_11, var_12):\n return [\n [[[var_12] * var_11 for var_14 in range(var_10)] for var_14 in range(var_9)]\n for var_13 in range(var_8)\n ]\n\n\ndef func_8(var_16, var_17=1):\n return int(-(-var_16 // var_17))\n\n\ndef func_1():\n return int(eval(func_9()))\n\n\ndef func_3():\n return list(map(int, func_9().split()))\n\n\ndef func_2(var_7=None):\n return list(func_3()) if var_7 is None else [func_1() for var_13 in range(var_7)]\n\n\ndef func_7():\n print(\"Yes\")\n\n\ndef func_5():\n print(\"No\")\n\n\ndef func_6():\n print(\"YES\")\n\n\ndef func_4():\n print(\"NO\")\n\n\nsys.setrecursionlimit(10**9)\nvar_3 = 10**18\nvar_6 = 10**9 + 7\nvar_7, var_5, var_4 = func_3()\nvar_1 = func_2()\nvar_2 = func_2()\nvar_15 = min(var_1) + min(var_2)\nfor _ in range(var_4):\n var_16, var_17, var_10 = func_3()\n var_16 -= 1\n var_17 -= 1\n var_15 = min(var_15, var_1[var_16] + var_2[var_17] - var_10)\nprint(var_15)\n```", "output": "SLOWER 1.587", "pair_id": "python_p02748_pair0008_reversed", "problem_id": "p02748", "language": "python", "direction": "reversed", "speedup_ratio": 3.0043} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_7 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_3 = True\n var_8 = str(var_4)\n var_6 = len(var_8)\n for var_5 in range(var_6 // 2 + 1):\n if var_8[var_5] != var_8[-var_5 - 1]:\n var_3 = False\n break\n if var_3:\n var_7 += 1\nprint(var_7)\n```\n\n=== Code B (Modified) ===\n```python\ndef func_1():\n var_1, var_2 = list(map(int, input().rstrip().split()))\n var_3 = 0\n for var_4 in range(var_1, var_2 + 1):\n var_5 = str(var_4)\n if var_5 == var_5[::-1]:\n var_3 += 1\n print(var_3)\n\n\nif __name__ == \"__main__\":\n func_1()\n```", "output": "FASTER 1.8711", "pair_id": "python_p03416_pair0165_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 3.6581} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\n\nvar_7 = sys.stdin.readline\nfrom itertools import combinations\n\n\ndef func_3(var_10):\n for _ in range(var_10):\n yield list(map(int, var_7().split()))\n\n\ndef func_1(var_9, var_5, var_11):\n var_3 = sum(1 if var_5[var_8] == 1 else 0 for var_8 in var_9)\n return var_11[var_3]\n\n\ndef func_2():\n var_10 = int(eval(var_7()))\n var_1 = list(func_3(var_10))\n var_2 = list(func_3(var_10))\n for var_6 in range(1, 11):\n for var_4 in combinations(list(range(10)), var_6):\n yield sum(\n func_1(var_4, var_5, var_11) for var_5, var_11 in zip(var_1, var_2)\n )\n\n\nprint((max(func_2())))\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\nimport itertools\n\n\ndef func_2(var_4):\n return eval(\"0b\" + var_4)\n\n\ndef func_1():\n var_4 = int(sys.stdin.readline().rstrip())\n var_9 = [\n func_2(\"\".join(str(var_10) for var_10 in sys.stdin.readline().split()))\n for _ in range(var_4)\n ]\n var_8 = [\n [int(var_10) for var_10 in sys.stdin.readline().split()] for _ in range(var_4)\n ]\n var_3 = -(10**10)\n for var_6 in itertools.product(\"01\", repeat=10):\n var_6 = func_2(\"\".join(var_6))\n if var_6 == 0:\n continue\n var_7 = 0\n for var_2 in range(var_4):\n var_1 = var_9[var_2]\n var_5 = bin(var_1 & var_6).count(\"1\")\n var_7 += var_8[var_2][var_5]\n var_3 = max(var_3, var_7)\n print(var_3)\n\n\nif __name__ == \"__main__\":\n\n func_1()\n```", "output": "SLOWER 1.4756", "pair_id": "python_p03503_pair0034_reversed", "problem_id": "p03503", "language": "python", "direction": "reversed", "speedup_ratio": 2.7809} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_4, var_3 = list(map(int, input().split()))\nvar_1 = 0\nfor var_2 in range(var_4, var_3 + 1):\n if str(var_2)[0] + str(var_2)[1] == str(var_2)[-1] + str(var_2)[-2]:\n var_1 += 1\nprint(var_1)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = [\n var_3 for var_3 in map(str, list(range(var_1, var_2 + 1))) if var_3 == var_3[::-1]\n]\nprint((len(var_4)))\n```", "output": "FASTER 2.0397", "pair_id": "python_p03416_pair0166_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 4.1115} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_8 = int(eval(input()))\nvar_4 = []\nfor var_5 in range(var_8):\n var_11 = 0\n var_9 = list(map(int, input().split()))\n for var_6 in range(10):\n var_11 += var_9[var_6] << var_6\n var_4.append(var_11)\nvar_10 = []\nfor var_5 in range(var_8):\n var_10.append(list(map(int, input().split())))\nvar_1 = -(10**12)\nfor var_5 in range(1, 1 << 10):\n var_11 = 0\n for var_6 in range(var_8):\n var_3 = var_4[var_6] & var_5\n var_2 = 0\n for var_7 in range(10):\n if (var_3 >> var_7) % 2:\n var_2 += 1\n var_11 += var_10[var_6][var_2]\n var_1 = max(var_1, var_11)\nprint(var_1)\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\n\nvar_7 = sys.stdin.readline\nfrom itertools import combinations\n\n\ndef func_3(var_10):\n for _ in range(var_10):\n yield list(map(int, var_7().split()))\n\n\ndef func_1(var_9, var_5, var_11):\n var_3 = len([0 for var_8 in var_9 if var_5[var_8] == 1])\n return var_11[var_3]\n\n\ndef func_2():\n var_10 = int(eval(var_7()))\n var_1 = list(func_3(var_10))\n var_2 = list(func_3(var_10))\n for var_6 in range(1, 11):\n for var_4 in combinations(list(range(10)), var_6):\n yield sum(\n func_1(var_4, var_5, var_11) for var_5, var_11 in zip(var_1, var_2)\n )\n\n\nprint((max(func_2())))\n```", "output": "FASTER 1.4578", "pair_id": "python_p03503_pair0035_forward", "problem_id": "p03503", "language": "python", "direction": "forward", "speedup_ratio": 2.7469} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\nimport math\nfrom collections import defaultdict\nfrom bisect import bisect_left, bisect_right\n\nsys.setrecursionlimit(10**7)\n\n\ndef func_4():\n return sys.stdin.readline()[:-1]\n\n\nvar_4 = 10**9 + 7\n\n\ndef func_1():\n return int(eval(func_4()))\n\n\ndef func_2():\n return list(map(int, func_4().split()))\n\n\ndef func_3(var_6, var_3):\n if var_6 <= 0:\n return [[] for _ in range(var_3)]\n elif var_3 == 1:\n return [func_1() for _ in range(var_6)]\n else:\n var_5 = [func_2() for _ in range(var_6)]\n return list(map(list, list(zip(*var_5))))\n\n\nfrom decimal import getcontext, Decimal\n\ngetcontext().prec = 28\nvar_1, var_2 = list(map(str, func_4().split()))\nvar_1 = int(var_1)\nvar_2 = Decimal(var_2)\nprint((int(var_1 * var_2)))\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = input().split()\nvar_1 = int(var_1)\nvar_3, var_4 = list(map(int, var_2.split(\".\")))\nvar_5 = var_1 * (var_3 * 100 + var_4)\nprint((int(var_5 // 100)))\n```", "output": "FASTER 2.0589", "pair_id": "python_p02659_pair0042_forward", "problem_id": "p02659", "language": "python", "direction": "forward", "speedup_ratio": 4.1668} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\ndef func_1():\n var_1, var_2 = list(map(int, input().rstrip().split()))\n var_3 = 0\n for var_4 in range(var_1, var_2 + 1):\n var_5 = str(var_4)\n if var_5 == var_5[::-1]:\n var_3 += 1\n print(var_3)\n\n\nif __name__ == \"__main__\":\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n if list(str(var_4)) == list(reversed(str(var_4))):\n var_3 += 1\nprint(var_3)\n```", "output": "SLOWER 2.1464", "pair_id": "python_p03416_pair0002_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 4.4271} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_6 = int(eval(input()))\nvar_2 = list(map(int, input().split()))\nfrom itertools import product\n\nvar_5 = [-1, 0, 1]\nvar_3 = 0\nfor var_7 in product(var_5, repeat=var_6):\n var_1 = []\n for var_4 in range(var_6):\n var_1.append(var_7[var_4] + var_2[var_4])\n if any(var_8 % 2 == 0 for var_8 in var_1):\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nimport math\nimport string\n\n\ndef func_5():\n return list(map(int, input().split()))\n\n\ndef func_4(var_7, var_8):\n return math.factorial(var_7) // (\n math.factorial(var_7 - var_8) * math.factorial(var_8)\n )\n\n\ndef func_3(var_10):\n var_9 = []\n for var_5 in var_10:\n if not (var_5 in var_9):\n var_9.append(var_5)\n return len(var_10) != len(var_9)\n\n\ndef func_1(var_7):\n func_1 = []\n for var_4 in range(1, var_7 + 1):\n if var_7 % var_4 == 0:\n func_1.append(var_4)\n return func_1\n\n\nvar_2 = [-1, -1, -1, 0, 0, 1, 1, 1]\nvar_3 = [-1, 0, 1, -1, 1, -1, 0, 1]\nvar_7 = int(eval(input()))\nvar_1 = func_5()\n\n\ndef func_2(var_6):\n if len(var_6) == var_7:\n for var_4 in range(len(var_6)):\n if var_6[var_4] % 2 == 0:\n return 1\n return 0\n return (\n func_2(var_6 + [var_1[len(var_6)]])\n + func_2(var_6 + [var_1[len(var_6)] - 1])\n + func_2(var_6 + [var_1[len(var_6)] + 1])\n )\n\n\nprint((func_2([])))\n```", "output": "FASTER 2.1906", "pair_id": "python_p03568_pair0032_forward", "problem_id": "p03568", "language": "python", "direction": "forward", "speedup_ratio": 4.5649} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\nfrom operator import itemgetter\nfrom heapq import heapify, heappop, heappush\n\nvar_1 = int(10e15)\nvar_2 = -var_1\nvar_11 = 1000000007\nsys.setrecursionlimit(1000000)\n\n\ndef func_2():\n return list(map(int, input().split()))\n\n\ndef func_4():\n return input().split()\n\n\ndef func_1():\n return int(sys.stdin.readline())\n\n\ndef func_3():\n return eval(input())\n\n\nvar_3, var_4 = func_2()\nvar_5 = [func_2() for var_9 in range(var_3)]\nvar_5.sort(key=itemgetter(0))\n\nvar_8 = [[0] * (var_4 + 1 + 3000 + 1) for _ in range(var_3 + 1)]\nvar_6 = 0\nfor var_9 in range(var_3):\n for var_10 in range(var_4 + 1 + 3000 + 1):\n var_12, var_7 = var_5[var_9]\n if 0 <= var_10 - var_12 < var_4:\n var_8[var_9 + 1][var_10] = max(\n var_8[var_9][var_10], var_8[var_9][var_10 - var_12] + var_7\n )\n else:\n var_8[var_9 + 1][var_10] = var_8[var_9][var_10]\n var_6 = max(var_6, var_8[var_9 + 1][var_10])\nprint(var_6)\n```\n\n=== Code B (Modified) ===\n```python\ndef func_1():\n var_2, var_3, *var_1 = list(map(int, open(0).read().split()))\n var_4 = [0] * (var_3 + max(var_1[::2]))\n for var_7, var_6 in sorted(zip(*[iter(var_1)] * 2)):\n for var_5 in reversed(list(range(var_3))):\n var_4[var_5 + var_7] = max(var_4[var_5 + var_7], var_4[var_5] + var_6)\n print((max(var_4)))\n\n\nfunc_1()\n```", "output": "FASTER 6.1143", "pair_id": "python_p02863_pair0038_forward", "problem_id": "p02863", "language": "python", "direction": "forward", "speedup_ratio": 69.2784} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nfrom sys import stdin\n\n\ndef func_1():\n\n var_9 = stdin.readline\n var_8, var_10 = list(map(int, var_9().split()))\n var_7 = [list(map(int, var_9().split())) for _ in range(var_8)]\n var_7.sort()\n var_1 = [0] * var_8\n var_2 = [0] * var_8\n for var_4 in range(var_8):\n var_1[var_4], var_2[var_4] = var_7[var_4][0], var_7[var_4][1]\n\n var_5 = -(10**9)\n var_3 = [[var_5] * (var_10 + 1) for _ in range(var_8 + 1)]\n var_3[0][0] = 0\n for var_4 in range(var_8):\n for var_6 in range(var_10 + 1):\n\n if var_6 != var_10:\n var_3[var_4 + 1][min(var_10, var_6 + var_1[var_4])] = max(\n var_3[var_4 + 1][min(var_10, var_6 + var_1[var_4])],\n var_3[var_4][var_6] + var_2[var_4],\n )\n\n var_3[var_4 + 1][var_6] = max(var_3[var_4 + 1][var_6], var_3[var_4][var_6])\n print((max(var_3[var_8])))\n\n\nif __name__ == \"__main__\":\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\ndef func_1():\n var_2, var_3, *var_1 = list(map(int, open(0).read().split()))\n var_4 = [0] * (var_3 + max(var_1[::2]))\n for var_7, var_6 in sorted(zip(*[iter(var_1)] * 2)):\n for var_5 in reversed(list(range(var_3))):\n var_4[var_5 + var_7] = max(var_4[var_5 + var_7], var_4[var_5] + var_6)\n print((max(var_4)))\n\n\nfunc_1()\n```", "output": "FASTER 1.1965", "pair_id": "python_p02863_pair0006_forward", "problem_id": "p02863", "language": "python", "direction": "forward", "speedup_ratio": 2.2918} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nfor var_3 in range(1, 1009):\n if int(var_3 * 0.08) == var_1 and int(var_3 * 0.1) == var_2:\n print((int(var_3)))\n exit()\nprint(\"-1\")\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_3 = list(map(int, input().split()))\nvar_2 = -1\nfor var_4 in range(10, 12501):\n if int(var_4 * 0.08) == var_1 and int(var_4 * 0.1) == var_3:\n var_2 = var_4\n break\nprint(var_2)\n```", "output": "SLOWER 3.3967", "pair_id": "python_p02755_pair0008_reversed", "problem_id": "p02755", "language": "python", "direction": "reversed", "speedup_ratio": 10.5316} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_5 = input()[::-1]\nvar_2 = [0] * 2019\nvar_2[0] = 1\nvar_4 = 0\nvar_6 = 1\nvar_1 = 0\nfor var_3 in var_5:\n var_4 = (var_4 + int(var_3) * var_6) % 2019\n var_6 = var_6 * 10 % 2019\n var_2[var_4] += 1\nfor var_3 in var_2:\n var_1 += var_3 * (var_3 - 1) // 2\nprint(var_1)\n```\n\n=== Code B (Modified) ===\n```python\n\"\"\"\"\"\"\n\nfrom collections import defaultdict\n\n\ndef func_1(var_10, var_9):\n var_5 = 1\n yield var_5\n for _ in range(1, var_10):\n var_5 = (var_5 * 10) % var_9\n yield var_5\n\n\ndef func_2():\n var_3 = 2019\n var_4 = input()[::-1]\n\n var_1 = [\n int(var_11) * var_10 % var_3\n for var_11, var_10 in zip(var_4, func_1(len(var_4), var_3))\n ]\n\n var_2 = [0]\n for var_5 in var_1:\n var_2.append((var_2[-1] + var_5) % var_3)\n\n var_8 = defaultdict(int)\n for var_6 in var_2:\n var_8[var_6] += 1\n var_7 = sum(var_12 * (var_12 - 1) // 2 for var_12 in list(var_8.values()))\n print(var_7)\n\n\nfunc_2()\n```", "output": "FASTER 1.3201", "pair_id": "python_p02702_pair0010_forward", "problem_id": "p02702", "language": "python", "direction": "forward", "speedup_ratio": 2.4969} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\ndef func_1():\n var_1, var_2 = list(map(int, input().split()))\n var_3 = 0\n for var_4 in range(var_1, var_2 + 1):\n\n if (var_4 % 10) == (var_4 // 10000 % 10) and (var_4 // 10 % 10) == (\n var_4 // 1000 % 10\n ):\n var_3 += 1\n print(var_3)\n\n\nif __name__ == \"__main__\":\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_7 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_3 = True\n var_8 = str(var_4)\n var_6 = len(var_8)\n for var_5 in range(var_6 // 2 + 1):\n if var_8[var_5] != var_8[-var_5 - 1]:\n var_3 = False\n break\n if var_3:\n var_7 += 1\nprint(var_7)\n```", "output": "SLOWER 2.7891", "pair_id": "python_p03416_pair0074_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 6.9122} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_4 = {}\nvar_5 = 0\nfor var_6 in range(10000, 100000):\n var_3 = list(str(var_6))\n if var_3 == list(reversed(var_3)):\n var_5 += 1\n var_4[var_6] = var_5\nvar_1, var_2 = list(map(int, input().split()))\nprint((var_4[var_2] - var_4[var_1 - 1] if var_1 > 10000 else var_4[var_2]))\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = [0] * (var_2 + 1)\nfor var_3 in range(1, var_2 + 1):\n if str(var_3) == str(var_3)[::-1]:\n var_4[var_3] = var_4[var_3 - 1] + 1\n else:\n var_4[var_3] = var_4[var_3 - 1]\nprint((var_4[var_2] - var_4[var_1 - 1]))\n```", "output": "FASTER 1.6313", "pair_id": "python_p03416_pair0167_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 3.098} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = input().split()\nprint((int(var_1) * int(var_2[:-3] + var_2[-2:]) // 100))\n```\n\n=== Code B (Modified) ===\n```python\ndef func_1():\n from sys import setrecursionlimit, stdin\n from os import environ\n from collections import defaultdict, deque, Counter\n from math import ceil, floor, gcd\n from itertools import accumulate, combinations, combinations_with_replacement\n\n setrecursionlimit(10**6)\n var_7 = (\n (lambda *var_11: print(*var_11))\n if \"TERM_PROGRAM\" in environ\n else lambda *var_12: 0\n )\n var_8 = lambda: stdin.readline().rstrip()\n var_3 = lambda: list(map(int, var_8().split()))\n var_1 = lambda: int(var_8())\n var_4 = 10**9 + 7\n var_2 = 10**9 + 10\n var_9, var_10 = var_8().split()\n var_5 = int(var_9)\n var_10 = var_10.split(\".\")\n var_6 = int(var_10[0]) * 100\n if len(var_10) == 2:\n var_6 += int(var_10[1])\n print(var_5 * var_6 // 100)\n\n\nfunc_1()\n```", "output": "SLOWER 2.5742", "pair_id": "python_p02659_pair0043_reversed", "problem_id": "p02659", "language": "python", "direction": "reversed", "speedup_ratio": 5.9555} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport math\nimport string\n\n\ndef func_4():\n return list(map(int, input().split()))\n\n\ndef func_3(var_6, var_7):\n return math.factorial(var_6) // (\n math.factorial(var_6 - var_7) * math.factorial(var_7)\n )\n\n\ndef func_2(var_9):\n var_8 = []\n for var_5 in var_9:\n if not (var_5 in var_8):\n var_8.append(var_5)\n return len(var_9) != len(var_8)\n\n\ndef func_1(var_6):\n func_1 = []\n for var_4 in range(1, var_6 + 1):\n if var_6 % var_4 == 0:\n func_1.append(var_4)\n return func_1\n\n\nvar_2 = [-1, -1, -1, 0, 0, 1, 1, 1]\nvar_3 = [-1, 0, 1, -1, 1, -1, 0, 1]\nvar_6 = int(eval(input()))\nvar_1 = func_4()\nvar_10 = 1\nfor var_4 in range(len(var_1)):\n if var_1[var_4] % 2 == 0:\n var_10 *= 2\n else:\n var_10 *= 1\nprint((3 ** len(var_1) - var_10))\n```\n\n=== Code B (Modified) ===\n```python\nvar_2 = int(eval(input()))\n(*var_1,) = list(map(int, input().split()))\nvar_5 = 0\nfor var_3 in var_1:\n if var_3 % 2 == 0:\n var_5 += 1\nvar_4 = 3**var_2 - 2**var_5\nprint(var_4)\n```", "output": "FASTER 1.6929", "pair_id": "python_p03568_pair0033_forward", "problem_id": "p03568", "language": "python", "direction": "forward", "speedup_ratio": 3.2331} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = input().split()\nprint((int(var_1) * int(var_2[:-3] + var_2[-2:]) // 100))\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\nimport math\nfrom collections import defaultdict\nfrom bisect import bisect_left, bisect_right\n\nsys.setrecursionlimit(10**7)\n\n\ndef func_4():\n return sys.stdin.readline()[:-1]\n\n\nvar_4 = 10**9 + 7\n\n\ndef func_1():\n return int(eval(func_4()))\n\n\ndef func_2():\n return list(map(int, func_4().split()))\n\n\ndef func_3(var_6, var_3):\n if var_6 <= 0:\n return [[] for _ in range(var_3)]\n elif var_3 == 1:\n return [func_1() for _ in range(var_6)]\n else:\n var_5 = [func_2() for _ in range(var_6)]\n return list(map(list, list(zip(*var_5))))\n\n\nvar_1, var_2 = list(map(str, func_4().split()))\nvar_1 = int(var_1)\nvar_2 = 100 * int(var_2[0]) + 10 * int(var_2[2]) + int(var_2[3])\nprint((var_1 * var_2 // 100))\n```", "output": "SLOWER 2.7265", "pair_id": "python_p02659_pair0044_reversed", "problem_id": "p02659", "language": "python", "direction": "reversed", "speedup_ratio": 6.6183} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\ndef func_1(*var_2: str) -> str:\n var_3 = int(var_2[0])\n var_4 = 1\n var_1 = 7 % var_3\n while var_1:\n var_1 = (var_1 * 10 + 7) % var_3\n var_4 += 1\n if var_3 < var_4:\n var_4 = -1\n break\n return str(var_4)\n\n\nif __name__ == \"__main__\":\n print((func_1(*(open(0).read().splitlines()))))\n```\n\n=== Code B (Modified) ===\n```python\nvar_1 = int(eval(input()))\nvar_3 = 0\nfor var_2 in range(1000001):\n var_3 += 7 * pow(10, var_2, var_1)\n var_3 %= var_1\n if var_3 == 0:\n print((var_2 + 1))\n break\nelse:\n print((-1))\n```", "output": "SLOWER 3.1368", "pair_id": "python_p02596_pair0001_reversed", "problem_id": "p02596", "language": "python", "direction": "reversed", "speedup_ratio": 8.7958} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_3 = list(map(int, input().split()))\nvar_2 = 0\nfor var_5 in range(var_3 + 1)[var_1:]:\n if len(str(var_5)) % 2 == 0:\n var_6 = list(str(var_5))[: len(str(var_5)) // 2]\n var_7 = list(reversed(list(str(var_5))[len(str(var_5)) // 2 :]))\n if var_6 == var_7:\n var_2 += 1\n else:\n var_8 = list(str(var_5))[: len(str(var_5)) // 2 + 1]\n var_4 = list(reversed(list(str(var_5))[len(str(var_5)) // 2 :]))\n if var_8 == var_4:\n var_2 += 1\nprint(var_2)\n```\n\n=== Code B (Modified) ===\n```python\nfrom sys import stdin\n\nvar_6 = lambda: list(map(int, stdin.readline().split()))\nvar_5 = lambda: list(map(int, stdin.readline().split()))\nvar_1, var_3 = var_6()\nvar_2 = 0\nfor var_4 in range(var_1, var_3 + 1):\n var_7 = str(var_4)\n if var_7 == var_7[::-1]:\n var_2 += 1\nprint(var_2)\n```", "output": "FASTER 2.4561", "pair_id": "python_p03416_pair0168_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 5.4874} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = str(var_4)\n if var_5[0] == var_5[4] and var_5[1] == var_5[3]:\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_4, var_3 = list(map(int, input().split()))\nvar_1 = 0\nfor var_2 in range(var_4, var_3 + 1):\n if str(var_2)[0] + str(var_2)[1] == str(var_2)[-1] + str(var_2)[-2]:\n var_1 += 1\nprint(var_1)\n```", "output": "SLOWER 1.6072", "pair_id": "python_p03416_pair0156_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 3.0467} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = str(var_4)\n if var_5 == var_5[::-1]:\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n if str(var_4) == \"\".join(reversed(str(var_4))):\n var_3 += 1\nprint(var_3)\n```", "output": "SLOWER 1.0807", "pair_id": "python_p03416_pair0035_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 2.1151} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\n\nvar_7 = sys.stdin.readline\nfrom itertools import combinations\n\n\ndef func_3(var_10):\n for _ in range(var_10):\n yield list(map(int, var_7().split()))\n\n\ndef func_1(var_9, var_5, var_11):\n var_3 = sum(1 if var_5[var_8] == 1 else 0 for var_8 in var_9)\n return var_11[var_3]\n\n\ndef func_2():\n var_10 = int(eval(var_7()))\n var_1 = list(func_3(var_10))\n var_2 = list(func_3(var_10))\n for var_6 in range(1, 11):\n for var_4 in combinations(list(range(10)), var_6):\n yield sum(\n func_1(var_4, var_5, var_11) for var_5, var_11 in zip(var_1, var_2)\n )\n\n\nprint((max(func_2())))\n```\n\n=== Code B (Modified) ===\n```python\nimport itertools\n\nvar_6 = int(eval(input()))\nvar_2 = [[]] * var_6\nfor var_4 in range(var_6):\n var_3 = list(map(int, input().split()))\n\n var_2[var_4] = var_3\nvar_8 = [[]] * var_6\nfor var_4 in range(var_6):\n var_9 = list(map(int, input().split()))\n var_8[var_4] = var_9\nvar_10 = -(10**11)\nfor var_1 in itertools.product([0, 1], repeat=10):\n if sum(var_1) == 0:\n continue\n var_11 = 0\n for var_7 in range(var_6):\n var_5 = 0\n for var_4 in range(10):\n if var_2[var_7][var_4] == 1 and var_1[var_4] == 1:\n var_5 += 1\n var_11 = var_11 + var_8[var_7][var_5]\n var_10 = max(var_10, var_11)\nprint(var_10)\n```", "output": "SLOWER 1.0485", "pair_id": "python_p03503_pair0025_reversed", "problem_id": "p03503", "language": "python", "direction": "reversed", "speedup_ratio": 2.0684} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_7, var_6 = list(map(int, input().split()))\nvar_5 = [tuple(input().split()) for _ in range(var_6)]\nvar_9 = [[] for _ in range(var_7)]\nfor var_2 in range(var_6):\n var_9[int(var_5[var_2][0]) - 1].append(var_5[var_2][1])\nvar_1, var_8 = 0, 0\nfor var_3 in range(var_7):\n if \"AC\" in var_9[var_3]:\n var_1 += 1\n for var_4 in range(len(var_9[var_3])):\n if var_9[var_3][var_4] == \"WA\":\n var_8 += 1\n else:\n break\nprint((var_1, var_8))\n```\n\n=== Code B (Modified) ===\n```python\nvar_2, var_1 = list(map(int, input().split()))\nvar_3 = 0\nvar_8 = 0\nvar_4 = [0] * (var_2 + 1)\nvar_9 = [0] * (var_2 + 1)\nfor var_5 in range(var_1):\n var_6, var_7 = input().split()\n var_6 = int(var_6)\n if var_7 == \"AC\":\n if var_4[var_6] == 0:\n var_3 += 1\n var_8 += var_9[var_6]\n var_4[var_6] = 1\n else:\n var_9[var_6] += 1\nprint((var_3, var_8))\n```", "output": "FASTER 4.4932", "pair_id": "python_p02802_pair0009_forward", "problem_id": "p02802", "language": "python", "direction": "forward", "speedup_ratio": 22.5216} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\n\nvar_8 = sys.stdin.readline\n\n\ndef func_1():\n var_2 = int(eval(var_8()))\n var_1 = []\n for _ in range(var_2):\n var_1.append(list(map(int, var_8().split())))\n var_3 = []\n for _ in range(var_2):\n var_3.append(list(map(int, var_8().split())))\n var_4 = -(10**7) * var_2\n for var_7 in range(1, 1 << 10):\n var_11 = 0\n for var_10, var_6 in enumerate(var_1):\n var_5 = 0\n for var_9 in range(10):\n if (var_7 >> var_9) & 1 & var_6[var_9]:\n var_5 += 1\n var_11 += var_3[var_10][var_5]\n var_4 = max(var_4, var_11)\n print(var_4)\n\n\nif __name__ == \"__main__\":\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\nimport itertools\n\n\ndef func_2(var_4):\n return eval(\"0b\" + var_4)\n\n\ndef func_1():\n var_4 = int(sys.stdin.readline().rstrip())\n var_9 = [\n func_2(\"\".join(str(var_10) for var_10 in sys.stdin.readline().split()))\n for _ in range(var_4)\n ]\n var_8 = [\n [int(var_10) for var_10 in sys.stdin.readline().split()] for _ in range(var_4)\n ]\n var_3 = -(10**10)\n for var_6 in itertools.product(\"01\", repeat=10):\n var_6 = func_2(\"\".join(var_6))\n if var_6 == 0:\n continue\n var_7 = 0\n for var_2 in range(var_4):\n var_1 = var_9[var_2]\n var_5 = bin(var_1 & var_6).count(\"1\")\n var_7 += var_8[var_2][var_5]\n var_3 = max(var_3, var_7)\n print(var_3)\n\n\nif __name__ == \"__main__\":\n\n func_1()\n```", "output": "SLOWER 1.366", "pair_id": "python_p03503_pair0028_reversed", "problem_id": "p03503", "language": "python", "direction": "reversed", "speedup_ratio": 2.5776} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nfrom itertools import product\n\nvar_6 = int(eval(input()))\nvar_1 = list(map(int, input().split()))\nvar_5 = 0\nfor var_2 in product((-1, 0, 1), repeat=var_6):\n var_7 = 1\n for var_3, var_4 in zip(var_1, var_2):\n var_7 *= var_3 + var_4\n if var_7 % 2 == 0:\n var_5 += 1\nprint(var_5)\n```\n\n=== Code B (Modified) ===\n```python\nvar_2 = int(eval(input()))\nvar_1 = list(map(int, input().split()))\nvar_4 = 1\nfor var_3 in range(var_2):\n if var_1[var_3] % 2 == 0:\n var_4 *= 2\nprint((3**var_2 - var_4))\n```", "output": "FASTER 10.0467", "pair_id": "python_p03568_pair0004_forward", "problem_id": "p03568", "language": "python", "direction": "forward", "speedup_ratio": 1057.6766} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_4 = int(eval(input()))\nvar_1 = list(map(int, input().split()))\nvar_3 = 1\nfor var_2 in var_1:\n var_3 *= 2 if var_2 % 2 == 0 else 1\nprint((3**var_4 - var_3))\n```\n\n=== Code B (Modified) ===\n```python\nfrom itertools import product\n\nvar_6 = int(eval(input()))\nvar_1 = list(map(int, input().split()))\nvar_5 = 0\nfor var_2 in product((-1, 0, 1), repeat=var_6):\n var_7 = 1\n for var_3, var_4 in zip(var_1, var_2):\n var_7 *= var_3 + var_4\n if var_7 % 2 == 0:\n var_5 += 1\nprint(var_5)\n```", "output": "SLOWER 10.1524", "pair_id": "python_p03568_pair0020_reversed", "problem_id": "p03568", "language": "python", "direction": "reversed", "speedup_ratio": 1138.1035} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_5 in range(10):\n for var_6 in range(10):\n for var_7 in range(10):\n var_3 = 10000 * var_5 + 1000 * var_6 + 100 * var_7 + 10 * var_6 + var_5\n if var_1 <= var_3 <= var_2:\n var_4 += 1\nprint(var_4)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_3 = list(map(int, input().split()))\nvar_2 = 0\nfor var_5 in range(var_3 + 1)[var_1:]:\n if len(str(var_5)) % 2 == 0:\n var_6 = list(str(var_5))[: len(str(var_5)) // 2]\n var_7 = list(reversed(list(str(var_5))[len(str(var_5)) // 2 :]))\n if var_6 == var_7:\n var_2 += 1\n else:\n var_8 = list(str(var_5))[: len(str(var_5)) // 2 + 1]\n var_4 = list(reversed(list(str(var_5))[len(str(var_5)) // 2 :]))\n if var_8 == var_4:\n var_2 += 1\nprint(var_2)\n```", "output": "SLOWER 6.3001", "pair_id": "python_p03416_pair0139_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 78.7987} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_10 = []\nvar_10 = input().rstrip().split(\" \")\nvar_1 = int(var_10[0])\nvar_3 = int(var_10[1])\nvar_2 = 0\nvar_6 = var_1\nwhile var_6 <= var_3:\n var_4 = var_6 // 10000\n var_5 = (var_6 - var_4 * 10000) // 1000\n var_7 = var_6 // 100\n var_8 = (var_6 - var_7 * 100) // 10\n var_9 = var_6 % 10\n if (var_4 == var_9) and (var_5 == var_8):\n var_2 += 1\n var_6 += 1\nprint(var_2)\n```\n\n=== Code B (Modified) ===\n```python\ndef func_1():\n var_1, var_2 = list(map(int, input().split()))\n var_3 = 0\n for var_4 in range(var_1, var_2 + 1):\n\n if (var_4 % 10) == (var_4 // 10000 % 10) and (var_4 // 10 % 10) == (\n var_4 // 1000 % 10\n ):\n var_3 += 1\n print(var_3)\n\n\nif __name__ == \"__main__\":\n func_1()\n```", "output": "FASTER 2.4731", "pair_id": "python_p03416_pair0026_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 5.5522} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_7 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_3 = True\n var_8 = str(var_4)\n var_6 = len(var_8)\n for var_5 in range(var_6 // 2 + 1):\n if var_8[var_5] != var_8[-var_5 - 1]:\n var_3 = False\n break\n if var_3:\n var_7 += 1\nprint(var_7)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\n\n\ndef func_1(var_5, var_6):\n var_4 = 0\n for var_3 in range(var_5, var_6 + 1):\n if str(var_3) == str(var_3)[::-1]:\n var_4 += 1\n return var_4\n\n\nprint((func_1(var_1, var_2)))\n```", "output": "FASTER 1.4487", "pair_id": "python_p03416_pair0169_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 2.7297} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport numpy as np\n\nvar_7 = input()[::-1]\nvar_6 = len(var_7)\nvar_1 = np.zeros(var_6, dtype=int)\nvar_4 = np.zeros(var_6, dtype=int)\nvar_2 = np.zeros(2019, dtype=int)\nvar_8 = 10\nvar_1[0] = int(var_7[0])\nvar_4[0] = var_1[0]\nvar_2[var_4[0]] += 1\nfor var_5 in range(1, var_6):\n var_1[var_5] = int(var_7[var_5]) * var_8 % 2019\n var_4[var_5] = (var_4[var_5 - 1] + var_1[var_5]) % 2019\n var_2[var_4[var_5]] += 1\n var_8 = var_8 * 10 % 2019\nvar_3 = var_2[np.nonzero(var_2)]\nprint(\n (\n int(\n sum([var_3[var_5] * (var_3[var_5] - 1) for var_5 in range(var_3.shape[0])])\n / 2\n )\n + var_2[0]\n )\n)\n```\n\n=== Code B (Modified) ===\n```python\nvar_6 = input()[::-1]\nvar_5 = len(var_6)\nvar_1 = [0] * var_5\nvar_3 = [0] * var_5\nvar_2 = [0] * 2019\nvar_7 = 10\nvar_1[0] = int(var_6[0])\nvar_3[0] = var_1[0]\nvar_2[var_3[0]] += 1\nfor var_4 in range(1, var_5):\n var_1[var_4] = int(var_6[var_4]) * var_7 % 2019\n var_3[var_4] = (var_3[var_4 - 1] + var_1[var_4]) % 2019\n var_2[var_3[var_4]] += 1\n var_7 = var_7 * 10 % 2019\nprint(\n (\n int(sum([var_2[var_4] * (var_2[var_4] - 1) for var_4 in range(2019)]) / 2)\n + var_2[0]\n )\n)\n```", "output": "SLOWER 1.0297", "pair_id": "python_p02702_pair0009_reversed", "problem_id": "p02702", "language": "python", "direction": "reversed", "speedup_ratio": 2.0416} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\n_, var_1 = open(0)\nvar_1, *var_2 = list(map(int, var_1.split()))\nfor var_2 in var_2:\n var_1 ^= var_2\nprint((\"YNeos\"[var_1 > 0 :: 2]))\n```\n\n=== Code B (Modified) ===\n```python\nfrom collections import defaultdict\n\nvar_8 = int(eval(input()))\nvar_1 = tuple(map(int, input().split()))\nvar_3 = True\nif var_8 % 3 == 0:\n var_5 = defaultdict(int)\n for var_2 in var_1:\n var_5[var_2] += 1\n var_7 = var_8 // 3\n var_10 = []\n for var_9, var_4 in list(var_5.items()):\n if var_4 % var_7 != 0:\n var_3 = False\n break\n else:\n for _ in range(var_4 // var_7):\n var_10.append(var_9)\n else:\n if any(\n var_10[(0 + var_6) % 3] ^ var_10[(1 + var_6) % 3] != var_10[(2 + var_6) % 3]\n for var_6 in range(3)\n ):\n var_3 = False\nelse:\n if any(var_2 != 0 for var_2 in var_1):\n var_3 = False\nprint((\"Yes\" if var_3 else \"No\"))\n```", "output": "SLOWER 1.2494", "pair_id": "python_p02975_pair0007_reversed", "problem_id": "p02975", "language": "python", "direction": "reversed", "speedup_ratio": 2.3774} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n if list(str(var_4)) == list(reversed(str(var_4))):\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\n\n\ndef func_1(var_5, var_6):\n var_4 = 0\n for var_3 in range(var_5, var_6 + 1):\n if str(var_3) == str(var_3)[::-1]:\n var_4 += 1\n return var_4\n\n\nprint((func_1(var_1, var_2)))\n```", "output": "FASTER 1.724", "pair_id": "python_p03416_pair0170_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 3.3035} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_4 = str(var_4)\n if var_4 == var_4[::-1]:\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n if list(str(var_4)) == list(reversed(str(var_4))):\n var_3 += 1\nprint(var_3)\n```", "output": "SLOWER 1.2534", "pair_id": "python_p03416_pair0163_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 2.384} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = input().split()\nvar_1 = int(var_1)\nvar_2 = int(var_2)\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = list(str(var_4))\n if (var_5[0] == var_5[4]) and (var_5[1] == var_5[3]):\n var_3 = var_3 + 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\ndef func_1():\n var_1, var_2 = list(map(int, input().split()))\n var_3 = 0\n for var_4 in range(var_1, var_2 + 1):\n\n if (var_4 % 10) == (var_4 // 10000 % 10) and (var_4 // 10 % 10) == (\n var_4 // 1000 % 10\n ):\n var_3 += 1\n print(var_3)\n\n\nif __name__ == \"__main__\":\n func_1()\n```", "output": "FASTER 2.0684", "pair_id": "python_p03416_pair0171_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 4.1941} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nfrom sys import stdin\n\n\ndef func_1():\n\n var_11 = stdin.readline\n var_2 = int(var_11())\n var_1 = []\n for var_6 in range(var_2):\n var_5 = int(\"\".join(var_11().strip().split(\" \")), 2)\n var_1.append(var_5)\n var_3 = []\n for var_6 in range(var_2):\n var_10 = list(map(int, var_11().split()))\n var_3.append(var_10)\n var_8 = float(\"-inf\")\n for var_9 in range(1, 1 << 10):\n var_12 = 0\n for var_7 in range(var_2):\n var_4 = bin(var_9 & var_1[var_7]).count(\"1\")\n var_12 += var_3[var_7][var_4]\n var_8 = max(var_12, var_8)\n print(var_8)\n\n\nif __name__ == \"__main__\":\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\n\nvar_7 = sys.stdin.readline\nfrom itertools import combinations\n\n\ndef func_3(var_10):\n for _ in range(var_10):\n yield list(map(int, var_7().split()))\n\n\ndef func_1(var_9, var_5, var_11):\n var_3 = len([0 for var_8 in var_9 if var_5[var_8] == 1])\n return var_11[var_3]\n\n\ndef func_2():\n var_10 = int(eval(var_7()))\n var_1 = list(func_3(var_10))\n var_2 = list(func_3(var_10))\n for var_6 in range(1, 11):\n for var_4 in combinations(list(range(10)), var_6):\n yield sum(\n func_1(var_4, var_5, var_11) for var_5, var_11 in zip(var_1, var_2)\n )\n\n\nprint((max(func_2())))\n```", "output": "SLOWER 1.2554", "pair_id": "python_p03503_pair0036_reversed", "problem_id": "p03503", "language": "python", "direction": "reversed", "speedup_ratio": 2.3874} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nfrom collections import Counter\n\nvar_1 = input()[::-1]\nvar_5 = [0]\nvar_4 = 0\nvar_6 = 2019\nfor var_7 in var_1:\n var_8 = int(var_7) * pow(10, var_4, var_6) % var_6\n var_8 = var_5[-1] + var_8\n var_5.append(var_8 % var_6)\n var_4 += 1\nvar_3 = Counter(var_5)\nvar_2 = sum(var_9 * (var_9 - 1) // 2 for var_9 in list(var_3.values()))\nprint(var_2)\n```\n\n=== Code B (Modified) ===\n```python\nvar_6 = input()[::-1]\nvar_5 = len(var_6)\nvar_1 = [0] * var_5\nvar_3 = [0] * var_5\nvar_2 = [0] * 2019\nvar_7 = 10\nvar_1[0] = int(var_6[0])\nvar_3[0] = var_1[0]\nvar_2[var_3[0]] += 1\nfor var_4 in range(1, var_5):\n var_1[var_4] = int(var_6[var_4]) * var_7 % 2019\n var_3[var_4] = (var_3[var_4 - 1] + var_1[var_4]) % 2019\n var_2[var_3[var_4]] += 1\n var_7 = var_7 * 10 % 2019\nprint(\n (\n int(sum([var_2[var_4] * (var_2[var_4] - 1) for var_4 in range(2019)]) / 2)\n + var_2[0]\n )\n)\n```", "output": "SLOWER 1.6668", "pair_id": "python_p02702_pair0003_reversed", "problem_id": "p02702", "language": "python", "direction": "reversed", "speedup_ratio": 3.175} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n if str(var_4) == \"\".join(reversed(str(var_4))):\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\ndef func_1():\n var_1, var_2 = list(map(int, input().split()))\n var_3 = 0\n for var_4 in range(var_1, var_2 + 1):\n\n if (var_4 % 10) == (var_4 // 10000 % 10) and (var_4 // 10 % 10) == (\n var_4 // 1000 % 10\n ):\n var_3 += 1\n print(var_3)\n\n\nif __name__ == \"__main__\":\n func_1()\n```", "output": "FASTER 2.7403", "pair_id": "python_p03416_pair0172_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 6.682} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_6 = str(var_4)\n var_5 = var_6[::-1]\n if var_6 == var_5:\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_4, var_3 = list(map(int, input().split()))\nvar_1 = 0\nfor var_2 in range(var_4, var_3 + 1):\n if str(var_2)[0] + str(var_2)[1] == str(var_2)[-1] + str(var_2)[-2]:\n var_1 += 1\nprint(var_1)\n```", "output": "SLOWER 1.0907", "pair_id": "python_p03416_pair0173_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 2.1298} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\nimport math\nfrom collections import defaultdict\nfrom bisect import bisect_left, bisect_right\n\nsys.setrecursionlimit(10**7)\n\n\ndef func_4():\n return sys.stdin.readline()[:-1]\n\n\nvar_4 = 10**9 + 7\n\n\ndef func_1():\n return int(eval(func_4()))\n\n\ndef func_2():\n return list(map(int, func_4().split()))\n\n\ndef func_3(var_6, var_3):\n if var_6 <= 0:\n return [[] for _ in range(var_3)]\n elif var_3 == 1:\n return [func_1() for _ in range(var_6)]\n else:\n var_5 = [func_2() for _ in range(var_6)]\n return list(map(list, list(zip(*var_5))))\n\n\nvar_1, var_2 = list(map(str, func_4().split()))\nvar_1 = int(var_1)\nvar_2 = 100 * int(var_2[0]) + 10 * int(var_2[2]) + int(var_2[3])\nprint((var_1 * var_2 // 100))\n```\n\n=== Code B (Modified) ===\n```python\nimport decimal\n\n\ndef func_1():\n var_1, var_2 = list(map(decimal.Decimal, input().split()))\n print((var_1 * var_2 // 1))\n\n\nif __name__ == \"__main__\":\n func_1()\n```", "output": "FASTER 2.0678", "pair_id": "python_p02659_pair0041_forward", "problem_id": "p02659", "language": "python", "direction": "forward", "speedup_ratio": 4.1925} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\n\nsys.setrecursionlimit(2147483647)\nvar_2 = float(\"inf\")\nvar_3 = 10**9 + 7\nvar_10 = lambda: sys.stdin.readline().rstrip()\n\n\ndef func_1():\n var_11, var_4 = list(map(int, var_10().split()))\n var_1 = [tuple(map(int, var_10().split())) for _ in range(var_11)]\n var_1.sort()\n var_8 = [0] * var_4\n var_6 = -var_2\n for var_9 in range(var_11):\n var_5, var_7 = var_1[var_9]\n var_12 = var_8[:]\n for var_13 in range(var_4):\n if var_13 + var_5 < var_4:\n var_12[var_13 + var_5] = max(\n var_12[var_13 + var_5], var_8[var_13] + var_7\n )\n else:\n var_6 = max(var_6, var_8[var_13] + var_7)\n var_8 = var_12\n print((max(var_6, max(var_8))))\n\n\nfunc_1()\n```\n\n=== Code B (Modified) ===\n```python\nvar_6, var_7 = list(map(int, input().split()))\nvar_1 = [list(map(int, input().split())) for _ in range(var_6)]\nvar_1.sort()\nvar_3 = [(6007) * [0] for _ in range(var_6 + 1)]\nvar_3[0][0] = 0\nvar_2 = 0\nfor var_4 in range(var_6):\n for var_5 in range(6007):\n var_3[var_4 + 1][var_5] = max(var_3[var_4 + 1][var_5], var_3[var_4][var_5])\n if var_5 < var_7:\n var_3[var_4 + 1][var_5 + var_1[var_4][0]] = max(\n var_3[var_4][var_5] + var_1[var_4][1],\n var_3[var_4][var_5 + var_1[var_4][0]],\n )\n var_2 = max(var_2, var_3[var_4 + 1][var_5])\nprint(var_2)\n```", "output": "SLOWER 6.7598", "pair_id": "python_p02863_pair0039_reversed", "problem_id": "p02863", "language": "python", "direction": "reversed", "speedup_ratio": 108.3692} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\ndef func_1():\n from sys import setrecursionlimit, stdin\n from os import environ\n from collections import defaultdict, deque, Counter\n from math import ceil, floor, gcd\n from itertools import accumulate, combinations, combinations_with_replacement\n\n setrecursionlimit(10**6)\n var_7 = (\n (lambda *var_11: print(*var_11))\n if \"TERM_PROGRAM\" in environ\n else lambda *var_12: 0\n )\n var_8 = lambda: stdin.readline().rstrip()\n var_3 = lambda: list(map(int, var_8().split()))\n var_1 = lambda: int(var_8())\n var_4 = 10**9 + 7\n var_2 = 10**9 + 10\n var_9, var_10 = var_8().split()\n var_5 = int(var_9)\n var_6 = int(float(var_10) * 100 + 0.5)\n print(var_5 * var_6 // 100)\n\n\nfunc_1()\n```\n\n=== Code B (Modified) ===\n```python\ndef func_1():\n var_1, var_3 = input().split()\n var_1 = int(var_1)\n var_3 = int(float(var_3) * 100 + 0.5)\n var_2 = var_1 * var_3\n print((var_2 // 100))\n\n\nif __name__ == \"__main__\":\n func_1()\n```", "output": "FASTER 1.575", "pair_id": "python_p02659_pair0045_forward", "problem_id": "p02659", "language": "python", "direction": "forward", "speedup_ratio": 2.9793} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport copy\n\nvar_8 = int(eval(input()))\nvar_10 = set([var_6 for var_6 in range(1, 10**5)])\nvar_5 = []\nvar_11 = {}\nvar_9 = []\nfor var_6 in range(var_8 - 1):\n var_1, var_2 = list(map(int, input().split(\" \")))\n var_5.append([var_1, var_2])\n var_11.setdefault(var_1, []).append(var_2)\n var_9.append([])\nvar_9.append([])\nvar_9.append([])\nvar_7 = 0\nfor var_12 in range(1, var_8 + 1):\n var_14 = var_11.get(var_12, [])\n var_3 = 1\n for var_13 in var_14:\n if var_3 in var_9[var_12]:\n var_3 += 1\n else:\n pass\n var_9[var_13].append(var_3)\n if var_3 >= var_7:\n var_7 = var_3\n var_3 += 1\nprint(var_7)\nfor var_4 in var_5:\n print((var_9[var_4[1]][0]))\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\n\n\ndef func_1():\n var_9 = int(sys.stdin.readline().rstrip())\n var_8 = list(map(int, sys.stdin.read().split()))\n var_2 = list(zip(var_8, var_8))\n var_7 = [[] for _ in range(var_9 + 1)]\n for var_1, var_3 in var_2:\n var_7[var_1].append(var_3)\n var_7[var_3].append(var_1)\n var_13 = 1\n var_11 = [None] * (var_9 + 1)\n\n var_5 = []\n var_14 = [var_13]\n\n while var_14:\n var_15 = var_14.pop()\n\n for var_16 in var_7[var_15]:\n if var_16 == var_11[var_15]:\n continue\n\n var_11[var_16] = var_15\n var_14.append(var_16)\n var_5.append(var_15)\n var_6 = [-1] * (var_9 + 1)\n for var_15 in var_5:\n var_10 = var_6[var_15]\n var_4 = 1\n for var_16 in var_7[var_15]:\n if var_16 == var_11[var_15]:\n continue\n if var_4 == var_10:\n var_4 += 1\n var_6[var_16] = var_4\n var_4 += 1\n var_12 = []\n for var_1, var_3 in var_2:\n if var_1 == var_11[var_3]:\n var_12.append(var_6[var_3])\n else:\n var_12.append(var_6[var_1])\n print((max(var_12)))\n print((\"\\n\".join(map(str, var_12))))\n\n\nif __name__ == \"__main__\":\n func_1()\n```", "output": "FASTER 4.1418", "pair_id": "python_p02850_pair0003_forward", "problem_id": "p02850", "language": "python", "direction": "forward", "speedup_ratio": 17.653} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\ndef func_1():\n return list(map(int, input().split()))\n\n\nvar_1, var_2, var_3 = func_1()\nvar_4 = list(func_1())\nvar_6 = list(func_1())\nvar_5 = min(var_4) + min(var_6)\nfor _ in range(var_3):\n var_8, var_9, var_7 = func_1()\n var_5 = min(var_5, var_4[var_8 - 1] + var_6[var_9 - 1] - var_7)\nprint(var_5)\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\nfrom collections import Counter\n\n\ndef func_10():\n return sys.stdin.readline().strip()\n\n\ndef func_11(var_12, var_13, var_14):\n return [[var_14] * var_13 for var_17 in range(var_12)]\n\n\ndef func_12(var_12, var_13, var_14, var_15):\n return [[[var_15] * var_14 for var_18 in range(var_13)] for var_17 in range(var_12)]\n\n\ndef func_13(var_12, var_13, var_14, var_15, var_16):\n return [\n [[[var_16] * var_15 for var_18 in range(var_14)] for var_18 in range(var_13)]\n for var_17 in range(var_12)\n ]\n\n\ndef func_8(var_22, var_23=1):\n return int(-(-var_22 // var_23))\n\n\ndef func_1():\n return int(eval(func_10()))\n\n\ndef func_3():\n return list(map(int, func_10().split()))\n\n\ndef func_2(var_11=None):\n return list(func_3()) if var_11 is None else [func_1() for var_17 in range(var_11)]\n\n\ndef func_7():\n print(\"Yes\")\n\n\ndef func_5():\n print(\"No\")\n\n\ndef func_6():\n print(\"YES\")\n\n\ndef func_4():\n print(\"NO\")\n\n\nsys.setrecursionlimit(10**9)\nvar_5 = 10**18\nvar_10 = 10**9 + 7\n\n\ndef func_9(var_1, var_2):\n \"\"\"\"\"\"\n import numpy as np\n from numpy.fft import rfft, irfft\n\n var_8 = max(var_1)\n var_9 = max(var_2)\n var_3 = [0] * (var_8 + 1)\n var_4 = [0] * (var_9 + 1)\n for var_12 in var_1:\n var_3[var_12] += 1\n for var_13 in var_2:\n var_4[var_13] += 1\n\n var_6 = 1\n var_19 = 0\n while var_6 <= var_8 + var_9:\n var_19 += 1\n var_6 = 2**var_19\n\n var_21 = irfft(rfft(var_3, var_6) * rfft(var_4, var_6), var_6)\n\n var_21 = np.rint(var_21).astype(np.int64)\n return var_21\n\n\nvar_11, var_7, var_6 = func_3()\nvar_1 = func_2()\nvar_2 = func_2()\nvar_21 = list(func_9(var_1, var_2))\nvar_20 = var_5\nfor var_17, var_12 in enumerate(var_21):\n if var_12 != 0:\n var_20 = var_17\n break\nfor _ in range(var_6):\n var_22, var_23, var_14 = func_3()\n var_22 -= 1\n var_23 -= 1\n var_20 = min(var_20, var_1[var_22] + var_2[var_23] - var_14)\nprint(var_20)\n```", "output": "SLOWER 3.3693", "pair_id": "python_p02748_pair0011_reversed", "problem_id": "p02748", "language": "python", "direction": "reversed", "speedup_ratio": 10.3341} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_5 in range(10):\n for var_6 in range(10):\n for var_7 in range(10):\n var_3 = 10000 * var_5 + 1000 * var_6 + 100 * var_7 + 10 * var_6 + var_5\n if var_1 <= var_3 <= var_2:\n var_4 += 1\nprint(var_4)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_5 in range(var_1, var_2 + 1):\n var_3 = str(var_5)\n if var_3[0] == var_3[-1] and var_3[1] == var_3[-2]:\n var_4 += 1\nprint(var_4)\n```", "output": "SLOWER 3.734", "pair_id": "python_p03416_pair0099_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 13.3058} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_4 = str(var_4)\n if var_4[0] == var_4[-1] and var_4[1] == var_4[-2]:\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_3 in range(var_1, var_2 + 1):\n var_5 = list(str(var_3))\n var_6 = list(reversed(var_5))\n if var_5 == var_6:\n var_4 += 1\nprint(var_4)\n```", "output": "SLOWER 1.4924", "pair_id": "python_p03416_pair0174_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 2.8135} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\nimport math\nfrom collections import defaultdict\nfrom bisect import bisect_left, bisect_right\n\nsys.setrecursionlimit(10**7)\n\n\ndef func_4():\n return sys.stdin.readline()[:-1]\n\n\nvar_4 = 10**9 + 7\n\n\ndef func_1():\n return int(eval(func_4()))\n\n\ndef func_2():\n return list(map(int, func_4().split()))\n\n\ndef func_3(var_6, var_3):\n if var_6 <= 0:\n return [[] for _ in range(var_3)]\n elif var_3 == 1:\n return [func_1() for _ in range(var_6)]\n else:\n var_5 = [func_2() for _ in range(var_6)]\n return list(map(list, list(zip(*var_5))))\n\n\nfrom decimal import getcontext, Decimal\n\ngetcontext().prec = 28\nvar_1, var_2 = list(map(str, func_4().split()))\nvar_1 = int(var_1)\nvar_2 = Decimal(var_2)\nprint((int(var_1 * var_2)))\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\n\nvar_3 = sys.stdin.readline\nvar_1, var_2 = var_3().split()\nvar_1 = int(var_1)\nvar_2 = int(float(var_2) * 100 + 0.5)\nprint((var_1 * var_2 // 100))\n```", "output": "FASTER 2.2902", "pair_id": "python_p02659_pair0046_forward", "problem_id": "p02659", "language": "python", "direction": "forward", "speedup_ratio": 4.8913} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\n\n\ndef func_1():\n return sys.stdin.readline()[:-1]\n\n\nvar_3 = int(eval(func_1()))\nwhile 1:\n var_1 = 0\n for var_2 in range(2, int(var_3 ** (1 / 2))):\n if var_3 % var_2 == 0:\n var_1 = 1\n break\n if var_1 == 0:\n break\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nimport numpy as np\nfrom bisect import bisect_left\n\n\ndef func_1():\n var_4 = []\n var_1 = np.ones(10**5 + 10)\n var_1[0] = var_1[1] = 0\n for var_3, var_2 in enumerate(var_1):\n if var_2:\n var_4.append(var_3)\n var_1[2 * var_3 : 10**5 + 10 : var_3] = 0\n return var_4\n\n\ndef func_2(var_6):\n var_7 = int(var_6)\n var_5 = func_1()\n return str(var_5[bisect_left(var_5, var_7)])\n\n\nif __name__ == \"__main__\":\n import sys\n\n print((func_2(sys.stdin.read().strip())))\n```", "output": "SLOWER 7.7323", "pair_id": "python_p02819_pair0008_reversed", "problem_id": "p02819", "language": "python", "direction": "reversed", "speedup_ratio": 212.6457} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\n\n\ndef func_1(var_5, var_6):\n var_4 = 0\n for var_3 in range(var_5, var_6 + 1):\n if str(var_3) == str(var_3)[::-1]:\n var_4 += 1\n return var_4\n\n\nprint((func_1(var_1, var_2)))\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_5 in range(10):\n for var_6 in range(10):\n for var_7 in range(10):\n var_3 = 10000 * var_5 + 1000 * var_6 + 100 * var_7 + 10 * var_6 + var_5\n if var_1 <= var_3 <= var_2:\n var_4 += 1\nprint(var_4)\n```", "output": "FASTER 3.5019", "pair_id": "python_p03416_pair0175_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 11.3289} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\nimport math\nfrom collections import defaultdict\nfrom bisect import bisect_left, bisect_right\n\nsys.setrecursionlimit(10**7)\n\n\ndef func_4():\n return sys.stdin.readline()[:-1]\n\n\nvar_4 = 10**9 + 7\n\n\ndef func_1():\n return int(eval(func_4()))\n\n\ndef func_2():\n return list(map(int, func_4().split()))\n\n\ndef func_3(var_6, var_3):\n if var_6 <= 0:\n return [[] for _ in range(var_3)]\n elif var_3 == 1:\n return [func_1() for _ in range(var_6)]\n else:\n var_5 = [func_2() for _ in range(var_6)]\n return list(map(list, list(zip(*var_5))))\n\n\nvar_1, var_2 = list(map(str, func_4().split()))\nvar_1 = int(var_1)\nvar_2 = 100 * int(var_2[0]) + 10 * int(var_2[2]) + int(var_2[3])\nprint((var_1 * var_2 // 100))\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\n\nvar_5 = sys.stdin.readline\nif __name__ == \"__main__\":\n var_1, var_3 = var_5().split()\n var_2 = int(var_1)\n var_4 = round(float(var_3) * 100)\n print((var_2 * var_4 // 100))\n```", "output": "FASTER 2.0389", "pair_id": "python_p02659_pair0047_forward", "problem_id": "p02659", "language": "python", "direction": "forward", "speedup_ratio": 4.1093} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\ndef func_1():\n var_2 = int(eval(input()))\n var_1 = [int(var_6) for var_6 in input().split()]\n var_4 = 3**var_2\n var_5 = len([var_3 for var_3 in var_1 if var_3 % 2 == 0])\n var_4 -= 2**var_5\n print(var_4)\n\n\nif __name__ == \"__main__\":\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\ndef func_1():\n var_2 = int(input())\n var_1 = [int(var_6) for var_6 in input().split()]\n if var_2 == 1:\n return print(1 if var_1[0] % 2 == 0 else 2)\n var_3 = 0\n var_5 = (-1, 0, 1)\n from itertools import product\n\n for var_6 in product(range(3), repeat=var_2):\n var_4 = 1\n for var_7 in range(var_2):\n var_4 *= var_1[var_7] + var_5[var_6[var_7]]\n if var_4 % 2 == 0:\n var_3 += 1\n print(var_3)\n\n\nif __name__ == \"__main__\":\n func_1()\n```", "output": "SLOWER 8.0497", "pair_id": "python_p03568_pair0034_reversed", "problem_id": "p03568", "language": "python", "direction": "reversed", "speedup_ratio": 264.9728} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n if list(str(var_4)) == list(reversed(str(var_4))):\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().strip().split(\" \")))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n if str(var_4) == str(var_4)[::-1]:\n var_3 += 1\nprint(var_3)\n```", "output": "FASTER 1.0931", "pair_id": "python_p03416_pair0003_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 2.1333} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nfrom collections import Counter, defaultdict, deque\nfrom heapq import heappop, heappush, heapify\nimport sys, bisect, math, itertools, fractions, pprint\n\nsys.setrecursionlimit(10**8)\nvar_6 = 10**9 + 7\nvar_1 = float(\"inf\")\n\n\ndef func_1():\n return int(sys.stdin.readline())\n\n\ndef func_2():\n return list(map(int, sys.stdin.readline().split()))\n\n\nvar_8, var_11 = func_2()\nvar_17 = [func_2() for _ in range(var_8)]\nvar_10 = var_17[::-1]\nvar_14 = [[0] * var_11 for _ in range(var_8)]\nvar_3 = [[0] * var_11 for _ in range(var_8)]\nfor var_4 in range(var_8 - 1):\n var_16, var_15 = var_17[var_4]\n for var_5 in range(var_11):\n if var_5 < var_16:\n var_14[var_4 + 1][var_5] = var_14[var_4][var_5]\n else:\n var_14[var_4 + 1][var_5] = max(\n var_14[var_4][var_5], var_14[var_4][var_5 - var_16] + var_15\n )\nvar_9 = var_14[var_8 - 1][var_11 - 1] + var_17[var_8 - 1][1]\nfor var_4 in range(var_8 - 1):\n var_16, var_15 = var_10[var_4]\n for var_5 in range(var_11):\n if var_5 < var_16:\n var_3[var_4 + 1][var_5] = var_3[var_4][var_5]\n else:\n var_3[var_4 + 1][var_5] = max(\n var_3[var_4][var_5], var_3[var_4][var_5 - var_16] + var_15\n )\n var_9 = max(var_9, var_3[var_8 - 1][var_11 - 1] + var_17[0][1])\n\nfor var_4 in range(1, var_8 - 1):\n var_13 = var_4\n var_2 = var_8 - var_4 - 1\n var_7 = 0\n for var_5 in range(var_11):\n var_12 = var_14[var_13][var_5] + var_3[var_2][var_11 - 1 - var_5]\n var_7 = max(var_7, var_12)\n var_9 = max(var_9, var_7 + var_17[var_4][1])\nprint(var_9)\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\n\nvar_9 = sys.stdin.readline\nfrom operator import itemgetter\n\nvar_3, var_4 = list(map(int, var_9().split()))\nvar_1 = [list(map(int, var_9().split())) for _ in range(var_3)]\nvar_1.sort(key=itemgetter(0))\nvar_8 = [[0 for _ in range(var_3 + 1)] for _ in range(var_4 + 1)]\n\nvar_2 = []\nfor var_10 in range(var_3):\n var_5, var_7 = var_1[var_10]\n for var_11 in range(var_4):\n if var_5 > var_11:\n var_8[var_11][var_10 + 1] = var_8[var_11][var_10]\n else:\n if var_7 + var_8[var_11 - var_5][var_10] >= var_8[var_11][var_10]:\n var_8[var_11][var_10 + 1] = var_8[var_11 - var_5][var_10] + var_7\n else:\n var_8[var_11][var_10 + 1] = var_8[var_11][var_10]\n var_2.append(var_8[var_4 - 1][var_10] + var_7)\nvar_6 = max(var_2)\nprint(var_6)\n```", "output": "FASTER 1.024", "pair_id": "python_p02863_pair0040_forward", "problem_id": "p02863", "language": "python", "direction": "forward", "speedup_ratio": 2.0336} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = str(var_4)\n if var_5 == var_5[::-1]:\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_4 = {}\nvar_5 = 0\nfor var_6 in range(10000, 100000):\n var_3 = list(str(var_6))\n if var_3 == list(reversed(var_3)):\n var_5 += 1\n var_4[var_6] = var_5\nvar_1, var_2 = list(map(int, input().split()))\nprint((var_4[var_2] - var_4[var_1 - 1] if var_1 > 10000 else var_4[var_2]))\n```", "output": "SLOWER 3.5781", "pair_id": "python_p03416_pair0131_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 11.9428} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().rstrip().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = list(map(int, list(str(var_4))))\n if var_5[0] == var_5[4] and var_5[1] == var_5[3]:\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = str(var_4)\n if var_5 == var_5[::-1]:\n var_3 += 1\nprint(var_3)\n```", "output": "FASTER 1.6875", "pair_id": "python_p03416_pair0176_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 3.221} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\n\nvar_8 = sys.stdin.readline\n\n\ndef func_1():\n var_2 = int(eval(var_8()))\n var_1 = [int(var_8().replace(\" \", \"\"), 2) for _ in range(var_2)]\n var_3 = [list(map(int, var_8().split())) for _ in range(var_2)]\n var_4 = -(10**7) * var_2\n for var_7 in range(1, 1 << 10):\n var_10 = 0\n for var_9, var_6 in enumerate(var_1):\n var_5 = bin(var_7 & var_6).count(\"1\")\n var_10 += var_3[var_9][var_5]\n var_4 = max(var_4, var_10)\n print(var_4)\n\n\nif __name__ == \"__main__\":\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nvar_8 = int(eval(input()))\nvar_4 = []\nfor var_5 in range(var_8):\n var_11 = 0\n var_9 = list(map(int, input().split()))\n for var_6 in range(10):\n var_11 += var_9[var_6] << var_6\n var_4.append(var_11)\nvar_10 = []\nfor var_5 in range(var_8):\n var_10.append(list(map(int, input().split())))\nvar_1 = -(10**12)\nfor var_5 in range(1, 1 << 10):\n var_11 = 0\n for var_6 in range(var_8):\n var_3 = list(bin(var_4[var_6] & var_5)[2:])\n var_2 = 0\n for var_7 in var_3:\n if var_7 == \"1\":\n var_2 += 1\n var_11 += var_10[var_6][var_2]\n var_1 = max(var_1, var_11)\nprint(var_1)\n```", "output": "SLOWER 2.2065", "pair_id": "python_p03503_pair0017_reversed", "problem_id": "p03503", "language": "python", "direction": "reversed", "speedup_ratio": 4.6157} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nfrom sys import stdin\n\nvar_6 = lambda: list(map(int, stdin.readline().split()))\nvar_5 = lambda: list(map(int, stdin.readline().split()))\nvar_1, var_3 = var_6()\nvar_2 = 0\nfor var_4 in range(var_1, var_3 + 1):\n var_7 = str(var_4)\n if var_7 == var_7[::-1]:\n var_2 += 1\nprint(var_2)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = [0] * (var_2 + 1)\nfor var_3 in range(1, var_2 + 1):\n if str(var_3) == str(var_3)[::-1]:\n var_4[var_3] = var_4[var_3 - 1] + 1\n else:\n var_4[var_3] = var_4[var_3 - 1]\nprint((var_4[var_2] - var_4[var_1 - 1]))\n```", "output": "SLOWER 1.9239", "pair_id": "python_p03416_pair0177_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 3.7944} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\ndef func_1():\n var_2, var_3, *var_1 = list(map(int, open(0).read().split()))\n var_4 = [0] * (var_3 + max(var_1[::2]))\n for var_7, var_6 in sorted(zip(*[iter(var_1)] * 2)):\n for var_5 in reversed(list(range(var_3))):\n var_4[var_5 + var_7] = max(var_4[var_5 + var_7], var_4[var_5] + var_6)\n print((max(var_4)))\n\n\nfunc_1()\n```\n\n=== Code B (Modified) ===\n```python\nfrom collections import Counter, defaultdict, deque\nfrom heapq import heappop, heappush, heapify\nimport sys, bisect, math, itertools, fractions, pprint\n\nsys.setrecursionlimit(10**8)\nvar_6 = 10**9 + 7\nvar_1 = float(\"inf\")\n\n\ndef func_1():\n return int(sys.stdin.readline())\n\n\ndef func_2():\n return list(map(int, sys.stdin.readline().split()))\n\n\nvar_8, var_11 = func_2()\nvar_17 = [func_2() for _ in range(var_8)]\nvar_10 = var_17[::-1]\nvar_14 = [[0] * var_11 for _ in range(var_8)]\nvar_3 = [[0] * var_11 for _ in range(var_8)]\nfor var_4 in range(var_8 - 1):\n var_16, var_15 = var_17[var_4]\n for var_5 in range(var_11):\n if var_5 < var_16:\n var_14[var_4 + 1][var_5] = var_14[var_4][var_5]\n else:\n var_14[var_4 + 1][var_5] = max(\n var_14[var_4][var_5], var_14[var_4][var_5 - var_16] + var_15\n )\nvar_9 = var_14[var_8 - 1][var_11 - 1] + var_17[var_8 - 1][1]\nfor var_4 in range(var_8 - 1):\n var_16, var_15 = var_10[var_4]\n for var_5 in range(var_11):\n if var_5 < var_16:\n var_3[var_4 + 1][var_5] = var_3[var_4][var_5]\n else:\n var_3[var_4 + 1][var_5] = max(\n var_3[var_4][var_5], var_3[var_4][var_5 - var_16] + var_15\n )\n var_9 = max(var_9, var_3[var_8 - 1][var_11 - 1] + var_17[0][1])\n\nfor var_4 in range(1, var_8 - 1):\n var_13 = var_4\n var_2 = var_8 - var_4 - 1\n var_7 = 0\n for var_5 in range(var_11):\n var_12 = var_14[var_13][var_5] + var_3[var_2][var_11 - 1 - var_5]\n var_7 = max(var_7, var_12)\n var_9 = max(var_9, var_7 + var_17[var_4][1])\nprint(var_9)\n```", "output": "SLOWER 2.2995", "pair_id": "python_p02863_pair0011_reversed", "problem_id": "p02863", "language": "python", "direction": "reversed", "speedup_ratio": 4.9229} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\n\"\"\"\"\"\"\n\nfrom collections import defaultdict\n\n\ndef func_1(var_10, var_9):\n var_5 = 1\n yield var_5\n for _ in range(1, var_10):\n var_5 = (var_5 * 10) % var_9\n yield var_5\n\n\ndef func_2():\n var_3 = 2019\n var_4 = input()[::-1]\n\n var_1 = [\n int(var_11) * var_10 % var_3\n for var_11, var_10 in zip(var_4, func_1(len(var_4), var_3))\n ]\n\n var_2 = [0]\n for var_5 in var_1:\n var_2.append((var_2[-1] + var_5) % var_3)\n\n var_8 = defaultdict(int)\n for var_6 in var_2:\n var_8[var_6] += 1\n var_7 = sum(var_12 * (var_12 - 1) // 2 for var_12 in list(var_8.values()))\n print(var_7)\n\n\nfunc_2()\n```\n\n=== Code B (Modified) ===\n```python\nvar_5 = input()[::-1]\nvar_2 = [0] * 2019\nvar_2[0] = 1\nvar_4 = 0\nvar_6 = 1\nvar_1 = 0\nfor var_3 in var_5:\n var_4 = (var_4 + int(var_3) * var_6) % 2019\n var_6 = var_6 * 10 % 2019\n var_2[var_4] += 1\nfor var_3 in var_2:\n var_1 += var_3 * (var_3 - 1) // 2\nprint(var_1)\n```", "output": "SLOWER 1.3201", "pair_id": "python_p02702_pair0010_reversed", "problem_id": "p02702", "language": "python", "direction": "reversed", "speedup_ratio": 2.4969} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_6 = str(var_4)\n var_5 = var_6[::-1]\n if var_6 == var_5:\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\n\n\ndef func_1(var_5):\n var_4 = 0\n for var_3 in range(1, var_5 + 1):\n if str(var_3) == str(var_3)[::-1]:\n var_4 += 1\n return var_4\n\n\nprint((func_1(var_2) - func_1(var_1 - 1)))\n```", "output": "SLOWER 1.3402", "pair_id": "python_p03416_pair0142_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 2.5319} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = str(var_4)\n if var_5[0] == var_5[4] and var_5[1] == var_5[3]:\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_5 in range(10):\n for var_6 in range(10):\n for var_7 in range(10):\n var_3 = 10000 * var_5 + 1000 * var_6 + 100 * var_7 + 10 * var_6 + var_5\n if var_1 <= var_3 <= var_2:\n var_4 += 1\nprint(var_4)\n```", "output": "FASTER 3.5594", "pair_id": "python_p03416_pair0178_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 11.7893} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_6, var_7 = list(map(int, input().split()))\nvar_1 = [list(map(int, input().split())) for _ in range(var_6)]\nvar_1.sort()\nvar_3 = [(6007) * [0] for _ in range(var_6 + 1)]\nvar_3[0][0] = 0\nvar_2 = 0\nfor var_4 in range(var_6):\n for var_5 in range(6007):\n var_3[var_4 + 1][var_5] = max(var_3[var_4 + 1][var_5], var_3[var_4][var_5])\n if var_5 < var_7:\n var_3[var_4 + 1][var_5 + var_1[var_4][0]] = max(\n var_3[var_4][var_5] + var_1[var_4][1],\n var_3[var_4][var_5 + var_1[var_4][0]],\n )\n var_2 = max(var_2, var_3[var_4 + 1][var_5])\nprint(var_2)\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\n\nvar_9 = sys.stdin.readline\nfrom operator import itemgetter\n\nvar_3, var_4 = list(map(int, var_9().split()))\nvar_1 = [list(map(int, var_9().split())) for _ in range(var_3)]\nvar_1.sort(key=itemgetter(0))\nvar_8 = [[0 for _ in range(var_3 + 1)] for _ in range(var_4 + 1)]\n\nvar_2 = []\nfor var_10 in range(var_3):\n var_5, var_7 = var_1[var_10]\n for var_11 in range(var_4):\n if var_5 > var_11:\n var_8[var_11][var_10 + 1] = var_8[var_11][var_10]\n else:\n if var_7 + var_8[var_11 - var_5][var_10] >= var_8[var_11][var_10]:\n var_8[var_11][var_10 + 1] = var_8[var_11 - var_5][var_10] + var_7\n else:\n var_8[var_11][var_10 + 1] = var_8[var_11][var_10]\n var_2.append(var_8[var_4 - 1][var_10] + var_7)\nvar_6 = max(var_2)\nprint(var_6)\n```", "output": "FASTER 5.7437", "pair_id": "python_p02863_pair0026_forward", "problem_id": "p02863", "language": "python", "direction": "forward", "speedup_ratio": 53.5847} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = input().split()\nprint((int(var_1) * int(var_2[:-3] + var_2[-2:]) // 100))\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\nimport math\nfrom collections import defaultdict\nfrom bisect import bisect_left, bisect_right\n\nsys.setrecursionlimit(10**7)\n\n\ndef func_4():\n return sys.stdin.readline()[:-1]\n\n\nvar_4 = 10**9 + 7\n\n\ndef func_1():\n return int(eval(func_4()))\n\n\ndef func_2():\n return list(map(int, func_4().split()))\n\n\ndef func_3(var_6, var_3):\n if var_6 <= 0:\n return [[] for _ in range(var_3)]\n elif var_3 == 1:\n return [func_1() for _ in range(var_6)]\n else:\n var_5 = [func_2() for _ in range(var_6)]\n return list(map(list, list(zip(*var_5))))\n\n\nfrom decimal import getcontext, Decimal\n\ngetcontext().prec = 28\nvar_1, var_2 = list(map(str, func_4().split()))\nvar_1 = int(var_1)\nvar_2 = Decimal(var_2)\nprint((int(var_1 * var_2)))\n```", "output": "SLOWER 2.7073", "pair_id": "python_p02659_pair0048_reversed", "problem_id": "p02659", "language": "python", "direction": "reversed", "speedup_ratio": 6.5312} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport bisect\nimport sys\n\nsys.setrecursionlimit(10**6)\nvar_17 = sys.stdout.write\nvar_7 = lambda *var_15: print(*var_15) if var_1 else 0\nvar_1 = True\n\n\ndef func_1(var_10=sys.stdin.readline):\n var_12 = lambda: var_10().rstrip()\n var_3 = lambda: list(map(int, var_12().split()))\n var_2 = lambda: int(var_12())\n var_4 = lambda var_18: [var_3() for _ in range(var_18)]\n var_14, var_16 = var_3()\n var_5 = var_4(var_14)\n var_8 = [[0] * var_16 for _ in range(var_14)]\n for var_11 in range(1, var_14):\n for var_13 in range(1, var_16):\n if var_13 < var_5[var_11 - 1][0]:\n var_8[var_11][var_13] = var_8[var_11 - 1][var_13]\n else:\n var_8[var_11][var_13] = max(\n var_8[var_11 - 1][var_13],\n var_8[var_11 - 1][var_13 - var_5[var_11 - 1][0]]\n + var_5[var_11 - 1][1],\n )\n var_9 = [[0] * var_16 for _ in range(var_14)]\n for var_11 in range(1, var_14):\n for var_13 in range(1, var_16):\n if var_13 < var_5[var_14 - var_11][0]:\n var_9[var_11][var_13] = var_9[var_11 - 1][var_13]\n else:\n var_9[var_11][var_13] = max(\n var_9[var_11 - 1][var_13],\n var_9[var_11 - 1][var_13 - var_5[var_14 - var_11][0]]\n + var_5[var_14 - var_11][1],\n )\n var_6 = 0\n for var_11 in range(var_14):\n for var_13 in range(var_16 - 1):\n var_6 = max(\n var_6,\n var_8[var_11][var_13]\n + var_9[var_14 - var_11 - 1][var_16 - var_13 - 1]\n + var_5[var_11][1],\n )\n print(var_6)\n\n\nif __name__ == \"__main__\":\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\n\nsys.setrecursionlimit(2147483647)\nvar_2 = float(\"inf\")\nvar_3 = 10**9 + 7\nvar_10 = lambda: sys.stdin.readline().rstrip()\n\n\ndef func_1():\n var_11, var_4 = list(map(int, var_10().split()))\n var_1 = [tuple(map(int, var_10().split())) for _ in range(var_11)]\n var_1.sort()\n var_8 = [0] * var_4\n var_6 = -var_2\n for var_9 in range(var_11):\n var_5, var_7 = var_1[var_9]\n var_12 = var_8[:]\n for var_13 in range(var_4):\n if var_13 + var_5 < var_4:\n var_12[var_13 + var_5] = max(\n var_12[var_13 + var_5], var_8[var_13] + var_7\n )\n else:\n var_6 = max(var_6, var_8[var_13] + var_7)\n var_8 = var_12\n print((max(var_6, max(var_8))))\n\n\nfunc_1()\n```", "output": "FASTER 1.4425", "pair_id": "python_p02863_pair0041_forward", "problem_id": "p02863", "language": "python", "direction": "forward", "speedup_ratio": 2.718} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\nfrom collections import Counter\n\n\ndef func_10():\n return sys.stdin.readline().strip()\n\n\ndef func_11(var_12, var_13, var_14):\n return [[var_14] * var_13 for var_17 in range(var_12)]\n\n\ndef func_12(var_12, var_13, var_14, var_15):\n return [[[var_15] * var_14 for var_18 in range(var_13)] for var_17 in range(var_12)]\n\n\ndef func_13(var_12, var_13, var_14, var_15, var_16):\n return [\n [[[var_16] * var_15 for var_18 in range(var_14)] for var_18 in range(var_13)]\n for var_17 in range(var_12)\n ]\n\n\ndef func_8(var_22, var_23=1):\n return int(-(-var_22 // var_23))\n\n\ndef func_1():\n return int(eval(func_10()))\n\n\ndef func_3():\n return list(map(int, func_10().split()))\n\n\ndef func_2(var_11=None):\n return list(func_3()) if var_11 is None else [func_1() for var_17 in range(var_11)]\n\n\ndef func_7():\n print(\"Yes\")\n\n\ndef func_5():\n print(\"No\")\n\n\ndef func_6():\n print(\"YES\")\n\n\ndef func_4():\n print(\"NO\")\n\n\nsys.setrecursionlimit(10**9)\nvar_5 = 10**18\nvar_10 = 10**9 + 7\n\n\ndef func_9(var_1, var_2):\n \"\"\"\"\"\"\n import numpy as np\n from numpy.fft import rfft, irfft\n\n var_8 = max(var_1)\n var_9 = max(var_2)\n var_3 = [0] * (var_8 + 1)\n var_4 = [0] * (var_9 + 1)\n for var_12 in var_1:\n var_3[var_12] += 1\n for var_13 in var_2:\n var_4[var_13] += 1\n\n var_6 = 1\n var_19 = 0\n while var_6 <= var_8 + var_9:\n var_19 += 1\n var_6 = 2**var_19\n\n var_21 = irfft(rfft(var_3, var_6) * rfft(var_4, var_6), var_6)\n\n var_21 = np.rint(var_21).astype(np.int64)\n return var_21\n\n\nvar_11, var_7, var_6 = func_3()\nvar_1 = func_2()\nvar_2 = func_2()\nvar_21 = list(func_9(var_1, var_2))\nvar_20 = var_5\nfor var_17, var_12 in enumerate(var_21):\n if var_12 != 0:\n var_20 = var_17\n break\nfor _ in range(var_6):\n var_22, var_23, var_14 = func_3()\n var_22 -= 1\n var_23 -= 1\n var_20 = min(var_20, var_1[var_22] + var_2[var_23] - var_14)\nprint(var_20)\n```\n\n=== Code B (Modified) ===\n```python\ndef func_1():\n return list(map(int, input().split()))\n\n\nvar_1, var_2, var_3 = func_1()\nvar_4 = list(func_1())\nvar_6 = list(func_1())\nvar_5 = min(var_4) + min(var_6)\nfor _ in range(var_3):\n var_8, var_9, var_7 = func_1()\n var_5 = min(var_5, var_4[var_8 - 1] + var_6[var_9 - 1] - var_7)\nprint(var_5)\n```", "output": "FASTER 3.3693", "pair_id": "python_p02748_pair0011_forward", "problem_id": "p02748", "language": "python", "direction": "forward", "speedup_ratio": 10.3341} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_4 = int(eval(input()))\nvar_1 = list(map(int, input().split()))\nvar_3 = 1\nfor var_2 in var_1:\n var_3 *= 2 if var_2 % 2 == 0 else 1\nprint((3**var_4 - var_3))\n```\n\n=== Code B (Modified) ===\n```python\nimport math\nimport string\n\n\ndef func_5():\n return list(map(int, input().split()))\n\n\ndef func_4(var_7, var_8):\n return math.factorial(var_7) // (\n math.factorial(var_7 - var_8) * math.factorial(var_8)\n )\n\n\ndef func_3(var_10):\n var_9 = []\n for var_5 in var_10:\n if not (var_5 in var_9):\n var_9.append(var_5)\n return len(var_10) != len(var_9)\n\n\ndef func_1(var_7):\n func_1 = []\n for var_4 in range(1, var_7 + 1):\n if var_7 % var_4 == 0:\n func_1.append(var_4)\n return func_1\n\n\nvar_2 = [-1, -1, -1, 0, 0, 1, 1, 1]\nvar_3 = [-1, 0, 1, -1, 1, -1, 0, 1]\nvar_7 = int(eval(input()))\nvar_1 = func_5()\n\n\ndef func_2(var_6):\n if len(var_6) == var_7:\n for var_4 in range(len(var_6)):\n if var_6[var_4] % 2 == 0:\n return 1\n return 0\n return (\n func_2(var_6 + [var_1[len(var_6)]])\n + func_2(var_6 + [var_1[len(var_6)] - 1])\n + func_2(var_6 + [var_1[len(var_6)] + 1])\n )\n\n\nprint((func_2([])))\n```", "output": "SLOWER 7.7659", "pair_id": "python_p03568_pair0035_reversed", "problem_id": "p03568", "language": "python", "direction": "reversed", "speedup_ratio": 217.6585} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\n\"\"\"\"\"\"\n\nfrom collections import defaultdict\n\n\ndef func_1(var_10, var_9):\n var_5 = 1\n yield var_5\n for _ in range(1, var_10):\n var_5 = (var_5 * 10) % var_9\n yield var_5\n\n\ndef func_2():\n var_3 = 2019\n var_4 = input()[::-1]\n\n var_1 = [\n int(var_11) * var_10 % var_3\n for var_11, var_10 in zip(var_4, func_1(len(var_4), var_3))\n ]\n\n var_2 = [0]\n for var_5 in var_1:\n var_2.append((var_2[-1] + var_5) % var_3)\n\n var_8 = defaultdict(int)\n for var_6 in var_2:\n var_8[var_6] += 1\n var_7 = sum(var_12 * (var_12 - 1) // 2 for var_12 in list(var_8.values()))\n print(var_7)\n\n\nfunc_2()\n```\n\n=== Code B (Modified) ===\n```python\nvar_6 = input()[::-1]\nvar_4 = len(var_6)\nvar_2 = [0] * 2019\nvar_2[0] = 1\nvar_7 = 1\nvar_5 = 0\nvar_1 = 0\nfor var_3 in range(var_4):\n var_5 = (var_5 + int(var_6[var_3]) * var_7) % 2019\n var_7 = var_7 * 10 % 2019\n var_2[var_5] += 1\nfor var_3 in var_2:\n var_1 += var_3 * (var_3 - 1) // 2\nprint(var_1)\n```", "output": "SLOWER 1.3499", "pair_id": "python_p02702_pair0011_reversed", "problem_id": "p02702", "language": "python", "direction": "reversed", "speedup_ratio": 2.5489} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = str(var_4)\n if var_5 == var_5[::-1]:\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().rstrip().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = list(map(int, list(str(var_4))))\n if var_5[0] == var_5[4] and var_5[1] == var_5[3]:\n var_3 += 1\nprint(var_3)\n```", "output": "SLOWER 1.6875", "pair_id": "python_p03416_pair0176_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 3.221} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = list(str(var_4))\n if var_5 == list(reversed(var_5)):\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_5 in range(10):\n for var_6 in range(10):\n for var_7 in range(10):\n var_3 = 10000 * var_5 + 1000 * var_6 + 100 * var_7 + 10 * var_6 + var_5\n if var_1 <= var_3 <= var_2:\n var_4 += 1\nprint(var_4)\n```", "output": "FASTER 5.0577", "pair_id": "python_p03416_pair0112_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 33.3066} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nfrom fractions import Fraction\n\nvar_1, var_2 = input().split()\n\n\nfrom decimal import *\n\nvar_4 = var_3(var_1)\nvar_6 = var_3(var_2)\nvar_7().prec = 28\nvar_5 = var_4 * var_6\nprint((int(var_5)))\n```\n\n=== Code B (Modified) ===\n```python\ndef func_1():\n from sys import setrecursionlimit, stdin\n from os import environ\n from collections import defaultdict, deque, Counter\n from math import ceil, floor, gcd\n from itertools import accumulate, combinations, combinations_with_replacement\n\n setrecursionlimit(10**6)\n var_7 = (\n (lambda *var_11: print(*var_11))\n if \"TERM_PROGRAM\" in environ\n else lambda *var_12: 0\n )\n var_8 = lambda: stdin.readline().rstrip()\n var_3 = lambda: list(map(int, var_8().split()))\n var_1 = lambda: int(var_8())\n var_4 = 10**9 + 7\n var_2 = 10**9 + 10\n var_9, var_10 = var_8().split()\n var_5 = int(var_9)\n var_10 = var_10.split(\".\")\n var_6 = int(var_10[0]) * 100\n if len(var_10) == 2:\n var_6 += int(var_10[1])\n print(var_5 * var_6 // 100)\n\n\nfunc_1()\n```", "output": "SLOWER 1.768", "pair_id": "python_p02659_pair0049_reversed", "problem_id": "p02659", "language": "python", "direction": "reversed", "speedup_ratio": 3.4057} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\ndef func_1():\n var_2 = int(eval(input()))\n var_1 = [int(var_6) for var_6 in input().split()]\n var_4 = 3**var_2\n var_5 = len([var_3 for var_3 in var_1 if var_3 % 2 == 0])\n var_4 -= 2**var_5\n print(var_4)\n\n\nif __name__ == \"__main__\":\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nvar_6 = int(eval(input()))\nvar_2 = list(map(int, input().split()))\nfrom itertools import product\n\nvar_5 = [-1, 0, 1]\nvar_3 = 0\nfor var_7 in product(var_5, repeat=var_6):\n var_1 = []\n for var_4 in range(var_6):\n var_1.append(var_7[var_4] + var_2[var_4])\n if any(var_8 % 2 == 0 for var_8 in var_1):\n var_3 += 1\nprint(var_3)\n```", "output": "SLOWER 9.3238", "pair_id": "python_p03568_pair0025_reversed", "problem_id": "p03568", "language": "python", "direction": "reversed", "speedup_ratio": 640.828} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\n\nvar_10 = sys.stdin.readline\nvar_2, var_3 = list(map(int, var_10().split()))\nvar_1 = [list(map(int, var_10().split())) for _ in range(var_2)]\nvar_8 = [[0 for _ in range(var_2 + 1)] for _ in range(var_3 + 1)]\n\nvar_13 = [[0 for _ in range(var_2 + 1)] for _ in range(var_3 + 1)]\nfor var_11 in range(var_2):\n var_4, var_6 = var_1[var_11]\n for var_15 in range(var_3):\n if var_4 > var_15:\n var_8[var_15][var_11 + 1] = var_8[var_15][var_11]\n var_13[var_15][var_11 + 1] = var_15\n else:\n if var_6 + var_8[var_15 - var_4][var_11] >= var_8[var_15][var_11]:\n var_8[var_15][var_11 + 1] = var_8[var_15 - var_4][var_11] + var_6\n var_13[var_15][var_11 + 1] = var_15 - var_4\n else:\n var_8[var_15][var_11 + 1] = var_8[var_15][var_11]\n var_13[var_15][var_11 + 1] = var_15\nvar_5 = var_8[var_3 - 1][var_2]\nvar_14 = [False] * var_2\nvar_7 = var_3 - 1\nfor var_9 in reversed(list(range(var_2))):\n if var_13[var_7][var_9 + 1] == var_7 - var_1[var_9][0]:\n var_14[var_9] = True\n var_7 = var_13[var_7][var_9 + 1]\nvar_12 = 0\nfor var_9 in range(var_2):\n if not var_14[var_9] and var_1[var_9][1] > var_12:\n var_12 = var_1[var_9][1]\nprint((var_5 + var_12))\n```\n\n=== Code B (Modified) ===\n```python\nfrom collections import Counter, defaultdict, deque\nfrom heapq import heappop, heappush, heapify\nimport sys, bisect, math, itertools, fractions, pprint\n\nsys.setrecursionlimit(10**8)\nvar_6 = 10**9 + 7\nvar_1 = float(\"inf\")\n\n\ndef func_1():\n return int(sys.stdin.readline())\n\n\ndef func_2():\n return list(map(int, sys.stdin.readline().split()))\n\n\nvar_7, var_9 = func_2()\nvar_13 = [func_2() for _ in range(var_7)]\nvar_13.sort(key=lambda var_14: var_14[1], reverse=True)\nvar_8 = 0\nvar_10 = min(var_7, 5)\nfor var_3 in range(var_10):\n var_2 = [[0] * (var_9 + 5) for _ in range(var_7 + 5)]\n for var_4 in range(var_7):\n var_12, var_11 = var_13[var_4]\n for var_5 in range(var_9):\n if var_5 < var_12 or var_3 == var_4:\n var_2[var_4 + 1][var_5] = var_2[var_4][var_5]\n else:\n var_2[var_4 + 1][var_5] = max(\n var_2[var_4][var_5], var_2[var_4][var_5 - var_12] + var_11\n )\n\n var_8 = max(var_2[var_7][var_9 - 1] + var_13[var_3][1], var_8)\nprint(var_8)\n```", "output": "SLOWER 1.1545", "pair_id": "python_p02863_pair0042_reversed", "problem_id": "p02863", "language": "python", "direction": "reversed", "speedup_ratio": 2.226} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport math\n\nvar_1, var_2 = input().split()\nvar_1 = int(var_1)\nvar_3 = int(var_2[0] + var_2[2] + var_2[3])\nprint((int(var_1 * var_3) // 100))\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\nimport math\nfrom collections import defaultdict\nfrom bisect import bisect_left, bisect_right\n\nsys.setrecursionlimit(10**7)\n\n\ndef func_4():\n return sys.stdin.readline()[:-1]\n\n\nvar_4 = 10**9 + 7\n\n\ndef func_1():\n return int(eval(func_4()))\n\n\ndef func_2():\n return list(map(int, func_4().split()))\n\n\ndef func_3(var_6, var_3):\n if var_6 <= 0:\n return [[] for _ in range(var_3)]\n elif var_3 == 1:\n return [func_1() for _ in range(var_6)]\n else:\n var_5 = [func_2() for _ in range(var_6)]\n return list(map(list, list(zip(*var_5))))\n\n\nfrom decimal import getcontext, Decimal\n\ngetcontext().prec = 28\nvar_1, var_2 = list(map(str, func_4().split()))\nvar_1 = int(var_1)\nvar_2 = Decimal(var_2)\nprint((int(var_1 * var_2)))\n```", "output": "SLOWER 2.2596", "pair_id": "python_p02659_pair0050_reversed", "problem_id": "p02659", "language": "python", "direction": "reversed", "speedup_ratio": 4.7885} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\n\"\"\"\"\"\"\n\nfrom collections import deque\n\n\ndef func_1():\n var_5, *var_1 = list(map(int, open(0).read().split()))\n var_2 = var_1[1::2]\n var_4 = [[] for _ in range(var_5 + 1)]\n for var_7, var_8 in zip(*[iter(var_1)] * 2):\n var_4[var_7].append(var_8)\n var_6 = deque([1])\n var_3 = [0] * (var_5 + 1)\n while var_6:\n var_11 = var_6.popleft()\n var_9 = 0\n for var_10 in var_4[var_11]:\n var_9 += 1 + (var_9 + 1 == var_3[var_11])\n var_3[var_10] = var_9\n var_6.append(var_10)\n print((max(var_3)))\n for var_8 in var_2:\n print((var_3[var_8]))\n\n\nfunc_1()\n```\n\n=== Code B (Modified) ===\n```python\nvar_11 = int(eval(input()))\nvar_12 = {var_8: [] for var_8 in range(1, var_11 + 1)}\nvar_19 = [False for var_8 in range(var_11 + 1)]\nvar_16 = []\nfor _ in range(var_11 - 1):\n var_2, var_3 = list(map(int, input().split()))\n var_12[var_2].append(var_3)\n var_12[var_3].append(var_2)\n var_16.append((var_2, var_3))\nvar_9 = var_16[0][0]\nvar_19[var_9] = True\nvar_6 = []\nvar_7 = []\nvar_14 = {var_8: {} for var_8 in range(1, var_11 + 1)}\nvar_10 = [0 for var_8 in range(var_11 + 1)]\n\nvar_4 = 1\nfor var_5 in var_12[var_9]:\n var_19[var_5] = True\n var_14[var_9][var_5] = var_4\n var_14[var_5][var_9] = var_4\n var_10[var_5] = var_4\n var_4 += 1\n var_6.append(var_5)\nwhile var_6:\n for var_15 in var_6:\n var_13 = 1\n for var_5 in var_12[var_15]:\n if var_19[var_5] == False:\n var_19[var_5] = True\n if var_13 != var_10[var_15]:\n var_14[var_15][var_5] = var_13\n var_14[var_5][var_15] = var_13\n var_10[var_5] = var_13\n var_13 += 1\n var_7.append(var_5)\n else:\n var_13 += 1\n var_14[var_15][var_5] = var_13\n var_14[var_5][var_15] = var_13\n var_10[var_5] = var_13\n var_13 += 1\n var_7.append(var_5)\n if var_7:\n var_6 = var_7\n var_7 = []\n else:\n var_6 = []\n var_7 = []\nvar_1 = 0\nfor var_8 in range(1, var_11 + 1):\n var_1 = max(var_1, len(var_12[var_8]))\nprint(var_1)\nfor var_8 in range(var_11 - 1):\n var_17, var_18 = var_16[var_8][0], var_16[var_8][1]\n print((var_14[var_17][var_18]))\n```", "output": "SLOWER 1.0109", "pair_id": "python_p02850_pair0024_reversed", "problem_id": "p02850", "language": "python", "direction": "reversed", "speedup_ratio": 2.0151} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_4 = str(var_4)\n if var_4[0] == var_4[-1] and var_4[1] == var_4[-2]:\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n if str(var_4) == \"\".join(reversed(str(var_4))):\n var_3 += 1\nprint(var_3)\n```", "output": "SLOWER 1.26", "pair_id": "python_p03416_pair0106_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 2.3949} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_3 = list(map(int, input().split()))\nvar_2 = 0\nfor var_5 in range(var_3 + 1)[var_1:]:\n if len(str(var_5)) % 2 == 0:\n var_6 = list(str(var_5))[: len(str(var_5)) // 2]\n var_7 = list(reversed(list(str(var_5))[len(str(var_5)) // 2 :]))\n if var_6 == var_7:\n var_2 += 1\n else:\n var_8 = list(str(var_5))[: len(str(var_5)) // 2 + 1]\n var_4 = list(reversed(list(str(var_5))[len(str(var_5)) // 2 :]))\n if var_8 == var_4:\n var_2 += 1\nprint(var_2)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_8 in range(var_1, var_2 + 1):\n var_7 = str(var_8)\n var_6 = len(var_7)\n var_4 = True\n for var_5 in range(var_6 // 2):\n if var_7[var_5] != var_7[var_6 - 1 - var_5]:\n var_4 = False\n break\n if var_4:\n var_3 += 1\nprint(var_3)\n```", "output": "FASTER 1.3483", "pair_id": "python_p03416_pair0179_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 2.5461} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_6 in range(var_1, var_2 + 1):\n var_3 = str(var_6)\n var_5 = True\n for var_7 in range(len(var_3) // 2):\n if var_3[var_7] != var_3[-var_7 - 1] and var_5:\n var_5 = not var_5\n if var_5:\n var_4 += 1\nprint(var_4)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_4 = str(var_4)\n if var_4[0] == var_4[-1] and var_4[1] == var_4[-2]:\n var_3 += 1\nprint(var_3)\n```", "output": "FASTER 1.6437", "pair_id": "python_p03416_pair0001_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 3.1246} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport math\n\nvar_1, var_4 = (int(var_10) for var_10 in input().split())\nvar_2 = math.ceil(var_1 / 0.08)\nvar_3 = math.ceil((var_1 + 1) / 0.08)\n\"\"\"\"\"\"\nvar_5 = math.ceil(var_4 / 0.1)\nvar_6 = math.ceil((var_4 + 1) / 0.1)\n\"\"\"\"\"\"\nvar_7 = list(range(var_2, var_3))\nvar_8 = list(range(var_5, var_6))\nvar_9 = set(var_7) & set(var_8)\nif len(var_9) == 0:\n print((-1))\nelse:\n print((min(var_9)))\n```\n\n=== Code B (Modified) ===\n```python\nfrom math import floor\n\nvar_1, var_2 = list(map(int, input().split()))\n\n\nfor var_3 in range(1010):\n if (floor(var_3 * 0.08) == var_1) and (floor(var_3 * 0.1) == var_2):\n\n print(var_3)\n quit()\n\n\nprint((-1))\n```", "output": "SLOWER 1.1204", "pair_id": "python_p02755_pair0001_reversed", "problem_id": "p02755", "language": "python", "direction": "reversed", "speedup_ratio": 2.1741} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\nfrom collections import Counter\n\n\ndef func_10():\n return sys.stdin.readline().strip()\n\n\ndef func_11(var_12, var_13, var_14):\n return [[var_14] * var_13 for var_17 in range(var_12)]\n\n\ndef func_12(var_12, var_13, var_14, var_15):\n return [[[var_15] * var_14 for var_18 in range(var_13)] for var_17 in range(var_12)]\n\n\ndef func_13(var_12, var_13, var_14, var_15, var_16):\n return [\n [[[var_16] * var_15 for var_18 in range(var_14)] for var_18 in range(var_13)]\n for var_17 in range(var_12)\n ]\n\n\ndef func_8(var_22, var_23=1):\n return int(-(-var_22 // var_23))\n\n\ndef func_1():\n return int(eval(func_10()))\n\n\ndef func_3():\n return list(map(int, func_10().split()))\n\n\ndef func_2(var_11=None):\n return list(func_3()) if var_11 is None else [func_1() for var_17 in range(var_11)]\n\n\ndef func_7():\n print(\"Yes\")\n\n\ndef func_5():\n print(\"No\")\n\n\ndef func_6():\n print(\"YES\")\n\n\ndef func_4():\n print(\"NO\")\n\n\nsys.setrecursionlimit(10**9)\nvar_5 = 10**18\nvar_10 = 10**9 + 7\n\n\ndef func_9(var_1, var_2):\n \"\"\"\"\"\"\n import numpy as np\n from numpy.fft import rfft, irfft\n\n var_8 = max(var_1)\n var_9 = max(var_2)\n var_3 = [0] * (var_8 + 1)\n var_4 = [0] * (var_9 + 1)\n for var_12 in var_1:\n var_3[var_12] += 1\n for var_13 in var_2:\n var_4[var_13] += 1\n\n var_6 = 1\n var_19 = 0\n while var_6 <= var_8 + var_9:\n var_19 += 1\n var_6 = 2**var_19\n\n var_21 = irfft(rfft(var_3, var_6) * rfft(var_4, var_6), var_6)\n\n var_21 = np.rint(var_21).astype(np.int64)\n return var_21\n\n\nvar_11, var_7, var_6 = func_3()\nvar_1 = func_2()\nvar_2 = func_2()\nvar_21 = list(func_9(var_1, var_2))\nvar_20 = var_5\nfor var_17, var_12 in enumerate(var_21):\n if var_12 != 0:\n var_20 = var_17\n break\nfor _ in range(var_6):\n var_22, var_23, var_14 = func_3()\n var_22 -= 1\n var_23 -= 1\n var_20 = min(var_20, var_1[var_22] + var_2[var_23] - var_14)\nprint(var_20)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_3, var_8 = list(map(int, input().split()))\nvar_2 = list(map(int, input().split()))\nvar_4 = list(map(int, input().split()))\nvar_7 = min(var_2) + min(var_4)\nvar_9 = [0] * var_8\nvar_10 = [0] * var_8\nvar_5 = [0] * var_8\nfor var_6 in range(var_8):\n var_9[var_6], var_10[var_6], var_5[var_6] = list(map(int, input().split()))\n var_9[var_6] -= 1\n var_10[var_6] -= 1\nfor var_6 in range(var_8):\n var_7 = min(var_7, var_2[var_9[var_6]] + var_4[var_10[var_6]] - var_5[var_6])\nprint(var_7)\n```", "output": "FASTER 2.762", "pair_id": "python_p02748_pair0005_forward", "problem_id": "p02748", "language": "python", "direction": "forward", "speedup_ratio": 6.7835} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_4, var_3 = list(map(int, input().split()))\nvar_1 = 0\nfor var_2 in range(var_4, var_3 + 1):\n if str(var_2)[0] + str(var_2)[1] == str(var_2)[-1] + str(var_2)[-2]:\n var_1 += 1\nprint(var_1)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_6 = str(var_4)\n var_5 = var_6[::-1]\n if var_6 == var_5:\n var_3 += 1\nprint(var_3)\n```", "output": "FASTER 1.0907", "pair_id": "python_p03416_pair0173_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 2.1298} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = str(var_4)\n if var_5[0] == var_5[4] and var_5[1] == var_5[3]:\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n if list(str(var_4)) == list(reversed(str(var_4))):\n var_3 += 1\nprint(var_3)\n```", "output": "SLOWER 1.6665", "pair_id": "python_p03416_pair0143_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 3.1745} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_4 = {}\nvar_5 = 0\nfor var_6 in range(10000, 100000):\n var_3 = list(str(var_6))\n if var_3 == list(reversed(var_3)):\n var_5 += 1\n var_4[var_6] = var_5\nvar_1, var_2 = list(map(int, input().split()))\nprint((var_4[var_2] - var_4[var_1 - 1] if var_1 > 10000 else var_4[var_2]))\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_5 in range(var_1, var_2 + 1):\n var_3 = str(var_5)\n if var_3[0] == var_3[-1] and var_3[1] == var_3[-2]:\n var_4 += 1\nprint(var_4)\n```", "output": "FASTER 3.6652", "pair_id": "python_p03416_pair0180_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 12.6861} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport math\nimport string\n\n\ndef func_4():\n return list(map(int, input().split()))\n\n\ndef func_3(var_6, var_7):\n return math.factorial(var_6) // (\n math.factorial(var_6 - var_7) * math.factorial(var_7)\n )\n\n\ndef func_2(var_9):\n var_8 = []\n for var_5 in var_9:\n if not (var_5 in var_8):\n var_8.append(var_5)\n return len(var_9) != len(var_8)\n\n\ndef func_1(var_6):\n func_1 = []\n for var_4 in range(1, var_6 + 1):\n if var_6 % var_4 == 0:\n func_1.append(var_4)\n return func_1\n\n\nvar_2 = [-1, -1, -1, 0, 0, 1, 1, 1]\nvar_3 = [-1, 0, 1, -1, 1, -1, 0, 1]\nvar_6 = int(eval(input()))\nvar_1 = func_4()\nvar_10 = 1\nfor var_4 in range(len(var_1)):\n if var_1[var_4] % 2 == 0:\n var_10 *= 2\n else:\n var_10 *= 1\nprint((3 ** len(var_1) - var_10))\n```\n\n=== Code B (Modified) ===\n```python\ndef func_1():\n var_2 = int(input())\n var_1 = [int(var_6) for var_6 in input().split()]\n if var_2 == 1:\n return print(1 if var_1[0] % 2 == 0 else 2)\n var_3 = 0\n var_5 = (-1, 0, 1)\n from itertools import product\n\n for var_6 in product(range(3), repeat=var_2):\n var_4 = 1\n for var_7 in range(var_2):\n var_4 *= var_1[var_7] + var_5[var_6[var_7]]\n if var_4 % 2 == 0:\n var_3 += 1\n print(var_3)\n\n\nif __name__ == \"__main__\":\n func_1()\n```", "output": "SLOWER 6.869", "pair_id": "python_p03568_pair0036_reversed", "problem_id": "p03568", "language": "python", "direction": "reversed", "speedup_ratio": 116.8901} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_5 = input()[::-1]\nvar_2 = [0] * 2019\nvar_2[0] = 1\nvar_4 = 0\nvar_6 = 1\nvar_1 = 0\nfor var_3 in var_5:\n var_4 = (var_4 + int(var_3) * var_6) % 2019\n var_6 = var_6 * 10 % 2019\n var_2[var_4] += 1\nfor var_3 in var_2:\n var_1 += var_3 * (var_3 - 1) // 2\nprint(var_1)\n```\n\n=== Code B (Modified) ===\n```python\nfrom collections import Counter\n\nvar_1 = input()[::-1]\nvar_5 = [0]\nvar_4 = 0\nvar_6 = 2019\nfor var_7 in var_1:\n var_8 = int(var_7) * pow(10, var_4, var_6) % var_6\n var_8 = var_5[-1] + var_8\n var_5.append(var_8 % var_6)\n var_4 += 1\nvar_3 = Counter(var_5)\nvar_2 = sum(var_9 * (var_9 - 1) // 2 for var_9 in list(var_3.values()))\nprint(var_2)\n```", "output": "FASTER 1.9367", "pair_id": "python_p02702_pair0002_forward", "problem_id": "p02702", "language": "python", "direction": "forward", "speedup_ratio": 3.8282} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_8, var_9 = list(map(int, input().split()))\nvar_5 = [[0] * (var_9 + 3001) for _ in range(var_8 + 1)]\nvar_3 = 0\nvar_2 = [list(map(int, input().split())) for _ in range(var_8)]\nvar_2.sort()\nfor var_6 in range(1, var_8 + 1):\n var_1, var_4 = var_2[var_6 - 1]\n for var_7 in range(var_9):\n var_5[var_6][var_7] = max(var_5[var_6 - 1][var_7], var_5[var_6][var_7])\n var_5[var_6][var_7 + var_1] = var_5[var_6 - 1][var_7] + var_4\n var_3 = max(var_5[var_6][var_7], var_5[var_6][var_7 + var_1], var_3)\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\ndef func_1():\n var_2, var_3, *var_1 = list(map(int, open(0).read().split()))\n var_4 = [0] * (var_3 + max(var_1[::2]))\n for var_7, var_6 in sorted(zip(*[iter(var_1)] * 2)):\n for var_5 in reversed(list(range(var_3))):\n var_4[var_5 + var_7] = max(var_4[var_5 + var_7], var_4[var_5] + var_6)\n print((max(var_4)))\n\n\nfunc_1()\n```", "output": "FASTER 1.8091", "pair_id": "python_p02863_pair0043_forward", "problem_id": "p02863", "language": "python", "direction": "forward", "speedup_ratio": 3.5042} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1 = list(map(int, input().split()))\nvar_2 = 0\nfor var_3 in range(var_1[0], var_1[1] + 1):\n var_4 = str(var_3)\n if var_4[0] == var_4[4] and var_4[1] == var_4[3]:\n var_2 += 1\nprint(var_2)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_5 in range(10):\n for var_6 in range(10):\n for var_7 in range(10):\n var_3 = 10000 * var_5 + 1000 * var_6 + 100 * var_7 + 10 * var_6 + var_5\n if var_1 <= var_3 <= var_2:\n var_4 += 1\nprint(var_4)\n```", "output": "FASTER 3.5367", "pair_id": "python_p03416_pair0014_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 11.6056} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(str, input().split()))\nvar_1 = int(var_1)\nvar_2 = int(float(var_2) * 1000)\nprint((var_1 * var_2 // 1000))\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\nimport math\nfrom collections import defaultdict\nfrom bisect import bisect_left, bisect_right\n\nsys.setrecursionlimit(10**7)\n\n\ndef func_4():\n return sys.stdin.readline()[:-1]\n\n\nvar_4 = 10**9 + 7\n\n\ndef func_1():\n return int(eval(func_4()))\n\n\ndef func_2():\n return list(map(int, func_4().split()))\n\n\ndef func_3(var_6, var_3):\n if var_6 <= 0:\n return [[] for _ in range(var_3)]\n elif var_3 == 1:\n return [func_1() for _ in range(var_6)]\n else:\n var_5 = [func_2() for _ in range(var_6)]\n return list(map(list, list(zip(*var_5))))\n\n\nvar_1, var_2 = list(map(str, func_4().split()))\nvar_1 = int(var_1)\nvar_2 = 100 * int(var_2[0]) + 10 * int(var_2[2]) + int(var_2[3])\nprint((var_1 * var_2 // 100))\n```", "output": "SLOWER 2.3246", "pair_id": "python_p02659_pair0001_reversed", "problem_id": "p02659", "language": "python", "direction": "reversed", "speedup_ratio": 5.0091} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nfrom sys import stdin\n\n\ndef func_1():\n\n var_11 = stdin.readline\n var_2 = int(var_11())\n var_1 = []\n for var_6 in range(var_2):\n var_5 = int(\"\".join(var_11().strip().split(\" \")), 2)\n var_1.append(var_5)\n var_3 = []\n for var_6 in range(var_2):\n var_10 = list(map(int, var_11().split()))\n var_3.append(var_10)\n var_8 = float(\"-inf\")\n for var_9 in range(1, 1 << 10):\n var_12 = 0\n for var_7 in range(var_2):\n var_4 = bin(var_9 & var_1[var_7]).count(\"1\")\n var_12 += var_3[var_7][var_4]\n var_8 = max(var_12, var_8)\n print(var_8)\n\n\nif __name__ == \"__main__\":\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\nimport numpy as np\n\nvar_6 = int(eval(input()))\n\nvar_1 = [input().replace(\" \", \"\") for var_4 in range(var_6)]\n\nvar_7 = [list(map(int, input().split())) for var_4 in range(var_6)]\nvar_11 = -999999999999999\nfor var_4 in range(1, 1024):\n var_3 = format(var_4, \"010b\")\n var_9 = 0\n for var_2, var_8 in zip(var_1, var_7):\n var_10 = 0\n for var_5 in range(10):\n if var_2[var_5] == \"1\" and var_3[var_5] == \"1\":\n var_10 += 1\n var_9 += var_8[var_10]\n if var_9 > var_11:\n if var_9 == 0:\n print((str(var_4)))\n break\n var_11 = var_9\nprint(var_11)\n```", "output": "SLOWER 2.3748", "pair_id": "python_p03503_pair0037_reversed", "problem_id": "p03503", "language": "python", "direction": "reversed", "speedup_ratio": 5.1868} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\n\nsys.setrecursionlimit(2147483647)\nvar_2 = float(\"inf\")\nvar_3 = 10**9 + 7\nvar_10 = lambda: sys.stdin.readline().rstrip()\n\n\ndef func_1():\n var_11, var_4 = list(map(int, var_10().split()))\n var_1 = [tuple(map(int, var_10().split())) for _ in range(var_11)]\n var_1.sort()\n var_8 = [0] * var_4\n var_6 = -var_2\n for var_9 in range(var_11):\n var_5, var_7 = var_1[var_9]\n var_12 = var_8[:]\n for var_13 in range(var_4):\n if var_13 + var_5 < var_4:\n var_12[var_13 + var_5] = max(\n var_12[var_13 + var_5], var_8[var_13] + var_7\n )\n else:\n var_6 = max(var_6, var_8[var_13] + var_7)\n var_8 = var_12\n print((max(var_6, max(var_8))))\n\n\nfunc_1()\n```\n\n=== Code B (Modified) ===\n```python\nfrom collections import Counter, defaultdict, deque\nfrom heapq import heappop, heappush, heapify\nimport sys, bisect, math, itertools, fractions, pprint\n\nsys.setrecursionlimit(10**8)\nvar_6 = 10**9 + 7\nvar_1 = float(\"inf\")\n\n\ndef func_1():\n return int(sys.stdin.readline())\n\n\ndef func_2():\n return list(map(int, sys.stdin.readline().split()))\n\n\nvar_8, var_11 = func_2()\nvar_17 = [func_2() for _ in range(var_8)]\nvar_10 = var_17[::-1]\nvar_14 = [[0] * var_11 for _ in range(var_8)]\nvar_3 = [[0] * var_11 for _ in range(var_8)]\nfor var_4 in range(var_8 - 1):\n var_16, var_15 = var_17[var_4]\n for var_5 in range(var_11):\n if var_5 < var_16:\n var_14[var_4 + 1][var_5] = var_14[var_4][var_5]\n else:\n var_14[var_4 + 1][var_5] = max(\n var_14[var_4][var_5], var_14[var_4][var_5 - var_16] + var_15\n )\nvar_9 = var_14[var_8 - 1][var_11 - 1] + var_17[var_8 - 1][1]\nfor var_4 in range(var_8 - 1):\n var_16, var_15 = var_10[var_4]\n for var_5 in range(var_11):\n if var_5 < var_16:\n var_3[var_4 + 1][var_5] = var_3[var_4][var_5]\n else:\n var_3[var_4 + 1][var_5] = max(\n var_3[var_4][var_5], var_3[var_4][var_5 - var_16] + var_15\n )\n var_9 = max(var_9, var_3[var_8 - 1][var_11 - 1] + var_17[0][1])\n\nfor var_4 in range(1, var_8 - 1):\n var_13 = var_4\n var_2 = var_8 - var_4 - 1\n var_7 = 0\n for var_5 in range(var_11):\n var_12 = var_14[var_13][var_5] + var_3[var_2][var_11 - 1 - var_5]\n var_7 = max(var_7, var_12)\n var_9 = max(var_9, var_7 + var_17[var_4][1])\nprint(var_9)\n```", "output": "SLOWER 2.0401", "pair_id": "python_p02863_pair0044_reversed", "problem_id": "p02863", "language": "python", "direction": "reversed", "speedup_ratio": 4.1128} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\n\nvar_9 = sys.stdin.readline\nfrom operator import itemgetter\n\nvar_3, var_4 = list(map(int, var_9().split()))\nvar_1 = [list(map(int, var_9().split())) for _ in range(var_3)]\nvar_1.sort(key=itemgetter(0))\nvar_8 = [[0 for _ in range(var_3 + 1)] for _ in range(var_4 + 1)]\n\nvar_2 = []\nfor var_10 in range(var_3):\n var_5, var_7 = var_1[var_10]\n for var_11 in range(var_4):\n if var_5 > var_11:\n var_8[var_11][var_10 + 1] = var_8[var_11][var_10]\n else:\n if var_7 + var_8[var_11 - var_5][var_10] >= var_8[var_11][var_10]:\n var_8[var_11][var_10 + 1] = var_8[var_11 - var_5][var_10] + var_7\n else:\n var_8[var_11][var_10 + 1] = var_8[var_11][var_10]\n var_2.append(var_8[var_4 - 1][var_10] + var_7)\nvar_6 = max(var_2)\nprint(var_6)\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\nfrom operator import itemgetter\nfrom heapq import heapify, heappop, heappush\n\nvar_1 = int(10e15)\nvar_2 = -var_1\nvar_11 = 1000000007\nsys.setrecursionlimit(1000000)\n\n\ndef func_2():\n return list(map(int, input().split()))\n\n\ndef func_4():\n return input().split()\n\n\ndef func_1():\n return int(sys.stdin.readline())\n\n\ndef func_3():\n return eval(input())\n\n\nvar_3, var_4 = func_2()\nvar_5 = [func_2() for var_9 in range(var_3)]\nvar_5.sort(key=itemgetter(0))\n\nvar_8 = [[0] * (var_4 + 1 + 3000 + 1) for _ in range(var_3 + 1)]\nvar_6 = 0\nfor var_9 in range(var_3):\n for var_10 in range(var_4 + 1 + 3000 + 1):\n var_12, var_7 = var_5[var_9]\n if 0 <= var_10 - var_12 < var_4:\n var_8[var_9 + 1][var_10] = max(\n var_8[var_9][var_10], var_8[var_9][var_10 - var_12] + var_7\n )\n else:\n var_8[var_9 + 1][var_10] = var_8[var_9][var_10]\n var_6 = max(var_6, var_8[var_9 + 1][var_10])\nprint(var_6)\n```", "output": "SLOWER 4.8389", "pair_id": "python_p02863_pair0045_reversed", "problem_id": "p02863", "language": "python", "direction": "reversed", "speedup_ratio": 28.619} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().rstrip().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = list(map(int, list(str(var_4))))\n if var_5[0] == var_5[4] and var_5[1] == var_5[3]:\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = str(var_4)\n if var_5[0] == var_5[4] and var_5[1] == var_5[3]:\n var_3 += 1\nprint(var_3)\n```", "output": "FASTER 1.9492", "pair_id": "python_p03416_pair0133_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 3.8615} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_3 = list(map(int, input().split()))\nvar_2 = 0\nfor var_5 in range(var_3 + 1)[var_1:]:\n if len(str(var_5)) % 2 == 0:\n var_6 = list(str(var_5))[: len(str(var_5)) // 2]\n var_7 = list(reversed(list(str(var_5))[len(str(var_5)) // 2 :]))\n if var_6 == var_7:\n var_2 += 1\n else:\n var_8 = list(str(var_5))[: len(str(var_5)) // 2 + 1]\n var_4 = list(reversed(list(str(var_5))[len(str(var_5)) // 2 :]))\n if var_8 == var_4:\n var_2 += 1\nprint(var_2)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_7 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_3 = True\n var_8 = str(var_4)\n var_6 = len(var_8)\n for var_5 in range(var_6 // 2 + 1):\n if var_8[var_5] != var_8[-var_5 - 1]:\n var_3 = False\n break\n if var_3:\n var_7 += 1\nprint(var_7)\n```", "output": "FASTER 1.3494", "pair_id": "python_p03416_pair0045_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 2.5481} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\n\nsys.setrecursionlimit(2147483647)\nvar_2 = float(\"inf\")\nvar_3 = 10**9 + 7\nvar_10 = lambda: sys.stdin.readline().rstrip()\n\n\ndef func_1():\n var_11, var_4 = list(map(int, var_10().split()))\n var_1 = [tuple(map(int, var_10().split())) for _ in range(var_11)]\n var_1.sort()\n var_8 = [0] * var_4\n var_6 = -var_2\n for var_9 in range(var_11):\n var_5, var_7 = var_1[var_9]\n var_12 = var_8[:]\n for var_13 in range(var_4):\n if var_13 + var_5 < var_4:\n var_12[var_13 + var_5] = max(\n var_12[var_13 + var_5], var_8[var_13] + var_7\n )\n else:\n var_6 = max(var_6, var_8[var_13] + var_7)\n var_8 = var_12\n print((max(var_6, max(var_8))))\n\n\nfunc_1()\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_6 = sorted([list(map(int, input().split())) for var_5 in range(var_1)])\n\nvar_4 = [[0] * (var_2 + 1) for var_5 in range(var_1 + 1)]\n\nfor var_5 in range(var_1):\n var_9, var_8 = var_6[var_5]\n for var_7 in range(var_2 + 1):\n if var_7 + var_9 <= var_2:\n var_4[var_5 + 1][var_7 + var_9] = max(\n var_4[var_5 + 1][var_7 + var_9], var_4[var_5][var_7] + var_8\n )\n var_4[var_5 + 1][var_7] = max(var_4[var_5][var_7], var_4[var_5 + 1][var_7])\nvar_3 = 0\nfor var_5, (var_9, var_8) in enumerate(var_6):\n var_3 = max(var_3, var_4[var_5][var_2 - 1] + var_8)\nprint(var_3)\n```", "output": "SLOWER 1.4447", "pair_id": "python_p02863_pair0046_reversed", "problem_id": "p02863", "language": "python", "direction": "reversed", "speedup_ratio": 2.722} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\n\n\ndef func_1(var_5):\n var_4 = 0\n for var_3 in range(1, var_5 + 1):\n if str(var_3) == str(var_3)[::-1]:\n var_4 += 1\n return var_4\n\n\nprint((func_1(var_2) - func_1(var_1 - 1)))\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_4 = str(var_4)\n if var_4 == var_4[::-1]:\n var_3 += 1\nprint(var_3)\n```", "output": "FASTER 1.4436", "pair_id": "python_p03416_pair0181_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 2.72} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = [0] * (var_2 + 1)\nfor var_3 in range(1, var_2 + 1):\n if str(var_3) == str(var_3)[::-1]:\n var_4[var_3] = var_4[var_3 - 1] + 1\n else:\n var_4[var_3] = var_4[var_3 - 1]\nprint((var_4[var_2] - var_4[var_1 - 1]))\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = input().split()\nvar_1 = int(var_1)\nvar_2 = int(var_2)\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = list(str(var_4))\n if (var_5[0] == var_5[4]) and (var_5[1] == var_5[3]):\n var_3 = var_3 + 1\nprint(var_3)\n```", "output": "FASTER 1.5379", "pair_id": "python_p03416_pair0182_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 2.9038} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\n\nvar_3 = sys.stdin.readline\nvar_1, var_2 = var_3().split()\nvar_1 = int(var_1)\nvar_2 = int(float(var_2) * 100 + 0.5)\nprint((var_1 * var_2 // 100))\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\nimport math\nfrom collections import defaultdict\nfrom bisect import bisect_left, bisect_right\n\nsys.setrecursionlimit(10**7)\n\n\ndef func_4():\n return sys.stdin.readline()[:-1]\n\n\nvar_4 = 10**9 + 7\n\n\ndef func_1():\n return int(eval(func_4()))\n\n\ndef func_2():\n return list(map(int, func_4().split()))\n\n\ndef func_3(var_6, var_3):\n if var_6 <= 0:\n return [[] for _ in range(var_3)]\n elif var_3 == 1:\n return [func_1() for _ in range(var_6)]\n else:\n var_5 = [func_2() for _ in range(var_6)]\n return list(map(list, list(zip(*var_5))))\n\n\nvar_1, var_2 = list(map(str, func_4().split()))\nvar_1 = int(var_1)\nvar_2 = 100 * int(var_2[0]) + 10 * int(var_2[2]) + int(var_2[3])\nprint((var_1 * var_2 // 100))\n```", "output": "SLOWER 2.3093", "pair_id": "python_p02659_pair0051_reversed", "problem_id": "p02659", "language": "python", "direction": "reversed", "speedup_ratio": 4.9565} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\n\nvar_20 = sys.stdin.read\nvar_21 = sys.stdin.readline\nvar_22 = sys.stdin.readlines\nsys.setrecursionlimit(10**9)\nvar_2 = 1 << 60\nvar_5 = 1000000007\n\n\nvar_4 = 1000001\n\n\nclass Class_1:\n def __init__(self, var_13, var_19, var_12):\n self.l = var_13\n self.r = var_19\n self.idx = var_12\n\n\ndef func_4(var_12, var_24, var_10, var_15):\n while var_12 <= var_15:\n var_10[var_12] += var_24\n var_12 += var_12 & -var_12\n\n\ndef func_3(var_12, var_10, var_15):\n var_23 = 0\n while var_12:\n var_23 += var_10[var_12]\n var_12 -= var_12 & -var_12\n return var_23\n\n\ndef func_1(var_9, var_15, var_17, var_16):\n\n var_10 = [0] * (var_15 + 1)\n\n var_14 = [-1] * var_4\n\n var_8 = [0] * var_16\n var_18 = 0\n for var_11 in range(var_15):\n\n if var_14[var_9[var_11]] != -1:\n func_4(var_14[var_9[var_11]] + 1, -1, var_10, var_15)\n\n var_14[var_9[var_11]] = var_11\n func_4(var_11 + 1, 1, var_10, var_15)\n\n while var_18 < var_16 and var_17[var_18].r == var_11:\n var_8[var_17[var_18].idx] = func_3(\n var_17[var_18].r + 1, var_10, var_15\n ) - func_3(var_17[var_18].l, var_10, var_15)\n var_18 += 1\n\n for var_11 in range(var_16):\n print((var_8[var_11]))\n\n\ndef func_2():\n var_6, var_7 = list(map(int, var_21().split()))\n var_1 = list(map(int, var_21().split()))\n (*var_3,) = list(map(int, var_20().split()))\n var_17 = [0] * var_7\n for var_11, (var_13, var_19) in enumerate(zip(*[iter(var_3)] * 2)):\n var_17[var_11] = Class_1(var_13 - 1, var_19 - 1, var_11)\n var_17.sort(key=lambda var_25: var_25.r)\n func_1(var_1, var_6, var_17, var_7)\n return\n\n\nif __name__ == \"__main__\":\n func_2()\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\n\nvar_17 = sys.stdin.read\nvar_18 = sys.stdin.readline\nvar_19 = sys.stdin.readlines\nsys.setrecursionlimit(10**9)\nvar_2 = 1 << 60\nvar_4 = 1000000007\n\n\nclass Class_1:\n def __init__(self, var_12):\n self.n = var_12\n self.data = [0] * (var_12 + 1)\n\n def func_1(self, var_10, var_20=1):\n var_10 += 1\n while var_10 <= self.n:\n self.data[var_10] += var_20\n var_10 += var_10 & -var_10\n\n def func_2(self, var_10):\n var_10 += 1\n var_20 = 0\n while var_10 > 0:\n var_20 += self.data[var_10]\n var_10 -= var_10 & -var_10\n return var_20\n\n def func_3(self, var_11, var_16):\n return self.get_sum(var_16 - 1) - self.get_sum(var_11 - 1)\n\n\ndef func_4():\n var_5, var_6 = map(int, var_18().split())\n var_1 = list(map(int, var_18().split()))\n var_3 = map(int, var_17().split())\n var_13 = [-1] * (var_5 + 1)\n var_14 = [[] for _ in range(var_5)]\n for var_10, var_9 in enumerate(var_1):\n if var_13[var_9] != -1:\n var_14[var_13[var_9]].append(var_10)\n var_13[var_9] = var_10\n var_15 = [[] for _ in range(var_5 + 1)]\n for var_10, (var_11, var_16) in enumerate(zip(*[iter(var_3)] * 2)):\n var_11 -= 1\n var_16 -= 1\n var_15[var_11].append((var_16, var_10))\n var_7 = [0] * var_6\n var_8 = Class_1(var_5)\n for var_11 in range(var_5 - 1, -1, -1):\n for var_16 in var_14[var_11]:\n var_8.add(var_16)\n for var_16, var_10 in var_15[var_11]:\n var_7[var_10] = (var_16 - var_11 + 1) - var_8.get_sum(var_16)\n print(*var_7, sep=\"\\n\")\n return\n\n\nif __name__ == \"__main__\":\n func_4()\n```", "output": "FASTER 2.1032", "pair_id": "python_p02599_pair0003_forward", "problem_id": "p02599", "language": "python", "direction": "forward", "speedup_ratio": 4.2966} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_3 in range(var_1, var_2 + 1):\n var_5 = list(str(var_3))\n var_6 = list(reversed(var_5))\n if var_5 == var_6:\n var_4 += 1\nprint(var_4)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_6 = str(var_4)\n var_5 = var_6[::-1]\n if var_6 == var_5:\n var_3 += 1\nprint(var_3)\n```", "output": "FASTER 1.0582", "pair_id": "python_p03416_pair0004_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 2.0824} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\ndef func_1():\n from sys import setrecursionlimit, stdin\n from os import environ\n from collections import defaultdict, deque, Counter\n from math import ceil, floor, gcd\n from itertools import accumulate, combinations, combinations_with_replacement\n\n setrecursionlimit(10**6)\n var_7 = (\n (lambda *var_11: print(*var_11))\n if \"TERM_PROGRAM\" in environ\n else lambda *var_12: 0\n )\n var_8 = lambda: stdin.readline().rstrip()\n var_3 = lambda: list(map(int, var_8().split()))\n var_1 = lambda: int(var_8())\n var_4 = 10**9 + 7\n var_2 = 10**9 + 10\n var_9, var_10 = var_8().split()\n var_5 = int(var_9)\n var_6 = int(float(var_10) * 100 + 0.5)\n print(var_5 * var_6 // 100)\n\n\nfunc_1()\n```\n\n=== Code B (Modified) ===\n```python\nimport decimal\n\nvar_1, var_2 = (decimal.Decimal(var_3) for var_3 in input().split())\nprint((int(var_1 * var_2)))\n```", "output": "FASTER 1.9551", "pair_id": "python_p02659_pair0038_forward", "problem_id": "p02659", "language": "python", "direction": "forward", "speedup_ratio": 3.8775} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\n\nvar_20 = sys.stdin.read\nvar_21 = sys.stdin.readline\nvar_22 = sys.stdin.readlines\nsys.setrecursionlimit(10**9)\nvar_2 = 1 << 60\nvar_5 = 1000000007\n\n\nvar_4 = 1000001\n\n\nclass Class_1:\n def __init__(self, var_13, var_19, var_12):\n self.l = var_13\n self.r = var_19\n self.idx = var_12\n\n\ndef func_4(var_12, var_24, var_10, var_15):\n while var_12 <= var_15:\n var_10[var_12] += var_24\n var_12 += var_12 & -var_12\n\n\ndef func_3(var_12, var_10, var_15):\n var_23 = 0\n while var_12:\n var_23 += var_10[var_12]\n var_12 -= var_12 & -var_12\n return var_23\n\n\ndef func_1(var_9, var_15, var_17, var_16):\n\n var_10 = [0] * (var_15 + 1)\n\n var_14 = [-1] * var_4\n\n var_8 = [0] * var_16\n var_18 = 0\n for var_11 in range(var_15):\n\n if var_14[var_9[var_11]] != -1:\n func_4(var_14[var_9[var_11]] + 1, -1, var_10, var_15)\n\n var_14[var_9[var_11]] = var_11\n func_4(var_11 + 1, 1, var_10, var_15)\n\n while var_18 < var_16 and var_17[var_18].r == var_11:\n var_8[var_17[var_18].idx] = func_3(\n var_17[var_18].r + 1, var_10, var_15\n ) - func_3(var_17[var_18].l, var_10, var_15)\n var_18 += 1\n\n for var_11 in range(var_16):\n print((var_8[var_11]))\n\n\ndef func_2():\n var_6, var_7 = list(map(int, var_21().split()))\n var_1 = list(map(int, var_21().split()))\n (*var_3,) = list(map(int, var_20().split()))\n var_17 = [0] * var_7\n for var_11, (var_13, var_19) in enumerate(zip(*[iter(var_3)] * 2)):\n var_17[var_11] = Class_1(var_13 - 1, var_19 - 1, var_11)\n var_17.sort(key=lambda var_25: var_25.r)\n func_1(var_1, var_6, var_17, var_7)\n return\n\n\nif __name__ == \"__main__\":\n func_2()\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\n\n\ndef func_5():\n return sys.stdin.readline()[:-1]\n\n\ndef func_2():\n return int(eval(func_5()))\n\n\ndef func_3():\n return list(map(int, func_5().split()))\n\n\ndef func_1():\n return list(func_3())\n\n\nvar_11, var_12 = func_3()\nvar_5 = [0] + func_1()\nvar_2 = [func_1() + [var_6] for var_6 in range(var_12)]\nvar_2.sort(key=lambda var_17: var_17[1])\nvar_4 = [0] * (var_12)\nvar_10 = [0 for var_6 in range(var_11 + 1)]\nvar_1 = 2\nwhile var_1 <= var_11:\n var_1 *= 2\nvar_16 = [0] * (2 * var_1)\n\n\ndef func_7(var_8, var_17):\n var_8 += var_1 - 1\n var_16[var_8] = var_17\n while var_8 > 0:\n var_8 = (var_8 - 1) // 2\n var_16[var_8] = var_16[var_8 * 2 + 1] + var_16[var_8 * 2 + 2]\n\n\ndef func_4(var_8, var_17):\n var_8 += var_1 - 1\n while var_8 >= 0:\n var_16[var_8] += var_17\n var_8 = (var_8 - 1) // 2\n\n\ndef func_6(var_9, var_13):\n func_1 = var_9 + var_1 - 1\n var_3 = var_13 + var_1 - 1\n var_14 = 0\n while func_1 <= var_3:\n if var_3 & 1:\n var_14 += var_16[var_3]\n var_3 -= 2\n else:\n var_3 -= 1\n if func_1 & 1:\n func_1 -= 1\n else:\n var_14 += var_16[func_1]\n func_1 >>= 1\n var_3 >>= 1\n return var_14\n\n\nvar_7 = 1\nfor var_9, var_13, var_6 in var_2:\n while var_7 <= var_13:\n var_15 = var_5[var_7]\n func_4(var_10[var_15], -1)\n func_4(var_7, 1)\n var_10[var_15] = var_7\n var_7 += 1\n var_4[var_6] = func_6(var_9, var_13)\nfor var_6 in var_4:\n print(var_6)\n```", "output": "FASTER 2.1494", "pair_id": "python_p02599_pair0004_forward", "problem_id": "p02599", "language": "python", "direction": "forward", "speedup_ratio": 4.4365} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_4 = {}\nvar_5 = 0\nfor var_6 in range(10000, 100000):\n var_3 = list(str(var_6))\n if var_3 == list(reversed(var_3)):\n var_5 += 1\n var_4[var_6] = var_5\nvar_1, var_2 = list(map(int, input().split()))\nprint((var_4[var_2] - var_4[var_1 - 1] if var_1 > 10000 else var_4[var_2]))\n```\n\n=== Code B (Modified) ===\n```python\nfrom sys import stdin\n\nvar_6 = lambda: list(map(int, stdin.readline().split()))\nvar_5 = lambda: list(map(int, stdin.readline().split()))\nvar_1, var_3 = var_6()\nvar_2 = 0\nfor var_4 in range(var_1, var_3 + 1):\n var_7 = str(var_4)\n if var_7 == var_7[::-1]:\n var_2 += 1\nprint(var_2)\n```", "output": "FASTER 3.5552", "pair_id": "python_p03416_pair0183_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 11.7549} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = str(var_4)\n if var_5[0] == var_5[4] and var_5[1] == var_5[3]:\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_8 in range(var_1, var_2 + 1):\n var_7 = str(var_8)\n var_6 = len(var_7)\n var_4 = True\n for var_5 in range(var_6 // 2):\n if var_7[var_5] != var_7[var_6 - 1 - var_5]:\n var_4 = False\n break\n if var_4:\n var_3 += 1\nprint(var_3)\n```", "output": "SLOWER 1.3924", "pair_id": "python_p03416_pair0184_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 2.6251} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_5 in range(var_1, var_2 + 1):\n var_3 = str(var_5)\n if var_3[0] == var_3[-1] and var_3[1] == var_3[-2]:\n var_4 += 1\nprint(var_4)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = list(str(var_4))\n if var_5 == list(reversed(var_5)):\n var_3 += 1\nprint(var_3)\n```", "output": "SLOWER 1.3238", "pair_id": "python_p03416_pair0019_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 2.5032} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_3 in range(var_1, var_2 + 1):\n var_5 = list(str(var_3))\n var_6 = list(reversed(var_5))\n if var_5 == var_6:\n var_4 += 1\nprint(var_4)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().strip().split(\" \")))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n if str(var_4) == str(var_4)[::-1]:\n var_3 += 1\nprint(var_3)\n```", "output": "FASTER 1.0014", "pair_id": "python_p03416_pair0185_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 2.0019} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_7 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_3 = True\n var_8 = str(var_4)\n var_6 = len(var_8)\n for var_5 in range(var_6 // 2 + 1):\n if var_8[var_5] != var_8[-var_5 - 1]:\n var_3 = False\n break\n if var_3:\n var_7 += 1\nprint(var_7)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_4 = str(var_4)\n if var_4[0] == var_4[-1] and var_4[1] == var_4[-2]:\n var_3 += 1\nprint(var_3)\n```", "output": "FASTER 1.3088", "pair_id": "python_p03416_pair0186_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 2.4774} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().rstrip().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = list(map(int, list(str(var_4))))\n if var_5[0] == var_5[4] and var_5[1] == var_5[3]:\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nfrom sys import stdin\n\nvar_6 = lambda: list(map(int, stdin.readline().split()))\nvar_5 = lambda: list(map(int, stdin.readline().split()))\nvar_1, var_3 = var_6()\nvar_2 = 0\nfor var_4 in range(var_1, var_3 + 1):\n var_7 = str(var_4)\n if var_7 == var_7[::-1]:\n var_2 += 1\nprint(var_2)\n```", "output": "FASTER 1.6646", "pair_id": "python_p03416_pair0117_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 3.1703} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_3 = list(map(int, input().split()))\nvar_2 = 0\nfor var_5 in range(var_3 + 1)[var_1:]:\n if len(str(var_5)) % 2 == 0:\n var_6 = list(str(var_5))[: len(str(var_5)) // 2]\n var_7 = list(reversed(list(str(var_5))[len(str(var_5)) // 2 :]))\n if var_6 == var_7:\n var_2 += 1\n else:\n var_8 = list(str(var_5))[: len(str(var_5)) // 2 + 1]\n var_4 = list(reversed(list(str(var_5))[len(str(var_5)) // 2 :]))\n if var_8 == var_4:\n var_2 += 1\nprint(var_2)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n if list(str(var_4)) == list(reversed(str(var_4))):\n var_3 += 1\nprint(var_3)\n```", "output": "FASTER 1.0742", "pair_id": "python_p03416_pair0187_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 2.1055} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_3 in range(var_1, var_2 + 1):\n var_5 = list(str(var_3))\n var_6 = list(reversed(var_5))\n if var_5 == var_6:\n var_4 += 1\nprint(var_4)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_4 = str(var_4)\n if var_4[0] == var_4[-1] and var_4[1] == var_4[-2]:\n var_3 += 1\nprint(var_3)\n```", "output": "FASTER 1.4924", "pair_id": "python_p03416_pair0174_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 2.8135} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\n\nvar_8 = sys.stdin.readline\n\n\ndef func_1():\n var_2 = int(eval(var_8()))\n var_1 = [int(var_8().replace(\" \", \"\"), 2) for _ in range(var_2)]\n var_3 = [list(map(int, var_8().split())) for _ in range(var_2)]\n var_4 = -(10**7) * var_2\n for var_7 in range(1, 1 << 10):\n var_10 = 0\n for var_9, var_6 in enumerate(var_1):\n var_5 = bin(var_7 & var_6).count(\"1\")\n var_10 += var_3[var_9][var_5]\n var_4 = max(var_4, var_10)\n print(var_4)\n\n\nif __name__ == \"__main__\":\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\n\nvar_7 = sys.stdin.readline\nfrom itertools import combinations\n\n\ndef func_3(var_10):\n for _ in range(var_10):\n yield list(map(int, var_7().split()))\n\n\ndef func_1(var_9, var_5, var_11):\n var_3 = sum(1 if var_5[var_8] == 1 else 0 for var_8 in var_9)\n return var_11[var_3]\n\n\ndef func_2():\n var_10 = int(eval(var_7()))\n var_1 = list(func_3(var_10))\n var_2 = list(func_3(var_10))\n for var_6 in range(1, 11):\n for var_4 in combinations(list(range(10)), var_6):\n yield sum(\n func_1(var_4, var_5, var_11) for var_5, var_11 in zip(var_1, var_2)\n )\n\n\nprint((max(func_2())))\n```", "output": "SLOWER 1.6626", "pair_id": "python_p03503_pair0033_reversed", "problem_id": "p03503", "language": "python", "direction": "reversed", "speedup_ratio": 3.1659} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nfrom collections import Counter, defaultdict, deque\nfrom heapq import heappop, heappush, heapify\nimport sys, bisect, math, itertools, fractions, pprint\n\nsys.setrecursionlimit(10**8)\nvar_6 = 10**9 + 7\nvar_1 = float(\"inf\")\n\n\ndef func_1():\n return int(sys.stdin.readline())\n\n\ndef func_2():\n return list(map(int, sys.stdin.readline().split()))\n\n\nvar_7, var_9 = func_2()\nvar_13 = [func_2() for _ in range(var_7)]\nvar_13.sort(key=lambda var_14: var_14[1], reverse=True)\nvar_8 = 0\nvar_10 = min(var_7, 5)\nfor var_3 in range(var_10):\n var_2 = [[0] * (var_9 + 5) for _ in range(var_7 + 5)]\n for var_4 in range(var_7):\n var_12, var_11 = var_13[var_4]\n for var_5 in range(var_9):\n if var_5 < var_12 or var_3 == var_4:\n var_2[var_4 + 1][var_5] = var_2[var_4][var_5]\n else:\n var_2[var_4 + 1][var_5] = max(\n var_2[var_4][var_5], var_2[var_4][var_5 - var_12] + var_11\n )\n\n var_8 = max(var_2[var_7][var_9 - 1] + var_13[var_3][1], var_8)\nprint(var_8)\n```\n\n=== Code B (Modified) ===\n```python\nimport bisect\nimport sys\n\nsys.setrecursionlimit(10**6)\nvar_16 = sys.stdout.write\nvar_7 = lambda *var_14: print(*var_14) if var_1 else 0\nvar_1 = True\n\n\ndef func_1(var_9=sys.stdin.readline):\n var_11 = lambda: var_9().rstrip()\n var_3 = lambda: list(map(int, var_11().split()))\n var_2 = lambda: int(var_11())\n var_4 = lambda var_17: [var_3() for _ in range(var_17)]\n var_13, var_15 = var_3()\n var_5 = var_4(var_13)\n var_5.sort()\n var_8 = [[0] * var_15 for _ in range(var_13 + 1)]\n for var_10 in range(1, var_13 + 1):\n for var_12 in range(1, var_15):\n if var_12 < var_5[var_10 - 1][0]:\n var_8[var_10][var_12] = var_8[var_10 - 1][var_12]\n else:\n var_8[var_10][var_12] = max(\n var_8[var_10 - 1][var_12],\n var_8[var_10 - 1][var_12 - var_5[var_10 - 1][0]]\n + var_5[var_10 - 1][1],\n )\n var_6 = 0\n for var_10 in range(var_13):\n var_6 = max(var_6, var_8[var_10][var_15 - 1] + var_5[var_10][1])\n print(var_6)\n\n\nif __name__ == \"__main__\":\n func_1()\n```", "output": "FASTER 2.0434", "pair_id": "python_p02863_pair0047_forward", "problem_id": "p02863", "language": "python", "direction": "forward", "speedup_ratio": 4.1221} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nfrom fractions import Fraction\n\nvar_1, var_2 = input().split()\n\n\nfrom decimal import *\n\nvar_4 = var_3(var_1)\nvar_6 = var_3(var_2)\nvar_7().prec = 28\nvar_5 = var_4 * var_6\nprint((int(var_5)))\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\nimport math\nfrom collections import defaultdict\nfrom bisect import bisect_left, bisect_right\n\nsys.setrecursionlimit(10**7)\n\n\ndef func_4():\n return sys.stdin.readline()[:-1]\n\n\nvar_4 = 10**9 + 7\n\n\ndef func_1():\n return int(eval(func_4()))\n\n\ndef func_2():\n return list(map(int, func_4().split()))\n\n\ndef func_3(var_6, var_3):\n if var_6 <= 0:\n return [[] for _ in range(var_3)]\n elif var_3 == 1:\n return [func_1() for _ in range(var_6)]\n else:\n var_5 = [func_2() for _ in range(var_6)]\n return list(map(list, list(zip(*var_5))))\n\n\nfrom decimal import getcontext, Decimal\n\ngetcontext().prec = 28\nvar_1, var_2 = list(map(str, func_4().split()))\nvar_1 = int(var_1)\nvar_2 = Decimal(var_2)\nprint((int(var_1 * var_2)))\n```", "output": "SLOWER 1.9011", "pair_id": "python_p02659_pair0006_reversed", "problem_id": "p02659", "language": "python", "direction": "reversed", "speedup_ratio": 3.7349} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1 = list(map(int, input().split()))\nvar_2 = 0\nfor var_3 in range(var_1[0], var_1[1] + 1):\n var_4 = str(var_3)\n if var_4[0] == var_4[4] and var_4[1] == var_4[3]:\n var_2 += 1\nprint(var_2)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_8 in range(var_1, var_2 + 1):\n var_7 = str(var_8)\n var_6 = len(var_7)\n var_4 = True\n for var_5 in range(var_6 // 2):\n if var_7[var_5] != var_7[var_6 - 1 - var_5]:\n var_4 = False\n break\n if var_4:\n var_3 += 1\nprint(var_3)\n```", "output": "SLOWER 1.4151", "pair_id": "python_p03416_pair0188_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 2.6667} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_6, var_7 = list(map(int, input().split()))\nvar_1 = [list(map(int, input().split())) for _ in range(var_6)]\nvar_1.sort()\nvar_3 = [(6007) * [0] for _ in range(var_6 + 1)]\nvar_3[0][0] = 0\nvar_2 = 0\nfor var_4 in range(var_6):\n for var_5 in range(6007):\n var_3[var_4 + 1][var_5] = max(var_3[var_4 + 1][var_5], var_3[var_4][var_5])\n if var_5 < var_7:\n var_3[var_4 + 1][var_5 + var_1[var_4][0]] = max(\n var_3[var_4][var_5] + var_1[var_4][1],\n var_3[var_4][var_5 + var_1[var_4][0]],\n )\n var_2 = max(var_2, var_3[var_4 + 1][var_5])\nprint(var_2)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_6 = sorted([list(map(int, input().split())) for var_5 in range(var_1)])\n\nvar_4 = [[0] * (var_2 + 1) for var_5 in range(var_1 + 1)]\n\nfor var_5 in range(var_1):\n var_9, var_8 = var_6[var_5]\n for var_7 in range(var_2 + 1):\n if var_7 + var_9 <= var_2:\n var_4[var_5 + 1][var_7 + var_9] = max(\n var_4[var_5 + 1][var_7 + var_9], var_4[var_5][var_7] + var_8\n )\n var_4[var_5 + 1][var_7] = max(var_4[var_5][var_7], var_4[var_5 + 1][var_7])\nvar_3 = 0\nfor var_5, (var_9, var_8) in enumerate(var_6):\n var_3 = max(var_3, var_4[var_5][var_2 - 1] + var_8)\nprint(var_3)\n```", "output": "FASTER 5.3151", "pair_id": "python_p02863_pair0048_forward", "problem_id": "p02863", "language": "python", "direction": "forward", "speedup_ratio": 39.8117} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\n\nvar_8 = sys.stdin.readline\nvar_9 = int(eval(var_8()))\nvar_6 = []\nfor var_7 in range(var_9 - 1):\n var_1, var_3 = list(map(int, var_8().split()))\n var_6.append([var_1 - 1, var_3 - 1, var_7])\nvar_6.sort()\nvar_13 = [0] * (var_9)\nvar_2 = [0] * (var_9 - 1)\nvar_10 = 1\nvar_11 = 0\nfor var_5 in var_6:\n _from, var_12, var_7 = var_5\n if _from != var_11:\n var_10 = 1\n if var_13[_from] == var_10:\n var_10 += 1\n var_2[var_7] = var_10\n var_13[var_12] = var_10\n var_10 += 1\n var_11 = _from\nprint((max(var_2)))\nfor var_4 in var_2:\n print(var_4)\n```\n\n=== Code B (Modified) ===\n```python\nvar_11 = int(eval(input()))\nvar_12 = {var_8: [] for var_8 in range(1, var_11 + 1)}\nvar_19 = [False for var_8 in range(var_11 + 1)]\nvar_16 = []\nfor _ in range(var_11 - 1):\n var_2, var_3 = list(map(int, input().split()))\n var_12[var_2].append(var_3)\n var_12[var_3].append(var_2)\n var_16.append((var_2, var_3))\nvar_9 = var_16[0][0]\nvar_19[var_9] = True\nvar_6 = []\nvar_7 = []\nvar_14 = {var_8: {} for var_8 in range(1, var_11 + 1)}\nvar_10 = [0 for var_8 in range(var_11 + 1)]\n\nvar_4 = 1\nfor var_5 in var_12[var_9]:\n var_19[var_5] = True\n var_14[var_9][var_5] = var_4\n var_14[var_5][var_9] = var_4\n var_10[var_5] = var_4\n var_4 += 1\n var_6.append(var_5)\nwhile var_6:\n for var_15 in var_6:\n var_13 = 1\n for var_5 in var_12[var_15]:\n if var_19[var_5] == False:\n var_19[var_5] = True\n if var_13 != var_10[var_15]:\n var_14[var_15][var_5] = var_13\n var_14[var_5][var_15] = var_13\n var_10[var_5] = var_13\n var_13 += 1\n var_7.append(var_5)\n else:\n var_13 += 1\n var_14[var_15][var_5] = var_13\n var_14[var_5][var_15] = var_13\n var_10[var_5] = var_13\n var_13 += 1\n var_7.append(var_5)\n if var_7:\n var_6 = var_7\n var_7 = []\n else:\n var_6 = []\n var_7 = []\nvar_1 = 0\nfor var_8 in range(1, var_11 + 1):\n var_1 = max(var_1, len(var_12[var_8]))\nprint(var_1)\nfor var_8 in range(var_11 - 1):\n var_17, var_18 = var_16[var_8][0], var_16[var_8][1]\n print((var_14[var_17][var_18]))\n```", "output": "SLOWER 1.2377", "pair_id": "python_p02850_pair0025_reversed", "problem_id": "p02850", "language": "python", "direction": "reversed", "speedup_ratio": 2.3582} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = input().split()\nvar_1 = int(var_1)\nvar_2 = int(var_2)\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = list(str(var_4))\n if (var_5[0] == var_5[4]) and (var_5[1] == var_5[3]):\n var_3 = var_3 + 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = [\n var_3 for var_3 in map(str, list(range(var_1, var_2 + 1))) if var_3 == var_3[::-1]\n]\nprint((len(var_4)))\n```", "output": "FASTER 1.1029", "pair_id": "python_p03416_pair0189_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 2.1478} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport decimal\n\n\ndef func_1():\n var_1, var_2 = list(map(decimal.Decimal, input().split()))\n print((var_1 * var_2 // 1))\n\n\nif __name__ == \"__main__\":\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\ndef func_1():\n from sys import setrecursionlimit, stdin\n from os import environ\n from collections import defaultdict, deque, Counter\n from math import ceil, floor, gcd\n from itertools import accumulate, combinations, combinations_with_replacement\n\n setrecursionlimit(10**6)\n var_7 = (\n (lambda *var_11: print(*var_11))\n if \"TERM_PROGRAM\" in environ\n else lambda *var_12: 0\n )\n var_8 = lambda: stdin.readline().rstrip()\n var_3 = lambda: list(map(int, var_8().split()))\n var_1 = lambda: int(var_8())\n var_4 = 10**9 + 7\n var_2 = 10**9 + 10\n var_9, var_10 = var_8().split()\n var_5 = int(var_9)\n var_6 = int(float(var_10) * 100 + 0.5)\n print(var_5 * var_6 // 100)\n\n\nfunc_1()\n```", "output": "SLOWER 1.7718", "pair_id": "python_p02659_pair0052_reversed", "problem_id": "p02659", "language": "python", "direction": "reversed", "speedup_ratio": 3.4148} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\n\nvar_5 = sys.stdin.readline\nif __name__ == \"__main__\":\n var_1, var_3 = var_5().split()\n var_2 = int(var_1)\n var_4 = round(float(var_3) * 100)\n print((var_2 * var_4 // 100))\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\nimport math\nfrom collections import defaultdict\nfrom bisect import bisect_left, bisect_right\n\nsys.setrecursionlimit(10**7)\n\n\ndef func_4():\n return sys.stdin.readline()[:-1]\n\n\nvar_4 = 10**9 + 7\n\n\ndef func_1():\n return int(eval(func_4()))\n\n\ndef func_2():\n return list(map(int, func_4().split()))\n\n\ndef func_3(var_6, var_3):\n if var_6 <= 0:\n return [[] for _ in range(var_3)]\n elif var_3 == 1:\n return [func_1() for _ in range(var_6)]\n else:\n var_5 = [func_2() for _ in range(var_6)]\n return list(map(list, list(zip(*var_5))))\n\n\nfrom decimal import getcontext, Decimal\n\ngetcontext().prec = 28\nvar_1, var_2 = list(map(str, func_4().split()))\nvar_1 = int(var_1)\nvar_2 = Decimal(var_2)\nprint((int(var_1 * var_2)))\n```", "output": "SLOWER 2.0198", "pair_id": "python_p02659_pair0036_reversed", "problem_id": "p02659", "language": "python", "direction": "reversed", "speedup_ratio": 4.0552} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nfrom sys import stdin\n\nvar_6 = lambda: list(map(int, stdin.readline().split()))\nvar_5 = lambda: list(map(int, stdin.readline().split()))\nvar_1, var_3 = var_6()\nvar_2 = 0\nfor var_4 in range(var_1, var_3 + 1):\n var_7 = str(var_4)\n if var_7 == var_7[::-1]:\n var_2 += 1\nprint(var_2)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_3 in range(var_1, var_2 + 1):\n var_5 = list(str(var_3))\n var_6 = list(reversed(var_5))\n if var_5 == var_6:\n var_4 += 1\nprint(var_4)\n```", "output": "SLOWER 1.2902", "pair_id": "python_p03416_pair0085_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 2.4457} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_3 in range(var_1, var_2 + 1):\n var_5 = list(str(var_3))\n var_6 = list(reversed(var_5))\n if var_5 == var_6:\n var_4 += 1\nprint(var_4)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_5 in range(var_1, var_2 + 1):\n var_3 = str(var_5)\n if var_3[0] == var_3[-1] and var_3[1] == var_3[-2]:\n var_4 += 1\nprint(var_4)\n```", "output": "FASTER 1.4002", "pair_id": "python_p03416_pair0190_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 2.6394} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\n\nvar_20 = sys.stdin.read\nvar_21 = sys.stdin.readline\nvar_22 = sys.stdin.readlines\nsys.setrecursionlimit(10**9)\nvar_2 = 1 << 60\nvar_5 = 1000000007\n\n\nvar_4 = 1000001\n\n\nclass Class_1:\n def __init__(self, var_13, var_19, var_12):\n self.l = var_13\n self.r = var_19\n self.idx = var_12\n\n\ndef func_4(var_12, var_24, var_10, var_15):\n while var_12 <= var_15:\n var_10[var_12] += var_24\n var_12 += var_12 & -var_12\n\n\ndef func_3(var_12, var_10, var_15):\n var_23 = 0\n while var_12:\n var_23 += var_10[var_12]\n var_12 -= var_12 & -var_12\n return var_23\n\n\ndef func_1(var_9, var_15, var_17, var_16):\n\n var_10 = [0] * (var_15 + 1)\n\n var_14 = [-1] * var_4\n\n var_8 = [0] * var_16\n var_18 = 0\n for var_11 in range(var_15):\n\n if var_14[var_9[var_11]] != -1:\n func_4(var_14[var_9[var_11]] + 1, -1, var_10, var_15)\n\n var_14[var_9[var_11]] = var_11\n func_4(var_11 + 1, 1, var_10, var_15)\n\n while var_18 < var_16 and var_17[var_18].r == var_11:\n var_8[var_17[var_18].idx] = func_3(\n var_17[var_18].r + 1, var_10, var_15\n ) - func_3(var_17[var_18].l, var_10, var_15)\n var_18 += 1\n\n for var_11 in range(var_16):\n print((var_8[var_11]))\n\n\ndef func_2():\n var_6, var_7 = list(map(int, var_21().split()))\n var_1 = list(map(int, var_21().split()))\n (*var_3,) = list(map(int, var_20().split()))\n var_17 = [0] * var_7\n for var_11, (var_13, var_19) in enumerate(zip(*[iter(var_3)] * 2)):\n var_17[var_11] = Class_1(var_13 - 1, var_19 - 1, var_11)\n var_17.sort(key=lambda var_25: var_25.r)\n func_1(var_1, var_6, var_17, var_7)\n return\n\n\nif __name__ == \"__main__\":\n func_2()\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\n\n\nclass Class_1:\n \"\"\"\"\"\"\n\n def __init__(self, var_1):\n self.__n = len(var_1)\n self.__node = [0] * (self.__n + 1)\n self.__data = [0] * (self.__n + 1)\n var_7 = [0] * (self.__n + 1)\n for var_11 in range(self.__n):\n var_7[var_11 + 1] = var_7[var_11] + var_1[var_11]\n for var_11 in range(1, self.__n + 1):\n self.__data[var_11] = var_1[var_11 - 1]\n self.__node[var_11] = var_7[var_11] - var_7[var_11 - (var_11 & -var_11)]\n\n def func_1(self, var_11, var_22):\n self.__data[var_11] += var_22\n while var_11 <= self.__n:\n self.__node[var_11] += var_22\n var_11 += var_11 & -var_11\n\n def func_4(self, var_11):\n \"\"\"\"\"\"\n var_19 = 0\n while var_11 > 0:\n var_19 += self.__node[var_11]\n var_11 -= var_11 & -var_11\n return var_19\n\n def func_2(self, var_11, var_12):\n \"\"\"\"\"\"\n if var_11 == var_12:\n return self.__data[var_11]\n else:\n return self.sum(var_12) - self.sum(var_11 - 1)\n\n\ndef func_3():\n var_4, var_6 = map(int, input().split())\n var_3 = list(map(int, input().split()))\n var_5 = [[] for _ in range(var_4)]\n for var_11, var_9 in enumerate(var_3):\n var_5[var_9 - 1].append(var_11)\n var_18 = [0] * var_4\n for var_14 in var_5:\n if len(var_14):\n var_18[var_14.pop()] = 1\n var_2 = Class_1(var_18)\n var_16 = [[] for _ in range(var_4)]\n for var_11, var_20 in enumerate(sys.stdin.readlines()):\n var_13, var_17 = map(int, var_20.split())\n var_16[var_17 - 1].append((var_13 - 1, var_11))\n var_8 = [None] * var_6\n var_10 = var_4 - 1\n for var_17, var_15 in enumerate(reversed(var_16)):\n var_17 = (var_4 - 1) - var_17\n while var_15:\n var_13, var_11 = var_15.pop()\n while var_17 < var_10:\n var_9 = var_3[var_10] - 1\n var_14 = var_5[var_9]\n if len(var_14):\n var_2.add(var_14.pop() + 1, 1)\n var_10 -= 1\n var_21 = var_2.get(var_13 + 1, var_17 + 1)\n var_8[var_11] = var_21\n print(*var_8, sep=\"\\n\")\n\n\nif __name__ == \"__main__\":\n func_3()\n```", "output": "FASTER 1.7958", "pair_id": "python_p02599_pair0005_forward", "problem_id": "p02599", "language": "python", "direction": "forward", "speedup_ratio": 3.472} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nfrom collections import Counter, defaultdict, deque\nfrom heapq import heappop, heappush, heapify\nimport sys, bisect, math, itertools, fractions, pprint\n\nsys.setrecursionlimit(10**8)\nvar_6 = 10**9 + 7\nvar_1 = float(\"inf\")\n\n\ndef func_1():\n return int(sys.stdin.readline())\n\n\ndef func_2():\n return list(map(int, sys.stdin.readline().split()))\n\n\nvar_8, var_11 = func_2()\nvar_17 = [func_2() for _ in range(var_8)]\nvar_10 = var_17[::-1]\nvar_14 = [[0] * var_11 for _ in range(var_8)]\nvar_3 = [[0] * var_11 for _ in range(var_8)]\nfor var_4 in range(var_8 - 1):\n var_16, var_15 = var_17[var_4]\n for var_5 in range(var_11):\n if var_5 < var_16:\n var_14[var_4 + 1][var_5] = var_14[var_4][var_5]\n else:\n var_14[var_4 + 1][var_5] = max(\n var_14[var_4][var_5], var_14[var_4][var_5 - var_16] + var_15\n )\nvar_9 = var_14[var_8 - 1][var_11 - 1] + var_17[var_8 - 1][1]\nfor var_4 in range(var_8 - 1):\n var_16, var_15 = var_10[var_4]\n for var_5 in range(var_11):\n if var_5 < var_16:\n var_3[var_4 + 1][var_5] = var_3[var_4][var_5]\n else:\n var_3[var_4 + 1][var_5] = max(\n var_3[var_4][var_5], var_3[var_4][var_5 - var_16] + var_15\n )\n var_9 = max(var_9, var_3[var_8 - 1][var_11 - 1] + var_17[0][1])\n\nfor var_4 in range(1, var_8 - 1):\n var_13 = var_4\n var_2 = var_8 - var_4 - 1\n var_7 = 0\n for var_5 in range(var_11):\n var_12 = var_14[var_13][var_5] + var_3[var_2][var_11 - 1 - var_5]\n var_7 = max(var_7, var_12)\n var_9 = max(var_9, var_7 + var_17[var_4][1])\nprint(var_9)\n```\n\n=== Code B (Modified) ===\n```python\nfrom sys import stdin\n\n\ndef func_1():\n\n var_9 = stdin.readline\n var_8, var_10 = list(map(int, var_9().split()))\n var_7 = [list(map(int, var_9().split())) for _ in range(var_8)]\n var_7.sort()\n var_1 = [0] * var_8\n var_2 = [0] * var_8\n for var_4 in range(var_8):\n var_1[var_4], var_2[var_4] = var_7[var_4][0], var_7[var_4][1]\n\n var_5 = -(10**9)\n var_3 = [[var_5] * (var_10 + 1) for _ in range(var_8 + 1)]\n var_3[0][0] = 0\n for var_4 in range(var_8):\n for var_6 in range(var_10 + 1):\n\n if var_6 != var_10:\n var_3[var_4 + 1][min(var_10, var_6 + var_1[var_4])] = max(\n var_3[var_4 + 1][min(var_10, var_6 + var_1[var_4])],\n var_3[var_4][var_6] + var_2[var_4],\n )\n\n var_3[var_4 + 1][var_6] = max(var_3[var_4 + 1][var_6], var_3[var_4][var_6])\n print((max(var_3[var_8])))\n\n\nif __name__ == \"__main__\":\n func_1()\n```", "output": "FASTER 1.1031", "pair_id": "python_p02863_pair0049_forward", "problem_id": "p02863", "language": "python", "direction": "forward", "speedup_ratio": 2.1481} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_2 = int(eval(input()))\nvar_3 = [int(eval(input())) for var_1 in range(var_2)]\nprint((sum(var_3) - max(var_3) // 2))\n```\n\n=== Code B (Modified) ===\n```python\nimport copy\nimport random\nimport bisect\nimport fractions\nimport math\nimport sys\nimport collections\nfrom decimal import Decimal\n\nvar_5 = 10**9 + 7\nsys.setrecursionlimit(var_5)\nvar_3 = collections.deque()\n\n\ndef func_1():\n return list(map(int, sys.stdin.readline().split()))\n\n\nvar_1 = int(eval(input()))\nvar_6 = [0 for var_4 in range(var_1)]\nfor var_4 in range(var_1):\n var_6[var_4] = int(eval(input()))\nvar_6.sort()\nvar_2 = sum(var_6)\nvar_2 -= var_6[-1] // 2\nprint(var_2)\n```", "output": "SLOWER 1.0159", "pair_id": "python_p03207_pair0002_reversed", "problem_id": "p03207", "language": "python", "direction": "reversed", "speedup_ratio": 2.0221} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_6 = sorted([list(map(int, input().split())) for var_5 in range(var_1)])\n\nvar_4 = [[0] * (var_2 + 1) for var_5 in range(var_1 + 1)]\n\nfor var_5 in range(var_1):\n var_9, var_8 = var_6[var_5]\n for var_7 in range(var_2 + 1):\n if var_7 + var_9 <= var_2:\n var_4[var_5 + 1][var_7 + var_9] = max(\n var_4[var_5 + 1][var_7 + var_9], var_4[var_5][var_7] + var_8\n )\n var_4[var_5 + 1][var_7] = max(var_4[var_5][var_7], var_4[var_5 + 1][var_7])\nvar_3 = 0\nfor var_5, (var_9, var_8) in enumerate(var_6):\n for var_7 in range(var_2):\n var_3 = max(var_3, var_4[var_5][var_7] + var_8)\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_2, var_3, *var_1 = list(map(int, open(0).read().split()))\nvar_4 = [0] * (var_3 + max(var_1[::2]))\nfor var_7, var_6 in sorted(zip(*[iter(var_1)] * 2)):\n for var_5 in reversed(list(range(var_3))):\n var_4[var_5 + var_7] = max(var_4[var_5 + var_7], var_4[var_5] + var_6)\nprint((max(var_4)))\n```", "output": "FASTER 1.3487", "pair_id": "python_p02863_pair0050_forward", "problem_id": "p02863", "language": "python", "direction": "forward", "speedup_ratio": 2.5469} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_6, var_7 = list(map(int, input().split()))\nvar_1 = [list(map(int, input().split())) for _ in range(var_6)]\nvar_1.sort()\nvar_3 = [(6007) * [0] for _ in range(var_6 + 1)]\nvar_3[0][0] = 0\nvar_2 = 0\nfor var_4 in range(var_6):\n for var_5 in range(6007):\n var_3[var_4 + 1][var_5] = max(var_3[var_4 + 1][var_5], var_3[var_4][var_5])\n if var_5 < var_7:\n var_3[var_4 + 1][var_5 + var_1[var_4][0]] = max(\n var_3[var_4][var_5] + var_1[var_4][1],\n var_3[var_4][var_5 + var_1[var_4][0]],\n )\n var_2 = max(var_2, var_3[var_4 + 1][var_5])\nprint(var_2)\n```\n\n=== Code B (Modified) ===\n```python\nfrom collections import Counter, defaultdict, deque\nfrom heapq import heappop, heappush, heapify\nimport sys, bisect, math, itertools, fractions, pprint\n\nsys.setrecursionlimit(10**8)\nvar_6 = 10**9 + 7\nvar_1 = float(\"inf\")\n\n\ndef func_1():\n return int(sys.stdin.readline())\n\n\ndef func_2():\n return list(map(int, sys.stdin.readline().split()))\n\n\nvar_8, var_11 = func_2()\nvar_17 = [func_2() for _ in range(var_8)]\nvar_10 = var_17[::-1]\nvar_14 = [[0] * var_11 for _ in range(var_8)]\nvar_3 = [[0] * var_11 for _ in range(var_8)]\nfor var_4 in range(var_8 - 1):\n var_16, var_15 = var_17[var_4]\n for var_5 in range(var_11):\n if var_5 < var_16:\n var_14[var_4 + 1][var_5] = var_14[var_4][var_5]\n else:\n var_14[var_4 + 1][var_5] = max(\n var_14[var_4][var_5], var_14[var_4][var_5 - var_16] + var_15\n )\nvar_9 = var_14[var_8 - 1][var_11 - 1] + var_17[var_8 - 1][1]\nfor var_4 in range(var_8 - 1):\n var_16, var_15 = var_10[var_4]\n for var_5 in range(var_11):\n if var_5 < var_16:\n var_3[var_4 + 1][var_5] = var_3[var_4][var_5]\n else:\n var_3[var_4 + 1][var_5] = max(\n var_3[var_4][var_5], var_3[var_4][var_5 - var_16] + var_15\n )\n var_9 = max(var_9, var_3[var_8 - 1][var_11 - 1] + var_17[0][1])\n\nfor var_4 in range(1, var_8 - 1):\n var_13 = var_4\n var_2 = var_8 - var_4 - 1\n var_7 = 0\n for var_5 in range(var_11):\n var_12 = var_14[var_13][var_5] + var_3[var_2][var_11 - 1 - var_5]\n var_7 = max(var_7, var_12)\n var_9 = max(var_9, var_7 + var_17[var_4][1])\nprint(var_9)\n```", "output": "FASTER 4.7197", "pair_id": "python_p02863_pair0051_forward", "problem_id": "p02863", "language": "python", "direction": "forward", "speedup_ratio": 26.3491} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_2 = int(eval(input()))\n(*var_1,) = list(map(int, input().split()))\nvar_5 = 0\nfor var_3 in var_1:\n if var_3 % 2 == 0:\n var_5 += 1\nvar_4 = 3**var_2 - 2**var_5\nprint(var_4)\n```\n\n=== Code B (Modified) ===\n```python\nimport math\nimport string\n\n\ndef func_5():\n return list(map(int, input().split()))\n\n\ndef func_4(var_7, var_8):\n return math.factorial(var_7) // (\n math.factorial(var_7 - var_8) * math.factorial(var_8)\n )\n\n\ndef func_3(var_10):\n var_9 = []\n for var_5 in var_10:\n if not (var_5 in var_9):\n var_9.append(var_5)\n return len(var_10) != len(var_9)\n\n\ndef func_1(var_7):\n func_1 = []\n for var_4 in range(1, var_7 + 1):\n if var_7 % var_4 == 0:\n func_1.append(var_4)\n return func_1\n\n\nvar_2 = [-1, -1, -1, 0, 0, 1, 1, 1]\nvar_3 = [-1, 0, 1, -1, 1, -1, 0, 1]\nvar_7 = int(eval(input()))\nvar_1 = func_5()\n\n\ndef func_2(var_6):\n if len(var_6) == var_7:\n for var_4 in range(len(var_6)):\n if var_6[var_4] % 2 == 0:\n return 1\n return 0\n return (\n func_2(var_6 + [var_1[len(var_6)]])\n + func_2(var_6 + [var_1[len(var_6)] - 1])\n + func_2(var_6 + [var_1[len(var_6)] + 1])\n )\n\n\nprint((func_2([])))\n```", "output": "SLOWER 7.6454", "pair_id": "python_p03568_pair0037_reversed", "problem_id": "p03568", "language": "python", "direction": "reversed", "speedup_ratio": 200.2176} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_5 in range(var_1, var_2 + 1):\n var_3 = str(var_5)\n if var_3[0] == var_3[-1] and var_3[1] == var_3[-2]:\n var_4 += 1\nprint(var_4)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_6 in range(var_1, var_2 + 1):\n var_3 = str(var_6)\n var_5 = True\n for var_7 in range(len(var_3) // 2):\n if var_3[var_7] != var_3[-var_7 - 1] and var_5:\n var_5 = not var_5\n if var_5:\n var_4 += 1\nprint(var_4)\n```", "output": "SLOWER 1.5515", "pair_id": "python_p03416_pair0111_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 2.9313} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport bisect, copy, heapq, math, sys\nfrom collections import *\nfrom functools import lru_cache\nfrom itertools import accumulate, combinations, permutations, product\n\n\ndef func_2():\n return sys.stdin.readline()[:-1]\n\n\ndef func_4(var_8):\n return [0] + list(accumulate(var_8))\n\n\ndef func_1(var_1, var_4):\n return -(-var_1 // var_4)\n\n\nsys.setrecursionlimit(5000000)\nvar_9 = pow(10, 9) + 7\nvar_2 = [chr(ord(\"a\") + var_6) for var_6 in range(26)]\nvar_5 = [[1, 0], [0, 1], [-1, 0], [0, -1]]\nvar_11 = int(eval(func_2()))\n\n\ndef func_3(var_10):\n if var_10 == 1:\n return False\n for var_7 in range(2, int(math.sqrt(var_10)) + 1):\n if var_10 % var_7 == 0:\n return False\n return True\n\n\nvar_3 = var_11\nwhile not func_3(var_3):\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nfrom math import sqrt\n\nvar_2 = int(eval(input()))\n\n\ndef func_1(var_2):\n if var_2 < 2:\n return False\n for var_1 in range(2, int(sqrt(var_2)) + 1):\n if var_2 % var_1 == 0:\n return False\n return True\n\n\nwhile not func_1(var_2):\n var_2 += 1\nprint(var_2)\n```", "output": "FASTER 1.442", "pair_id": "python_p02819_pair0006_forward", "problem_id": "p02819", "language": "python", "direction": "forward", "speedup_ratio": 2.717} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = str(var_4)\n if var_5[0] == var_5[4] and var_5[1] == var_5[3]:\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n if str(var_4) == \"\".join(reversed(str(var_4))):\n var_3 += 1\nprint(var_3)\n```", "output": "SLOWER 1.3424", "pair_id": "python_p03416_pair0067_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 2.5357} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport copy\n\nvar_8 = int(eval(input()))\nvar_10 = set([var_6 for var_6 in range(1, 10**5)])\nvar_5 = []\nvar_11 = {}\nvar_9 = []\nfor var_6 in range(var_8 - 1):\n var_1, var_2 = list(map(int, input().split(\" \")))\n var_5.append([var_1, var_2])\n var_11.setdefault(var_1, []).append(var_2)\n var_9.append([])\nvar_9.append([])\nvar_9.append([])\nvar_7 = 0\nfor var_12 in range(1, var_8 + 1):\n var_14 = var_11.get(var_12, [])\n var_3 = 1\n for var_13 in var_14:\n if var_3 in var_9[var_12]:\n var_3 += 1\n else:\n pass\n var_9[var_13].append(var_3)\n if var_3 >= var_7:\n var_7 = var_3\n var_3 += 1\nprint(var_7)\nfor var_4 in var_5:\n print((var_9[var_4[1]][0]))\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\nfrom collections import deque\n\n\ndef func_1():\n var_7 = int(sys.stdin.readline().rstrip())\n var_3 = list(map(int, sys.stdin.read().split()))\n var_3 = list(zip(var_3, var_3))\n var_1 = [[] for _ in range(var_7 + 1)]\n for var_2, var_4 in var_3:\n var_1[var_2].append(var_4)\n var_1[var_4].append(var_2)\n var_10 = deque([1])\n var_9 = [None] * (var_7 + 1)\n var_6 = [0] * (var_7 + 1)\n while var_10:\n var_11 = var_10.popleft()\n var_8 = var_6[var_11]\n var_5 = 1\n for var_12 in var_1[var_11]:\n if var_12 == var_9[var_11]:\n continue\n var_9[var_12] = var_11\n if var_5 == var_8:\n var_5 += 1\n var_6[var_12] = var_5\n var_10.append(var_12)\n var_5 += 1\n print((max(var_6)))\n for var_2, var_4 in var_3:\n if var_2 == var_9[var_4]:\n print((var_6[var_4]))\n else:\n print((var_6[var_2]))\n\n\nif __name__ == \"__main__\":\n func_1()\n```", "output": "FASTER 4.4037", "pair_id": "python_p02850_pair0026_forward", "problem_id": "p02850", "language": "python", "direction": "forward", "speedup_ratio": 21.1661} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = str(var_4)\n if var_5[0] == var_5[4] and var_5[1] == var_5[3]:\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_3 in range(var_1, var_2 + 1):\n var_5 = list(str(var_3))\n var_6 = list(reversed(var_5))\n if var_5 == var_6:\n var_4 += 1\nprint(var_4)\n```", "output": "SLOWER 1.5748", "pair_id": "python_p03416_pair0191_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 2.9789} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_5 in range(10):\n for var_6 in range(10):\n for var_7 in range(10):\n var_3 = 10000 * var_5 + 1000 * var_6 + 100 * var_7 + 10 * var_6 + var_5\n if var_1 <= var_3 <= var_2:\n var_4 += 1\nprint(var_4)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\n\n\ndef func_1(var_5, var_6):\n var_4 = 0\n for var_3 in range(var_5, var_6 + 1):\n if str(var_3) == str(var_3)[::-1]:\n var_4 += 1\n return var_4\n\n\nprint((func_1(var_1, var_2)))\n```", "output": "SLOWER 3.5019", "pair_id": "python_p03416_pair0175_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 11.3289} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\nimport itertools\n\n\ndef func_2(var_4):\n return bin(eval(\"0b\" + str(var_4)))\n\n\ndef func_1():\n var_4 = int(sys.stdin.readline().rstrip())\n var_9 = [\n func_2(\"\".join(str(var_10) for var_10 in sys.stdin.readline().split()))\n for _ in range(var_4)\n ]\n var_8 = [\n [int(var_10) for var_10 in sys.stdin.readline().split()] for _ in range(var_4)\n ]\n var_3 = -(10**10)\n for var_6 in itertools.product(\"01\", repeat=10):\n var_6 = func_2(\"\".join(var_6))\n if var_6 == \"0b0\":\n continue\n var_7 = 0\n for var_2 in range(var_4):\n var_1 = var_9[var_2]\n var_5 = bin(eval(var_1) & eval(var_6)).count(\"1\")\n var_7 += var_8[var_2][var_5]\n var_3 = max(var_3, var_7)\n print(var_3)\n\n\nif __name__ == \"__main__\":\n\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nfrom sys import stdin\n\n\ndef func_1():\n\n var_13 = stdin.readline\n var_2 = int(var_13())\n var_1 = []\n for var_6 in range(var_2):\n var_5 = list(map(int, var_13().split()))\n var_1.append(var_5)\n var_3 = []\n for var_6 in range(var_2):\n var_12 = list(map(int, var_13().split()))\n var_3.append(var_12)\n var_9 = -float(\"inf\")\n for var_6 in range(1 << 10):\n if var_6 == 0:\n continue\n else:\n var_11 = []\n for var_7 in range(10):\n if (var_6 >> var_7) & 1:\n var_11.append(var_7)\n var_10 = [0] * 10\n for var_7 in var_11:\n var_10[var_7] = 1\n var_14 = 0\n for var_7 in range(var_2):\n var_4 = 0\n for var_8 in range(10):\n if var_10[var_8] == 1 and var_1[var_7][var_8] == 1:\n var_4 += 1\n var_14 += var_3[var_7][var_4]\n var_9 = max(var_14, var_9)\n print(var_9)\n\n\nif __name__ == \"__main__\":\n func_1()\n```", "output": "FASTER 3.3644", "pair_id": "python_p03503_pair0038_forward", "problem_id": "p03503", "language": "python", "direction": "forward", "speedup_ratio": 10.2989} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nfrom sys import stdin\n\n\ndef func_1():\n\n var_9 = stdin.readline\n var_8, var_10 = list(map(int, var_9().split()))\n var_7 = [list(map(int, var_9().split())) for _ in range(var_8)]\n var_7.sort()\n var_1 = [0] * var_8\n var_2 = [0] * var_8\n for var_4 in range(var_8):\n var_1[var_4], var_2[var_4] = var_7[var_4][0], var_7[var_4][1]\n\n var_5 = -float(\"inf\")\n var_3 = [[var_5] * (var_10 + 1) for _ in range(var_8 + 1)]\n var_3[0][0] = 0\n for var_4 in range(var_8):\n for var_6 in range(var_10 + 1):\n\n if var_6 != var_10:\n var_3[var_4 + 1][min(var_10, var_6 + var_1[var_4])] = max(\n var_3[var_4 + 1][min(var_10, var_6 + var_1[var_4])],\n var_3[var_4][var_6] + var_2[var_4],\n )\n\n var_3[var_4 + 1][var_6] = max(var_3[var_4 + 1][var_6], var_3[var_4][var_6])\n print((max(var_3[var_8])))\n\n\nif __name__ == \"__main__\":\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nfrom collections import Counter, defaultdict, deque\nfrom heapq import heappop, heappush, heapify\nimport sys, bisect, math, itertools, fractions, pprint\n\nsys.setrecursionlimit(10**8)\nvar_6 = 10**9 + 7\nvar_1 = float(\"inf\")\n\n\ndef func_1():\n return int(sys.stdin.readline())\n\n\ndef func_2():\n return list(map(int, sys.stdin.readline().split()))\n\n\nvar_7, var_9 = func_2()\nvar_13 = [func_2() for _ in range(var_7)]\nvar_13.sort(key=lambda var_14: var_14[1], reverse=True)\nvar_8 = 0\nvar_10 = min(var_7, 5)\nfor var_3 in range(var_10):\n var_2 = [[0] * (var_9 + 5) for _ in range(var_7 + 5)]\n for var_4 in range(var_7):\n var_12, var_11 = var_13[var_4]\n for var_5 in range(var_9):\n if var_5 < var_12 or var_3 == var_4:\n var_2[var_4 + 1][var_5] = var_2[var_4][var_5]\n else:\n var_2[var_4 + 1][var_5] = max(\n var_2[var_4][var_5], var_2[var_4][var_5 - var_12] + var_11\n )\n\n var_8 = max(var_2[var_7][var_9 - 1] + var_13[var_3][1], var_8)\nprint(var_8)\n```", "output": "SLOWER 1.7184", "pair_id": "python_p02863_pair0052_reversed", "problem_id": "p02863", "language": "python", "direction": "reversed", "speedup_ratio": 3.2907} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_8 in range(var_1, var_2 + 1):\n var_7 = str(var_8)\n var_6 = len(var_7)\n var_4 = True\n for var_5 in range(var_6 // 2):\n if var_7[var_5] != var_7[var_6 - 1 - var_5]:\n var_4 = False\n break\n if var_4:\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = str(var_4)\n if var_5 == var_5[::-1]:\n var_3 += 1\nprint(var_3)\n```", "output": "FASTER 1.1307", "pair_id": "python_p03416_pair0192_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 2.1897} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().strip().split(\" \")))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n if str(var_4) == str(var_4)[::-1]:\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\ndef func_1():\n var_1, var_2 = list(map(int, input().rstrip().split()))\n var_3 = 0\n for var_4 in range(var_1, var_2 + 1):\n var_5 = str(var_4)\n if var_5 == var_5[::-1]:\n var_3 += 1\n print(var_3)\n\n\nif __name__ == \"__main__\":\n func_1()\n```", "output": "FASTER 1.0533", "pair_id": "python_p03416_pair0127_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 2.0752} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = [0] * (var_2 + 1)\nfor var_3 in range(1, var_2 + 1):\n if str(var_3) == str(var_3)[::-1]:\n var_4[var_3] = var_4[var_3 - 1] + 1\n else:\n var_4[var_3] = var_4[var_3 - 1]\nprint((var_4[var_2] - var_4[var_1 - 1]))\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = str(var_4)\n if var_5 == var_5[::-1]:\n var_3 += 1\nprint(var_3)\n```", "output": "FASTER 1.9467", "pair_id": "python_p03416_pair0048_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 3.855} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = str(var_4)\n if var_5[0] == var_5[4] and var_5[1] == var_5[3]:\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_6 in range(var_1, var_2 + 1):\n var_3 = str(var_6)\n var_5 = True\n for var_7 in range(len(var_3) // 2):\n if var_3[var_7] != var_3[-var_7 - 1] and var_5:\n var_5 = not var_5\n if var_5:\n var_4 += 1\nprint(var_4)\n```", "output": "SLOWER 1.7261", "pair_id": "python_p03416_pair0193_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 3.3083} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\n\nvar_9 = sys.stdin.readline\nfrom operator import itemgetter\n\nvar_3, var_4 = list(map(int, var_9().split()))\nvar_1 = [list(map(int, var_9().split())) for _ in range(var_3)]\nvar_1.sort(key=itemgetter(0))\nvar_8 = [[0 for _ in range(var_3 + 1)] for _ in range(var_4 + 1)]\n\nvar_2 = []\nfor var_10 in range(var_3):\n var_5, var_7 = var_1[var_10]\n for var_11 in range(var_4):\n if var_5 > var_11:\n var_8[var_11][var_10 + 1] = var_8[var_11][var_10]\n else:\n if var_7 + var_8[var_11 - var_5][var_10] >= var_8[var_11][var_10]:\n var_8[var_11][var_10 + 1] = var_8[var_11 - var_5][var_10] + var_7\n else:\n var_8[var_11][var_10 + 1] = var_8[var_11][var_10]\n var_2.append(var_8[var_4 - 1][var_10] + var_7)\nvar_6 = max(var_2)\nprint(var_6)\n```\n\n=== Code B (Modified) ===\n```python\nfrom collections import Counter, defaultdict, deque\nfrom heapq import heappop, heappush, heapify\nimport sys, bisect, math, itertools, fractions, pprint\n\nsys.setrecursionlimit(10**8)\nvar_6 = 10**9 + 7\nvar_1 = float(\"inf\")\n\n\ndef func_1():\n return int(sys.stdin.readline())\n\n\ndef func_2():\n return list(map(int, sys.stdin.readline().split()))\n\n\nvar_7, var_9 = func_2()\nvar_13 = [func_2() for _ in range(var_7)]\nvar_13.sort(key=lambda var_14: var_14[1], reverse=True)\nvar_8 = 0\nvar_10 = min(var_7, 5)\nfor var_3 in range(var_10):\n var_2 = [[0] * (var_9 + 5) for _ in range(var_7 + 5)]\n for var_4 in range(var_7):\n var_12, var_11 = var_13[var_4]\n for var_5 in range(var_9):\n if var_5 < var_12 or var_3 == var_4:\n var_2[var_4 + 1][var_5] = var_2[var_4][var_5]\n else:\n var_2[var_4 + 1][var_5] = max(\n var_2[var_4][var_5], var_2[var_4][var_5 - var_12] + var_11\n )\n\n var_8 = max(var_2[var_7][var_9 - 1] + var_13[var_3][1], var_8)\nprint(var_8)\n```", "output": "SLOWER 1.6625", "pair_id": "python_p02863_pair0001_reversed", "problem_id": "p02863", "language": "python", "direction": "reversed", "speedup_ratio": 3.1657} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nfrom collections import deque\n\n\ndef func_2(var_9, var_2, var_4):\n\n var_6 = {var_7: dict() for var_7 in range(var_9)}\n for var_7 in range(var_9 - 1):\n var_1, var_3 = var_2[var_7] - 1, var_4[var_7] - 1\n var_6[var_1][var_3] = -1\n var_6[var_3][var_1] = -1\n var_8 = max([len(var_6[var_1]) for var_1 in range(var_9)])\n var_14 = [-1] * var_9\n var_14[0] = var_8 - 1\n\n var_12 = deque([0])\n while len(var_12) > 0:\n var_10 = var_12.popleft()\n var_5 = var_14[var_10]\n for var_11 in list(var_6[var_10].keys()):\n if var_14[var_11] != -1:\n continue\n var_5 += 1\n var_5 %= var_8\n\n var_6[var_10][var_11] = var_5\n var_6[var_11][var_10] = var_5\n var_14[var_11] = var_5\n var_12.append(var_11)\n var_13 = [0] * (var_9 - 1)\n for var_7 in range(var_9 - 1):\n var_13[var_7] = var_6[var_2[var_7] - 1][var_4[var_7] - 1] + 1\n return var_8, var_13\n\n\ndef func_1():\n var_9 = int(eval(input()))\n var_2 = [0] * (var_9 - 1)\n var_4 = [0] * (var_9 - 1)\n for var_7 in range(var_9 - 1):\n var_1, var_3 = list(map(int, input().split()))\n var_2[var_7] = var_1\n var_4[var_7] = var_3\n var_8, var_13 = func_2(var_9, var_2, var_4)\n print(var_8)\n for var_7 in range(var_9 - 1):\n print((var_13[var_7]))\n\n\ndef func_3():\n print((func_2(3, [1, 2], [2, 3])))\n print((func_2(8, [1, 2, 2, 2, 4, 5, 6], [2, 3, 4, 5, 7, 6, 8])))\n\n\nif __name__ == \"__main__\":\n\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\n\nvar_8 = sys.stdin.readline\nvar_9 = int(eval(var_8()))\nvar_6 = []\nfor var_7 in range(var_9 - 1):\n var_1, var_3 = list(map(int, var_8().split()))\n var_6.append([var_1 - 1, var_3 - 1, var_7])\nvar_6.sort()\nvar_13 = [0] * (var_9)\nvar_2 = [0] * (var_9 - 1)\nvar_10 = 1\nvar_11 = 0\nfor var_5 in var_6:\n _from, var_12, var_7 = var_5\n if _from != var_11:\n var_10 = 1\n if var_13[_from] == var_10:\n var_10 += 1\n var_2[var_7] = var_10\n var_13[var_12] = var_10\n var_10 += 1\n var_11 = _from\nprint((max(var_2)))\nfor var_4 in var_2:\n print(var_4)\n```", "output": "FASTER 1.2025", "pair_id": "python_p02850_pair0012_forward", "problem_id": "p02850", "language": "python", "direction": "forward", "speedup_ratio": 2.3014} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\ndef func_1():\n from sys import setrecursionlimit, stdin\n from os import environ\n from collections import defaultdict, deque, Counter\n from math import ceil, floor, gcd\n from itertools import accumulate, combinations, combinations_with_replacement\n\n setrecursionlimit(10**6)\n var_7 = (\n (lambda *var_11: print(*var_11))\n if \"TERM_PROGRAM\" in environ\n else lambda *var_12: 0\n )\n var_8 = lambda: stdin.readline().rstrip()\n var_3 = lambda: list(map(int, var_8().split()))\n var_1 = lambda: int(var_8())\n var_4 = 10**9 + 7\n var_2 = 10**9 + 10\n var_9, var_10 = var_8().split()\n var_5 = int(var_9)\n var_6 = int(float(var_10) * 100 + 0.5)\n print(var_5 * var_6 // 100)\n\n\nfunc_1()\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = input().split()\nvar_1 = int(var_1)\nvar_2 = int(\"\".join(var_2.split(\".\")))\nprint(((var_1 * var_2) // 100))\n```", "output": "FASTER 2.2081", "pair_id": "python_p02659_pair0053_forward", "problem_id": "p02659", "language": "python", "direction": "forward", "speedup_ratio": 4.6207} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_4, var_3 = list(map(int, input().split()))\nvar_1 = 0\nfor var_2 in range(var_4, var_3 + 1):\n if str(var_2)[0] + str(var_2)[1] == str(var_2)[-1] + str(var_2)[-2]:\n var_1 += 1\nprint(var_1)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().strip().split(\" \")))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n if str(var_4) == str(var_4)[::-1]:\n var_3 += 1\nprint(var_3)\n```", "output": "FASTER 1.0338", "pair_id": "python_p03416_pair0060_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 2.0474} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = input().split()\nvar_1 = int(var_1)\nvar_2 = int(var_2)\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = list(str(var_4))\n if (var_5[0] == var_5[4]) and (var_5[1] == var_5[3]):\n var_3 = var_3 + 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_6 in range(var_1, var_2 + 1):\n var_3 = str(var_6)\n var_5 = True\n for var_7 in range(len(var_3) // 2):\n if var_3[var_7] != var_3[-var_7 - 1] and var_5:\n var_5 = not var_5\n if var_5:\n var_4 += 1\nprint(var_4)\n```", "output": "SLOWER 1.0556", "pair_id": "python_p03416_pair0145_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 2.0786} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = list(reversed(list(str(var_4))))\n if var_5 == list(str(var_4)):\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = [\n var_3 for var_3 in map(str, list(range(var_1, var_2 + 1))) if var_3 == var_3[::-1]\n]\nprint((len(var_4)))\n```", "output": "FASTER 2.3555", "pair_id": "python_p03416_pair0194_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 5.1178} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_6, var_5 = list(map(int, input().split(\" \")))\nvar_2 = [list(map(int, input().split(\" \"))) for _ in range(var_5)]\nvar_2.sort(key=lambda var_7: var_7[1])\nvar_4 = 0\nvar_7 = 0\nfor var_1, var_3 in var_2:\n if var_1 <= var_7 < var_3:\n continue\n var_7 = var_3 - 1\n var_4 += 1\nprint(var_4)\n```\n\n=== Code B (Modified) ===\n```python\nvar_2, var_1 = [int(var_12) for var_12 in input().split()]\nvar_3 = []\nfor var_8 in range(var_1):\n var_5, var_6 = [int(var_12) for var_12 in input().split()]\n var_3.append((var_5, var_6))\nvar_3.sort()\nvar_9 = float(\"inf\")\nvar_4 = [var_9 for var_5 in range(var_2 + 1)]\nfor var_5, var_6 in var_3:\n var_4[var_5] = min(var_4[var_5], var_6)\nvar_3 = [\n (var_5, var_4[var_5]) for var_5 in range(1, var_2 + 1) if var_4[var_5] != var_9\n]\nvar_3.sort(key=lambda var_11: var_11[1])\nvar_7 = [True] * (var_2)\nvar_10 = None\nfor var_5, var_6 in var_3:\n if var_10 == None or var_10 < var_5:\n var_7[var_6 - 1] = False\n var_10 = var_6 - 1\nprint((sum(1 for var_6 in var_7 if not var_6)))\n```", "output": "SLOWER 1.0353", "pair_id": "python_p03295_pair0001_reversed", "problem_id": "p03295", "language": "python", "direction": "reversed", "speedup_ratio": 2.0495} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\ndef func_1():\n var_1, var_2 = list(map(int, input().rstrip().split()))\n var_3 = 0\n for var_4 in range(var_1, var_2 + 1):\n var_5 = str(var_4)\n if var_5 == var_5[::-1]:\n var_3 += 1\n print(var_3)\n\n\nif __name__ == \"__main__\":\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_8 in range(var_1, var_2 + 1):\n var_7 = str(var_8)\n var_6 = len(var_7)\n var_4 = True\n for var_5 in range(var_6 // 2):\n if var_7[var_5] != var_7[var_6 - 1 - var_5]:\n var_4 = False\n break\n if var_4:\n var_3 += 1\nprint(var_3)\n```", "output": "SLOWER 1.8722", "pair_id": "python_p03416_pair0195_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 3.661} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = input().split()\nvar_1 = int(var_1)\nvar_3, var_4 = list(map(int, var_2.split(\".\")))\nvar_5 = var_1 * (var_3 * 100 + var_4)\nprint((int(var_5 // 100)))\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\nimport math\nfrom collections import defaultdict\nfrom bisect import bisect_left, bisect_right\n\nsys.setrecursionlimit(10**7)\n\n\ndef func_4():\n return sys.stdin.readline()[:-1]\n\n\nvar_4 = 10**9 + 7\n\n\ndef func_1():\n return int(eval(func_4()))\n\n\ndef func_2():\n return list(map(int, func_4().split()))\n\n\ndef func_3(var_6, var_3):\n if var_6 <= 0:\n return [[] for _ in range(var_3)]\n elif var_3 == 1:\n return [func_1() for _ in range(var_6)]\n else:\n var_5 = [func_2() for _ in range(var_6)]\n return list(map(list, list(zip(*var_5))))\n\n\nfrom decimal import getcontext, Decimal\n\ngetcontext().prec = 28\nvar_1, var_2 = list(map(str, func_4().split()))\nvar_1 = int(var_1)\nvar_2 = Decimal(var_2)\nprint((int(var_1 * var_2)))\n```", "output": "SLOWER 2.0589", "pair_id": "python_p02659_pair0042_reversed", "problem_id": "p02659", "language": "python", "direction": "reversed", "speedup_ratio": 4.1668} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = list(reversed(list(str(var_4))))\n if var_5 == list(str(var_4)):\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = str(var_4)\n if var_5[0] == var_5[4] and var_5[1] == var_5[3]:\n var_3 += 1\nprint(var_3)\n```", "output": "FASTER 1.9231", "pair_id": "python_p03416_pair0066_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 3.7924} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\nfrom operator import itemgetter\nfrom heapq import heapify, heappop, heappush\n\nvar_1 = int(10e15)\nvar_2 = -var_1\nvar_11 = 1000000007\nsys.setrecursionlimit(1000000)\n\n\ndef func_2():\n return list(map(int, input().split()))\n\n\ndef func_4():\n return input().split()\n\n\ndef func_1():\n return int(sys.stdin.readline())\n\n\ndef func_3():\n return eval(input())\n\n\nvar_3, var_4 = func_2()\nvar_5 = [func_2() for var_9 in range(var_3)]\nvar_5.sort(key=itemgetter(0))\n\nvar_8 = [[0] * (var_4 + 1 + 3000 + 1) for _ in range(var_3 + 1)]\nvar_6 = 0\nfor var_9 in range(var_3):\n for var_10 in range(var_4 + 1 + 3000 + 1):\n var_12, var_7 = var_5[var_9]\n if 0 <= var_10 - var_12 < var_4:\n var_8[var_9 + 1][var_10] = max(\n var_8[var_9][var_10], var_8[var_9][var_10 - var_12] + var_7\n )\n else:\n var_8[var_9 + 1][var_10] = var_8[var_9][var_10]\n var_6 = max(var_6, var_8[var_9 + 1][var_10])\nprint(var_6)\n```\n\n=== Code B (Modified) ===\n```python\nvar_8, var_9 = list(map(int, input().split()))\nvar_5 = [[0] * (var_9 + 3001) for _ in range(var_8 + 1)]\nvar_3 = 0\nvar_2 = [list(map(int, input().split())) for _ in range(var_8)]\nvar_2.sort()\nfor var_6 in range(1, var_8 + 1):\n var_1, var_4 = var_2[var_6 - 1]\n for var_7 in range(var_9):\n var_5[var_6][var_7] = max(var_5[var_6 - 1][var_7], var_5[var_6][var_7])\n var_5[var_6][var_7 + var_1] = var_5[var_6 - 1][var_7] + var_4\n var_3 = max(var_5[var_6][var_7], var_5[var_6][var_7 + var_1], var_3)\nprint(var_3)\n```", "output": "FASTER 4.3053", "pair_id": "python_p02863_pair0053_forward", "problem_id": "p02863", "language": "python", "direction": "forward", "speedup_ratio": 19.7702} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_3 in range(var_1, var_2 + 1):\n var_5 = list(str(var_3))\n var_6 = list(reversed(var_5))\n if var_5 == var_6:\n var_4 += 1\nprint(var_4)\n```\n\n=== Code B (Modified) ===\n```python\nvar_4 = {}\nvar_5 = 0\nfor var_6 in range(10000, 100000):\n var_3 = list(str(var_6))\n if var_3 == list(reversed(var_3)):\n var_5 += 1\n var_4[var_6] = var_5\nvar_1, var_2 = list(map(int, input().split()))\nprint((var_4[var_2] - var_4[var_1 - 1] if var_1 > 10000 else var_4[var_2]))\n```", "output": "SLOWER 2.265", "pair_id": "python_p03416_pair0196_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 4.8064} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport math\n\nvar_1, var_2 = input().split()\nvar_1 = int(var_1)\nvar_3 = int(var_2[0] + var_2[2] + var_2[3])\nprint((var_1 * var_3 // 100))\n```\n\n=== Code B (Modified) ===\n```python\ndef func_1():\n from sys import setrecursionlimit, stdin\n from os import environ\n from collections import defaultdict, deque, Counter\n from math import ceil, floor, gcd\n from itertools import accumulate, combinations, combinations_with_replacement\n\n setrecursionlimit(10**6)\n var_7 = (\n (lambda *var_11: print(*var_11))\n if \"TERM_PROGRAM\" in environ\n else lambda *var_12: 0\n )\n var_8 = lambda: stdin.readline().rstrip()\n var_3 = lambda: list(map(int, var_8().split()))\n var_1 = lambda: int(var_8())\n var_4 = 10**9 + 7\n var_2 = 10**9 + 10\n var_9, var_10 = var_8().split()\n var_5 = int(var_9)\n var_10 = var_10.split(\".\")\n var_6 = int(var_10[0]) * 100\n if len(var_10) == 2:\n var_6 += int(var_10[1])\n print(var_5 * var_6 // 100)\n\n\nfunc_1()\n```", "output": "SLOWER 2.2041", "pair_id": "python_p02659_pair0054_reversed", "problem_id": "p02659", "language": "python", "direction": "reversed", "speedup_ratio": 4.6079} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nfrom collections import deque\n\n\ndef func_2(var_9, var_2, var_4):\n\n var_6 = {var_7: dict() for var_7 in range(var_9)}\n for var_7 in range(var_9 - 1):\n var_1, var_3 = var_2[var_7] - 1, var_4[var_7] - 1\n var_6[var_1][var_3] = -1\n var_6[var_3][var_1] = -1\n var_8 = max([len(var_6[var_1]) for var_1 in range(var_9)])\n var_14 = [-1] * var_9\n var_14[0] = var_8 - 1\n\n var_12 = deque([0])\n while len(var_12) > 0:\n var_10 = var_12.popleft()\n var_5 = var_14[var_10]\n for var_11 in list(var_6[var_10].keys()):\n if var_14[var_11] != -1:\n continue\n var_5 += 1\n var_5 %= var_8\n\n var_6[var_10][var_11] = var_5\n var_6[var_11][var_10] = var_5\n var_14[var_11] = var_5\n var_12.append(var_11)\n var_13 = [0] * (var_9 - 1)\n for var_7 in range(var_9 - 1):\n var_13[var_7] = var_6[var_2[var_7] - 1][var_4[var_7] - 1] + 1\n return var_8, var_13\n\n\ndef func_1():\n var_9 = int(eval(input()))\n var_2 = [0] * (var_9 - 1)\n var_4 = [0] * (var_9 - 1)\n for var_7 in range(var_9 - 1):\n var_1, var_3 = list(map(int, input().split()))\n var_2[var_7] = var_1\n var_4[var_7] = var_3\n var_8, var_13 = func_2(var_9, var_2, var_4)\n print(var_8)\n for var_7 in range(var_9 - 1):\n print((var_13[var_7]))\n\n\ndef func_3():\n print((func_2(3, [1, 2], [2, 3])))\n print((func_2(8, [1, 2, 2, 2, 4, 5, 6], [2, 3, 4, 5, 7, 6, 8])))\n\n\nif __name__ == \"__main__\":\n\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nimport copy\n\nvar_8 = int(eval(input()))\nvar_10 = set([var_6 for var_6 in range(1, 10**5)])\nvar_5 = []\nvar_11 = {}\nvar_9 = []\nfor var_6 in range(var_8 - 1):\n var_1, var_2 = list(map(int, input().split(\" \")))\n var_5.append([var_1, var_2])\n var_11.setdefault(var_1, []).append(var_2)\n var_9.append([])\nvar_9.append([])\nvar_9.append([])\nvar_7 = 0\nfor var_12 in range(1, var_8 + 1):\n var_14 = var_11.get(var_12, [])\n var_3 = 1\n for var_13 in var_14:\n if var_3 in var_9[var_12]:\n var_3 += 1\n else:\n pass\n var_9[var_13].append(var_3)\n if var_3 >= var_7:\n var_7 = var_3\n var_3 += 1\nprint(var_7)\nfor var_4 in var_5:\n print((var_9[var_4[1]][0]))\n```", "output": "SLOWER 3.6429", "pair_id": "python_p02850_pair0022_reversed", "problem_id": "p02850", "language": "python", "direction": "reversed", "speedup_ratio": 12.4917} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\n\n\ndef func_1(var_5):\n var_4 = 0\n for var_3 in range(1, var_5 + 1):\n if str(var_3) == str(var_3)[::-1]:\n var_4 += 1\n return var_4\n\n\nprint((func_1(var_2) - func_1(var_1 - 1)))\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = input().split()\nvar_1 = int(var_1)\nvar_2 = int(var_2)\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = list(str(var_4))\n if (var_5[0] == var_5[4]) and (var_5[1] == var_5[3]):\n var_3 = var_3 + 1\nprint(var_3)\n```", "output": "FASTER 1.1863", "pair_id": "python_p03416_pair0197_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 2.2757} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nfrom collections import Counter, defaultdict, deque\nfrom heapq import heappop, heappush, heapify\nimport sys, bisect, math, itertools, fractions, pprint\n\nsys.setrecursionlimit(10**8)\nvar_6 = 10**9 + 7\nvar_1 = float(\"inf\")\n\n\ndef func_1():\n return int(sys.stdin.readline())\n\n\ndef func_2():\n return list(map(int, sys.stdin.readline().split()))\n\n\nvar_8, var_11 = func_2()\nvar_17 = [func_2() for _ in range(var_8)]\nvar_10 = var_17[::-1]\nvar_14 = [[0] * var_11 for _ in range(var_8)]\nvar_3 = [[0] * var_11 for _ in range(var_8)]\nfor var_4 in range(var_8 - 1):\n var_16, var_15 = var_17[var_4]\n for var_5 in range(var_11):\n if var_5 < var_16:\n var_14[var_4 + 1][var_5] = var_14[var_4][var_5]\n else:\n var_14[var_4 + 1][var_5] = max(\n var_14[var_4][var_5], var_14[var_4][var_5 - var_16] + var_15\n )\nvar_9 = var_14[var_8 - 1][var_11 - 1] + var_17[var_8 - 1][1]\nfor var_4 in range(var_8 - 1):\n var_16, var_15 = var_10[var_4]\n for var_5 in range(var_11):\n if var_5 < var_16:\n var_3[var_4 + 1][var_5] = var_3[var_4][var_5]\n else:\n var_3[var_4 + 1][var_5] = max(\n var_3[var_4][var_5], var_3[var_4][var_5 - var_16] + var_15\n )\n var_9 = max(var_9, var_3[var_8 - 1][var_11 - 1] + var_17[0][1])\n\nfor var_4 in range(1, var_8 - 1):\n var_13 = var_4\n var_2 = var_8 - var_4 - 1\n var_7 = 0\n for var_5 in range(var_11):\n var_12 = var_14[var_13][var_5] + var_3[var_2][var_11 - 1 - var_5]\n var_7 = max(var_7, var_12)\n var_9 = max(var_9, var_7 + var_17[var_4][1])\nprint(var_9)\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\n\nsys.setrecursionlimit(2147483647)\nvar_2 = float(\"inf\")\nvar_3 = 10**9 + 7\nvar_10 = lambda: sys.stdin.readline().rstrip()\n\n\ndef func_1():\n var_11, var_4 = list(map(int, var_10().split()))\n var_1 = [tuple(map(int, var_10().split())) for _ in range(var_11)]\n var_1.sort()\n var_8 = [0] * var_4\n var_6 = -var_2\n for var_9 in range(var_11):\n var_5, var_7 = var_1[var_9]\n var_12 = var_8[:]\n for var_13 in range(var_4):\n if var_13 + var_5 < var_4:\n var_12[var_13 + var_5] = max(\n var_12[var_13 + var_5], var_8[var_13] + var_7\n )\n else:\n var_6 = max(var_6, var_8[var_13] + var_7)\n var_8 = var_12\n print((max(var_6, max(var_8))))\n\n\nfunc_1()\n```", "output": "FASTER 2.0401", "pair_id": "python_p02863_pair0044_forward", "problem_id": "p02863", "language": "python", "direction": "forward", "speedup_ratio": 4.1128} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = list(str(var_4))\n if var_5 == list(reversed(var_5)):\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_4 = {}\nvar_5 = 0\nfor var_6 in range(10000, 100000):\n var_3 = list(str(var_6))\n if var_3 == list(reversed(var_3)):\n var_5 += 1\n var_4[var_6] = var_5\nvar_1, var_2 = list(map(int, input().split()))\nprint((var_4[var_2] - var_4[var_1 - 1] if var_1 > 10000 else var_4[var_2]))\n```", "output": "SLOWER 2.3414", "pair_id": "python_p03416_pair0198_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 5.068} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\n\n\ndef func_1(var_5, var_6):\n var_4 = 0\n for var_3 in range(var_5, var_6 + 1):\n if str(var_3) == str(var_3)[::-1]:\n var_4 += 1\n return var_4\n\n\nprint((func_1(var_1, var_2)))\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_3 = list(map(int, input().split()))\nvar_2 = 0\nfor var_5 in range(var_3 + 1)[var_1:]:\n if len(str(var_5)) % 2 == 0:\n var_6 = list(str(var_5))[: len(str(var_5)) // 2]\n var_7 = list(reversed(list(str(var_5))[len(str(var_5)) // 2 :]))\n if var_6 == var_7:\n var_2 += 1\n else:\n var_8 = list(str(var_5))[: len(str(var_5)) // 2 + 1]\n var_4 = list(reversed(list(str(var_5))[len(str(var_5)) // 2 :]))\n if var_8 == var_4:\n var_2 += 1\nprint(var_2)\n```", "output": "SLOWER 2.7982", "pair_id": "python_p03416_pair0199_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 6.9556} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_2 = int(eval(input()))\n(*var_1,) = list(map(int, input().split()))\nvar_5 = 0\nfor var_3 in var_1:\n if var_3 % 2 == 0:\n var_5 += 1\nvar_4 = 3**var_2 - 2**var_5\nprint(var_4)\n```\n\n=== Code B (Modified) ===\n```python\nimport math\nimport string\n\n\ndef func_4():\n return list(map(int, input().split()))\n\n\ndef func_3(var_6, var_7):\n return math.factorial(var_6) // (\n math.factorial(var_6 - var_7) * math.factorial(var_7)\n )\n\n\ndef func_2(var_9):\n var_8 = []\n for var_5 in var_9:\n if not (var_5 in var_8):\n var_8.append(var_5)\n return len(var_9) != len(var_8)\n\n\ndef func_1(var_6):\n func_1 = []\n for var_4 in range(1, var_6 + 1):\n if var_6 % var_4 == 0:\n func_1.append(var_4)\n return func_1\n\n\nvar_2 = [-1, -1, -1, 0, 0, 1, 1, 1]\nvar_3 = [-1, 0, 1, -1, 1, -1, 0, 1]\nvar_6 = int(eval(input()))\nvar_1 = func_4()\nvar_10 = 1\nfor var_4 in range(len(var_1)):\n if var_1[var_4] % 2 == 0:\n var_10 *= 2\n else:\n var_10 *= 1\nprint((3 ** len(var_1) - var_10))\n```", "output": "SLOWER 1.6929", "pair_id": "python_p03568_pair0033_reversed", "problem_id": "p03568", "language": "python", "direction": "reversed", "speedup_ratio": 3.2331} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nfrom collections import Counter, defaultdict, deque\nfrom heapq import heappop, heappush, heapify\nimport sys, bisect, math, itertools, fractions, pprint\n\nsys.setrecursionlimit(10**8)\nvar_6 = 10**9 + 7\nvar_1 = float(\"inf\")\n\n\ndef func_1():\n return int(sys.stdin.readline())\n\n\ndef func_2():\n return list(map(int, sys.stdin.readline().split()))\n\n\nvar_7, var_9 = func_2()\nvar_13 = [func_2() for _ in range(var_7)]\nvar_13.sort(key=lambda var_14: var_14[1], reverse=True)\nvar_8 = 0\nvar_10 = min(var_7, 5)\nfor var_3 in range(var_10):\n var_2 = [[0] * (var_9 + 5) for _ in range(var_7 + 5)]\n for var_4 in range(var_7):\n var_12, var_11 = var_13[var_4]\n for var_5 in range(var_9):\n if var_5 < var_12 or var_3 == var_4:\n var_2[var_4 + 1][var_5] = var_2[var_4][var_5]\n else:\n var_2[var_4 + 1][var_5] = max(\n var_2[var_4][var_5], var_2[var_4][var_5 - var_12] + var_11\n )\n\n var_8 = max(var_2[var_7][var_9 - 1] + var_13[var_3][1], var_8)\nprint(var_8)\n```\n\n=== Code B (Modified) ===\n```python\nimport bisect\nimport sys\n\nsys.setrecursionlimit(10**6)\nvar_17 = sys.stdout.write\nvar_7 = lambda *var_15: print(*var_15) if var_1 else 0\nvar_1 = True\n\n\ndef func_1(var_10=sys.stdin.readline):\n var_12 = lambda: var_10().rstrip()\n var_3 = lambda: list(map(int, var_12().split()))\n var_2 = lambda: int(var_12())\n var_4 = lambda var_18: [var_3() for _ in range(var_18)]\n var_14, var_16 = var_3()\n var_5 = var_4(var_14)\n var_8 = [[0] * var_16 for _ in range(var_14)]\n for var_11 in range(1, var_14):\n for var_13 in range(1, var_16):\n if var_13 < var_5[var_11 - 1][0]:\n var_8[var_11][var_13] = var_8[var_11 - 1][var_13]\n else:\n var_8[var_11][var_13] = max(\n var_8[var_11 - 1][var_13],\n var_8[var_11 - 1][var_13 - var_5[var_11 - 1][0]]\n + var_5[var_11 - 1][1],\n )\n var_9 = [[0] * var_16 for _ in range(var_14)]\n for var_11 in range(1, var_14):\n for var_13 in range(1, var_16):\n if var_13 < var_5[var_14 - var_11][0]:\n var_9[var_11][var_13] = var_9[var_11 - 1][var_13]\n else:\n var_9[var_11][var_13] = max(\n var_9[var_11 - 1][var_13],\n var_9[var_11 - 1][var_13 - var_5[var_14 - var_11][0]]\n + var_5[var_14 - var_11][1],\n )\n var_6 = 0\n for var_11 in range(var_14):\n for var_13 in range(var_16 - 1):\n var_6 = max(\n var_6,\n var_8[var_11][var_13]\n + var_9[var_14 - var_11 - 1][var_16 - var_13 - 1]\n + var_5[var_11][1],\n )\n print(var_6)\n\n\nif __name__ == \"__main__\":\n func_1()\n```", "output": "FASTER 1.236", "pair_id": "python_p02863_pair0054_forward", "problem_id": "p02863", "language": "python", "direction": "forward", "speedup_ratio": 2.3555} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\n\n\ndef func_1(var_5, var_6):\n var_4 = 0\n for var_3 in range(var_5, var_6 + 1):\n if str(var_3) == str(var_3)[::-1]:\n var_4 += 1\n return var_4\n\n\nprint((func_1(var_1, var_2)))\n```\n\n=== Code B (Modified) ===\n```python\nvar_4, var_3 = list(map(int, input().split()))\nvar_1 = 0\nfor var_2 in range(var_4, var_3 + 1):\n if str(var_2)[0] + str(var_2)[1] == str(var_2)[-1] + str(var_2)[-2]:\n var_1 += 1\nprint(var_1)\n```", "output": "SLOWER 1.6647", "pair_id": "python_p03416_pair0200_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 3.1705} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nfrom functools import *\n\n_, var_1 = open(0)\nprint(\n (\n \"YNeos\"[\n var_2(lambda var_3, var_4: var_3 ^ var_4, list(map(int, var_1.split())))\n > 0 :: 2\n ]\n )\n)\n```\n\n=== Code B (Modified) ===\n```python\nfrom collections import defaultdict\n\nvar_8 = int(eval(input()))\nvar_1 = tuple(map(int, input().split()))\nvar_3 = True\nif var_8 % 3 == 0:\n var_5 = defaultdict(int)\n for var_2 in var_1:\n var_5[var_2] += 1\n var_7 = var_8 // 3\n var_10 = []\n for var_9, var_4 in list(var_5.items()):\n if var_4 % var_7 != 0:\n var_3 = False\n break\n else:\n for _ in range(var_4 // var_7):\n var_10.append(var_9)\n else:\n if any(\n var_10[(0 + var_6) % 3] ^ var_10[(1 + var_6) % 3] != var_10[(2 + var_6) % 3]\n for var_6 in range(3)\n ):\n var_3 = False\nelse:\n if any(var_2 != 0 for var_2 in var_1):\n var_3 = False\nprint((\"Yes\" if var_3 else \"No\"))\n```", "output": "SLOWER 1.1419", "pair_id": "python_p02975_pair0002_reversed", "problem_id": "p02975", "language": "python", "direction": "reversed", "speedup_ratio": 2.2067} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_3 = list(map(int, input().split()))\nvar_2 = 0\nfor var_5 in range(var_3 + 1)[var_1:]:\n if len(str(var_5)) % 2 == 0:\n var_6 = list(str(var_5))[: len(str(var_5)) // 2]\n var_7 = list(reversed(list(str(var_5))[len(str(var_5)) // 2 :]))\n if var_6 == var_7:\n var_2 += 1\n else:\n var_8 = list(str(var_5))[: len(str(var_5)) // 2 + 1]\n var_4 = list(reversed(list(str(var_5))[len(str(var_5)) // 2 :]))\n if var_8 == var_4:\n var_2 += 1\nprint(var_2)\n```\n\n=== Code B (Modified) ===\n```python\ndef func_1():\n var_1, var_2 = list(map(int, input().split()))\n var_3 = 0\n for var_4 in range(var_1, var_2 + 1):\n\n if (var_4 % 10) == (var_4 // 10000 % 10) and (var_4 // 10 % 10) == (\n var_4 // 1000 % 10\n ):\n var_3 += 1\n print(var_3)\n\n\nif __name__ == \"__main__\":\n func_1()\n```", "output": "FASTER 4.1386", "pair_id": "python_p03416_pair0162_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 17.6132} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\nimport itertools\n\n\ndef func_2(var_4):\n return bin(eval(\"0b\" + str(var_4)))\n\n\ndef func_1():\n var_4 = int(sys.stdin.readline().rstrip())\n var_9 = [\n func_2(\"\".join(str(var_10) for var_10 in sys.stdin.readline().split()))\n for _ in range(var_4)\n ]\n var_8 = [\n [int(var_10) for var_10 in sys.stdin.readline().split()] for _ in range(var_4)\n ]\n var_3 = -(10**10)\n for var_6 in itertools.product(\"01\", repeat=10):\n var_6 = func_2(\"\".join(var_6))\n if var_6 == \"0b0\":\n continue\n var_7 = 0\n for var_2 in range(var_4):\n var_1 = var_9[var_2]\n var_5 = bin(eval(var_1) & eval(var_6)).count(\"1\")\n var_7 += var_8[var_2][var_5]\n var_3 = max(var_3, var_7)\n print(var_3)\n\n\nif __name__ == \"__main__\":\n\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\nimport itertools\n\n\ndef func_2(var_4):\n return eval(\"0b\" + var_4)\n\n\ndef func_1():\n var_4 = int(sys.stdin.readline().rstrip())\n var_9 = [\n func_2(\"\".join(str(var_10) for var_10 in sys.stdin.readline().split()))\n for _ in range(var_4)\n ]\n var_8 = [\n [int(var_10) for var_10 in sys.stdin.readline().split()] for _ in range(var_4)\n ]\n var_3 = -(10**10)\n for var_6 in itertools.product(\"01\", repeat=10):\n var_6 = func_2(\"\".join(var_6))\n if var_6 == 0:\n continue\n var_7 = 0\n for var_2 in range(var_4):\n var_1 = var_9[var_2]\n var_5 = bin(var_1 & var_6).count(\"1\")\n var_7 += var_8[var_2][var_5]\n var_3 = max(var_3, var_7)\n print(var_3)\n\n\nif __name__ == \"__main__\":\n\n func_1()\n```", "output": "FASTER 2.1735", "pair_id": "python_p03503_pair0039_forward", "problem_id": "p03503", "language": "python", "direction": "forward", "speedup_ratio": 4.5112} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport math\n\nvar_1, var_2 = input().split()\nvar_1 = int(var_1)\nvar_3 = int(var_2[0] + var_2[2] + var_2[3])\nprint((var_1 * var_3 // 100))\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\nimport math\nfrom collections import defaultdict\nfrom bisect import bisect_left, bisect_right\n\nsys.setrecursionlimit(10**7)\n\n\ndef func_4():\n return sys.stdin.readline()[:-1]\n\n\nvar_4 = 10**9 + 7\n\n\ndef func_1():\n return int(eval(func_4()))\n\n\ndef func_2():\n return list(map(int, func_4().split()))\n\n\ndef func_3(var_6, var_3):\n if var_6 <= 0:\n return [[] for _ in range(var_3)]\n elif var_3 == 1:\n return [func_1() for _ in range(var_6)]\n else:\n var_5 = [func_2() for _ in range(var_6)]\n return list(map(list, list(zip(*var_5))))\n\n\nvar_1, var_2 = list(map(str, func_4().split()))\nvar_1 = int(var_1)\nvar_2 = 100 * int(var_2[0]) + 10 * int(var_2[2]) + int(var_2[3])\nprint((var_1 * var_2 // 100))\n```", "output": "SLOWER 2.3564", "pair_id": "python_p02659_pair0004_reversed", "problem_id": "p02659", "language": "python", "direction": "reversed", "speedup_ratio": 5.1208} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\ndef func_1():\n from sys import setrecursionlimit, stdin\n from os import environ\n from collections import defaultdict, deque, Counter\n from math import ceil, floor, gcd\n from itertools import accumulate, combinations, combinations_with_replacement\n\n setrecursionlimit(10**6)\n var_7 = (\n (lambda *var_11: print(*var_11))\n if \"TERM_PROGRAM\" in environ\n else lambda *var_12: 0\n )\n var_8 = lambda: stdin.readline().rstrip()\n var_3 = lambda: list(map(int, var_8().split()))\n var_1 = lambda: int(var_8())\n var_4 = 10**9 + 7\n var_2 = 10**9 + 10\n var_9, var_10 = var_8().split()\n var_5 = int(var_9)\n var_10 = var_10.split(\".\")\n var_6 = int(var_10[0]) * 100\n if len(var_10) == 2:\n var_6 += int(var_10[1])\n print(var_5 * var_6 // 100)\n\n\nfunc_1()\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\n\nvar_3 = sys.stdin.readline\nif __name__ == \"__main__\":\n var_1, var_2 = var_3().split()\n print((int(var_1) * round(float(var_2) * 100) // 100))\n```", "output": "FASTER 2.1103", "pair_id": "python_p02659_pair0021_forward", "problem_id": "p02659", "language": "python", "direction": "forward", "speedup_ratio": 4.3177} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nfrom math import floor\n\nvar_1, var_2 = list(map(int, input().split()))\n\n\nfor var_3 in range(1010):\n if (floor(var_3 * 0.08) == var_1) and (floor(var_3 * 0.1) == var_2):\n\n print(var_3)\n quit()\n\n\nprint((-1))\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_3 = list(map(int, input().split()))\nvar_2 = -1\nfor var_4 in range(10, 12501):\n if int(var_4 * 0.08) == var_1 and int(var_4 * 0.1) == var_3:\n var_2 = var_4\n break\nprint(var_2)\n```", "output": "SLOWER 3.4688", "pair_id": "python_p02755_pair0009_reversed", "problem_id": "p02755", "language": "python", "direction": "reversed", "speedup_ratio": 11.0714} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_4 = {}\nvar_5 = 0\nfor var_6 in range(10000, 100000):\n var_3 = list(str(var_6))\n if var_3 == list(reversed(var_3)):\n var_5 += 1\n var_4[var_6] = var_5\nvar_1, var_2 = list(map(int, input().split()))\nprint((var_4[var_2] - var_4[var_1 - 1] if var_1 > 10000 else var_4[var_2]))\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().strip().split(\" \")))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n if str(var_4) == str(var_4)[::-1]:\n var_3 += 1\nprint(var_3)\n```", "output": "FASTER 3.2663", "pair_id": "python_p03416_pair0092_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 9.622} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_5 in range(var_1, var_2 + 1):\n var_3 = str(var_5)\n if var_3[0] == var_3[-1] and var_3[1] == var_3[-2]:\n var_4 += 1\nprint(var_4)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_7 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_3 = True\n var_8 = str(var_4)\n var_6 = len(var_8)\n for var_5 in range(var_6 // 2 + 1):\n if var_8[var_5] != var_8[-var_5 - 1]:\n var_3 = False\n break\n if var_3:\n var_7 += 1\nprint(var_7)\n```", "output": "SLOWER 1.2167", "pair_id": "python_p03416_pair0201_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 2.3241} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\ndef func_1():\n return list(map(int, input().split()))\n\n\nvar_1, var_2, var_3 = func_1()\nvar_4 = list(func_1())\nvar_6 = list(func_1())\nvar_5 = min(var_4) + min(var_6)\nfor _ in range(var_3):\n var_8, var_9, var_7 = func_1()\n var_5 = min(var_5, var_4[var_8 - 1] + var_6[var_9 - 1] - var_7)\nprint(var_5)\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\nfrom collections import Counter\n\n\ndef func_9():\n return sys.stdin.readline().strip()\n\n\ndef func_10(var_8, var_9, var_10):\n return [[var_10] * var_9 for var_13 in range(var_8)]\n\n\ndef func_11(var_8, var_9, var_10, var_11):\n return [[[var_11] * var_10 for var_14 in range(var_9)] for var_13 in range(var_8)]\n\n\ndef func_12(var_8, var_9, var_10, var_11, var_12):\n return [\n [[[var_12] * var_11 for var_14 in range(var_10)] for var_14 in range(var_9)]\n for var_13 in range(var_8)\n ]\n\n\ndef func_8(var_16, var_17=1):\n return int(-(-var_16 // var_17))\n\n\ndef func_1():\n return int(eval(func_9()))\n\n\ndef func_3():\n return list(map(int, func_9().split()))\n\n\ndef func_2(var_7=None):\n return list(func_3()) if var_7 is None else [func_1() for var_13 in range(var_7)]\n\n\ndef func_7():\n print(\"Yes\")\n\n\ndef func_5():\n print(\"No\")\n\n\ndef func_6():\n print(\"YES\")\n\n\ndef func_4():\n print(\"NO\")\n\n\nsys.setrecursionlimit(10**9)\nvar_3 = 10**18\nvar_6 = 10**9 + 7\nvar_7, var_5, var_4 = func_3()\nvar_1 = func_2()\nvar_2 = func_2()\nvar_15 = min(var_1) + min(var_2)\nfor _ in range(var_4):\n var_16, var_17, var_10 = func_3()\n var_16 -= 1\n var_17 -= 1\n var_15 = min(var_15, var_1[var_16] + var_2[var_17] - var_10)\nprint(var_15)\n```", "output": "SLOWER 2.0028", "pair_id": "python_p02748_pair0010_reversed", "problem_id": "p02748", "language": "python", "direction": "reversed", "speedup_ratio": 4.0077} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = list(reversed(list(str(var_4))))\n if var_5 == list(str(var_4)):\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1 = list(map(int, input().split()))\nvar_2 = 0\nfor var_3 in range(var_1[0], var_1[1] + 1):\n var_4 = str(var_3)\n if var_4[0] == var_4[4] and var_4[1] == var_4[3]:\n var_2 += 1\nprint(var_2)\n```", "output": "FASTER 1.9458", "pair_id": "python_p03416_pair0202_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 3.8524} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nfrom functools import reduce\nfrom itertools import product\n\nvar_2 = int(eval(input()))\n(*var_1,) = list(map(int, input().split()))\nvar_4 = 0\nfor var_7 in product([-1, 0, 1], repeat=var_2):\n var_6 = reduce(\n lambda var_8, var_9: var_8 * var_9,\n [var_3 + var_7[var_5] for var_5, var_3 in enumerate(var_1)],\n )\n if var_6 % 2 == 0:\n var_4 += 1\nprint(var_4)\n```\n\n=== Code B (Modified) ===\n```python\ndef func_1():\n var_2 = int(eval(input()))\n var_1 = [int(var_6) for var_6 in input().split()]\n var_4 = 3**var_2\n var_5 = len([var_3 for var_3 in var_1 if var_3 % 2 == 0])\n var_4 -= 2**var_5\n print(var_4)\n\n\nif __name__ == \"__main__\":\n func_1()\n```", "output": "FASTER 9.2492", "pair_id": "python_p03568_pair0038_forward", "problem_id": "p03568", "language": "python", "direction": "forward", "speedup_ratio": 608.5427} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_6 = str(var_4)\n var_5 = var_6[::-1]\n if var_6 == var_5:\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_5 in range(10):\n for var_6 in range(10):\n for var_7 in range(10):\n var_3 = 10000 * var_5 + 1000 * var_6 + 100 * var_7 + 10 * var_6 + var_5\n if var_1 <= var_3 <= var_2:\n var_4 += 1\nprint(var_4)\n```", "output": "FASTER 4.076", "pair_id": "python_p03416_pair0203_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 16.8649} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_8 = int(eval(input()))\nvar_6 = []\nfor var_7 in range(var_8 - 1):\n var_1, var_3 = list(map(int, input().split()))\n var_6.append([var_1 - 1, var_3 - 1, var_7])\nvar_6.sort()\nvar_12 = [0] * (var_8)\nvar_2 = [0] * (var_8 - 1)\nvar_9 = 1\nvar_10 = 0\nfor var_5 in var_6:\n _from, var_11, var_7 = var_5\n if _from != var_10:\n var_9 = 1\n if var_12[_from] == var_9:\n var_9 += 1\n var_2[var_7] = var_9\n var_12[var_11] = var_9\n var_9 += 1\n var_10 = _from\nprint((max(var_2)))\nfor var_4 in var_2:\n print(var_4)\n```\n\n=== Code B (Modified) ===\n```python\nvar_11 = int(eval(input()))\nvar_12 = {var_8: [] for var_8 in range(1, var_11 + 1)}\nvar_19 = [False for var_8 in range(var_11 + 1)]\nvar_16 = []\nfor _ in range(var_11 - 1):\n var_2, var_3 = list(map(int, input().split()))\n var_12[var_2].append(var_3)\n var_12[var_3].append(var_2)\n var_16.append((var_2, var_3))\nvar_9 = var_16[0][0]\nvar_19[var_9] = True\nvar_6 = []\nvar_7 = []\nvar_14 = {var_8: {} for var_8 in range(1, var_11 + 1)}\nvar_10 = [0 for var_8 in range(var_11 + 1)]\n\nvar_4 = 1\nfor var_5 in var_12[var_9]:\n var_19[var_5] = True\n var_14[var_9][var_5] = var_4\n var_14[var_5][var_9] = var_4\n var_10[var_5] = var_4\n var_4 += 1\n var_6.append(var_5)\nwhile var_6:\n for var_15 in var_6:\n var_13 = 1\n for var_5 in var_12[var_15]:\n if var_19[var_5] == False:\n var_19[var_5] = True\n if var_13 != var_10[var_15]:\n var_14[var_15][var_5] = var_13\n var_14[var_5][var_15] = var_13\n var_10[var_5] = var_13\n var_13 += 1\n var_7.append(var_5)\n else:\n var_13 += 1\n var_14[var_15][var_5] = var_13\n var_14[var_5][var_15] = var_13\n var_10[var_5] = var_13\n var_13 += 1\n var_7.append(var_5)\n if var_7:\n var_6 = var_7\n var_7 = []\n else:\n var_6 = []\n var_7 = []\nvar_1 = 0\nfor var_8 in range(1, var_11 + 1):\n var_1 = max(var_1, len(var_12[var_8]))\nprint(var_1)\nfor var_8 in range(var_11 - 1):\n var_17, var_18 = var_16[var_8][0], var_16[var_8][1]\n print((var_14[var_17][var_18]))\n```", "output": "SLOWER 1.2591", "pair_id": "python_p02850_pair0001_reversed", "problem_id": "p02850", "language": "python", "direction": "reversed", "speedup_ratio": 2.3934} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\nimport math\nfrom collections import defaultdict\nfrom bisect import bisect_left, bisect_right\n\nsys.setrecursionlimit(10**7)\n\n\ndef func_4():\n return sys.stdin.readline()[:-1]\n\n\nvar_4 = 10**9 + 7\n\n\ndef func_1():\n return int(eval(func_4()))\n\n\ndef func_2():\n return list(map(int, func_4().split()))\n\n\ndef func_3(var_6, var_3):\n if var_6 <= 0:\n return [[] for _ in range(var_3)]\n elif var_3 == 1:\n return [func_1() for _ in range(var_6)]\n else:\n var_5 = [func_2() for _ in range(var_6)]\n return list(map(list, list(zip(*var_5))))\n\n\nvar_1, var_2 = list(map(str, func_4().split()))\nvar_1 = int(var_1)\nvar_2 = 100 * int(var_2[0]) + 10 * int(var_2[2]) + int(var_2[3])\nprint((var_1 * var_2 // 100))\n```\n\n=== Code B (Modified) ===\n```python\ndef func_1():\n var_1, var_3 = input().split()\n var_1 = int(var_1)\n var_3 = int(float(var_3) * 100 + 0.5)\n var_2 = var_1 * var_3\n print((var_2 // 100))\n\n\nif __name__ == \"__main__\":\n func_1()\n```", "output": "FASTER 1.871", "pair_id": "python_p02659_pair0055_forward", "problem_id": "p02659", "language": "python", "direction": "forward", "speedup_ratio": 3.6579} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\nimport numpy as np\n\nvar_6 = int(eval(input()))\n\nvar_1 = [input().replace(\" \", \"\") for var_4 in range(var_6)]\n\nvar_7 = [list(map(int, input().split())) for var_4 in range(var_6)]\nvar_11 = -999999999999999\nfor var_4 in range(1, 1024):\n var_3 = format(var_4, \"010b\")\n var_9 = 0\n for var_2, var_8 in zip(var_1, var_7):\n var_10 = 0\n for var_5 in range(10):\n if var_2[var_5] == \"1\" and var_3[var_5] == \"1\":\n var_10 += 1\n var_9 += var_8[var_10]\n if var_9 > var_11:\n if var_9 == 0:\n print((str(var_4)))\n break\n var_11 = var_9\nprint(var_11)\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\n\nvar_8 = sys.stdin.readline\n\n\ndef func_1():\n var_2 = int(eval(var_8()))\n var_1 = [int(var_8().replace(\" \", \"\"), 2) for _ in range(var_2)]\n var_3 = [list(map(int, var_8().split())) for _ in range(var_2)]\n var_4 = -(10**7) * var_2\n for var_7 in range(1, 1 << 10):\n var_10 = 0\n for var_9, var_6 in enumerate(var_1):\n var_5 = bin(var_7 & var_6).count(\"1\")\n var_10 += var_3[var_9][var_5]\n var_4 = max(var_4, var_10)\n print(var_4)\n\n\nif __name__ == \"__main__\":\n func_1()\n```", "output": "FASTER 2.2365", "pair_id": "python_p03503_pair0008_forward", "problem_id": "p03503", "language": "python", "direction": "forward", "speedup_ratio": 4.7126} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport numpy as np\nfrom itertools import product\n\nvar_6 = int(eval(input()))\nvar_2 = list(map(int, input().split()))\nvar_2 = np.array(var_2)\nvar_5 = [-1, 0, 1]\nvar_3 = 0\nfor var_7 in product(var_5, repeat=var_6):\n var_7 = np.array(var_7)\n var_1 = var_2 + var_7\n var_4 = var_1.cumprod()\n if var_4[-1] % 2 == 0:\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nimport math\nimport string\n\n\ndef func_5():\n return list(map(int, input().split()))\n\n\ndef func_4(var_7, var_8):\n return math.factorial(var_7) // (\n math.factorial(var_7 - var_8) * math.factorial(var_8)\n )\n\n\ndef func_3(var_10):\n var_9 = []\n for var_5 in var_10:\n if not (var_5 in var_9):\n var_9.append(var_5)\n return len(var_10) != len(var_9)\n\n\ndef func_1(var_7):\n func_1 = []\n for var_4 in range(1, var_7 + 1):\n if var_7 % var_4 == 0:\n func_1.append(var_4)\n return func_1\n\n\nvar_2 = [-1, -1, -1, 0, 0, 1, 1, 1]\nvar_3 = [-1, 0, 1, -1, 1, -1, 0, 1]\nvar_7 = int(eval(input()))\nvar_1 = func_5()\n\n\ndef func_2(var_6):\n if len(var_6) == var_7:\n for var_4 in range(len(var_6)):\n if var_6[var_4] % 2 == 0:\n return 1\n return 0\n return (\n func_2(var_6 + [var_1[len(var_6)]])\n + func_2(var_6 + [var_1[len(var_6)] - 1])\n + func_2(var_6 + [var_1[len(var_6)] + 1])\n )\n\n\nprint((func_2([])))\n```", "output": "FASTER 2.3825", "pair_id": "python_p03568_pair0039_forward", "problem_id": "p03568", "language": "python", "direction": "forward", "speedup_ratio": 5.2145} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = input().split()\nvar_1 = int(var_1)\nvar_2 = int(var_2.replace(\".\", \"\"))\nprint((var_1 * var_2 // 100))\n```\n\n=== Code B (Modified) ===\n```python\ndef func_1():\n from sys import setrecursionlimit, stdin\n from os import environ\n from collections import defaultdict, deque, Counter\n from math import ceil, floor, gcd\n from itertools import accumulate, combinations, combinations_with_replacement\n\n setrecursionlimit(10**6)\n var_7 = (\n (lambda *var_11: print(*var_11))\n if \"TERM_PROGRAM\" in environ\n else lambda *var_12: 0\n )\n var_8 = lambda: stdin.readline().rstrip()\n var_3 = lambda: list(map(int, var_8().split()))\n var_1 = lambda: int(var_8())\n var_4 = 10**9 + 7\n var_2 = 10**9 + 10\n var_9, var_10 = var_8().split()\n var_5 = int(var_9)\n var_6 = int(float(var_10) * 100 + 0.5)\n print(var_5 * var_6 // 100)\n\n\nfunc_1()\n```", "output": "SLOWER 2.2868", "pair_id": "python_p02659_pair0037_reversed", "problem_id": "p02659", "language": "python", "direction": "reversed", "speedup_ratio": 4.8798} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_6, var_7 = list(map(int, input().split()))\nvar_1 = [list(map(int, input().split())) for _ in range(var_6)]\nvar_1.sort()\nvar_3 = [(6007) * [0] for _ in range(var_6 + 1)]\nvar_3[0][0] = 0\nvar_2 = 0\nfor var_4 in range(var_6):\n for var_5 in range(6007):\n var_3[var_4 + 1][var_5] = max(var_3[var_4 + 1][var_5], var_3[var_4][var_5])\n if var_5 < var_7:\n var_3[var_4 + 1][var_5 + var_1[var_4][0]] = max(\n var_3[var_4][var_5] + var_1[var_4][1],\n var_3[var_4][var_5 + var_1[var_4][0]],\n )\n var_2 = max(var_2, var_3[var_4 + 1][var_5])\nprint(var_2)\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\nfrom collections import deque\n\nvar_1 = int(10e10)\nvar_2 = -var_1\nvar_12 = 1000000007\nsys.setrecursionlimit(1000000)\n\n\ndef func_2():\n return list(map(int, input().split()))\n\n\ndef func_4():\n return input().split()\n\n\ndef func_1():\n return int(sys.stdin.readline())\n\n\ndef func_3():\n return eval(input())\n\n\nvar_3, var_4 = func_2()\nvar_6 = [func_2() for var_10 in range(var_3)]\nvar_6.sort()\nvar_7 = 0\nvar_9 = [[0] * var_4 for var_10 in range(var_3 + 1)]\nfor var_10 in range(1, var_3 + 1):\n var_5, var_8 = var_6[var_10 - 1]\n for var_11 in range(var_4):\n if 0 <= var_11 - var_5 < var_4:\n var_9[var_10][var_11] = max(\n var_9[var_10 - 1][var_11], var_9[var_10 - 1][var_11 - var_5] + var_8\n )\n else:\n var_9[var_10][var_11] = var_9[var_10 - 1][var_11]\n else:\n var_7 = max(var_7, var_9[var_10 - 1][-1] + var_8)\nprint(var_7)\n```", "output": "FASTER 5.6348", "pair_id": "python_p02863_pair0025_forward", "problem_id": "p02863", "language": "python", "direction": "forward", "speedup_ratio": 49.688} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = list(reversed(list(str(var_4))))\n if var_5 == list(str(var_4)):\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_5 in range(10):\n for var_6 in range(10):\n for var_7 in range(10):\n var_3 = 10000 * var_5 + 1000 * var_6 + 100 * var_7 + 10 * var_6 + var_5\n if var_1 <= var_3 <= var_2:\n var_4 += 1\nprint(var_4)\n```", "output": "FASTER 5.4825", "pair_id": "python_p03416_pair0141_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 44.7094} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\n\n\ndef func_1(var_5, var_6):\n var_4 = 0\n for var_3 in range(var_5, var_6 + 1):\n if str(var_3) == str(var_3)[::-1]:\n var_4 += 1\n return var_4\n\n\nprint((func_1(var_1, var_2)))\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\n\n\ndef func_1(var_5):\n var_4 = 0\n for var_3 in range(1, var_5 + 1):\n if str(var_3) == str(var_3)[::-1]:\n var_4 += 1\n return var_4\n\n\nprint((func_1(var_2) - func_1(var_1 - 1)))\n```", "output": "SLOWER 1.9143", "pair_id": "python_p03416_pair0124_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 3.7692} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport numpy as np\nfrom itertools import product\n\nvar_6 = int(eval(input()))\nvar_2 = list(map(int, input().split()))\nvar_2 = np.array(var_2)\nvar_5 = [-1, 0, 1]\nvar_3 = 0\nfor var_7 in product(var_5, repeat=var_6):\n var_7 = np.array(var_7)\n var_1 = var_2 + var_7\n var_4 = var_1.cumprod()\n if var_4[-1] % 2 == 0:\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\ndef func_1():\n var_2 = int(input())\n var_1 = [int(var_6) for var_6 in input().split()]\n if var_2 == 1:\n return print(1 if var_1[0] % 2 == 0 else 2)\n var_3 = 0\n var_5 = (-1, 0, 1)\n from itertools import product\n\n for var_6 in product(range(3), repeat=var_2):\n var_4 = 1\n for var_7 in range(var_2):\n var_4 *= var_1[var_7] + var_5[var_6[var_7]]\n if var_4 % 2 == 0:\n var_3 += 1\n print(var_3)\n\n\nif __name__ == \"__main__\":\n func_1()\n```", "output": "FASTER 1.466", "pair_id": "python_p03568_pair0040_forward", "problem_id": "p03568", "language": "python", "direction": "forward", "speedup_ratio": 2.7626} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().rstrip().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = list(map(int, list(str(var_4))))\n if var_5[0] == var_5[4] and var_5[1] == var_5[3]:\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\ndef func_1():\n var_1, var_2 = list(map(int, input().rstrip().split()))\n var_3 = 0\n for var_4 in range(var_1, var_2 + 1):\n var_5 = str(var_4)\n if var_5 == var_5[::-1]:\n var_3 += 1\n print(var_3)\n\n\nif __name__ == \"__main__\":\n func_1()\n```", "output": "FASTER 2.429", "pair_id": "python_p03416_pair0161_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 5.3852} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_3 = list(map(int, input().split()))\nvar_2 = 0\nfor var_5 in range(var_3 + 1)[var_1:]:\n if len(str(var_5)) % 2 == 0:\n var_6 = list(str(var_5))[: len(str(var_5)) // 2]\n var_7 = list(reversed(list(str(var_5))[len(str(var_5)) // 2 :]))\n if var_6 == var_7:\n var_2 += 1\n else:\n var_8 = list(str(var_5))[: len(str(var_5)) // 2 + 1]\n var_4 = list(reversed(list(str(var_5))[len(str(var_5)) // 2 :]))\n if var_8 == var_4:\n var_2 += 1\nprint(var_2)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = list(str(var_4))\n if var_5 == list(reversed(var_5)):\n var_3 += 1\nprint(var_3)\n```", "output": "FASTER 1.2424", "pair_id": "python_p03416_pair0204_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 2.3659} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_4 = int(eval(input()))\nvar_1 = 0\nif var_4 == 2:\n print((2))\nelse:\n for var_2 in range(var_4, 10**6):\n for var_3 in range(2, var_2 // 2 + 2):\n if var_2 % var_3 == 0:\n break\n else:\n var_1 = var_2\n break\n print(var_1)\n```\n\n=== Code B (Modified) ===\n```python\nimport bisect, copy, heapq, math, sys\nfrom collections import *\nfrom functools import lru_cache\nfrom itertools import accumulate, combinations, permutations, product\n\n\ndef func_2():\n return sys.stdin.readline()[:-1]\n\n\ndef func_4(var_8):\n return [0] + list(accumulate(var_8))\n\n\ndef func_1(var_1, var_4):\n return -(-var_1 // var_4)\n\n\nsys.setrecursionlimit(5000000)\nvar_9 = pow(10, 9) + 7\nvar_2 = [chr(ord(\"a\") + var_6) for var_6 in range(26)]\nvar_5 = [[1, 0], [0, 1], [-1, 0], [0, -1]]\nvar_11 = int(eval(func_2()))\n\n\ndef func_3(var_10):\n if var_10 == 1:\n return False\n for var_7 in range(2, int(math.sqrt(var_10)) + 1):\n if var_10 % var_7 == 0:\n return False\n return True\n\n\nvar_3 = var_11\nwhile not func_3(var_3):\n var_3 += 1\nprint(var_3)\n```", "output": "SLOWER 1.4219", "pair_id": "python_p02819_pair0001_reversed", "problem_id": "p02819", "language": "python", "direction": "reversed", "speedup_ratio": 2.6793} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nfrom functools import reduce\nfrom itertools import product\n\nvar_2 = int(eval(input()))\n(*var_1,) = list(map(int, input().split()))\nvar_4 = 0\nfor var_7 in product([-1, 0, 1], repeat=var_2):\n var_6 = reduce(\n lambda var_8, var_9: var_8 * var_9,\n [var_3 + var_7[var_5] for var_5, var_3 in enumerate(var_1)],\n )\n if var_6 % 2 == 0:\n var_4 += 1\nprint(var_4)\n```\n\n=== Code B (Modified) ===\n```python\nimport math\nimport string\n\n\ndef func_5():\n return list(map(int, input().split()))\n\n\ndef func_4(var_7, var_8):\n return math.factorial(var_7) // (\n math.factorial(var_7 - var_8) * math.factorial(var_8)\n )\n\n\ndef func_3(var_10):\n var_9 = []\n for var_5 in var_10:\n if not (var_5 in var_9):\n var_9.append(var_5)\n return len(var_10) != len(var_9)\n\n\ndef func_1(var_7):\n func_1 = []\n for var_4 in range(1, var_7 + 1):\n if var_7 % var_4 == 0:\n func_1.append(var_4)\n return func_1\n\n\nvar_2 = [-1, -1, -1, 0, 0, 1, 1, 1]\nvar_3 = [-1, 0, 1, -1, 1, -1, 0, 1]\nvar_7 = int(eval(input()))\nvar_1 = func_5()\n\n\ndef func_2(var_6):\n if len(var_6) == var_7:\n for var_4 in range(len(var_6)):\n if var_6[var_4] % 2 == 0:\n return 1\n return 0\n return (\n func_2(var_6 + [var_1[len(var_6)]])\n + func_2(var_6 + [var_1[len(var_6)] - 1])\n + func_2(var_6 + [var_1[len(var_6)] + 1])\n )\n\n\nprint((func_2([])))\n```", "output": "FASTER 2.116", "pair_id": "python_p03568_pair0027_forward", "problem_id": "p03568", "language": "python", "direction": "forward", "speedup_ratio": 4.3349} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_2 = int(eval(input()))\nvar_1 = list(map(int, input().split()))\nvar_4 = 1\nfor var_3 in range(var_2):\n if var_1[var_3] % 2 == 0:\n var_4 *= 2\nprint((3**var_2 - var_4))\n```\n\n=== Code B (Modified) ===\n```python\nimport numpy as np\nfrom itertools import product\n\nvar_6 = int(eval(input()))\nvar_2 = list(map(int, input().split()))\nvar_2 = np.array(var_2)\nvar_5 = [-1, 0, 1]\nvar_3 = 0\nfor var_7 in product(var_5, repeat=var_6):\n var_7 = np.array(var_7)\n var_1 = var_2 + var_7\n var_4 = var_1.cumprod()\n if var_4[-1] % 2 == 0:\n var_3 += 1\nprint(var_3)\n```", "output": "SLOWER 10.0427", "pair_id": "python_p03568_pair0041_reversed", "problem_id": "p03568", "language": "python", "direction": "reversed", "speedup_ratio": 1054.7734} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = [0] * (var_2 + 1)\nfor var_3 in range(1, var_2 + 1):\n if str(var_3) == str(var_3)[::-1]:\n var_4[var_3] = var_4[var_3 - 1] + 1\n else:\n var_4[var_3] = var_4[var_3 - 1]\nprint((var_4[var_2] - var_4[var_1 - 1]))\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = str(var_4)\n if var_5[0] == var_5[4] and var_5[1] == var_5[3]:\n var_3 += 1\nprint(var_3)\n```", "output": "FASTER 2.2084", "pair_id": "python_p03416_pair0057_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 4.6217} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_8 in range(var_1, var_2 + 1):\n var_7 = str(var_8)\n var_6 = len(var_7)\n var_4 = True\n for var_5 in range(var_6 // 2):\n if var_7[var_5] != var_7[var_6 - 1 - var_5]:\n var_4 = False\n break\n if var_4:\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\ndef func_1():\n var_1, var_2 = list(map(int, input().rstrip().split()))\n var_3 = 0\n for var_4 in range(var_1, var_2 + 1):\n var_5 = str(var_4)\n if var_5 == var_5[::-1]:\n var_3 += 1\n print(var_3)\n\n\nif __name__ == \"__main__\":\n func_1()\n```", "output": "FASTER 1.8722", "pair_id": "python_p03416_pair0195_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 3.661} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = input().split()\nvar_1 = int(var_1)\nvar_2 = int(var_2)\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = list(str(var_4))\n if (var_5[0] == var_5[4]) and (var_5[1] == var_5[3]):\n var_3 = var_3 + 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\ndef func_1():\n var_1, var_2 = list(map(int, input().rstrip().split()))\n var_3 = 0\n for var_4 in range(var_1, var_2 + 1):\n var_5 = str(var_4)\n if var_5 == var_5[::-1]:\n var_3 += 1\n print(var_3)\n\n\nif __name__ == \"__main__\":\n func_1()\n```", "output": "FASTER 1.1503", "pair_id": "python_p03416_pair0205_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 2.2196} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nimport math\n\nif math.ceil((var_1 + 1) * 12.5) <= math.ceil(var_2 * 10) or math.ceil(\n var_1 * 12.5\n) >= math.ceil((var_2 + 1) * 10):\n print((-1))\nelse:\n print((max(math.ceil(var_1 * 12.5), math.ceil(var_2 * 10))))\n```\n\n=== Code B (Modified) ===\n```python\nfrom math import floor\n\nvar_1, var_2 = list(map(int, input().split()))\n\n\nfor var_3 in range(1010):\n if (floor(var_3 * 0.08) == var_1) and (floor(var_3 * 0.1) == var_2):\n\n print(var_3)\n quit()\n\n\nprint((-1))\n```", "output": "SLOWER 1.8508", "pair_id": "python_p02755_pair0010_reversed", "problem_id": "p02755", "language": "python", "direction": "reversed", "speedup_ratio": 3.6071} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport math\n\n\ndef func_1():\n var_1, var_2 = list(map(int, input().split()))\n\n var_5 = max(math.ceil(var_1 / 0.08), math.ceil(var_2 / 0.1))\n\n var_4 = min((math.ceil((var_1 + 1) / 0.08), math.ceil((var_2 + 1) / 0.1)))\n\n for var_3 in range(var_5, var_4 + 1):\n if (math.floor(var_3 * 0.08) == var_1) and (math.floor(var_3 * 0.1) == var_2):\n print(var_3)\n quit()\n\n print((-1))\n\n\nif __name__ == \"__main__\":\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nfrom math import floor\n\nvar_1, var_2 = list(map(int, input().split()))\n\n\nfor var_3 in range(1010):\n if (floor(var_3 * 0.08) == var_1) and (floor(var_3 * 0.1) == var_2):\n\n print(var_3)\n quit()\n\n\nprint((-1))\n```", "output": "SLOWER 1.1074", "pair_id": "python_p02755_pair0007_reversed", "problem_id": "p02755", "language": "python", "direction": "reversed", "speedup_ratio": 2.1545} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_2, var_1 = [int(var_12) for var_12 in input().split()]\nvar_3 = []\nfor var_8 in range(var_1):\n var_5, var_6 = [int(var_12) for var_12 in input().split()]\n var_3.append((var_5, var_6))\nvar_3.sort()\nvar_9 = float(\"inf\")\nvar_4 = [var_9 for var_5 in range(var_2 + 1)]\nfor var_5, var_6 in var_3:\n var_4[var_5] = min(var_4[var_5], var_6)\nvar_3 = [\n (var_5, var_4[var_5]) for var_5 in range(1, var_2 + 1) if var_4[var_5] != var_9\n]\nvar_3.sort(key=lambda var_11: var_11[1])\nvar_7 = [True] * (var_2)\nvar_10 = None\nfor var_5, var_6 in var_3:\n if var_10 == None or var_10 < var_5:\n var_7[var_6 - 1] = False\n var_10 = var_6 - 1\nprint((sum(1 for var_6 in var_7 if not var_6)))\n```\n\n=== Code B (Modified) ===\n```python\nvar_7, var_6 = list(map(int, input().split(\" \")))\nvar_2 = [list(map(int, input().split(\" \"))) for _ in range(var_6)]\nvar_2.sort(key=lambda var_8: var_8[1])\nvar_5 = 0\nvar_4 = 0\nfor var_1, var_3 in var_2:\n if var_4 > var_1:\n continue\n var_4 = var_3\n var_5 += 1\nprint(var_5)\n```", "output": "FASTER 1.0821", "pair_id": "python_p03295_pair0003_forward", "problem_id": "p03295", "language": "python", "direction": "forward", "speedup_ratio": 2.1171} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\n\"\"\"\"\"\"\n\nfrom collections import deque\n\n\ndef func_1():\n var_5, *var_1 = list(map(int, open(0).read().split()))\n var_2 = var_1[1::2]\n var_4 = [[] for _ in range(var_5 + 1)]\n for var_7, var_8 in zip(*[iter(var_1)] * 2):\n var_4[var_7].append(var_8)\n var_6 = deque([1])\n var_3 = [0] * (var_5 + 1)\n while var_6:\n var_11 = var_6.popleft()\n var_9 = 0\n for var_10 in var_4[var_11]:\n var_9 += 1 + (var_9 + 1 == var_3[var_11])\n var_3[var_10] = var_9\n var_6.append(var_10)\n print((max(var_3)))\n for var_8 in var_2:\n print((var_3[var_8]))\n\n\nfunc_1()\n```\n\n=== Code B (Modified) ===\n```python\nimport copy\n\nvar_8 = int(eval(input()))\nvar_10 = set([var_6 for var_6 in range(1, 10**5)])\nvar_5 = []\nvar_11 = {}\nvar_9 = []\nfor var_6 in range(var_8 - 1):\n var_1, var_2 = list(map(int, input().split(\" \")))\n var_5.append([var_1, var_2])\n var_11.setdefault(var_1, []).append(var_2)\n var_9.append([])\nvar_9.append([])\nvar_9.append([])\nvar_7 = 0\nfor var_12 in range(1, var_8 + 1):\n var_14 = var_11.get(var_12, [])\n var_3 = 1\n for var_13 in var_14:\n if var_3 in var_9[var_12]:\n var_3 += 1\n else:\n pass\n var_9[var_13].append(var_3)\n if var_3 >= var_7:\n var_7 = var_3\n var_3 += 1\nprint(var_7)\nfor var_4 in var_5:\n print((var_9[var_4[1]][0]))\n```", "output": "SLOWER 4.6186", "pair_id": "python_p02850_pair0016_reversed", "problem_id": "p02850", "language": "python", "direction": "reversed", "speedup_ratio": 24.5662} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\n\nsys.setrecursionlimit(2147483647)\nvar_2 = float(\"inf\")\nvar_3 = 10**9 + 7\nvar_10 = lambda: sys.stdin.readline().rstrip()\n\n\ndef func_1():\n var_11, var_4 = list(map(int, var_10().split()))\n var_1 = [tuple(map(int, var_10().split())) for _ in range(var_11)]\n var_1.sort()\n var_8 = [0] * var_4\n var_6 = -var_2\n for var_9 in range(var_11):\n var_5, var_7 = var_1[var_9]\n var_12 = var_8[:]\n for var_13 in range(var_4):\n if var_13 + var_5 < var_4:\n var_12[var_13 + var_5] = max(\n var_12[var_13 + var_5], var_8[var_13] + var_7\n )\n else:\n var_6 = max(var_6, var_8[var_13] + var_7)\n var_8 = var_12\n print((max(var_6, max(var_8))))\n\n\nfunc_1()\n```\n\n=== Code B (Modified) ===\n```python\nimport bisect\nimport sys\n\nsys.setrecursionlimit(10**6)\nvar_17 = sys.stdout.write\nvar_7 = lambda *var_15: print(*var_15) if var_1 else 0\nvar_1 = True\n\n\ndef func_1(var_10=sys.stdin.readline):\n var_12 = lambda: var_10().rstrip()\n var_3 = lambda: list(map(int, var_12().split()))\n var_2 = lambda: int(var_12())\n var_4 = lambda var_18: [var_3() for _ in range(var_18)]\n var_14, var_16 = var_3()\n var_5 = var_4(var_14)\n var_8 = [[0] * var_16 for _ in range(var_14)]\n for var_11 in range(1, var_14):\n for var_13 in range(1, var_16):\n if var_13 < var_5[var_11 - 1][0]:\n var_8[var_11][var_13] = var_8[var_11 - 1][var_13]\n else:\n var_8[var_11][var_13] = max(\n var_8[var_11 - 1][var_13],\n var_8[var_11 - 1][var_13 - var_5[var_11 - 1][0]]\n + var_5[var_11 - 1][1],\n )\n var_9 = [[0] * var_16 for _ in range(var_14)]\n for var_11 in range(1, var_14):\n for var_13 in range(1, var_16):\n if var_13 < var_5[var_14 - var_11][0]:\n var_9[var_11][var_13] = var_9[var_11 - 1][var_13]\n else:\n var_9[var_11][var_13] = max(\n var_9[var_11 - 1][var_13],\n var_9[var_11 - 1][var_13 - var_5[var_14 - var_11][0]]\n + var_5[var_14 - var_11][1],\n )\n var_6 = 0\n for var_11 in range(var_14):\n for var_13 in range(var_16 - 1):\n var_6 = max(\n var_6,\n var_8[var_11][var_13]\n + var_9[var_14 - var_11 - 1][var_16 - var_13 - 1]\n + var_5[var_11][1],\n )\n print(var_6)\n\n\nif __name__ == \"__main__\":\n func_1()\n```", "output": "SLOWER 1.4425", "pair_id": "python_p02863_pair0041_reversed", "problem_id": "p02863", "language": "python", "direction": "reversed", "speedup_ratio": 2.718} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_3 = list(map(int, input().split()))\nvar_2 = -1\nfor var_4 in range(10, 12501):\n if int(var_4 * 0.08) == var_1 and int(var_4 * 0.1) == var_3:\n var_2 = var_4\n break\nprint(var_2)\n```\n\n=== Code B (Modified) ===\n```python\nimport math\n\nvar_1, var_4 = (int(var_10) for var_10 in input().split())\nvar_2 = math.ceil(var_1 / 0.08)\nvar_3 = math.ceil((var_1 + 1) / 0.08)\n\"\"\"\"\"\"\nvar_5 = math.ceil(var_4 / 0.1)\nvar_6 = math.ceil((var_4 + 1) / 0.1)\n\"\"\"\"\"\"\nvar_7 = list(range(var_2, var_3))\nvar_8 = list(range(var_5, var_6))\nvar_9 = set(var_7) & set(var_8)\nif len(var_9) == 0:\n print((-1))\nelse:\n print((min(var_9)))\n```", "output": "FASTER 4.5892", "pair_id": "python_p02755_pair0011_forward", "problem_id": "p02755", "language": "python", "direction": "forward", "speedup_ratio": 24.0708} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport copy\n\nvar_8 = int(eval(input()))\nvar_10 = set([var_6 for var_6 in range(1, 10**5)])\nvar_5 = []\nvar_11 = {}\nvar_9 = []\nfor var_6 in range(var_8 - 1):\n var_1, var_2 = list(map(int, input().split(\" \")))\n var_5.append([var_1, var_2])\n var_11.setdefault(var_1, []).append(var_2)\n var_9.append([])\nvar_9.append([])\nvar_9.append([])\nvar_7 = 0\nfor var_12 in range(1, var_8 + 1):\n var_14 = var_11.get(var_12, [])\n var_3 = 1\n for var_13 in var_14:\n if var_3 in var_9[var_12]:\n var_3 += 1\n else:\n pass\n var_9[var_13].append(var_3)\n if var_3 >= var_7:\n var_7 = var_3\n var_3 += 1\nprint(var_7)\nfor var_4 in var_5:\n print((var_9[var_4[1]][0]))\n```\n\n=== Code B (Modified) ===\n```python\nfrom collections import deque\n\nvar_9 = int(eval(input()))\nvar_6 = {var_7: dict() for var_7 in range(var_9)}\nvar_2 = [0] * (var_9 - 1)\nvar_4 = [0] * (var_9 - 1)\nfor var_7 in range(var_9 - 1):\n var_1, var_3 = list(map(int, input().split()))\n var_2[var_7] = var_1 - 1\n var_4[var_7] = var_3 - 1\n var_6[var_1 - 1][var_3 - 1] = -1\n var_6[var_3 - 1][var_1 - 1] = -1\nvar_8 = max([len(var_6[var_1]) for var_1 in range(var_9)])\nvar_13 = [-1] * var_9\nvar_13[0] = var_8 - 1\n\nvar_12 = deque([0])\nwhile len(var_12) > 0:\n var_10 = var_12.popleft()\n var_5 = var_13[var_10]\n for var_11 in list(var_6[var_10].keys()):\n if var_13[var_11] != -1:\n continue\n var_5 += 1\n var_5 %= var_8\n\n var_6[var_10][var_11] = var_5\n var_6[var_11][var_10] = var_5\n var_13[var_11] = var_5\n var_12.append(var_11)\nprint(var_8)\nfor var_7 in range(var_9 - 1):\n print((var_6[var_2[var_7]][var_4[var_7]] + 1))\n```", "output": "FASTER 4.1649", "pair_id": "python_p02850_pair0027_forward", "problem_id": "p02850", "language": "python", "direction": "forward", "speedup_ratio": 17.9377} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\ndef func_1():\n var_2 = int(input())\n var_1 = [int(var_6) for var_6 in input().split()]\n if var_2 == 1:\n return print(1 if var_1[0] % 2 == 0 else 2)\n var_3 = 0\n var_5 = (-1, 0, 1)\n from itertools import product\n\n for var_6 in product(range(3), repeat=var_2):\n var_4 = 1\n for var_7 in range(var_2):\n var_4 *= var_1[var_7] + var_5[var_6[var_7]]\n if var_4 % 2 == 0:\n var_3 += 1\n print(var_3)\n\n\nif __name__ == \"__main__\":\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nvar_2 = int(eval(input()))\n(*var_1,) = list(map(int, input().split()))\nvar_5 = 0\nfor var_3 in var_1:\n if var_3 % 2 == 0:\n var_5 += 1\nvar_4 = 3**var_2 - 2**var_5\nprint(var_4)\n```", "output": "FASTER 8.5619", "pair_id": "python_p03568_pair0030_forward", "problem_id": "p03568", "language": "python", "direction": "forward", "speedup_ratio": 377.9172} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nfrom sys import stdin\n\nvar_5 = stdin.readline\nvar_2, var_1 = list(map(int, var_5().split()))\nvar_3 = [False] * var_2\nvar_8 = [0] * var_2\nvar_9 = 0\nfor var_4 in range(var_1):\n var_6, var_7 = var_5().split()\n var_6 = int(var_6) - 1\n if var_3[var_6] is False and var_7 == \"AC\":\n var_9 += var_8[var_6]\n var_3[var_6] = True\n elif var_7 == \"WA\":\n var_8[var_6] += 1\nprint((var_3.count(True), var_9))\n```\n\n=== Code B (Modified) ===\n```python\nvar_7, var_6 = list(map(int, input().split()))\nvar_5 = [tuple(input().split()) for _ in range(var_6)]\nvar_9 = [[] for _ in range(var_7)]\nfor var_2 in range(var_6):\n var_9[int(var_5[var_2][0]) - 1].append(var_5[var_2][1])\nvar_1, var_8 = 0, 0\nfor var_3 in range(var_7):\n if \"AC\" in var_9[var_3]:\n var_1 += 1\n for var_4 in range(len(var_9[var_3])):\n if var_9[var_3][var_4] == \"WA\":\n var_8 += 1\n else:\n break\nprint((var_1, var_8))\n```", "output": "SLOWER 3.0644", "pair_id": "python_p02802_pair0006_reversed", "problem_id": "p02802", "language": "python", "direction": "reversed", "speedup_ratio": 8.3654} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\ndef func_1():\n var_2 = int(input())\n var_1 = [int(var_6) for var_6 in input().split()]\n if var_2 == 1:\n return print(1 if var_1[0] % 2 == 0 else 2)\n var_3 = 0\n var_5 = (-1, 0, 1)\n from itertools import product\n\n for var_6 in product(range(3), repeat=var_2):\n var_4 = 1\n for var_7 in range(var_2):\n var_4 *= var_1[var_7] + var_5[var_6[var_7]]\n if var_4 % 2 == 0:\n var_3 += 1\n print(var_3)\n\n\nif __name__ == \"__main__\":\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nfrom itertools import product\n\nvar_6 = int(eval(input()))\nvar_1 = list(map(int, input().split()))\nvar_5 = 0\nfor var_2 in product((-1, 0, 1), repeat=var_6):\n var_7 = 1\n for var_3, var_4 in zip(var_1, var_2):\n var_7 *= var_3 + var_4\n if var_7 % 2 == 0:\n var_5 += 1\nprint(var_5)\n```", "output": "SLOWER 1.47", "pair_id": "python_p03568_pair0042_reversed", "problem_id": "p03568", "language": "python", "direction": "reversed", "speedup_ratio": 2.7702} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\n\n\ndef func_1(var_5):\n var_4 = 0\n for var_3 in range(1, var_5 + 1):\n if str(var_3) == str(var_3)[::-1]:\n var_4 += 1\n return var_4\n\n\nprint((func_1(var_2) - func_1(var_1 - 1)))\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_4 = str(var_4)\n if var_4[0] == var_4[-1] and var_4[1] == var_4[-2]:\n var_3 += 1\nprint(var_3)\n```", "output": "FASTER 1.7743", "pair_id": "python_p03416_pair0083_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 3.4208} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = input().split()\nvar_1 = int(var_1)\nvar_2 = int(var_2)\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = list(str(var_4))\n if (var_5[0] == var_5[4]) and (var_5[1] == var_5[3]):\n var_3 = var_3 + 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_5 in range(10):\n for var_6 in range(10):\n for var_7 in range(10):\n var_3 = 10000 * var_5 + 1000 * var_6 + 100 * var_7 + 10 * var_6 + var_5\n if var_1 <= var_3 <= var_2:\n var_4 += 1\nprint(var_4)\n```", "output": "FASTER 4.2299", "pair_id": "python_p03416_pair0101_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 18.7637} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_6, var_7 = list(map(int, input().split()))\nvar_1 = [list(map(int, input().split())) for _ in range(var_6)]\nvar_1.sort()\nvar_3 = [(6007) * [0] for _ in range(var_6 + 1)]\nvar_3[0][0] = 0\nvar_2 = 0\nfor var_4 in range(var_6):\n for var_5 in range(6007):\n var_3[var_4 + 1][var_5] = max(var_3[var_4 + 1][var_5], var_3[var_4][var_5])\n if var_5 < var_7:\n var_3[var_4 + 1][var_5 + var_1[var_4][0]] = max(\n var_3[var_4][var_5] + var_1[var_4][1],\n var_3[var_4][var_5 + var_1[var_4][0]],\n )\n var_2 = max(var_2, var_3[var_4 + 1][var_5])\nprint(var_2)\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\n\nsys.setrecursionlimit(2147483647)\nvar_2 = float(\"inf\")\nvar_3 = 10**9 + 7\nvar_10 = lambda: sys.stdin.readline().rstrip()\n\n\ndef func_1():\n var_11, var_4 = list(map(int, var_10().split()))\n var_1 = [tuple(map(int, var_10().split())) for _ in range(var_11)]\n var_1.sort()\n var_8 = [0] * var_4\n var_6 = -var_2\n for var_9 in range(var_11):\n var_5, var_7 = var_1[var_9]\n var_12 = var_8[:]\n for var_13 in range(var_4):\n if var_13 + var_5 < var_4:\n var_12[var_13 + var_5] = max(\n var_12[var_13 + var_5], var_8[var_13] + var_7\n )\n else:\n var_6 = max(var_6, var_8[var_13] + var_7)\n var_8 = var_12\n print((max(var_6, max(var_8))))\n\n\nfunc_1()\n```", "output": "FASTER 6.7598", "pair_id": "python_p02863_pair0039_forward", "problem_id": "p02863", "language": "python", "direction": "forward", "speedup_ratio": 108.3692} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\ndef func_1():\n from sys import setrecursionlimit, stdin\n from os import environ\n from collections import defaultdict, deque, Counter\n from math import ceil, floor, gcd\n from itertools import accumulate, combinations, combinations_with_replacement\n\n setrecursionlimit(10**6)\n var_7 = (\n (lambda *var_11: print(*var_11))\n if \"TERM_PROGRAM\" in environ\n else lambda *var_12: 0\n )\n var_8 = lambda: stdin.readline().rstrip()\n var_3 = lambda: list(map(int, var_8().split()))\n var_1 = lambda: int(var_8())\n var_4 = 10**9 + 7\n var_2 = 10**9 + 10\n var_9, var_10 = var_8().split()\n var_5 = int(var_9)\n var_6 = int(float(var_10) * 100 + 0.5)\n print(var_5 * var_6 // 100)\n\n\nfunc_1()\n```\n\n=== Code B (Modified) ===\n```python\nimport math\n\nvar_1, var_2 = input().split()\nvar_1 = int(var_1)\nvar_3 = int(var_2[0] + var_2[2] + var_2[3])\nprint((var_1 * var_3 // 100))\n```", "output": "FASTER 2.0604", "pair_id": "python_p02659_pair0056_forward", "problem_id": "p02659", "language": "python", "direction": "forward", "speedup_ratio": 4.1709} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().rstrip().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = list(map(int, list(str(var_4))))\n if var_5[0] == var_5[4] and var_5[1] == var_5[3]:\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = input().split()\nvar_1 = int(var_1)\nvar_2 = int(var_2)\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = list(str(var_4))\n if (var_5[0] == var_5[4]) and (var_5[1] == var_5[3]):\n var_3 = var_3 + 1\nprint(var_3)\n```", "output": "FASTER 1.2787", "pair_id": "python_p03416_pair0015_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 2.4262} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().strip().split(\" \")))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n if str(var_4) == str(var_4)[::-1]:\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = list(reversed(list(str(var_4))))\n if var_5 == list(str(var_4)):\n var_3 += 1\nprint(var_3)\n```", "output": "SLOWER 1.3497", "pair_id": "python_p03416_pair0206_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 2.5486} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_3 = list(map(int, input().split()))\nvar_2 = -1\nfor var_4 in range(10, 12501):\n if int(var_4 * 0.08) == var_1 and int(var_4 * 0.1) == var_3:\n var_2 = var_4\n break\nprint(var_2)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_2 = var_2 / 0.1\nvar_3 = [var_4 + var_2 for var_4 in range(10)]\nfor var_4 in var_3:\n if int(var_4 * 0.08) == var_1:\n print((int(var_4)))\n exit()\nprint(\"-1\")\n```", "output": "FASTER 5.3061", "pair_id": "python_p02755_pair0012_forward", "problem_id": "p02755", "language": "python", "direction": "forward", "speedup_ratio": 39.5622} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = list(str(var_4))\n if var_5 == list(reversed(var_5)):\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_4 = str(var_4)\n if var_4[0] == var_4[-1] and var_4[1] == var_4[-2]:\n var_3 += 1\nprint(var_3)\n```", "output": "FASTER 1.4159", "pair_id": "python_p03416_pair0207_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 2.6682} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\nfrom collections import deque\n\nvar_1 = int(10e10)\nvar_2 = -var_1\nvar_12 = 1000000007\nsys.setrecursionlimit(1000000)\n\n\ndef func_2():\n return list(map(int, input().split()))\n\n\ndef func_4():\n return input().split()\n\n\ndef func_1():\n return int(sys.stdin.readline())\n\n\ndef func_3():\n return eval(input())\n\n\nvar_3, var_4 = func_2()\nvar_6 = [func_2() for var_10 in range(var_3)]\nvar_6.sort()\nvar_7 = 0\nvar_9 = [[0] * var_4 for var_10 in range(var_3 + 1)]\nfor var_10 in range(1, var_3 + 1):\n var_5, var_8 = var_6[var_10 - 1]\n for var_11 in range(var_4):\n if 0 <= var_11 - var_5 < var_4:\n var_9[var_10][var_11] = max(\n var_9[var_10 - 1][var_11], var_9[var_10 - 1][var_11 - var_5] + var_8\n )\n else:\n var_9[var_10][var_11] = var_9[var_10 - 1][var_11]\n else:\n var_7 = max(var_7, var_9[var_10 - 1][-1] + var_8)\nprint(var_7)\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\n\nsys.setrecursionlimit(2147483647)\nvar_2 = float(\"inf\")\nvar_3 = 10**9 + 7\nvar_10 = lambda: sys.stdin.readline().rstrip()\n\n\ndef func_1():\n var_11, var_4 = list(map(int, var_10().split()))\n var_1 = [tuple(map(int, var_10().split())) for _ in range(var_11)]\n var_1.sort()\n var_8 = [0] * var_4\n var_6 = -var_2\n for var_9 in range(var_11):\n var_5, var_7 = var_1[var_9]\n var_12 = var_8[:]\n for var_13 in range(var_4):\n if var_13 + var_5 < var_4:\n var_12[var_13 + var_5] = max(\n var_12[var_13 + var_5], var_8[var_13] + var_7\n )\n else:\n var_6 = max(var_6, var_8[var_13] + var_7)\n var_8 = var_12\n print((max(var_6, max(var_8))))\n\n\nfunc_1()\n```", "output": "FASTER 1.125", "pair_id": "python_p02863_pair0055_forward", "problem_id": "p02863", "language": "python", "direction": "forward", "speedup_ratio": 2.181} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_10 = []\nvar_10 = input().rstrip().split(\" \")\nvar_1 = int(var_10[0])\nvar_3 = int(var_10[1])\nvar_2 = 0\nvar_6 = var_1\nwhile var_6 <= var_3:\n var_4 = var_6 // 10000\n var_5 = (var_6 - var_4 * 10000) // 1000\n var_7 = var_6 // 100\n var_8 = (var_6 - var_7 * 100) // 10\n var_9 = var_6 % 10\n if (var_4 == var_9) and (var_5 == var_8):\n var_2 += 1\n var_6 += 1\nprint(var_2)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_3 = list(map(int, input().split()))\nvar_2 = 0\nfor var_5 in range(var_3 + 1)[var_1:]:\n if len(str(var_5)) % 2 == 0:\n var_6 = list(str(var_5))[: len(str(var_5)) // 2]\n var_7 = list(reversed(list(str(var_5))[len(str(var_5)) // 2 :]))\n if var_6 == var_7:\n var_2 += 1\n else:\n var_8 = list(str(var_5))[: len(str(var_5)) // 2 + 1]\n var_4 = list(reversed(list(str(var_5))[len(str(var_5)) // 2 :]))\n if var_8 == var_4:\n var_2 += 1\nprint(var_2)\n```", "output": "SLOWER 1.6655", "pair_id": "python_p03416_pair0208_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 3.1723} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\n\nvar_10 = sys.stdin.readline\nvar_2, var_3 = list(map(int, var_10().split()))\nvar_1 = [list(map(int, var_10().split())) for _ in range(var_2)]\nvar_8 = [[0 for _ in range(var_2 + 1)] for _ in range(var_3 + 1)]\n\nvar_13 = [[0 for _ in range(var_2 + 1)] for _ in range(var_3 + 1)]\nfor var_11 in range(var_2):\n var_4, var_6 = var_1[var_11]\n for var_15 in range(var_3):\n if var_4 > var_15:\n var_8[var_15][var_11 + 1] = var_8[var_15][var_11]\n var_13[var_15][var_11 + 1] = var_15\n else:\n if var_6 + var_8[var_15 - var_4][var_11] >= var_8[var_15][var_11]:\n var_8[var_15][var_11 + 1] = var_8[var_15 - var_4][var_11] + var_6\n var_13[var_15][var_11 + 1] = var_15 - var_4\n else:\n var_8[var_15][var_11 + 1] = var_8[var_15][var_11]\n var_13[var_15][var_11 + 1] = var_15\nvar_5 = var_8[var_3 - 1][var_2]\nvar_14 = [False] * var_2\nvar_7 = var_3 - 1\nfor var_9 in reversed(list(range(var_2))):\n if var_13[var_7][var_9 + 1] == var_7 - var_1[var_9][0]:\n var_14[var_9] = True\n var_7 = var_13[var_7][var_9 + 1]\nvar_12 = 0\nfor var_9 in range(var_2):\n if not var_14[var_9] and var_1[var_9][1] > var_12:\n var_12 = var_1[var_9][1]\nprint((var_5 + var_12))\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\n\nsys.setrecursionlimit(2147483647)\nvar_2 = float(\"inf\")\nvar_3 = 10**9 + 7\nvar_10 = lambda: sys.stdin.readline().rstrip()\n\n\ndef func_1():\n var_11, var_4 = list(map(int, var_10().split()))\n var_1 = [tuple(map(int, var_10().split())) for _ in range(var_11)]\n var_1.sort()\n var_8 = [0] * var_4\n var_6 = -var_2\n for var_9 in range(var_11):\n var_5, var_7 = var_1[var_9]\n var_12 = var_8[:]\n for var_13 in range(var_4):\n if var_13 + var_5 < var_4:\n var_12[var_13 + var_5] = max(\n var_12[var_13 + var_5], var_8[var_13] + var_7\n )\n else:\n var_6 = max(var_6, var_8[var_13] + var_7)\n var_8 = var_12\n print((max(var_6, max(var_8))))\n\n\nfunc_1()\n```", "output": "FASTER 1.5241", "pair_id": "python_p02863_pair0010_forward", "problem_id": "p02863", "language": "python", "direction": "forward", "speedup_ratio": 2.8761} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\ndef func_1():\n var_1, var_2 = list(map(int, input().split()))\n var_3 = 0\n for var_4 in range(var_1, var_2 + 1):\n\n if (var_4 % 10) == (var_4 // 10000 % 10) and (var_4 // 10 % 10) == (\n var_4 // 1000 % 10\n ):\n var_3 += 1\n print(var_3)\n\n\nif __name__ == \"__main__\":\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nvar_4 = {}\nvar_5 = 0\nfor var_6 in range(10000, 100000):\n var_3 = list(str(var_6))\n if var_3 == list(reversed(var_3)):\n var_5 += 1\n var_4[var_6] = var_5\nvar_1, var_2 = list(map(int, input().split()))\nprint((var_4[var_2] - var_4[var_1 - 1] if var_1 > 10000 else var_4[var_2]))\n```", "output": "SLOWER 5.2377", "pair_id": "python_p03416_pair0209_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 37.7303} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_3 = list(map(int, input().split()))\nvar_2 = -1\nfor var_4 in range(10, 12501):\n if int(var_4 * 0.08) == var_1 and int(var_4 * 0.1) == var_3:\n var_2 = var_4\n break\nprint(var_2)\n```\n\n=== Code B (Modified) ===\n```python\nfrom math import floor\n\nvar_1, var_2 = list(map(int, input().split()))\n\n\nfor var_3 in range(1010):\n if (floor(var_3 * 0.08) == var_1) and (floor(var_3 * 0.1) == var_2):\n\n print(var_3)\n quit()\n\n\nprint((-1))\n```", "output": "FASTER 3.4688", "pair_id": "python_p02755_pair0009_forward", "problem_id": "p02755", "language": "python", "direction": "forward", "speedup_ratio": 11.0714} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nfrom collections import Counter, defaultdict, deque\nfrom heapq import heappop, heappush, heapify\nimport sys, bisect, math, itertools, fractions, pprint\n\nsys.setrecursionlimit(10**8)\nvar_6 = 10**9 + 7\nvar_1 = float(\"inf\")\n\n\ndef func_1():\n return int(sys.stdin.readline())\n\n\ndef func_2():\n return list(map(int, sys.stdin.readline().split()))\n\n\nvar_7, var_9 = func_2()\nvar_13 = [func_2() for _ in range(var_7)]\nvar_13.sort(key=lambda var_14: var_14[1], reverse=True)\nvar_8 = 0\nvar_10 = min(var_7, 5)\nfor var_3 in range(var_10):\n var_2 = [[0] * (var_9 + 5) for _ in range(var_7 + 5)]\n for var_4 in range(var_7):\n var_12, var_11 = var_13[var_4]\n for var_5 in range(var_9):\n if var_5 < var_12 or var_3 == var_4:\n var_2[var_4 + 1][var_5] = var_2[var_4][var_5]\n else:\n var_2[var_4 + 1][var_5] = max(\n var_2[var_4][var_5], var_2[var_4][var_5 - var_12] + var_11\n )\n\n var_8 = max(var_2[var_7][var_9 - 1] + var_13[var_3][1], var_8)\nprint(var_8)\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\nfrom operator import itemgetter\nfrom heapq import heapify, heappop, heappush\n\nvar_1 = int(10e15)\nvar_2 = -var_1\nvar_11 = 1000000007\nsys.setrecursionlimit(1000000)\n\n\ndef func_2():\n return list(map(int, input().split()))\n\n\ndef func_4():\n return input().split()\n\n\ndef func_1():\n return int(sys.stdin.readline())\n\n\ndef func_3():\n return eval(input())\n\n\nvar_3, var_4 = func_2()\nvar_5 = [func_2() for var_9 in range(var_3)]\nvar_5.sort(key=itemgetter(0))\n\nvar_8 = [[0] * (var_4 + 1 + 3000 + 1) for _ in range(var_3 + 1)]\nvar_6 = 0\nfor var_9 in range(var_3):\n for var_10 in range(var_4 + 1 + 3000 + 1):\n var_12, var_7 = var_5[var_9]\n if 0 <= var_10 - var_12 < var_4:\n var_8[var_9 + 1][var_10] = max(\n var_8[var_9][var_10], var_8[var_9][var_10 - var_12] + var_7\n )\n else:\n var_8[var_9 + 1][var_10] = var_8[var_9][var_10]\n var_6 = max(var_6, var_8[var_9 + 1][var_10])\nprint(var_6)\n```", "output": "SLOWER 3.1764", "pair_id": "python_p02863_pair0056_reversed", "problem_id": "p02863", "language": "python", "direction": "reversed", "speedup_ratio": 9.0403} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_3 = list(map(int, input().split()))\nvar_2 = 0\nfor var_5 in range(var_3 + 1)[var_1:]:\n if len(str(var_5)) % 2 == 0:\n var_6 = list(str(var_5))[: len(str(var_5)) // 2]\n var_7 = list(reversed(list(str(var_5))[len(str(var_5)) // 2 :]))\n if var_6 == var_7:\n var_2 += 1\n else:\n var_8 = list(str(var_5))[: len(str(var_5)) // 2 + 1]\n var_4 = list(reversed(list(str(var_5))[len(str(var_5)) // 2 :]))\n if var_8 == var_4:\n var_2 += 1\nprint(var_2)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1 = list(map(int, input().split()))\nvar_2 = 0\nfor var_3 in range(var_1[0], var_1[1] + 1):\n var_4 = str(var_3)\n if var_4[0] == var_4[4] and var_4[1] == var_4[3]:\n var_2 += 1\nprint(var_2)\n```", "output": "FASTER 2.7633", "pair_id": "python_p03416_pair0116_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 6.7897} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\n\nvar_8 = sys.stdin.readline\n\n\ndef func_1():\n var_2 = int(eval(var_8()))\n var_1 = []\n for _ in range(var_2):\n var_1.append(list(map(int, var_8().split())))\n var_3 = []\n for _ in range(var_2):\n var_3.append(list(map(int, var_8().split())))\n var_4 = -(10**7) * var_2\n for var_7 in range(1, 1 << 10):\n var_11 = 0\n for var_10, var_6 in enumerate(var_1):\n var_5 = 0\n for var_9 in range(10):\n if (var_7 >> var_9) & 1 & var_6[var_9]:\n var_5 += 1\n var_11 += var_3[var_10][var_5]\n var_4 = max(var_4, var_11)\n print(var_4)\n\n\nif __name__ == \"__main__\":\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nvar_5 = 0\nif var_5 == 0:\n var_8 = int(eval(input()))\n var_2 = []\n for var_4 in range(var_8):\n var_3 = list(map(int, input().split()))\n var_2.append(var_3)\n var_9 = []\n for var_4 in range(var_8):\n var_10 = list(map(int, input().split()))\n var_9.append(var_10)\nelif var_5 == 1:\n var_8 = 1\n var_2 = [[1, 1, 0, 1, 0, 0, 0, 1, 0, 1]]\n var_9 = [[3, 4, 5, 6, 7, 8, 9, -2, -3, 4, -2]]\nelif var_5 == 2:\n var_8 = 2\n var_2 = [[1, 1, 1, 1, 1, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 1, 1, 1, 1, 1]]\n var_9 = [\n [0, -2, -2, -2, -2, -2, -1, -1, -1, -1, -1],\n [0, -2, -2, -2, -2, -2, -1, -1, -1, -1, -1],\n ]\nelif var_5 == 3:\n var_8 = 3\n var_2 = [\n [1, 1, 1, 1, 1, 1, 0, 0, 1, 1],\n [0, 1, 0, 1, 1, 1, 1, 0, 1, 0],\n [1, 0, 1, 1, 0, 1, 0, 1, 0, 1],\n ]\n var_9 = [\n [-8, 6, -2, -8, -8, 4, 8, 7, -6, 2, 2],\n [-9, 2, 0, 1, 7, -5, 0, -2, -6, 5, 5],\n [6, -6, 7, -9, 6, -5, 8, 0, -9, -7, -7],\n ]\nimport itertools\n\nvar_13 = -(10**11)\nfor var_4 in itertools.product([0, 1], repeat=10):\n var_11 = list(var_4)\n var_12 = 0\n if sum(var_11) != 0:\n for var_7 in range(var_8):\n var_1 = 0\n for var_6 in range(10):\n var_1 = var_1 + var_11[var_6] * var_2[var_7][var_6]\n var_12 = var_12 + var_9[var_7][var_1]\n\n var_13 = max(var_12, var_13)\nprint(var_13)\n```", "output": "SLOWER 1.363", "pair_id": "python_p03503_pair0014_reversed", "problem_id": "p03503", "language": "python", "direction": "reversed", "speedup_ratio": 2.5722} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = [\n var_3 for var_3 in map(str, list(range(var_1, var_2 + 1))) if var_3 == var_3[::-1]\n]\nprint((len(var_4)))\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = [0] * (var_2 + 1)\nfor var_3 in range(1, var_2 + 1):\n if str(var_3) == str(var_3)[::-1]:\n var_4[var_3] = var_4[var_3 - 1] + 1\n else:\n var_4[var_3] = var_4[var_3 - 1]\nprint((var_4[var_2] - var_4[var_1 - 1]))\n```", "output": "SLOWER 2.6408", "pair_id": "python_p03416_pair0119_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 6.2369} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_5 in range(10):\n for var_6 in range(10):\n for var_7 in range(10):\n var_3 = 10000 * var_5 + 1000 * var_6 + 100 * var_7 + 10 * var_6 + var_5\n if var_1 <= var_3 <= var_2:\n var_4 += 1\nprint(var_4)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\n\n\ndef func_1(var_5):\n var_4 = 0\n for var_3 in range(1, var_5 + 1):\n if str(var_3) == str(var_3)[::-1]:\n var_4 += 1\n return var_4\n\n\nprint((func_1(var_2) - func_1(var_1 - 1)))\n```", "output": "SLOWER 5.4162", "pair_id": "python_p03416_pair0210_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 42.7005} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nfrom sys import stdin\n\nvar_6 = lambda: list(map(int, stdin.readline().split()))\nvar_5 = lambda: list(map(int, stdin.readline().split()))\nvar_1, var_3 = var_6()\nvar_2 = 0\nfor var_4 in range(var_1, var_3 + 1):\n var_7 = str(var_4)\n if var_7 == var_7[::-1]:\n var_2 += 1\nprint(var_2)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\n\n\ndef func_1(var_5):\n var_4 = 0\n for var_3 in range(1, var_5 + 1):\n if str(var_3) == str(var_3)[::-1]:\n var_4 += 1\n return var_4\n\n\nprint((func_1(var_2) - func_1(var_1 - 1)))\n```", "output": "SLOWER 1.5722", "pair_id": "python_p03416_pair0129_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 2.9736} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = [0] * (var_2 + 1)\nfor var_3 in range(1, var_2 + 1):\n if str(var_3) == str(var_3)[::-1]:\n var_4[var_3] = var_4[var_3 - 1] + 1\n else:\n var_4[var_3] = var_4[var_3 - 1]\nprint((var_4[var_2] - var_4[var_1 - 1]))\n```\n\n=== Code B (Modified) ===\n```python\nfrom sys import stdin\n\nvar_6 = lambda: list(map(int, stdin.readline().split()))\nvar_5 = lambda: list(map(int, stdin.readline().split()))\nvar_1, var_3 = var_6()\nvar_2 = 0\nfor var_4 in range(var_1, var_3 + 1):\n var_7 = str(var_4)\n if var_7 == var_7[::-1]:\n var_2 += 1\nprint(var_2)\n```", "output": "FASTER 1.9239", "pair_id": "python_p03416_pair0177_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 3.7944} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_6 = int(eval(input()))\nvar_2 = list(map(int, input().split()))\nfrom itertools import product\n\nvar_5 = [-1, 0, 1]\nvar_3 = 0\nfor var_7 in product(var_5, repeat=var_6):\n var_1 = []\n for var_4 in range(var_6):\n var_1.append(var_7[var_4] + var_2[var_4])\n if any(var_8 % 2 == 0 for var_8 in var_1):\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_4 = int(eval(input()))\nvar_2 = list(map(int, input().split()))\n\n\ndef func_1(var_1, var_8, var_3):\n if var_8 == var_4:\n var_9 = 1\n for var_5 in var_3:\n var_9 *= var_5\n return 1 if var_9 % 2 == 0 else 0\n var_6 = var_3.copy()\n var_6.append(var_1[var_8] - 1)\n var_5 = var_3.copy()\n var_5.append(var_1[var_8])\n var_7 = var_3.copy()\n var_7.append(var_1[var_8] + 1)\n return (\n func_1(var_1, var_8 + 1, var_6)\n + func_1(var_1, var_8 + 1, var_5)\n + func_1(var_1, var_8 + 1, var_7)\n )\n\n\nprint((func_1(var_2, 0, [])))\n```", "output": "FASTER 1.5499", "pair_id": "python_p03568_pair0016_forward", "problem_id": "p03568", "language": "python", "direction": "forward", "speedup_ratio": 2.928} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = str(var_4)\n if var_5 == var_5[::-1]:\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\ndef func_1():\n var_1, var_2 = list(map(int, input().split()))\n var_3 = 0\n for var_4 in range(var_1, var_2 + 1):\n\n if (var_4 % 10) == (var_4 // 10000 % 10) and (var_4 // 10 % 10) == (\n var_4 // 1000 % 10\n ):\n var_3 += 1\n print(var_3)\n\n\nif __name__ == \"__main__\":\n func_1()\n```", "output": "FASTER 1.6596", "pair_id": "python_p03416_pair0211_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 3.1592} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_2, var_3, *var_1 = list(map(int, open(0).read().split()))\nvar_4 = [0] * (var_3 + max(var_1[::2]))\nfor var_7, var_6 in sorted(zip(*[iter(var_1)] * 2)):\n for var_5 in reversed(list(range(var_3))):\n var_4[var_5 + var_7] = max(var_4[var_5 + var_7], var_4[var_5] + var_6)\nprint((max(var_4)))\n```\n\n=== Code B (Modified) ===\n```python\nfrom collections import Counter, defaultdict, deque\nfrom heapq import heappop, heappush, heapify\nimport sys, bisect, math, itertools, fractions, pprint\n\nsys.setrecursionlimit(10**8)\nvar_6 = 10**9 + 7\nvar_1 = float(\"inf\")\n\n\ndef func_1():\n return int(sys.stdin.readline())\n\n\ndef func_2():\n return list(map(int, sys.stdin.readline().split()))\n\n\nvar_7, var_9 = func_2()\nvar_13 = [func_2() for _ in range(var_7)]\nvar_13.sort(key=lambda var_14: var_14[1], reverse=True)\nvar_8 = 0\nvar_10 = min(var_7, 5)\nfor var_3 in range(var_10):\n var_2 = [[0] * (var_9 + 5) for _ in range(var_7 + 5)]\n for var_4 in range(var_7):\n var_12, var_11 = var_13[var_4]\n for var_5 in range(var_9):\n if var_5 < var_12 or var_3 == var_4:\n var_2[var_4 + 1][var_5] = var_2[var_4][var_5]\n else:\n var_2[var_4 + 1][var_5] = max(\n var_2[var_4][var_5], var_2[var_4][var_5 - var_12] + var_11\n )\n\n var_8 = max(var_2[var_7][var_9 - 1] + var_13[var_3][1], var_8)\nprint(var_8)\n```", "output": "SLOWER 2.226", "pair_id": "python_p02863_pair0057_reversed", "problem_id": "p02863", "language": "python", "direction": "reversed", "speedup_ratio": 4.6782} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\n\nsys.setrecursionlimit(500000)\n\n\ndef func_3():\n return sys.stdin.readline()[:-1]\n\n\nclass Class_1:\n def __init__(self, var_3):\n self.N = len(var_3)\n self.bit = [0] * self.N\n for var_11, var_14 in enumerate(var_3):\n self.add(var_11, var_14)\n\n def func_1(self, var_5, var_18):\n var_19 = var_5 + 1\n for var_11 in range(1000):\n self.bit[var_19 - 1] += var_18\n var_19 += var_19 & -var_19\n if var_19 > self.N:\n break\n\n def func_5(self, var_5):\n var_19 = var_5 + 1\n var_16 = 0\n for var_11 in range(1000):\n var_16 += self.bit[var_19 - 1]\n var_19 -= var_19 & -var_19\n if var_19 <= 0:\n break\n return var_16\n\n\ndef func_4():\n var_4, var_2, var_1 = list(map(int, func_3().split()))\n var_9 = []\n for var_11 in range(var_4):\n var_19, var_10 = list(map(int, func_3().split()))\n if var_10 % var_1 == 0:\n var_9.append([var_19, var_10 // var_1])\n else:\n var_9.append([var_19, var_10 // var_1 + 1])\n var_9.sort(key=lambda var_19: var_19[0])\n\n def func_2(var_12):\n var_19 = var_9[var_12][0]\n if var_9[var_4 - 1][0] <= var_19 + 2 * var_2:\n return var_4 - 1\n var_14 = var_12\n var_15 = var_4 - 1\n while var_15 - var_14 > 1:\n if var_9[(var_15 + var_14) // 2][0] <= var_19 + 2 * var_2:\n var_14 = (var_15 + var_14) // 2\n else:\n var_15 = (var_15 + var_14) // 2\n return var_14\n\n var_6 = Class_1([0] * var_4)\n var_7 = 0\n for var_11 in range(var_4):\n if var_11 > 0:\n var_17 = var_6.sum(var_4 - 1) - var_6.sum(var_11 - 1)\n else:\n var_17 = 0\n if var_9[var_11][1] - var_17 > 0:\n var_7 += var_9[var_11][1] - var_17\n var_13 = func_2(var_11)\n var_6.add(var_13, var_9[var_11][1] - var_17)\n var_9 = var_9[::-1]\n for var_11 in range(var_4):\n var_9[var_11][0] = -var_9[var_11][0]\n var_6 = Class_1([0] * var_4)\n var_8 = 0\n for var_11 in range(var_4):\n if var_11 > 0:\n var_17 = var_6.sum(var_4 - 1) - var_6.sum(var_11 - 1)\n else:\n var_17 = 0\n if var_9[var_11][1] - var_17 > 0:\n var_8 += var_9[var_11][1] - var_17\n var_13 = func_2(var_11)\n var_6.add(var_13, var_9[var_11][1] - var_17)\n print((min(var_7, var_8)))\n\n\nif __name__ == \"__main__\":\n func_4()\n```\n\n=== Code B (Modified) ===\n```python\nimport bisect\n\nvar_9, var_4, var_1 = list(map(int, input().split()))\nvar_5 = [None] * var_9\nfor var_7 in range(var_9):\n var_11, var_6 = list(map(int, input().split()))\n var_5[var_7] = (var_11, var_6)\nvar_5.sort()\nvar_11 = [int(var_5[var_7][0]) for var_7 in range(var_9)]\nvar_6 = [int(var_5[var_7][1]) for var_7 in range(var_9)]\nvar_2 = 0\nvar_3 = [0] * var_9\nfor var_7 in range(var_9):\n if var_7 != 0:\n var_3[var_7] += var_3[var_7 - 1]\n if var_3[var_7] >= var_6[var_7]:\n continue\n var_10 = (var_6[var_7] - var_3[var_7] - 1) // var_1 + 1\n var_2 += var_10\n var_3[var_7] += var_10 * var_1\n var_8 = bisect.bisect_right(var_11, var_11[var_7] + 2 * var_4)\n if var_8 == var_9:\n continue\n var_3[var_8] -= var_10 * var_1\nprint(var_2)\n```", "output": "FASTER 1.3694", "pair_id": "python_p02788_pair0003_forward", "problem_id": "p02788", "language": "python", "direction": "forward", "speedup_ratio": 2.5837} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = str(var_4)\n if var_5 == var_5[::-1]:\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_8 in range(var_1, var_2 + 1):\n var_7 = str(var_8)\n var_6 = len(var_7)\n var_4 = True\n for var_5 in range(var_6 // 2):\n if var_7[var_5] != var_7[var_6 - 1 - var_5]:\n var_4 = False\n break\n if var_4:\n var_3 += 1\nprint(var_3)\n```", "output": "SLOWER 1.1307", "pair_id": "python_p03416_pair0192_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 2.1897} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nfrom functools import reduce\nfrom itertools import product\n\nvar_2 = int(eval(input()))\n(*var_1,) = list(map(int, input().split()))\nvar_4 = 0\nfor var_7 in product([-1, 0, 1], repeat=var_2):\n var_6 = reduce(\n lambda var_8, var_9: var_8 * var_9,\n [var_3 + var_7[var_5] for var_5, var_3 in enumerate(var_1)],\n )\n if var_6 % 2 == 0:\n var_4 += 1\nprint(var_4)\n```\n\n=== Code B (Modified) ===\n```python\ndef func_1():\n var_2 = int(input())\n var_1 = [int(var_6) for var_6 in input().split()]\n if var_2 == 1:\n return print(1 if var_1[0] % 2 == 0 else 2)\n var_3 = 0\n var_5 = (-1, 0, 1)\n from itertools import product\n\n for var_6 in product(range(3), repeat=var_2):\n var_4 = 1\n for var_7 in range(var_2):\n var_4 *= var_1[var_7] + var_5[var_6[var_7]]\n if var_4 % 2 == 0:\n var_3 += 1\n print(var_3)\n\n\nif __name__ == \"__main__\":\n func_1()\n```", "output": "FASTER 1.1995", "pair_id": "python_p03568_pair0043_forward", "problem_id": "p03568", "language": "python", "direction": "forward", "speedup_ratio": 2.2966} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_6, var_5 = list(map(int, input().split()))\nvar_8 = [[] for _ in range(var_6)]\nfor var_2 in range(var_5):\n var_10, var_11 = input().split()\n var_8[int(var_10) - 1].append(var_11)\n\nvar_1, var_7 = 0, 0\nfor var_3 in range(var_6):\n var_9 = var_8[var_3]\n if \"AC\" in var_9:\n var_1 += 1\n for var_4 in var_9:\n if var_4 == \"WA\":\n var_7 += 1\n else:\n break\nprint((var_1, var_7))\n```\n\n=== Code B (Modified) ===\n```python\nvar_2, var_1 = list(map(int, input().split()))\nvar_3 = 0\nvar_8 = 0\nvar_4 = [0] * (var_2 + 1)\nvar_9 = [0] * (var_2 + 1)\nfor var_5 in range(var_1):\n var_6, var_7 = input().split()\n var_6 = int(var_6)\n if var_7 == \"AC\":\n if var_4[var_6] == 0:\n var_3 += 1\n var_8 += var_9[var_6]\n var_4[var_6] = 1\n else:\n var_9[var_6] += 1\nprint((var_3, var_8))\n```", "output": "FASTER 4.7247", "pair_id": "python_p02802_pair0007_forward", "problem_id": "p02802", "language": "python", "direction": "forward", "speedup_ratio": 26.4418} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\nfrom collections import deque\n\nvar_13 = sys.stdin.readline\nvar_2 = int(eval(var_13()))\nvar_5 = [deque() for _ in range(var_2)]\nvar_3 = [-1] * var_2\nfor var_12 in range(var_2 - 1):\n var_6, var_8 = list(map(int, var_13().split()))\n var_5[var_6 - 1].append((var_12, var_8 - 1))\n\n\nvar_4 = deque([(0, -1)])\nvar_1 = [-1] * (var_2 - 1)\nvar_11 = 0\nwhile var_4:\n var_14, var_10 = var_4.pop()\n var_9 = 1\n for var_12, var_15 in var_5[var_14]:\n if var_9 == var_10:\n var_9 += 1\n var_1[var_12] = var_9\n var_4.appendleft((var_15, var_9))\n var_9 += 1\n var_11 = max(var_11, var_9 - 1)\nprint(var_11)\nfor var_7 in var_1:\n print(var_7)\n```\n\n=== Code B (Modified) ===\n```python\nvar_11 = int(eval(input()))\nvar_12 = {var_8: [] for var_8 in range(1, var_11 + 1)}\nvar_19 = [False for var_8 in range(var_11 + 1)]\nvar_16 = []\nfor _ in range(var_11 - 1):\n var_2, var_3 = list(map(int, input().split()))\n var_12[var_2].append(var_3)\n var_12[var_3].append(var_2)\n var_16.append((var_2, var_3))\nvar_9 = var_16[0][0]\nvar_19[var_9] = True\nvar_6 = []\nvar_7 = []\nvar_14 = {var_8: {} for var_8 in range(1, var_11 + 1)}\nvar_10 = [0 for var_8 in range(var_11 + 1)]\n\nvar_4 = 1\nfor var_5 in var_12[var_9]:\n var_19[var_5] = True\n var_14[var_9][var_5] = var_4\n var_14[var_5][var_9] = var_4\n var_10[var_5] = var_4\n var_4 += 1\n var_6.append(var_5)\nwhile var_6:\n for var_15 in var_6:\n var_13 = 1\n for var_5 in var_12[var_15]:\n if var_19[var_5] == False:\n var_19[var_5] = True\n if var_13 != var_10[var_15]:\n var_14[var_15][var_5] = var_13\n var_14[var_5][var_15] = var_13\n var_10[var_5] = var_13\n var_13 += 1\n var_7.append(var_5)\n else:\n var_13 += 1\n var_14[var_15][var_5] = var_13\n var_14[var_5][var_15] = var_13\n var_10[var_5] = var_13\n var_13 += 1\n var_7.append(var_5)\n if var_7:\n var_6 = var_7\n var_7 = []\n else:\n var_6 = []\n var_7 = []\nvar_1 = 0\nfor var_8 in range(1, var_11 + 1):\n var_1 = max(var_1, len(var_12[var_8]))\nprint(var_1)\nfor var_8 in range(var_11 - 1):\n var_17, var_18 = var_16[var_8][0], var_16[var_8][1]\n print((var_14[var_17][var_18]))\n```", "output": "SLOWER 1.0442", "pair_id": "python_p02850_pair0028_reversed", "problem_id": "p02850", "language": "python", "direction": "reversed", "speedup_ratio": 2.0622} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_11 = int(eval(input()))\nvar_12 = {var_8: [] for var_8 in range(1, var_11 + 1)}\nvar_19 = [False for var_8 in range(var_11 + 1)]\nvar_16 = []\nfor _ in range(var_11 - 1):\n var_2, var_3 = list(map(int, input().split()))\n var_12[var_2].append(var_3)\n var_12[var_3].append(var_2)\n var_16.append((var_2, var_3))\nvar_9 = var_16[0][0]\nvar_19[var_9] = True\nvar_6 = []\nvar_7 = []\nvar_14 = {var_8: {} for var_8 in range(1, var_11 + 1)}\nvar_10 = [0 for var_8 in range(var_11 + 1)]\n\nvar_4 = 1\nfor var_5 in var_12[var_9]:\n var_19[var_5] = True\n var_14[var_9][var_5] = var_4\n var_14[var_5][var_9] = var_4\n var_10[var_5] = var_4\n var_4 += 1\n var_6.append(var_5)\nwhile var_6:\n for var_15 in var_6:\n var_13 = 1\n for var_5 in var_12[var_15]:\n if var_19[var_5] == False:\n var_19[var_5] = True\n if var_13 != var_10[var_15]:\n var_14[var_15][var_5] = var_13\n var_14[var_5][var_15] = var_13\n var_10[var_5] = var_13\n var_13 += 1\n var_7.append(var_5)\n else:\n var_13 += 1\n var_14[var_15][var_5] = var_13\n var_14[var_5][var_15] = var_13\n var_10[var_5] = var_13\n var_13 += 1\n var_7.append(var_5)\n if var_7:\n var_6 = var_7\n var_7 = []\n else:\n var_6 = []\n var_7 = []\nvar_1 = 0\nfor var_8 in range(1, var_11 + 1):\n var_1 = max(var_1, len(var_12[var_8]))\nprint(var_1)\nfor var_8 in range(var_11 - 1):\n var_17, var_18 = var_16[var_8][0], var_16[var_8][1]\n print((var_14[var_17][var_18]))\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\n\nvar_8 = sys.stdin.readline\nvar_9 = int(eval(var_8()))\nvar_6 = []\nfor var_7 in range(var_9 - 1):\n var_1, var_3 = list(map(int, var_8().split()))\n var_6.append([var_1 - 1, var_3 - 1, var_7])\nvar_6.sort()\nvar_13 = [0] * (var_9)\nvar_2 = [0] * (var_9 - 1)\nvar_10 = 1\nvar_11 = 0\nfor var_5 in var_6:\n _from, var_12, var_7 = var_5\n if _from != var_11:\n var_10 = 1\n if var_13[_from] == var_10:\n var_10 += 1\n var_2[var_7] = var_10\n var_13[var_12] = var_10\n var_10 += 1\n var_11 = _from\nprint((max(var_2)))\nfor var_4 in var_2:\n print(var_4)\n```", "output": "FASTER 1.2377", "pair_id": "python_p02850_pair0025_forward", "problem_id": "p02850", "language": "python", "direction": "forward", "speedup_ratio": 2.3582} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_10 = []\nvar_10 = input().rstrip().split(\" \")\nvar_1 = int(var_10[0])\nvar_3 = int(var_10[1])\nvar_2 = 0\nvar_6 = var_1\nwhile var_6 <= var_3:\n var_4 = var_6 // 10000\n var_5 = (var_6 - var_4 * 10000) // 1000\n var_7 = var_6 // 100\n var_8 = (var_6 - var_7 * 100) // 10\n var_9 = var_6 % 10\n if (var_4 == var_9) and (var_5 == var_8):\n var_2 += 1\n var_6 += 1\nprint(var_2)\n```\n\n=== Code B (Modified) ===\n```python\nvar_4 = {}\nvar_5 = 0\nfor var_6 in range(10000, 100000):\n var_3 = list(str(var_6))\n if var_3 == list(reversed(var_3)):\n var_5 += 1\n var_4[var_6] = var_5\nvar_1, var_2 = list(map(int, input().split()))\nprint((var_4[var_2] - var_4[var_1 - 1] if var_1 > 10000 else var_4[var_2]))\n```", "output": "SLOWER 2.7646", "pair_id": "python_p03416_pair0041_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 6.7956} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_4 = str(var_4)\n if var_4[0] == var_4[-1] and var_4[1] == var_4[-2]:\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_8 in range(var_1, var_2 + 1):\n var_7 = str(var_8)\n var_6 = len(var_7)\n var_4 = True\n for var_5 in range(var_6 // 2):\n if var_7[var_5] != var_7[var_6 - 1 - var_5]:\n var_4 = False\n break\n if var_4:\n var_3 += 1\nprint(var_3)\n```", "output": "SLOWER 1.3099", "pair_id": "python_p03416_pair0140_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 2.4793} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_4, var_3 = list(map(int, input().split()))\nvar_1 = 0\nfor var_2 in range(var_4, var_3 + 1):\n if str(var_2)[0] + str(var_2)[1] == str(var_2)[-1] + str(var_2)[-2]:\n var_1 += 1\nprint(var_1)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = str(var_4)\n if var_5 == var_5[::-1]:\n var_3 += 1\nprint(var_3)\n```", "output": "FASTER 1.3456", "pair_id": "python_p03416_pair0212_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 2.5413} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = [\n var_3 for var_3 in map(str, list(range(var_1, var_2 + 1))) if var_3 == var_3[::-1]\n]\nprint((len(var_4)))\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().strip().split(\" \")))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n if str(var_4) == str(var_4)[::-1]:\n var_3 += 1\nprint(var_3)\n```", "output": "SLOWER 1.0058", "pair_id": "python_p03416_pair0070_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 2.0081} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\ndef func_1():\n from sys import setrecursionlimit, stdin\n from os import environ\n from collections import defaultdict, deque, Counter\n from math import ceil, floor, gcd\n from itertools import accumulate, combinations, combinations_with_replacement\n\n setrecursionlimit(10**6)\n var_7 = (\n (lambda *var_11: print(*var_11))\n if \"TERM_PROGRAM\" in environ\n else lambda *var_12: 0\n )\n var_8 = lambda: stdin.readline().rstrip()\n var_3 = lambda: list(map(int, var_8().split()))\n var_1 = lambda: int(var_8())\n var_4 = 10**9 + 7\n var_2 = 10**9 + 10\n var_9, var_10 = var_8().split()\n var_5 = int(var_9)\n var_6 = int(float(var_10) * 100 + 0.5)\n print(var_5 * var_6 // 100)\n\n\nfunc_1()\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\n\nvar_5 = sys.stdin.readline\nif __name__ == \"__main__\":\n var_1, var_3 = var_5().split()\n var_2 = int(var_1)\n var_4 = round(float(var_3) * 100)\n print((var_2 * var_4 // 100))\n```", "output": "FASTER 1.7429", "pair_id": "python_p02659_pair0020_forward", "problem_id": "p02659", "language": "python", "direction": "forward", "speedup_ratio": 3.347} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\n\n\ndef func_1(var_5):\n var_4 = 0\n for var_3 in range(1, var_5 + 1):\n if str(var_3) == str(var_3)[::-1]:\n var_4 += 1\n return var_4\n\n\nprint((func_1(var_2) - func_1(var_1 - 1)))\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = str(var_4)\n if var_5 == var_5[::-1]:\n var_3 += 1\nprint(var_3)\n```", "output": "FASTER 1.5951", "pair_id": "python_p03416_pair0213_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 3.0211} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport copy\n\nvar_8 = int(eval(input()))\nvar_10 = set([var_6 for var_6 in range(1, 10**5)])\nvar_5 = []\nvar_11 = {}\nvar_9 = []\nfor var_6 in range(var_8 - 1):\n var_1, var_2 = list(map(int, input().split(\" \")))\n var_5.append([var_1, var_2])\n var_11.setdefault(var_1, []).append(var_2)\n var_9.append([])\nvar_9.append([])\nvar_9.append([])\nvar_7 = 0\nfor var_12 in range(1, var_8 + 1):\n var_14 = var_11.get(var_12, [])\n var_3 = 1\n for var_13 in var_14:\n if var_3 in var_9[var_12]:\n var_3 += 1\n else:\n pass\n var_9[var_13].append(var_3)\n if var_3 >= var_7:\n var_7 = var_3\n var_3 += 1\nprint(var_7)\nfor var_4 in var_5:\n print((var_9[var_4[1]][0]))\n```\n\n=== Code B (Modified) ===\n```python\nvar_11 = int(eval(input()))\nvar_12 = {var_8: [] for var_8 in range(1, var_11 + 1)}\nvar_19 = [False for var_8 in range(var_11 + 1)]\nvar_16 = []\nfor _ in range(var_11 - 1):\n var_2, var_3 = list(map(int, input().split()))\n var_12[var_2].append(var_3)\n var_12[var_3].append(var_2)\n var_16.append((var_2, var_3))\nvar_9 = var_16[0][0]\nvar_19[var_9] = True\nvar_6 = []\nvar_7 = []\nvar_14 = {var_8: {} for var_8 in range(1, var_11 + 1)}\nvar_10 = [0 for var_8 in range(var_11 + 1)]\n\nvar_4 = 1\nfor var_5 in var_12[var_9]:\n var_19[var_5] = True\n var_14[var_9][var_5] = var_4\n var_14[var_5][var_9] = var_4\n var_10[var_5] = var_4\n var_4 += 1\n var_6.append(var_5)\nwhile var_6:\n for var_15 in var_6:\n var_13 = 1\n for var_5 in var_12[var_15]:\n if var_19[var_5] == False:\n var_19[var_5] = True\n if var_13 != var_10[var_15]:\n var_14[var_15][var_5] = var_13\n var_14[var_5][var_15] = var_13\n var_10[var_5] = var_13\n var_13 += 1\n var_7.append(var_5)\n else:\n var_13 += 1\n var_14[var_15][var_5] = var_13\n var_14[var_5][var_15] = var_13\n var_10[var_5] = var_13\n var_13 += 1\n var_7.append(var_5)\n if var_7:\n var_6 = var_7\n var_7 = []\n else:\n var_6 = []\n var_7 = []\nvar_1 = 0\nfor var_8 in range(1, var_11 + 1):\n var_1 = max(var_1, len(var_12[var_8]))\nprint(var_1)\nfor var_8 in range(var_11 - 1):\n var_17, var_18 = var_16[var_8][0], var_16[var_8][1]\n print((var_14[var_17][var_18]))\n```", "output": "FASTER 3.6078", "pair_id": "python_p02850_pair0006_forward", "problem_id": "p02850", "language": "python", "direction": "forward", "speedup_ratio": 12.1912} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_6 = sorted([list(map(int, input().split())) for var_5 in range(var_1)])\n\nvar_4 = [[0] * (var_2 + 1) for var_5 in range(var_1 + 1)]\n\nfor var_5 in range(var_1):\n var_9, var_8 = var_6[var_5]\n for var_7 in range(var_2 + 1):\n if var_7 + var_9 <= var_2:\n var_4[var_5 + 1][var_7 + var_9] = max(\n var_4[var_5 + 1][var_7 + var_9], var_4[var_5][var_7] + var_8\n )\n var_4[var_5 + 1][var_7] = max(var_4[var_5][var_7], var_4[var_5 + 1][var_7])\nvar_3 = 0\nfor var_5, (var_9, var_8) in enumerate(var_6):\n var_3 = max(var_3, var_4[var_5][var_2 - 1] + var_8)\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\ndef func_1():\n var_2, var_3, *var_1 = list(map(int, open(0).read().split()))\n var_4 = [0] * (var_3 + max(var_1[::2]))\n for var_7, var_6 in sorted(zip(*[iter(var_1)] * 2)):\n for var_5 in reversed(list(range(var_3))):\n var_4[var_5 + var_7] = max(var_4[var_5 + var_7], var_4[var_5] + var_6)\n print((max(var_4)))\n\n\nfunc_1()\n```", "output": "FASTER 1.7041", "pair_id": "python_p02863_pair0034_forward", "problem_id": "p02863", "language": "python", "direction": "forward", "speedup_ratio": 3.2582} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n if str(var_4) == \"\".join(reversed(str(var_4))):\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_5 in range(var_1, var_2 + 1):\n var_3 = str(var_5)\n if var_3[0] == var_3[-1] and var_3[1] == var_3[-2]:\n var_4 += 1\nprint(var_4)\n```", "output": "FASTER 1.1678", "pair_id": "python_p03416_pair0214_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 2.2467} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1 = (\n input()\n .replace(\"eraser\", \" \")\n .replace(\"erase\", \" \")\n .replace(\"dreamer\", \" \")\n .replace(\"dream\", \" \")\n .replace(\" \", \"\")\n)\nif var_1:\n print(\"NO\")\nelse:\n print(\"YES\")\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\n\nvar_5 = sys.stdin.readline\n\n\ndef func_1():\n var_3 = var_5().rstrip()\n var_11 = [\"dream\", \"dreamer\", \"erase\", \"eraser\"]\n var_9 = \"YES\"\n var_7 = var_3\n var_6 = var_3\n while True:\n for var_4 in range(4):\n var_10 = var_11[var_4]\n var_2 = len(var_10)\n var_1 = len(var_6)\n if var_2 <= var_1:\n var_8 = var_6[var_1 - var_2 :]\n if var_8 == var_10:\n var_6 = var_6[: var_1 - var_2]\n if var_6 == \"\":\n break\n elif var_6 == var_7:\n var_9 = \"NO\"\n break\n else:\n var_7 = var_6\n print(var_9)\n\n\nfunc_1()\n```", "output": "SLOWER 1.396", "pair_id": "python_p03854_pair0001_reversed", "problem_id": "p03854", "language": "python", "direction": "reversed", "speedup_ratio": 2.6318} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport numpy as np\nfrom itertools import product\n\nvar_6 = int(eval(input()))\nvar_2 = list(map(int, input().split()))\nvar_2 = np.array(var_2)\nvar_5 = [-1, 0, 1]\nvar_3 = 0\nfor var_7 in product(var_5, repeat=var_6):\n var_7 = np.array(var_7)\n var_1 = var_2 + var_7\n var_4 = var_1.cumprod()\n if var_4[-1] % 2 == 0:\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_2 = int(eval(input()))\nvar_1 = list(map(int, input().split()))\nvar_4 = 1\nfor var_3 in range(var_2):\n if var_1[var_3] % 2 == 0:\n var_4 *= 2\nprint((3**var_2 - var_4))\n```", "output": "FASTER 10.0427", "pair_id": "python_p03568_pair0041_forward", "problem_id": "p03568", "language": "python", "direction": "forward", "speedup_ratio": 1054.7734} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_6 = sorted([list(map(int, input().split())) for var_5 in range(var_1)])\n\nvar_4 = [[0] * (var_2 + 1) for var_5 in range(var_1 + 1)]\n\nfor var_5 in range(var_1):\n var_9, var_8 = var_6[var_5]\n for var_7 in range(var_2 + 1):\n if var_7 + var_9 <= var_2:\n var_4[var_5 + 1][var_7 + var_9] = max(\n var_4[var_5 + 1][var_7 + var_9], var_4[var_5][var_7] + var_8\n )\n var_4[var_5 + 1][var_7] = max(var_4[var_5][var_7], var_4[var_5 + 1][var_7])\nvar_3 = 0\nfor var_5, (var_9, var_8) in enumerate(var_6):\n for var_7 in range(var_2):\n var_3 = max(var_3, var_4[var_5][var_7] + var_8)\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nimport bisect\nimport sys\n\nsys.setrecursionlimit(10**6)\nvar_16 = sys.stdout.write\nvar_7 = lambda *var_14: print(*var_14) if var_1 else 0\nvar_1 = True\n\n\ndef func_1(var_9=sys.stdin.readline):\n var_11 = lambda: var_9().rstrip()\n var_3 = lambda: list(map(int, var_11().split()))\n var_2 = lambda: int(var_11())\n var_4 = lambda var_17: [var_3() for _ in range(var_17)]\n var_13, var_15 = var_3()\n var_5 = var_4(var_13)\n var_5.sort()\n var_8 = [[0] * var_15 for _ in range(var_13 + 1)]\n for var_10 in range(1, var_13 + 1):\n for var_12 in range(1, var_15):\n if var_12 < var_5[var_10 - 1][0]:\n var_8[var_10][var_12] = var_8[var_10 - 1][var_12]\n else:\n var_8[var_10][var_12] = max(\n var_8[var_10 - 1][var_12],\n var_8[var_10 - 1][var_12 - var_5[var_10 - 1][0]]\n + var_5[var_10 - 1][1],\n )\n var_6 = 0\n for var_10 in range(var_13):\n var_6 = max(var_6, var_8[var_10][var_15 - 1] + var_5[var_10][1])\n print(var_6)\n\n\nif __name__ == \"__main__\":\n func_1()\n```", "output": "FASTER 1.1662", "pair_id": "python_p02863_pair0058_forward", "problem_id": "p02863", "language": "python", "direction": "forward", "speedup_ratio": 2.2442} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_5 in range(var_1, var_2 + 1):\n var_3 = str(var_5)\n if var_3[0] == var_3[-1] and var_3[1] == var_3[-2]:\n var_4 += 1\nprint(var_4)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_3 = list(map(int, input().split()))\nvar_2 = 0\nfor var_5 in range(var_3 + 1)[var_1:]:\n if len(str(var_5)) % 2 == 0:\n var_6 = list(str(var_5))[: len(str(var_5)) // 2]\n var_7 = list(reversed(list(str(var_5))[len(str(var_5)) // 2 :]))\n if var_6 == var_7:\n var_2 += 1\n else:\n var_8 = list(str(var_5))[: len(str(var_5)) // 2 + 1]\n var_4 = list(reversed(list(str(var_5))[len(str(var_5)) // 2 :]))\n if var_8 == var_4:\n var_2 += 1\nprint(var_2)\n```", "output": "SLOWER 2.5661", "pair_id": "python_p03416_pair0215_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 5.9221} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_6 in range(var_1, var_2 + 1):\n var_3 = str(var_6)\n var_5 = True\n for var_7 in range(len(var_3) // 2):\n if var_3[var_7] != var_3[-var_7 - 1] and var_5:\n var_5 = not var_5\n if var_5:\n var_4 += 1\nprint(var_4)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_5 in range(10):\n for var_6 in range(10):\n for var_7 in range(10):\n var_3 = 10000 * var_5 + 1000 * var_6 + 100 * var_7 + 10 * var_6 + var_5\n if var_1 <= var_3 <= var_2:\n var_4 += 1\nprint(var_4)\n```", "output": "FASTER 5.2855", "pair_id": "python_p03416_pair0216_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 39.0027} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2, var_3 = list(map(int, input().split()))\nvar_4 = list(map(int, input().split()))\nvar_6 = list(map(int, input().split()))\nvar_5 = min(var_4) + min(var_6)\nfor var_8 in range(var_3):\n var_7 = list(map(int, input().split()))\n var_9 = var_4[var_7[0] - 1] + var_6[var_7[1] - 1] - var_7[2]\n var_5 = min(var_9, var_5)\nprint(var_5)\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\nfrom collections import Counter\n\n\ndef func_10():\n return sys.stdin.readline().strip()\n\n\ndef func_11(var_12, var_13, var_14):\n return [[var_14] * var_13 for var_17 in range(var_12)]\n\n\ndef func_12(var_12, var_13, var_14, var_15):\n return [[[var_15] * var_14 for var_18 in range(var_13)] for var_17 in range(var_12)]\n\n\ndef func_13(var_12, var_13, var_14, var_15, var_16):\n return [\n [[[var_16] * var_15 for var_18 in range(var_14)] for var_18 in range(var_13)]\n for var_17 in range(var_12)\n ]\n\n\ndef func_8(var_22, var_23=1):\n return int(-(-var_22 // var_23))\n\n\ndef func_1():\n return int(eval(func_10()))\n\n\ndef func_3():\n return list(map(int, func_10().split()))\n\n\ndef func_2(var_11=None):\n return list(func_3()) if var_11 is None else [func_1() for var_17 in range(var_11)]\n\n\ndef func_7():\n print(\"Yes\")\n\n\ndef func_5():\n print(\"No\")\n\n\ndef func_6():\n print(\"YES\")\n\n\ndef func_4():\n print(\"NO\")\n\n\nsys.setrecursionlimit(10**9)\nvar_5 = 10**18\nvar_10 = 10**9 + 7\n\n\ndef func_9(var_1, var_2):\n \"\"\"\"\"\"\n import numpy as np\n from numpy.fft import rfft, irfft\n\n var_8 = max(var_1)\n var_9 = max(var_2)\n var_3 = [0] * (var_8 + 1)\n var_4 = [0] * (var_9 + 1)\n for var_12 in var_1:\n var_3[var_12] += 1\n for var_13 in var_2:\n var_4[var_13] += 1\n\n var_6 = 1\n var_19 = 0\n while var_6 <= var_8 + var_9:\n var_19 += 1\n var_6 = 2**var_19\n\n var_21 = irfft(rfft(var_3, var_6) * rfft(var_4, var_6), var_6)\n\n var_21 = np.rint(var_21).astype(np.int64)\n return var_21\n\n\nvar_11, var_7, var_6 = func_3()\nvar_1 = func_2()\nvar_2 = func_2()\nvar_21 = list(func_9(var_1, var_2))\nvar_20 = var_5\nfor var_17, var_12 in enumerate(var_21):\n if var_12 != 0:\n var_20 = var_17\n break\nfor _ in range(var_6):\n var_22, var_23, var_14 = func_3()\n var_22 -= 1\n var_23 -= 1\n var_20 = min(var_20, var_1[var_22] + var_2[var_23] - var_14)\nprint(var_20)\n```", "output": "SLOWER 3.1615", "pair_id": "python_p02748_pair0006_reversed", "problem_id": "p02748", "language": "python", "direction": "reversed", "speedup_ratio": 8.9474} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_6, var_7 = list(map(int, input().split()))\nvar_1 = [list(map(int, input().split())) for _ in range(var_6)]\nvar_1.sort()\nvar_3 = [(6007) * [0] for _ in range(var_6 + 1)]\nvar_3[0][0] = 0\nvar_2 = 0\nfor var_4 in range(var_6):\n for var_5 in range(6007):\n var_3[var_4 + 1][var_5] = max(var_3[var_4 + 1][var_5], var_3[var_4][var_5])\n if var_5 < var_7:\n var_3[var_4 + 1][var_5 + var_1[var_4][0]] = max(\n var_3[var_4][var_5] + var_1[var_4][1],\n var_3[var_4][var_5 + var_1[var_4][0]],\n )\n var_2 = max(var_2, var_3[var_4 + 1][var_5])\nprint(var_2)\n```\n\n=== Code B (Modified) ===\n```python\nvar_2, var_3, *var_1 = list(map(int, open(0).read().split()))\nvar_4 = [0] * (var_3 + max(var_1[::2]))\nfor var_7, var_6 in sorted(zip(*[iter(var_1)] * 2)):\n for var_5 in reversed(list(range(var_3))):\n var_4[var_5 + var_7] = max(var_4[var_5 + var_7], var_4[var_5] + var_6)\nprint((max(var_4)))\n```", "output": "FASTER 6.3072", "pair_id": "python_p02863_pair0030_forward", "problem_id": "p02863", "language": "python", "direction": "forward", "speedup_ratio": 79.1867} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport math\nimport string\n\n\ndef func_5():\n return list(map(int, input().split()))\n\n\ndef func_4(var_7, var_8):\n return math.factorial(var_7) // (\n math.factorial(var_7 - var_8) * math.factorial(var_8)\n )\n\n\ndef func_3(var_10):\n var_9 = []\n for var_5 in var_10:\n if not (var_5 in var_9):\n var_9.append(var_5)\n return len(var_10) != len(var_9)\n\n\ndef func_1(var_7):\n func_1 = []\n for var_4 in range(1, var_7 + 1):\n if var_7 % var_4 == 0:\n func_1.append(var_4)\n return func_1\n\n\nvar_2 = [-1, -1, -1, 0, 0, 1, 1, 1]\nvar_3 = [-1, 0, 1, -1, 1, -1, 0, 1]\nvar_7 = int(eval(input()))\nvar_1 = func_5()\n\n\ndef func_2(var_6):\n if len(var_6) == var_7:\n for var_4 in range(len(var_6)):\n if var_6[var_4] % 2 == 0:\n return 1\n return 0\n return (\n func_2(var_6 + [var_1[len(var_6)]])\n + func_2(var_6 + [var_1[len(var_6)] - 1])\n + func_2(var_6 + [var_1[len(var_6)] + 1])\n )\n\n\nprint((func_2([])))\n```\n\n=== Code B (Modified) ===\n```python\nvar_2 = int(eval(input()))\nvar_1 = list(map(int, input().split()))\nvar_4 = 1\nfor var_3 in range(var_2):\n if var_1[var_3] % 2 == 0:\n var_4 *= 2\nprint((3**var_2 - var_4))\n```", "output": "FASTER 7.6602", "pair_id": "python_p03568_pair0044_forward", "problem_id": "p03568", "language": "python", "direction": "forward", "speedup_ratio": 202.2771} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\n\nvar_7 = sys.stdin.readline\nfrom itertools import combinations\n\n\ndef func_3(var_10):\n for _ in range(var_10):\n yield list(map(int, var_7().split()))\n\n\ndef func_1(var_9, var_5, var_11):\n var_3 = len([0 for var_8 in var_9 if var_5[var_8] == 1])\n return var_11[var_3]\n\n\ndef func_2():\n var_10 = int(eval(var_7()))\n var_1 = list(func_3(var_10))\n var_2 = list(func_3(var_10))\n for var_6 in range(1, 11):\n for var_4 in combinations(list(range(10)), var_6):\n yield sum(\n func_1(var_4, var_5, var_11) for var_5, var_11 in zip(var_1, var_2)\n )\n\n\nprint((max(func_2())))\n```\n\n=== Code B (Modified) ===\n```python\nvar_5 = 0\nif var_5 == 0:\n var_8 = int(eval(input()))\n var_2 = []\n for var_4 in range(var_8):\n var_3 = list(map(int, input().split()))\n var_2.append(var_3)\n var_9 = []\n for var_4 in range(var_8):\n var_10 = list(map(int, input().split()))\n var_9.append(var_10)\nelif var_5 == 1:\n var_8 = 1\n var_2 = [[1, 1, 0, 1, 0, 0, 0, 1, 0, 1]]\n var_9 = [[3, 4, 5, 6, 7, 8, 9, -2, -3, 4, -2]]\nelif var_5 == 2:\n var_8 = 2\n var_2 = [[1, 1, 1, 1, 1, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 1, 1, 1, 1, 1]]\n var_9 = [\n [0, -2, -2, -2, -2, -2, -1, -1, -1, -1, -1],\n [0, -2, -2, -2, -2, -2, -1, -1, -1, -1, -1],\n ]\nelif var_5 == 3:\n var_8 = 3\n var_2 = [\n [1, 1, 1, 1, 1, 1, 0, 0, 1, 1],\n [0, 1, 0, 1, 1, 1, 1, 0, 1, 0],\n [1, 0, 1, 1, 0, 1, 0, 1, 0, 1],\n ]\n var_9 = [\n [-8, 6, -2, -8, -8, 4, 8, 7, -6, 2, 2],\n [-9, 2, 0, 1, 7, -5, 0, -2, -6, 5, 5],\n [6, -6, 7, -9, 6, -5, 8, 0, -9, -7, -7],\n ]\nimport itertools\n\nvar_13 = -(10**11)\nfor var_4 in itertools.product([0, 1], repeat=10):\n var_11 = list(var_4)\n var_12 = 0\n if sum(var_11) != 0:\n for var_7 in range(var_8):\n var_1 = 0\n for var_6 in range(10):\n var_1 = var_1 + var_11[var_6] * var_2[var_7][var_6]\n var_12 = var_12 + var_9[var_7][var_1]\n\n var_13 = max(var_12, var_13)\nprint(var_13)\n```", "output": "SLOWER 2.018", "pair_id": "python_p03503_pair0040_reversed", "problem_id": "p03503", "language": "python", "direction": "reversed", "speedup_ratio": 4.0503} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\ndef func_1():\n var_1, var_2 = list(map(int, input().split()))\n var_3 = 0\n for var_4 in range(var_1, var_2 + 1):\n\n if (var_4 % 10) == (var_4 // 10000 % 10) and (var_4 // 10 % 10) == (\n var_4 // 1000 % 10\n ):\n var_3 += 1\n print(var_3)\n\n\nif __name__ == \"__main__\":\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n if str(var_4) == \"\".join(reversed(str(var_4))):\n var_3 += 1\nprint(var_3)\n```", "output": "SLOWER 2.7403", "pair_id": "python_p03416_pair0172_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 6.682} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_6 in range(var_1, var_2 + 1):\n var_3 = str(var_6)\n var_5 = True\n for var_7 in range(len(var_3) // 2):\n if var_3[var_7] != var_3[-var_7 - 1] and var_5:\n var_5 = not var_5\n if var_5:\n var_4 += 1\nprint(var_4)\n```\n\n=== Code B (Modified) ===\n```python\nfrom sys import stdin\n\nvar_6 = lambda: list(map(int, stdin.readline().split()))\nvar_5 = lambda: list(map(int, stdin.readline().split()))\nvar_1, var_3 = var_6()\nvar_2 = 0\nfor var_4 in range(var_1, var_3 + 1):\n var_7 = str(var_4)\n if var_7 == var_7[::-1]:\n var_2 += 1\nprint(var_2)\n```", "output": "FASTER 1.4415", "pair_id": "python_p03416_pair0125_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 2.7161} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport math\nimport string\n\n\ndef func_5():\n return list(map(int, input().split()))\n\n\ndef func_4(var_7, var_8):\n return math.factorial(var_7) // (\n math.factorial(var_7 - var_8) * math.factorial(var_8)\n )\n\n\ndef func_3(var_10):\n var_9 = []\n for var_5 in var_10:\n if not (var_5 in var_9):\n var_9.append(var_5)\n return len(var_10) != len(var_9)\n\n\ndef func_1(var_7):\n func_1 = []\n for var_4 in range(1, var_7 + 1):\n if var_7 % var_4 == 0:\n func_1.append(var_4)\n return func_1\n\n\nvar_2 = [-1, -1, -1, 0, 0, 1, 1, 1]\nvar_3 = [-1, 0, 1, -1, 1, -1, 0, 1]\nvar_7 = int(eval(input()))\nvar_1 = func_5()\n\n\ndef func_2(var_6):\n if len(var_6) == var_7:\n for var_4 in range(len(var_6)):\n if var_6[var_4] % 2 == 0:\n return 1\n return 0\n return (\n func_2(var_6 + [var_1[len(var_6)]])\n + func_2(var_6 + [var_1[len(var_6)] - 1])\n + func_2(var_6 + [var_1[len(var_6)] + 1])\n )\n\n\nprint((func_2([])))\n```\n\n=== Code B (Modified) ===\n```python\nvar_4 = int(eval(input()))\nvar_1 = list(map(int, input().split()))\nvar_3 = 1\nfor var_2 in var_1:\n var_3 *= 2 if var_2 % 2 == 0 else 1\nprint((3**var_4 - var_3))\n```", "output": "FASTER 7.7659", "pair_id": "python_p03568_pair0035_forward", "problem_id": "p03568", "language": "python", "direction": "forward", "speedup_ratio": 217.6585} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\ndef func_1():\n from sys import setrecursionlimit, stdin\n from os import environ\n from collections import defaultdict, deque, Counter\n from math import ceil, floor, gcd\n from itertools import accumulate, combinations, combinations_with_replacement\n\n setrecursionlimit(10**6)\n var_7 = (\n (lambda *var_11: print(*var_11))\n if \"TERM_PROGRAM\" in environ\n else lambda *var_12: 0\n )\n var_8 = lambda: stdin.readline().rstrip()\n var_3 = lambda: list(map(int, var_8().split()))\n var_1 = lambda: int(var_8())\n var_4 = 10**9 + 7\n var_2 = 10**9 + 10\n var_9, var_10 = var_8().split()\n var_5 = int(var_9)\n var_10 = var_10.split(\".\")\n var_6 = int(var_10[0]) * 100\n if len(var_10) == 2:\n var_6 += int(var_10[1])\n print(var_5 * var_6 // 100)\n\n\nfunc_1()\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = input().split()\nvar_1 = int(var_1)\nvar_2 = int(\"\".join(var_2.split(\".\")))\nprint(((var_1 * var_2) // 100))\n```", "output": "FASTER 2.3519", "pair_id": "python_p02659_pair0057_forward", "problem_id": "p02659", "language": "python", "direction": "forward", "speedup_ratio": 5.1048} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_4, var_3 = list(map(int, input().split()))\nvar_1 = 0\nfor var_2 in range(var_4, var_3 + 1):\n if str(var_2)[0] + str(var_2)[1] == str(var_2)[-1] + str(var_2)[-2]:\n var_1 += 1\nprint(var_1)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1 = list(map(int, input().split()))\nvar_2 = 0\nfor var_3 in range(var_1[0], var_1[1] + 1):\n var_4 = str(var_3)\n if var_4[0] == var_4[4] and var_4[1] == var_4[3]:\n var_2 += 1\nprint(var_2)\n```", "output": "FASTER 1.6299", "pair_id": "python_p03416_pair0217_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 3.0949} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_3 = list(map(int, input().split()))\nvar_2 = 0\nfor var_5 in range(var_3 + 1)[var_1:]:\n if len(str(var_5)) % 2 == 0:\n var_6 = list(str(var_5))[: len(str(var_5)) // 2]\n var_7 = list(reversed(list(str(var_5))[len(str(var_5)) // 2 :]))\n if var_6 == var_7:\n var_2 += 1\n else:\n var_8 = list(str(var_5))[: len(str(var_5)) // 2 + 1]\n var_4 = list(reversed(list(str(var_5))[len(str(var_5)) // 2 :]))\n if var_8 == var_4:\n var_2 += 1\nprint(var_2)\n```\n\n=== Code B (Modified) ===\n```python\nvar_10 = []\nvar_10 = input().rstrip().split(\" \")\nvar_1 = int(var_10[0])\nvar_3 = int(var_10[1])\nvar_2 = 0\nvar_6 = var_1\nwhile var_6 <= var_3:\n var_4 = var_6 // 10000\n var_5 = (var_6 - var_4 * 10000) // 1000\n var_7 = var_6 // 100\n var_8 = (var_6 - var_7 * 100) // 10\n var_9 = var_6 % 10\n if (var_4 == var_9) and (var_5 == var_8):\n var_2 += 1\n var_6 += 1\nprint(var_2)\n```", "output": "FASTER 1.6655", "pair_id": "python_p03416_pair0208_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 3.1723} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_6 = input()[::-1]\nvar_4 = len(var_6)\nvar_2 = [0] * 2019\nvar_2[0] = 1\nvar_7 = 1\nvar_5 = 0\nvar_1 = 0\nfor var_3 in range(var_4):\n var_5 = (var_5 + int(var_6[var_3]) * var_7) % 2019\n var_7 = var_7 * 10 % 2019\n var_2[var_5] += 1\nfor var_3 in var_2:\n var_1 += var_3 * (var_3 - 1) // 2\nprint(var_1)\n```\n\n=== Code B (Modified) ===\n```python\n\"\"\"\"\"\"\n\nfrom collections import defaultdict\n\n\ndef func_1(var_10, var_9):\n var_5 = 1\n yield var_5\n for _ in range(1, var_10):\n var_5 = (var_5 * 10) % var_9\n yield var_5\n\n\ndef func_2():\n var_3 = 2019\n var_4 = input()[::-1]\n\n var_1 = [\n int(var_11) * var_10 % var_3\n for var_11, var_10 in zip(var_4, func_1(len(var_4), var_3))\n ]\n\n var_2 = [0]\n for var_5 in var_1:\n var_2.append((var_2[-1] + var_5) % var_3)\n\n var_8 = defaultdict(int)\n for var_6 in var_2:\n var_8[var_6] += 1\n var_7 = sum(var_12 * (var_12 - 1) // 2 for var_12 in list(var_8.values()))\n print(var_7)\n\n\nfunc_2()\n```", "output": "FASTER 1.3499", "pair_id": "python_p02702_pair0011_forward", "problem_id": "p02702", "language": "python", "direction": "forward", "speedup_ratio": 2.5489} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_6, var_5 = list(map(int, input().split()))\nvar_1 = [0] * var_6\nfor var_4 in range(var_5):\n var_2, var_3 = list(map(int, input().split()))\n var_1[var_2 - 1] += 1\n var_1[var_3 - 1] += 1\nfor var_4 in range(var_6):\n print((var_1[var_4]))\n```\n\n=== Code B (Modified) ===\n```python\nvar_3, var_2 = map(int, input().split())\nvar_4 = [0] * var_3\n[\n exec(\n \"roads[%d] += 1; roads[%d] += 1\"\n % tuple(map(lambda var_1: int(var_1) - 1, input().split()))\n )\n for _ in range(var_2)\n]\nprint(*var_4, sep=\"\\n\", end=\"\")\n```", "output": "SLOWER 1.1224", "pair_id": "python_p03720_pair0001_reversed", "problem_id": "p03720", "language": "python", "direction": "reversed", "speedup_ratio": 2.1771} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\nfrom collections import deque\n\nvar_13 = sys.stdin.readline\nvar_2 = int(eval(var_13()))\nvar_5 = [deque() for _ in range(var_2)]\nvar_3 = [-1] * var_2\nfor var_12 in range(var_2 - 1):\n var_6, var_8 = list(map(int, var_13().split()))\n var_5[var_6 - 1].append((var_12, var_8 - 1))\n\n\nvar_4 = deque([(0, -1)])\nvar_1 = [-1] * (var_2 - 1)\nvar_11 = 0\nwhile var_4:\n var_14, var_10 = var_4.pop()\n var_9 = 1\n for var_12, var_15 in var_5[var_14]:\n if var_9 == var_10:\n var_9 += 1\n var_1[var_12] = var_9\n var_4.appendleft((var_15, var_9))\n var_9 += 1\n var_11 = max(var_11, var_9 - 1)\nprint(var_11)\nfor var_7 in var_1:\n print(var_7)\n```\n\n=== Code B (Modified) ===\n```python\nfrom collections import deque\n\n\ndef func_2(var_9, var_2, var_4):\n\n var_6 = {var_7: dict() for var_7 in range(var_9)}\n for var_7 in range(var_9 - 1):\n var_1, var_3 = var_2[var_7] - 1, var_4[var_7] - 1\n var_6[var_1][var_3] = -1\n var_6[var_3][var_1] = -1\n var_8 = max([len(var_6[var_1]) for var_1 in range(var_9)])\n var_14 = [-1] * var_9\n var_14[0] = var_8 - 1\n\n var_12 = deque([0])\n while len(var_12) > 0:\n var_10 = var_12.popleft()\n var_5 = var_14[var_10]\n for var_11 in list(var_6[var_10].keys()):\n if var_14[var_11] != -1:\n continue\n var_5 += 1\n var_5 %= var_8\n\n var_6[var_10][var_11] = var_5\n var_6[var_11][var_10] = var_5\n var_14[var_11] = var_5\n var_12.append(var_11)\n var_13 = [0] * (var_9 - 1)\n for var_7 in range(var_9 - 1):\n var_13[var_7] = var_6[var_2[var_7] - 1][var_4[var_7] - 1] + 1\n return var_8, var_13\n\n\ndef func_1():\n var_9 = int(eval(input()))\n var_2 = [0] * (var_9 - 1)\n var_4 = [0] * (var_9 - 1)\n for var_7 in range(var_9 - 1):\n var_1, var_3 = list(map(int, input().split()))\n var_2[var_7] = var_1\n var_4[var_7] = var_3\n var_8, var_13 = func_2(var_9, var_2, var_4)\n print(var_8)\n for var_7 in range(var_9 - 1):\n print((var_13[var_7]))\n\n\ndef func_3():\n print((func_2(3, [1, 2], [2, 3])))\n print((func_2(8, [1, 2, 2, 2, 4, 5, 6], [2, 3, 4, 5, 7, 6, 8])))\n\n\nif __name__ == \"__main__\":\n\n func_1()\n```", "output": "SLOWER 1.0091", "pair_id": "python_p02850_pair0029_reversed", "problem_id": "p02850", "language": "python", "direction": "reversed", "speedup_ratio": 2.0126} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1 = int(eval(input()))\nvar_2 = []\nfor _ in range(var_1):\n var_2.append(int(eval(input())))\nprint((sum(var_2) - max(var_2) // 2))\n```\n\n=== Code B (Modified) ===\n```python\nimport copy\nimport random\nimport bisect\nimport fractions\nimport math\nimport sys\nimport collections\nfrom decimal import Decimal\n\nvar_5 = 10**9 + 7\nsys.setrecursionlimit(var_5)\nvar_3 = collections.deque()\n\n\ndef func_1():\n return list(map(int, sys.stdin.readline().split()))\n\n\nvar_1 = int(eval(input()))\nvar_6 = [0 for var_4 in range(var_1)]\nfor var_4 in range(var_1):\n var_6[var_4] = int(eval(input()))\nvar_6.sort()\nvar_2 = sum(var_6)\nvar_2 -= var_6[-1] // 2\nprint(var_2)\n```", "output": "SLOWER 1.0811", "pair_id": "python_p03207_pair0004_reversed", "problem_id": "p03207", "language": "python", "direction": "reversed", "speedup_ratio": 2.1156} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\ndef func_1():\n var_2, var_3, *var_1 = list(map(int, open(0).read().split()))\n var_4 = [0] * (var_3 + max(var_1[::2]))\n for var_7, var_6 in sorted(zip(*[iter(var_1)] * 2)):\n for var_5 in reversed(list(range(var_3))):\n var_4[var_5 + var_7] = max(var_4[var_5 + var_7], var_4[var_5] + var_6)\n print((max(var_4)))\n\n\nfunc_1()\n```\n\n=== Code B (Modified) ===\n```python\nvar_6, var_7 = list(map(int, input().split()))\nvar_1 = [list(map(int, input().split())) for _ in range(var_6)]\nvar_1.sort()\nvar_3 = [(6007) * [0] for _ in range(var_6 + 1)]\nvar_3[0][0] = 0\nvar_2 = 0\nfor var_4 in range(var_6):\n for var_5 in range(6007):\n var_3[var_4 + 1][var_5] = max(var_3[var_4 + 1][var_5], var_3[var_4][var_5])\n if var_5 < var_7:\n var_3[var_4 + 1][var_5 + var_1[var_4][0]] = max(\n var_3[var_4][var_5] + var_1[var_4][1],\n var_3[var_4][var_5 + var_1[var_4][0]],\n )\n var_2 = max(var_2, var_3[var_4 + 1][var_5])\nprint(var_2)\n```", "output": "SLOWER 7.0192", "pair_id": "python_p02863_pair0059_reversed", "problem_id": "p02863", "language": "python", "direction": "reversed", "speedup_ratio": 129.7134} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nfrom collections import Counter, defaultdict, deque\nfrom heapq import heappop, heappush, heapify\nimport sys, bisect, math, itertools, fractions, pprint\n\nsys.setrecursionlimit(10**8)\nvar_6 = 10**9 + 7\nvar_1 = float(\"inf\")\n\n\ndef func_1():\n return int(sys.stdin.readline())\n\n\ndef func_2():\n return list(map(int, sys.stdin.readline().split()))\n\n\nvar_7, var_9 = func_2()\nvar_13 = [func_2() for _ in range(var_7)]\nvar_13.sort(key=lambda var_14: var_14[1], reverse=True)\nvar_8 = 0\nvar_10 = min(var_7, 5)\nfor var_3 in range(var_10):\n var_2 = [[0] * (var_9 + 5) for _ in range(var_7 + 5)]\n for var_4 in range(var_7):\n var_12, var_11 = var_13[var_4]\n for var_5 in range(var_9):\n if var_5 < var_12 or var_3 == var_4:\n var_2[var_4 + 1][var_5] = var_2[var_4][var_5]\n else:\n var_2[var_4 + 1][var_5] = max(\n var_2[var_4][var_5], var_2[var_4][var_5 - var_12] + var_11\n )\n\n var_8 = max(var_2[var_7][var_9 - 1] + var_13[var_3][1], var_8)\nprint(var_8)\n```\n\n=== Code B (Modified) ===\n```python\nvar_6, var_7 = list(map(int, input().split()))\nvar_1 = [list(map(int, input().split())) for _ in range(var_6)]\nvar_1.sort()\nvar_3 = [(6007) * [0] for _ in range(var_6 + 1)]\nvar_3[0][0] = 0\nvar_2 = 0\nfor var_4 in range(var_6):\n for var_5 in range(6007):\n var_3[var_4 + 1][var_5] = max(var_3[var_4 + 1][var_5], var_3[var_4][var_5])\n if var_5 < var_7:\n var_3[var_4 + 1][var_5 + var_1[var_4][0]] = max(\n var_3[var_4][var_5] + var_1[var_4][1],\n var_3[var_4][var_5 + var_1[var_4][0]],\n )\n var_2 = max(var_2, var_3[var_4 + 1][var_5])\nprint(var_2)\n```", "output": "SLOWER 4.0812", "pair_id": "python_p02863_pair0060_reversed", "problem_id": "p02863", "language": "python", "direction": "reversed", "speedup_ratio": 16.9267} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport math\nimport string\n\n\ndef func_5():\n return list(map(int, input().split()))\n\n\ndef func_4(var_7, var_8):\n return math.factorial(var_7) // (\n math.factorial(var_7 - var_8) * math.factorial(var_8)\n )\n\n\ndef func_3(var_10):\n var_9 = []\n for var_5 in var_10:\n if not (var_5 in var_9):\n var_9.append(var_5)\n return len(var_10) != len(var_9)\n\n\ndef func_1(var_7):\n func_1 = []\n for var_4 in range(1, var_7 + 1):\n if var_7 % var_4 == 0:\n func_1.append(var_4)\n return func_1\n\n\nvar_2 = [-1, -1, -1, 0, 0, 1, 1, 1]\nvar_3 = [-1, 0, 1, -1, 1, -1, 0, 1]\nvar_7 = int(eval(input()))\nvar_1 = func_5()\n\n\ndef func_2(var_6):\n if len(var_6) == var_7:\n for var_4 in range(len(var_6)):\n if var_6[var_4] % 2 == 0:\n return 1\n return 0\n return (\n func_2(var_6 + [var_1[len(var_6)]])\n + func_2(var_6 + [var_1[len(var_6)] - 1])\n + func_2(var_6 + [var_1[len(var_6)] + 1])\n )\n\n\nprint((func_2([])))\n```\n\n=== Code B (Modified) ===\n```python\nimport math\nimport string\n\n\ndef func_4():\n return list(map(int, input().split()))\n\n\ndef func_3(var_6, var_7):\n return math.factorial(var_6) // (\n math.factorial(var_6 - var_7) * math.factorial(var_7)\n )\n\n\ndef func_2(var_9):\n var_8 = []\n for var_5 in var_9:\n if not (var_5 in var_8):\n var_8.append(var_5)\n return len(var_9) != len(var_8)\n\n\ndef func_1(var_6):\n func_1 = []\n for var_4 in range(1, var_6 + 1):\n if var_6 % var_4 == 0:\n func_1.append(var_4)\n return func_1\n\n\nvar_2 = [-1, -1, -1, 0, 0, 1, 1, 1]\nvar_3 = [-1, 0, 1, -1, 1, -1, 0, 1]\nvar_6 = int(eval(input()))\nvar_1 = func_4()\nvar_10 = 1\nfor var_4 in range(len(var_1)):\n if var_1[var_4] % 2 == 0:\n var_10 *= 2\n else:\n var_10 *= 1\nprint((3 ** len(var_1) - var_10))\n```", "output": "FASTER 5.9525", "pair_id": "python_p03568_pair0021_forward", "problem_id": "p03568", "language": "python", "direction": "forward", "speedup_ratio": 61.9275} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_3, var_8 = list(map(int, input().split()))\nvar_2 = list(map(int, input().split()))\nvar_4 = list(map(int, input().split()))\nvar_7 = min(var_2) + min(var_4)\nvar_9 = [0] * var_8\nvar_10 = [0] * var_8\nvar_5 = [0] * var_8\nfor var_6 in range(var_8):\n var_9[var_6], var_10[var_6], var_5[var_6] = list(map(int, input().split()))\n var_9[var_6] -= 1\n var_10[var_6] -= 1\nfor var_6 in range(var_8):\n var_7 = min(var_7, var_2[var_9[var_6]] + var_4[var_10[var_6]] - var_5[var_6])\nprint(var_7)\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\nfrom collections import Counter\n\n\ndef func_9():\n return sys.stdin.readline().strip()\n\n\ndef func_10(var_8, var_9, var_10):\n return [[var_10] * var_9 for var_13 in range(var_8)]\n\n\ndef func_11(var_8, var_9, var_10, var_11):\n return [[[var_11] * var_10 for var_14 in range(var_9)] for var_13 in range(var_8)]\n\n\ndef func_12(var_8, var_9, var_10, var_11, var_12):\n return [\n [[[var_12] * var_11 for var_14 in range(var_10)] for var_14 in range(var_9)]\n for var_13 in range(var_8)\n ]\n\n\ndef func_8(var_16, var_17=1):\n return int(-(-var_16 // var_17))\n\n\ndef func_1():\n return int(eval(func_9()))\n\n\ndef func_3():\n return list(map(int, func_9().split()))\n\n\ndef func_2(var_7=None):\n return list(func_3()) if var_7 is None else [func_1() for var_13 in range(var_7)]\n\n\ndef func_7():\n print(\"Yes\")\n\n\ndef func_5():\n print(\"No\")\n\n\ndef func_6():\n print(\"YES\")\n\n\ndef func_4():\n print(\"NO\")\n\n\nsys.setrecursionlimit(10**9)\nvar_3 = 10**18\nvar_6 = 10**9 + 7\nvar_7, var_5, var_4 = func_3()\nvar_1 = func_2()\nvar_2 = func_2()\nvar_15 = min(var_1) + min(var_2)\nfor _ in range(var_4):\n var_16, var_17, var_10 = func_3()\n var_16 -= 1\n var_17 -= 1\n var_15 = min(var_15, var_1[var_16] + var_2[var_17] - var_10)\nprint(var_15)\n```", "output": "SLOWER 1.3955", "pair_id": "python_p02748_pair0012_reversed", "problem_id": "p02748", "language": "python", "direction": "reversed", "speedup_ratio": 2.6308} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_5 in range(var_1, var_2 + 1):\n var_3 = str(var_5)\n if var_3[0] == var_3[-1] and var_3[1] == var_3[-2]:\n var_4 += 1\nprint(var_4)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n if str(var_4) == \"\".join(reversed(str(var_4))):\n var_3 += 1\nprint(var_3)\n```", "output": "SLOWER 1.1678", "pair_id": "python_p03416_pair0214_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 2.2467} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nfrom sys import stdin\n\n\ndef func_1():\n\n var_11 = stdin.readline\n var_2 = int(var_11())\n var_1 = []\n for var_6 in range(var_2):\n var_5 = int(\"\".join(var_11().strip().split(\" \")), 2)\n var_1.append(var_5)\n var_3 = []\n for var_6 in range(var_2):\n var_10 = list(map(int, var_11().split()))\n var_3.append(var_10)\n var_8 = float(\"-inf\")\n for var_9 in range(1, 1 << 10):\n var_12 = 0\n for var_7 in range(var_2):\n var_4 = bin(var_9 & var_1[var_7]).count(\"1\")\n var_12 += var_3[var_7][var_4]\n var_8 = max(var_12, var_8)\n print(var_8)\n\n\nif __name__ == \"__main__\":\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nvar_5 = 0\nif var_5 == 0:\n var_8 = int(eval(input()))\n var_2 = []\n for var_4 in range(var_8):\n var_3 = list(map(int, input().split()))\n var_2.append(var_3)\n var_9 = []\n for var_4 in range(var_8):\n var_10 = list(map(int, input().split()))\n var_9.append(var_10)\nelif var_5 == 1:\n var_8 = 1\n var_2 = [[1, 1, 0, 1, 0, 0, 0, 1, 0, 1]]\n var_9 = [[3, 4, 5, 6, 7, 8, 9, -2, -3, 4, -2]]\nelif var_5 == 2:\n var_8 = 2\n var_2 = [[1, 1, 1, 1, 1, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 1, 1, 1, 1, 1]]\n var_9 = [\n [0, -2, -2, -2, -2, -2, -1, -1, -1, -1, -1],\n [0, -2, -2, -2, -2, -2, -1, -1, -1, -1, -1],\n ]\nelif var_5 == 3:\n var_8 = 3\n var_2 = [\n [1, 1, 1, 1, 1, 1, 0, 0, 1, 1],\n [0, 1, 0, 1, 1, 1, 1, 0, 1, 0],\n [1, 0, 1, 1, 0, 1, 0, 1, 0, 1],\n ]\n var_9 = [\n [-8, 6, -2, -8, -8, 4, 8, 7, -6, 2, 2],\n [-9, 2, 0, 1, 7, -5, 0, -2, -6, 5, 5],\n [6, -6, 7, -9, 6, -5, 8, 0, -9, -7, -7],\n ]\nimport itertools\n\nvar_13 = -(10**11)\nfor var_4 in itertools.product([0, 1], repeat=10):\n var_11 = list(var_4)\n var_12 = 0\n if sum(var_11) != 0:\n for var_7 in range(var_8):\n var_1 = 0\n for var_6 in range(10):\n var_1 = var_1 + var_11[var_6] * var_2[var_7][var_6]\n var_12 = var_12 + var_9[var_7][var_1]\n\n var_13 = max(var_12, var_13)\nprint(var_13)\n```", "output": "SLOWER 3.2735", "pair_id": "python_p03503_pair0041_reversed", "problem_id": "p03503", "language": "python", "direction": "reversed", "speedup_ratio": 9.6696} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_5 in range(var_1, var_2 + 1):\n var_3 = str(var_5)\n if var_3[0] == var_3[-1] and var_3[1] == var_3[-2]:\n var_4 += 1\nprint(var_4)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().rstrip().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = list(map(int, list(str(var_4))))\n if var_5[0] == var_5[4] and var_5[1] == var_5[3]:\n var_3 += 1\nprint(var_3)\n```", "output": "SLOWER 1.7746", "pair_id": "python_p03416_pair0064_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 3.4214} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport numpy as np\nfrom bisect import bisect_left\n\n\ndef func_1():\n var_4 = []\n var_1 = np.ones(10**5 + 10)\n var_1[0] = var_1[1] = 0\n for var_3, var_2 in enumerate(var_1):\n if var_2:\n var_4.append(var_3)\n var_1[2 * var_3 : 10**5 + 10 : var_3] = 0\n return var_4\n\n\ndef func_2(var_6):\n var_7 = int(var_6)\n var_5 = func_1()\n return str(var_5[bisect_left(var_5, var_7)])\n\n\nif __name__ == \"__main__\":\n import sys\n\n print((func_2(sys.stdin.read().strip())))\n```\n\n=== Code B (Modified) ===\n```python\nimport bisect, copy, heapq, math, sys\nfrom collections import *\nfrom functools import lru_cache\nfrom itertools import accumulate, combinations, permutations, product\n\n\ndef func_2():\n return sys.stdin.readline()[:-1]\n\n\ndef func_4(var_8):\n return [0] + list(accumulate(var_8))\n\n\ndef func_1(var_1, var_4):\n return -(-var_1 // var_4)\n\n\nsys.setrecursionlimit(5000000)\nvar_9 = pow(10, 9) + 7\nvar_2 = [chr(ord(\"a\") + var_6) for var_6 in range(26)]\nvar_5 = [[1, 0], [0, 1], [-1, 0], [0, -1]]\nvar_11 = int(eval(func_2()))\n\n\ndef func_3(var_10):\n if var_10 == 1:\n return False\n for var_7 in range(2, int(math.sqrt(var_10)) + 1):\n if var_10 % var_7 == 0:\n return False\n return True\n\n\nvar_3 = var_11\nwhile not func_3(var_3):\n var_3 += 1\nprint(var_3)\n```", "output": "FASTER 6.3202", "pair_id": "python_p02819_pair0003_forward", "problem_id": "p02819", "language": "python", "direction": "forward", "speedup_ratio": 79.9029} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_6, var_7 = list(map(int, input().split()))\nvar_1 = [list(map(int, input().split())) for _ in range(var_6)]\nvar_1.sort()\nvar_3 = [(6007) * [0] for _ in range(var_6 + 1)]\nvar_3[0][0] = 0\nvar_2 = 0\nfor var_4 in range(var_6):\n for var_5 in range(6007):\n var_3[var_4 + 1][var_5] = max(var_3[var_4 + 1][var_5], var_3[var_4][var_5])\n if var_5 < var_7:\n var_3[var_4 + 1][var_5 + var_1[var_4][0]] = max(\n var_3[var_4][var_5] + var_1[var_4][1],\n var_3[var_4][var_5 + var_1[var_4][0]],\n )\n var_2 = max(var_2, var_3[var_4 + 1][var_5])\nprint(var_2)\n```\n\n=== Code B (Modified) ===\n```python\ndef func_1():\n var_2, var_3, *var_1 = list(map(int, open(0).read().split()))\n var_4 = [0] * (var_3 + max(var_1[::2]))\n for var_7, var_6 in sorted(zip(*[iter(var_1)] * 2)):\n for var_5 in reversed(list(range(var_3))):\n var_4[var_5 + var_7] = max(var_4[var_5 + var_7], var_4[var_5] + var_6)\n print((max(var_4)))\n\n\nfunc_1()\n```", "output": "FASTER 7.0192", "pair_id": "python_p02863_pair0059_forward", "problem_id": "p02863", "language": "python", "direction": "forward", "speedup_ratio": 129.7134} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport math\n\nvar_1, var_2 = input().split()\nvar_1 = int(var_1)\nvar_3 = int(var_2[0] + var_2[2] + var_2[3])\nprint((var_1 * var_3 // 100))\n```\n\n=== Code B (Modified) ===\n```python\ndef func_1():\n from sys import setrecursionlimit, stdin\n from os import environ\n from collections import defaultdict, deque, Counter\n from math import ceil, floor, gcd\n from itertools import accumulate, combinations, combinations_with_replacement\n\n setrecursionlimit(10**6)\n var_7 = (\n (lambda *var_11: print(*var_11))\n if \"TERM_PROGRAM\" in environ\n else lambda *var_12: 0\n )\n var_8 = lambda: stdin.readline().rstrip()\n var_3 = lambda: list(map(int, var_8().split()))\n var_1 = lambda: int(var_8())\n var_4 = 10**9 + 7\n var_2 = 10**9 + 10\n var_9, var_10 = var_8().split()\n var_5 = int(var_9)\n var_6 = int(float(var_10) * 100 + 0.5)\n print(var_5 * var_6 // 100)\n\n\nfunc_1()\n```", "output": "SLOWER 2.0604", "pair_id": "python_p02659_pair0056_reversed", "problem_id": "p02659", "language": "python", "direction": "reversed", "speedup_ratio": 4.1709} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport math\nimport string\n\n\ndef func_5():\n return list(map(int, input().split()))\n\n\ndef func_4(var_7, var_8):\n return math.factorial(var_7) // (\n math.factorial(var_7 - var_8) * math.factorial(var_8)\n )\n\n\ndef func_3(var_10):\n var_9 = []\n for var_5 in var_10:\n if not (var_5 in var_9):\n var_9.append(var_5)\n return len(var_10) != len(var_9)\n\n\ndef func_1(var_7):\n func_1 = []\n for var_4 in range(1, var_7 + 1):\n if var_7 % var_4 == 0:\n func_1.append(var_4)\n return func_1\n\n\nvar_2 = [-1, -1, -1, 0, 0, 1, 1, 1]\nvar_3 = [-1, 0, 1, -1, 1, -1, 0, 1]\nvar_7 = int(eval(input()))\nvar_1 = func_5()\n\n\ndef func_2(var_6):\n if len(var_6) == var_7:\n for var_4 in range(len(var_6)):\n if var_6[var_4] % 2 == 0:\n return 1\n return 0\n return (\n func_2(var_6 + [var_1[len(var_6)]])\n + func_2(var_6 + [var_1[len(var_6)] - 1])\n + func_2(var_6 + [var_1[len(var_6)] + 1])\n )\n\n\nprint((func_2([])))\n```\n\n=== Code B (Modified) ===\n```python\nimport numpy as np\nfrom itertools import product\n\nvar_6 = int(eval(input()))\nvar_2 = list(map(int, input().split()))\nvar_2 = np.array(var_2)\nvar_5 = [-1, 0, 1]\nvar_3 = 0\nfor var_7 in product(var_5, repeat=var_6):\n var_7 = np.array(var_7)\n var_1 = var_2 + var_7\n var_4 = var_1.cumprod()\n if var_4[-1] % 2 == 0:\n var_3 += 1\nprint(var_3)\n```", "output": "SLOWER 2.3825", "pair_id": "python_p03568_pair0039_reversed", "problem_id": "p03568", "language": "python", "direction": "reversed", "speedup_ratio": 5.2145} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_6 = input()[::-1]\nvar_5 = len(var_6)\nvar_1 = [0] * var_5\nvar_3 = [0] * var_5\nvar_2 = [0] * 2019\nvar_7 = 10\nvar_1[0] = int(var_6[0])\nvar_3[0] = var_1[0]\nvar_2[var_3[0]] += 1\nfor var_4 in range(1, var_5):\n var_1[var_4] = int(var_6[var_4]) * var_7 % 2019\n var_3[var_4] = (var_3[var_4 - 1] + var_1[var_4]) % 2019\n var_2[var_3[var_4]] += 1\n var_7 = var_7 * 10 % 2019\nprint(\n (\n int(sum([var_2[var_4] * (var_2[var_4] - 1) for var_4 in range(2019)]) / 2)\n + var_2[0]\n )\n)\n```\n\n=== Code B (Modified) ===\n```python\n\"\"\"\"\"\"\n\nfrom collections import defaultdict\n\n\ndef func_1(var_10, var_9):\n var_5 = 1\n yield var_5\n for _ in range(1, var_10):\n var_5 = (var_5 * 10) % var_9\n yield var_5\n\n\ndef func_2():\n var_3 = 2019\n var_4 = input()[::-1]\n\n var_1 = [\n int(var_11) * var_10 % var_3\n for var_11, var_10 in zip(var_4, func_1(len(var_4), var_3))\n ]\n\n var_2 = [0]\n for var_5 in var_1:\n var_2.append((var_2[-1] + var_5) % var_3)\n\n var_8 = defaultdict(int)\n for var_6 in var_2:\n var_8[var_6] += 1\n var_7 = sum(var_12 * (var_12 - 1) // 2 for var_12 in list(var_8.values()))\n print(var_7)\n\n\nfunc_2()\n```", "output": "FASTER 1.0502", "pair_id": "python_p02702_pair0012_forward", "problem_id": "p02702", "language": "python", "direction": "forward", "speedup_ratio": 2.0708} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_6 = str(var_4)\n var_5 = var_6[::-1]\n if var_6 == var_5:\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_6 in range(var_1, var_2 + 1):\n var_3 = str(var_6)\n var_5 = True\n for var_7 in range(len(var_3) // 2):\n if var_3[var_7] != var_3[-var_7 - 1] and var_5:\n var_5 = not var_5\n if var_5:\n var_4 += 1\nprint(var_4)\n```", "output": "SLOWER 1.2096", "pair_id": "python_p03416_pair0054_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 2.3127} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\n\nvar_3 = sys.stdin.readline\nif __name__ == \"__main__\":\n var_1, var_2 = var_3().split()\n print((int(var_1) * round(float(var_2) * 100) // 100))\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\nimport math\nfrom collections import defaultdict\nfrom bisect import bisect_left, bisect_right\n\nsys.setrecursionlimit(10**7)\n\n\ndef func_4():\n return sys.stdin.readline()[:-1]\n\n\nvar_4 = 10**9 + 7\n\n\ndef func_1():\n return int(eval(func_4()))\n\n\ndef func_2():\n return list(map(int, func_4().split()))\n\n\ndef func_3(var_6, var_3):\n if var_6 <= 0:\n return [[] for _ in range(var_3)]\n elif var_3 == 1:\n return [func_1() for _ in range(var_6)]\n else:\n var_5 = [func_2() for _ in range(var_6)]\n return list(map(list, list(zip(*var_5))))\n\n\nfrom decimal import getcontext, Decimal\n\ngetcontext().prec = 28\nvar_1, var_2 = list(map(str, func_4().split()))\nvar_1 = int(var_1)\nvar_2 = Decimal(var_2)\nprint((int(var_1 * var_2)))\n```", "output": "SLOWER 2.2434", "pair_id": "python_p02659_pair0031_reversed", "problem_id": "p02659", "language": "python", "direction": "reversed", "speedup_ratio": 4.7352} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nfor var_3 in range(1, 1009):\n if int(var_3 * 0.08) == var_1 and int(var_3 * 0.1) == var_2:\n print((int(var_3)))\n exit()\nprint(\"-1\")\n```\n\n=== Code B (Modified) ===\n```python\nimport math\n\n\ndef func_1():\n var_1, var_2 = list(map(int, input().split()))\n\n var_5 = max(math.ceil(var_1 / 0.08), math.ceil(var_2 / 0.1))\n\n var_4 = min((math.ceil((var_1 + 1) / 0.08), math.ceil((var_2 + 1) / 0.1)))\n\n for var_3 in range(var_5, var_4 + 1):\n if (math.floor(var_3 * 0.08) == var_1) and (math.floor(var_3 * 0.1) == var_2):\n print(var_3)\n quit()\n\n print((-1))\n\n\nif __name__ == \"__main__\":\n func_1()\n```", "output": "FASTER 1.1794", "pair_id": "python_p02755_pair0013_forward", "problem_id": "p02755", "language": "python", "direction": "forward", "speedup_ratio": 2.2649} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\nfrom collections import Counter\n\n\ndef func_9():\n return sys.stdin.readline().strip()\n\n\ndef func_10(var_8, var_9, var_10):\n return [[var_10] * var_9 for var_13 in range(var_8)]\n\n\ndef func_11(var_8, var_9, var_10, var_11):\n return [[[var_11] * var_10 for var_14 in range(var_9)] for var_13 in range(var_8)]\n\n\ndef func_12(var_8, var_9, var_10, var_11, var_12):\n return [\n [[[var_12] * var_11 for var_14 in range(var_10)] for var_14 in range(var_9)]\n for var_13 in range(var_8)\n ]\n\n\ndef func_8(var_16, var_17=1):\n return int(-(-var_16 // var_17))\n\n\ndef func_1():\n return int(eval(func_9()))\n\n\ndef func_3():\n return list(map(int, func_9().split()))\n\n\ndef func_2(var_7=None):\n return list(func_3()) if var_7 is None else [func_1() for var_13 in range(var_7)]\n\n\ndef func_7():\n print(\"Yes\")\n\n\ndef func_5():\n print(\"No\")\n\n\ndef func_6():\n print(\"YES\")\n\n\ndef func_4():\n print(\"NO\")\n\n\nsys.setrecursionlimit(10**9)\nvar_3 = 10**18\nvar_6 = 10**9 + 7\nvar_7, var_5, var_4 = func_3()\nvar_1 = func_2()\nvar_2 = func_2()\nvar_15 = min(var_1) + min(var_2)\nfor _ in range(var_4):\n var_16, var_17, var_10 = func_3()\n var_16 -= 1\n var_17 -= 1\n var_15 = min(var_15, var_1[var_16] + var_2[var_17] - var_10)\nprint(var_15)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_3, var_8 = list(map(int, input().split()))\nvar_2 = list(map(int, input().split()))\nvar_4 = list(map(int, input().split()))\nvar_7 = min(var_2) + min(var_4)\nvar_9 = [0] * var_8\nvar_10 = [0] * var_8\nvar_5 = [0] * var_8\nfor var_6 in range(var_8):\n var_9[var_6], var_10[var_6], var_5[var_6] = list(map(int, input().split()))\n var_9[var_6] -= 1\n var_10[var_6] -= 1\nfor var_6 in range(var_8):\n var_7 = min(var_7, var_2[var_9[var_6]] + var_4[var_10[var_6]] - var_5[var_6])\nprint(var_7)\n```", "output": "FASTER 1.3955", "pair_id": "python_p02748_pair0012_forward", "problem_id": "p02748", "language": "python", "direction": "forward", "speedup_ratio": 2.6308} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nfrom sys import stdin\n\nvar_6 = lambda: list(map(int, stdin.readline().split()))\nvar_5 = lambda: list(map(int, stdin.readline().split()))\nvar_1, var_3 = var_6()\nvar_2 = 0\nfor var_4 in range(var_1, var_3 + 1):\n var_7 = str(var_4)\n if var_7 == var_7[::-1]:\n var_2 += 1\nprint(var_2)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n if list(str(var_4)) == list(reversed(str(var_4))):\n var_3 += 1\nprint(var_3)\n```", "output": "SLOWER 1.3819", "pair_id": "python_p03416_pair0218_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 2.6062} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\ndef func_1():\n from sys import setrecursionlimit, stdin\n from os import environ\n from collections import defaultdict, deque, Counter\n from math import ceil, floor, gcd\n from itertools import accumulate, combinations, combinations_with_replacement\n\n setrecursionlimit(10**6)\n var_7 = (\n (lambda *var_11: print(*var_11))\n if \"TERM_PROGRAM\" in environ\n else lambda *var_12: 0\n )\n var_8 = lambda: stdin.readline().rstrip()\n var_3 = lambda: list(map(int, var_8().split()))\n var_1 = lambda: int(var_8())\n var_4 = 10**9 + 7\n var_2 = 10**9 + 10\n var_9, var_10 = var_8().split()\n var_5 = int(var_9)\n var_6 = int(float(var_10) * 100 + 0.5)\n print(var_5 * var_6 // 100)\n\n\nfunc_1()\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(str, input().split()))\nvar_1 = int(var_1)\nvar_2 = int(float(var_2) * 1000)\nprint((var_1 * var_2 // 1000))\n```", "output": "FASTER 2.0285", "pair_id": "python_p02659_pair0027_forward", "problem_id": "p02659", "language": "python", "direction": "forward", "speedup_ratio": 4.0799} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport math\n\nvar_1, var_2 = input().split()\nvar_1 = int(var_1)\nvar_3 = int(var_2[0] + var_2[2] + var_2[3])\nprint((int(var_1 * var_3) // 100))\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\nimport math\nfrom collections import defaultdict\nfrom bisect import bisect_left, bisect_right\n\nsys.setrecursionlimit(10**7)\n\n\ndef func_4():\n return sys.stdin.readline()[:-1]\n\n\nvar_4 = 10**9 + 7\n\n\ndef func_1():\n return int(eval(func_4()))\n\n\ndef func_2():\n return list(map(int, func_4().split()))\n\n\ndef func_3(var_6, var_3):\n if var_6 <= 0:\n return [[] for _ in range(var_3)]\n elif var_3 == 1:\n return [func_1() for _ in range(var_6)]\n else:\n var_5 = [func_2() for _ in range(var_6)]\n return list(map(list, list(zip(*var_5))))\n\n\nvar_1, var_2 = list(map(str, func_4().split()))\nvar_1 = int(var_1)\nvar_2 = 100 * int(var_2[0]) + 10 * int(var_2[2]) + int(var_2[3])\nprint((var_1 * var_2 // 100))\n```", "output": "SLOWER 2.2787", "pair_id": "python_p02659_pair0026_reversed", "problem_id": "p02659", "language": "python", "direction": "reversed", "speedup_ratio": 4.8523} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\nfrom collections import deque\n\nvar_1 = int(10e10)\nvar_2 = -var_1\nvar_12 = 1000000007\nsys.setrecursionlimit(1000000)\n\n\ndef func_2():\n return list(map(int, input().split()))\n\n\ndef func_4():\n return input().split()\n\n\ndef func_1():\n return int(sys.stdin.readline())\n\n\ndef func_3():\n return eval(input())\n\n\nvar_3, var_4 = func_2()\nvar_6 = [func_2() for var_10 in range(var_3)]\nvar_6.sort()\nvar_7 = 0\nvar_9 = [[0] * var_4 for var_10 in range(var_3 + 1)]\nfor var_10 in range(1, var_3 + 1):\n var_5, var_8 = var_6[var_10 - 1]\n for var_11 in range(var_4):\n if 0 <= var_11 - var_5 < var_4:\n var_9[var_10][var_11] = max(\n var_9[var_10 - 1][var_11], var_9[var_10 - 1][var_11 - var_5] + var_8\n )\n else:\n var_9[var_10][var_11] = var_9[var_10 - 1][var_11]\n else:\n var_7 = max(var_7, var_9[var_10 - 1][-1] + var_8)\nprint(var_7)\n```\n\n=== Code B (Modified) ===\n```python\nfrom collections import Counter, defaultdict, deque\nfrom heapq import heappop, heappush, heapify\nimport sys, bisect, math, itertools, fractions, pprint\n\nsys.setrecursionlimit(10**8)\nvar_6 = 10**9 + 7\nvar_1 = float(\"inf\")\n\n\ndef func_1():\n return int(sys.stdin.readline())\n\n\ndef func_2():\n return list(map(int, sys.stdin.readline().split()))\n\n\nvar_7, var_9 = func_2()\nvar_13 = [func_2() for _ in range(var_7)]\nvar_13.sort(key=lambda var_14: var_14[1], reverse=True)\nvar_8 = 0\nvar_10 = min(var_7, 5)\nfor var_3 in range(var_10):\n var_2 = [[0] * (var_9 + 5) for _ in range(var_7 + 5)]\n for var_4 in range(var_7):\n var_12, var_11 = var_13[var_4]\n for var_5 in range(var_9):\n if var_5 < var_12 or var_3 == var_4:\n var_2[var_4 + 1][var_5] = var_2[var_4][var_5]\n else:\n var_2[var_4 + 1][var_5] = max(\n var_2[var_4][var_5], var_2[var_4][var_5 - var_12] + var_11\n )\n\n var_8 = max(var_2[var_7][var_9 - 1] + var_13[var_3][1], var_8)\nprint(var_8)\n```", "output": "SLOWER 1.5536", "pair_id": "python_p02863_pair0024_reversed", "problem_id": "p02863", "language": "python", "direction": "reversed", "speedup_ratio": 2.9355} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_6 in range(var_1, var_2 + 1):\n var_3 = str(var_6)\n var_5 = True\n for var_7 in range(len(var_3) // 2):\n if var_3[var_7] != var_3[-var_7 - 1] and var_5:\n var_5 = not var_5\n if var_5:\n var_4 += 1\nprint(var_4)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_4 = str(var_4)\n if var_4 == var_4[::-1]:\n var_3 += 1\nprint(var_3)\n```", "output": "FASTER 1.313", "pair_id": "python_p03416_pair0219_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 2.4845} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\ndef func_1():\n var_2, var_3, *var_1 = list(map(int, open(0).read().split()))\n var_4 = [0] * (var_3 + max(var_1[::2]))\n for var_7, var_6 in sorted(zip(*[iter(var_1)] * 2)):\n for var_5 in reversed(list(range(var_3))):\n var_4[var_5 + var_7] = max(var_4[var_5 + var_7], var_4[var_5] + var_6)\n print((max(var_4)))\n\n\nfunc_1()\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\nfrom collections import deque\n\nvar_1 = int(10e10)\nvar_2 = -var_1\nvar_12 = 1000000007\nsys.setrecursionlimit(1000000)\n\n\ndef func_2():\n return list(map(int, input().split()))\n\n\ndef func_4():\n return input().split()\n\n\ndef func_1():\n return int(sys.stdin.readline())\n\n\ndef func_3():\n return eval(input())\n\n\nvar_3, var_4 = func_2()\nvar_6 = [func_2() for var_10 in range(var_3)]\nvar_6.sort()\nvar_7 = 0\nvar_9 = [[0] * var_4 for var_10 in range(var_3 + 1)]\nfor var_10 in range(1, var_3 + 1):\n var_5, var_8 = var_6[var_10 - 1]\n for var_11 in range(var_4):\n if 0 <= var_11 - var_5 < var_4:\n var_9[var_10][var_11] = max(\n var_9[var_10 - 1][var_11], var_9[var_10 - 1][var_11 - var_5] + var_8\n )\n else:\n var_9[var_10][var_11] = var_9[var_10 - 1][var_11]\n else:\n var_7 = max(var_7, var_9[var_10 - 1][-1] + var_8)\nprint(var_7)\n```", "output": "SLOWER 1.3844", "pair_id": "python_p02863_pair0027_reversed", "problem_id": "p02863", "language": "python", "direction": "reversed", "speedup_ratio": 2.6106} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = list(str(var_4))\n if var_5 == list(reversed(var_5)):\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = str(var_4)\n if var_5 == var_5[::-1]:\n var_3 += 1\nprint(var_3)\n```", "output": "FASTER 1.2366", "pair_id": "python_p03416_pair0108_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 2.3565} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = str(var_4)\n if var_5 == var_5[::-1]:\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_5 in range(10):\n for var_6 in range(10):\n for var_7 in range(10):\n var_3 = 10000 * var_5 + 1000 * var_6 + 100 * var_7 + 10 * var_6 + var_5\n if var_1 <= var_3 <= var_2:\n var_4 += 1\nprint(var_4)\n```", "output": "FASTER 3.8211", "pair_id": "python_p03416_pair0016_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 14.1339} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = list(str(var_4))\n if var_5 == list(reversed(var_5)):\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_3 = list(map(int, input().split()))\nvar_2 = 0\nfor var_5 in range(var_3 + 1)[var_1:]:\n if len(str(var_5)) % 2 == 0:\n var_6 = list(str(var_5))[: len(str(var_5)) // 2]\n var_7 = list(reversed(list(str(var_5))[len(str(var_5)) // 2 :]))\n if var_6 == var_7:\n var_2 += 1\n else:\n var_8 = list(str(var_5))[: len(str(var_5)) // 2 + 1]\n var_4 = list(reversed(list(str(var_5))[len(str(var_5)) // 2 :]))\n if var_8 == var_4:\n var_2 += 1\nprint(var_2)\n```", "output": "SLOWER 1.2424", "pair_id": "python_p03416_pair0204_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 2.3659} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nfrom decimal import Decimal\nimport math\n\nvar_1, var_2 = list(map(str, input().split()))\nvar_1 = int(var_1)\nvar_2 = Decimal(var_2)\nvar_3 = math.floor(var_1 * var_2)\nprint((int(var_3)))\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\nimport math\nfrom collections import defaultdict\nfrom bisect import bisect_left, bisect_right\n\nsys.setrecursionlimit(10**7)\n\n\ndef func_4():\n return sys.stdin.readline()[:-1]\n\n\nvar_4 = 10**9 + 7\n\n\ndef func_1():\n return int(eval(func_4()))\n\n\ndef func_2():\n return list(map(int, func_4().split()))\n\n\ndef func_3(var_6, var_3):\n if var_6 <= 0:\n return [[] for _ in range(var_3)]\n elif var_3 == 1:\n return [func_1() for _ in range(var_6)]\n else:\n var_5 = [func_2() for _ in range(var_6)]\n return list(map(list, list(zip(*var_5))))\n\n\nfrom decimal import getcontext, Decimal\n\ngetcontext().prec = 28\nvar_1, var_2 = list(map(str, func_4().split()))\nvar_1 = int(var_1)\nvar_2 = Decimal(var_2)\nprint((int(var_1 * var_2)))\n```", "output": "SLOWER 1.9581", "pair_id": "python_p02659_pair0019_reversed", "problem_id": "p02659", "language": "python", "direction": "reversed", "speedup_ratio": 3.8855} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\ndef func_1():\n from sys import setrecursionlimit, stdin\n from os import environ\n from collections import defaultdict, deque, Counter\n from math import ceil, floor, gcd\n from itertools import accumulate, combinations, combinations_with_replacement\n\n setrecursionlimit(10**6)\n var_7 = (\n (lambda *var_11: print(*var_11))\n if \"TERM_PROGRAM\" in environ\n else lambda *var_12: 0\n )\n var_8 = lambda: stdin.readline().rstrip()\n var_3 = lambda: list(map(int, var_8().split()))\n var_1 = lambda: int(var_8())\n var_4 = 10**9 + 7\n var_2 = 10**9 + 10\n var_9, var_10 = var_8().split()\n var_5 = int(var_9)\n var_10 = var_10.split(\".\")\n var_6 = int(var_10[0]) * 100\n if len(var_10) == 2:\n var_6 += int(var_10[1])\n print(var_5 * var_6 // 100)\n\n\nfunc_1()\n```\n\n=== Code B (Modified) ===\n```python\nimport decimal\n\n\ndef func_1():\n var_1, var_2 = list(map(decimal.Decimal, input().split()))\n print((var_1 * var_2 // 1))\n\n\nif __name__ == \"__main__\":\n func_1()\n```", "output": "FASTER 1.9156", "pair_id": "python_p02659_pair0058_forward", "problem_id": "p02659", "language": "python", "direction": "forward", "speedup_ratio": 3.7726} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().rstrip().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = list(map(int, list(str(var_4))))\n if var_5[0] == var_5[4] and var_5[1] == var_5[3]:\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_5 in range(10):\n for var_6 in range(10):\n for var_7 in range(10):\n var_3 = 10000 * var_5 + 1000 * var_6 + 100 * var_7 + 10 * var_6 + var_5\n if var_1 <= var_3 <= var_2:\n var_4 += 1\nprint(var_4)\n```", "output": "FASTER 5.5086", "pair_id": "python_p03416_pair0220_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 45.5247} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_3 in range(var_1, var_2 + 1):\n var_5 = list(str(var_3))\n var_6 = list(reversed(var_5))\n if var_5 == var_6:\n var_4 += 1\nprint(var_4)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1 = list(map(int, input().split()))\nvar_2 = 0\nfor var_3 in range(var_1[0], var_1[1] + 1):\n var_4 = str(var_3)\n if var_4[0] == var_4[4] and var_4[1] == var_4[3]:\n var_2 += 1\nprint(var_2)\n```", "output": "FASTER 1.5975", "pair_id": "python_p03416_pair0113_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 3.0261} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\n\nsys.setrecursionlimit(2147483647)\nvar_2 = float(\"inf\")\nvar_3 = 10**9 + 7\nvar_10 = lambda: sys.stdin.readline().rstrip()\n\n\ndef func_1():\n var_11, var_4 = list(map(int, var_10().split()))\n var_1 = [tuple(map(int, var_10().split())) for _ in range(var_11)]\n var_1.sort()\n var_8 = [0] * var_4\n var_6 = -var_2\n for var_9 in range(var_11):\n var_5, var_7 = var_1[var_9]\n var_12 = var_8[:]\n for var_13 in range(var_4):\n if var_13 + var_5 < var_4:\n var_12[var_13 + var_5] = max(\n var_12[var_13 + var_5], var_8[var_13] + var_7\n )\n else:\n var_6 = max(var_6, var_8[var_13] + var_7)\n var_8 = var_12\n print((max(var_6, max(var_8))))\n\n\nfunc_1()\n```\n\n=== Code B (Modified) ===\n```python\nvar_8, var_9 = list(map(int, input().split()))\nvar_5 = [[0] * (var_9 + 3001) for _ in range(var_8 + 1)]\nvar_3 = 0\nvar_2 = [list(map(int, input().split())) for _ in range(var_8)]\nvar_2.sort()\nfor var_6 in range(1, var_8 + 1):\n var_1, var_4 = var_2[var_6 - 1]\n for var_7 in range(var_9):\n var_5[var_6][var_7] = max(var_5[var_6 - 1][var_7], var_5[var_6][var_7])\n var_5[var_6][var_7 + var_1] = var_5[var_6 - 1][var_7] + var_4\n var_3 = max(var_5[var_6][var_7], var_5[var_6][var_7 + var_1], var_3)\nprint(var_3)\n```", "output": "SLOWER 1.5497", "pair_id": "python_p02863_pair0003_reversed", "problem_id": "p02863", "language": "python", "direction": "reversed", "speedup_ratio": 2.9276} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_3, var_2 = map(int, input().split())\nvar_4 = [0] * var_3\n[\n exec(\n \"roads[%d] += 1; roads[%d] += 1\"\n % tuple(map(lambda var_1: int(var_1) - 1, input().split()))\n )\n for _ in range(var_2)\n]\nprint(*var_4, sep=\"\\n\", end=\"\")\n```\n\n=== Code B (Modified) ===\n```python\nvar_4, var_3 = list(map(int, input().split()))\nvar_1 = [0] * var_4\nfor var_2 in range(var_3):\n var_5, var_6 = list(map(int, input().split()))\n var_1[var_5 - 1] += 1\n var_1[var_6 - 1] += 1\nfor var_2 in range(var_4):\n print((var_1[var_2]))\n```", "output": "FASTER 1.1067", "pair_id": "python_p03720_pair0002_forward", "problem_id": "p03720", "language": "python", "direction": "forward", "speedup_ratio": 2.1535} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = [0] * (var_2 + 1)\nfor var_3 in range(1, var_2 + 1):\n if str(var_3) == str(var_3)[::-1]:\n var_4[var_3] = var_4[var_3 - 1] + 1\n else:\n var_4[var_3] = var_4[var_3 - 1]\nprint((var_4[var_2] - var_4[var_1 - 1]))\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_5 in range(10):\n for var_6 in range(10):\n for var_7 in range(10):\n var_3 = 10000 * var_5 + 1000 * var_6 + 100 * var_7 + 10 * var_6 + var_5\n if var_1 <= var_3 <= var_2:\n var_4 += 1\nprint(var_4)\n```", "output": "FASTER 5.7678", "pair_id": "python_p03416_pair0068_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 54.4866} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = input().split()\nvar_1 = int(var_1)\nvar_2 = int(\"\".join(var_2.split(\".\")))\nprint(((var_1 * var_2) // 100))\n```\n\n=== Code B (Modified) ===\n```python\ndef func_1():\n from sys import setrecursionlimit, stdin\n from os import environ\n from collections import defaultdict, deque, Counter\n from math import ceil, floor, gcd\n from itertools import accumulate, combinations, combinations_with_replacement\n\n setrecursionlimit(10**6)\n var_7 = (\n (lambda *var_11: print(*var_11))\n if \"TERM_PROGRAM\" in environ\n else lambda *var_12: 0\n )\n var_8 = lambda: stdin.readline().rstrip()\n var_3 = lambda: list(map(int, var_8().split()))\n var_1 = lambda: int(var_8())\n var_4 = 10**9 + 7\n var_2 = 10**9 + 10\n var_9, var_10 = var_8().split()\n var_5 = int(var_9)\n var_10 = var_10.split(\".\")\n var_6 = int(var_10[0]) * 100\n if len(var_10) == 2:\n var_6 += int(var_10[1])\n print(var_5 * var_6 // 100)\n\n\nfunc_1()\n```", "output": "SLOWER 2.3519", "pair_id": "python_p02659_pair0057_reversed", "problem_id": "p02659", "language": "python", "direction": "reversed", "speedup_ratio": 5.1048} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\n\"\"\"\"\"\"\n\nfrom collections import defaultdict\n\n\ndef func_1(var_10, var_9):\n var_5 = 1\n yield var_5\n for _ in range(1, var_10):\n var_5 = (var_5 * 10) % var_9\n yield var_5\n\n\ndef func_2():\n var_3 = 2019\n var_4 = input()[::-1]\n\n var_1 = [\n int(var_11) * var_10 % var_3\n for var_11, var_10 in zip(var_4, func_1(len(var_4), var_3))\n ]\n\n var_2 = [0]\n for var_5 in var_1:\n var_2.append((var_2[-1] + var_5) % var_3)\n\n var_8 = defaultdict(int)\n for var_6 in var_2:\n var_8[var_6] += 1\n var_7 = sum(var_12 * (var_12 - 1) // 2 for var_12 in list(var_8.values()))\n print(var_7)\n\n\nfunc_2()\n```\n\n=== Code B (Modified) ===\n```python\nvar_6 = input()[::-1]\nvar_5 = len(var_6)\nvar_1 = [0] * var_5\nvar_3 = [0] * var_5\nvar_2 = [0] * 2019\nvar_7 = 10\nvar_1[0] = int(var_6[0])\nvar_3[0] = var_1[0]\nvar_2[var_3[0]] += 1\nfor var_4 in range(1, var_5):\n var_1[var_4] = int(var_6[var_4]) * var_7 % 2019\n var_3[var_4] = (var_3[var_4 - 1] + var_1[var_4]) % 2019\n var_2[var_3[var_4]] += 1\n var_7 = var_7 * 10 % 2019\nprint(\n (\n int(sum([var_2[var_4] * (var_2[var_4] - 1) for var_4 in range(2019)]) / 2)\n + var_2[0]\n )\n)\n```", "output": "SLOWER 1.0502", "pair_id": "python_p02702_pair0012_reversed", "problem_id": "p02702", "language": "python", "direction": "reversed", "speedup_ratio": 2.0708} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_6 = sorted([list(map(int, input().split())) for var_5 in range(var_1)])\n\nvar_4 = [[0] * (var_2 + 1) for var_5 in range(var_1 + 1)]\n\nfor var_5 in range(var_1):\n var_9, var_8 = var_6[var_5]\n for var_7 in range(var_2 + 1):\n if var_7 + var_9 <= var_2:\n var_4[var_5 + 1][var_7 + var_9] = max(\n var_4[var_5 + 1][var_7 + var_9], var_4[var_5][var_7] + var_8\n )\n var_4[var_5 + 1][var_7] = max(var_4[var_5][var_7], var_4[var_5 + 1][var_7])\nvar_3 = 0\nfor var_5, (var_9, var_8) in enumerate(var_6):\n for var_7 in range(var_2):\n var_3 = max(var_3, var_4[var_5][var_7] + var_8)\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\n\nsys.setrecursionlimit(2147483647)\nvar_2 = float(\"inf\")\nvar_3 = 10**9 + 7\nvar_10 = lambda: sys.stdin.readline().rstrip()\n\n\ndef func_1():\n var_11, var_4 = list(map(int, var_10().split()))\n var_1 = [tuple(map(int, var_10().split())) for _ in range(var_11)]\n var_1.sort()\n var_8 = [0] * var_4\n var_6 = -var_2\n for var_9 in range(var_11):\n var_5, var_7 = var_1[var_9]\n var_12 = var_8[:]\n for var_13 in range(var_4):\n if var_13 + var_5 < var_4:\n var_12[var_13 + var_5] = max(\n var_12[var_13 + var_5], var_8[var_13] + var_7\n )\n else:\n var_6 = max(var_6, var_8[var_13] + var_7)\n var_8 = var_12\n print((max(var_6, max(var_8))))\n\n\nfunc_1()\n```", "output": "FASTER 1.8014", "pair_id": "python_p02863_pair0008_forward", "problem_id": "p02863", "language": "python", "direction": "forward", "speedup_ratio": 3.4856} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = input().split()\nvar_1 = int(var_1)\nvar_2 = int(\"\".join(var_2.split(\".\")))\nprint(((var_1 * var_2) // 100))\n```\n\n=== Code B (Modified) ===\n```python\ndef func_1():\n from sys import setrecursionlimit, stdin\n from os import environ\n from collections import defaultdict, deque, Counter\n from math import ceil, floor, gcd\n from itertools import accumulate, combinations, combinations_with_replacement\n\n setrecursionlimit(10**6)\n var_7 = (\n (lambda *var_11: print(*var_11))\n if \"TERM_PROGRAM\" in environ\n else lambda *var_12: 0\n )\n var_8 = lambda: stdin.readline().rstrip()\n var_3 = lambda: list(map(int, var_8().split()))\n var_1 = lambda: int(var_8())\n var_4 = 10**9 + 7\n var_2 = 10**9 + 10\n var_9, var_10 = var_8().split()\n var_5 = int(var_9)\n var_6 = int(float(var_10) * 100 + 0.5)\n print(var_5 * var_6 // 100)\n\n\nfunc_1()\n```", "output": "SLOWER 2.2081", "pair_id": "python_p02659_pair0053_reversed", "problem_id": "p02659", "language": "python", "direction": "reversed", "speedup_ratio": 4.6207} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\ndef func_1():\n from sys import setrecursionlimit, stdin\n from os import environ\n from collections import defaultdict, deque, Counter\n from math import ceil, floor, gcd\n from itertools import accumulate, combinations, combinations_with_replacement\n\n setrecursionlimit(10**6)\n var_7 = (\n (lambda *var_11: print(*var_11))\n if \"TERM_PROGRAM\" in environ\n else lambda *var_12: 0\n )\n var_8 = lambda: stdin.readline().rstrip()\n var_3 = lambda: list(map(int, var_8().split()))\n var_1 = lambda: int(var_8())\n var_4 = 10**9 + 7\n var_2 = 10**9 + 10\n var_9, var_10 = var_8().split()\n var_5 = int(var_9)\n var_10 = var_10.split(\".\")\n var_6 = int(var_10[0]) * 100\n if len(var_10) == 2:\n var_6 += int(var_10[1])\n print(var_5 * var_6 // 100)\n\n\nfunc_1()\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = input().split()\nprint((int(var_1) * int(var_2[:-3] + var_2[-2:]) // 100))\n```", "output": "FASTER 2.5742", "pair_id": "python_p02659_pair0043_forward", "problem_id": "p02659", "language": "python", "direction": "forward", "speedup_ratio": 5.9555} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_4 = str(var_4)\n if var_4[0] == var_4[-1] and var_4[1] == var_4[-2]:\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_4 = {}\nvar_5 = 0\nfor var_6 in range(10000, 100000):\n var_3 = list(str(var_6))\n if var_3 == list(reversed(var_3)):\n var_5 += 1\n var_4[var_6] = var_5\nvar_1, var_2 = list(map(int, input().split()))\nprint((var_4[var_2] - var_4[var_1 - 1] if var_1 > 10000 else var_4[var_2]))\n```", "output": "SLOWER 3.7573", "pair_id": "python_p03416_pair0044_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 13.5227} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = str(var_4)\n if var_5[0] == var_5[4] and var_5[1] == var_5[3]:\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_4 = {}\nvar_5 = 0\nfor var_6 in range(10000, 100000):\n var_3 = list(str(var_6))\n if var_3 == list(reversed(var_3)):\n var_5 += 1\n var_4[var_6] = var_5\nvar_1, var_2 = list(map(int, input().split()))\nprint((var_4[var_2] - var_4[var_1 - 1] if var_1 > 10000 else var_4[var_2]))\n```", "output": "SLOWER 3.8398", "pair_id": "python_p03416_pair0221_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 14.318} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\ndef func_1():\n var_1, var_2 = list(map(int, input().split()))\n var_3 = 0\n for var_4 in range(var_1, var_2 + 1):\n\n if (var_4 % 10) == (var_4 // 10000 % 10) and (var_4 // 10 % 10) == (\n var_4 // 1000 % 10\n ):\n var_3 += 1\n print(var_3)\n\n\nif __name__ == \"__main__\":\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_4 = str(var_4)\n if var_4[0] == var_4[-1] and var_4[1] == var_4[-2]:\n var_3 += 1\nprint(var_3)\n```", "output": "SLOWER 1.4803", "pair_id": "python_p03416_pair0153_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 2.7901} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_2 = int(eval(input()))\n(*var_1,) = list(map(int, input().split()))\nvar_5 = 0\nfor var_3 in var_1:\n if var_3 % 2 == 0:\n var_5 += 1\nvar_4 = 3**var_2 - 2**var_5\nprint(var_4)\n```\n\n=== Code B (Modified) ===\n```python\nvar_6 = int(eval(input()))\nvar_2 = list(map(int, input().split()))\nfrom itertools import product\n\nvar_5 = [-1, 0, 1]\nvar_3 = 0\nfor var_7 in product(var_5, repeat=var_6):\n var_1 = []\n for var_4 in range(var_6):\n var_1.append(var_7[var_4] + var_2[var_4])\n if any(var_8 % 2 == 0 for var_8 in var_1):\n var_3 += 1\nprint(var_3)\n```", "output": "SLOWER 9.836", "pair_id": "python_p03568_pair0045_reversed", "problem_id": "p03568", "language": "python", "direction": "reversed", "speedup_ratio": 913.9804} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nfrom sys import stdin\n\nvar_6 = lambda: list(map(int, stdin.readline().split()))\nvar_5 = lambda: list(map(int, stdin.readline().split()))\nvar_1, var_3 = var_6()\nvar_2 = 0\nfor var_4 in range(var_1, var_3 + 1):\n var_7 = str(var_4)\n if var_7 == var_7[::-1]:\n var_2 += 1\nprint(var_2)\n```\n\n=== Code B (Modified) ===\n```python\nvar_4 = {}\nvar_5 = 0\nfor var_6 in range(10000, 100000):\n var_3 = list(str(var_6))\n if var_3 == list(reversed(var_3)):\n var_5 += 1\n var_4[var_6] = var_5\nvar_1, var_2 = list(map(int, input().split()))\nprint((var_4[var_2] - var_4[var_1 - 1] if var_1 > 10000 else var_4[var_2]))\n```", "output": "SLOWER 3.5552", "pair_id": "python_p03416_pair0183_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 11.7549} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\nfrom collections import deque\n\n\ndef func_1():\n var_7 = int(sys.stdin.readline().rstrip())\n var_3 = list(map(int, sys.stdin.read().split()))\n var_3 = list(zip(var_3, var_3))\n var_1 = [[] for _ in range(var_7 + 1)]\n for var_2, var_4 in var_3:\n var_1[var_2].append(var_4)\n var_1[var_4].append(var_2)\n var_10 = deque([1])\n var_9 = [None] * (var_7 + 1)\n var_6 = [0] * (var_7 + 1)\n while var_10:\n var_11 = var_10.popleft()\n var_8 = var_6[var_11]\n var_5 = 1\n for var_12 in var_1[var_11]:\n if var_12 == var_9[var_11]:\n continue\n var_9[var_12] = var_11\n if var_5 == var_8:\n var_5 += 1\n var_6[var_12] = var_5\n var_10.append(var_12)\n var_5 += 1\n print((max(var_6)))\n for var_2, var_4 in var_3:\n if var_2 == var_9[var_4]:\n print((var_6[var_4]))\n else:\n print((var_6[var_2]))\n\n\nif __name__ == \"__main__\":\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nimport copy\n\nvar_8 = int(eval(input()))\nvar_10 = set([var_6 for var_6 in range(1, 10**5)])\nvar_5 = []\nvar_11 = {}\nvar_9 = []\nfor var_6 in range(var_8 - 1):\n var_1, var_2 = list(map(int, input().split(\" \")))\n var_5.append([var_1, var_2])\n var_11.setdefault(var_1, []).append(var_2)\n var_9.append([])\nvar_9.append([])\nvar_9.append([])\nvar_7 = 0\nfor var_12 in range(1, var_8 + 1):\n var_14 = var_11.get(var_12, [])\n var_3 = 1\n for var_13 in var_14:\n if var_3 in var_9[var_12]:\n var_3 += 1\n else:\n pass\n var_9[var_13].append(var_3)\n if var_3 >= var_7:\n var_7 = var_3\n var_3 += 1\nprint(var_7)\nfor var_4 in var_5:\n print((var_9[var_4[1]][0]))\n```", "output": "SLOWER 4.4037", "pair_id": "python_p02850_pair0026_reversed", "problem_id": "p02850", "language": "python", "direction": "reversed", "speedup_ratio": 21.1661} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_6 in range(var_1, var_2 + 1):\n var_3 = str(var_6)\n var_5 = True\n for var_7 in range(len(var_3) // 2):\n if var_3[var_7] != var_3[-var_7 - 1] and var_5:\n var_5 = not var_5\n if var_5:\n var_4 += 1\nprint(var_4)\n```\n\n=== Code B (Modified) ===\n```python\ndef func_1():\n var_1, var_2 = list(map(int, input().split()))\n var_3 = 0\n for var_4 in range(var_1, var_2 + 1):\n\n if (var_4 % 10) == (var_4 // 10000 % 10) and (var_4 // 10 % 10) == (\n var_4 // 1000 % 10\n ):\n var_3 += 1\n print(var_3)\n\n\nif __name__ == \"__main__\":\n func_1()\n```", "output": "FASTER 3.124", "pair_id": "python_p03416_pair0158_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 8.718} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\nfrom collections import Counter\n\n\ndef func_9():\n return sys.stdin.readline().strip()\n\n\ndef func_10(var_8, var_9, var_10):\n return [[var_10] * var_9 for var_13 in range(var_8)]\n\n\ndef func_11(var_8, var_9, var_10, var_11):\n return [[[var_11] * var_10 for var_14 in range(var_9)] for var_13 in range(var_8)]\n\n\ndef func_12(var_8, var_9, var_10, var_11, var_12):\n return [\n [[[var_12] * var_11 for var_14 in range(var_10)] for var_14 in range(var_9)]\n for var_13 in range(var_8)\n ]\n\n\ndef func_8(var_16, var_17=1):\n return int(-(-var_16 // var_17))\n\n\ndef func_1():\n return int(eval(func_9()))\n\n\ndef func_3():\n return list(map(int, func_9().split()))\n\n\ndef func_2(var_7=None):\n return list(func_3()) if var_7 is None else [func_1() for var_13 in range(var_7)]\n\n\ndef func_7():\n print(\"Yes\")\n\n\ndef func_5():\n print(\"No\")\n\n\ndef func_6():\n print(\"YES\")\n\n\ndef func_4():\n print(\"NO\")\n\n\nsys.setrecursionlimit(10**9)\nvar_3 = 10**18\nvar_6 = 10**9 + 7\nvar_7, var_5, var_4 = func_3()\nvar_1 = func_2()\nvar_2 = func_2()\nvar_15 = min(var_1) + min(var_2)\nfor _ in range(var_4):\n var_16, var_17, var_10 = func_3()\n var_16 -= 1\n var_17 -= 1\n var_15 = min(var_15, var_1[var_16] + var_2[var_17] - var_10)\nprint(var_15)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2, var_8 = list(map(int, input().split()))\nvar_4 = list(map(int, input().split()))\nvar_9 = list(map(int, input().split()))\nvar_10 = [list(map(int, input().split())) for var_6 in range(var_8)]\nvar_7 = 200001\nfor var_6 in range(var_8):\n var_5 = var_10[var_6][0] - 1\n var_3 = var_10[var_6][1] - 1\n if var_7 >= var_4[var_5] + var_9[var_3] - var_10[var_6][2]:\n var_7 = var_4[var_5] + var_9[var_3] - var_10[var_6][2]\nvar_4.sort()\nvar_9.sort()\nif var_7 >= (var_4[0] + var_9[0]):\n print((var_4[0] + var_9[0]))\nelse:\n print(var_7)\n```", "output": "FASTER 1.1425", "pair_id": "python_p02748_pair0007_forward", "problem_id": "p02748", "language": "python", "direction": "forward", "speedup_ratio": 2.2077} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\n\nvar_7 = sys.stdin.readline\nfrom itertools import combinations\n\n\ndef func_3(var_10):\n for _ in range(var_10):\n yield list(map(int, var_7().split()))\n\n\ndef func_1(var_9, var_5, var_11):\n var_3 = len([0 for var_8 in var_9 if var_5[var_8] == 1])\n return var_11[var_3]\n\n\ndef func_2():\n var_10 = int(eval(var_7()))\n var_1 = list(func_3(var_10))\n var_2 = list(func_3(var_10))\n for var_6 in range(1, 11):\n for var_4 in combinations(list(range(10)), var_6):\n yield sum(\n func_1(var_4, var_5, var_11) for var_5, var_11 in zip(var_1, var_2)\n )\n\n\nprint((max(func_2())))\n```\n\n=== Code B (Modified) ===\n```python\nvar_8 = int(eval(input()))\nvar_4 = []\nfor var_5 in range(var_8):\n var_11 = 0\n var_9 = list(map(int, input().split()))\n for var_6 in range(10):\n var_11 += var_9[var_6] << var_6\n var_4.append(var_11)\nvar_10 = []\nfor var_5 in range(var_8):\n var_10.append(list(map(int, input().split())))\nvar_1 = -(10**12)\nfor var_5 in range(1, 1 << 10):\n var_11 = 0\n for var_6 in range(var_8):\n var_3 = var_4[var_6] & var_5\n var_2 = 0\n for var_7 in range(10):\n if (var_3 >> var_7) % 2:\n var_2 += 1\n var_11 += var_10[var_6][var_2]\n var_1 = max(var_1, var_11)\nprint(var_1)\n```", "output": "SLOWER 1.4578", "pair_id": "python_p03503_pair0035_reversed", "problem_id": "p03503", "language": "python", "direction": "reversed", "speedup_ratio": 2.7469} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport numpy as np\nfrom itertools import product\n\nvar_6 = int(eval(input()))\nvar_2 = list(map(int, input().split()))\nvar_2 = np.array(var_2)\nvar_5 = [-1, 0, 1]\nvar_3 = 0\nfor var_7 in product(var_5, repeat=var_6):\n var_7 = np.array(var_7)\n var_1 = var_2 + var_7\n var_4 = var_1.cumprod()\n if var_4[-1] % 2 == 0:\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_4 = int(eval(input()))\nvar_2 = list(map(int, input().split()))\n\n\ndef func_1(var_1, var_8, var_3):\n if var_8 == var_4:\n var_9 = 1\n for var_5 in var_3:\n var_9 *= var_5\n return 1 if var_9 % 2 == 0 else 0\n var_6 = var_3.copy()\n var_6.append(var_1[var_8] - 1)\n var_5 = var_3.copy()\n var_5.append(var_1[var_8])\n var_7 = var_3.copy()\n var_7.append(var_1[var_8] + 1)\n return (\n func_1(var_1, var_8 + 1, var_6)\n + func_1(var_1, var_8 + 1, var_5)\n + func_1(var_1, var_8 + 1, var_7)\n )\n\n\nprint((func_1(var_2, 0, [])))\n```", "output": "FASTER 1.7419", "pair_id": "python_p03568_pair0046_forward", "problem_id": "p03568", "language": "python", "direction": "forward", "speedup_ratio": 3.3447} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_5 in range(var_1, var_2 + 1):\n var_3 = str(var_5)\n if var_3[0] == var_3[-1] and var_3[1] == var_3[-2]:\n var_4 += 1\nprint(var_4)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = list(reversed(list(str(var_4))))\n if var_5 == list(str(var_4)):\n var_3 += 1\nprint(var_3)\n```", "output": "SLOWER 1.7485", "pair_id": "python_p03416_pair0130_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 3.3602} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport copy\nimport random\nimport bisect\nimport fractions\nimport math\nimport sys\nimport collections\nfrom decimal import Decimal\n\nvar_5 = 10**9 + 7\nsys.setrecursionlimit(var_5)\nvar_3 = collections.deque()\n\n\ndef func_1():\n return list(map(int, sys.stdin.readline().split()))\n\n\nvar_1 = int(eval(input()))\nvar_6 = [0 for var_4 in range(var_1)]\nfor var_4 in range(var_1):\n var_6[var_4] = int(eval(input()))\nvar_6.sort()\nvar_2 = sum(var_6)\nvar_2 -= var_6[-1] // 2\nprint(var_2)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1 = [int(eval(input())) for _ in range(int(eval(input())))]\nprint((sum(var_1) - int(max(var_1) / 2)))\n```", "output": "FASTER 1.0343", "pair_id": "python_p03207_pair0001_forward", "problem_id": "p03207", "language": "python", "direction": "forward", "speedup_ratio": 2.0481} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = [\n var_3 for var_3 in map(str, list(range(var_1, var_2 + 1))) if var_3 == var_3[::-1]\n]\nprint((len(var_4)))\n```\n\n=== Code B (Modified) ===\n```python\nvar_4, var_3 = list(map(int, input().split()))\nvar_1 = 0\nfor var_2 in range(var_4, var_3 + 1):\n if str(var_2)[0] + str(var_2)[1] == str(var_2)[-1] + str(var_2)[-2]:\n var_1 += 1\nprint(var_1)\n```", "output": "SLOWER 2.0397", "pair_id": "python_p03416_pair0166_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 4.1115} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\nfrom collections import Counter\n\n\ndef func_10():\n return sys.stdin.readline().strip()\n\n\ndef func_11(var_12, var_13, var_14):\n return [[var_14] * var_13 for var_17 in range(var_12)]\n\n\ndef func_12(var_12, var_13, var_14, var_15):\n return [[[var_15] * var_14 for var_18 in range(var_13)] for var_17 in range(var_12)]\n\n\ndef func_13(var_12, var_13, var_14, var_15, var_16):\n return [\n [[[var_16] * var_15 for var_18 in range(var_14)] for var_18 in range(var_13)]\n for var_17 in range(var_12)\n ]\n\n\ndef func_8(var_22, var_23=1):\n return int(-(-var_22 // var_23))\n\n\ndef func_1():\n return int(eval(func_10()))\n\n\ndef func_3():\n return list(map(int, func_10().split()))\n\n\ndef func_2(var_11=None):\n return list(func_3()) if var_11 is None else [func_1() for var_17 in range(var_11)]\n\n\ndef func_7():\n print(\"Yes\")\n\n\ndef func_5():\n print(\"No\")\n\n\ndef func_6():\n print(\"YES\")\n\n\ndef func_4():\n print(\"NO\")\n\n\nsys.setrecursionlimit(10**9)\nvar_5 = 10**18\nvar_10 = 10**9 + 7\n\n\ndef func_9(var_1, var_2):\n \"\"\"\"\"\"\n import numpy as np\n from numpy.fft import rfft, irfft\n\n var_8 = max(var_1)\n var_9 = max(var_2)\n var_3 = [0] * (var_8 + 1)\n var_4 = [0] * (var_9 + 1)\n for var_12 in var_1:\n var_3[var_12] += 1\n for var_13 in var_2:\n var_4[var_13] += 1\n\n var_6 = 1\n var_19 = 0\n while var_6 <= var_8 + var_9:\n var_19 += 1\n var_6 = 2**var_19\n\n var_21 = irfft(rfft(var_3, var_6) * rfft(var_4, var_6), var_6)\n\n var_21 = np.rint(var_21).astype(np.int64)\n return var_21\n\n\nvar_11, var_7, var_6 = func_3()\nvar_1 = func_2()\nvar_2 = func_2()\nvar_21 = list(func_9(var_1, var_2))\nvar_20 = var_5\nfor var_17, var_12 in enumerate(var_21):\n if var_12 != 0:\n var_20 = var_17\n break\nfor _ in range(var_6):\n var_22, var_23, var_14 = func_3()\n var_22 -= 1\n var_23 -= 1\n var_20 = min(var_20, var_1[var_22] + var_2[var_23] - var_14)\nprint(var_20)\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\nfrom collections import Counter\n\n\ndef func_9():\n return sys.stdin.readline().strip()\n\n\ndef func_10(var_8, var_9, var_10):\n return [[var_10] * var_9 for var_13 in range(var_8)]\n\n\ndef func_11(var_8, var_9, var_10, var_11):\n return [[[var_11] * var_10 for var_14 in range(var_9)] for var_13 in range(var_8)]\n\n\ndef func_12(var_8, var_9, var_10, var_11, var_12):\n return [\n [[[var_12] * var_11 for var_14 in range(var_10)] for var_14 in range(var_9)]\n for var_13 in range(var_8)\n ]\n\n\ndef func_8(var_16, var_17=1):\n return int(-(-var_16 // var_17))\n\n\ndef func_1():\n return int(eval(func_9()))\n\n\ndef func_3():\n return list(map(int, func_9().split()))\n\n\ndef func_2(var_7=None):\n return list(func_3()) if var_7 is None else [func_1() for var_13 in range(var_7)]\n\n\ndef func_7():\n print(\"Yes\")\n\n\ndef func_5():\n print(\"No\")\n\n\ndef func_6():\n print(\"YES\")\n\n\ndef func_4():\n print(\"NO\")\n\n\nsys.setrecursionlimit(10**9)\nvar_3 = 10**18\nvar_6 = 10**9 + 7\nvar_7, var_5, var_4 = func_3()\nvar_1 = func_2()\nvar_2 = func_2()\nvar_15 = min(var_1) + min(var_2)\nfor _ in range(var_4):\n var_16, var_17, var_10 = func_3()\n var_16 -= 1\n var_17 -= 1\n var_15 = min(var_15, var_1[var_16] + var_2[var_17] - var_10)\nprint(var_15)\n```", "output": "FASTER 1.3665", "pair_id": "python_p02748_pair0003_forward", "problem_id": "p02748", "language": "python", "direction": "forward", "speedup_ratio": 2.5785} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1 = list(map(int, input().split()))\nvar_2 = 0\nfor var_3 in range(var_1[0], var_1[1] + 1):\n var_4 = str(var_3)\n if var_4[0] == var_4[4] and var_4[1] == var_4[3]:\n var_2 += 1\nprint(var_2)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = list(reversed(list(str(var_4))))\n if var_5 == list(str(var_4)):\n var_3 += 1\nprint(var_3)\n```", "output": "SLOWER 1.9458", "pair_id": "python_p03416_pair0202_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 3.8524} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\ndef func_1():\n var_1, var_2 = list(map(int, input().rstrip().split()))\n var_3 = 0\n for var_4 in range(var_1, var_2 + 1):\n var_5 = str(var_4)\n if var_5 == var_5[::-1]:\n var_3 += 1\n print(var_3)\n\n\nif __name__ == \"__main__\":\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = input().split()\nvar_1 = int(var_1)\nvar_2 = int(var_2)\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = list(str(var_4))\n if (var_5[0] == var_5[4]) and (var_5[1] == var_5[3]):\n var_3 = var_3 + 1\nprint(var_3)\n```", "output": "SLOWER 1.1503", "pair_id": "python_p03416_pair0205_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 2.2196} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport bisect\n\nvar_9, var_4, var_1 = list(map(int, input().split()))\nvar_5 = [None] * var_9\nfor var_7 in range(var_9):\n var_11, var_6 = list(map(int, input().split()))\n var_5[var_7] = (var_11, var_6)\nvar_5.sort()\nvar_11 = [int(var_5[var_7][0]) for var_7 in range(var_9)]\nvar_6 = [int(var_5[var_7][1]) for var_7 in range(var_9)]\nvar_2 = 0\nvar_3 = [0] * var_9\nfor var_7 in range(var_9):\n if var_7 != 0:\n var_3[var_7] += var_3[var_7 - 1]\n if var_3[var_7] >= var_6[var_7]:\n continue\n var_10 = (var_6[var_7] - var_3[var_7] - 1) // var_1 + 1\n var_2 += var_10\n var_3[var_7] += var_10 * var_1\n var_8 = bisect.bisect_right(var_11, var_11[var_7] + 2 * var_4)\n if var_8 == var_9:\n continue\n var_3[var_8] -= var_10 * var_1\nprint(var_2)\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\n\nsys.setrecursionlimit(500000)\n\n\ndef func_3():\n return sys.stdin.readline()[:-1]\n\n\nclass Class_1:\n def __init__(self, var_3):\n self.N = len(var_3)\n self.bit = [0] * self.N\n for var_11, var_14 in enumerate(var_3):\n self.add(var_11, var_14)\n\n def func_1(self, var_5, var_18):\n var_19 = var_5 + 1\n for var_11 in range(1000):\n self.bit[var_19 - 1] += var_18\n var_19 += var_19 & -var_19\n if var_19 > self.N:\n break\n\n def func_5(self, var_5):\n var_19 = var_5 + 1\n var_16 = 0\n for var_11 in range(1000):\n var_16 += self.bit[var_19 - 1]\n var_19 -= var_19 & -var_19\n if var_19 <= 0:\n break\n return var_16\n\n\ndef func_4():\n var_4, var_2, var_1 = list(map(int, func_3().split()))\n var_9 = []\n for var_11 in range(var_4):\n var_19, var_10 = list(map(int, func_3().split()))\n if var_10 % var_1 == 0:\n var_9.append([var_19, var_10 // var_1])\n else:\n var_9.append([var_19, var_10 // var_1 + 1])\n var_9.sort(key=lambda var_19: var_19[0])\n\n def func_2(var_12):\n var_19 = var_9[var_12][0]\n if var_9[var_4 - 1][0] <= var_19 + 2 * var_2:\n return var_4 - 1\n var_14 = var_12\n var_15 = var_4 - 1\n while var_15 - var_14 > 1:\n if var_9[(var_15 + var_14) // 2][0] <= var_19 + 2 * var_2:\n var_14 = (var_15 + var_14) // 2\n else:\n var_15 = (var_15 + var_14) // 2\n return var_14\n\n var_6 = Class_1([0] * var_4)\n var_7 = 0\n for var_11 in range(var_4):\n if var_11 > 0:\n var_17 = var_6.sum(var_4 - 1) - var_6.sum(var_11 - 1)\n else:\n var_17 = 0\n if var_9[var_11][1] - var_17 > 0:\n var_7 += var_9[var_11][1] - var_17\n var_13 = func_2(var_11)\n var_6.add(var_13, var_9[var_11][1] - var_17)\n var_9 = var_9[::-1]\n for var_11 in range(var_4):\n var_9[var_11][0] = -var_9[var_11][0]\n var_6 = Class_1([0] * var_4)\n var_8 = 0\n for var_11 in range(var_4):\n if var_11 > 0:\n var_17 = var_6.sum(var_4 - 1) - var_6.sum(var_11 - 1)\n else:\n var_17 = 0\n if var_9[var_11][1] - var_17 > 0:\n var_8 += var_9[var_11][1] - var_17\n var_13 = func_2(var_11)\n var_6.add(var_13, var_9[var_11][1] - var_17)\n print((min(var_7, var_8)))\n\n\nif __name__ == \"__main__\":\n func_4()\n```", "output": "SLOWER 1.3694", "pair_id": "python_p02788_pair0003_reversed", "problem_id": "p02788", "language": "python", "direction": "reversed", "speedup_ratio": 2.5837} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport math\n\n\ndef func_1():\n var_1, var_2 = list(map(int, input().split()))\n\n var_5 = max(math.ceil(var_1 / 0.08), math.ceil(var_2 / 0.1))\n\n var_4 = min((math.ceil((var_1 + 1) / 0.08), math.ceil((var_2 + 1) / 0.1)))\n\n for var_3 in range(var_5, var_4 + 1):\n if (math.floor(var_3 * 0.08) == var_1) and (math.floor(var_3 * 0.1) == var_2):\n print(var_3)\n quit()\n\n print((-1))\n\n\nif __name__ == \"__main__\":\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_3 = list(map(int, input().split()))\nvar_2 = -1\nfor var_4 in range(10, 12501):\n if int(var_4 * 0.08) == var_1 and int(var_4 * 0.1) == var_3:\n var_2 = var_4\n break\nprint(var_2)\n```", "output": "SLOWER 4.5761", "pair_id": "python_p02755_pair0006_reversed", "problem_id": "p02755", "language": "python", "direction": "reversed", "speedup_ratio": 23.8532} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nfrom collections import Counter\n\nvar_4 = int(eval(input()))\nvar_1 = list(map(int, input().split()))\nvar_2 = Counter(var_1)\nvar_3 = list(var_2)\nif sum(var_1) == 0:\n print(\"Yes\")\nelif len(var_1) % 3 != 0:\n print(\"No\")\nelif len(var_2) > 3 or len(var_2) <= 1:\n print(\"No\")\nelif len(var_2) == 3:\n if (\n var_2[var_3[0]] == var_4 // 3\n and var_2[var_3[1]] == var_4 // 3\n and var_2[var_3[2]] == var_4 // 3\n ):\n if var_3[0] ^ var_3[1] ^ var_3[2] == 0:\n print(\"Yes\")\n else:\n print(\"No\")\n else:\n print(\"No\")\nelse:\n var_3.sort()\n if var_3[0] == 0 and var_2[var_3[0]] == var_4 // 3:\n print(\"Yes\")\n else:\n print(\"No\")\n```\n\n=== Code B (Modified) ===\n```python\n_, var_1 = open(0)\nvar_1, *var_2 = list(map(int, var_1.split()))\nfor var_2 in var_2:\n var_1 ^= var_2\nprint((\"YNeos\"[var_1 > 0 :: 2]))\n```", "output": "FASTER 1.4077", "pair_id": "python_p02975_pair0008_forward", "problem_id": "p02975", "language": "python", "direction": "forward", "speedup_ratio": 2.6532} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_4 = {}\nvar_5 = 0\nfor var_6 in range(10000, 100000):\n var_3 = list(str(var_6))\n if var_3 == list(reversed(var_3)):\n var_5 += 1\n var_4[var_6] = var_5\nvar_1, var_2 = list(map(int, input().split()))\nprint((var_4[var_2] - var_4[var_1 - 1] if var_1 > 10000 else var_4[var_2]))\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_6 = str(var_4)\n var_5 = var_6[::-1]\n if var_6 == var_5:\n var_3 += 1\nprint(var_3)\n```", "output": "FASTER 3.3232", "pair_id": "python_p03416_pair0071_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 10.0089} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().rstrip().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = list(map(int, list(str(var_4))))\n if var_5[0] == var_5[4] and var_5[1] == var_5[3]:\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_4 = {}\nvar_5 = 0\nfor var_6 in range(10000, 100000):\n var_3 = list(str(var_6))\n if var_3 == list(reversed(var_3)):\n var_5 += 1\n var_4[var_6] = var_5\nvar_1, var_2 = list(map(int, input().split()))\nprint((var_4[var_2] - var_4[var_1 - 1] if var_1 > 10000 else var_4[var_2]))\n```", "output": "SLOWER 1.8906", "pair_id": "python_p03416_pair0103_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 3.7079} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\nimport itertools\n\n\ndef func_2(var_4):\n return eval(\"0b\" + var_4)\n\n\ndef func_1():\n var_4 = int(sys.stdin.readline().rstrip())\n var_9 = [\n func_2(\"\".join(str(var_10) for var_10 in sys.stdin.readline().split()))\n for _ in range(var_4)\n ]\n var_8 = [\n [int(var_10) for var_10 in sys.stdin.readline().split()] for _ in range(var_4)\n ]\n var_3 = -(10**10)\n for var_6 in itertools.product(\"01\", repeat=10):\n var_6 = func_2(\"\".join(var_6))\n if var_6 == 0:\n continue\n var_7 = 0\n for var_2 in range(var_4):\n var_1 = var_9[var_2]\n var_5 = bin(var_1 & var_6).count(\"1\")\n var_7 += var_8[var_2][var_5]\n var_3 = max(var_3, var_7)\n print(var_3)\n\n\nif __name__ == \"__main__\":\n\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\nimport itertools\n\n\ndef func_2(var_4):\n return bin(eval(\"0b\" + str(var_4)))\n\n\ndef func_1():\n var_4 = int(sys.stdin.readline().rstrip())\n var_9 = [\n func_2(\"\".join(str(var_10) for var_10 in sys.stdin.readline().split()))\n for _ in range(var_4)\n ]\n var_8 = [\n [int(var_10) for var_10 in sys.stdin.readline().split()] for _ in range(var_4)\n ]\n var_3 = -(10**10)\n for var_6 in itertools.product(\"01\", repeat=10):\n var_6 = func_2(\"\".join(var_6))\n if var_6 == \"0b0\":\n continue\n var_7 = 0\n for var_2 in range(var_4):\n var_1 = var_9[var_2]\n var_5 = bin(eval(var_1) & eval(var_6)).count(\"1\")\n var_7 += var_8[var_2][var_5]\n var_3 = max(var_3, var_7)\n print(var_3)\n\n\nif __name__ == \"__main__\":\n\n func_1()\n```", "output": "SLOWER 2.1735", "pair_id": "python_p03503_pair0039_reversed", "problem_id": "p03503", "language": "python", "direction": "reversed", "speedup_ratio": 4.5112} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\n\"\"\"\"\"\"\n\nfrom collections import deque\n\n\ndef func_1():\n var_5, *var_1 = list(map(int, open(0).read().split()))\n var_2 = var_1[1::2]\n var_4 = [[] for _ in range(var_5 + 1)]\n for var_7, var_8 in zip(*[iter(var_1)] * 2):\n var_4[var_7] += (var_8,)\n var_6 = deque([1])\n var_3 = [0] * (var_5 + 1)\n while var_6:\n var_11 = var_6.popleft()\n var_9 = 0\n for var_10 in var_4[var_11]:\n var_9 += 1 + (var_9 + 1 == var_3[var_11])\n var_3[var_10] = var_9\n var_6 += (var_10,)\n print((max(var_3)))\n for var_8 in var_2:\n print((var_3[var_8]))\n\n\nfunc_1()\n```\n\n=== Code B (Modified) ===\n```python\nimport copy\n\nvar_8 = int(eval(input()))\nvar_10 = set([var_6 for var_6 in range(1, 10**5)])\nvar_5 = []\nvar_11 = {}\nvar_9 = []\nfor var_6 in range(var_8 - 1):\n var_1, var_2 = list(map(int, input().split(\" \")))\n var_5.append([var_1, var_2])\n var_11.setdefault(var_1, []).append(var_2)\n var_9.append([])\nvar_9.append([])\nvar_9.append([])\nvar_7 = 0\nfor var_12 in range(1, var_8 + 1):\n var_14 = var_11.get(var_12, [])\n var_3 = 1\n for var_13 in var_14:\n if var_3 in var_9[var_12]:\n var_3 += 1\n else:\n pass\n var_9[var_13].append(var_3)\n if var_3 >= var_7:\n var_7 = var_3\n var_3 += 1\nprint(var_7)\nfor var_4 in var_5:\n print((var_9[var_4[1]][0]))\n```", "output": "SLOWER 4.6116", "pair_id": "python_p02850_pair0030_reversed", "problem_id": "p02850", "language": "python", "direction": "reversed", "speedup_ratio": 24.4475} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_4 = int(eval(input()))\nvar_2 = list(map(int, input().split()))\n\n\ndef func_1(var_1, var_8, var_3):\n if var_8 == var_4:\n var_9 = 1\n for var_5 in var_3:\n var_9 *= var_5\n return 1 if var_9 % 2 == 0 else 0\n var_6 = var_3.copy()\n var_6.append(var_1[var_8] - 1)\n var_5 = var_3.copy()\n var_5.append(var_1[var_8])\n var_7 = var_3.copy()\n var_7.append(var_1[var_8] + 1)\n return (\n func_1(var_1, var_8 + 1, var_6)\n + func_1(var_1, var_8 + 1, var_5)\n + func_1(var_1, var_8 + 1, var_7)\n )\n\n\nprint((func_1(var_2, 0, [])))\n```\n\n=== Code B (Modified) ===\n```python\nvar_4 = int(eval(input()))\nvar_1 = list(map(int, input().split()))\nvar_3 = 1\nfor var_2 in var_1:\n var_3 *= 2 if var_2 % 2 == 0 else 1\nprint((3**var_4 - var_3))\n```", "output": "FASTER 8.4066", "pair_id": "python_p03568_pair0047_forward", "problem_id": "p03568", "language": "python", "direction": "forward", "speedup_ratio": 339.3399} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_4, var_3 = list(map(int, input().split()))\nvar_1 = 0\nfor var_2 in range(var_4, var_3 + 1):\n if str(var_2)[0] + str(var_2)[1] == str(var_2)[-1] + str(var_2)[-2]:\n var_1 += 1\nprint(var_1)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\n\n\ndef func_1(var_5, var_6):\n var_4 = 0\n for var_3 in range(var_5, var_6 + 1):\n if str(var_3) == str(var_3)[::-1]:\n var_4 += 1\n return var_4\n\n\nprint((func_1(var_1, var_2)))\n```", "output": "FASTER 1.6647", "pair_id": "python_p03416_pair0200_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 3.1705} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1 = lambda: list(map(int, input().split()))\nvar_6 = int(eval(input()))\nif var_6 % 3:\n var_3 = \"YNeos\"[any(var_1()) :: 2]\nelse:\n var_2 = sorted(var_1())\n var_5 = var_6 // 3\n if var_2[0] ^ var_2[var_5] ^ var_2[2 * var_5]:\n var_3 = \"No\"\n elif any(\n len(set(var_2[var_4 : var_4 + var_5])) > 1 for var_4 in range(0, var_6, var_5)\n ):\n var_3 = \"No\"\n else:\n var_3 = \"Yes\"\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_3, var_1 = int(eval(input())), 0\nfor var_2 in list(map(int, input().split())):\n var_1 ^= var_2\nprint((\"Yes\" if var_1 == 0 else \"No\"))\n```", "output": "FASTER 1.2261", "pair_id": "python_p02975_pair0005_forward", "problem_id": "p02975", "language": "python", "direction": "forward", "speedup_ratio": 2.3393} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_11 = int(eval(input()))\nvar_12 = {var_8: [] for var_8 in range(1, var_11 + 1)}\nvar_19 = [False for var_8 in range(var_11 + 1)]\nvar_16 = []\nfor _ in range(var_11 - 1):\n var_2, var_3 = list(map(int, input().split()))\n var_12[var_2].append(var_3)\n var_12[var_3].append(var_2)\n var_16.append((var_2, var_3))\nvar_9 = var_16[0][0]\nvar_19[var_9] = True\nvar_6 = []\nvar_7 = []\nvar_14 = {var_8: {} for var_8 in range(1, var_11 + 1)}\nvar_10 = [0 for var_8 in range(var_11 + 1)]\n\nvar_4 = 1\nfor var_5 in var_12[var_9]:\n var_19[var_5] = True\n var_14[var_9][var_5] = var_4\n var_14[var_5][var_9] = var_4\n var_10[var_5] = var_4\n var_4 += 1\n var_6.append(var_5)\nwhile var_6:\n for var_15 in var_6:\n var_13 = 1\n for var_5 in var_12[var_15]:\n if var_19[var_5] == False:\n var_19[var_5] = True\n if var_13 != var_10[var_15]:\n var_14[var_15][var_5] = var_13\n var_14[var_5][var_15] = var_13\n var_10[var_5] = var_13\n var_13 += 1\n var_7.append(var_5)\n else:\n var_13 += 1\n var_14[var_15][var_5] = var_13\n var_14[var_5][var_15] = var_13\n var_10[var_5] = var_13\n var_13 += 1\n var_7.append(var_5)\n if var_7:\n var_6 = var_7\n var_7 = []\n else:\n var_6 = []\n var_7 = []\nvar_1 = 0\nfor var_8 in range(1, var_11 + 1):\n var_1 = max(var_1, len(var_12[var_8]))\nprint(var_1)\nfor var_8 in range(var_11 - 1):\n var_17, var_18 = var_16[var_8][0], var_16[var_8][1]\n print((var_14[var_17][var_18]))\n```\n\n=== Code B (Modified) ===\n```python\n\"\"\"\"\"\"\n\nfrom collections import deque\n\n\ndef func_1():\n var_5, *var_1 = list(map(int, open(0).read().split()))\n var_2 = var_1[1::2]\n var_4 = [[] for _ in range(var_5 + 1)]\n for var_7, var_8 in zip(*[iter(var_1)] * 2):\n var_4[var_7].append(var_8)\n var_6 = deque([1])\n var_3 = [0] * (var_5 + 1)\n while var_6:\n var_11 = var_6.popleft()\n var_9 = 0\n for var_10 in var_4[var_11]:\n var_9 += 1 + (var_9 + 1 == var_3[var_11])\n var_3[var_10] = var_9\n var_6.append(var_10)\n print((max(var_3)))\n for var_8 in var_2:\n print((var_3[var_8]))\n\n\nfunc_1()\n```", "output": "FASTER 1.0109", "pair_id": "python_p02850_pair0024_forward", "problem_id": "p02850", "language": "python", "direction": "forward", "speedup_ratio": 2.0151} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\n\nvar_20 = sys.stdin.read\nvar_21 = sys.stdin.readline\nvar_22 = sys.stdin.readlines\nsys.setrecursionlimit(10**9)\nvar_2 = 1 << 60\nvar_5 = 1000000007\n\n\nvar_4 = 1000001\n\n\nclass Class_1:\n def __init__(self, var_13, var_19, var_12):\n self.l = var_13\n self.r = var_19\n self.idx = var_12\n\n\ndef func_4(var_12, var_24, var_10, var_15):\n while var_12 <= var_15:\n var_10[var_12] += var_24\n var_12 += var_12 & -var_12\n\n\ndef func_3(var_12, var_10, var_15):\n var_23 = 0\n while var_12:\n var_23 += var_10[var_12]\n var_12 -= var_12 & -var_12\n return var_23\n\n\ndef func_1(var_9, var_15, var_17, var_16):\n\n var_10 = [0] * (var_15 + 1)\n\n var_14 = [-1] * var_4\n\n var_8 = [0] * var_16\n var_18 = 0\n for var_11 in range(var_15):\n\n if var_14[var_9[var_11]] != -1:\n func_4(var_14[var_9[var_11]] + 1, -1, var_10, var_15)\n\n var_14[var_9[var_11]] = var_11\n func_4(var_11 + 1, 1, var_10, var_15)\n\n while var_18 < var_16 and var_17[var_18].r == var_11:\n var_8[var_17[var_18].idx] = func_3(\n var_17[var_18].r + 1, var_10, var_15\n ) - func_3(var_17[var_18].l, var_10, var_15)\n var_18 += 1\n\n for var_11 in range(var_16):\n print((var_8[var_11]))\n\n\ndef func_2():\n var_6, var_7 = list(map(int, var_21().split()))\n var_1 = list(map(int, var_21().split()))\n (*var_3,) = list(map(int, var_20().split()))\n var_17 = [0] * var_7\n for var_11, (var_13, var_19) in enumerate(zip(*[iter(var_3)] * 2)):\n var_17[var_11] = Class_1(var_13 - 1, var_19 - 1, var_11)\n var_17.sort(key=lambda var_25: var_25.r)\n func_1(var_1, var_6, var_17, var_7)\n return\n\n\nif __name__ == \"__main__\":\n func_2()\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\n\n\ndef func_6():\n return sys.stdin.readline()[:-1]\n\n\ndef func_2():\n return int(eval(func_6()))\n\n\ndef func_3():\n return list(map(int, func_6().split()))\n\n\ndef func_1():\n return list(func_3())\n\n\nvar_10, var_11 = func_3()\nvar_5 = [0] + func_1()\nvar_3 = [func_1() + [var_6] for var_6 in range(var_11)]\nvar_3.sort(key=lambda var_15: var_15[1])\nvar_4 = [0] * (var_11)\nvar_9 = [0 for var_6 in range(var_10 + 1)]\nvar_2 = 2\nwhile var_2 <= var_10:\n var_2 *= 2\nvar_1 = [0] * (var_2 + 1)\n\n\ndef func_4(var_6, var_15):\n while var_6 <= var_2:\n var_1[var_6] += var_15\n var_6 += var_6 & -var_6\n\n\ndef func_5(var_6):\n var_13 = 0\n while var_6:\n var_13 += var_1[var_6]\n var_6 -= var_6 & -var_6\n return var_13\n\n\ndef func_7(var_8, var_12):\n return func_5(var_12) - func_5(var_8 - 1)\n\n\nvar_7 = 1\nfor var_8, var_12, var_6 in var_3:\n while var_7 <= var_12:\n var_14 = var_5[var_7]\n if var_9[var_14]:\n func_4(var_9[var_14], -1)\n func_4(var_7, 1)\n var_9[var_14] = var_7\n var_7 += 1\n var_4[var_6] = func_7(var_8, var_12)\nfor var_6 in var_4:\n print(var_6)\n```", "output": "FASTER 2.4053", "pair_id": "python_p02599_pair0001_forward", "problem_id": "p02599", "language": "python", "direction": "forward", "speedup_ratio": 5.2974} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_5 in range(10):\n for var_6 in range(10):\n for var_7 in range(10):\n var_3 = 10000 * var_5 + 1000 * var_6 + 100 * var_7 + 10 * var_6 + var_5\n if var_1 <= var_3 <= var_2:\n var_4 += 1\nprint(var_4)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = [\n var_3 for var_3 in map(str, list(range(var_1, var_2 + 1))) if var_3 == var_3[::-1]\n]\nprint((len(var_4)))\n```", "output": "SLOWER 3.127", "pair_id": "python_p03416_pair0078_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 8.7361} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\n\n\ndef func_1(var_5):\n var_4 = 0\n for var_3 in range(1, var_5 + 1):\n if str(var_3) == str(var_3)[::-1]:\n var_4 += 1\n return var_4\n\n\nprint((func_1(var_2) - func_1(var_1 - 1)))\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_5 in range(var_1, var_2 + 1):\n var_3 = str(var_5)\n if var_3[0] == var_3[-1] and var_3[1] == var_3[-2]:\n var_4 += 1\nprint(var_4)\n```", "output": "FASTER 1.6822", "pair_id": "python_p03416_pair0020_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 3.2092} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_3 = list(map(int, input().split()))\nvar_2 = 0\nfor var_5 in range(var_3 + 1)[var_1:]:\n if len(str(var_5)) % 2 == 0:\n var_6 = list(str(var_5))[: len(str(var_5)) // 2]\n var_7 = list(reversed(list(str(var_5))[len(str(var_5)) // 2 :]))\n if var_6 == var_7:\n var_2 += 1\n else:\n var_8 = list(str(var_5))[: len(str(var_5)) // 2 + 1]\n var_4 = list(reversed(list(str(var_5))[len(str(var_5)) // 2 :]))\n if var_8 == var_4:\n var_2 += 1\nprint(var_2)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = input().split()\nvar_1 = int(var_1)\nvar_2 = int(var_2)\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = list(str(var_4))\n if (var_5[0] == var_5[4]) and (var_5[1] == var_5[3]):\n var_3 = var_3 + 1\nprint(var_3)\n```", "output": "FASTER 2.0702", "pair_id": "python_p03416_pair0036_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 4.1995} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_3 = list(map(int, input().split()))\nvar_2 = 0\nfor var_5 in range(var_3 + 1)[var_1:]:\n if len(str(var_5)) % 2 == 0:\n var_6 = list(str(var_5))[: len(str(var_5)) // 2]\n var_7 = list(reversed(list(str(var_5))[len(str(var_5)) // 2 :]))\n if var_6 == var_7:\n var_2 += 1\n else:\n var_8 = list(str(var_5))[: len(str(var_5)) // 2 + 1]\n var_4 = list(reversed(list(str(var_5))[len(str(var_5)) // 2 :]))\n if var_8 == var_4:\n var_2 += 1\nprint(var_2)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\n\n\ndef func_1(var_5, var_6):\n var_4 = 0\n for var_3 in range(var_5, var_6 + 1):\n if str(var_3) == str(var_3)[::-1]:\n var_4 += 1\n return var_4\n\n\nprint((func_1(var_1, var_2)))\n```", "output": "FASTER 2.7982", "pair_id": "python_p03416_pair0199_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 6.9556} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport copy\n\nvar_8 = int(eval(input()))\nvar_10 = set([var_6 for var_6 in range(1, 10**5)])\nvar_5 = []\nvar_11 = {}\nvar_9 = []\nfor var_6 in range(var_8 - 1):\n var_1, var_2 = list(map(int, input().split(\" \")))\n var_5.append([var_1, var_2])\n var_11.setdefault(var_1, []).append(var_2)\n var_9.append([])\nvar_9.append([])\nvar_9.append([])\nvar_7 = 0\nfor var_12 in range(1, var_8 + 1):\n var_14 = var_11.get(var_12, [])\n var_3 = 1\n for var_13 in var_14:\n if var_3 in var_9[var_12]:\n var_3 += 1\n else:\n pass\n var_9[var_13].append(var_3)\n if var_3 >= var_7:\n var_7 = var_3\n var_3 += 1\nprint(var_7)\nfor var_4 in var_5:\n print((var_9[var_4[1]][0]))\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\n\nvar_12 = sys.stdin.readline\nvar_2 = int(eval(var_12()))\nvar_9 = [[] for _ in range(var_2)]\nvar_1 = {}\nfor var_10 in range(var_2 - 1):\n var_4, var_6 = list(map(int, var_12().split()))\n var_9[var_4 - 1].append(var_6 - 1)\n var_9[var_6 - 1].append(var_4 - 1)\n var_1[(var_4 - 1) * var_2 + var_6 - 1] = var_10\n var_1[(var_6 - 1) * var_2 + var_4 - 1] = var_10\nvar_15 = [0]\nvar_8 = [False] * var_2\nvar_8[0] = True\nvar_3 = [None] * var_2\nvar_3[0] = 0\nvar_5 = [None] * (var_2 - 1)\nwhile var_15:\n var_16 = []\n for var_14 in var_15:\n var_7 = var_3[var_14]\n var_17 = 1\n for var_13 in var_9[var_14]:\n if not var_8[var_13]:\n var_8[var_13] = True\n var_16.append(var_13)\n var_11 = var_1[var_14 * var_2 + var_13]\n if var_17 == var_7:\n var_17 += 1\n var_5[var_11] = var_17\n var_3[var_13] = var_17\n var_17 += 1\n var_15 = var_16\nprint((max(var_5)))\nfor var_4 in var_5:\n print(var_4)\n```", "output": "FASTER 4.2702", "pair_id": "python_p02850_pair0019_forward", "problem_id": "p02850", "language": "python", "direction": "forward", "speedup_ratio": 19.2961} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_2, var_3, *var_1 = list(map(int, open(0).read().split()))\nvar_4 = [0] * (var_3 + max(var_1[::2]))\nfor var_7, var_6 in sorted(zip(*[iter(var_1)] * 2)):\n for var_5 in reversed(list(range(var_3))):\n var_4[var_5 + var_7] = max(var_4[var_5 + var_7], var_4[var_5] + var_6)\nprint((max(var_4)))\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_6 = sorted([list(map(int, input().split())) for var_5 in range(var_1)])\n\nvar_4 = [[0] * (var_2 + 1) for var_5 in range(var_1 + 1)]\n\nfor var_5 in range(var_1):\n var_9, var_8 = var_6[var_5]\n for var_7 in range(var_2 + 1):\n if var_7 + var_9 <= var_2:\n var_4[var_5 + 1][var_7 + var_9] = max(\n var_4[var_5 + 1][var_7 + var_9], var_4[var_5][var_7] + var_8\n )\n var_4[var_5 + 1][var_7] = max(var_4[var_5][var_7], var_4[var_5 + 1][var_7])\nvar_3 = 0\nfor var_5, (var_9, var_8) in enumerate(var_6):\n for var_7 in range(var_2):\n var_3 = max(var_3, var_4[var_5][var_7] + var_8)\nprint(var_3)\n```", "output": "SLOWER 1.3487", "pair_id": "python_p02863_pair0050_reversed", "problem_id": "p02863", "language": "python", "direction": "reversed", "speedup_ratio": 2.5469} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_4 = str(var_4)\n if var_4 == var_4[::-1]:\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_5 in range(10):\n for var_6 in range(10):\n for var_7 in range(10):\n var_3 = 10000 * var_5 + 1000 * var_6 + 100 * var_7 + 10 * var_6 + var_5\n if var_1 <= var_3 <= var_2:\n var_4 += 1\nprint(var_4)\n```", "output": "FASTER 3.9726", "pair_id": "python_p03416_pair0122_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 15.6985} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport copy\n\nvar_8 = int(eval(input()))\nvar_10 = set([var_6 for var_6 in range(1, 10**5)])\nvar_5 = []\nvar_11 = {}\nvar_9 = []\nfor var_6 in range(var_8 - 1):\n var_1, var_2 = list(map(int, input().split(\" \")))\n var_5.append([var_1, var_2])\n var_11.setdefault(var_1, []).append(var_2)\n var_9.append([])\nvar_9.append([])\nvar_9.append([])\nvar_7 = 0\nfor var_12 in range(1, var_8 + 1):\n var_14 = var_11.get(var_12, [])\n var_3 = 1\n for var_13 in var_14:\n if var_3 in var_9[var_12]:\n var_3 += 1\n else:\n pass\n var_9[var_13].append(var_3)\n if var_3 >= var_7:\n var_7 = var_3\n var_3 += 1\nprint(var_7)\nfor var_4 in var_5:\n print((var_9[var_4[1]][0]))\n```\n\n=== Code B (Modified) ===\n```python\n\"\"\"\"\"\"\n\nfrom collections import deque\n\n\ndef func_1():\n var_5, *var_1 = list(map(int, open(0).read().split()))\n var_2 = var_1[1::2]\n var_4 = [[] for _ in range(var_5 + 1)]\n for var_7, var_8 in zip(*[iter(var_1)] * 2):\n var_4[var_7] += (var_8,)\n var_6 = deque([1])\n var_3 = [0] * (var_5 + 1)\n while var_6:\n var_11 = var_6.popleft()\n var_9 = 0\n for var_10 in var_4[var_11]:\n var_9 += 1 + (var_9 + 1 == var_3[var_11])\n var_3[var_10] = var_9\n var_6 += (var_10,)\n print((max(var_3)))\n for var_8 in var_2:\n print((var_3[var_8]))\n\n\nfunc_1()\n```", "output": "FASTER 4.6116", "pair_id": "python_p02850_pair0030_forward", "problem_id": "p02850", "language": "python", "direction": "forward", "speedup_ratio": 24.4475} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\nfrom operator import itemgetter\nfrom heapq import heapify, heappop, heappush\n\nvar_1 = int(10e15)\nvar_2 = -var_1\nvar_11 = 1000000007\nsys.setrecursionlimit(1000000)\n\n\ndef func_2():\n return list(map(int, input().split()))\n\n\ndef func_4():\n return input().split()\n\n\ndef func_1():\n return int(sys.stdin.readline())\n\n\ndef func_3():\n return eval(input())\n\n\nvar_3, var_4 = func_2()\nvar_5 = [func_2() for var_9 in range(var_3)]\nvar_5.sort(key=itemgetter(0))\n\nvar_8 = [[0] * (var_4 + 1 + 3000 + 1) for _ in range(var_3 + 1)]\nvar_6 = 0\nfor var_9 in range(var_3):\n for var_10 in range(var_4 + 1 + 3000 + 1):\n var_12, var_7 = var_5[var_9]\n if 0 <= var_10 - var_12 < var_4:\n var_8[var_9 + 1][var_10] = max(\n var_8[var_9][var_10], var_8[var_9][var_10 - var_12] + var_7\n )\n else:\n var_8[var_9 + 1][var_10] = var_8[var_9][var_10]\n var_6 = max(var_6, var_8[var_9 + 1][var_10])\nprint(var_6)\n```\n\n=== Code B (Modified) ===\n```python\nimport bisect\nimport sys\n\nsys.setrecursionlimit(10**6)\nvar_16 = sys.stdout.write\nvar_7 = lambda *var_14: print(*var_14) if var_1 else 0\nvar_1 = True\n\n\ndef func_1(var_9=sys.stdin.readline):\n var_11 = lambda: var_9().rstrip()\n var_3 = lambda: list(map(int, var_11().split()))\n var_2 = lambda: int(var_11())\n var_4 = lambda var_17: [var_3() for _ in range(var_17)]\n var_13, var_15 = var_3()\n var_5 = var_4(var_13)\n var_5.sort()\n var_8 = [[0] * var_15 for _ in range(var_13 + 1)]\n for var_10 in range(1, var_13 + 1):\n for var_12 in range(1, var_15):\n if var_12 < var_5[var_10 - 1][0]:\n var_8[var_10][var_12] = var_8[var_10 - 1][var_12]\n else:\n var_8[var_10][var_12] = max(\n var_8[var_10 - 1][var_12],\n var_8[var_10 - 1][var_12 - var_5[var_10 - 1][0]]\n + var_5[var_10 - 1][1],\n )\n var_6 = 0\n for var_10 in range(var_13):\n var_6 = max(var_6, var_8[var_10][var_15 - 1] + var_5[var_10][1])\n print(var_6)\n\n\nif __name__ == \"__main__\":\n func_1()\n```", "output": "FASTER 5.2198", "pair_id": "python_p02863_pair0061_forward", "problem_id": "p02863", "language": "python", "direction": "forward", "speedup_ratio": 37.2652} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_5 in range(10):\n for var_6 in range(10):\n for var_7 in range(10):\n var_3 = 10000 * var_5 + 1000 * var_6 + 100 * var_7 + 10 * var_6 + var_5\n if var_1 <= var_3 <= var_2:\n var_4 += 1\nprint(var_4)\n```\n\n=== Code B (Modified) ===\n```python\nvar_4 = {}\nvar_5 = 0\nfor var_6 in range(10000, 100000):\n var_3 = list(str(var_6))\n if var_3 == list(reversed(var_3)):\n var_5 += 1\n var_4[var_6] = var_5\nvar_1, var_2 = list(map(int, input().split()))\nprint((var_4[var_2] - var_4[var_1 - 1] if var_1 > 10000 else var_4[var_2]))\n```", "output": "SLOWER 7.3992", "pair_id": "python_p03416_pair0222_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 168.7989} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = input().split()\nprint((int(var_1) * int(var_2[:-3] + var_2[-2:]) // 100))\n```\n\n=== Code B (Modified) ===\n```python\ndef func_1():\n from sys import setrecursionlimit, stdin\n from os import environ\n from collections import defaultdict, deque, Counter\n from math import ceil, floor, gcd\n from itertools import accumulate, combinations, combinations_with_replacement\n\n setrecursionlimit(10**6)\n var_7 = (\n (lambda *var_11: print(*var_11))\n if \"TERM_PROGRAM\" in environ\n else lambda *var_12: 0\n )\n var_8 = lambda: stdin.readline().rstrip()\n var_3 = lambda: list(map(int, var_8().split()))\n var_1 = lambda: int(var_8())\n var_4 = 10**9 + 7\n var_2 = 10**9 + 10\n var_9, var_10 = var_8().split()\n var_5 = int(var_9)\n var_6 = int(float(var_10) * 100 + 0.5)\n print(var_5 * var_6 // 100)\n\n\nfunc_1()\n```", "output": "SLOWER 2.4305", "pair_id": "python_p02659_pair0014_reversed", "problem_id": "p02659", "language": "python", "direction": "reversed", "speedup_ratio": 5.3907} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\ndef func_1():\n from sys import setrecursionlimit, stdin\n from os import environ\n from collections import defaultdict, deque, Counter\n from math import ceil, floor, gcd\n from itertools import accumulate, combinations, combinations_with_replacement\n\n setrecursionlimit(10**6)\n var_7 = (\n (lambda *var_11: print(*var_11))\n if \"TERM_PROGRAM\" in environ\n else lambda *var_12: 0\n )\n var_8 = lambda: stdin.readline().rstrip()\n var_3 = lambda: list(map(int, var_8().split()))\n var_1 = lambda: int(var_8())\n var_4 = 10**9 + 7\n var_2 = 10**9 + 10\n var_9, var_10 = var_8().split()\n var_5 = int(var_9)\n var_6 = int(float(var_10) * 100 + 0.5)\n print(var_5 * var_6 // 100)\n\n\nfunc_1()\n```\n\n=== Code B (Modified) ===\n```python\nfrom decimal import Decimal\nimport math\n\nvar_1, var_2 = list(map(str, input().split()))\nvar_1 = int(var_1)\nvar_2 = Decimal(var_2)\nvar_3 = math.floor(var_1 * var_2)\nprint((int(var_3)))\n```", "output": "FASTER 1.6812", "pair_id": "python_p02659_pair0003_forward", "problem_id": "p02659", "language": "python", "direction": "forward", "speedup_ratio": 3.207} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport numpy as np\nfrom itertools import product\n\nvar_6 = int(eval(input()))\nvar_2 = list(map(int, input().split()))\nvar_2 = np.array(var_2)\nvar_5 = [-1, 0, 1]\nvar_3 = 0\nfor var_7 in product(var_5, repeat=var_6):\n var_7 = np.array(var_7)\n var_1 = var_2 + var_7\n var_4 = var_1.cumprod()\n if var_4[-1] % 2 == 0:\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\ndef func_1():\n var_2 = int(eval(input()))\n var_1 = [int(var_6) for var_6 in input().split()]\n var_4 = 3**var_2\n var_5 = len([var_3 for var_3 in var_1 if var_3 % 2 == 0])\n var_4 -= 2**var_5\n print(var_4)\n\n\nif __name__ == \"__main__\":\n func_1()\n```", "output": "FASTER 9.5157", "pair_id": "python_p03568_pair0005_forward", "problem_id": "p03568", "language": "python", "direction": "forward", "speedup_ratio": 732.014} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nfrom sys import stdin\n\n\ndef func_1():\n\n var_13 = stdin.readline\n var_2 = int(var_13())\n var_1 = []\n for var_6 in range(var_2):\n var_5 = list(map(int, var_13().split()))\n var_1.append(var_5)\n var_3 = []\n for var_6 in range(var_2):\n var_12 = list(map(int, var_13().split()))\n var_3.append(var_12)\n var_9 = -float(\"inf\")\n for var_6 in range(1 << 10):\n if var_6 == 0:\n continue\n else:\n var_11 = []\n for var_7 in range(10):\n if (var_6 >> var_7) & 1:\n var_11.append(var_7)\n var_10 = [0] * 10\n for var_7 in var_11:\n var_10[var_7] = 1\n var_14 = 0\n for var_7 in range(var_2):\n var_4 = 0\n for var_8 in range(10):\n if var_10[var_8] == 1 and var_1[var_7][var_8] == 1:\n var_4 += 1\n var_14 += var_3[var_7][var_4]\n var_9 = max(var_14, var_9)\n print(var_9)\n\n\nif __name__ == \"__main__\":\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nvar_5 = 0\nif var_5 == 0:\n var_8 = int(eval(input()))\n var_2 = []\n for var_4 in range(var_8):\n var_3 = list(map(int, input().split()))\n var_2.append(var_3)\n var_9 = []\n for var_4 in range(var_8):\n var_10 = list(map(int, input().split()))\n var_9.append(var_10)\nelif var_5 == 1:\n var_8 = 1\n var_2 = [[1, 1, 0, 1, 0, 0, 0, 1, 0, 1]]\n var_9 = [[3, 4, 5, 6, 7, 8, 9, -2, -3, 4, -2]]\nelif var_5 == 2:\n var_8 = 2\n var_2 = [[1, 1, 1, 1, 1, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 1, 1, 1, 1, 1]]\n var_9 = [\n [0, -2, -2, -2, -2, -2, -1, -1, -1, -1, -1],\n [0, -2, -2, -2, -2, -2, -1, -1, -1, -1, -1],\n ]\nelif var_5 == 3:\n var_8 = 3\n var_2 = [\n [1, 1, 1, 1, 1, 1, 0, 0, 1, 1],\n [0, 1, 0, 1, 1, 1, 1, 0, 1, 0],\n [1, 0, 1, 1, 0, 1, 0, 1, 0, 1],\n ]\n var_9 = [\n [-8, 6, -2, -8, -8, 4, 8, 7, -6, 2, 2],\n [-9, 2, 0, 1, 7, -5, 0, -2, -6, 5, 5],\n [6, -6, 7, -9, 6, -5, 8, 0, -9, -7, -7],\n ]\nimport itertools\n\nvar_13 = -(10**11)\nfor var_4 in itertools.product([0, 1], repeat=10):\n var_11 = list(var_4)\n var_12 = 0\n if sum(var_11) != 0:\n for var_7 in range(var_8):\n var_1 = 0\n for var_6 in range(10):\n var_1 = var_1 + var_11[var_6] * var_2[var_7][var_6]\n var_12 = var_12 + var_9[var_7][var_1]\n\n var_13 = max(var_12, var_13)\nprint(var_13)\n```", "output": "SLOWER 1.1878", "pair_id": "python_p03503_pair0030_reversed", "problem_id": "p03503", "language": "python", "direction": "reversed", "speedup_ratio": 2.2781} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\ndef func_1():\n var_1, var_2 = list(map(int, input().split()))\n var_3 = 0\n for var_4 in range(var_1, var_2 + 1):\n\n if (var_4 % 10) == (var_4 // 10000 % 10) and (var_4 // 10 % 10) == (\n var_4 // 1000 % 10\n ):\n var_3 += 1\n print(var_3)\n\n\nif __name__ == \"__main__\":\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_8 in range(var_1, var_2 + 1):\n var_7 = str(var_8)\n var_6 = len(var_7)\n var_4 = True\n for var_5 in range(var_6 // 2):\n if var_7[var_5] != var_7[var_6 - 1 - var_5]:\n var_4 = False\n break\n if var_4:\n var_3 += 1\nprint(var_3)\n```", "output": "SLOWER 2.7903", "pair_id": "python_p03416_pair0223_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 6.9176} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_4, var_3 = list(map(int, input().split()))\nvar_1 = [0] * var_4\nfor var_2 in range(var_3):\n var_5, var_6 = list(map(int, input().split()))\n var_1[var_5 - 1] += 1\n var_1[var_6 - 1] += 1\nfor var_2 in range(var_4):\n print((var_1[var_2]))\n```\n\n=== Code B (Modified) ===\n```python\nvar_3, var_2 = map(int, input().split())\nvar_4 = [0] * var_3\n[\n exec(\n \"roads[%d] += 1; roads[%d] += 1\"\n % tuple(map(lambda var_1: int(var_1) - 1, input().split()))\n )\n for _ in range(var_2)\n]\nprint(*var_4, sep=\"\\n\", end=\"\")\n```", "output": "SLOWER 1.1067", "pair_id": "python_p03720_pair0002_reversed", "problem_id": "p03720", "language": "python", "direction": "reversed", "speedup_ratio": 2.1535} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_2, var_1 = list(map(int, input().split()))\nvar_7 = []\nfor var_6 in range(var_1):\n var_3, var_5 = list(map(int, input().split()))\n var_7.append([var_5, var_3])\n\nvar_7.sort()\nvar_4 = 1\nvar_9, var_8 = var_7[0]\nfor var_6 in range(1, var_1):\n var_5, var_3 = var_7[var_6]\n if var_9 <= var_3:\n var_9 = var_5\n var_4 += 1\nprint(var_4)\n```\n\n=== Code B (Modified) ===\n```python\nvar_2, var_1 = [int(var_12) for var_12 in input().split()]\nvar_3 = []\nfor var_8 in range(var_1):\n var_5, var_6 = [int(var_12) for var_12 in input().split()]\n var_3.append((var_5, var_6))\nvar_3.sort()\nvar_9 = float(\"inf\")\nvar_4 = [var_9 for var_5 in range(var_2 + 1)]\nfor var_5, var_6 in var_3:\n var_4[var_5] = min(var_4[var_5], var_6)\nvar_3 = [\n (var_5, var_4[var_5]) for var_5 in range(1, var_2 + 1) if var_4[var_5] != var_9\n]\nvar_3.sort(key=lambda var_11: var_11[1])\nvar_7 = [True] * (var_2)\nvar_10 = None\nfor var_5, var_6 in var_3:\n if var_10 == None or var_10 < var_5:\n var_7[var_6 - 1] = False\n var_10 = var_6 - 1\nprint((sum(1 for var_6 in var_7 if not var_6)))\n```", "output": "SLOWER 1.0817", "pair_id": "python_p03295_pair0004_reversed", "problem_id": "p03295", "language": "python", "direction": "reversed", "speedup_ratio": 2.1165} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\n_, var_1 = open(0)\nvar_1, *var_2 = list(map(int, var_1.split()))\nfor var_2 in var_2:\n var_1 ^= var_2\nprint((\"YNeos\"[var_1 > 0 :: 2]))\n```\n\n=== Code B (Modified) ===\n```python\ndef func_1():\n from collections import Counter\n\n var_4 = int(eval(input()))\n (*var_1,) = list(map(int, input().split()))\n if var_4 % 3 == 0:\n var_2 = Counter(var_1)\n if len(var_2) == 1:\n print((\"Yes\" if 0 in var_2 else \"No\"))\n return\n elif len(var_2) == 2:\n print((\"Yes\" if var_2[0] == var_4 // 3 else \"No\"))\n return\n elif len(var_2) == 3:\n var_7 = 0\n var_5 = None\n for var_3, var_6 in list(var_2.items()):\n if var_5 is None:\n var_5 = var_6\n elif var_5 != var_6:\n print(\"No\")\n return\n var_7 ^= var_3\n print((\"Yes\" if var_7 == 0 else \"No\"))\n return\n else:\n print(\"No\")\n return\n else:\n print((\"Yes\" if all([var_7 == 0 for var_7 in var_1]) else \"No\"))\n return\n\n\nif __name__ == \"__main__\":\n func_1()\n```", "output": "SLOWER 1.5263", "pair_id": "python_p02975_pair0006_reversed", "problem_id": "p02975", "language": "python", "direction": "reversed", "speedup_ratio": 2.8805} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().strip().split(\" \")))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n if str(var_4) == str(var_4)[::-1]:\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_6 in range(var_1, var_2 + 1):\n var_3 = str(var_6)\n var_5 = True\n for var_7 in range(len(var_3) // 2):\n if var_3[var_7] != var_3[-var_7 - 1] and var_5:\n var_5 = not var_5\n if var_5:\n var_4 += 1\nprint(var_4)\n```", "output": "SLOWER 1.1527", "pair_id": "python_p03416_pair0224_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 2.2233} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = [\n var_3 for var_3 in map(str, list(range(var_1, var_2 + 1))) if var_3 == var_3[::-1]\n]\nprint((len(var_4)))\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = input().split()\nvar_1 = int(var_1)\nvar_2 = int(var_2)\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = list(str(var_4))\n if (var_5[0] == var_5[4]) and (var_5[1] == var_5[3]):\n var_3 = var_3 + 1\nprint(var_3)\n```", "output": "SLOWER 1.1029", "pair_id": "python_p03416_pair0189_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 2.1478} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_4 = str(var_4)\n if var_4[0] == var_4[-1] and var_4[1] == var_4[-2]:\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = list(str(var_4))\n if var_5 == list(reversed(var_5)):\n var_3 += 1\nprint(var_3)\n```", "output": "SLOWER 1.4159", "pair_id": "python_p03416_pair0207_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 2.6682} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = list(str(var_4))\n if var_5 == list(reversed(var_5)):\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = [\n var_3 for var_3 in map(str, list(range(var_1, var_2 + 1))) if var_3 == var_3[::-1]\n]\nprint((len(var_4)))\n```", "output": "FASTER 1.9307", "pair_id": "python_p03416_pair0225_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 3.8125} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_5 = 0\nif var_5 == 0:\n var_8 = int(eval(input()))\n var_2 = []\n for var_4 in range(var_8):\n var_3 = list(map(int, input().split()))\n var_2.append(var_3)\n var_9 = []\n for var_4 in range(var_8):\n var_10 = list(map(int, input().split()))\n var_9.append(var_10)\nelif var_5 == 1:\n var_8 = 1\n var_2 = [[1, 1, 0, 1, 0, 0, 0, 1, 0, 1]]\n var_9 = [[3, 4, 5, 6, 7, 8, 9, -2, -3, 4, -2]]\nelif var_5 == 2:\n var_8 = 2\n var_2 = [[1, 1, 1, 1, 1, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 1, 1, 1, 1, 1]]\n var_9 = [\n [0, -2, -2, -2, -2, -2, -1, -1, -1, -1, -1],\n [0, -2, -2, -2, -2, -2, -1, -1, -1, -1, -1],\n ]\nelif var_5 == 3:\n var_8 = 3\n var_2 = [\n [1, 1, 1, 1, 1, 1, 0, 0, 1, 1],\n [0, 1, 0, 1, 1, 1, 1, 0, 1, 0],\n [1, 0, 1, 1, 0, 1, 0, 1, 0, 1],\n ]\n var_9 = [\n [-8, 6, -2, -8, -8, 4, 8, 7, -6, 2, 2],\n [-9, 2, 0, 1, 7, -5, 0, -2, -6, 5, 5],\n [6, -6, 7, -9, 6, -5, 8, 0, -9, -7, -7],\n ]\nimport itertools\n\nvar_13 = -(10**11)\nfor var_4 in itertools.product([0, 1], repeat=10):\n var_11 = list(var_4)\n var_12 = 0\n if sum(var_11) != 0:\n for var_7 in range(var_8):\n var_1 = 0\n for var_6 in range(10):\n var_1 = var_1 + var_11[var_6] * var_2[var_7][var_6]\n var_12 = var_12 + var_9[var_7][var_1]\n\n var_13 = max(var_12, var_13)\nprint(var_13)\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\n\nvar_8 = sys.stdin.readline\n\n\ndef func_1():\n var_2 = int(eval(var_8()))\n var_1 = [int(var_8().replace(\" \", \"\"), 2) for _ in range(var_2)]\n var_3 = [list(map(int, var_8().split())) for _ in range(var_2)]\n var_4 = -(10**7) * var_2\n for var_7 in range(1, 1 << 10):\n var_10 = 0\n for var_9, var_6 in enumerate(var_1):\n var_5 = bin(var_7 & var_6).count(\"1\")\n var_10 += var_3[var_9][var_5]\n var_4 = max(var_4, var_10)\n print(var_4)\n\n\nif __name__ == \"__main__\":\n func_1()\n```", "output": "FASTER 3.1351", "pair_id": "python_p03503_pair0042_forward", "problem_id": "p03503", "language": "python", "direction": "forward", "speedup_ratio": 8.7856} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\n\nvar_7 = sys.stdin.readline\nfrom itertools import combinations\n\n\ndef func_3(var_10):\n for _ in range(var_10):\n yield list(map(int, var_7().split()))\n\n\ndef func_1(var_9, var_5, var_11):\n var_3 = len([0 for var_8 in var_9 if var_5[var_8] == 1])\n return var_11[var_3]\n\n\ndef func_2():\n var_10 = int(eval(var_7()))\n var_1 = list(func_3(var_10))\n var_2 = list(func_3(var_10))\n for var_6 in range(1, 11):\n for var_4 in combinations(list(range(10)), var_6):\n yield sum(\n func_1(var_4, var_5, var_11) for var_5, var_11 in zip(var_1, var_2)\n )\n\n\nprint((max(func_2())))\n```\n\n=== Code B (Modified) ===\n```python\nfrom sys import stdin\n\n\ndef func_1():\n\n var_11 = stdin.readline\n var_2 = int(var_11())\n var_1 = []\n for var_6 in range(var_2):\n var_5 = int(\"\".join(var_11().strip().split(\" \")), 2)\n var_1.append(var_5)\n var_3 = []\n for var_6 in range(var_2):\n var_10 = list(map(int, var_11().split()))\n var_3.append(var_10)\n var_8 = float(\"-inf\")\n for var_9 in range(1, 1 << 10):\n var_12 = 0\n for var_7 in range(var_2):\n var_4 = bin(var_9 & var_1[var_7]).count(\"1\")\n var_12 += var_3[var_7][var_4]\n var_8 = max(var_12, var_8)\n print(var_8)\n\n\nif __name__ == \"__main__\":\n func_1()\n```", "output": "FASTER 1.2554", "pair_id": "python_p03503_pair0036_forward", "problem_id": "p03503", "language": "python", "direction": "forward", "speedup_ratio": 2.3874} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nfrom sys import stdin\n\nvar_6 = lambda: list(map(int, stdin.readline().split()))\nvar_5 = lambda: list(map(int, stdin.readline().split()))\nvar_1, var_3 = var_6()\nvar_2 = 0\nfor var_4 in range(var_1, var_3 + 1):\n var_7 = str(var_4)\n if var_7 == var_7[::-1]:\n var_2 += 1\nprint(var_2)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_3 = list(map(int, input().split()))\nvar_2 = 0\nfor var_5 in range(var_3 + 1)[var_1:]:\n if len(str(var_5)) % 2 == 0:\n var_6 = list(str(var_5))[: len(str(var_5)) // 2]\n var_7 = list(reversed(list(str(var_5))[len(str(var_5)) // 2 :]))\n if var_6 == var_7:\n var_2 += 1\n else:\n var_8 = list(str(var_5))[: len(str(var_5)) // 2 + 1]\n var_4 = list(reversed(list(str(var_5))[len(str(var_5)) // 2 :]))\n if var_8 == var_4:\n var_2 += 1\nprint(var_2)\n```", "output": "SLOWER 2.4561", "pair_id": "python_p03416_pair0168_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 5.4874} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\nfrom operator import itemgetter\nfrom heapq import heapify, heappop, heappush\n\nvar_1 = int(10e15)\nvar_2 = -var_1\nvar_11 = 1000000007\nsys.setrecursionlimit(1000000)\n\n\ndef func_2():\n return list(map(int, input().split()))\n\n\ndef func_4():\n return input().split()\n\n\ndef func_1():\n return int(sys.stdin.readline())\n\n\ndef func_3():\n return eval(input())\n\n\nvar_3, var_4 = func_2()\nvar_5 = [func_2() for var_9 in range(var_3)]\nvar_5.sort(key=itemgetter(0))\n\nvar_8 = [[0] * (var_4 + 1 + 3000 + 1) for _ in range(var_3 + 1)]\nvar_6 = 0\nfor var_9 in range(var_3):\n for var_10 in range(var_4 + 1 + 3000 + 1):\n var_12, var_7 = var_5[var_9]\n if 0 <= var_10 - var_12 < var_4:\n var_8[var_9 + 1][var_10] = max(\n var_8[var_9][var_10], var_8[var_9][var_10 - var_12] + var_7\n )\n else:\n var_8[var_9 + 1][var_10] = var_8[var_9][var_10]\n var_6 = max(var_6, var_8[var_9 + 1][var_10])\nprint(var_6)\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\n\nvar_10 = sys.stdin.readline\nvar_2, var_3 = list(map(int, var_10().split()))\nvar_1 = [list(map(int, var_10().split())) for _ in range(var_2)]\nvar_8 = [[0 for _ in range(var_2 + 1)] for _ in range(var_3 + 1)]\n\nvar_13 = [[0 for _ in range(var_2 + 1)] for _ in range(var_3 + 1)]\nfor var_11 in range(var_2):\n var_4, var_6 = var_1[var_11]\n for var_15 in range(var_3):\n if var_4 > var_15:\n var_8[var_15][var_11 + 1] = var_8[var_15][var_11]\n var_13[var_15][var_11 + 1] = var_15\n else:\n if var_6 + var_8[var_15 - var_4][var_11] >= var_8[var_15][var_11]:\n var_8[var_15][var_11 + 1] = var_8[var_15 - var_4][var_11] + var_6\n var_13[var_15][var_11 + 1] = var_15 - var_4\n else:\n var_8[var_15][var_11 + 1] = var_8[var_15][var_11]\n var_13[var_15][var_11 + 1] = var_15\nvar_5 = var_8[var_3 - 1][var_2]\nvar_14 = [False] * var_2\nvar_7 = var_3 - 1\nfor var_9 in reversed(list(range(var_2))):\n if var_13[var_7][var_9 + 1] == var_7 - var_1[var_9][0]:\n var_14[var_9] = True\n var_7 = var_13[var_7][var_9 + 1]\nvar_12 = 0\nfor var_9 in range(var_2):\n if not var_14[var_9] and var_1[var_9][1] > var_12:\n var_12 = var_1[var_9][1]\nprint((var_5 + var_12))\n```", "output": "FASTER 4.3309", "pair_id": "python_p02863_pair0062_forward", "problem_id": "p02863", "language": "python", "direction": "forward", "speedup_ratio": 20.1241} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nfrom collections import Counter, defaultdict, deque\nfrom heapq import heappop, heappush, heapify\nimport sys, bisect, math, itertools, fractions, pprint\n\nsys.setrecursionlimit(10**8)\nvar_6 = 10**9 + 7\nvar_1 = float(\"inf\")\n\n\ndef func_1():\n return int(sys.stdin.readline())\n\n\ndef func_2():\n return list(map(int, sys.stdin.readline().split()))\n\n\nvar_8, var_11 = func_2()\nvar_17 = [func_2() for _ in range(var_8)]\nvar_10 = var_17[::-1]\nvar_14 = [[0] * var_11 for _ in range(var_8)]\nvar_3 = [[0] * var_11 for _ in range(var_8)]\nfor var_4 in range(var_8 - 1):\n var_16, var_15 = var_17[var_4]\n for var_5 in range(var_11):\n if var_5 < var_16:\n var_14[var_4 + 1][var_5] = var_14[var_4][var_5]\n else:\n var_14[var_4 + 1][var_5] = max(\n var_14[var_4][var_5], var_14[var_4][var_5 - var_16] + var_15\n )\nvar_9 = var_14[var_8 - 1][var_11 - 1] + var_17[var_8 - 1][1]\nfor var_4 in range(var_8 - 1):\n var_16, var_15 = var_10[var_4]\n for var_5 in range(var_11):\n if var_5 < var_16:\n var_3[var_4 + 1][var_5] = var_3[var_4][var_5]\n else:\n var_3[var_4 + 1][var_5] = max(\n var_3[var_4][var_5], var_3[var_4][var_5 - var_16] + var_15\n )\n var_9 = max(var_9, var_3[var_8 - 1][var_11 - 1] + var_17[0][1])\n\nfor var_4 in range(1, var_8 - 1):\n var_13 = var_4\n var_2 = var_8 - var_4 - 1\n var_7 = 0\n for var_5 in range(var_11):\n var_12 = var_14[var_13][var_5] + var_3[var_2][var_11 - 1 - var_5]\n var_7 = max(var_7, var_12)\n var_9 = max(var_9, var_7 + var_17[var_4][1])\nprint(var_9)\n```\n\n=== Code B (Modified) ===\n```python\nvar_6, var_7 = list(map(int, input().split()))\nvar_1 = [list(map(int, input().split())) for _ in range(var_6)]\nvar_1.sort()\nvar_3 = [(6007) * [0] for _ in range(var_6 + 1)]\nvar_3[0][0] = 0\nvar_2 = 0\nfor var_4 in range(var_6):\n for var_5 in range(6007):\n var_3[var_4 + 1][var_5] = max(var_3[var_4 + 1][var_5], var_3[var_4][var_5])\n if var_5 < var_7:\n var_3[var_4 + 1][var_5 + var_1[var_4][0]] = max(\n var_3[var_4][var_5] + var_1[var_4][1],\n var_3[var_4][var_5 + var_1[var_4][0]],\n )\n var_2 = max(var_2, var_3[var_4 + 1][var_5])\nprint(var_2)\n```", "output": "SLOWER 4.7197", "pair_id": "python_p02863_pair0051_reversed", "problem_id": "p02863", "language": "python", "direction": "reversed", "speedup_ratio": 26.3491} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().rstrip().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = list(map(int, list(str(var_4))))\n if var_5[0] == var_5[4] and var_5[1] == var_5[3]:\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = [\n var_3 for var_3 in map(str, list(range(var_1, var_2 + 1))) if var_3 == var_3[::-1]\n]\nprint((len(var_4)))\n```", "output": "FASTER 2.3816", "pair_id": "python_p03416_pair0226_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 5.2111} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\ndef func_1():\n var_2 = int(eval(input()))\n var_1 = [int(var_6) for var_6 in input().split()]\n var_4 = 3**var_2\n var_5 = len([var_3 for var_3 in var_1 if var_3 % 2 == 0])\n var_4 -= 2**var_5\n print(var_4)\n\n\nif __name__ == \"__main__\":\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nfrom functools import reduce\nfrom itertools import product\n\nvar_2 = int(eval(input()))\n(*var_1,) = list(map(int, input().split()))\nvar_4 = 0\nfor var_7 in product([-1, 0, 1], repeat=var_2):\n var_6 = reduce(\n lambda var_8, var_9: var_8 * var_9,\n [var_3 + var_7[var_5] for var_5, var_3 in enumerate(var_1)],\n )\n if var_6 % 2 == 0:\n var_4 += 1\nprint(var_4)\n```", "output": "SLOWER 9.2492", "pair_id": "python_p03568_pair0038_reversed", "problem_id": "p03568", "language": "python", "direction": "reversed", "speedup_ratio": 608.5427} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_5 in range(10):\n for var_6 in range(10):\n for var_7 in range(10):\n var_3 = 10000 * var_5 + 1000 * var_6 + 100 * var_7 + 10 * var_6 + var_5\n if var_1 <= var_3 <= var_2:\n var_4 += 1\nprint(var_4)\n```\n\n=== Code B (Modified) ===\n```python\ndef func_1():\n var_1, var_2 = list(map(int, input().split()))\n var_3 = 0\n for var_4 in range(var_1, var_2 + 1):\n\n if (var_4 % 10) == (var_4 // 10000 % 10) and (var_4 // 10 % 10) == (\n var_4 // 1000 % 10\n ):\n var_3 += 1\n print(var_3)\n\n\nif __name__ == \"__main__\":\n func_1()\n```", "output": "SLOWER 2.1615", "pair_id": "python_p03416_pair0077_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 4.4738} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\nimport math\nfrom collections import defaultdict\nfrom bisect import bisect_left, bisect_right\n\nsys.setrecursionlimit(10**7)\n\n\ndef func_4():\n return sys.stdin.readline()[:-1]\n\n\nvar_4 = 10**9 + 7\n\n\ndef func_1():\n return int(eval(func_4()))\n\n\ndef func_2():\n return list(map(int, func_4().split()))\n\n\ndef func_3(var_6, var_3):\n if var_6 <= 0:\n return [[] for _ in range(var_3)]\n elif var_3 == 1:\n return [func_1() for _ in range(var_6)]\n else:\n var_5 = [func_2() for _ in range(var_6)]\n return list(map(list, list(zip(*var_5))))\n\n\nfrom decimal import getcontext, Decimal\n\ngetcontext().prec = 28\nvar_1, var_2 = list(map(str, func_4().split()))\nvar_1 = int(var_1)\nvar_2 = Decimal(var_2)\nprint((int(var_1 * var_2)))\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(str, input().split()))\nvar_1 = int(var_1)\nvar_2 = int(float(var_2) * 1000)\nprint((var_1 * var_2 // 1000))\n```", "output": "FASTER 2.3054", "pair_id": "python_p02659_pair0059_forward", "problem_id": "p02659", "language": "python", "direction": "forward", "speedup_ratio": 4.9432} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2, var_3 = list(map(int, input().split()))\nvar_4 = list(map(int, input().split()))\nvar_6 = list(map(int, input().split()))\nvar_5 = min(var_4) + min(var_6)\nfor var_8 in range(var_3):\n var_7 = list(map(int, input().split()))\n var_9 = var_4[var_7[0] - 1] + var_6[var_7[1] - 1] - var_7[2]\n var_5 = min(var_9, var_5)\nprint(var_5)\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\nfrom collections import Counter\n\n\ndef func_9():\n return sys.stdin.readline().strip()\n\n\ndef func_10(var_8, var_9, var_10):\n return [[var_10] * var_9 for var_13 in range(var_8)]\n\n\ndef func_11(var_8, var_9, var_10, var_11):\n return [[[var_11] * var_10 for var_14 in range(var_9)] for var_13 in range(var_8)]\n\n\ndef func_12(var_8, var_9, var_10, var_11, var_12):\n return [\n [[[var_12] * var_11 for var_14 in range(var_10)] for var_14 in range(var_9)]\n for var_13 in range(var_8)\n ]\n\n\ndef func_8(var_16, var_17=1):\n return int(-(-var_16 // var_17))\n\n\ndef func_1():\n return int(eval(func_9()))\n\n\ndef func_3():\n return list(map(int, func_9().split()))\n\n\ndef func_2(var_7=None):\n return list(func_3()) if var_7 is None else [func_1() for var_13 in range(var_7)]\n\n\ndef func_7():\n print(\"Yes\")\n\n\ndef func_5():\n print(\"No\")\n\n\ndef func_6():\n print(\"YES\")\n\n\ndef func_4():\n print(\"NO\")\n\n\nsys.setrecursionlimit(10**9)\nvar_3 = 10**18\nvar_6 = 10**9 + 7\nvar_7, var_5, var_4 = func_3()\nvar_1 = func_2()\nvar_2 = func_2()\nvar_15 = min(var_1) + min(var_2)\nfor _ in range(var_4):\n var_16, var_17, var_10 = func_3()\n var_16 -= 1\n var_17 -= 1\n var_15 = min(var_15, var_1[var_16] + var_2[var_17] - var_10)\nprint(var_15)\n```", "output": "SLOWER 1.7949", "pair_id": "python_p02748_pair0013_reversed", "problem_id": "p02748", "language": "python", "direction": "reversed", "speedup_ratio": 3.47} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_7 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_3 = True\n var_8 = str(var_4)\n var_6 = len(var_8)\n for var_5 in range(var_6 // 2 + 1):\n if var_8[var_5] != var_8[-var_5 - 1]:\n var_3 = False\n break\n if var_3:\n var_7 += 1\nprint(var_7)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_5 in range(10):\n for var_6 in range(10):\n for var_7 in range(10):\n var_3 = 10000 * var_5 + 1000 * var_6 + 100 * var_7 + 10 * var_6 + var_5\n if var_1 <= var_3 <= var_2:\n var_4 += 1\nprint(var_4)\n```", "output": "FASTER 4.9507", "pair_id": "python_p03416_pair0227_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 30.924} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\n\nvar_3 = sys.stdin.readline\nvar_1, var_2 = var_3().split()\nvar_1 = int(var_1)\nvar_2 = int(float(var_2) * 100 + 0.5)\nprint((var_1 * var_2 // 100))\n```\n\n=== Code B (Modified) ===\n```python\ndef func_1():\n from sys import setrecursionlimit, stdin\n from os import environ\n from collections import defaultdict, deque, Counter\n from math import ceil, floor, gcd\n from itertools import accumulate, combinations, combinations_with_replacement\n\n setrecursionlimit(10**6)\n var_7 = (\n (lambda *var_11: print(*var_11))\n if \"TERM_PROGRAM\" in environ\n else lambda *var_12: 0\n )\n var_8 = lambda: stdin.readline().rstrip()\n var_3 = lambda: list(map(int, var_8().split()))\n var_1 = lambda: int(var_8())\n var_4 = 10**9 + 7\n var_2 = 10**9 + 10\n var_9, var_10 = var_8().split()\n var_5 = int(var_9)\n var_10 = var_10.split(\".\")\n var_6 = int(var_10[0]) * 100\n if len(var_10) == 2:\n var_6 += int(var_10[1])\n print(var_5 * var_6 // 100)\n\n\nfunc_1()\n```", "output": "SLOWER 2.1571", "pair_id": "python_p02659_pair0011_reversed", "problem_id": "p02659", "language": "python", "direction": "reversed", "speedup_ratio": 4.4601} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_2 = int(eval(input()))\nvar_1 = list(map(int, input().split()))\nvar_4 = 1\nfor var_3 in range(var_2):\n if var_1[var_3] % 2 == 0:\n var_4 *= 2\nprint((3**var_2 - var_4))\n```\n\n=== Code B (Modified) ===\n```python\nvar_6 = int(eval(input()))\nvar_2 = list(map(int, input().split()))\nfrom itertools import product\n\nvar_5 = [-1, 0, 1]\nvar_3 = 0\nfor var_7 in product(var_5, repeat=var_6):\n var_1 = []\n for var_4 in range(var_6):\n var_1.append(var_7[var_4] + var_2[var_4])\n if any(var_8 % 2 == 0 for var_8 in var_1):\n var_3 += 1\nprint(var_3)\n```", "output": "SLOWER 9.8508", "pair_id": "python_p03568_pair0008_reversed", "problem_id": "p03568", "language": "python", "direction": "reversed", "speedup_ratio": 923.3817} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\nimport math\nfrom collections import defaultdict\nfrom bisect import bisect_left, bisect_right\n\nsys.setrecursionlimit(10**7)\n\n\ndef func_4():\n return sys.stdin.readline()[:-1]\n\n\nvar_4 = 10**9 + 7\n\n\ndef func_1():\n return int(eval(func_4()))\n\n\ndef func_2():\n return list(map(int, func_4().split()))\n\n\ndef func_3(var_6, var_3):\n if var_6 <= 0:\n return [[] for _ in range(var_3)]\n elif var_3 == 1:\n return [func_1() for _ in range(var_6)]\n else:\n var_5 = [func_2() for _ in range(var_6)]\n return list(map(list, list(zip(*var_5))))\n\n\nfrom decimal import getcontext, Decimal\n\ngetcontext().prec = 28\nvar_1, var_2 = list(map(str, func_4().split()))\nvar_1 = int(var_1)\nvar_2 = Decimal(var_2)\nprint((int(var_1 * var_2)))\n```\n\n=== Code B (Modified) ===\n```python\ndef func_1():\n var_1, var_3 = input().split()\n var_1 = int(var_1)\n var_3 = int(float(var_3) * 100 + 0.5)\n var_2 = var_1 * var_3\n print((var_2 // 100))\n\n\nif __name__ == \"__main__\":\n func_1()\n```", "output": "FASTER 1.8519", "pair_id": "python_p02659_pair0012_forward", "problem_id": "p02659", "language": "python", "direction": "forward", "speedup_ratio": 3.6097} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\ndef func_1():\n from sys import setrecursionlimit, stdin\n from os import environ\n from collections import defaultdict, deque, Counter\n from math import ceil, floor, gcd\n from itertools import accumulate, combinations, combinations_with_replacement\n\n setrecursionlimit(10**6)\n var_7 = (\n (lambda *var_11: print(*var_11))\n if \"TERM_PROGRAM\" in environ\n else lambda *var_12: 0\n )\n var_8 = lambda: stdin.readline().rstrip()\n var_3 = lambda: list(map(int, var_8().split()))\n var_1 = lambda: int(var_8())\n var_4 = 10**9 + 7\n var_2 = 10**9 + 10\n var_9, var_10 = var_8().split()\n var_5 = int(var_9)\n var_10 = var_10.split(\".\")\n var_6 = int(var_10[0]) * 100\n if len(var_10) == 2:\n var_6 += int(var_10[1])\n print(var_5 * var_6 // 100)\n\n\nfunc_1()\n```\n\n=== Code B (Modified) ===\n```python\nfrom fractions import Fraction\n\nvar_1, var_2 = input().split()\n\n\nfrom decimal import *\n\nvar_4 = var_3(var_1)\nvar_6 = var_3(var_2)\nvar_7().prec = 28\nvar_5 = var_4 * var_6\nprint((int(var_5)))\n```", "output": "FASTER 1.768", "pair_id": "python_p02659_pair0049_forward", "problem_id": "p02659", "language": "python", "direction": "forward", "speedup_ratio": 3.4057} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_4 = 19\nvar_7 = [0] * (2 ** (var_4 + 1) - 1)\n\n\ndef func_1(var_12, var_17):\n var_11 = 2**var_4 + var_12 - 1\n while var_11 >= 0:\n var_7[var_11] += var_17\n var_11 = (var_11 - 1) // 2\n\n\ndef func_2(var_8, var_9):\n var_13 = var_8 + (1 << var_4)\n var_15 = var_9 + (1 << var_4)\n var_16 = 0\n while var_13 < var_15:\n if var_13 % 2:\n var_16 += var_7[var_13 - 1]\n var_13 += 1\n if var_15 % 2:\n var_15 -= 1\n var_16 += var_7[var_15 - 1]\n var_13 >>= 1\n var_15 >>= 1\n return var_16\n\n\nvar_3, var_5 = map(int, input().split())\nvar_2 = [int(var_8) - 1 for var_8 in input().split()]\nvar_6 = [[] for _ in range(var_3)]\nfor var_11 in range(var_5):\n var_13, var_15 = map(int, input().split())\n var_6[var_15 - 1].append((var_13 - 1, var_11))\nvar_14 = [-1] * var_3\nvar_1 = [-1] * var_5\nfunc_1(1, var_3)\nfor var_15 in range(var_3):\n var_10 = var_2[var_15]\n func_1(var_14[var_10] + 2, -1)\n func_1(var_15 + 2, 1)\n var_14[var_10] = var_15\n for var_13, var_11 in var_6[var_15]:\n var_1[var_11] = func_2(var_13 + 2, 1 << var_4)\nprint(*var_1, sep=\"\\n\")\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\n\nvar_20 = sys.stdin.read\nvar_21 = sys.stdin.readline\nvar_22 = sys.stdin.readlines\nsys.setrecursionlimit(10**9)\nvar_2 = 1 << 60\nvar_5 = 1000000007\n\n\nvar_4 = 1000001\n\n\nclass Class_1:\n def __init__(self, var_13, var_19, var_12):\n self.l = var_13\n self.r = var_19\n self.idx = var_12\n\n\ndef func_4(var_12, var_24, var_10, var_15):\n while var_12 <= var_15:\n var_10[var_12] += var_24\n var_12 += var_12 & -var_12\n\n\ndef func_3(var_12, var_10, var_15):\n var_23 = 0\n while var_12:\n var_23 += var_10[var_12]\n var_12 -= var_12 & -var_12\n return var_23\n\n\ndef func_1(var_9, var_15, var_17, var_16):\n\n var_10 = [0] * (var_15 + 1)\n\n var_14 = [-1] * var_4\n\n var_8 = [0] * var_16\n var_18 = 0\n for var_11 in range(var_15):\n\n if var_14[var_9[var_11]] != -1:\n func_4(var_14[var_9[var_11]] + 1, -1, var_10, var_15)\n\n var_14[var_9[var_11]] = var_11\n func_4(var_11 + 1, 1, var_10, var_15)\n\n while var_18 < var_16 and var_17[var_18].r == var_11:\n var_8[var_17[var_18].idx] = func_3(\n var_17[var_18].r + 1, var_10, var_15\n ) - func_3(var_17[var_18].l, var_10, var_15)\n var_18 += 1\n\n for var_11 in range(var_16):\n print((var_8[var_11]))\n\n\ndef func_2():\n var_6, var_7 = list(map(int, var_21().split()))\n var_1 = list(map(int, var_21().split()))\n (*var_3,) = list(map(int, var_20().split()))\n var_17 = [0] * var_7\n for var_11, (var_13, var_19) in enumerate(zip(*[iter(var_3)] * 2)):\n var_17[var_11] = Class_1(var_13 - 1, var_19 - 1, var_11)\n var_17.sort(key=lambda var_25: var_25.r)\n func_1(var_1, var_6, var_17, var_7)\n return\n\n\nif __name__ == \"__main__\":\n func_2()\n```", "output": "SLOWER 1.8145", "pair_id": "python_p02599_pair0006_reversed", "problem_id": "p02599", "language": "python", "direction": "reversed", "speedup_ratio": 3.5173} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport copy\n\nvar_8 = int(eval(input()))\nvar_10 = set([var_6 for var_6 in range(1, 10**5)])\nvar_5 = []\nvar_11 = {}\nvar_9 = []\nfor var_6 in range(var_8 - 1):\n var_1, var_2 = list(map(int, input().split(\" \")))\n var_5.append([var_1, var_2])\n var_11.setdefault(var_1, []).append(var_2)\n var_9.append([])\nvar_9.append([])\nvar_9.append([])\nvar_7 = 0\nfor var_12 in range(1, var_8 + 1):\n var_14 = var_11.get(var_12, [])\n var_3 = 1\n for var_13 in var_14:\n if var_3 in var_9[var_12]:\n var_3 += 1\n else:\n pass\n var_9[var_13].append(var_3)\n if var_3 >= var_7:\n var_7 = var_3\n var_3 += 1\nprint(var_7)\nfor var_4 in var_5:\n print((var_9[var_4[1]][0]))\n```\n\n=== Code B (Modified) ===\n```python\nfrom collections import deque\n\nvar_4, *var_2 = list(map(int, open(0).read().split()))\nvar_3 = [set() for _ in range(var_4 + 1)]\nfor var_9, (var_6, var_7) in enumerate(zip(*[iter(var_2)] * 2)):\n var_3[var_6].add((var_7, var_9))\n var_3[var_7].add((var_6, var_9))\nvar_1 = [0] * (var_4 - 1)\nvar_5 = deque([(0, 1)])\nwhile var_5:\n var_10, var_12 = var_5.popleft()\n var_8 = 0\n for var_11, var_9 in var_3[var_12]:\n var_3[var_11].remove((var_12, var_9))\n var_8 += 1 + (var_8 + 1 == var_10)\n var_5.append((var_8, var_11))\n var_1[var_9] = var_8\nprint((max(var_1), *var_1))\n```", "output": "FASTER 4.5634", "pair_id": "python_p02850_pair0031_forward", "problem_id": "p02850", "language": "python", "direction": "forward", "speedup_ratio": 23.6433} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\n\n\ndef func_1(var_5, var_6):\n var_4 = 0\n for var_3 in range(var_5, var_6 + 1):\n if str(var_3) == str(var_3)[::-1]:\n var_4 += 1\n return var_4\n\n\nprint((func_1(var_1, var_2)))\n```\n\n=== Code B (Modified) ===\n```python\ndef func_1():\n var_1, var_2 = list(map(int, input().split()))\n var_3 = 0\n for var_4 in range(var_1, var_2 + 1):\n\n if (var_4 % 10) == (var_4 // 10000 % 10) and (var_4 // 10 % 10) == (\n var_4 // 1000 % 10\n ):\n var_3 += 1\n print(var_3)\n\n\nif __name__ == \"__main__\":\n func_1()\n```", "output": "FASTER 1.3404", "pair_id": "python_p03416_pair0005_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 2.5323} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\n\nvar_7 = sys.stdin.readline\nfrom itertools import combinations\n\n\ndef func_3(var_10):\n for _ in range(var_10):\n yield list(map(int, var_7().split()))\n\n\ndef func_1(var_9, var_5, var_11):\n var_3 = len([0 for var_8 in var_9 if var_5[var_8] == 1])\n return var_11[var_3]\n\n\ndef func_2():\n var_10 = int(eval(var_7()))\n var_1 = list(func_3(var_10))\n var_2 = list(func_3(var_10))\n for var_6 in range(1, 11):\n for var_4 in combinations(list(range(10)), var_6):\n yield sum(\n func_1(var_4, var_5, var_11) for var_5, var_11 in zip(var_1, var_2)\n )\n\n\nprint((max(func_2())))\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\nimport numpy as np\n\nvar_5 = sys.stdin.readline\n\nvar_7 = int(eval(var_5()))\n\nvar_1 = [var_5().replace(\" \", \"\") for var_4 in range(var_7)]\n\nvar_8 = [list(map(int, var_5().split())) for var_4 in range(var_7)]\n\n\nvar_12 = -999999999999999\n\nfor var_4 in range(1, 1024):\n\n var_3 = format(var_4, \"010b\")\n\n var_10 = 0\n for var_2, var_9 in zip(var_1, var_8):\n\n var_11 = 0\n for var_6 in range(10):\n\n if var_2[var_6] == \"1\" and var_3[var_6] == \"1\":\n\n var_11 += 1\n\n var_10 += var_9[var_11]\n if var_10 > var_12:\n\n var_12 = var_10\nprint(var_12)\n```", "output": "SLOWER 1.6251", "pair_id": "python_p03503_pair0031_reversed", "problem_id": "p03503", "language": "python", "direction": "reversed", "speedup_ratio": 3.0846} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_4 = str(var_4)\n if var_4 == var_4[::-1]:\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_3 in range(var_1, var_2 + 1):\n var_5 = list(str(var_3))\n var_6 = list(reversed(var_5))\n if var_5 == var_6:\n var_4 += 1\nprint(var_4)\n```", "output": "SLOWER 1.1616", "pair_id": "python_p03416_pair0128_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 2.2371} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = str(var_4)\n if var_5 == var_5[::-1]:\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = list(reversed(list(str(var_4))))\n if var_5 == list(str(var_4)):\n var_3 += 1\nprint(var_3)\n```", "output": "SLOWER 1.6614", "pair_id": "python_p03416_pair0228_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 3.1633} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nfrom sys import stdin\n\n\ndef func_1():\n\n var_13 = stdin.readline\n var_2 = int(var_13())\n var_1 = []\n for var_6 in range(var_2):\n var_5 = list(map(int, var_13().split()))\n var_1.append(var_5)\n var_3 = []\n for var_6 in range(var_2):\n var_12 = list(map(int, var_13().split()))\n var_3.append(var_12)\n var_9 = -float(\"inf\")\n for var_6 in range(1 << 10):\n if var_6 == 0:\n continue\n else:\n var_11 = []\n for var_7 in range(10):\n if (var_6 >> var_7) & 1:\n var_11.append(var_7)\n var_10 = [0] * 10\n for var_7 in var_11:\n var_10[var_7] = 1\n var_14 = 0\n for var_7 in range(var_2):\n var_4 = 0\n for var_8 in range(10):\n if var_10[var_8] == 1 and var_1[var_7][var_8] == 1:\n var_4 += 1\n var_14 += var_3[var_7][var_4]\n var_9 = max(var_14, var_9)\n print(var_9)\n\n\nif __name__ == \"__main__\":\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\nimport itertools\n\n\ndef func_2(var_4):\n return bin(eval(\"0b\" + str(var_4)))\n\n\ndef func_1():\n var_4 = int(sys.stdin.readline().rstrip())\n var_9 = [\n func_2(\"\".join(str(var_10) for var_10 in sys.stdin.readline().split()))\n for _ in range(var_4)\n ]\n var_8 = [\n [int(var_10) for var_10 in sys.stdin.readline().split()] for _ in range(var_4)\n ]\n var_3 = -(10**10)\n for var_6 in itertools.product(\"01\", repeat=10):\n var_6 = func_2(\"\".join(var_6))\n if var_6 == \"0b0\":\n continue\n var_7 = 0\n for var_2 in range(var_4):\n var_1 = var_9[var_2]\n var_5 = bin(eval(var_1) & eval(var_6)).count(\"1\")\n var_7 += var_8[var_2][var_5]\n var_3 = max(var_3, var_7)\n print(var_3)\n\n\nif __name__ == \"__main__\":\n\n func_1()\n```", "output": "SLOWER 3.3644", "pair_id": "python_p03503_pair0038_reversed", "problem_id": "p03503", "language": "python", "direction": "reversed", "speedup_ratio": 10.2989} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport itertools\n\nvar_6 = int(eval(input()))\nvar_2 = [[]] * var_6\nfor var_4 in range(var_6):\n var_3 = list(map(int, input().split()))\n\n var_2[var_4] = var_3\nvar_8 = [[]] * var_6\nfor var_4 in range(var_6):\n var_9 = list(map(int, input().split()))\n var_8[var_4] = var_9\nvar_10 = -(10**11)\nfor var_1 in itertools.product([0, 1], repeat=10):\n if sum(var_1) == 0:\n continue\n var_11 = 0\n for var_7 in range(var_6):\n var_5 = 0\n for var_4 in range(10):\n if var_2[var_7][var_4] == 1 and var_1[var_4] == 1:\n var_5 += 1\n var_11 = var_11 + var_8[var_7][var_5]\n var_10 = max(var_10, var_11)\nprint(var_10)\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\n\nvar_7 = sys.stdin.readline\nfrom itertools import combinations\n\n\ndef func_3(var_10):\n for _ in range(var_10):\n yield list(map(int, var_7().split()))\n\n\ndef func_1(var_9, var_5, var_11):\n var_3 = len([0 for var_8 in var_9 if var_5[var_8] == 1])\n return var_11[var_3]\n\n\ndef func_2():\n var_10 = int(eval(var_7()))\n var_1 = list(func_3(var_10))\n var_2 = list(func_3(var_10))\n for var_6 in range(1, 11):\n for var_4 in combinations(list(range(10)), var_6):\n yield sum(\n func_1(var_4, var_5, var_11) for var_5, var_11 in zip(var_1, var_2)\n )\n\n\nprint((max(func_2())))\n```", "output": "FASTER 1.5941", "pair_id": "python_p03503_pair0002_forward", "problem_id": "p03503", "language": "python", "direction": "forward", "speedup_ratio": 3.019} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_4 = int(eval(input()))\nvar_2 = list(map(int, input().split()))\n\n\ndef func_1(var_1, var_8, var_3):\n if var_8 == var_4:\n var_9 = 1\n for var_5 in var_3:\n var_9 *= var_5\n return 1 if var_9 % 2 == 0 else 0\n var_6 = var_3.copy()\n var_6.append(var_1[var_8] - 1)\n var_5 = var_3.copy()\n var_5.append(var_1[var_8])\n var_7 = var_3.copy()\n var_7.append(var_1[var_8] + 1)\n return (\n func_1(var_1, var_8 + 1, var_6)\n + func_1(var_1, var_8 + 1, var_5)\n + func_1(var_1, var_8 + 1, var_7)\n )\n\n\nprint((func_1(var_2, 0, [])))\n```\n\n=== Code B (Modified) ===\n```python\nfrom functools import reduce\nfrom itertools import product\n\nvar_2 = int(eval(input()))\n(*var_1,) = list(map(int, input().split()))\nvar_4 = 0\nfor var_7 in product([-1, 0, 1], repeat=var_2):\n var_6 = reduce(\n lambda var_8, var_9: var_8 * var_9,\n [var_3 + var_7[var_5] for var_5, var_3 in enumerate(var_1)],\n )\n if var_6 % 2 == 0:\n var_4 += 1\nprint(var_4)\n```", "output": "SLOWER 1.4753", "pair_id": "python_p03568_pair0014_reversed", "problem_id": "p03568", "language": "python", "direction": "reversed", "speedup_ratio": 2.7805} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nfor var_3 in range(1, 1009):\n if int(var_3 * 0.08) == var_1 and int(var_3 * 0.1) == var_2:\n print((int(var_3)))\n exit()\nprint(\"-1\")\n```\n\n=== Code B (Modified) ===\n```python\nimport math\n\nvar_1, var_4 = (int(var_10) for var_10 in input().split())\nvar_2 = math.ceil(var_1 / 0.08)\nvar_3 = math.ceil((var_1 + 1) / 0.08)\n\"\"\"\"\"\"\nvar_5 = math.ceil(var_4 / 0.1)\nvar_6 = math.ceil((var_4 + 1) / 0.1)\n\"\"\"\"\"\"\nvar_7 = list(range(var_2, var_3))\nvar_8 = list(range(var_5, var_6))\nvar_9 = set(var_7) & set(var_8)\nif len(var_9) == 0:\n print((-1))\nelse:\n print((min(var_9)))\n```", "output": "FASTER 1.1926", "pair_id": "python_p02755_pair0014_forward", "problem_id": "p02755", "language": "python", "direction": "forward", "speedup_ratio": 2.2856} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nfrom collections import deque\n\nvar_4, *var_2 = list(map(int, open(0).read().split()))\nvar_3 = [set() for _ in range(var_4 + 1)]\nfor var_9, (var_6, var_7) in enumerate(zip(*[iter(var_2)] * 2)):\n var_3[var_6].add((var_7, var_9))\n var_3[var_7].add((var_6, var_9))\nvar_1 = [0] * (var_4 - 1)\nvar_5 = deque([(0, 1)])\nwhile var_5:\n var_10, var_12 = var_5.popleft()\n var_8 = 0\n for var_11, var_9 in var_3[var_12]:\n var_3[var_11].remove((var_12, var_9))\n var_8 += 1 + (var_8 + 1 == var_10)\n var_5.append((var_8, var_11))\n var_1[var_9] = var_8\nprint((max(var_1), *var_1))\n```\n\n=== Code B (Modified) ===\n```python\nimport copy\n\nvar_8 = int(eval(input()))\nvar_10 = set([var_6 for var_6 in range(1, 10**5)])\nvar_5 = []\nvar_11 = {}\nvar_9 = []\nfor var_6 in range(var_8 - 1):\n var_1, var_2 = list(map(int, input().split(\" \")))\n var_5.append([var_1, var_2])\n var_11.setdefault(var_1, []).append(var_2)\n var_9.append([])\nvar_9.append([])\nvar_9.append([])\nvar_7 = 0\nfor var_12 in range(1, var_8 + 1):\n var_14 = var_11.get(var_12, [])\n var_3 = 1\n for var_13 in var_14:\n if var_3 in var_9[var_12]:\n var_3 += 1\n else:\n pass\n var_9[var_13].append(var_3)\n if var_3 >= var_7:\n var_7 = var_3\n var_3 += 1\nprint(var_7)\nfor var_4 in var_5:\n print((var_9[var_4[1]][0]))\n```", "output": "SLOWER 4.5634", "pair_id": "python_p02850_pair0031_reversed", "problem_id": "p02850", "language": "python", "direction": "reversed", "speedup_ratio": 23.6433} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = list(reversed(list(str(var_4))))\n if var_5 == list(str(var_4)):\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\ndef func_1():\n var_1, var_2 = list(map(int, input().rstrip().split()))\n var_3 = 0\n for var_4 in range(var_1, var_2 + 1):\n var_5 = str(var_4)\n if var_5 == var_5[::-1]:\n var_3 += 1\n print(var_3)\n\n\nif __name__ == \"__main__\":\n func_1()\n```", "output": "FASTER 2.4029", "pair_id": "python_p03416_pair0160_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 5.2888} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_4 = int(eval(input()))\nvar_2 = list(map(int, input().split()))\n\n\ndef func_1(var_1, var_8, var_3):\n if var_8 == var_4:\n var_9 = 1\n for var_5 in var_3:\n var_9 *= var_5\n return 1 if var_9 % 2 == 0 else 0\n var_6 = var_3.copy()\n var_6.append(var_1[var_8] - 1)\n var_5 = var_3.copy()\n var_5.append(var_1[var_8])\n var_7 = var_3.copy()\n var_7.append(var_1[var_8] + 1)\n return (\n func_1(var_1, var_8 + 1, var_6)\n + func_1(var_1, var_8 + 1, var_5)\n + func_1(var_1, var_8 + 1, var_7)\n )\n\n\nprint((func_1(var_2, 0, [])))\n```\n\n=== Code B (Modified) ===\n```python\nimport numpy as np\nfrom itertools import product\n\nvar_6 = int(eval(input()))\nvar_2 = list(map(int, input().split()))\nvar_2 = np.array(var_2)\nvar_5 = [-1, 0, 1]\nvar_3 = 0\nfor var_7 in product(var_5, repeat=var_6):\n var_7 = np.array(var_7)\n var_1 = var_2 + var_7\n var_4 = var_1.cumprod()\n if var_4[-1] % 2 == 0:\n var_3 += 1\nprint(var_3)\n```", "output": "SLOWER 1.7419", "pair_id": "python_p03568_pair0046_reversed", "problem_id": "p03568", "language": "python", "direction": "reversed", "speedup_ratio": 3.3447} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\n\"\"\"\"\"\"\n\nfrom collections import defaultdict\n\n\ndef func_1(var_10, var_9):\n var_5 = 1\n yield var_5\n for _ in range(1, var_10):\n var_5 = (var_5 * 10) % var_9\n yield var_5\n\n\ndef func_2():\n var_3 = 2019\n var_4 = input()[::-1]\n\n var_1 = [\n int(var_11) * var_10 % var_3\n for var_11, var_10 in zip(var_4, func_1(len(var_4), var_3))\n ]\n\n var_2 = [0]\n for var_5 in var_1:\n var_2.append((var_2[-1] + var_5) % var_3)\n\n var_8 = defaultdict(int)\n for var_6 in var_2:\n var_8[var_6] += 1\n var_7 = sum(var_12 * (var_12 - 1) // 2 for var_12 in list(var_8.values()))\n print(var_7)\n\n\nfunc_2()\n```\n\n=== Code B (Modified) ===\n```python\nvar_6 = 2019\nvar_1 = [0] * var_6\nvar_3 = 1\nvar_5 = var_4 = 0\nfor var_2 in input()[::-1]:\n var_1[var_4] += 1\n var_4 -= int(var_2) * var_3\n var_4 %= var_6\n var_5 += var_1[var_4]\n var_3 *= 10\n var_3 %= var_6\nprint(var_5)\n```", "output": "FASTER 1.5308", "pair_id": "python_p02702_pair0013_forward", "problem_id": "p02702", "language": "python", "direction": "forward", "speedup_ratio": 2.8894} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_6 in range(var_1, var_2 + 1):\n var_3 = str(var_6)\n var_5 = True\n for var_7 in range(len(var_3) // 2):\n if var_3[var_7] != var_3[-var_7 - 1] and var_5:\n var_5 = not var_5\n if var_5:\n var_4 += 1\nprint(var_4)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_3 = list(map(int, input().split()))\nvar_2 = 0\nfor var_5 in range(var_3 + 1)[var_1:]:\n if len(str(var_5)) % 2 == 0:\n var_6 = list(str(var_5))[: len(str(var_5)) // 2]\n var_7 = list(reversed(list(str(var_5))[len(str(var_5)) // 2 :]))\n if var_6 == var_7:\n var_2 += 1\n else:\n var_8 = list(str(var_5))[: len(str(var_5)) // 2 + 1]\n var_4 = list(reversed(list(str(var_5))[len(str(var_5)) // 2 :]))\n if var_8 == var_4:\n var_2 += 1\nprint(var_2)\n```", "output": "SLOWER 1.0146", "pair_id": "python_p03416_pair0115_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 2.0203} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport math\nimport string\n\n\ndef func_4():\n return list(map(int, input().split()))\n\n\ndef func_3(var_6, var_7):\n return math.factorial(var_6) // (\n math.factorial(var_6 - var_7) * math.factorial(var_7)\n )\n\n\ndef func_2(var_9):\n var_8 = []\n for var_5 in var_9:\n if not (var_5 in var_8):\n var_8.append(var_5)\n return len(var_9) != len(var_8)\n\n\ndef func_1(var_6):\n func_1 = []\n for var_4 in range(1, var_6 + 1):\n if var_6 % var_4 == 0:\n func_1.append(var_4)\n return func_1\n\n\nvar_2 = [-1, -1, -1, 0, 0, 1, 1, 1]\nvar_3 = [-1, 0, 1, -1, 1, -1, 0, 1]\nvar_6 = int(eval(input()))\nvar_1 = func_4()\nvar_10 = 1\nfor var_4 in range(len(var_1)):\n if var_1[var_4] % 2 == 0:\n var_10 *= 2\n else:\n var_10 *= 1\nprint((3 ** len(var_1) - var_10))\n```\n\n=== Code B (Modified) ===\n```python\nfrom itertools import product\n\nvar_6 = int(eval(input()))\nvar_1 = list(map(int, input().split()))\nvar_5 = 0\nfor var_2 in product((-1, 0, 1), repeat=var_6):\n var_7 = 1\n for var_3, var_4 in zip(var_1, var_2):\n var_7 *= var_3 + var_4\n if var_7 % 2 == 0:\n var_5 += 1\nprint(var_5)\n```", "output": "SLOWER 8.339", "pair_id": "python_p03568_pair0031_reversed", "problem_id": "p03568", "language": "python", "direction": "reversed", "speedup_ratio": 323.8095} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_3 in range(var_1, var_2 + 1):\n var_5 = list(str(var_3))\n var_6 = list(reversed(var_5))\n if var_5 == var_6:\n var_4 += 1\nprint(var_4)\n```\n\n=== Code B (Modified) ===\n```python\ndef func_1():\n var_1, var_2 = list(map(int, input().rstrip().split()))\n var_3 = 0\n for var_4 in range(var_1, var_2 + 1):\n var_5 = str(var_4)\n if var_5 == var_5[::-1]:\n var_3 += 1\n print(var_3)\n\n\nif __name__ == \"__main__\":\n func_1()\n```", "output": "FASTER 2.0546", "pair_id": "python_p03416_pair0229_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 4.1544} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport math\nimport string\n\n\ndef func_5():\n return list(map(int, input().split()))\n\n\ndef func_4(var_7, var_8):\n return math.factorial(var_7) // (\n math.factorial(var_7 - var_8) * math.factorial(var_8)\n )\n\n\ndef func_3(var_10):\n var_9 = []\n for var_5 in var_10:\n if not (var_5 in var_9):\n var_9.append(var_5)\n return len(var_10) != len(var_9)\n\n\ndef func_1(var_7):\n func_1 = []\n for var_4 in range(1, var_7 + 1):\n if var_7 % var_4 == 0:\n func_1.append(var_4)\n return func_1\n\n\nvar_2 = [-1, -1, -1, 0, 0, 1, 1, 1]\nvar_3 = [-1, 0, 1, -1, 1, -1, 0, 1]\nvar_7 = int(eval(input()))\nvar_1 = func_5()\n\n\ndef func_2(var_6):\n if len(var_6) == var_7:\n for var_4 in range(len(var_6)):\n if var_6[var_4] % 2 == 0:\n return 1\n return 0\n return (\n func_2(var_6 + [var_1[len(var_6)]])\n + func_2(var_6 + [var_1[len(var_6)] - 1])\n + func_2(var_6 + [var_1[len(var_6)] + 1])\n )\n\n\nprint((func_2([])))\n```\n\n=== Code B (Modified) ===\n```python\nvar_2 = int(eval(input()))\n(*var_1,) = list(map(int, input().split()))\nvar_5 = 0\nfor var_3 in var_1:\n if var_3 % 2 == 0:\n var_5 += 1\nvar_4 = 3**var_2 - 2**var_5\nprint(var_4)\n```", "output": "FASTER 7.6454", "pair_id": "python_p03568_pair0037_forward", "problem_id": "p03568", "language": "python", "direction": "forward", "speedup_ratio": 200.2176} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport math\n\nvar_1, var_4 = (int(var_10) for var_10 in input().split())\nvar_2 = math.ceil(var_1 / 0.08)\nvar_3 = math.ceil((var_1 + 1) / 0.08)\n\"\"\"\"\"\"\nvar_5 = math.ceil(var_4 / 0.1)\nvar_6 = math.ceil((var_4 + 1) / 0.1)\n\"\"\"\"\"\"\nvar_7 = list(range(var_2, var_3))\nvar_8 = list(range(var_5, var_6))\nvar_9 = set(var_7) & set(var_8)\nif len(var_9) == 0:\n print((-1))\nelse:\n print((min(var_9)))\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_3 = list(map(int, input().split()))\nvar_2 = -1\nfor var_4 in range(10, 12501):\n if int(var_4 * 0.08) == var_1 and int(var_4 * 0.1) == var_3:\n var_2 = var_4\n break\nprint(var_2)\n```", "output": "SLOWER 4.5892", "pair_id": "python_p02755_pair0011_reversed", "problem_id": "p02755", "language": "python", "direction": "reversed", "speedup_ratio": 24.0708} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nfrom sys import stdin\n\nvar_6 = lambda: list(map(int, stdin.readline().split()))\nvar_5 = lambda: list(map(int, stdin.readline().split()))\nvar_1, var_3 = var_6()\nvar_2 = 0\nfor var_4 in range(var_1, var_3 + 1):\n var_7 = str(var_4)\n if var_7 == var_7[::-1]:\n var_2 += 1\nprint(var_2)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_5 in range(10):\n for var_6 in range(10):\n for var_7 in range(10):\n var_3 = 10000 * var_5 + 1000 * var_6 + 100 * var_7 + 10 * var_6 + var_5\n if var_1 <= var_3 <= var_2:\n var_4 += 1\nprint(var_4)\n```", "output": "FASTER 3.844", "pair_id": "python_p03416_pair0051_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 14.3598} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport copy\n\nvar_8 = int(eval(input()))\nvar_10 = set([var_6 for var_6 in range(1, 10**5)])\nvar_5 = []\nvar_11 = {}\nvar_9 = []\nfor var_6 in range(var_8 - 1):\n var_1, var_2 = list(map(int, input().split(\" \")))\n var_5.append([var_1, var_2])\n var_11.setdefault(var_1, []).append(var_2)\n var_9.append([])\nvar_9.append([])\nvar_9.append([])\nvar_7 = 0\nfor var_12 in range(1, var_8 + 1):\n var_14 = var_11.get(var_12, [])\n var_3 = 1\n for var_13 in var_14:\n if var_3 in var_9[var_12]:\n var_3 += 1\n else:\n pass\n var_9[var_13].append(var_3)\n if var_3 >= var_7:\n var_7 = var_3\n var_3 += 1\nprint(var_7)\nfor var_4 in var_5:\n print((var_9[var_4[1]][0]))\n```\n\n=== Code B (Modified) ===\n```python\nvar_6 = int(eval(input()))\nimport sys\n\nsys.setrecursionlimit(10**6)\nvar_11 = [[] for _ in range(var_6)]\nfor var_4 in range(var_6 - 1):\n var_1, var_2 = list(map(int, input().split()))\n var_11[var_1 - 1].append((var_2 - 1, var_4))\n var_11[var_2 - 1].append((var_1 - 1, var_4))\nvar_5 = [0] * (var_6 - 1)\n\n\ndef func_1(var_8, var_10, var_9):\n var_3 = 1\n for var_7, var_4 in var_11[var_8]:\n if var_7 == var_9:\n continue\n if var_3 == var_10:\n var_3 += 1\n var_5[var_4] = var_3\n func_1(var_7, var_3, var_8)\n var_3 += 1\n\n\nfunc_1(0, -1, -1)\nprint((max(var_5)))\nfor var_4 in var_5:\n print(var_4)\n```", "output": "FASTER 4.64", "pair_id": "python_p02850_pair0011_forward", "problem_id": "p02850", "language": "python", "direction": "forward", "speedup_ratio": 24.934} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = [\n var_3 for var_3 in map(str, list(range(var_1, var_2 + 1))) if var_3 == var_3[::-1]\n]\nprint((len(var_4)))\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n if str(var_4) == \"\".join(reversed(str(var_4))):\n var_3 += 1\nprint(var_3)\n```", "output": "SLOWER 1.7748", "pair_id": "python_p03416_pair0135_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 3.4219} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nfrom collections import Counter, defaultdict, deque\nfrom heapq import heappop, heappush, heapify\nimport sys, bisect, math, itertools, fractions, pprint\n\nsys.setrecursionlimit(10**8)\nvar_6 = 10**9 + 7\nvar_1 = float(\"inf\")\n\n\ndef func_1():\n return int(sys.stdin.readline())\n\n\ndef func_2():\n return list(map(int, sys.stdin.readline().split()))\n\n\nvar_8, var_11 = func_2()\nvar_17 = [func_2() for _ in range(var_8)]\nvar_10 = var_17[::-1]\nvar_14 = [[0] * var_11 for _ in range(var_8)]\nvar_3 = [[0] * var_11 for _ in range(var_8)]\nfor var_4 in range(var_8 - 1):\n var_16, var_15 = var_17[var_4]\n for var_5 in range(var_11):\n if var_5 < var_16:\n var_14[var_4 + 1][var_5] = var_14[var_4][var_5]\n else:\n var_14[var_4 + 1][var_5] = max(\n var_14[var_4][var_5], var_14[var_4][var_5 - var_16] + var_15\n )\nvar_9 = var_14[var_8 - 1][var_11 - 1] + var_17[var_8 - 1][1]\nfor var_4 in range(var_8 - 1):\n var_16, var_15 = var_10[var_4]\n for var_5 in range(var_11):\n if var_5 < var_16:\n var_3[var_4 + 1][var_5] = var_3[var_4][var_5]\n else:\n var_3[var_4 + 1][var_5] = max(\n var_3[var_4][var_5], var_3[var_4][var_5 - var_16] + var_15\n )\n var_9 = max(var_9, var_3[var_8 - 1][var_11 - 1] + var_17[0][1])\n\nfor var_4 in range(1, var_8 - 1):\n var_13 = var_4\n var_2 = var_8 - var_4 - 1\n var_7 = 0\n for var_5 in range(var_11):\n var_12 = var_14[var_13][var_5] + var_3[var_2][var_11 - 1 - var_5]\n var_7 = max(var_7, var_12)\n var_9 = max(var_9, var_7 + var_17[var_4][1])\nprint(var_9)\n```\n\n=== Code B (Modified) ===\n```python\nimport bisect\nimport sys\n\nsys.setrecursionlimit(10**6)\nvar_16 = sys.stdout.write\nvar_7 = lambda *var_14: print(*var_14) if var_1 else 0\nvar_1 = True\n\n\ndef func_1(var_9=sys.stdin.readline):\n var_11 = lambda: var_9().rstrip()\n var_3 = lambda: list(map(int, var_11().split()))\n var_2 = lambda: int(var_11())\n var_4 = lambda var_17: [var_3() for _ in range(var_17)]\n var_13, var_15 = var_3()\n var_5 = var_4(var_13)\n var_5.sort()\n var_8 = [[0] * var_15 for _ in range(var_13 + 1)]\n for var_10 in range(1, var_13 + 1):\n for var_12 in range(1, var_15):\n if var_12 < var_5[var_10 - 1][0]:\n var_8[var_10][var_12] = var_8[var_10 - 1][var_12]\n else:\n var_8[var_10][var_12] = max(\n var_8[var_10 - 1][var_12],\n var_8[var_10 - 1][var_12 - var_5[var_10 - 1][0]]\n + var_5[var_10 - 1][1],\n )\n var_6 = 0\n for var_10 in range(var_13):\n var_6 = max(var_6, var_8[var_10][var_15 - 1] + var_5[var_10][1])\n print(var_6)\n\n\nif __name__ == \"__main__\":\n func_1()\n```", "output": "FASTER 1.4049", "pair_id": "python_p02863_pair0063_forward", "problem_id": "p02863", "language": "python", "direction": "forward", "speedup_ratio": 2.648} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_3 in range(var_1, var_2 + 1):\n var_5 = list(str(var_3))\n var_6 = list(reversed(var_5))\n if var_5 == var_6:\n var_4 += 1\nprint(var_4)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = str(var_4)\n if var_5[0] == var_5[4] and var_5[1] == var_5[3]:\n var_3 += 1\nprint(var_3)\n```", "output": "FASTER 1.5748", "pair_id": "python_p03416_pair0191_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 2.9789} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\ndef func_1():\n var_1, var_3 = input().split()\n var_1 = int(var_1)\n var_3 = int(float(var_3) * 100 + 0.5)\n var_2 = var_1 * var_3\n print((var_2 // 100))\n\n\nif __name__ == \"__main__\":\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\nimport math\nfrom collections import defaultdict\nfrom bisect import bisect_left, bisect_right\n\nsys.setrecursionlimit(10**7)\n\n\ndef func_4():\n return sys.stdin.readline()[:-1]\n\n\nvar_4 = 10**9 + 7\n\n\ndef func_1():\n return int(eval(func_4()))\n\n\ndef func_2():\n return list(map(int, func_4().split()))\n\n\ndef func_3(var_6, var_3):\n if var_6 <= 0:\n return [[] for _ in range(var_3)]\n elif var_3 == 1:\n return [func_1() for _ in range(var_6)]\n else:\n var_5 = [func_2() for _ in range(var_6)]\n return list(map(list, list(zip(*var_5))))\n\n\nvar_1, var_2 = list(map(str, func_4().split()))\nvar_1 = int(var_1)\nvar_2 = 100 * int(var_2[0]) + 10 * int(var_2[2]) + int(var_2[3])\nprint((var_1 * var_2 // 100))\n```", "output": "SLOWER 1.871", "pair_id": "python_p02659_pair0055_reversed", "problem_id": "p02659", "language": "python", "direction": "reversed", "speedup_ratio": 3.6579} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1 = int(eval(input()))\nvar_3 = 0\nfor var_2 in range(1000001):\n var_3 += 7 * pow(10, var_2, var_1)\n var_3 %= var_1\n if var_3 == 0:\n print((var_2 + 1))\n break\nelse:\n print((-1))\n```\n\n=== Code B (Modified) ===\n```python\ndef func_1(var_1):\n var_2 = 0\n var_4 = 1\n for var_3 in range(1_000_001):\n var_2 += 7 * var_4\n var_2 %= var_1\n if var_2 == 0:\n return var_3 + 1\n var_4 *= 10\n var_4 %= var_1\n else:\n return -1\n\n\nprint((func_1(int(eval(input())))))\n```", "output": "FASTER 2.9835", "pair_id": "python_p02596_pair0002_forward", "problem_id": "p02596", "language": "python", "direction": "forward", "speedup_ratio": 7.9088} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\nimport math\nfrom collections import defaultdict\nfrom bisect import bisect_left, bisect_right\n\nsys.setrecursionlimit(10**7)\n\n\ndef func_4():\n return sys.stdin.readline()[:-1]\n\n\nvar_4 = 10**9 + 7\n\n\ndef func_1():\n return int(eval(func_4()))\n\n\ndef func_2():\n return list(map(int, func_4().split()))\n\n\ndef func_3(var_6, var_3):\n if var_6 <= 0:\n return [[] for _ in range(var_3)]\n elif var_3 == 1:\n return [func_1() for _ in range(var_6)]\n else:\n var_5 = [func_2() for _ in range(var_6)]\n return list(map(list, list(zip(*var_5))))\n\n\nvar_1, var_2 = list(map(str, func_4().split()))\nvar_1 = int(var_1)\nvar_2 = 100 * int(var_2[0]) + 10 * int(var_2[2]) + int(var_2[3])\nprint((var_1 * var_2 // 100))\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = input().split()\nvar_1 = int(var_1)\nvar_3, var_4 = list(map(int, var_2.split(\".\")))\nvar_5 = var_1 * (var_3 * 100 + var_4)\nprint((int(var_5 // 100)))\n```", "output": "FASTER 2.0781", "pair_id": "python_p02659_pair0034_forward", "problem_id": "p02659", "language": "python", "direction": "forward", "speedup_ratio": 4.2224} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_7 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_3 = True\n var_8 = str(var_4)\n var_6 = len(var_8)\n for var_5 in range(var_6 // 2 + 1):\n if var_8[var_5] != var_8[-var_5 - 1]:\n var_3 = False\n break\n if var_3:\n var_7 += 1\nprint(var_7)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = str(var_4)\n if var_5[0] == var_5[4] and var_5[1] == var_5[3]:\n var_3 += 1\nprint(var_3)\n```", "output": "FASTER 1.3913", "pair_id": "python_p03416_pair0230_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 2.6231} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\ndef func_1():\n return list(map(int, input().split()))\n\n\nimport numpy as np\n\nvar_1, var_2, var_3 = func_1()\nvar_4 = np.array(list(func_1()))\nvar_6 = np.array(list(func_1()))\nvar_9 = min(var_4) + min(var_6)\nvar_5 = float(\"inf\")\nfor var_8 in range(var_3):\n var_11, var_12, var_7 = func_1()\n var_10 = var_4[var_11 - 1] + var_6[var_12 - 1] - var_7\n var_5 = min(var_5, var_10)\nprint((min(var_5, var_9)))\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\nfrom collections import Counter\n\n\ndef func_10():\n return sys.stdin.readline().strip()\n\n\ndef func_11(var_12, var_13, var_14):\n return [[var_14] * var_13 for var_17 in range(var_12)]\n\n\ndef func_12(var_12, var_13, var_14, var_15):\n return [[[var_15] * var_14 for var_18 in range(var_13)] for var_17 in range(var_12)]\n\n\ndef func_13(var_12, var_13, var_14, var_15, var_16):\n return [\n [[[var_16] * var_15 for var_18 in range(var_14)] for var_18 in range(var_13)]\n for var_17 in range(var_12)\n ]\n\n\ndef func_8(var_22, var_23=1):\n return int(-(-var_22 // var_23))\n\n\ndef func_1():\n return int(eval(func_10()))\n\n\ndef func_3():\n return list(map(int, func_10().split()))\n\n\ndef func_2(var_11=None):\n return list(func_3()) if var_11 is None else [func_1() for var_17 in range(var_11)]\n\n\ndef func_7():\n print(\"Yes\")\n\n\ndef func_5():\n print(\"No\")\n\n\ndef func_6():\n print(\"YES\")\n\n\ndef func_4():\n print(\"NO\")\n\n\nsys.setrecursionlimit(10**9)\nvar_5 = 10**18\nvar_10 = 10**9 + 7\n\n\ndef func_9(var_1, var_2):\n \"\"\"\"\"\"\n import numpy as np\n from numpy.fft import rfft, irfft\n\n var_8 = max(var_1)\n var_9 = max(var_2)\n var_3 = [0] * (var_8 + 1)\n var_4 = [0] * (var_9 + 1)\n for var_12 in var_1:\n var_3[var_12] += 1\n for var_13 in var_2:\n var_4[var_13] += 1\n\n var_6 = 1\n var_19 = 0\n while var_6 <= var_8 + var_9:\n var_19 += 1\n var_6 = 2**var_19\n\n var_21 = irfft(rfft(var_3, var_6) * rfft(var_4, var_6), var_6)\n\n var_21 = np.rint(var_21).astype(np.int64)\n return var_21\n\n\nvar_11, var_7, var_6 = func_3()\nvar_1 = func_2()\nvar_2 = func_2()\nvar_21 = list(func_9(var_1, var_2))\nvar_20 = var_5\nfor var_17, var_12 in enumerate(var_21):\n if var_12 != 0:\n var_20 = var_17\n break\nfor _ in range(var_6):\n var_22, var_23, var_14 = func_3()\n var_22 -= 1\n var_23 -= 1\n var_20 = min(var_20, var_1[var_22] + var_2[var_23] - var_14)\nprint(var_20)\n```", "output": "SLOWER 2.9536", "pair_id": "python_p02748_pair0004_reversed", "problem_id": "p02748", "language": "python", "direction": "reversed", "speedup_ratio": 7.7468} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = list(reversed(list(str(var_4))))\n if var_5 == list(str(var_4)):\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = input().split()\nvar_1 = int(var_1)\nvar_2 = int(var_2)\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = list(str(var_4))\n if (var_5[0] == var_5[4]) and (var_5[1] == var_5[3]):\n var_3 = var_3 + 1\nprint(var_3)\n```", "output": "FASTER 1.2527", "pair_id": "python_p03416_pair0231_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 2.3828} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_8 in range(var_1, var_2 + 1):\n var_7 = str(var_8)\n var_6 = len(var_7)\n var_4 = True\n for var_5 in range(var_6 // 2):\n if var_7[var_5] != var_7[var_6 - 1 - var_5]:\n var_4 = False\n break\n if var_4:\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1 = list(map(int, input().split()))\nvar_2 = 0\nfor var_3 in range(var_1[0], var_1[1] + 1):\n var_4 = str(var_3)\n if var_4[0] == var_4[4] and var_4[1] == var_4[3]:\n var_2 += 1\nprint(var_2)\n```", "output": "FASTER 1.4151", "pair_id": "python_p03416_pair0188_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 2.6667} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\nfrom operator import itemgetter\nfrom heapq import heapify, heappop, heappush\n\nvar_1 = int(10e15)\nvar_2 = -var_1\nvar_11 = 1000000007\nsys.setrecursionlimit(1000000)\n\n\ndef func_2():\n return list(map(int, input().split()))\n\n\ndef func_4():\n return input().split()\n\n\ndef func_1():\n return int(sys.stdin.readline())\n\n\ndef func_3():\n return eval(input())\n\n\nvar_3, var_4 = func_2()\nvar_5 = [func_2() for var_9 in range(var_3)]\nvar_5.sort(key=itemgetter(0))\n\nvar_8 = [[0] * (var_4 + 1 + 3000 + 1) for _ in range(var_3 + 1)]\nvar_6 = 0\nfor var_9 in range(var_3):\n for var_10 in range(var_4 + 1 + 3000 + 1):\n var_12, var_7 = var_5[var_9]\n if 0 <= var_10 - var_12 < var_4:\n var_8[var_9 + 1][var_10] = max(\n var_8[var_9][var_10], var_8[var_9][var_10 - var_12] + var_7\n )\n else:\n var_8[var_9 + 1][var_10] = var_8[var_9][var_10]\n var_6 = max(var_6, var_8[var_9 + 1][var_10])\nprint(var_6)\n```\n\n=== Code B (Modified) ===\n```python\nfrom collections import Counter, defaultdict, deque\nfrom heapq import heappop, heappush, heapify\nimport sys, bisect, math, itertools, fractions, pprint\n\nsys.setrecursionlimit(10**8)\nvar_6 = 10**9 + 7\nvar_1 = float(\"inf\")\n\n\ndef func_1():\n return int(sys.stdin.readline())\n\n\ndef func_2():\n return list(map(int, sys.stdin.readline().split()))\n\n\nvar_7, var_9 = func_2()\nvar_13 = [func_2() for _ in range(var_7)]\nvar_13.sort(key=lambda var_14: var_14[1], reverse=True)\nvar_8 = 0\nvar_10 = min(var_7, 5)\nfor var_3 in range(var_10):\n var_2 = [[0] * (var_9 + 5) for _ in range(var_7 + 5)]\n for var_4 in range(var_7):\n var_12, var_11 = var_13[var_4]\n for var_5 in range(var_9):\n if var_5 < var_12 or var_3 == var_4:\n var_2[var_4 + 1][var_5] = var_2[var_4][var_5]\n else:\n var_2[var_4 + 1][var_5] = max(\n var_2[var_4][var_5], var_2[var_4][var_5 - var_12] + var_11\n )\n\n var_8 = max(var_2[var_7][var_9 - 1] + var_13[var_3][1], var_8)\nprint(var_8)\n```", "output": "FASTER 3.1764", "pair_id": "python_p02863_pair0056_forward", "problem_id": "p02863", "language": "python", "direction": "forward", "speedup_ratio": 9.0403} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_8 in range(var_1, var_2 + 1):\n var_7 = str(var_8)\n var_6 = len(var_7)\n var_4 = True\n for var_5 in range(var_6 // 2):\n if var_7[var_5] != var_7[var_6 - 1 - var_5]:\n var_4 = False\n break\n if var_4:\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_5 in range(var_1, var_2 + 1):\n var_3 = str(var_5)\n if var_3[0] == var_3[-1] and var_3[1] == var_3[-2]:\n var_4 += 1\nprint(var_4)\n```", "output": "FASTER 1.2178", "pair_id": "python_p03416_pair0030_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 2.3259} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_11 = int(eval(input()))\nvar_12 = {var_8: [] for var_8 in range(1, var_11 + 1)}\nvar_19 = [False for var_8 in range(var_11 + 1)]\nvar_16 = []\nfor _ in range(var_11 - 1):\n var_2, var_3 = list(map(int, input().split()))\n var_12[var_2].append(var_3)\n var_12[var_3].append(var_2)\n var_16.append((var_2, var_3))\nvar_9 = var_16[0][0]\nvar_19[var_9] = True\nvar_6 = []\nvar_7 = []\nvar_14 = {var_8: {} for var_8 in range(1, var_11 + 1)}\nvar_10 = [0 for var_8 in range(var_11 + 1)]\n\nvar_4 = 1\nfor var_5 in var_12[var_9]:\n var_19[var_5] = True\n var_14[var_9][var_5] = var_4\n var_14[var_5][var_9] = var_4\n var_10[var_5] = var_4\n var_4 += 1\n var_6.append(var_5)\nwhile var_6:\n for var_15 in var_6:\n var_13 = 1\n for var_5 in var_12[var_15]:\n if var_19[var_5] == False:\n var_19[var_5] = True\n if var_13 != var_10[var_15]:\n var_14[var_15][var_5] = var_13\n var_14[var_5][var_15] = var_13\n var_10[var_5] = var_13\n var_13 += 1\n var_7.append(var_5)\n else:\n var_13 += 1\n var_14[var_15][var_5] = var_13\n var_14[var_5][var_15] = var_13\n var_10[var_5] = var_13\n var_13 += 1\n var_7.append(var_5)\n if var_7:\n var_6 = var_7\n var_7 = []\n else:\n var_6 = []\n var_7 = []\nvar_1 = 0\nfor var_8 in range(1, var_11 + 1):\n var_1 = max(var_1, len(var_12[var_8]))\nprint(var_1)\nfor var_8 in range(var_11 - 1):\n var_17, var_18 = var_16[var_8][0], var_16[var_8][1]\n print((var_14[var_17][var_18]))\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\nfrom collections import deque\n\nvar_13 = sys.stdin.readline\nvar_2 = int(eval(var_13()))\nvar_5 = [deque() for _ in range(var_2)]\nvar_3 = [-1] * var_2\nfor var_12 in range(var_2 - 1):\n var_6, var_8 = list(map(int, var_13().split()))\n var_5[var_6 - 1].append((var_12, var_8 - 1))\n\n\nvar_4 = deque([(0, -1)])\nvar_1 = [-1] * (var_2 - 1)\nvar_11 = 0\nwhile var_4:\n var_14, var_10 = var_4.pop()\n var_9 = 1\n for var_12, var_15 in var_5[var_14]:\n if var_9 == var_10:\n var_9 += 1\n var_1[var_12] = var_9\n var_4.appendleft((var_15, var_9))\n var_9 += 1\n var_11 = max(var_11, var_9 - 1)\nprint(var_11)\nfor var_7 in var_1:\n print(var_7)\n```", "output": "FASTER 1.0442", "pair_id": "python_p02850_pair0028_forward", "problem_id": "p02850", "language": "python", "direction": "forward", "speedup_ratio": 2.0622} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nfrom sys import stdin\n\n\ndef func_1():\n\n var_11 = stdin.readline\n var_2 = int(var_11())\n var_1 = []\n for var_6 in range(var_2):\n var_5 = int(\"\".join(var_11().strip().split(\" \")), 2)\n var_1.append(var_5)\n var_3 = []\n for var_6 in range(var_2):\n var_10 = list(map(int, var_11().split()))\n var_3.append(var_10)\n var_8 = float(\"-inf\")\n for var_9 in range(1, 1 << 10):\n var_12 = 0\n for var_7 in range(var_2):\n var_4 = bin(var_9 & var_1[var_7]).count(\"1\")\n var_12 += var_3[var_7][var_4]\n var_8 = max(var_12, var_8)\n print(var_8)\n\n\nif __name__ == \"__main__\":\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\nimport itertools\n\n\ndef func_2(var_4):\n return bin(eval(\"0b\" + str(var_4)))\n\n\ndef func_1():\n var_4 = int(sys.stdin.readline().rstrip())\n var_9 = [\n func_2(\"\".join(str(var_10) for var_10 in sys.stdin.readline().split()))\n for _ in range(var_4)\n ]\n var_8 = [\n [int(var_10) for var_10 in sys.stdin.readline().split()] for _ in range(var_4)\n ]\n var_3 = -(10**10)\n for var_6 in itertools.product(\"01\", repeat=10):\n var_6 = func_2(\"\".join(var_6))\n if var_6 == \"0b0\":\n continue\n var_7 = 0\n for var_2 in range(var_4):\n var_1 = var_9[var_2]\n var_5 = bin(eval(var_1) & eval(var_6)).count(\"1\")\n var_7 += var_8[var_2][var_5]\n var_3 = max(var_3, var_7)\n print(var_3)\n\n\nif __name__ == \"__main__\":\n\n func_1()\n```", "output": "SLOWER 5.45", "pair_id": "python_p03503_pair0043_reversed", "problem_id": "p03503", "language": "python", "direction": "reversed", "speedup_ratio": 43.7144} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\nimport numpy as np\n\nvar_6 = int(eval(input()))\n\nvar_1 = [input().replace(\" \", \"\") for var_4 in range(var_6)]\n\nvar_7 = [list(map(int, input().split())) for var_4 in range(var_6)]\nvar_11 = -999999999999999\nfor var_4 in range(1, 1024):\n var_3 = format(var_4, \"010b\")\n var_9 = 0\n for var_2, var_8 in zip(var_1, var_7):\n var_10 = 0\n for var_5 in range(10):\n if var_2[var_5] == \"1\" and var_3[var_5] == \"1\":\n var_10 += 1\n var_9 += var_8[var_10]\n if var_9 > var_11:\n if var_9 == 0:\n print((str(var_4)))\n break\n var_11 = var_9\nprint(var_11)\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\n\nvar_7 = sys.stdin.readline\nfrom itertools import combinations\n\n\ndef func_3(var_10):\n for _ in range(var_10):\n yield list(map(int, var_7().split()))\n\n\ndef func_1(var_9, var_5, var_11):\n var_3 = len([0 for var_8 in var_9 if var_5[var_8] == 1])\n return var_11[var_3]\n\n\ndef func_2():\n var_10 = int(eval(var_7()))\n var_1 = list(func_3(var_10))\n var_2 = list(func_3(var_10))\n for var_6 in range(1, 11):\n for var_4 in combinations(list(range(10)), var_6):\n yield sum(\n func_1(var_4, var_5, var_11) for var_5, var_11 in zip(var_1, var_2)\n )\n\n\nprint((max(func_2())))\n```", "output": "FASTER 1.1194", "pair_id": "python_p03503_pair0012_forward", "problem_id": "p03503", "language": "python", "direction": "forward", "speedup_ratio": 2.1726} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport copy\n\nvar_8 = int(eval(input()))\nvar_10 = set([var_6 for var_6 in range(1, 10**5)])\nvar_5 = []\nvar_11 = {}\nvar_9 = []\nfor var_6 in range(var_8 - 1):\n var_1, var_2 = list(map(int, input().split(\" \")))\n var_5.append([var_1, var_2])\n var_11.setdefault(var_1, []).append(var_2)\n var_9.append([])\nvar_9.append([])\nvar_9.append([])\nvar_7 = 0\nfor var_12 in range(1, var_8 + 1):\n var_14 = var_11.get(var_12, [])\n var_3 = 1\n for var_13 in var_14:\n if var_3 in var_9[var_12]:\n var_3 += 1\n else:\n pass\n var_9[var_13].append(var_3)\n if var_3 >= var_7:\n var_7 = var_3\n var_3 += 1\nprint(var_7)\nfor var_4 in var_5:\n print((var_9[var_4[1]][0]))\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\n\nvar_10 = sys.stdin.readline\nvar_4 = int(eval(var_10()))\nvar_9 = [[] for _ in range(var_4)]\nvar_3 = []\nfor _ in range(var_4 - 1):\n var_5, var_6 = list(map(int, var_10().split()))\n var_9[var_5 - 1].append(var_6 - 1)\n var_9[var_6 - 1].append(var_5 - 1)\n var_3.append((var_5 - 1, var_6 - 1))\nvar_1 = 0\nfor var_11 in range(var_4):\n var_1 = max(var_1, len(var_9[var_11]))\nvar_2 = dict()\nvar_8 = [-1] * var_4\nvar_14 = [0]\nvar_8[0] = var_1 + 1\nwhile var_14:\n var_15 = []\n for var_13 in var_14:\n var_7 = var_8[var_13]\n var_16 = 0\n for var_12 in var_9[var_13]:\n if var_8[var_12] == -1:\n if var_16 == var_7:\n var_16 += 1\n var_8[var_12] = var_16\n var_2[(var_13, var_12)] = var_16\n var_2[(var_12, var_13)] = var_16\n var_16 += 1\n var_15.append(var_12)\n var_14 = var_15\nprint(var_1)\nfor var_5, var_6 in var_3:\n print((var_2[(var_5, var_6)] + 1))\n```", "output": "FASTER 4.2291", "pair_id": "python_p02850_pair0013_forward", "problem_id": "p02850", "language": "python", "direction": "forward", "speedup_ratio": 18.7534} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport numpy as np\nfrom itertools import product\n\nvar_6 = int(eval(input()))\nvar_2 = list(map(int, input().split()))\nvar_2 = np.array(var_2)\nvar_5 = [-1, 0, 1]\nvar_3 = 0\nfor var_7 in product(var_5, repeat=var_6):\n var_7 = np.array(var_7)\n var_1 = var_2 + var_7\n var_4 = var_1.cumprod()\n if var_4[-1] % 2 == 0:\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_2 = int(eval(input()))\n(*var_1,) = list(map(int, input().split()))\nvar_5 = 0\nfor var_3 in var_1:\n if var_3 % 2 == 0:\n var_5 += 1\nvar_4 = 3**var_2 - 2**var_5\nprint(var_4)\n```", "output": "FASTER 10.028", "pair_id": "python_p03568_pair0017_forward", "problem_id": "p03568", "language": "python", "direction": "forward", "speedup_ratio": 1044.0343} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = input().split()\nvar_1 = int(var_1)\nvar_2 = int(var_2)\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = list(str(var_4))\n if (var_5[0] == var_5[4]) and (var_5[1] == var_5[3]):\n var_3 = var_3 + 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = [0] * (var_2 + 1)\nfor var_3 in range(1, var_2 + 1):\n if str(var_3) == str(var_3)[::-1]:\n var_4[var_3] = var_4[var_3 - 1] + 1\n else:\n var_4[var_3] = var_4[var_3 - 1]\nprint((var_4[var_2] - var_4[var_1 - 1]))\n```", "output": "SLOWER 1.5379", "pair_id": "python_p03416_pair0182_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 2.9038} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_6 = 2019\nvar_1 = [0] * var_6\nvar_3 = 1\nvar_5 = var_4 = 0\nfor var_2 in input()[::-1]:\n var_1[var_4] += 1\n var_4 -= int(var_2) * var_3\n var_4 %= var_6\n var_5 += var_1[var_4]\n var_3 *= 10\n var_3 %= var_6\nprint(var_5)\n```\n\n=== Code B (Modified) ===\n```python\n\"\"\"\"\"\"\n\nfrom collections import defaultdict\n\n\ndef func_1(var_10, var_9):\n var_5 = 1\n yield var_5\n for _ in range(1, var_10):\n var_5 = (var_5 * 10) % var_9\n yield var_5\n\n\ndef func_2():\n var_3 = 2019\n var_4 = input()[::-1]\n\n var_1 = [\n int(var_11) * var_10 % var_3\n for var_11, var_10 in zip(var_4, func_1(len(var_4), var_3))\n ]\n\n var_2 = [0]\n for var_5 in var_1:\n var_2.append((var_2[-1] + var_5) % var_3)\n\n var_8 = defaultdict(int)\n for var_6 in var_2:\n var_8[var_6] += 1\n var_7 = sum(var_12 * (var_12 - 1) // 2 for var_12 in list(var_8.values()))\n print(var_7)\n\n\nfunc_2()\n```", "output": "SLOWER 1.5308", "pair_id": "python_p02702_pair0013_reversed", "problem_id": "p02702", "language": "python", "direction": "reversed", "speedup_ratio": 2.8894} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\nimport itertools\n\n\ndef func_2(var_4):\n return bin(eval(\"0b\" + str(var_4)))\n\n\ndef func_1():\n var_4 = int(sys.stdin.readline().rstrip())\n var_9 = [\n func_2(\"\".join(str(var_10) for var_10 in sys.stdin.readline().split()))\n for _ in range(var_4)\n ]\n var_8 = [\n [int(var_10) for var_10 in sys.stdin.readline().split()] for _ in range(var_4)\n ]\n var_3 = -(10**10)\n for var_6 in itertools.product(\"01\", repeat=10):\n var_6 = func_2(\"\".join(var_6))\n if var_6 == \"0b0\":\n continue\n var_7 = 0\n for var_2 in range(var_4):\n var_1 = var_9[var_2]\n var_5 = bin(eval(var_1) & eval(var_6)).count(\"1\")\n var_7 += var_8[var_2][var_5]\n var_3 = max(var_3, var_7)\n print(var_3)\n\n\nif __name__ == \"__main__\":\n\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nfrom sys import stdin\n\n\ndef func_1():\n\n var_11 = stdin.readline\n var_2 = int(var_11())\n var_1 = []\n for var_6 in range(var_2):\n var_5 = int(\"\".join(var_11().strip().split(\" \")), 2)\n var_1.append(var_5)\n var_3 = []\n for var_6 in range(var_2):\n var_10 = list(map(int, var_11().split()))\n var_3.append(var_10)\n var_8 = float(\"-inf\")\n for var_9 in range(1, 1 << 10):\n var_12 = 0\n for var_7 in range(var_2):\n var_4 = bin(var_9 & var_1[var_7]).count(\"1\")\n var_12 += var_3[var_7][var_4]\n var_8 = max(var_12, var_8)\n print(var_8)\n\n\nif __name__ == \"__main__\":\n func_1()\n```", "output": "FASTER 5.45", "pair_id": "python_p03503_pair0043_forward", "problem_id": "p03503", "language": "python", "direction": "forward", "speedup_ratio": 43.7144} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\ndef func_1():\n var_1, var_2 = list(map(int, input().split()))\n var_3 = 0\n for var_4 in range(var_1, var_2 + 1):\n\n if (var_4 % 10) == (var_4 // 10000 % 10) and (var_4 // 10 % 10) == (\n var_4 // 1000 % 10\n ):\n var_3 += 1\n print(var_3)\n\n\nif __name__ == \"__main__\":\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_5 in range(var_1, var_2 + 1):\n var_3 = str(var_5)\n if var_3[0] == var_3[-1] and var_3[1] == var_3[-2]:\n var_4 += 1\nprint(var_4)\n```", "output": "SLOWER 1.5725", "pair_id": "python_p03416_pair0144_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 2.9741} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1 = list(map(int, input().split()))\nvar_2 = 0\nfor var_3 in range(var_1[0], var_1[1] + 1):\n var_4 = str(var_3)\n if var_4[0] == var_4[4] and var_4[1] == var_4[3]:\n var_2 += 1\nprint(var_2)\n```\n\n=== Code B (Modified) ===\n```python\nvar_4, var_3 = list(map(int, input().split()))\nvar_1 = 0\nfor var_2 in range(var_4, var_3 + 1):\n if str(var_2)[0] + str(var_2)[1] == str(var_2)[-1] + str(var_2)[-2]:\n var_1 += 1\nprint(var_1)\n```", "output": "SLOWER 1.6299", "pair_id": "python_p03416_pair0217_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 3.0949} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n if str(var_4) == \"\".join(reversed(str(var_4))):\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nfrom sys import stdin\n\nvar_6 = lambda: list(map(int, stdin.readline().split()))\nvar_5 = lambda: list(map(int, stdin.readline().split()))\nvar_1, var_3 = var_6()\nvar_2 = 0\nfor var_4 in range(var_1, var_3 + 1):\n var_7 = str(var_4)\n if var_7 == var_7[::-1]:\n var_2 += 1\nprint(var_2)\n```", "output": "FASTER 1.0578", "pair_id": "python_p03416_pair0104_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 2.0818} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport math\n\nvar_1, var_4 = (int(var_10) for var_10 in input().split())\nvar_2 = math.ceil(var_1 / 0.08)\nvar_3 = math.ceil((var_1 + 1) / 0.08)\n\"\"\"\"\"\"\nvar_5 = math.ceil(var_4 / 0.1)\nvar_6 = math.ceil((var_4 + 1) / 0.1)\n\"\"\"\"\"\"\nvar_7 = list(range(var_2, var_3))\nvar_8 = list(range(var_5, var_6))\nvar_9 = set(var_7) & set(var_8)\nif len(var_9) == 0:\n print((-1))\nelse:\n print((min(var_9)))\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nfor var_3 in range(1, 1009):\n if int(var_3 * 0.08) == var_1 and int(var_3 * 0.1) == var_2:\n print((int(var_3)))\n exit()\nprint(\"-1\")\n```", "output": "SLOWER 1.1926", "pair_id": "python_p02755_pair0014_reversed", "problem_id": "p02755", "language": "python", "direction": "reversed", "speedup_ratio": 2.2856} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\ndef func_1():\n var_2 = int(input())\n var_1 = [int(var_6) for var_6 in input().split()]\n if var_2 == 1:\n return print(1 if var_1[0] % 2 == 0 else 2)\n var_3 = 0\n var_5 = (-1, 0, 1)\n from itertools import product\n\n for var_6 in product(range(3), repeat=var_2):\n var_4 = 1\n for var_7 in range(var_2):\n var_4 *= var_1[var_7] + var_5[var_6[var_7]]\n if var_4 % 2 == 0:\n var_3 += 1\n print(var_3)\n\n\nif __name__ == \"__main__\":\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nimport math\nimport string\n\n\ndef func_4():\n return list(map(int, input().split()))\n\n\ndef func_3(var_6, var_7):\n return math.factorial(var_6) // (\n math.factorial(var_6 - var_7) * math.factorial(var_7)\n )\n\n\ndef func_2(var_9):\n var_8 = []\n for var_5 in var_9:\n if not (var_5 in var_8):\n var_8.append(var_5)\n return len(var_9) != len(var_8)\n\n\ndef func_1(var_6):\n func_1 = []\n for var_4 in range(1, var_6 + 1):\n if var_6 % var_4 == 0:\n func_1.append(var_4)\n return func_1\n\n\nvar_2 = [-1, -1, -1, 0, 0, 1, 1, 1]\nvar_3 = [-1, 0, 1, -1, 1, -1, 0, 1]\nvar_6 = int(eval(input()))\nvar_1 = func_4()\nvar_10 = 1\nfor var_4 in range(len(var_1)):\n if var_1[var_4] % 2 == 0:\n var_10 *= 2\n else:\n var_10 *= 1\nprint((3 ** len(var_1) - var_10))\n```", "output": "FASTER 6.869", "pair_id": "python_p03568_pair0036_forward", "problem_id": "p03568", "language": "python", "direction": "forward", "speedup_ratio": 116.8901} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\ndef func_1():\n var_2 = int(input())\n var_1 = [int(var_6) for var_6 in input().split()]\n if var_2 == 1:\n return print(1 if var_1[0] % 2 == 0 else 2)\n var_3 = 0\n var_5 = (-1, 0, 1)\n from itertools import product\n\n for var_6 in product(range(3), repeat=var_2):\n var_4 = 1\n for var_7 in range(var_2):\n var_4 *= var_1[var_7] + var_5[var_6[var_7]]\n if var_4 % 2 == 0:\n var_3 += 1\n print(var_3)\n\n\nif __name__ == \"__main__\":\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nfrom functools import reduce\nfrom itertools import product\n\nvar_2 = int(eval(input()))\n(*var_1,) = list(map(int, input().split()))\nvar_4 = 0\nfor var_7 in product([-1, 0, 1], repeat=var_2):\n var_6 = reduce(\n lambda var_8, var_9: var_8 * var_9,\n [var_3 + var_7[var_5] for var_5, var_3 in enumerate(var_1)],\n )\n if var_6 % 2 == 0:\n var_4 += 1\nprint(var_4)\n```", "output": "SLOWER 1.1995", "pair_id": "python_p03568_pair0043_reversed", "problem_id": "p03568", "language": "python", "direction": "reversed", "speedup_ratio": 2.2966} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\nimport itertools\n\n\ndef func_2(var_4):\n return eval(\"0b\" + var_4)\n\n\ndef func_1():\n var_4 = int(sys.stdin.readline().rstrip())\n var_9 = [\n func_2(\"\".join(str(var_10) for var_10 in sys.stdin.readline().split()))\n for _ in range(var_4)\n ]\n var_8 = [\n [int(var_10) for var_10 in sys.stdin.readline().split()] for _ in range(var_4)\n ]\n var_3 = -(10**10)\n for var_6 in itertools.product(\"01\", repeat=10):\n var_6 = func_2(\"\".join(var_6))\n if var_6 == 0:\n continue\n var_7 = 0\n for var_2 in range(var_4):\n var_1 = var_9[var_2]\n var_5 = bin(var_1 & var_6).count(\"1\")\n var_7 += var_8[var_2][var_5]\n var_3 = max(var_3, var_7)\n print(var_3)\n\n\nif __name__ == \"__main__\":\n\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nfrom sys import stdin\n\n\ndef func_1():\n\n var_13 = stdin.readline\n var_2 = int(var_13())\n var_1 = []\n for var_6 in range(var_2):\n var_5 = list(map(int, var_13().split()))\n var_1.append(var_5)\n var_3 = []\n for var_6 in range(var_2):\n var_12 = list(map(int, var_13().split()))\n var_3.append(var_12)\n var_9 = -float(\"inf\")\n for var_6 in range(1 << 10):\n if var_6 == 0:\n continue\n else:\n var_11 = []\n for var_7 in range(10):\n if (var_6 >> var_7) & 1:\n var_11.append(var_7)\n var_10 = [0] * 10\n for var_7 in var_11:\n var_10[var_7] = 1\n var_14 = 0\n for var_7 in range(var_2):\n var_4 = 0\n for var_8 in range(10):\n if var_10[var_8] == 1 and var_1[var_7][var_8] == 1:\n var_4 += 1\n var_14 += var_3[var_7][var_4]\n var_9 = max(var_14, var_9)\n print(var_9)\n\n\nif __name__ == \"__main__\":\n func_1()\n```", "output": "FASTER 1.1909", "pair_id": "python_p03503_pair0044_forward", "problem_id": "p03503", "language": "python", "direction": "forward", "speedup_ratio": 2.2829} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\ndef func_1():\n var_2, var_3, *var_1 = list(map(int, open(0).read().split()))\n var_4 = [0] * (var_3 + max(var_1[::2]))\n for var_7, var_6 in sorted(zip(*[iter(var_1)] * 2)):\n for var_5 in reversed(list(range(var_3))):\n var_4[var_5 + var_7] = max(var_4[var_5 + var_7], var_4[var_5] + var_6)\n print((max(var_4)))\n\n\nfunc_1()\n```\n\n=== Code B (Modified) ===\n```python\nfrom collections import Counter, defaultdict, deque\nfrom heapq import heappop, heappush, heapify\nimport sys, bisect, math, itertools, fractions, pprint\n\nsys.setrecursionlimit(10**8)\nvar_6 = 10**9 + 7\nvar_1 = float(\"inf\")\n\n\ndef func_1():\n return int(sys.stdin.readline())\n\n\ndef func_2():\n return list(map(int, sys.stdin.readline().split()))\n\n\nvar_7, var_9 = func_2()\nvar_13 = [func_2() for _ in range(var_7)]\nvar_13.sort(key=lambda var_14: var_14[1], reverse=True)\nvar_8 = 0\nvar_10 = min(var_7, 5)\nfor var_3 in range(var_10):\n var_2 = [[0] * (var_9 + 5) for _ in range(var_7 + 5)]\n for var_4 in range(var_7):\n var_12, var_11 = var_13[var_4]\n for var_5 in range(var_9):\n if var_5 < var_12 or var_3 == var_4:\n var_2[var_4 + 1][var_5] = var_2[var_4][var_5]\n else:\n var_2[var_4 + 1][var_5] = max(\n var_2[var_4][var_5], var_2[var_4][var_5 - var_12] + var_11\n )\n\n var_8 = max(var_2[var_7][var_9 - 1] + var_13[var_3][1], var_8)\nprint(var_8)\n```", "output": "SLOWER 2.938", "pair_id": "python_p02863_pair0015_reversed", "problem_id": "p02863", "language": "python", "direction": "reversed", "speedup_ratio": 7.6633} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_4 = str(var_4)\n if var_4[0] == var_4[-1] and var_4[1] == var_4[-2]:\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n if list(str(var_4)) == list(reversed(str(var_4))):\n var_3 += 1\nprint(var_3)\n```", "output": "SLOWER 1.584", "pair_id": "python_p03416_pair0110_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 2.9981} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\ndef func_1():\n from sys import setrecursionlimit, stdin\n from os import environ\n from collections import defaultdict, deque, Counter\n from math import ceil, floor, gcd\n from itertools import accumulate, combinations, combinations_with_replacement\n\n setrecursionlimit(10**6)\n var_7 = (\n (lambda *var_11: print(*var_11))\n if \"TERM_PROGRAM\" in environ\n else lambda *var_12: 0\n )\n var_8 = lambda: stdin.readline().rstrip()\n var_3 = lambda: list(map(int, var_8().split()))\n var_1 = lambda: int(var_8())\n var_4 = 10**9 + 7\n var_2 = 10**9 + 10\n var_9, var_10 = var_8().split()\n var_5 = int(var_9)\n var_6 = int(float(var_10) * 100 + 0.5)\n print(var_5 * var_6 // 100)\n\n\nfunc_1()\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = input().split()\nvar_1 = int(var_1)\nvar_3, var_4 = list(map(int, var_2.split(\".\")))\nvar_5 = var_1 * (var_3 * 100 + var_4)\nprint((int(var_5 // 100)))\n```", "output": "FASTER 1.782", "pair_id": "python_p02659_pair0028_forward", "problem_id": "p02659", "language": "python", "direction": "forward", "speedup_ratio": 3.4391} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = str(var_4)\n if var_5[0] == var_5[4] and var_5[1] == var_5[3]:\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\n\n\ndef func_1(var_5):\n var_4 = 0\n for var_3 in range(1, var_5 + 1):\n if str(var_3) == str(var_3)[::-1]:\n var_4 += 1\n return var_4\n\n\nprint((func_1(var_2) - func_1(var_1 - 1)))\n```", "output": "SLOWER 1.8568", "pair_id": "python_p03416_pair0232_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 3.622} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_5 in range(10):\n for var_6 in range(10):\n for var_7 in range(10):\n var_3 = 10000 * var_5 + 1000 * var_6 + 100 * var_7 + 10 * var_6 + var_5\n if var_1 <= var_3 <= var_2:\n var_4 += 1\nprint(var_4)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n if str(var_4) == \"\".join(reversed(str(var_4))):\n var_3 += 1\nprint(var_3)\n```", "output": "SLOWER 4.9018", "pair_id": "python_p03416_pair0024_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 29.8943} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_4 = int(eval(input()))\nvar_2 = list(map(int, input().split()))\n\n\ndef func_1(var_1, var_8, var_3):\n if var_8 == var_4:\n var_9 = 1\n for var_5 in var_3:\n var_9 *= var_5\n return 1 if var_9 % 2 == 0 else 0\n var_6 = var_3.copy()\n var_6.append(var_1[var_8] - 1)\n var_5 = var_3.copy()\n var_5.append(var_1[var_8])\n var_7 = var_3.copy()\n var_7.append(var_1[var_8] + 1)\n return (\n func_1(var_1, var_8 + 1, var_6)\n + func_1(var_1, var_8 + 1, var_5)\n + func_1(var_1, var_8 + 1, var_7)\n )\n\n\nprint((func_1(var_2, 0, [])))\n```\n\n=== Code B (Modified) ===\n```python\nfrom itertools import product\n\nvar_6 = int(eval(input()))\nvar_1 = list(map(int, input().split()))\nvar_5 = 0\nfor var_2 in product((-1, 0, 1), repeat=var_6):\n var_7 = 1\n for var_3, var_4 in zip(var_1, var_2):\n var_7 *= var_3 + var_4\n if var_7 % 2 == 0:\n var_5 += 1\nprint(var_5)\n```", "output": "SLOWER 1.7458", "pair_id": "python_p03568_pair0012_reversed", "problem_id": "p03568", "language": "python", "direction": "reversed", "speedup_ratio": 3.3539} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = list(reversed(list(str(var_4))))\n if var_5 == list(str(var_4)):\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_4 = {}\nvar_5 = 0\nfor var_6 in range(10000, 100000):\n var_3 = list(str(var_6))\n if var_3 == list(reversed(var_3)):\n var_5 += 1\n var_4[var_6] = var_5\nvar_1, var_2 = list(map(int, input().split()))\nprint((var_4[var_2] - var_4[var_1 - 1] if var_1 > 10000 else var_4[var_2]))\n```", "output": "SLOWER 1.9167", "pair_id": "python_p03416_pair0164_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 3.7755} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\n\nvar_5 = sys.stdin.readline\nif __name__ == \"__main__\":\n var_1, var_3 = var_5().split()\n var_2 = int(var_1)\n var_4 = round(float(var_3) * 100)\n print((var_2 * var_4 // 100))\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\nimport math\nfrom collections import defaultdict\nfrom bisect import bisect_left, bisect_right\n\nsys.setrecursionlimit(10**7)\n\n\ndef func_4():\n return sys.stdin.readline()[:-1]\n\n\nvar_4 = 10**9 + 7\n\n\ndef func_1():\n return int(eval(func_4()))\n\n\ndef func_2():\n return list(map(int, func_4().split()))\n\n\ndef func_3(var_6, var_3):\n if var_6 <= 0:\n return [[] for _ in range(var_3)]\n elif var_3 == 1:\n return [func_1() for _ in range(var_6)]\n else:\n var_5 = [func_2() for _ in range(var_6)]\n return list(map(list, list(zip(*var_5))))\n\n\nvar_1, var_2 = list(map(str, func_4().split()))\nvar_1 = int(var_1)\nvar_2 = 100 * int(var_2[0]) + 10 * int(var_2[2]) + int(var_2[3])\nprint((var_1 * var_2 // 100))\n```", "output": "SLOWER 2.0389", "pair_id": "python_p02659_pair0047_reversed", "problem_id": "p02659", "language": "python", "direction": "reversed", "speedup_ratio": 4.1093} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n if list(str(var_4)) == list(reversed(str(var_4))):\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_6 = str(var_4)\n var_5 = var_6[::-1]\n if var_6 == var_5:\n var_3 += 1\nprint(var_3)\n```", "output": "FASTER 1.15", "pair_id": "python_p03416_pair0136_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 2.2191} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\n\nvar_8 = sys.stdin.readline\nvar_9 = int(eval(var_8()))\nvar_6 = []\nfor var_7 in range(var_9 - 1):\n var_1, var_3 = list(map(int, var_8().split()))\n var_6.append([var_1 - 1, var_3 - 1, var_7])\nvar_6.sort()\nvar_13 = [0] * (var_9)\nvar_2 = [0] * (var_9 - 1)\nvar_10 = 1\nvar_11 = 0\nfor var_5 in var_6:\n _from, var_12, var_7 = var_5\n if _from != var_11:\n var_10 = 1\n if var_13[_from] == var_10:\n var_10 += 1\n var_2[var_7] = var_10\n var_13[var_12] = var_10\n var_10 += 1\n var_11 = _from\nprint((max(var_2)))\nfor var_4 in var_2:\n print(var_4)\n```\n\n=== Code B (Modified) ===\n```python\nimport copy\n\nvar_8 = int(eval(input()))\nvar_10 = set([var_6 for var_6 in range(1, 10**5)])\nvar_5 = []\nvar_11 = {}\nvar_9 = []\nfor var_6 in range(var_8 - 1):\n var_1, var_2 = list(map(int, input().split(\" \")))\n var_5.append([var_1, var_2])\n var_11.setdefault(var_1, []).append(var_2)\n var_9.append([])\nvar_9.append([])\nvar_9.append([])\nvar_7 = 0\nfor var_12 in range(1, var_8 + 1):\n var_14 = var_11.get(var_12, [])\n var_3 = 1\n for var_13 in var_14:\n if var_3 in var_9[var_12]:\n var_3 += 1\n else:\n pass\n var_9[var_13].append(var_3)\n if var_3 >= var_7:\n var_7 = var_3\n var_3 += 1\nprint(var_7)\nfor var_4 in var_5:\n print((var_9[var_4[1]][0]))\n```", "output": "SLOWER 4.8454", "pair_id": "python_p02850_pair0021_reversed", "problem_id": "p02850", "language": "python", "direction": "reversed", "speedup_ratio": 28.7486} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport copy\n\nvar_8 = int(eval(input()))\nvar_10 = set([var_6 for var_6 in range(1, 10**5)])\nvar_5 = []\nvar_11 = {}\nvar_9 = []\nfor var_6 in range(var_8 - 1):\n var_1, var_2 = list(map(int, input().split(\" \")))\n var_5.append([var_1, var_2])\n var_11.setdefault(var_1, []).append(var_2)\n var_9.append([])\nvar_9.append([])\nvar_9.append([])\nvar_7 = 0\nfor var_12 in range(1, var_8 + 1):\n var_14 = var_11.get(var_12, [])\n var_3 = 1\n for var_13 in var_14:\n if var_3 in var_9[var_12]:\n var_3 += 1\n else:\n pass\n var_9[var_13].append(var_3)\n if var_3 >= var_7:\n var_7 = var_3\n var_3 += 1\nprint(var_7)\nfor var_4 in var_5:\n print((var_9[var_4[1]][0]))\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\nfrom collections import deque\nimport numpy as np\n\n\ndef func_1():\n var_7 = int(sys.stdin.readline().rstrip())\n var_3 = np.array(sys.stdin.read().split(), dtype=np.int64).reshape(-1, 2)\n var_1 = [[] for _ in range(var_7 + 1)]\n for var_2, var_4 in var_3:\n var_1[var_2].append(var_4)\n var_1[var_4].append(var_2)\n var_9 = np.zeros(var_7 + 1, dtype=np.int64)\n var_6 = np.zeros(var_7 + 1, dtype=np.int64)\n var_10 = deque([1])\n while var_10:\n var_11 = var_10.popleft()\n var_8 = var_6[var_11]\n var_5 = 1\n for var_12 in var_1[var_11]:\n if var_12 == var_9[var_11]:\n continue\n var_9[var_12] = var_11\n if var_5 == var_8:\n var_5 += 1\n var_6[var_12] = var_5\n var_10.append(var_12)\n var_5 += 1\n print((np.amax(var_6)))\n for var_2, var_4 in var_3:\n if var_2 == var_9[var_4]:\n print((var_6[var_4]))\n else:\n print((var_6[var_2]))\n\n\nif __name__ == \"__main__\":\n func_1()\n```", "output": "FASTER 4.2049", "pair_id": "python_p02850_pair0018_forward", "problem_id": "p02850", "language": "python", "direction": "forward", "speedup_ratio": 18.4421} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_4 = int(eval(input()))\nvar_1 = list(map(int, input().split()))\nvar_3 = 1\nfor var_2 in var_1:\n var_3 *= 2 if var_2 % 2 == 0 else 1\nprint((3**var_4 - var_3))\n```\n\n=== Code B (Modified) ===\n```python\nvar_4 = int(eval(input()))\nvar_2 = list(map(int, input().split()))\n\n\ndef func_1(var_1, var_8, var_3):\n if var_8 == var_4:\n var_9 = 1\n for var_5 in var_3:\n var_9 *= var_5\n return 1 if var_9 % 2 == 0 else 0\n var_6 = var_3.copy()\n var_6.append(var_1[var_8] - 1)\n var_5 = var_3.copy()\n var_5.append(var_1[var_8])\n var_7 = var_3.copy()\n var_7.append(var_1[var_8] + 1)\n return (\n func_1(var_1, var_8 + 1, var_6)\n + func_1(var_1, var_8 + 1, var_5)\n + func_1(var_1, var_8 + 1, var_7)\n )\n\n\nprint((func_1(var_2, 0, [])))\n```", "output": "SLOWER 8.4066", "pair_id": "python_p03568_pair0047_reversed", "problem_id": "p03568", "language": "python", "direction": "reversed", "speedup_ratio": 339.3399} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport math\nimport string\n\n\ndef func_5():\n return list(map(int, input().split()))\n\n\ndef func_4(var_7, var_8):\n return math.factorial(var_7) // (\n math.factorial(var_7 - var_8) * math.factorial(var_8)\n )\n\n\ndef func_3(var_10):\n var_9 = []\n for var_5 in var_10:\n if not (var_5 in var_9):\n var_9.append(var_5)\n return len(var_10) != len(var_9)\n\n\ndef func_1(var_7):\n func_1 = []\n for var_4 in range(1, var_7 + 1):\n if var_7 % var_4 == 0:\n func_1.append(var_4)\n return func_1\n\n\nvar_2 = [-1, -1, -1, 0, 0, 1, 1, 1]\nvar_3 = [-1, 0, 1, -1, 1, -1, 0, 1]\nvar_7 = int(eval(input()))\nvar_1 = func_5()\n\n\ndef func_2(var_6):\n if len(var_6) == var_7:\n for var_4 in range(len(var_6)):\n if var_6[var_4] % 2 == 0:\n return 1\n return 0\n return (\n func_2(var_6 + [var_1[len(var_6)]])\n + func_2(var_6 + [var_1[len(var_6)] - 1])\n + func_2(var_6 + [var_1[len(var_6)] + 1])\n )\n\n\nprint((func_2([])))\n```\n\n=== Code B (Modified) ===\n```python\nvar_6 = int(eval(input()))\nvar_2 = list(map(int, input().split()))\nfrom itertools import product\n\nvar_5 = [-1, 0, 1]\nvar_3 = 0\nfor var_7 in product(var_5, repeat=var_6):\n var_1 = []\n for var_4 in range(var_6):\n var_1.append(var_7[var_4] + var_2[var_4])\n if any(var_8 % 2 == 0 for var_8 in var_1):\n var_3 += 1\nprint(var_3)\n```", "output": "SLOWER 2.1906", "pair_id": "python_p03568_pair0032_reversed", "problem_id": "p03568", "language": "python", "direction": "reversed", "speedup_ratio": 4.5649} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n if str(var_4) == \"\".join(reversed(str(var_4))):\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_4 = {}\nvar_5 = 0\nfor var_6 in range(10000, 100000):\n var_3 = list(str(var_6))\n if var_3 == list(reversed(var_3)):\n var_5 += 1\n var_4[var_6] = var_5\nvar_1, var_2 = list(map(int, input().split()))\nprint((var_4[var_2] - var_4[var_1 - 1] if var_1 > 10000 else var_4[var_2]))\n```", "output": "SLOWER 2.4974", "pair_id": "python_p03416_pair0233_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 5.6465} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\n\nvar_8 = sys.stdin.readline\n\n\ndef func_1():\n var_2 = int(eval(var_8()))\n var_1 = [int(var_8().replace(\" \", \"\"), 2) for _ in range(var_2)]\n var_3 = [list(map(int, var_8().split())) for _ in range(var_2)]\n var_4 = -(10**7) * var_2\n for var_7 in range(1, 1 << 10):\n var_10 = 0\n for var_9, var_6 in enumerate(var_1):\n var_5 = bin(var_7 & var_6).count(\"1\")\n var_10 += var_3[var_9][var_5]\n var_4 = max(var_4, var_10)\n print(var_4)\n\n\nif __name__ == \"__main__\":\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nfrom sys import stdin\n\n\ndef func_1():\n\n var_13 = stdin.readline\n var_2 = int(var_13())\n var_1 = []\n for var_6 in range(var_2):\n var_5 = list(map(int, var_13().split()))\n var_1.append(var_5)\n var_3 = []\n for var_6 in range(var_2):\n var_12 = list(map(int, var_13().split()))\n var_3.append(var_12)\n var_9 = -float(\"inf\")\n for var_6 in range(1 << 10):\n if var_6 == 0:\n continue\n else:\n var_11 = []\n for var_7 in range(10):\n if (var_6 >> var_7) & 1:\n var_11.append(var_7)\n var_10 = [0] * 10\n for var_7 in var_11:\n var_10[var_7] = 1\n var_14 = 0\n for var_7 in range(var_2):\n var_4 = 0\n for var_8 in range(10):\n if var_10[var_8] == 1 and var_1[var_7][var_8] == 1:\n var_4 += 1\n var_14 += var_3[var_7][var_4]\n var_9 = max(var_14, var_9)\n print(var_9)\n\n\nif __name__ == \"__main__\":\n func_1()\n```", "output": "SLOWER 1.9473", "pair_id": "python_p03503_pair0045_reversed", "problem_id": "p03503", "language": "python", "direction": "reversed", "speedup_ratio": 3.8565} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_6 = int(eval(input()))\nvar_2 = list(map(int, input().split()))\nfrom itertools import product\n\nvar_5 = [-1, 0, 1]\nvar_3 = 0\nfor var_7 in product(var_5, repeat=var_6):\n var_1 = []\n for var_4 in range(var_6):\n var_1.append(var_7[var_4] + var_2[var_4])\n if any(var_8 % 2 == 0 for var_8 in var_1):\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_2 = int(eval(input()))\n(*var_1,) = list(map(int, input().split()))\nvar_5 = 0\nfor var_3 in var_1:\n if var_3 % 2 == 0:\n var_5 += 1\nvar_4 = 3**var_2 - 2**var_5\nprint(var_4)\n```", "output": "FASTER 9.836", "pair_id": "python_p03568_pair0045_forward", "problem_id": "p03568", "language": "python", "direction": "forward", "speedup_ratio": 913.9804} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nfrom collections import defaultdict\n\nvar_8 = int(eval(input()))\nvar_1 = tuple(map(int, input().split()))\nvar_3 = True\nif var_8 % 3 == 0:\n var_5 = defaultdict(int)\n for var_2 in var_1:\n var_5[var_2] += 1\n var_7 = var_8 // 3\n var_10 = []\n for var_9, var_4 in list(var_5.items()):\n if var_4 % var_7 != 0:\n var_3 = False\n break\n else:\n for _ in range(var_4 // var_7):\n var_10.append(var_9)\n else:\n if any(\n var_10[(0 + var_6) % 3] ^ var_10[(1 + var_6) % 3] != var_10[(2 + var_6) % 3]\n for var_6 in range(3)\n ):\n var_3 = False\nelse:\n if any(var_2 != 0 for var_2 in var_1):\n var_3 = False\nprint((\"Yes\" if var_3 else \"No\"))\n```\n\n=== Code B (Modified) ===\n```python\n_, var_1 = open(0)\nvar_1, *var_2 = list(map(int, var_1.split()))\nfor var_2 in var_2:\n var_1 ^= var_2\nprint((\"YNeos\"[var_1 > 0 :: 2]))\n```", "output": "FASTER 1.2494", "pair_id": "python_p02975_pair0007_forward", "problem_id": "p02975", "language": "python", "direction": "forward", "speedup_ratio": 2.3774} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport math\nimport string\n\n\ndef func_4():\n return list(map(int, input().split()))\n\n\ndef func_3(var_6, var_7):\n return math.factorial(var_6) // (\n math.factorial(var_6 - var_7) * math.factorial(var_7)\n )\n\n\ndef func_2(var_9):\n var_8 = []\n for var_5 in var_9:\n if not (var_5 in var_8):\n var_8.append(var_5)\n return len(var_9) != len(var_8)\n\n\ndef func_1(var_6):\n func_1 = []\n for var_4 in range(1, var_6 + 1):\n if var_6 % var_4 == 0:\n func_1.append(var_4)\n return func_1\n\n\nvar_2 = [-1, -1, -1, 0, 0, 1, 1, 1]\nvar_3 = [-1, 0, 1, -1, 1, -1, 0, 1]\nvar_6 = int(eval(input()))\nvar_1 = func_4()\nvar_10 = 1\nfor var_4 in range(len(var_1)):\n if var_1[var_4] % 2 == 0:\n var_10 *= 2\n else:\n var_10 *= 1\nprint((3 ** len(var_1) - var_10))\n```\n\n=== Code B (Modified) ===\n```python\nvar_2 = int(eval(input()))\nvar_1 = list(map(int, input().split()))\nvar_4 = 1\nfor var_3 in range(var_2):\n if var_1[var_3] % 2 == 0:\n var_4 *= 2\nprint((3**var_2 - var_4))\n```", "output": "FASTER 1.7077", "pair_id": "python_p03568_pair0048_forward", "problem_id": "p03568", "language": "python", "direction": "forward", "speedup_ratio": 3.2664} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_4 = {}\nvar_5 = 0\nfor var_6 in range(10000, 100000):\n var_3 = list(str(var_6))\n if var_3 == list(reversed(var_3)):\n var_5 += 1\n var_4[var_6] = var_5\nvar_1, var_2 = list(map(int, input().split()))\nprint((var_4[var_2] - var_4[var_1 - 1] if var_1 > 10000 else var_4[var_2]))\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = list(str(var_4))\n if var_5 == list(reversed(var_5)):\n var_3 += 1\nprint(var_3)\n```", "output": "FASTER 2.3414", "pair_id": "python_p03416_pair0198_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 5.068} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\ndef func_1():\n from sys import setrecursionlimit, stdin\n from os import environ\n from collections import defaultdict, deque, Counter\n from math import ceil, floor, gcd\n from itertools import accumulate, combinations, combinations_with_replacement\n\n setrecursionlimit(10**6)\n var_7 = (\n (lambda *var_11: print(*var_11))\n if \"TERM_PROGRAM\" in environ\n else lambda *var_12: 0\n )\n var_8 = lambda: stdin.readline().rstrip()\n var_3 = lambda: list(map(int, var_8().split()))\n var_1 = lambda: int(var_8())\n var_4 = 10**9 + 7\n var_2 = 10**9 + 10\n var_9, var_10 = var_8().split()\n var_5 = int(var_9)\n var_6 = int(float(var_10) * 100 + 0.5)\n print(var_5 * var_6 // 100)\n\n\nfunc_1()\n```\n\n=== Code B (Modified) ===\n```python\nimport decimal\n\n\ndef func_1():\n var_1, var_2 = list(map(decimal.Decimal, input().split()))\n print((var_1 * var_2 // 1))\n\n\nif __name__ == \"__main__\":\n func_1()\n```", "output": "FASTER 1.7718", "pair_id": "python_p02659_pair0052_forward", "problem_id": "p02659", "language": "python", "direction": "forward", "speedup_ratio": 3.4148} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nfrom collections import deque\n\nvar_9 = int(eval(input()))\nvar_6 = {var_7: dict() for var_7 in range(var_9)}\nvar_2 = [0] * (var_9 - 1)\nvar_4 = [0] * (var_9 - 1)\nfor var_7 in range(var_9 - 1):\n var_1, var_3 = list(map(int, input().split()))\n var_2[var_7] = var_1 - 1\n var_4[var_7] = var_3 - 1\n var_6[var_1 - 1][var_3 - 1] = -1\n var_6[var_3 - 1][var_1 - 1] = -1\nvar_8 = max([len(var_6[var_1]) for var_1 in range(var_9)])\nvar_13 = [-1] * var_9\nvar_13[0] = var_8 - 1\n\nvar_12 = deque([0])\nwhile len(var_12) > 0:\n var_10 = var_12.popleft()\n var_5 = var_13[var_10]\n for var_11 in list(var_6[var_10].keys()):\n if var_13[var_11] != -1:\n continue\n var_5 += 1\n var_5 %= var_8\n\n var_6[var_10][var_11] = var_5\n var_6[var_11][var_10] = var_5\n var_13[var_11] = var_5\n var_12.append(var_11)\nprint(var_8)\nfor var_7 in range(var_9 - 1):\n print((var_6[var_2[var_7]][var_4[var_7]] + 1))\n```\n\n=== Code B (Modified) ===\n```python\nimport copy\n\nvar_8 = int(eval(input()))\nvar_10 = set([var_6 for var_6 in range(1, 10**5)])\nvar_5 = []\nvar_11 = {}\nvar_9 = []\nfor var_6 in range(var_8 - 1):\n var_1, var_2 = list(map(int, input().split(\" \")))\n var_5.append([var_1, var_2])\n var_11.setdefault(var_1, []).append(var_2)\n var_9.append([])\nvar_9.append([])\nvar_9.append([])\nvar_7 = 0\nfor var_12 in range(1, var_8 + 1):\n var_14 = var_11.get(var_12, [])\n var_3 = 1\n for var_13 in var_14:\n if var_3 in var_9[var_12]:\n var_3 += 1\n else:\n pass\n var_9[var_13].append(var_3)\n if var_3 >= var_7:\n var_7 = var_3\n var_3 += 1\nprint(var_7)\nfor var_4 in var_5:\n print((var_9[var_4[1]][0]))\n```", "output": "SLOWER 4.1649", "pair_id": "python_p02850_pair0027_reversed", "problem_id": "p02850", "language": "python", "direction": "reversed", "speedup_ratio": 17.9377} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1 = list(map(int, input().split()))\nvar_2 = 0\nfor var_3 in range(var_1[0], var_1[1] + 1):\n var_4 = str(var_3)\n if var_4[0] == var_4[4] and var_4[1] == var_4[3]:\n var_2 += 1\nprint(var_2)\n```\n\n=== Code B (Modified) ===\n```python\nvar_10 = []\nvar_10 = input().rstrip().split(\" \")\nvar_1 = int(var_10[0])\nvar_3 = int(var_10[1])\nvar_2 = 0\nvar_6 = var_1\nwhile var_6 <= var_3:\n var_4 = var_6 // 10000\n var_5 = (var_6 - var_4 * 10000) // 1000\n var_7 = var_6 // 100\n var_8 = (var_6 - var_7 * 100) // 10\n var_9 = var_6 % 10\n if (var_4 == var_9) and (var_5 == var_8):\n var_2 += 1\n var_6 += 1\nprint(var_2)\n```", "output": "SLOWER 1.0978", "pair_id": "python_p03416_pair0096_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 2.1403} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\nimport itertools\n\n\ndef func_2(var_4):\n return eval(\"0b\" + var_4)\n\n\ndef func_1():\n var_4 = int(sys.stdin.readline().rstrip())\n var_9 = [\n func_2(\"\".join(str(var_10) for var_10 in sys.stdin.readline().split()))\n for _ in range(var_4)\n ]\n var_8 = [\n [int(var_10) for var_10 in sys.stdin.readline().split()] for _ in range(var_4)\n ]\n var_3 = -(10**10)\n for var_6 in itertools.product(\"01\", repeat=10):\n var_6 = func_2(\"\".join(var_6))\n if var_6 == 0:\n continue\n var_7 = 0\n for var_2 in range(var_4):\n var_1 = var_9[var_2]\n var_5 = bin(var_1 & var_6).count(\"1\")\n var_7 += var_8[var_2][var_5]\n var_3 = max(var_3, var_7)\n print(var_3)\n\n\nif __name__ == \"__main__\":\n\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\n\nvar_7 = sys.stdin.readline\nfrom itertools import combinations\n\n\ndef func_3(var_10):\n for _ in range(var_10):\n yield list(map(int, var_7().split()))\n\n\ndef func_1(var_9, var_5, var_11):\n var_3 = sum(1 if var_5[var_8] == 1 else 0 for var_8 in var_9)\n return var_11[var_3]\n\n\ndef func_2():\n var_10 = int(eval(var_7()))\n var_1 = list(func_3(var_10))\n var_2 = list(func_3(var_10))\n for var_6 in range(1, 11):\n for var_4 in combinations(list(range(10)), var_6):\n yield sum(\n func_1(var_4, var_5, var_11) for var_5, var_11 in zip(var_1, var_2)\n )\n\n\nprint((max(func_2())))\n```", "output": "FASTER 1.4756", "pair_id": "python_p03503_pair0034_forward", "problem_id": "p03503", "language": "python", "direction": "forward", "speedup_ratio": 2.7809} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\n\nsys.setrecursionlimit(2147483647)\nvar_2 = float(\"inf\")\nvar_3 = 10**9 + 7\nvar_10 = lambda: sys.stdin.readline().rstrip()\n\n\ndef func_1():\n var_11, var_4 = list(map(int, var_10().split()))\n var_1 = [tuple(map(int, var_10().split())) for _ in range(var_11)]\n var_1.sort()\n var_8 = [0] * var_4\n var_6 = -var_2\n for var_9 in range(var_11):\n var_5, var_7 = var_1[var_9]\n var_12 = var_8[:]\n for var_13 in range(var_4):\n if var_13 + var_5 < var_4:\n var_12[var_13 + var_5] = max(\n var_12[var_13 + var_5], var_8[var_13] + var_7\n )\n else:\n var_6 = max(var_6, var_8[var_13] + var_7)\n var_8 = var_12\n print((max(var_6, max(var_8))))\n\n\nfunc_1()\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\nfrom collections import deque\n\nvar_1 = int(10e10)\nvar_2 = -var_1\nvar_12 = 1000000007\nsys.setrecursionlimit(1000000)\n\n\ndef func_2():\n return list(map(int, input().split()))\n\n\ndef func_4():\n return input().split()\n\n\ndef func_1():\n return int(sys.stdin.readline())\n\n\ndef func_3():\n return eval(input())\n\n\nvar_3, var_4 = func_2()\nvar_6 = [func_2() for var_10 in range(var_3)]\nvar_6.sort()\nvar_7 = 0\nvar_9 = [[0] * var_4 for var_10 in range(var_3 + 1)]\nfor var_10 in range(1, var_3 + 1):\n var_5, var_8 = var_6[var_10 - 1]\n for var_11 in range(var_4):\n if 0 <= var_11 - var_5 < var_4:\n var_9[var_10][var_11] = max(\n var_9[var_10 - 1][var_11], var_9[var_10 - 1][var_11 - var_5] + var_8\n )\n else:\n var_9[var_10][var_11] = var_9[var_10 - 1][var_11]\n else:\n var_7 = max(var_7, var_9[var_10 - 1][-1] + var_8)\nprint(var_7)\n```", "output": "SLOWER 1.125", "pair_id": "python_p02863_pair0055_reversed", "problem_id": "p02863", "language": "python", "direction": "reversed", "speedup_ratio": 2.181} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\nimport math\nfrom collections import defaultdict\nfrom bisect import bisect_left, bisect_right\n\nsys.setrecursionlimit(10**7)\n\n\ndef func_4():\n return sys.stdin.readline()[:-1]\n\n\nvar_4 = 10**9 + 7\n\n\ndef func_1():\n return int(eval(func_4()))\n\n\ndef func_2():\n return list(map(int, func_4().split()))\n\n\ndef func_3(var_6, var_3):\n if var_6 <= 0:\n return [[] for _ in range(var_3)]\n elif var_3 == 1:\n return [func_1() for _ in range(var_6)]\n else:\n var_5 = [func_2() for _ in range(var_6)]\n return list(map(list, list(zip(*var_5))))\n\n\nfrom decimal import getcontext, Decimal\n\ngetcontext().prec = 28\nvar_1, var_2 = list(map(str, func_4().split()))\nvar_1 = int(var_1)\nvar_2 = Decimal(var_2)\nprint((int(var_1 * var_2)))\n```\n\n=== Code B (Modified) ===\n```python\nimport decimal\n\nvar_1, var_2 = (decimal.Decimal(var_3) for var_3 in input().split())\nprint((int(var_1 * var_2)))\n```", "output": "FASTER 2.232", "pair_id": "python_p02659_pair0015_forward", "problem_id": "p02659", "language": "python", "direction": "forward", "speedup_ratio": 4.6978} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_5 in range(var_1, var_2 + 1):\n var_3 = str(var_5)\n if var_3[0] == var_3[-1] and var_3[1] == var_3[-2]:\n var_4 += 1\nprint(var_4)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n if list(str(var_4)) == list(reversed(str(var_4))):\n var_3 += 1\nprint(var_3)\n```", "output": "SLOWER 1.492", "pair_id": "python_p03416_pair0234_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 2.8127} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\ndef func_1():\n var_2 = int(input())\n var_1 = [int(var_6) for var_6 in input().split()]\n if var_2 == 1:\n return print(1 if var_1[0] % 2 == 0 else 2)\n var_3 = 0\n var_5 = (-1, 0, 1)\n from itertools import product\n\n for var_6 in product(range(3), repeat=var_2):\n var_4 = 1\n for var_7 in range(var_2):\n var_4 *= var_1[var_7] + var_5[var_6[var_7]]\n if var_4 % 2 == 0:\n var_3 += 1\n print(var_3)\n\n\nif __name__ == \"__main__\":\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nimport numpy as np\nfrom itertools import product\n\nvar_6 = int(eval(input()))\nvar_2 = list(map(int, input().split()))\nvar_2 = np.array(var_2)\nvar_5 = [-1, 0, 1]\nvar_3 = 0\nfor var_7 in product(var_5, repeat=var_6):\n var_7 = np.array(var_7)\n var_1 = var_2 + var_7\n var_4 = var_1.cumprod()\n if var_4[-1] % 2 == 0:\n var_3 += 1\nprint(var_3)\n```", "output": "SLOWER 1.466", "pair_id": "python_p03568_pair0040_reversed", "problem_id": "p03568", "language": "python", "direction": "reversed", "speedup_ratio": 2.7626} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nfrom sys import stdin\n\n\ndef func_1():\n\n var_11 = stdin.readline\n var_2 = int(var_11())\n var_1 = []\n for var_6 in range(var_2):\n var_5 = int(\"\".join(var_11().strip().split(\" \")), 2)\n var_1.append(var_5)\n var_3 = []\n for var_6 in range(var_2):\n var_10 = list(map(int, var_11().split()))\n var_3.append(var_10)\n var_8 = float(\"-inf\")\n for var_9 in range(1, 1 << 10):\n var_12 = 0\n for var_7 in range(var_2):\n var_4 = bin(var_9 & var_1[var_7]).count(\"1\")\n var_12 += var_3[var_7][var_4]\n var_8 = max(var_12, var_8)\n print(var_8)\n\n\nif __name__ == \"__main__\":\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\nimport numpy as np\n\nvar_5 = sys.stdin.readline\n\nvar_7 = int(eval(var_5()))\n\nvar_1 = [var_5().replace(\" \", \"\") for var_4 in range(var_7)]\n\nvar_8 = [list(map(int, var_5().split())) for var_4 in range(var_7)]\n\n\nvar_12 = -999999999999999\n\nfor var_4 in range(1, 1024):\n\n var_3 = format(var_4, \"010b\")\n\n var_10 = 0\n for var_2, var_9 in zip(var_1, var_8):\n\n var_11 = 0\n for var_6 in range(10):\n\n if var_2[var_6] == \"1\" and var_3[var_6] == \"1\":\n\n var_11 += 1\n\n var_10 += var_9[var_11]\n if var_10 > var_12:\n\n var_12 = var_10\nprint(var_12)\n```", "output": "SLOWER 2.8805", "pair_id": "python_p03503_pair0010_reversed", "problem_id": "p03503", "language": "python", "direction": "reversed", "speedup_ratio": 7.3642} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_2 = int(eval(input()))\nvar_1 = list(map(int, input().split()))\nvar_4 = 1\nfor var_3 in range(var_2):\n if var_1[var_3] % 2 == 0:\n var_4 *= 2\nprint((3**var_2 - var_4))\n```\n\n=== Code B (Modified) ===\n```python\nimport math\nimport string\n\n\ndef func_4():\n return list(map(int, input().split()))\n\n\ndef func_3(var_6, var_7):\n return math.factorial(var_6) // (\n math.factorial(var_6 - var_7) * math.factorial(var_7)\n )\n\n\ndef func_2(var_9):\n var_8 = []\n for var_5 in var_9:\n if not (var_5 in var_8):\n var_8.append(var_5)\n return len(var_9) != len(var_8)\n\n\ndef func_1(var_6):\n func_1 = []\n for var_4 in range(1, var_6 + 1):\n if var_6 % var_4 == 0:\n func_1.append(var_4)\n return func_1\n\n\nvar_2 = [-1, -1, -1, 0, 0, 1, 1, 1]\nvar_3 = [-1, 0, 1, -1, 1, -1, 0, 1]\nvar_6 = int(eval(input()))\nvar_1 = func_4()\nvar_10 = 1\nfor var_4 in range(len(var_1)):\n if var_1[var_4] % 2 == 0:\n var_10 *= 2\n else:\n var_10 *= 1\nprint((3 ** len(var_1) - var_10))\n```", "output": "SLOWER 1.7077", "pair_id": "python_p03568_pair0048_reversed", "problem_id": "p03568", "language": "python", "direction": "reversed", "speedup_ratio": 3.2664} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_5 = 0\nif var_5 == 0:\n var_8 = int(eval(input()))\n var_2 = []\n for var_4 in range(var_8):\n var_3 = list(map(int, input().split()))\n var_2.append(var_3)\n var_9 = []\n for var_4 in range(var_8):\n var_10 = list(map(int, input().split()))\n var_9.append(var_10)\nelif var_5 == 1:\n var_8 = 1\n var_2 = [[1, 1, 0, 1, 0, 0, 0, 1, 0, 1]]\n var_9 = [[3, 4, 5, 6, 7, 8, 9, -2, -3, 4, -2]]\nelif var_5 == 2:\n var_8 = 2\n var_2 = [[1, 1, 1, 1, 1, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 1, 1, 1, 1, 1]]\n var_9 = [\n [0, -2, -2, -2, -2, -2, -1, -1, -1, -1, -1],\n [0, -2, -2, -2, -2, -2, -1, -1, -1, -1, -1],\n ]\nelif var_5 == 3:\n var_8 = 3\n var_2 = [\n [1, 1, 1, 1, 1, 1, 0, 0, 1, 1],\n [0, 1, 0, 1, 1, 1, 1, 0, 1, 0],\n [1, 0, 1, 1, 0, 1, 0, 1, 0, 1],\n ]\n var_9 = [\n [-8, 6, -2, -8, -8, 4, 8, 7, -6, 2, 2],\n [-9, 2, 0, 1, 7, -5, 0, -2, -6, 5, 5],\n [6, -6, 7, -9, 6, -5, 8, 0, -9, -7, -7],\n ]\nimport itertools\n\nvar_13 = -(10**11)\nfor var_4 in itertools.product([0, 1], repeat=10):\n var_11 = list(var_4)\n var_12 = 0\n if sum(var_11) != 0:\n for var_7 in range(var_8):\n var_1 = 0\n for var_6 in range(10):\n var_1 = var_1 + var_11[var_6] * var_2[var_7][var_6]\n var_12 = var_12 + var_9[var_7][var_1]\n\n var_13 = max(var_12, var_13)\nprint(var_13)\n```\n\n=== Code B (Modified) ===\n```python\nfrom sys import stdin\n\n\ndef func_1():\n\n var_11 = stdin.readline\n var_2 = int(var_11())\n var_1 = []\n for var_6 in range(var_2):\n var_5 = int(\"\".join(var_11().strip().split(\" \")), 2)\n var_1.append(var_5)\n var_3 = []\n for var_6 in range(var_2):\n var_10 = list(map(int, var_11().split()))\n var_3.append(var_10)\n var_8 = float(\"-inf\")\n for var_9 in range(1, 1 << 10):\n var_12 = 0\n for var_7 in range(var_2):\n var_4 = bin(var_9 & var_1[var_7]).count(\"1\")\n var_12 += var_3[var_7][var_4]\n var_8 = max(var_12, var_8)\n print(var_8)\n\n\nif __name__ == \"__main__\":\n func_1()\n```", "output": "FASTER 3.2735", "pair_id": "python_p03503_pair0041_forward", "problem_id": "p03503", "language": "python", "direction": "forward", "speedup_ratio": 9.6696} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\ndef func_1():\n from sys import setrecursionlimit, stdin\n from os import environ\n from collections import defaultdict, deque, Counter\n from math import ceil, floor, gcd\n from itertools import accumulate, combinations, combinations_with_replacement\n\n setrecursionlimit(10**6)\n var_7 = (\n (lambda *var_11: print(*var_11))\n if \"TERM_PROGRAM\" in environ\n else lambda *var_12: 0\n )\n var_8 = lambda: stdin.readline().rstrip()\n var_3 = lambda: list(map(int, var_8().split()))\n var_1 = lambda: int(var_8())\n var_4 = 10**9 + 7\n var_2 = 10**9 + 10\n var_9, var_10 = var_8().split()\n var_5 = int(var_9)\n var_10 = var_10.split(\".\")\n var_6 = int(var_10[0]) * 100\n if len(var_10) == 2:\n var_6 += int(var_10[1])\n print(var_5 * var_6 // 100)\n\n\nfunc_1()\n```\n\n=== Code B (Modified) ===\n```python\nimport math\nfrom decimal import Decimal\n\nvar_1, var_2 = list(map(Decimal, input().split()))\nprint((math.floor(var_1 * var_2)))\n```", "output": "FASTER 2.3027", "pair_id": "python_p02659_pair0060_forward", "problem_id": "p02659", "language": "python", "direction": "forward", "speedup_ratio": 4.9339} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = [\n var_3 for var_3 in map(str, list(range(var_1, var_2 + 1))) if var_3 == var_3[::-1]\n]\nprint((len(var_4)))\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = list(reversed(list(str(var_4))))\n if var_5 == list(str(var_4)):\n var_3 += 1\nprint(var_3)\n```", "output": "SLOWER 2.3555", "pair_id": "python_p03416_pair0194_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 5.1178} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nfrom sys import stdin\n\n\ndef func_1():\n\n var_13 = stdin.readline\n var_2 = int(var_13())\n var_1 = []\n for var_6 in range(var_2):\n var_5 = list(map(int, var_13().split()))\n var_1.append(var_5)\n var_3 = []\n for var_6 in range(var_2):\n var_12 = list(map(int, var_13().split()))\n var_3.append(var_12)\n var_9 = -float(\"inf\")\n for var_6 in range(1 << 10):\n if var_6 == 0:\n continue\n else:\n var_11 = []\n for var_7 in range(10):\n if (var_6 >> var_7) & 1:\n var_11.append(var_7)\n var_10 = [0] * 10\n for var_7 in var_11:\n var_10[var_7] = 1\n var_14 = 0\n for var_7 in range(var_2):\n var_4 = 0\n for var_8 in range(10):\n if var_10[var_8] == 1 and var_1[var_7][var_8] == 1:\n var_4 += 1\n var_14 += var_3[var_7][var_4]\n var_9 = max(var_14, var_9)\n print(var_9)\n\n\nif __name__ == \"__main__\":\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\n\nvar_8 = sys.stdin.readline\n\n\ndef func_1():\n var_2 = int(eval(var_8()))\n var_1 = [int(var_8().replace(\" \", \"\"), 2) for _ in range(var_2)]\n var_3 = [list(map(int, var_8().split())) for _ in range(var_2)]\n var_4 = -(10**7) * var_2\n for var_7 in range(1, 1 << 10):\n var_10 = 0\n for var_9, var_6 in enumerate(var_1):\n var_5 = bin(var_7 & var_6).count(\"1\")\n var_10 += var_3[var_9][var_5]\n var_4 = max(var_4, var_10)\n print(var_4)\n\n\nif __name__ == \"__main__\":\n func_1()\n```", "output": "FASTER 1.9473", "pair_id": "python_p03503_pair0045_forward", "problem_id": "p03503", "language": "python", "direction": "forward", "speedup_ratio": 3.8565} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_6, var_7 = list(map(int, input().split()))\nvar_1 = [list(map(int, input().split())) for _ in range(var_6)]\nvar_1.sort()\nvar_3 = [(6007) * [0] for _ in range(var_6 + 1)]\nvar_3[0][0] = 0\nvar_2 = 0\nfor var_4 in range(var_6):\n for var_5 in range(6007):\n var_3[var_4 + 1][var_5] = max(var_3[var_4 + 1][var_5], var_3[var_4][var_5])\n if var_5 < var_7:\n var_3[var_4 + 1][var_5 + var_1[var_4][0]] = max(\n var_3[var_4][var_5] + var_1[var_4][1],\n var_3[var_4][var_5 + var_1[var_4][0]],\n )\n var_2 = max(var_2, var_3[var_4 + 1][var_5])\nprint(var_2)\n```\n\n=== Code B (Modified) ===\n```python\nfrom collections import Counter, defaultdict, deque\nfrom heapq import heappop, heappush, heapify\nimport sys, bisect, math, itertools, fractions, pprint\n\nsys.setrecursionlimit(10**8)\nvar_6 = 10**9 + 7\nvar_1 = float(\"inf\")\n\n\ndef func_1():\n return int(sys.stdin.readline())\n\n\ndef func_2():\n return list(map(int, sys.stdin.readline().split()))\n\n\nvar_7, var_9 = func_2()\nvar_13 = [func_2() for _ in range(var_7)]\nvar_13.sort(key=lambda var_14: var_14[1], reverse=True)\nvar_8 = 0\nvar_10 = min(var_7, 5)\nfor var_3 in range(var_10):\n var_2 = [[0] * (var_9 + 5) for _ in range(var_7 + 5)]\n for var_4 in range(var_7):\n var_12, var_11 = var_13[var_4]\n for var_5 in range(var_9):\n if var_5 < var_12 or var_3 == var_4:\n var_2[var_4 + 1][var_5] = var_2[var_4][var_5]\n else:\n var_2[var_4 + 1][var_5] = max(\n var_2[var_4][var_5], var_2[var_4][var_5 - var_12] + var_11\n )\n\n var_8 = max(var_2[var_7][var_9 - 1] + var_13[var_3][1], var_8)\nprint(var_8)\n```", "output": "FASTER 4.0812", "pair_id": "python_p02863_pair0060_forward", "problem_id": "p02863", "language": "python", "direction": "forward", "speedup_ratio": 16.9267} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_6 = str(var_4)\n var_5 = var_6[::-1]\n if var_6 == var_5:\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = [0] * (var_2 + 1)\nfor var_3 in range(1, var_2 + 1):\n if str(var_3) == str(var_3)[::-1]:\n var_4[var_3] = var_4[var_3 - 1] + 1\n else:\n var_4[var_3] = var_4[var_3 - 1]\nprint((var_4[var_2] - var_4[var_1 - 1]))\n```", "output": "SLOWER 1.6919", "pair_id": "python_p03416_pair0235_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 3.2308} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = [0] * (var_2 + 1)\nfor var_3 in range(1, var_2 + 1):\n if str(var_3) == str(var_3)[::-1]:\n var_4[var_3] = var_4[var_3 - 1] + 1\n else:\n var_4[var_3] = var_4[var_3 - 1]\nprint((var_4[var_2] - var_4[var_1 - 1]))\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_6 = str(var_4)\n var_5 = var_6[::-1]\n if var_6 == var_5:\n var_3 += 1\nprint(var_3)\n```", "output": "FASTER 1.6919", "pair_id": "python_p03416_pair0235_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 3.2308} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\nfrom collections import deque\n\nvar_13 = sys.stdin.readline\nvar_2 = int(eval(var_13()))\nvar_5 = [[] for _ in range(var_2)]\nvar_3 = [-1] * var_2\nfor var_12 in range(var_2 - 1):\n var_6, var_8 = list(map(int, var_13().split()))\n var_5[var_6 - 1].append((var_12, var_8 - 1))\n\n\nvar_4 = deque([(0, -1)])\nvar_1 = [-1] * (var_2 - 1)\nvar_11 = 0\nwhile var_4:\n var_14, var_10 = var_4.pop()\n var_9 = 1\n for var_12, var_15 in var_5[var_14]:\n if var_9 == var_10:\n var_9 += 1\n var_1[var_12] = var_9\n var_4.appendleft((var_15, var_9))\n var_9 += 1\n var_11 = max(var_11, var_9 - 1)\nprint(var_11)\nfor var_7 in var_1:\n print(var_7)\n```\n\n=== Code B (Modified) ===\n```python\nfrom collections import deque\n\n\ndef func_2(var_9, var_2, var_4):\n\n var_6 = {var_7: dict() for var_7 in range(var_9)}\n for var_7 in range(var_9 - 1):\n var_1, var_3 = var_2[var_7] - 1, var_4[var_7] - 1\n var_6[var_1][var_3] = -1\n var_6[var_3][var_1] = -1\n var_8 = max([len(var_6[var_1]) for var_1 in range(var_9)])\n var_14 = [-1] * var_9\n var_14[0] = var_8 - 1\n\n var_12 = deque([0])\n while len(var_12) > 0:\n var_10 = var_12.popleft()\n var_5 = var_14[var_10]\n for var_11 in list(var_6[var_10].keys()):\n if var_14[var_11] != -1:\n continue\n var_5 += 1\n var_5 %= var_8\n\n var_6[var_10][var_11] = var_5\n var_6[var_11][var_10] = var_5\n var_14[var_11] = var_5\n var_12.append(var_11)\n var_13 = [0] * (var_9 - 1)\n for var_7 in range(var_9 - 1):\n var_13[var_7] = var_6[var_2[var_7] - 1][var_4[var_7] - 1] + 1\n return var_8, var_13\n\n\ndef func_1():\n var_9 = int(eval(input()))\n var_2 = [0] * (var_9 - 1)\n var_4 = [0] * (var_9 - 1)\n for var_7 in range(var_9 - 1):\n var_1, var_3 = list(map(int, input().split()))\n var_2[var_7] = var_1\n var_4[var_7] = var_3\n var_8, var_13 = func_2(var_9, var_2, var_4)\n print(var_8)\n for var_7 in range(var_9 - 1):\n print((var_13[var_7]))\n\n\ndef func_3():\n print((func_2(3, [1, 2], [2, 3])))\n print((func_2(8, [1, 2, 2, 2, 4, 5, 6], [2, 3, 4, 5, 7, 6, 8])))\n\n\nif __name__ == \"__main__\":\n\n func_1()\n```", "output": "SLOWER 1.0324", "pair_id": "python_p02850_pair0032_reversed", "problem_id": "p02850", "language": "python", "direction": "reversed", "speedup_ratio": 2.0454} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = [\n var_3 for var_3 in map(str, list(range(var_1, var_2 + 1))) if var_3 == var_3[::-1]\n]\nprint((len(var_4)))\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().rstrip().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = list(map(int, list(str(var_4))))\n if var_5[0] == var_5[4] and var_5[1] == var_5[3]:\n var_3 += 1\nprint(var_3)\n```", "output": "SLOWER 2.3816", "pair_id": "python_p03416_pair0226_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 5.2111} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = str(var_4)\n if var_5[0] == var_5[4] and var_5[1] == var_5[3]:\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_10 = []\nvar_10 = input().rstrip().split(\" \")\nvar_1 = int(var_10[0])\nvar_3 = int(var_10[1])\nvar_2 = 0\nvar_6 = var_1\nwhile var_6 <= var_3:\n var_4 = var_6 // 10000\n var_5 = (var_6 - var_4 * 10000) // 1000\n var_7 = var_6 // 100\n var_8 = (var_6 - var_7 * 100) // 10\n var_9 = var_6 % 10\n if (var_4 == var_9) and (var_5 == var_8):\n var_2 += 1\n var_6 += 1\nprint(var_2)\n```", "output": "SLOWER 1.0752", "pair_id": "python_p03416_pair0236_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 2.107} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_6 = str(var_4)\n var_5 = var_6[::-1]\n if var_6 == var_5:\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().rstrip().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = list(map(int, list(str(var_4))))\n if var_5[0] == var_5[4] and var_5[1] == var_5[3]:\n var_3 += 1\nprint(var_3)\n```", "output": "SLOWER 1.4326", "pair_id": "python_p03416_pair0237_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 2.6994} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\nfrom operator import itemgetter\nfrom heapq import heapify, heappop, heappush\n\nvar_1 = int(10e15)\nvar_2 = -var_1\nvar_11 = 1000000007\nsys.setrecursionlimit(1000000)\n\n\ndef func_2():\n return list(map(int, input().split()))\n\n\ndef func_4():\n return input().split()\n\n\ndef func_1():\n return int(sys.stdin.readline())\n\n\ndef func_3():\n return eval(input())\n\n\nvar_3, var_4 = func_2()\nvar_5 = [func_2() for var_9 in range(var_3)]\nvar_5.sort(key=itemgetter(0))\n\nvar_8 = [[0] * (var_4 + 1 + 3000 + 1) for _ in range(var_3 + 1)]\nvar_6 = 0\nfor var_9 in range(var_3):\n for var_10 in range(var_4 + 1 + 3000 + 1):\n var_12, var_7 = var_5[var_9]\n if 0 <= var_10 - var_12 < var_4:\n var_8[var_9 + 1][var_10] = max(\n var_8[var_9][var_10], var_8[var_9][var_10 - var_12] + var_7\n )\n else:\n var_8[var_9 + 1][var_10] = var_8[var_9][var_10]\n var_6 = max(var_6, var_8[var_9 + 1][var_10])\nprint(var_6)\n```\n\n=== Code B (Modified) ===\n```python\nimport bisect\nimport sys\n\nsys.setrecursionlimit(10**6)\nvar_17 = sys.stdout.write\nvar_7 = lambda *var_15: print(*var_15) if var_1 else 0\nvar_1 = True\n\n\ndef func_1(var_10=sys.stdin.readline):\n var_12 = lambda: var_10().rstrip()\n var_3 = lambda: list(map(int, var_12().split()))\n var_2 = lambda: int(var_12())\n var_4 = lambda var_18: [var_3() for _ in range(var_18)]\n var_14, var_16 = var_3()\n var_5 = var_4(var_14)\n var_8 = [[0] * var_16 for _ in range(var_14)]\n for var_11 in range(1, var_14):\n for var_13 in range(1, var_16):\n if var_13 < var_5[var_11 - 1][0]:\n var_8[var_11][var_13] = var_8[var_11 - 1][var_13]\n else:\n var_8[var_11][var_13] = max(\n var_8[var_11 - 1][var_13],\n var_8[var_11 - 1][var_13 - var_5[var_11 - 1][0]]\n + var_5[var_11 - 1][1],\n )\n var_9 = [[0] * var_16 for _ in range(var_14)]\n for var_11 in range(1, var_14):\n for var_13 in range(1, var_16):\n if var_13 < var_5[var_14 - var_11][0]:\n var_9[var_11][var_13] = var_9[var_11 - 1][var_13]\n else:\n var_9[var_11][var_13] = max(\n var_9[var_11 - 1][var_13],\n var_9[var_11 - 1][var_13 - var_5[var_14 - var_11][0]]\n + var_5[var_14 - var_11][1],\n )\n var_6 = 0\n for var_11 in range(var_14):\n for var_13 in range(var_16 - 1):\n var_6 = max(\n var_6,\n var_8[var_11][var_13]\n + var_9[var_14 - var_11 - 1][var_16 - var_13 - 1]\n + var_5[var_11][1],\n )\n print(var_6)\n\n\nif __name__ == \"__main__\":\n func_1()\n```", "output": "FASTER 4.4124", "pair_id": "python_p02863_pair0012_forward", "problem_id": "p02863", "language": "python", "direction": "forward", "speedup_ratio": 21.2943} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\ndef func_1():\n var_2 = int(input())\n var_1 = [int(var_6) for var_6 in input().split()]\n if var_2 == 1:\n return print(1 if var_1[0] % 2 == 0 else 2)\n var_3 = 0\n var_5 = (-1, 0, 1)\n from itertools import product\n\n for var_6 in product(range(3), repeat=var_2):\n var_4 = 1\n for var_7 in range(var_2):\n var_4 *= var_1[var_7] + var_5[var_6[var_7]]\n if var_4 % 2 == 0:\n var_3 += 1\n print(var_3)\n\n\nif __name__ == \"__main__\":\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nvar_4 = int(eval(input()))\nvar_1 = list(map(int, input().split()))\nvar_3 = 1\nfor var_2 in var_1:\n var_3 *= 2 if var_2 % 2 == 0 else 1\nprint((3**var_4 - var_3))\n```", "output": "FASTER 8.6824", "pair_id": "python_p03568_pair0029_forward", "problem_id": "p03568", "language": "python", "direction": "forward", "speedup_ratio": 410.8374} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_5 in range(var_1, var_2 + 1):\n var_3 = str(var_5)\n if var_3[0] == var_3[-1] and var_3[1] == var_3[-2]:\n var_4 += 1\nprint(var_4)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_3 in range(var_1, var_2 + 1):\n var_5 = list(str(var_3))\n var_6 = list(reversed(var_5))\n if var_5 == var_6:\n var_4 += 1\nprint(var_4)\n```", "output": "SLOWER 1.4002", "pair_id": "python_p03416_pair0190_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 2.6394} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nfrom sys import stdin\n\n\ndef func_1():\n\n var_13 = stdin.readline\n var_2 = int(var_13())\n var_1 = []\n for var_6 in range(var_2):\n var_5 = list(map(int, var_13().split()))\n var_1.append(var_5)\n var_3 = []\n for var_6 in range(var_2):\n var_12 = list(map(int, var_13().split()))\n var_3.append(var_12)\n var_9 = -float(\"inf\")\n for var_6 in range(1 << 10):\n if var_6 == 0:\n continue\n else:\n var_11 = []\n for var_7 in range(10):\n if (var_6 >> var_7) & 1:\n var_11.append(var_7)\n var_10 = [0] * 10\n for var_7 in var_11:\n var_10[var_7] = 1\n var_14 = 0\n for var_7 in range(var_2):\n var_4 = 0\n for var_8 in range(10):\n if var_10[var_8] == 1 and var_1[var_7][var_8] == 1:\n var_4 += 1\n var_14 += var_3[var_7][var_4]\n var_9 = max(var_14, var_9)\n print(var_9)\n\n\nif __name__ == \"__main__\":\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nfrom sys import stdin\n\n\ndef func_1():\n\n var_11 = stdin.readline\n var_2 = int(var_11())\n var_1 = []\n for var_6 in range(var_2):\n var_5 = int(\"\".join(var_11().strip().split(\" \")), 2)\n var_1.append(var_5)\n var_3 = []\n for var_6 in range(var_2):\n var_10 = list(map(int, var_11().split()))\n var_3.append(var_10)\n var_8 = float(\"-inf\")\n for var_9 in range(1, 1 << 10):\n var_12 = 0\n for var_7 in range(var_2):\n var_4 = bin(var_9 & var_1[var_7]).count(\"1\")\n var_12 += var_3[var_7][var_4]\n var_8 = max(var_12, var_8)\n print(var_8)\n\n\nif __name__ == \"__main__\":\n func_1()\n```", "output": "FASTER 2.0856", "pair_id": "python_p03503_pair0046_forward", "problem_id": "p03503", "language": "python", "direction": "forward", "speedup_ratio": 4.2446} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\ndef func_1(var_3):\n var_4 = int(var_3)\n for var_1 in range(var_4, 2 * var_4):\n for var_2 in range(2, int(var_1**0.5)):\n if var_1 % var_2 == 0:\n break\n else:\n return str(var_1)\n\n\nif __name__ == \"__main__\":\n import sys\n\n print((func_1(sys.stdin.read().strip())))\n```\n\n=== Code B (Modified) ===\n```python\nimport bisect, copy, heapq, math, sys\nfrom collections import *\nfrom functools import lru_cache\nfrom itertools import accumulate, combinations, permutations, product\n\n\ndef func_2():\n return sys.stdin.readline()[:-1]\n\n\ndef func_4(var_8):\n return [0] + list(accumulate(var_8))\n\n\ndef func_1(var_1, var_4):\n return -(-var_1 // var_4)\n\n\nsys.setrecursionlimit(5000000)\nvar_9 = pow(10, 9) + 7\nvar_2 = [chr(ord(\"a\") + var_6) for var_6 in range(26)]\nvar_5 = [[1, 0], [0, 1], [-1, 0], [0, -1]]\nvar_11 = int(eval(func_2()))\n\n\ndef func_3(var_10):\n if var_10 == 1:\n return False\n for var_7 in range(2, int(math.sqrt(var_10)) + 1):\n if var_10 % var_7 == 0:\n return False\n return True\n\n\nvar_3 = var_11\nwhile not func_3(var_3):\n var_3 += 1\nprint(var_3)\n```", "output": "SLOWER 1.4975", "pair_id": "python_p02819_pair0002_reversed", "problem_id": "p02819", "language": "python", "direction": "reversed", "speedup_ratio": 2.8236} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().rstrip().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = list(map(int, list(str(var_4))))\n if var_5[0] == var_5[4] and var_5[1] == var_5[3]:\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_4 = str(var_4)\n if var_4 == var_4[::-1]:\n var_3 += 1\nprint(var_3)\n```", "output": "FASTER 1.536", "pair_id": "python_p03416_pair0049_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 2.8999} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\nimport numpy as np\n\nvar_6 = int(eval(input()))\n\nvar_1 = [input().replace(\" \", \"\") for var_4 in range(var_6)]\n\nvar_7 = [list(map(int, input().split())) for var_4 in range(var_6)]\nvar_11 = -999999999999999\nfor var_4 in range(1, 1024):\n var_3 = format(var_4, \"010b\")\n var_9 = 0\n for var_2, var_8 in zip(var_1, var_7):\n var_10 = 0\n for var_5 in range(10):\n if var_2[var_5] == \"1\" and var_3[var_5] == \"1\":\n var_10 += 1\n var_9 += var_8[var_10]\n if var_9 > var_11:\n if var_9 == 0:\n print((str(var_4)))\n break\n var_11 = var_9\nprint(var_11)\n```\n\n=== Code B (Modified) ===\n```python\nfrom sys import stdin\n\n\ndef func_1():\n\n var_11 = stdin.readline\n var_2 = int(var_11())\n var_1 = []\n for var_6 in range(var_2):\n var_5 = int(\"\".join(var_11().strip().split(\" \")), 2)\n var_1.append(var_5)\n var_3 = []\n for var_6 in range(var_2):\n var_10 = list(map(int, var_11().split()))\n var_3.append(var_10)\n var_8 = float(\"-inf\")\n for var_9 in range(1, 1 << 10):\n var_12 = 0\n for var_7 in range(var_2):\n var_4 = bin(var_9 & var_1[var_7]).count(\"1\")\n var_12 += var_3[var_7][var_4]\n var_8 = max(var_12, var_8)\n print(var_8)\n\n\nif __name__ == \"__main__\":\n func_1()\n```", "output": "FASTER 2.3748", "pair_id": "python_p03503_pair0037_forward", "problem_id": "p03503", "language": "python", "direction": "forward", "speedup_ratio": 5.1868} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_6 = int(eval(input()))\nimport sys\n\nsys.setrecursionlimit(10**6)\nvar_11 = [[] for _ in range(var_6)]\nfor var_4 in range(var_6 - 1):\n var_1, var_2 = list(map(int, input().split()))\n var_11[var_1 - 1].append((var_2 - 1, var_4))\n var_11[var_2 - 1].append((var_1 - 1, var_4))\nvar_5 = [0] * (var_6 - 1)\n\n\ndef func_1(var_8, var_10, var_9):\n var_3 = 1\n for var_7, var_4 in var_11[var_8]:\n if var_7 == var_9:\n continue\n if var_3 == var_10:\n var_3 += 1\n var_5[var_4] = var_3\n func_1(var_7, var_3, var_8)\n var_3 += 1\n\n\nfunc_1(0, -1, -1)\nprint((max(var_5)))\nfor var_4 in var_5:\n print(var_4)\n```\n\n=== Code B (Modified) ===\n```python\nvar_11 = int(eval(input()))\nvar_12 = {var_8: [] for var_8 in range(1, var_11 + 1)}\nvar_19 = [False for var_8 in range(var_11 + 1)]\nvar_16 = []\nfor _ in range(var_11 - 1):\n var_2, var_3 = list(map(int, input().split()))\n var_12[var_2].append(var_3)\n var_12[var_3].append(var_2)\n var_16.append((var_2, var_3))\nvar_9 = var_16[0][0]\nvar_19[var_9] = True\nvar_6 = []\nvar_7 = []\nvar_14 = {var_8: {} for var_8 in range(1, var_11 + 1)}\nvar_10 = [0 for var_8 in range(var_11 + 1)]\n\nvar_4 = 1\nfor var_5 in var_12[var_9]:\n var_19[var_5] = True\n var_14[var_9][var_5] = var_4\n var_14[var_5][var_9] = var_4\n var_10[var_5] = var_4\n var_4 += 1\n var_6.append(var_5)\nwhile var_6:\n for var_15 in var_6:\n var_13 = 1\n for var_5 in var_12[var_15]:\n if var_19[var_5] == False:\n var_19[var_5] = True\n if var_13 != var_10[var_15]:\n var_14[var_15][var_5] = var_13\n var_14[var_5][var_15] = var_13\n var_10[var_5] = var_13\n var_13 += 1\n var_7.append(var_5)\n else:\n var_13 += 1\n var_14[var_15][var_5] = var_13\n var_14[var_5][var_15] = var_13\n var_10[var_5] = var_13\n var_13 += 1\n var_7.append(var_5)\n if var_7:\n var_6 = var_7\n var_7 = []\n else:\n var_6 = []\n var_7 = []\nvar_1 = 0\nfor var_8 in range(1, var_11 + 1):\n var_1 = max(var_1, len(var_12[var_8]))\nprint(var_1)\nfor var_8 in range(var_11 - 1):\n var_17, var_18 = var_16[var_8][0], var_16[var_8][1]\n print((var_14[var_17][var_18]))\n```", "output": "SLOWER 1.0322", "pair_id": "python_p02850_pair0014_reversed", "problem_id": "p02850", "language": "python", "direction": "reversed", "speedup_ratio": 2.0452} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_5 in range(10):\n for var_6 in range(10):\n for var_7 in range(10):\n var_3 = 10000 * var_5 + 1000 * var_6 + 100 * var_7 + 10 * var_6 + var_5\n if var_1 <= var_3 <= var_2:\n var_4 += 1\nprint(var_4)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().rstrip().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = list(map(int, list(str(var_4))))\n if var_5[0] == var_5[4] and var_5[1] == var_5[3]:\n var_3 += 1\nprint(var_3)\n```", "output": "SLOWER 5.5086", "pair_id": "python_p03416_pair0220_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 45.5247} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_4 = int(eval(input()))\nvar_1 = list(map(int, input().split()))\nvar_3 = 1\nfor var_2 in var_1:\n var_3 *= 2 if var_2 % 2 == 0 else 1\nprint((3**var_4 - var_3))\n```\n\n=== Code B (Modified) ===\n```python\nimport math\nimport string\n\n\ndef func_4():\n return list(map(int, input().split()))\n\n\ndef func_3(var_6, var_7):\n return math.factorial(var_6) // (\n math.factorial(var_6 - var_7) * math.factorial(var_7)\n )\n\n\ndef func_2(var_9):\n var_8 = []\n for var_5 in var_9:\n if not (var_5 in var_8):\n var_8.append(var_5)\n return len(var_9) != len(var_8)\n\n\ndef func_1(var_6):\n func_1 = []\n for var_4 in range(1, var_6 + 1):\n if var_6 % var_4 == 0:\n func_1.append(var_4)\n return func_1\n\n\nvar_2 = [-1, -1, -1, 0, 0, 1, 1, 1]\nvar_3 = [-1, 0, 1, -1, 1, -1, 0, 1]\nvar_6 = int(eval(input()))\nvar_1 = func_4()\nvar_10 = 1\nfor var_4 in range(len(var_1)):\n if var_1[var_4] % 2 == 0:\n var_10 *= 2\n else:\n var_10 *= 1\nprint((3 ** len(var_1) - var_10))\n```", "output": "SLOWER 1.8134", "pair_id": "python_p03568_pair0049_reversed", "problem_id": "p03568", "language": "python", "direction": "reversed", "speedup_ratio": 3.5147} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nfrom sys import stdin\n\n\ndef func_1():\n\n var_11 = stdin.readline\n var_2 = int(var_11())\n var_1 = []\n for var_6 in range(var_2):\n var_5 = int(\"\".join(var_11().strip().split(\" \")), 2)\n var_1.append(var_5)\n var_3 = []\n for var_6 in range(var_2):\n var_10 = list(map(int, var_11().split()))\n var_3.append(var_10)\n var_8 = float(\"-inf\")\n for var_9 in range(1, 1 << 10):\n var_12 = 0\n for var_7 in range(var_2):\n var_4 = bin(var_9 & var_1[var_7]).count(\"1\")\n var_12 += var_3[var_7][var_4]\n var_8 = max(var_12, var_8)\n print(var_8)\n\n\nif __name__ == \"__main__\":\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nfrom sys import stdin\n\n\ndef func_1():\n\n var_13 = stdin.readline\n var_2 = int(var_13())\n var_1 = []\n for var_6 in range(var_2):\n var_5 = list(map(int, var_13().split()))\n var_1.append(var_5)\n var_3 = []\n for var_6 in range(var_2):\n var_12 = list(map(int, var_13().split()))\n var_3.append(var_12)\n var_9 = -float(\"inf\")\n for var_6 in range(1 << 10):\n if var_6 == 0:\n continue\n else:\n var_11 = []\n for var_7 in range(10):\n if (var_6 >> var_7) & 1:\n var_11.append(var_7)\n var_10 = [0] * 10\n for var_7 in var_11:\n var_10[var_7] = 1\n var_14 = 0\n for var_7 in range(var_2):\n var_4 = 0\n for var_8 in range(10):\n if var_10[var_8] == 1 and var_1[var_7][var_8] == 1:\n var_4 += 1\n var_14 += var_3[var_7][var_4]\n var_9 = max(var_14, var_9)\n print(var_9)\n\n\nif __name__ == \"__main__\":\n func_1()\n```", "output": "SLOWER 2.0856", "pair_id": "python_p03503_pair0046_reversed", "problem_id": "p03503", "language": "python", "direction": "reversed", "speedup_ratio": 4.2446} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\ndef func_1():\n from sys import setrecursionlimit, stdin\n from os import environ\n from collections import defaultdict, deque, Counter\n from math import ceil, floor, gcd\n from itertools import accumulate, combinations, combinations_with_replacement\n\n setrecursionlimit(10**6)\n var_7 = (\n (lambda *var_11: print(*var_11))\n if \"TERM_PROGRAM\" in environ\n else lambda *var_12: 0\n )\n var_8 = lambda: stdin.readline().rstrip()\n var_3 = lambda: list(map(int, var_8().split()))\n var_1 = lambda: int(var_8())\n var_4 = 10**9 + 7\n var_2 = 10**9 + 10\n var_9, var_10 = var_8().split()\n var_5 = int(var_9)\n var_10 = var_10.split(\".\")\n var_6 = int(var_10[0]) * 100\n if len(var_10) == 2:\n var_6 += int(var_10[1])\n print(var_5 * var_6 // 100)\n\n\nfunc_1()\n```\n\n=== Code B (Modified) ===\n```python\nimport math\n\nvar_1, var_2 = input().split()\nvar_1 = int(var_1)\nvar_3 = int(var_2[0] + var_2[2] + var_2[3])\nprint((int(var_1 * var_3) // 100))\n```", "output": "FASTER 2.1264", "pair_id": "python_p02659_pair0061_forward", "problem_id": "p02659", "language": "python", "direction": "forward", "speedup_ratio": 4.3663} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_2 = var_2 / 0.1\nvar_3 = [var_4 + var_2 for var_4 in range(10)]\nfor var_4 in var_3:\n if int(var_4 * 0.08) == var_1:\n print((int(var_4)))\n exit()\nprint(\"-1\")\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_3 = list(map(int, input().split()))\nvar_2 = -1\nfor var_4 in range(10, 12501):\n if int(var_4 * 0.08) == var_1 and int(var_4 * 0.1) == var_3:\n var_2 = var_4\n break\nprint(var_2)\n```", "output": "SLOWER 5.3061", "pair_id": "python_p02755_pair0012_reversed", "problem_id": "p02755", "language": "python", "direction": "reversed", "speedup_ratio": 39.5622} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\nimport math\nfrom collections import defaultdict\nfrom bisect import bisect_left, bisect_right\n\nsys.setrecursionlimit(10**7)\n\n\ndef func_4():\n return sys.stdin.readline()[:-1]\n\n\nvar_4 = 10**9 + 7\n\n\ndef func_1():\n return int(eval(func_4()))\n\n\ndef func_2():\n return list(map(int, func_4().split()))\n\n\ndef func_3(var_6, var_3):\n if var_6 <= 0:\n return [[] for _ in range(var_3)]\n elif var_3 == 1:\n return [func_1() for _ in range(var_6)]\n else:\n var_5 = [func_2() for _ in range(var_6)]\n return list(map(list, list(zip(*var_5))))\n\n\nvar_1, var_2 = list(map(str, func_4().split()))\nvar_1 = int(var_1)\nvar_2 = 100 * int(var_2[0]) + 10 * int(var_2[2]) + int(var_2[3])\nprint((var_1 * var_2 // 100))\n```\n\n=== Code B (Modified) ===\n```python\nimport math\nfrom decimal import Decimal\n\nvar_1, var_2 = list(map(Decimal, input().split()))\nprint((math.floor(var_1 * var_2)))\n```", "output": "FASTER 2.455", "pair_id": "python_p02659_pair0009_forward", "problem_id": "p02659", "language": "python", "direction": "forward", "speedup_ratio": 5.4831} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\n\nvar_20 = sys.stdin.read\nvar_21 = sys.stdin.readline\nvar_22 = sys.stdin.readlines\nsys.setrecursionlimit(10**9)\nvar_2 = 1 << 60\nvar_5 = 1000000007\n\n\nvar_4 = 1000001\n\n\nclass Class_1:\n def __init__(self, var_13, var_19, var_12):\n self.l = var_13\n self.r = var_19\n self.idx = var_12\n\n\ndef func_4(var_12, var_24, var_10, var_15):\n while var_12 <= var_15:\n var_10[var_12] += var_24\n var_12 += var_12 & -var_12\n\n\ndef func_3(var_12, var_10, var_15):\n var_23 = 0\n while var_12:\n var_23 += var_10[var_12]\n var_12 -= var_12 & -var_12\n return var_23\n\n\ndef func_1(var_9, var_15, var_17, var_16):\n\n var_10 = [0] * (var_15 + 1)\n\n var_14 = [-1] * var_4\n\n var_8 = [0] * var_16\n var_18 = 0\n for var_11 in range(var_15):\n\n if var_14[var_9[var_11]] != -1:\n func_4(var_14[var_9[var_11]] + 1, -1, var_10, var_15)\n\n var_14[var_9[var_11]] = var_11\n func_4(var_11 + 1, 1, var_10, var_15)\n\n while var_18 < var_16 and var_17[var_18].r == var_11:\n var_8[var_17[var_18].idx] = func_3(\n var_17[var_18].r + 1, var_10, var_15\n ) - func_3(var_17[var_18].l, var_10, var_15)\n var_18 += 1\n\n for var_11 in range(var_16):\n print((var_8[var_11]))\n\n\ndef func_2():\n var_6, var_7 = list(map(int, var_21().split()))\n var_1 = list(map(int, var_21().split()))\n (*var_3,) = list(map(int, var_20().split()))\n var_17 = [0] * var_7\n for var_11, (var_13, var_19) in enumerate(zip(*[iter(var_3)] * 2)):\n var_17[var_11] = Class_1(var_13 - 1, var_19 - 1, var_11)\n var_17.sort(key=lambda var_25: var_25.r)\n func_1(var_1, var_6, var_17, var_7)\n return\n\n\nif __name__ == \"__main__\":\n func_2()\n```\n\n=== Code B (Modified) ===\n```python\nvar_4 = 19\nvar_7 = [0] * (2 ** (var_4 + 1) - 1)\n\n\ndef func_1(var_12, var_17):\n var_11 = 2**var_4 + var_12 - 1\n while var_11 >= 0:\n var_7[var_11] += var_17\n var_11 = (var_11 - 1) // 2\n\n\ndef func_2(var_8, var_9):\n var_13 = var_8 + (1 << var_4)\n var_15 = var_9 + (1 << var_4)\n var_16 = 0\n while var_13 < var_15:\n if var_13 % 2:\n var_16 += var_7[var_13 - 1]\n var_13 += 1\n if var_15 % 2:\n var_15 -= 1\n var_16 += var_7[var_15 - 1]\n var_13 >>= 1\n var_15 >>= 1\n return var_16\n\n\nvar_3, var_5 = map(int, input().split())\nvar_2 = [int(var_8) - 1 for var_8 in input().split()]\nvar_6 = [[] for _ in range(var_3)]\nfor var_11 in range(var_5):\n var_13, var_15 = map(int, input().split())\n var_6[var_15 - 1].append((var_13 - 1, var_11))\nvar_14 = [-1] * var_3\nvar_1 = [-1] * var_5\nfunc_1(1, var_3)\nfor var_15 in range(var_3):\n var_10 = var_2[var_15]\n func_1(var_14[var_10] + 2, -1)\n func_1(var_15 + 2, 1)\n var_14[var_10] = var_15\n for var_13, var_11 in var_6[var_15]:\n var_1[var_11] = func_2(var_13 + 2, 1 << var_4)\nprint(*var_1, sep=\"\\n\")\n```", "output": "FASTER 1.8145", "pair_id": "python_p02599_pair0006_forward", "problem_id": "p02599", "language": "python", "direction": "forward", "speedup_ratio": 3.5173} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nfrom collections import Counter, defaultdict, deque\nfrom heapq import heappop, heappush, heapify\nimport sys, bisect, math, itertools, fractions, pprint\n\nsys.setrecursionlimit(10**8)\nvar_6 = 10**9 + 7\nvar_1 = float(\"inf\")\n\n\ndef func_1():\n return int(sys.stdin.readline())\n\n\ndef func_2():\n return list(map(int, sys.stdin.readline().split()))\n\n\nvar_7, var_9 = func_2()\nvar_13 = [func_2() for _ in range(var_7)]\nvar_13.sort(key=lambda var_14: var_14[1], reverse=True)\nvar_8 = 0\nvar_10 = min(var_7, 5)\nfor var_3 in range(var_10):\n var_2 = [[0] * (var_9 + 5) for _ in range(var_7 + 5)]\n for var_4 in range(var_7):\n var_12, var_11 = var_13[var_4]\n for var_5 in range(var_9):\n if var_5 < var_12 or var_3 == var_4:\n var_2[var_4 + 1][var_5] = var_2[var_4][var_5]\n else:\n var_2[var_4 + 1][var_5] = max(\n var_2[var_4][var_5], var_2[var_4][var_5 - var_12] + var_11\n )\n\n var_8 = max(var_2[var_7][var_9 - 1] + var_13[var_3][1], var_8)\nprint(var_8)\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\n\nvar_10 = sys.stdin.readline\nvar_2, var_3 = list(map(int, var_10().split()))\nvar_1 = [list(map(int, var_10().split())) for _ in range(var_2)]\nvar_8 = [[0 for _ in range(var_2 + 1)] for _ in range(var_3 + 1)]\n\nvar_13 = [[0 for _ in range(var_2 + 1)] for _ in range(var_3 + 1)]\nfor var_11 in range(var_2):\n var_4, var_6 = var_1[var_11]\n for var_15 in range(var_3):\n if var_4 > var_15:\n var_8[var_15][var_11 + 1] = var_8[var_15][var_11]\n var_13[var_15][var_11 + 1] = var_15\n else:\n if var_6 + var_8[var_15 - var_4][var_11] >= var_8[var_15][var_11]:\n var_8[var_15][var_11 + 1] = var_8[var_15 - var_4][var_11] + var_6\n var_13[var_15][var_11 + 1] = var_15 - var_4\n else:\n var_8[var_15][var_11 + 1] = var_8[var_15][var_11]\n var_13[var_15][var_11 + 1] = var_15\nvar_5 = var_8[var_3 - 1][var_2]\nvar_14 = [False] * var_2\nvar_7 = var_3 - 1\nfor var_9 in reversed(list(range(var_2))):\n if var_13[var_7][var_9 + 1] == var_7 - var_1[var_9][0]:\n var_14[var_9] = True\n var_7 = var_13[var_7][var_9 + 1]\nvar_12 = 0\nfor var_9 in range(var_2):\n if not var_14[var_9] and var_1[var_9][1] > var_12:\n var_12 = var_1[var_9][1]\nprint((var_5 + var_12))\n```", "output": "FASTER 1.1545", "pair_id": "python_p02863_pair0042_forward", "problem_id": "p02863", "language": "python", "direction": "forward", "speedup_ratio": 2.226} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_6 in range(var_1, var_2 + 1):\n var_3 = str(var_6)\n var_5 = True\n for var_7 in range(len(var_3) // 2):\n if var_3[var_7] != var_3[-var_7 - 1] and var_5:\n var_5 = not var_5\n if var_5:\n var_4 += 1\nprint(var_4)\n```\n\n=== Code B (Modified) ===\n```python\nvar_4 = {}\nvar_5 = 0\nfor var_6 in range(10000, 100000):\n var_3 = list(str(var_6))\n if var_3 == list(reversed(var_3)):\n var_5 += 1\n var_4[var_6] = var_5\nvar_1, var_2 = list(map(int, input().split()))\nprint((var_4[var_2] - var_4[var_1 - 1] if var_1 > 10000 else var_4[var_2]))\n```", "output": "SLOWER 2.1137", "pair_id": "python_p03416_pair0023_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 4.3279} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport math\nimport string\n\n\ndef func_5():\n return list(map(int, input().split()))\n\n\ndef func_4(var_7, var_8):\n return math.factorial(var_7) // (\n math.factorial(var_7 - var_8) * math.factorial(var_8)\n )\n\n\ndef func_3(var_10):\n var_9 = []\n for var_5 in var_10:\n if not (var_5 in var_9):\n var_9.append(var_5)\n return len(var_10) != len(var_9)\n\n\ndef func_1(var_7):\n func_1 = []\n for var_4 in range(1, var_7 + 1):\n if var_7 % var_4 == 0:\n func_1.append(var_4)\n return func_1\n\n\nvar_2 = [-1, -1, -1, 0, 0, 1, 1, 1]\nvar_3 = [-1, 0, 1, -1, 1, -1, 0, 1]\nvar_7 = int(eval(input()))\nvar_1 = func_5()\n\n\ndef func_2(var_6):\n if len(var_6) == var_7:\n for var_4 in range(len(var_6)):\n if var_6[var_4] % 2 == 0:\n return 1\n return 0\n return (\n func_2(var_6 + [var_1[len(var_6)]])\n + func_2(var_6 + [var_1[len(var_6)] - 1])\n + func_2(var_6 + [var_1[len(var_6)] + 1])\n )\n\n\nprint((func_2([])))\n```\n\n=== Code B (Modified) ===\n```python\nfrom itertools import product\n\nvar_6 = int(eval(input()))\nvar_1 = list(map(int, input().split()))\nvar_5 = 0\nfor var_2 in product((-1, 0, 1), repeat=var_6):\n var_7 = 1\n for var_3, var_4 in zip(var_1, var_2):\n var_7 *= var_3 + var_4\n if var_7 % 2 == 0:\n var_5 += 1\nprint(var_5)\n```", "output": "SLOWER 2.3865", "pair_id": "python_p03568_pair0050_reversed", "problem_id": "p03568", "language": "python", "direction": "reversed", "speedup_ratio": 5.2288} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_8 in range(var_1, var_2 + 1):\n var_7 = str(var_8)\n var_6 = len(var_7)\n var_4 = True\n for var_5 in range(var_6 // 2):\n if var_7[var_5] != var_7[var_6 - 1 - var_5]:\n var_4 = False\n break\n if var_4:\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_3 = list(map(int, input().split()))\nvar_2 = 0\nfor var_5 in range(var_3 + 1)[var_1:]:\n if len(str(var_5)) % 2 == 0:\n var_6 = list(str(var_5))[: len(str(var_5)) // 2]\n var_7 = list(reversed(list(str(var_5))[len(str(var_5)) // 2 :]))\n if var_6 == var_7:\n var_2 += 1\n else:\n var_8 = list(str(var_5))[: len(str(var_5)) // 2 + 1]\n var_4 = list(reversed(list(str(var_5))[len(str(var_5)) // 2 :]))\n if var_8 == var_4:\n var_2 += 1\nprint(var_2)\n```", "output": "SLOWER 1.3483", "pair_id": "python_p03416_pair0179_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 2.5461} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_4 = str(var_4)\n if var_4[0] == var_4[-1] and var_4[1] == var_4[-2]:\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_4, var_3 = list(map(int, input().split()))\nvar_1 = 0\nfor var_2 in range(var_4, var_3 + 1):\n if str(var_2)[0] + str(var_2)[1] == str(var_2)[-1] + str(var_2)[-2]:\n var_1 += 1\nprint(var_1)\n```", "output": "SLOWER 1.5248", "pair_id": "python_p03416_pair0033_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 2.8775} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\n\n\ndef func_1(var_5):\n var_4 = 0\n for var_3 in range(1, var_5 + 1):\n if str(var_3) == str(var_3)[::-1]:\n var_4 += 1\n return var_4\n\n\nprint((func_1(var_2) - func_1(var_1 - 1)))\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_5 in range(10):\n for var_6 in range(10):\n for var_7 in range(10):\n var_3 = 10000 * var_5 + 1000 * var_6 + 100 * var_7 + 10 * var_6 + var_5\n if var_1 <= var_3 <= var_2:\n var_4 += 1\nprint(var_4)\n```", "output": "FASTER 5.4162", "pair_id": "python_p03416_pair0210_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 42.7005} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_5 in range(10):\n for var_6 in range(10):\n for var_7 in range(10):\n var_3 = 10000 * var_5 + 1000 * var_6 + 100 * var_7 + 10 * var_6 + var_5\n if var_1 <= var_3 <= var_2:\n var_4 += 1\nprint(var_4)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = str(var_4)\n if var_5[0] == var_5[4] and var_5[1] == var_5[3]:\n var_3 += 1\nprint(var_3)\n```", "output": "SLOWER 3.5594", "pair_id": "python_p03416_pair0178_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 11.7893} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nfrom sys import stdin\n\nvar_6 = lambda: list(map(int, stdin.readline().split()))\nvar_5 = lambda: list(map(int, stdin.readline().split()))\nvar_1, var_3 = var_6()\nvar_2 = 0\nfor var_4 in range(var_1, var_3 + 1):\n var_7 = str(var_4)\n if var_7 == var_7[::-1]:\n var_2 += 1\nprint(var_2)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = list(reversed(list(str(var_4))))\n if var_5 == list(str(var_4)):\n var_3 += 1\nprint(var_3)\n```", "output": "SLOWER 1.6385", "pair_id": "python_p03416_pair0017_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 3.1135} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().strip().split(\" \")))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n if str(var_4) == str(var_4)[::-1]:\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_3 = list(map(int, input().split()))\nvar_2 = 0\nfor var_5 in range(var_3 + 1)[var_1:]:\n if len(str(var_5)) % 2 == 0:\n var_6 = list(str(var_5))[: len(str(var_5)) // 2]\n var_7 = list(reversed(list(str(var_5))[len(str(var_5)) // 2 :]))\n if var_6 == var_7:\n var_2 += 1\n else:\n var_8 = list(str(var_5))[: len(str(var_5)) // 2 + 1]\n var_4 = list(reversed(list(str(var_5))[len(str(var_5)) // 2 :]))\n if var_8 == var_4:\n var_2 += 1\nprint(var_2)\n```", "output": "SLOWER 2.1673", "pair_id": "python_p03416_pair0238_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 4.4917} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nfrom sys import stdin\n\n\ndef func_1():\n\n var_9 = stdin.readline\n var_8, var_10 = list(map(int, var_9().split()))\n var_7 = [list(map(int, var_9().split())) for _ in range(var_8)]\n var_7.sort()\n var_1 = [0] * var_8\n var_2 = [0] * var_8\n for var_4 in range(var_8):\n var_1[var_4], var_2[var_4] = var_7[var_4][0], var_7[var_4][1]\n\n var_5 = -float(\"inf\")\n var_3 = [[var_5] * (var_10 + 1) for _ in range(var_8 + 1)]\n var_3[0][0] = 0\n for var_4 in range(var_8):\n for var_6 in range(var_10 + 1):\n\n if var_6 != var_10:\n var_3[var_4 + 1][min(var_10, var_6 + var_1[var_4])] = max(\n var_3[var_4 + 1][min(var_10, var_6 + var_1[var_4])],\n var_3[var_4][var_6] + var_2[var_4],\n )\n\n var_3[var_4 + 1][var_6] = max(var_3[var_4 + 1][var_6], var_3[var_4][var_6])\n print((max(var_3[var_8])))\n\n\nif __name__ == \"__main__\":\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nfrom collections import Counter, defaultdict, deque\nfrom heapq import heappop, heappush, heapify\nimport sys, bisect, math, itertools, fractions, pprint\n\nsys.setrecursionlimit(10**8)\nvar_6 = 10**9 + 7\nvar_1 = float(\"inf\")\n\n\ndef func_1():\n return int(sys.stdin.readline())\n\n\ndef func_2():\n return list(map(int, sys.stdin.readline().split()))\n\n\nvar_8, var_11 = func_2()\nvar_17 = [func_2() for _ in range(var_8)]\nvar_10 = var_17[::-1]\nvar_14 = [[0] * var_11 for _ in range(var_8)]\nvar_3 = [[0] * var_11 for _ in range(var_8)]\nfor var_4 in range(var_8 - 1):\n var_16, var_15 = var_17[var_4]\n for var_5 in range(var_11):\n if var_5 < var_16:\n var_14[var_4 + 1][var_5] = var_14[var_4][var_5]\n else:\n var_14[var_4 + 1][var_5] = max(\n var_14[var_4][var_5], var_14[var_4][var_5 - var_16] + var_15\n )\nvar_9 = var_14[var_8 - 1][var_11 - 1] + var_17[var_8 - 1][1]\nfor var_4 in range(var_8 - 1):\n var_16, var_15 = var_10[var_4]\n for var_5 in range(var_11):\n if var_5 < var_16:\n var_3[var_4 + 1][var_5] = var_3[var_4][var_5]\n else:\n var_3[var_4 + 1][var_5] = max(\n var_3[var_4][var_5], var_3[var_4][var_5 - var_16] + var_15\n )\n var_9 = max(var_9, var_3[var_8 - 1][var_11 - 1] + var_17[0][1])\n\nfor var_4 in range(1, var_8 - 1):\n var_13 = var_4\n var_2 = var_8 - var_4 - 1\n var_7 = 0\n for var_5 in range(var_11):\n var_12 = var_14[var_13][var_5] + var_3[var_2][var_11 - 1 - var_5]\n var_7 = max(var_7, var_12)\n var_9 = max(var_9, var_7 + var_17[var_4][1])\nprint(var_9)\n```", "output": "SLOWER 1.08", "pair_id": "python_p02863_pair0028_reversed", "problem_id": "p02863", "language": "python", "direction": "reversed", "speedup_ratio": 2.114} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\ndef func_1():\n var_1, var_2 = list(map(int, input().split()))\n var_3 = 0\n for var_4 in range(var_1, var_2 + 1):\n\n if (var_4 % 10) == (var_4 // 10000 % 10) and (var_4 // 10 % 10) == (\n var_4 // 1000 % 10\n ):\n var_3 += 1\n print(var_3)\n\n\nif __name__ == \"__main__\":\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = list(reversed(list(str(var_4))))\n if var_5 == list(str(var_4)):\n var_3 += 1\nprint(var_3)\n```", "output": "SLOWER 3.321", "pair_id": "python_p03416_pair0239_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 9.9935} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = list(reversed(list(str(var_4))))\n if var_5 == list(str(var_4)):\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\ndef func_1():\n var_1, var_2 = list(map(int, input().split()))\n var_3 = 0\n for var_4 in range(var_1, var_2 + 1):\n\n if (var_4 % 10) == (var_4 // 10000 % 10) and (var_4 // 10 % 10) == (\n var_4 // 1000 % 10\n ):\n var_3 += 1\n print(var_3)\n\n\nif __name__ == \"__main__\":\n func_1()\n```", "output": "FASTER 3.321", "pair_id": "python_p03416_pair0239_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 9.9935} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_4 = str(var_4)\n if var_4 == var_4[::-1]:\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_6 in range(var_1, var_2 + 1):\n var_3 = str(var_6)\n var_5 = True\n for var_7 in range(len(var_3) // 2):\n if var_3[var_7] != var_3[-var_7 - 1] and var_5:\n var_5 = not var_5\n if var_5:\n var_4 += 1\nprint(var_4)\n```", "output": "SLOWER 1.313", "pair_id": "python_p03416_pair0219_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 2.4845} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nfrom decimal import Decimal\nimport math\n\nvar_1, var_2 = list(map(str, input().split()))\nvar_1 = int(var_1)\nvar_2 = Decimal(var_2)\nvar_3 = math.floor(var_1 * var_2)\nprint((int(var_3)))\n```\n\n=== Code B (Modified) ===\n```python\ndef func_1():\n from sys import setrecursionlimit, stdin\n from os import environ\n from collections import defaultdict, deque, Counter\n from math import ceil, floor, gcd\n from itertools import accumulate, combinations, combinations_with_replacement\n\n setrecursionlimit(10**6)\n var_7 = (\n (lambda *var_11: print(*var_11))\n if \"TERM_PROGRAM\" in environ\n else lambda *var_12: 0\n )\n var_8 = lambda: stdin.readline().rstrip()\n var_3 = lambda: list(map(int, var_8().split()))\n var_1 = lambda: int(var_8())\n var_4 = 10**9 + 7\n var_2 = 10**9 + 10\n var_9, var_10 = var_8().split()\n var_5 = int(var_9)\n var_10 = var_10.split(\".\")\n var_6 = int(var_10[0]) * 100\n if len(var_10) == 2:\n var_6 += int(var_10[1])\n print(var_5 * var_6 // 100)\n\n\nfunc_1()\n```", "output": "SLOWER 1.825", "pair_id": "python_p02659_pair0062_reversed", "problem_id": "p02659", "language": "python", "direction": "reversed", "speedup_ratio": 3.543} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\ndef func_1():\n var_2, var_3, *var_1 = list(map(int, open(0).read().split()))\n var_4 = [0] * (var_3 + max(var_1[::2]))\n for var_7, var_6 in sorted(zip(*[iter(var_1)] * 2)):\n for var_5 in reversed(list(range(var_3))):\n var_4[var_5 + var_7] = max(var_4[var_5 + var_7], var_4[var_5] + var_6)\n print((max(var_4)))\n\n\nfunc_1()\n```\n\n=== Code B (Modified) ===\n```python\nvar_8, var_9 = list(map(int, input().split()))\nvar_5 = [[0] * (var_9 + 3001) for _ in range(var_8 + 1)]\nvar_3 = 0\nvar_2 = [list(map(int, input().split())) for _ in range(var_8)]\nvar_2.sort()\nfor var_6 in range(1, var_8 + 1):\n var_1, var_4 = var_2[var_6 - 1]\n for var_7 in range(var_9):\n var_5[var_6][var_7] = max(var_5[var_6 - 1][var_7], var_5[var_6][var_7])\n var_5[var_6][var_7 + var_1] = var_5[var_6 - 1][var_7] + var_4\n var_3 = max(var_5[var_6][var_7], var_5[var_6][var_7 + var_1], var_3)\nprint(var_3)\n```", "output": "SLOWER 1.8091", "pair_id": "python_p02863_pair0043_reversed", "problem_id": "p02863", "language": "python", "direction": "reversed", "speedup_ratio": 3.5042} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_2, var_1 = [int(var_12) for var_12 in input().split()]\nvar_3 = []\nfor var_8 in range(var_1):\n var_5, var_6 = [int(var_12) for var_12 in input().split()]\n var_3.append((var_5, var_6))\nvar_3.sort()\nvar_9 = float(\"inf\")\nvar_4 = [var_9 for var_5 in range(var_2 + 1)]\nfor var_5, var_6 in var_3:\n var_4[var_5] = min(var_4[var_5], var_6)\nvar_3 = [\n (var_5, var_4[var_5]) for var_5 in range(1, var_2 + 1) if var_4[var_5] != var_9\n]\nvar_3.sort(key=lambda var_11: var_11[1])\nvar_7 = [True] * (var_2)\nvar_10 = None\nfor var_5, var_6 in var_3:\n if var_10 == None or var_10 < var_5:\n var_7[var_6 - 1] = False\n var_10 = var_6 - 1\nprint((sum(1 for var_6 in var_7 if not var_6)))\n```\n\n=== Code B (Modified) ===\n```python\nvar_2, var_1 = list(map(int, input().split()))\nvar_7 = []\nfor var_6 in range(var_1):\n var_3, var_5 = list(map(int, input().split()))\n var_7.append([var_5, var_3])\n\nvar_7.sort()\nvar_4 = 1\nvar_9, var_8 = var_7[0]\nfor var_6 in range(1, var_1):\n var_5, var_3 = var_7[var_6]\n if var_9 <= var_3:\n var_9 = var_5\n var_4 += 1\nprint(var_4)\n```", "output": "FASTER 1.0817", "pair_id": "python_p03295_pair0004_forward", "problem_id": "p03295", "language": "python", "direction": "forward", "speedup_ratio": 2.1165} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\n\nvar_9 = sys.stdin.readline\nfrom operator import itemgetter\n\nvar_3, var_4 = list(map(int, var_9().split()))\nvar_1 = [list(map(int, var_9().split())) for _ in range(var_3)]\nvar_1.sort(key=itemgetter(0))\nvar_8 = [[0 for _ in range(var_3 + 1)] for _ in range(var_4 + 1)]\n\nvar_2 = []\nfor var_10 in range(var_3):\n var_5, var_7 = var_1[var_10]\n for var_11 in range(var_4):\n if var_5 > var_11:\n var_8[var_11][var_10 + 1] = var_8[var_11][var_10]\n else:\n if var_7 + var_8[var_11 - var_5][var_10] >= var_8[var_11][var_10]:\n var_8[var_11][var_10 + 1] = var_8[var_11 - var_5][var_10] + var_7\n else:\n var_8[var_11][var_10 + 1] = var_8[var_11][var_10]\n var_2.append(var_8[var_4 - 1][var_10] + var_7)\nvar_6 = max(var_2)\nprint(var_6)\n```\n\n=== Code B (Modified) ===\n```python\ndef func_1():\n var_2, var_3, *var_1 = list(map(int, open(0).read().split()))\n var_4 = [0] * (var_3 + max(var_1[::2]))\n for var_7, var_6 in sorted(zip(*[iter(var_1)] * 2)):\n for var_5 in reversed(list(range(var_3))):\n var_4[var_5 + var_7] = max(var_4[var_5 + var_7], var_4[var_5] + var_6)\n print((max(var_4)))\n\n\nfunc_1()\n```", "output": "FASTER 1.2754", "pair_id": "python_p02863_pair0064_forward", "problem_id": "p02863", "language": "python", "direction": "forward", "speedup_ratio": 2.4207} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\nimport math\nfrom collections import defaultdict\nfrom bisect import bisect_left, bisect_right\n\nsys.setrecursionlimit(10**7)\n\n\ndef func_4():\n return sys.stdin.readline()[:-1]\n\n\nvar_4 = 10**9 + 7\n\n\ndef func_1():\n return int(eval(func_4()))\n\n\ndef func_2():\n return list(map(int, func_4().split()))\n\n\ndef func_3(var_6, var_3):\n if var_6 <= 0:\n return [[] for _ in range(var_3)]\n elif var_3 == 1:\n return [func_1() for _ in range(var_6)]\n else:\n var_5 = [func_2() for _ in range(var_6)]\n return list(map(list, list(zip(*var_5))))\n\n\nfrom decimal import getcontext, Decimal\n\ngetcontext().prec = 28\nvar_1, var_2 = list(map(str, func_4().split()))\nvar_1 = int(var_1)\nvar_2 = Decimal(var_2)\nprint((int(var_1 * var_2)))\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = input().split()\nprint((int(var_1) * int(var_2[:-3] + var_2[-2:]) // 100))\n```", "output": "FASTER 2.7073", "pair_id": "python_p02659_pair0048_forward", "problem_id": "p02659", "language": "python", "direction": "forward", "speedup_ratio": 6.5312} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_8 = int(eval(input()))\nvar_4 = []\nfor var_5 in range(var_8):\n var_11 = 0\n var_9 = list(map(int, input().split()))\n for var_6 in range(10):\n var_11 += var_9[var_6] << var_6\n var_4.append(var_11)\nvar_10 = []\nfor var_5 in range(var_8):\n var_10.append(list(map(int, input().split())))\nvar_1 = -(10**12)\nfor var_5 in range(1, 1 << 10):\n var_11 = 0\n for var_6 in range(var_8):\n var_3 = list(bin(var_4[var_6] & var_5)[2:])\n var_2 = 0\n for var_7 in var_3:\n if var_7 == \"1\":\n var_2 += 1\n var_11 += var_10[var_6][var_2]\n var_1 = max(var_1, var_11)\nprint(var_1)\n```\n\n=== Code B (Modified) ===\n```python\nfrom sys import stdin\n\n\ndef func_1():\n\n var_11 = stdin.readline\n var_2 = int(var_11())\n var_1 = []\n for var_6 in range(var_2):\n var_5 = int(\"\".join(var_11().strip().split(\" \")), 2)\n var_1.append(var_5)\n var_3 = []\n for var_6 in range(var_2):\n var_10 = list(map(int, var_11().split()))\n var_3.append(var_10)\n var_8 = float(\"-inf\")\n for var_9 in range(1, 1 << 10):\n var_12 = 0\n for var_7 in range(var_2):\n var_4 = bin(var_9 & var_1[var_7]).count(\"1\")\n var_12 += var_3[var_7][var_4]\n var_8 = max(var_12, var_8)\n print(var_8)\n\n\nif __name__ == \"__main__\":\n func_1()\n```", "output": "FASTER 2.3449", "pair_id": "python_p03503_pair0047_forward", "problem_id": "p03503", "language": "python", "direction": "forward", "speedup_ratio": 5.0801} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n if list(str(var_4)) == list(reversed(str(var_4))):\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nfrom sys import stdin\n\nvar_6 = lambda: list(map(int, stdin.readline().split()))\nvar_5 = lambda: list(map(int, stdin.readline().split()))\nvar_1, var_3 = var_6()\nvar_2 = 0\nfor var_4 in range(var_1, var_3 + 1):\n var_7 = str(var_4)\n if var_7 == var_7[::-1]:\n var_2 += 1\nprint(var_2)\n```", "output": "FASTER 1.3819", "pair_id": "python_p03416_pair0218_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 2.6062} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\n\nvar_9 = sys.stdin.readline\nfrom operator import itemgetter\n\nvar_3, var_4 = list(map(int, var_9().split()))\nvar_1 = [list(map(int, var_9().split())) for _ in range(var_3)]\nvar_1.sort(key=itemgetter(0))\nvar_8 = [[0 for _ in range(var_3 + 1)] for _ in range(var_4 + 1)]\n\nvar_2 = []\nfor var_10 in range(var_3):\n var_5, var_7 = var_1[var_10]\n for var_11 in range(var_4):\n if var_5 > var_11:\n var_8[var_11][var_10 + 1] = var_8[var_11][var_10]\n else:\n if var_7 + var_8[var_11 - var_5][var_10] >= var_8[var_11][var_10]:\n var_8[var_11][var_10 + 1] = var_8[var_11 - var_5][var_10] + var_7\n else:\n var_8[var_11][var_10 + 1] = var_8[var_11][var_10]\n var_2.append(var_8[var_4 - 1][var_10] + var_7)\nvar_6 = max(var_2)\nprint(var_6)\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\n\nsys.setrecursionlimit(2147483647)\nvar_2 = float(\"inf\")\nvar_3 = 10**9 + 7\nvar_10 = lambda: sys.stdin.readline().rstrip()\n\n\ndef func_1():\n var_11, var_4 = list(map(int, var_10().split()))\n var_1 = [tuple(map(int, var_10().split())) for _ in range(var_11)]\n var_1.sort()\n var_8 = [0] * var_4\n var_6 = -var_2\n for var_9 in range(var_11):\n var_5, var_7 = var_1[var_9]\n var_12 = var_8[:]\n for var_13 in range(var_4):\n if var_13 + var_5 < var_4:\n var_12[var_13 + var_5] = max(\n var_12[var_13 + var_5], var_8[var_13] + var_7\n )\n else:\n var_6 = max(var_6, var_8[var_13] + var_7)\n var_8 = var_12\n print((max(var_6, max(var_8))))\n\n\nfunc_1()\n```", "output": "FASTER 1.0161", "pair_id": "python_p02863_pair0065_forward", "problem_id": "p02863", "language": "python", "direction": "forward", "speedup_ratio": 2.0224} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\n\n\ndef func_1(var_5, var_6):\n var_4 = 0\n for var_3 in range(var_5, var_6 + 1):\n if str(var_3) == str(var_3)[::-1]:\n var_4 += 1\n return var_4\n\n\nprint((func_1(var_1, var_2)))\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_7 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_3 = True\n var_8 = str(var_4)\n var_6 = len(var_8)\n for var_5 in range(var_6 // 2 + 1):\n if var_8[var_5] != var_8[-var_5 - 1]:\n var_3 = False\n break\n if var_3:\n var_7 += 1\nprint(var_7)\n```", "output": "SLOWER 1.4487", "pair_id": "python_p03416_pair0169_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 2.7297} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\nimport math\nfrom collections import defaultdict\nfrom bisect import bisect_left, bisect_right\n\nsys.setrecursionlimit(10**7)\n\n\ndef func_4():\n return sys.stdin.readline()[:-1]\n\n\nvar_4 = 10**9 + 7\n\n\ndef func_1():\n return int(eval(func_4()))\n\n\ndef func_2():\n return list(map(int, func_4().split()))\n\n\ndef func_3(var_6, var_3):\n if var_6 <= 0:\n return [[] for _ in range(var_3)]\n elif var_3 == 1:\n return [func_1() for _ in range(var_6)]\n else:\n var_5 = [func_2() for _ in range(var_6)]\n return list(map(list, list(zip(*var_5))))\n\n\nvar_1, var_2 = list(map(str, func_4().split()))\nvar_1 = int(var_1)\nvar_2 = 100 * int(var_2[0]) + 10 * int(var_2[2]) + int(var_2[3])\nprint((var_1 * var_2 // 100))\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\n\nvar_3 = sys.stdin.readline\nvar_1, var_2 = var_3().split()\nvar_1 = int(var_1)\nvar_2 = int(float(var_2) * 100 + 0.5)\nprint((var_1 * var_2 // 100))\n```", "output": "FASTER 2.3093", "pair_id": "python_p02659_pair0051_forward", "problem_id": "p02659", "language": "python", "direction": "forward", "speedup_ratio": 4.9565} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nfrom collections import Counter, defaultdict, deque\nfrom heapq import heappop, heappush, heapify\nimport sys, bisect, math, itertools, fractions, pprint\n\nsys.setrecursionlimit(10**8)\nvar_6 = 10**9 + 7\nvar_1 = float(\"inf\")\n\n\ndef func_1():\n return int(sys.stdin.readline())\n\n\ndef func_2():\n return list(map(int, sys.stdin.readline().split()))\n\n\nvar_7, var_9 = func_2()\nvar_13 = [func_2() for _ in range(var_7)]\nvar_13.sort(key=lambda var_14: var_14[1], reverse=True)\nvar_8 = 0\nvar_10 = min(var_7, 5)\nfor var_3 in range(var_10):\n var_2 = [[0] * (var_9 + 5) for _ in range(var_7 + 5)]\n for var_4 in range(var_7):\n var_12, var_11 = var_13[var_4]\n for var_5 in range(var_9):\n if var_5 < var_12 or var_3 == var_4:\n var_2[var_4 + 1][var_5] = var_2[var_4][var_5]\n else:\n var_2[var_4 + 1][var_5] = max(\n var_2[var_4][var_5], var_2[var_4][var_5 - var_12] + var_11\n )\n\n var_8 = max(var_2[var_7][var_9 - 1] + var_13[var_3][1], var_8)\nprint(var_8)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_6 = sorted([list(map(int, input().split())) for var_5 in range(var_1)])\n\nvar_4 = [[0] * (var_2 + 1) for var_5 in range(var_1 + 1)]\n\nfor var_5 in range(var_1):\n var_9, var_8 = var_6[var_5]\n for var_7 in range(var_2 + 1):\n if var_7 + var_9 <= var_2:\n var_4[var_5 + 1][var_7 + var_9] = max(\n var_4[var_5 + 1][var_7 + var_9], var_4[var_5][var_7] + var_8\n )\n var_4[var_5 + 1][var_7] = max(var_4[var_5][var_7], var_4[var_5 + 1][var_7])\nvar_3 = 0\nfor var_5, (var_9, var_8) in enumerate(var_6):\n var_3 = max(var_3, var_4[var_5][var_2 - 1] + var_8)\nprint(var_3)\n```", "output": "FASTER 1.2339", "pair_id": "python_p02863_pair0066_forward", "problem_id": "p02863", "language": "python", "direction": "forward", "speedup_ratio": 2.352} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_4 = {}\nvar_5 = 0\nfor var_6 in range(10000, 100000):\n var_3 = list(str(var_6))\n if var_3 == list(reversed(var_3)):\n var_5 += 1\n var_4[var_6] = var_5\nvar_1, var_2 = list(map(int, input().split()))\nprint((var_4[var_2] - var_4[var_1 - 1] if var_1 > 10000 else var_4[var_2]))\n```\n\n=== Code B (Modified) ===\n```python\nvar_4, var_3 = list(map(int, input().split()))\nvar_1 = 0\nfor var_2 in range(var_4, var_3 + 1):\n if str(var_2)[0] + str(var_2)[1] == str(var_2)[-1] + str(var_2)[-2]:\n var_1 += 1\nprint(var_1)\n```", "output": "FASTER 2.2325", "pair_id": "python_p03416_pair0240_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 4.6995} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_6 = sorted([list(map(int, input().split())) for var_5 in range(var_1)])\n\nvar_4 = [[0] * (var_2 + 1) for var_5 in range(var_1 + 1)]\n\nfor var_5 in range(var_1):\n var_9, var_8 = var_6[var_5]\n for var_7 in range(var_2 + 1):\n if var_7 + var_9 <= var_2:\n var_4[var_5 + 1][var_7 + var_9] = max(\n var_4[var_5 + 1][var_7 + var_9], var_4[var_5][var_7] + var_8\n )\n var_4[var_5 + 1][var_7] = max(var_4[var_5][var_7], var_4[var_5 + 1][var_7])\nvar_3 = 0\nfor var_5, (var_9, var_8) in enumerate(var_6):\n var_3 = max(var_3, var_4[var_5][var_2 - 1] + var_8)\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\n\nsys.setrecursionlimit(2147483647)\nvar_2 = float(\"inf\")\nvar_3 = 10**9 + 7\nvar_10 = lambda: sys.stdin.readline().rstrip()\n\n\ndef func_1():\n var_11, var_4 = list(map(int, var_10().split()))\n var_1 = [tuple(map(int, var_10().split())) for _ in range(var_11)]\n var_1.sort()\n var_8 = [0] * var_4\n var_6 = -var_2\n for var_9 in range(var_11):\n var_5, var_7 = var_1[var_9]\n var_12 = var_8[:]\n for var_13 in range(var_4):\n if var_13 + var_5 < var_4:\n var_12[var_13 + var_5] = max(\n var_12[var_13 + var_5], var_8[var_13] + var_7\n )\n else:\n var_6 = max(var_6, var_8[var_13] + var_7)\n var_8 = var_12\n print((max(var_6, max(var_8))))\n\n\nfunc_1()\n```", "output": "FASTER 1.4447", "pair_id": "python_p02863_pair0046_forward", "problem_id": "p02863", "language": "python", "direction": "forward", "speedup_ratio": 2.722} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\nimport math\nfrom collections import defaultdict\nfrom bisect import bisect_left, bisect_right\n\nsys.setrecursionlimit(10**7)\n\n\ndef func_4():\n return sys.stdin.readline()[:-1]\n\n\nvar_4 = 10**9 + 7\n\n\ndef func_1():\n return int(eval(func_4()))\n\n\ndef func_2():\n return list(map(int, func_4().split()))\n\n\ndef func_3(var_6, var_3):\n if var_6 <= 0:\n return [[] for _ in range(var_3)]\n elif var_3 == 1:\n return [func_1() for _ in range(var_6)]\n else:\n var_5 = [func_2() for _ in range(var_6)]\n return list(map(list, list(zip(*var_5))))\n\n\nvar_1, var_2 = list(map(str, func_4().split()))\nvar_1 = int(var_1)\nvar_2 = 100 * int(var_2[0]) + 10 * int(var_2[2]) + int(var_2[3])\nprint((var_1 * var_2 // 100))\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = input().split()\nprint((int(var_1) * int(var_2[:-3] + var_2[-2:]) // 100))\n```", "output": "FASTER 2.7265", "pair_id": "python_p02659_pair0044_forward", "problem_id": "p02659", "language": "python", "direction": "forward", "speedup_ratio": 6.6183} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\nimport math\nfrom collections import defaultdict\nfrom bisect import bisect_left, bisect_right\n\nsys.setrecursionlimit(10**7)\n\n\ndef func_4():\n return sys.stdin.readline()[:-1]\n\n\nvar_4 = 10**9 + 7\n\n\ndef func_1():\n return int(eval(func_4()))\n\n\ndef func_2():\n return list(map(int, func_4().split()))\n\n\ndef func_3(var_6, var_3):\n if var_6 <= 0:\n return [[] for _ in range(var_3)]\n elif var_3 == 1:\n return [func_1() for _ in range(var_6)]\n else:\n var_5 = [func_2() for _ in range(var_6)]\n return list(map(list, list(zip(*var_5))))\n\n\nvar_1, var_2 = list(map(str, func_4().split()))\nvar_1 = int(var_1)\nvar_2 = 100 * int(var_2[0]) + 10 * int(var_2[2]) + int(var_2[3])\nprint((var_1 * var_2 // 100))\n```\n\n=== Code B (Modified) ===\n```python\nimport decimal\n\nvar_1, var_2 = (decimal.Decimal(var_3) for var_3 in input().split())\nprint((int(var_1 * var_2)))\n```", "output": "FASTER 2.2511", "pair_id": "python_p02659_pair0035_forward", "problem_id": "p02659", "language": "python", "direction": "forward", "speedup_ratio": 4.7605} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = [\n var_3 for var_3 in map(str, list(range(var_1, var_2 + 1))) if var_3 == var_3[::-1]\n]\nprint((len(var_4)))\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\n\n\ndef func_1(var_5):\n var_4 = 0\n for var_3 in range(1, var_5 + 1):\n if str(var_3) == str(var_3)[::-1]:\n var_4 += 1\n return var_4\n\n\nprint((func_1(var_2) - func_1(var_1 - 1)))\n```", "output": "SLOWER 2.2892", "pair_id": "python_p03416_pair0094_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 4.8878} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\ndef func_1():\n var_1, var_2 = list(map(int, input().split()))\n var_3 = 0\n for var_4 in range(var_1, var_2 + 1):\n\n if (var_4 % 10) == (var_4 // 10000 % 10) and (var_4 // 10 % 10) == (\n var_4 // 1000 % 10\n ):\n var_3 += 1\n print(var_3)\n\n\nif __name__ == \"__main__\":\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = str(var_4)\n if var_5 == var_5[::-1]:\n var_3 += 1\nprint(var_3)\n```", "output": "SLOWER 1.6596", "pair_id": "python_p03416_pair0211_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 3.1592} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = list(str(var_4))\n if var_5 == list(reversed(var_5)):\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = str(var_4)\n if var_5[0] == var_5[4] and var_5[1] == var_5[3]:\n var_3 += 1\nprint(var_3)\n```", "output": "FASTER 1.4984", "pair_id": "python_p03416_pair0126_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 2.8252} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\n\nvar_8 = sys.stdin.readline\n\n\ndef func_1():\n var_2 = int(eval(var_8()))\n var_1 = [int(var_8().replace(\" \", \"\"), 2) for _ in range(var_2)]\n var_3 = [list(map(int, var_8().split())) for _ in range(var_2)]\n var_4 = -(10**7) * var_2\n for var_7 in range(1, 1 << 10):\n var_10 = 0\n for var_9, var_6 in enumerate(var_1):\n var_5 = bin(var_7 & var_6).count(\"1\")\n var_10 += var_3[var_9][var_5]\n var_4 = max(var_4, var_10)\n print(var_4)\n\n\nif __name__ == \"__main__\":\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nvar_5 = 0\nif var_5 == 0:\n var_8 = int(eval(input()))\n var_2 = []\n for var_4 in range(var_8):\n var_3 = list(map(int, input().split()))\n var_2.append(var_3)\n var_9 = []\n for var_4 in range(var_8):\n var_10 = list(map(int, input().split()))\n var_9.append(var_10)\nelif var_5 == 1:\n var_8 = 1\n var_2 = [[1, 1, 0, 1, 0, 0, 0, 1, 0, 1]]\n var_9 = [[3, 4, 5, 6, 7, 8, 9, -2, -3, 4, -2]]\nelif var_5 == 2:\n var_8 = 2\n var_2 = [[1, 1, 1, 1, 1, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 1, 1, 1, 1, 1]]\n var_9 = [\n [0, -2, -2, -2, -2, -2, -1, -1, -1, -1, -1],\n [0, -2, -2, -2, -2, -2, -1, -1, -1, -1, -1],\n ]\nelif var_5 == 3:\n var_8 = 3\n var_2 = [\n [1, 1, 1, 1, 1, 1, 0, 0, 1, 1],\n [0, 1, 0, 1, 1, 1, 1, 0, 1, 0],\n [1, 0, 1, 1, 0, 1, 0, 1, 0, 1],\n ]\n var_9 = [\n [-8, 6, -2, -8, -8, 4, 8, 7, -6, 2, 2],\n [-9, 2, 0, 1, 7, -5, 0, -2, -6, 5, 5],\n [6, -6, 7, -9, 6, -5, 8, 0, -9, -7, -7],\n ]\nimport itertools\n\nvar_13 = -(10**11)\nfor var_4 in itertools.product([0, 1], repeat=10):\n var_11 = list(var_4)\n var_12 = 0\n if sum(var_11) != 0:\n for var_7 in range(var_8):\n var_1 = 0\n for var_6 in range(10):\n var_1 = var_1 + var_11[var_6] * var_2[var_7][var_6]\n var_12 = var_12 + var_9[var_7][var_1]\n\n var_13 = max(var_12, var_13)\nprint(var_13)\n```", "output": "SLOWER 3.1351", "pair_id": "python_p03503_pair0042_reversed", "problem_id": "p03503", "language": "python", "direction": "reversed", "speedup_ratio": 8.7856} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = [0] * (var_2 + 1)\nfor var_3 in range(1, var_2 + 1):\n if str(var_3) == str(var_3)[::-1]:\n var_4[var_3] = var_4[var_3 - 1] + 1\n else:\n var_4[var_3] = var_4[var_3 - 1]\nprint((var_4[var_2] - var_4[var_1 - 1]))\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_4 = str(var_4)\n if var_4[0] == var_4[-1] and var_4[1] == var_4[-2]:\n var_3 += 1\nprint(var_3)\n```", "output": "FASTER 2.126", "pair_id": "python_p03416_pair0029_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 4.365} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_6 = 2019\nvar_1 = [0] * var_6\nvar_3 = 1\nvar_5 = var_4 = 0\nfor var_2 in input()[::-1]:\n var_1[var_4] += 1\n var_4 -= int(var_2) * var_3\n var_4 %= var_6\n var_5 += var_1[var_4]\n var_3 *= 10\n var_3 %= var_6\nprint(var_5)\n```\n\n=== Code B (Modified) ===\n```python\nvar_5 = input()[::-1]\nvar_2 = [0] * 2019\nvar_2[0] = 1\nvar_4 = 0\nvar_6 = 1\nvar_1 = 0\nfor var_3 in var_5:\n var_4 = (var_4 + int(var_3) * var_6) % 2019\n var_6 = var_6 * 10 % 2019\n var_2[var_4] += 1\nfor var_3 in var_2:\n var_1 += var_3 * (var_3 - 1) // 2\nprint(var_1)\n```", "output": "SLOWER 2.8509", "pair_id": "python_p02702_pair0014_reversed", "problem_id": "p02702", "language": "python", "direction": "reversed", "speedup_ratio": 7.2145} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_8 in range(var_1, var_2 + 1):\n var_7 = str(var_8)\n var_6 = len(var_7)\n var_4 = True\n for var_5 in range(var_6 // 2):\n if var_7[var_5] != var_7[var_6 - 1 - var_5]:\n var_4 = False\n break\n if var_4:\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = [\n var_3 for var_3 in map(str, list(range(var_1, var_2 + 1))) if var_3 == var_3[::-1]\n]\nprint((len(var_4)))\n```", "output": "FASTER 1.8248", "pair_id": "python_p03416_pair0050_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 3.5426} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\nfrom collections import deque\n\nvar_13 = sys.stdin.readline\nvar_2 = int(eval(var_13()))\nvar_5 = [deque() for _ in range(var_2)]\nvar_3 = [-1] * var_2\nfor var_12 in range(var_2 - 1):\n var_6, var_8 = list(map(int, var_13().split()))\n var_5[var_6 - 1].append((var_12, var_8 - 1))\n\n\nvar_4 = deque([(0, -1)])\nvar_1 = [-1] * (var_2 - 1)\nvar_11 = 0\nwhile var_4:\n var_14, var_10 = var_4.pop()\n var_9 = 1\n for var_12, var_15 in var_5[var_14]:\n if var_9 == var_10:\n var_9 += 1\n var_1[var_12] = var_9\n var_4.appendleft((var_15, var_9))\n var_9 += 1\n var_11 = max(var_11, var_9 - 1)\nprint(var_11)\nfor var_7 in var_1:\n print(var_7)\n```\n\n=== Code B (Modified) ===\n```python\nimport copy\n\nvar_8 = int(eval(input()))\nvar_10 = set([var_6 for var_6 in range(1, 10**5)])\nvar_5 = []\nvar_11 = {}\nvar_9 = []\nfor var_6 in range(var_8 - 1):\n var_1, var_2 = list(map(int, input().split(\" \")))\n var_5.append([var_1, var_2])\n var_11.setdefault(var_1, []).append(var_2)\n var_9.append([])\nvar_9.append([])\nvar_9.append([])\nvar_7 = 0\nfor var_12 in range(1, var_8 + 1):\n var_14 = var_11.get(var_12, [])\n var_3 = 1\n for var_13 in var_14:\n if var_3 in var_9[var_12]:\n var_3 += 1\n else:\n pass\n var_9[var_13].append(var_3)\n if var_3 >= var_7:\n var_7 = var_3\n var_3 += 1\nprint(var_7)\nfor var_4 in var_5:\n print((var_9[var_4[1]][0]))\n```", "output": "SLOWER 4.6519", "pair_id": "python_p02850_pair0033_reversed", "problem_id": "p02850", "language": "python", "direction": "reversed", "speedup_ratio": 25.1403} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport math\nimport string\n\n\ndef func_4():\n return list(map(int, input().split()))\n\n\ndef func_3(var_6, var_7):\n return math.factorial(var_6) // (\n math.factorial(var_6 - var_7) * math.factorial(var_7)\n )\n\n\ndef func_2(var_9):\n var_8 = []\n for var_5 in var_9:\n if not (var_5 in var_8):\n var_8.append(var_5)\n return len(var_9) != len(var_8)\n\n\ndef func_1(var_6):\n func_1 = []\n for var_4 in range(1, var_6 + 1):\n if var_6 % var_4 == 0:\n func_1.append(var_4)\n return func_1\n\n\nvar_2 = [-1, -1, -1, 0, 0, 1, 1, 1]\nvar_3 = [-1, 0, 1, -1, 1, -1, 0, 1]\nvar_6 = int(eval(input()))\nvar_1 = func_4()\nvar_10 = 1\nfor var_4 in range(len(var_1)):\n if var_1[var_4] % 2 == 0:\n var_10 *= 2\n else:\n var_10 *= 1\nprint((3 ** len(var_1) - var_10))\n```\n\n=== Code B (Modified) ===\n```python\nimport numpy as np\nfrom itertools import product\n\nvar_6 = int(eval(input()))\nvar_2 = list(map(int, input().split()))\nvar_2 = np.array(var_2)\nvar_5 = [-1, 0, 1]\nvar_3 = 0\nfor var_7 in product(var_5, repeat=var_6):\n var_7 = np.array(var_7)\n var_1 = var_2 + var_7\n var_4 = var_1.cumprod()\n if var_4[-1] % 2 == 0:\n var_3 += 1\nprint(var_3)\n```", "output": "SLOWER 8.335", "pair_id": "python_p03568_pair0026_reversed", "problem_id": "p03568", "language": "python", "direction": "reversed", "speedup_ratio": 322.9207} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_8 = int(eval(input()))\nvar_1 = list(map(int, input().split()))\nvar_3 = 0\nvar_9 = sum(var_1)\nvar_2 = []\nvar_10 = 0\nfor var_6 in range(0, var_8):\n\n var_10 += var_1[var_6]\n var_11 = var_9 - var_10\n\n var_2.append(abs(var_10 - var_11))\n if var_10 == var_11:\n print((0))\n exit()\nvar_7 = var_2.index(min(var_2))\n\n\nvar_12 = sum(var_1[0:var_7])\nvar_13 = sum(var_1[var_7:])\n\n\nvar_4 = abs(var_12 - var_13)\nvar_14 = sum(var_1[0 : var_7 + 1])\nvar_15 = sum(var_1[var_7 + 1 :])\n\n\nvar_5 = abs(var_14 - var_15)\nprint((min(var_4, var_5)))\n```\n\n=== Code B (Modified) ===\n```python\nfrom itertools import accumulate, count\nfrom bisect import bisect_right\n\neval(input())\nvar_1 = [0] + list(accumulate(list(map(int, input().split()))))\nvar_2 = bisect_right(var_1, var_1[-1] // 2)\nprint((min(2 * var_1[var_2] - var_1[-1], var_1[-1] - 2 * var_1[var_2 - 1])))\n```", "output": "FASTER 1.1094", "pair_id": "python_p02854_pair0001_forward", "problem_id": "p02854", "language": "python", "direction": "forward", "speedup_ratio": 2.1576} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_8 = int(eval(input()))\nvar_4 = []\nfor var_5 in range(var_8):\n var_11 = 0\n var_9 = list(map(int, input().split()))\n for var_6 in range(10):\n var_11 += var_9[var_6] << var_6\n var_4.append(var_11)\nvar_10 = []\nfor var_5 in range(var_8):\n var_10.append(list(map(int, input().split())))\nvar_1 = -(10**12)\nfor var_5 in range(1, 1 << 10):\n var_11 = 0\n for var_6 in range(var_8):\n var_3 = list(bin(var_4[var_6] & var_5)[2:])\n var_2 = 0\n for var_7 in var_3:\n if var_7 == \"1\":\n var_2 += 1\n var_11 += var_10[var_6][var_2]\n var_1 = max(var_1, var_11)\nprint(var_1)\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\n\nvar_7 = sys.stdin.readline\nfrom itertools import combinations\n\n\ndef func_3(var_10):\n for _ in range(var_10):\n yield list(map(int, var_7().split()))\n\n\ndef func_1(var_9, var_5, var_11):\n var_3 = len([0 for var_8 in var_9 if var_5[var_8] == 1])\n return var_11[var_3]\n\n\ndef func_2():\n var_10 = int(eval(var_7()))\n var_1 = list(func_3(var_10))\n var_2 = list(func_3(var_10))\n for var_6 in range(1, 11):\n for var_4 in combinations(list(range(10)), var_6):\n yield sum(\n func_1(var_4, var_5, var_11) for var_5, var_11 in zip(var_1, var_2)\n )\n\n\nprint((max(func_2())))\n```", "output": "FASTER 1.0894", "pair_id": "python_p03503_pair0018_forward", "problem_id": "p03503", "language": "python", "direction": "forward", "speedup_ratio": 2.1279} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\n\nvar_2, var_1, *var_3 = sys.stdin.read().strip().split()\nvar_2 = int(var_2)\nvar_5 = [0] * var_2\nvar_10 = [0] * var_2\nfor var_6, var_8 in zip(*[iter(var_3)] * 2):\n var_6 = int(var_6) - 1\n if var_8 == \"AC\":\n var_5[var_6] = 1\n elif var_5[var_6] == 0:\n var_10[var_6] += 1\nvar_7 = sum([var_9 * var_4 for var_4, var_9 in zip(var_5, var_10)])\nprint((\"{} {}\".format(sum(var_5), var_7)))\n```\n\n=== Code B (Modified) ===\n```python\nvar_6, var_5 = list(map(int, input().split()))\nvar_8 = [[] for _ in range(var_6)]\nfor var_2 in range(var_5):\n var_10, var_11 = input().split()\n var_8[int(var_10) - 1].append(var_11)\n\nvar_1, var_7 = 0, 0\nfor var_3 in range(var_6):\n var_9 = var_8[var_3]\n if \"AC\" in var_9:\n var_1 += 1\n for var_4 in var_9:\n if var_4 == \"WA\":\n var_7 += 1\n else:\n break\nprint((var_1, var_7))\n```", "output": "SLOWER 1.7771", "pair_id": "python_p02802_pair0010_reversed", "problem_id": "p02802", "language": "python", "direction": "reversed", "speedup_ratio": 3.4274} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_3 = list(map(int, input().split()))\nvar_2 = 0\nfor var_5 in range(var_3 + 1)[var_1:]:\n if len(str(var_5)) % 2 == 0:\n var_6 = list(str(var_5))[: len(str(var_5)) // 2]\n var_7 = list(reversed(list(str(var_5))[len(str(var_5)) // 2 :]))\n if var_6 == var_7:\n var_2 += 1\n else:\n var_8 = list(str(var_5))[: len(str(var_5)) // 2 + 1]\n var_4 = list(reversed(list(str(var_5))[len(str(var_5)) // 2 :]))\n if var_8 == var_4:\n var_2 += 1\nprint(var_2)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = [\n var_3 for var_3 in map(str, list(range(var_1, var_2 + 1))) if var_3 == var_3[::-1]\n]\nprint((len(var_4)))\n```", "output": "FASTER 3.1731", "pair_id": "python_p03416_pair0241_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 9.0199} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = str(var_4)\n if var_5 == var_5[::-1]:\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_4, var_3 = list(map(int, input().split()))\nvar_1 = 0\nfor var_2 in range(var_4, var_3 + 1):\n if str(var_2)[0] + str(var_2)[1] == str(var_2)[-1] + str(var_2)[-2]:\n var_1 += 1\nprint(var_1)\n```", "output": "SLOWER 1.3456", "pair_id": "python_p03416_pair0212_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 2.5413} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\ndef func_1():\n var_1, var_2 = list(map(int, input().rstrip().split()))\n var_3 = 0\n for var_4 in range(var_1, var_2 + 1):\n var_5 = str(var_4)\n if var_5 == var_5[::-1]:\n var_3 += 1\n print(var_3)\n\n\nif __name__ == \"__main__\":\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_3 in range(var_1, var_2 + 1):\n var_5 = list(str(var_3))\n var_6 = list(reversed(var_5))\n if var_5 == var_6:\n var_4 += 1\nprint(var_4)\n```", "output": "SLOWER 2.0546", "pair_id": "python_p03416_pair0229_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 4.1544} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport bisect\nimport sys\n\nsys.setrecursionlimit(10**6)\nvar_16 = sys.stdout.write\nvar_7 = lambda *var_14: print(*var_14) if var_1 else 0\nvar_1 = True\n\n\ndef func_1(var_9=sys.stdin.readline):\n var_11 = lambda: var_9().rstrip()\n var_3 = lambda: list(map(int, var_11().split()))\n var_2 = lambda: int(var_11())\n var_4 = lambda var_17: [var_3() for _ in range(var_17)]\n var_13, var_15 = var_3()\n var_5 = var_4(var_13)\n var_5.sort()\n var_8 = [[0] * var_15 for _ in range(var_13 + 1)]\n for var_10 in range(1, var_13 + 1):\n for var_12 in range(1, var_15):\n if var_12 < var_5[var_10 - 1][0]:\n var_8[var_10][var_12] = var_8[var_10 - 1][var_12]\n else:\n var_8[var_10][var_12] = max(\n var_8[var_10 - 1][var_12],\n var_8[var_10 - 1][var_12 - var_5[var_10 - 1][0]]\n + var_5[var_10 - 1][1],\n )\n var_6 = 0\n for var_10 in range(var_13):\n var_6 = max(var_6, var_8[var_10][var_15 - 1] + var_5[var_10][1])\n print(var_6)\n\n\nif __name__ == \"__main__\":\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\nfrom operator import itemgetter\nfrom heapq import heapify, heappop, heappush\n\nvar_1 = int(10e15)\nvar_2 = -var_1\nvar_11 = 1000000007\nsys.setrecursionlimit(1000000)\n\n\ndef func_2():\n return list(map(int, input().split()))\n\n\ndef func_4():\n return input().split()\n\n\ndef func_1():\n return int(sys.stdin.readline())\n\n\ndef func_3():\n return eval(input())\n\n\nvar_3, var_4 = func_2()\nvar_5 = [func_2() for var_9 in range(var_3)]\nvar_5.sort(key=itemgetter(0))\n\nvar_8 = [[0] * (var_4 + 1 + 3000 + 1) for _ in range(var_3 + 1)]\nvar_6 = 0\nfor var_9 in range(var_3):\n for var_10 in range(var_4 + 1 + 3000 + 1):\n var_12, var_7 = var_5[var_9]\n if 0 <= var_10 - var_12 < var_4:\n var_8[var_9 + 1][var_10] = max(\n var_8[var_9][var_10], var_8[var_9][var_10 - var_12] + var_7\n )\n else:\n var_8[var_9 + 1][var_10] = var_8[var_9][var_10]\n var_6 = max(var_6, var_8[var_9 + 1][var_10])\nprint(var_6)\n```", "output": "SLOWER 5.2198", "pair_id": "python_p02863_pair0061_reversed", "problem_id": "p02863", "language": "python", "direction": "reversed", "speedup_ratio": 37.2652} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\n\nvar_8 = sys.stdin.readline\n\n\ndef func_1():\n var_2 = int(eval(var_8()))\n var_1 = [int(var_8().replace(\" \", \"\"), 2) for _ in range(var_2)]\n var_3 = [list(map(int, var_8().split())) for _ in range(var_2)]\n var_4 = -(10**7) * var_2\n for var_7 in range(1, 1 << 10):\n var_10 = 0\n for var_9, var_6 in enumerate(var_1):\n var_5 = bin(var_7 & var_6).count(\"1\")\n var_10 += var_3[var_9][var_5]\n var_4 = max(var_4, var_10)\n print(var_4)\n\n\nif __name__ == \"__main__\":\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\n\nvar_7 = sys.stdin.readline\nfrom itertools import combinations\n\n\ndef func_3(var_10):\n for _ in range(var_10):\n yield list(map(int, var_7().split()))\n\n\ndef func_1(var_9, var_5, var_11):\n var_3 = len([0 for var_8 in var_9 if var_5[var_8] == 1])\n return var_11[var_3]\n\n\ndef func_2():\n var_10 = int(eval(var_7()))\n var_1 = list(func_3(var_10))\n var_2 = list(func_3(var_10))\n for var_6 in range(1, 11):\n for var_4 in combinations(list(range(10)), var_6):\n yield sum(\n func_1(var_4, var_5, var_11) for var_5, var_11 in zip(var_1, var_2)\n )\n\n\nprint((max(func_2())))\n```", "output": "SLOWER 1.1171", "pair_id": "python_p03503_pair0022_reversed", "problem_id": "p03503", "language": "python", "direction": "reversed", "speedup_ratio": 2.1691} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = str(var_4)\n if var_5[0] == var_5[4] and var_5[1] == var_5[3]:\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_7 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_3 = True\n var_8 = str(var_4)\n var_6 = len(var_8)\n for var_5 in range(var_6 // 2 + 1):\n if var_8[var_5] != var_8[-var_5 - 1]:\n var_3 = False\n break\n if var_3:\n var_7 += 1\nprint(var_7)\n```", "output": "SLOWER 1.3913", "pair_id": "python_p03416_pair0230_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 2.6231} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\n\n\ndef func_1(var_5, var_6):\n var_4 = 0\n for var_3 in range(var_5, var_6 + 1):\n if str(var_3) == str(var_3)[::-1]:\n var_4 += 1\n return var_4\n\n\nprint((func_1(var_1, var_2)))\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n if list(str(var_4)) == list(reversed(str(var_4))):\n var_3 += 1\nprint(var_3)\n```", "output": "SLOWER 1.724", "pair_id": "python_p03416_pair0170_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 3.3035} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n if list(str(var_4)) == list(reversed(str(var_4))):\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_3 = list(map(int, input().split()))\nvar_2 = 0\nfor var_5 in range(var_3 + 1)[var_1:]:\n if len(str(var_5)) % 2 == 0:\n var_6 = list(str(var_5))[: len(str(var_5)) // 2]\n var_7 = list(reversed(list(str(var_5))[len(str(var_5)) // 2 :]))\n if var_6 == var_7:\n var_2 += 1\n else:\n var_8 = list(str(var_5))[: len(str(var_5)) // 2 + 1]\n var_4 = list(reversed(list(str(var_5))[len(str(var_5)) // 2 :]))\n if var_8 == var_4:\n var_2 += 1\nprint(var_2)\n```", "output": "SLOWER 1.0742", "pair_id": "python_p03416_pair0187_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 2.1055} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\n\nvar_9 = sys.stdin.readline\nfrom operator import itemgetter\n\nvar_3, var_4 = list(map(int, var_9().split()))\nvar_1 = [list(map(int, var_9().split())) for _ in range(var_3)]\nvar_1.sort(key=itemgetter(0))\nvar_8 = [[0 for _ in range(var_3 + 1)] for _ in range(var_4 + 1)]\n\nvar_2 = []\nfor var_10 in range(var_3):\n var_5, var_7 = var_1[var_10]\n for var_11 in range(var_4):\n if var_5 > var_11:\n var_8[var_11][var_10 + 1] = var_8[var_11][var_10]\n else:\n if var_7 + var_8[var_11 - var_5][var_10] >= var_8[var_11][var_10]:\n var_8[var_11][var_10 + 1] = var_8[var_11 - var_5][var_10] + var_7\n else:\n var_8[var_11][var_10 + 1] = var_8[var_11][var_10]\n var_2.append(var_8[var_4 - 1][var_10] + var_7)\nvar_6 = max(var_2)\nprint(var_6)\n```\n\n=== Code B (Modified) ===\n```python\nfrom collections import Counter, defaultdict, deque\nfrom heapq import heappop, heappush, heapify\nimport sys, bisect, math, itertools, fractions, pprint\n\nsys.setrecursionlimit(10**8)\nvar_6 = 10**9 + 7\nvar_1 = float(\"inf\")\n\n\ndef func_1():\n return int(sys.stdin.readline())\n\n\ndef func_2():\n return list(map(int, sys.stdin.readline().split()))\n\n\nvar_8, var_11 = func_2()\nvar_17 = [func_2() for _ in range(var_8)]\nvar_10 = var_17[::-1]\nvar_14 = [[0] * var_11 for _ in range(var_8)]\nvar_3 = [[0] * var_11 for _ in range(var_8)]\nfor var_4 in range(var_8 - 1):\n var_16, var_15 = var_17[var_4]\n for var_5 in range(var_11):\n if var_5 < var_16:\n var_14[var_4 + 1][var_5] = var_14[var_4][var_5]\n else:\n var_14[var_4 + 1][var_5] = max(\n var_14[var_4][var_5], var_14[var_4][var_5 - var_16] + var_15\n )\nvar_9 = var_14[var_8 - 1][var_11 - 1] + var_17[var_8 - 1][1]\nfor var_4 in range(var_8 - 1):\n var_16, var_15 = var_10[var_4]\n for var_5 in range(var_11):\n if var_5 < var_16:\n var_3[var_4 + 1][var_5] = var_3[var_4][var_5]\n else:\n var_3[var_4 + 1][var_5] = max(\n var_3[var_4][var_5], var_3[var_4][var_5 - var_16] + var_15\n )\n var_9 = max(var_9, var_3[var_8 - 1][var_11 - 1] + var_17[0][1])\n\nfor var_4 in range(1, var_8 - 1):\n var_13 = var_4\n var_2 = var_8 - var_4 - 1\n var_7 = 0\n for var_5 in range(var_11):\n var_12 = var_14[var_13][var_5] + var_3[var_2][var_11 - 1 - var_5]\n var_7 = max(var_7, var_12)\n var_9 = max(var_9, var_7 + var_17[var_4][1])\nprint(var_9)\n```", "output": "SLOWER 1.024", "pair_id": "python_p02863_pair0040_reversed", "problem_id": "p02863", "language": "python", "direction": "reversed", "speedup_ratio": 2.0336} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().strip().split(\" \")))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n if str(var_4) == str(var_4)[::-1]:\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = [0] * (var_2 + 1)\nfor var_3 in range(1, var_2 + 1):\n if str(var_3) == str(var_3)[::-1]:\n var_4[var_3] = var_4[var_3 - 1] + 1\n else:\n var_4[var_3] = var_4[var_3 - 1]\nprint((var_4[var_2] - var_4[var_1 - 1]))\n```", "output": "SLOWER 1.635", "pair_id": "python_p03416_pair0146_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 3.1059} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = input().split()\nvar_1 = int(var_1)\nvar_2 = int(\"\".join(var_2.split(\".\")))\nprint(((var_1 * var_2) // 100))\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\nimport math\nfrom collections import defaultdict\nfrom bisect import bisect_left, bisect_right\n\nsys.setrecursionlimit(10**7)\n\n\ndef func_4():\n return sys.stdin.readline()[:-1]\n\n\nvar_4 = 10**9 + 7\n\n\ndef func_1():\n return int(eval(func_4()))\n\n\ndef func_2():\n return list(map(int, func_4().split()))\n\n\ndef func_3(var_6, var_3):\n if var_6 <= 0:\n return [[] for _ in range(var_3)]\n elif var_3 == 1:\n return [func_1() for _ in range(var_6)]\n else:\n var_5 = [func_2() for _ in range(var_6)]\n return list(map(list, list(zip(*var_5))))\n\n\nvar_1, var_2 = list(map(str, func_4().split()))\nvar_1 = int(var_1)\nvar_2 = 100 * int(var_2[0]) + 10 * int(var_2[2]) + int(var_2[3])\nprint((var_1 * var_2 // 100))\n```", "output": "SLOWER 2.5041", "pair_id": "python_p02659_pair0063_reversed", "problem_id": "p02659", "language": "python", "direction": "reversed", "speedup_ratio": 5.673} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = input().split()\nvar_1 = int(var_1)\nvar_2 = int(var_2)\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = list(str(var_4))\n if (var_5[0] == var_5[4]) and (var_5[1] == var_5[3]):\n var_3 = var_3 + 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\n\n\ndef func_1(var_5):\n var_4 = 0\n for var_3 in range(1, var_5 + 1):\n if str(var_3) == str(var_3)[::-1]:\n var_4 += 1\n return var_4\n\n\nprint((func_1(var_2) - func_1(var_1 - 1)))\n```", "output": "SLOWER 1.1863", "pair_id": "python_p03416_pair0197_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 2.2757} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_8 = int(eval(input()))\nvar_4 = []\nfor var_5 in range(var_8):\n var_11 = 0\n var_9 = list(map(int, input().split()))\n for var_6 in range(10):\n var_11 += var_9[var_6] << var_6\n var_4.append(var_11)\nvar_10 = []\nfor var_5 in range(var_8):\n var_10.append(list(map(int, input().split())))\nvar_1 = -(10**12)\nfor var_5 in range(1, 1 << 10):\n var_11 = 0\n for var_6 in range(var_8):\n var_3 = var_4[var_6] & var_5\n var_2 = 0\n for var_7 in range(10):\n if (var_3 >> var_7) % 2:\n var_2 += 1\n var_11 += var_10[var_6][var_2]\n var_1 = max(var_1, var_11)\nprint(var_1)\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\nimport itertools\n\n\ndef func_2(var_4):\n return bin(eval(\"0b\" + str(var_4)))\n\n\ndef func_1():\n var_4 = int(sys.stdin.readline().rstrip())\n var_9 = [\n func_2(\"\".join(str(var_10) for var_10 in sys.stdin.readline().split()))\n for _ in range(var_4)\n ]\n var_8 = [\n [int(var_10) for var_10 in sys.stdin.readline().split()] for _ in range(var_4)\n ]\n var_3 = -(10**10)\n for var_6 in itertools.product(\"01\", repeat=10):\n var_6 = func_2(\"\".join(var_6))\n if var_6 == \"0b0\":\n continue\n var_7 = 0\n for var_2 in range(var_4):\n var_1 = var_9[var_2]\n var_5 = bin(eval(var_1) & eval(var_6)).count(\"1\")\n var_7 += var_8[var_2][var_5]\n var_3 = max(var_3, var_7)\n print(var_3)\n\n\nif __name__ == \"__main__\":\n\n func_1()\n```", "output": "SLOWER 2.7368", "pair_id": "python_p03503_pair0048_reversed", "problem_id": "p03503", "language": "python", "direction": "reversed", "speedup_ratio": 6.6658} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = list(str(var_4))\n if var_5 == list(reversed(var_5)):\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1 = list(map(int, input().split()))\nvar_2 = 0\nfor var_3 in range(var_1[0], var_1[1] + 1):\n var_4 = str(var_3)\n if var_4[0] == var_4[4] and var_4[1] == var_4[3]:\n var_2 += 1\nprint(var_2)\n```", "output": "FASTER 1.521", "pair_id": "python_p03416_pair0242_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 2.8699} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_6 in range(var_1, var_2 + 1):\n var_3 = str(var_6)\n var_5 = True\n for var_7 in range(len(var_3) // 2):\n if var_3[var_7] != var_3[-var_7 - 1] and var_5:\n var_5 = not var_5\n if var_5:\n var_4 += 1\nprint(var_4)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = str(var_4)\n if var_5 == var_5[::-1]:\n var_3 += 1\nprint(var_3)\n```", "output": "FASTER 1.4644", "pair_id": "python_p03416_pair0089_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 2.7595} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport bisect\nimport sys\n\nsys.setrecursionlimit(10**6)\nvar_17 = sys.stdout.write\nvar_7 = lambda *var_15: print(*var_15) if var_1 else 0\nvar_1 = True\n\n\ndef func_1(var_10=sys.stdin.readline):\n var_12 = lambda: var_10().rstrip()\n var_3 = lambda: list(map(int, var_12().split()))\n var_2 = lambda: int(var_12())\n var_4 = lambda var_18: [var_3() for _ in range(var_18)]\n var_14, var_16 = var_3()\n var_5 = var_4(var_14)\n var_8 = [[0] * var_16 for _ in range(var_14)]\n for var_11 in range(1, var_14):\n for var_13 in range(1, var_16):\n if var_13 < var_5[var_11 - 1][0]:\n var_8[var_11][var_13] = var_8[var_11 - 1][var_13]\n else:\n var_8[var_11][var_13] = max(\n var_8[var_11 - 1][var_13],\n var_8[var_11 - 1][var_13 - var_5[var_11 - 1][0]]\n + var_5[var_11 - 1][1],\n )\n var_9 = [[0] * var_16 for _ in range(var_14)]\n for var_11 in range(1, var_14):\n for var_13 in range(1, var_16):\n if var_13 < var_5[var_14 - var_11][0]:\n var_9[var_11][var_13] = var_9[var_11 - 1][var_13]\n else:\n var_9[var_11][var_13] = max(\n var_9[var_11 - 1][var_13],\n var_9[var_11 - 1][var_13 - var_5[var_14 - var_11][0]]\n + var_5[var_14 - var_11][1],\n )\n var_6 = 0\n for var_11 in range(var_14):\n for var_13 in range(var_16 - 1):\n var_6 = max(\n var_6,\n var_8[var_11][var_13]\n + var_9[var_14 - var_11 - 1][var_16 - var_13 - 1]\n + var_5[var_11][1],\n )\n print(var_6)\n\n\nif __name__ == \"__main__\":\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\ndef func_1():\n var_2, var_3, *var_1 = list(map(int, open(0).read().split()))\n var_4 = [0] * (var_3 + max(var_1[::2]))\n for var_7, var_6 in sorted(zip(*[iter(var_1)] * 2)):\n for var_5 in reversed(list(range(var_3))):\n var_4[var_5 + var_7] = max(var_4[var_5 + var_7], var_4[var_5] + var_6)\n print((max(var_4)))\n\n\nfunc_1()\n```", "output": "FASTER 1.7019", "pair_id": "python_p02863_pair0067_forward", "problem_id": "p02863", "language": "python", "direction": "forward", "speedup_ratio": 3.2534} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_8, var_9 = list(map(int, input().split()))\nvar_5 = [[0] * (var_9 + 3001) for _ in range(var_8 + 1)]\nvar_3 = 0\nvar_2 = [list(map(int, input().split())) for _ in range(var_8)]\nvar_2.sort()\nfor var_6 in range(1, var_8 + 1):\n var_1, var_4 = var_2[var_6 - 1]\n for var_7 in range(var_9):\n var_5[var_6][var_7] = max(var_5[var_6 - 1][var_7], var_5[var_6][var_7])\n var_5[var_6][var_7 + var_1] = var_5[var_6 - 1][var_7] + var_4\n var_3 = max(var_5[var_6][var_7], var_5[var_6][var_7 + var_1], var_3)\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_6, var_7 = list(map(int, input().split()))\nvar_1 = [list(map(int, input().split())) for _ in range(var_6)]\nvar_1.sort()\nvar_3 = [(6007) * [0] for _ in range(var_6 + 1)]\nvar_3[0][0] = 0\nvar_2 = 0\nfor var_4 in range(var_6):\n for var_5 in range(6007):\n var_3[var_4 + 1][var_5] = max(var_3[var_4 + 1][var_5], var_3[var_4][var_5])\n if var_5 < var_7:\n var_3[var_4 + 1][var_5 + var_1[var_4][0]] = max(\n var_3[var_4][var_5] + var_1[var_4][1],\n var_3[var_4][var_5 + var_1[var_4][0]],\n )\n var_2 = max(var_2, var_3[var_4 + 1][var_5])\nprint(var_2)\n```", "output": "SLOWER 5.2101", "pair_id": "python_p02863_pair0002_reversed", "problem_id": "p02863", "language": "python", "direction": "reversed", "speedup_ratio": 37.0168} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport math\n\nvar_1, var_2 = input().split()\nvar_1 = int(var_1)\nvar_3 = int(var_2[0] + var_2[2] + var_2[3])\nprint((int(var_1 * var_3) // 100))\n```\n\n=== Code B (Modified) ===\n```python\ndef func_1():\n from sys import setrecursionlimit, stdin\n from os import environ\n from collections import defaultdict, deque, Counter\n from math import ceil, floor, gcd\n from itertools import accumulate, combinations, combinations_with_replacement\n\n setrecursionlimit(10**6)\n var_7 = (\n (lambda *var_11: print(*var_11))\n if \"TERM_PROGRAM\" in environ\n else lambda *var_12: 0\n )\n var_8 = lambda: stdin.readline().rstrip()\n var_3 = lambda: list(map(int, var_8().split()))\n var_1 = lambda: int(var_8())\n var_4 = 10**9 + 7\n var_2 = 10**9 + 10\n var_9, var_10 = var_8().split()\n var_5 = int(var_9)\n var_10 = var_10.split(\".\")\n var_6 = int(var_10[0]) * 100\n if len(var_10) == 2:\n var_6 += int(var_10[1])\n print(var_5 * var_6 // 100)\n\n\nfunc_1()\n```", "output": "SLOWER 2.1264", "pair_id": "python_p02659_pair0061_reversed", "problem_id": "p02659", "language": "python", "direction": "reversed", "speedup_ratio": 4.3663} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport copy\nimport random\nimport bisect\nimport fractions\nimport math\nimport sys\nimport collections\nfrom decimal import Decimal\n\nvar_5 = 10**9 + 7\nsys.setrecursionlimit(var_5)\nvar_3 = collections.deque()\n\n\ndef func_1():\n return list(map(int, sys.stdin.readline().split()))\n\n\nvar_1 = int(eval(input()))\nvar_6 = [0 for var_4 in range(var_1)]\nfor var_4 in range(var_1):\n var_6[var_4] = int(eval(input()))\nvar_6.sort()\nvar_2 = sum(var_6)\nvar_2 -= var_6[-1] // 2\nprint(var_2)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1 = int(eval(input()))\nvar_2 = []\nfor _ in range(var_1):\n var_2.append(int(eval(input())))\nprint((sum(var_2) - max(var_2) // 2))\n```", "output": "FASTER 1.0811", "pair_id": "python_p03207_pair0004_forward", "problem_id": "p03207", "language": "python", "direction": "forward", "speedup_ratio": 2.1156} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = list(str(var_4))\n if var_5 == list(reversed(var_5)):\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\ndef func_1():\n var_1, var_2 = list(map(int, input().rstrip().split()))\n var_3 = 0\n for var_4 in range(var_1, var_2 + 1):\n var_5 = str(var_4)\n if var_5 == var_5[::-1]:\n var_3 += 1\n print(var_3)\n\n\nif __name__ == \"__main__\":\n func_1()\n```", "output": "FASTER 1.9782", "pair_id": "python_p03416_pair0037_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 3.9399} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\nimport itertools\n\n\ndef func_2(var_4):\n return bin(eval(\"0b\" + str(var_4)))\n\n\ndef func_1():\n var_4 = int(sys.stdin.readline().rstrip())\n var_9 = [\n func_2(\"\".join(str(var_10) for var_10 in sys.stdin.readline().split()))\n for _ in range(var_4)\n ]\n var_8 = [\n [int(var_10) for var_10 in sys.stdin.readline().split()] for _ in range(var_4)\n ]\n var_3 = -(10**10)\n for var_6 in itertools.product(\"01\", repeat=10):\n var_6 = func_2(\"\".join(var_6))\n if var_6 == \"0b0\":\n continue\n var_7 = 0\n for var_2 in range(var_4):\n var_1 = var_9[var_2]\n var_5 = bin(eval(var_1) & eval(var_6)).count(\"1\")\n var_7 += var_8[var_2][var_5]\n var_3 = max(var_3, var_7)\n print(var_3)\n\n\nif __name__ == \"__main__\":\n\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\n\nvar_7 = sys.stdin.readline\nfrom itertools import combinations\n\n\ndef func_3(var_10):\n for _ in range(var_10):\n yield list(map(int, var_7().split()))\n\n\ndef func_1(var_9, var_5, var_11):\n var_3 = sum(1 if var_5[var_8] == 1 else 0 for var_8 in var_9)\n return var_11[var_3]\n\n\ndef func_2():\n var_10 = int(eval(var_7()))\n var_1 = list(func_3(var_10))\n var_2 = list(func_3(var_10))\n for var_6 in range(1, 11):\n for var_4 in combinations(list(range(10)), var_6):\n yield sum(\n func_1(var_4, var_5, var_11) for var_5, var_11 in zip(var_1, var_2)\n )\n\n\nprint((max(func_2())))\n```", "output": "FASTER 3.6491", "pair_id": "python_p03503_pair0032_forward", "problem_id": "p03503", "language": "python", "direction": "forward", "speedup_ratio": 12.5454} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport math\n\nvar_1, var_2 = input().split()\nvar_1 = int(var_1)\nvar_3 = int(var_2[0] + var_2[2] + var_2[3])\nprint((var_1 * var_3 // 100))\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\nimport math\nfrom collections import defaultdict\nfrom bisect import bisect_left, bisect_right\n\nsys.setrecursionlimit(10**7)\n\n\ndef func_4():\n return sys.stdin.readline()[:-1]\n\n\nvar_4 = 10**9 + 7\n\n\ndef func_1():\n return int(eval(func_4()))\n\n\ndef func_2():\n return list(map(int, func_4().split()))\n\n\ndef func_3(var_6, var_3):\n if var_6 <= 0:\n return [[] for _ in range(var_3)]\n elif var_3 == 1:\n return [func_1() for _ in range(var_6)]\n else:\n var_5 = [func_2() for _ in range(var_6)]\n return list(map(list, list(zip(*var_5))))\n\n\nfrom decimal import getcontext, Decimal\n\ngetcontext().prec = 28\nvar_1, var_2 = list(map(str, func_4().split()))\nvar_1 = int(var_1)\nvar_2 = Decimal(var_2)\nprint((int(var_1 * var_2)))\n```", "output": "SLOWER 2.3373", "pair_id": "python_p02659_pair0016_reversed", "problem_id": "p02659", "language": "python", "direction": "reversed", "speedup_ratio": 5.0534} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_5 = 0\nif var_5 == 0:\n var_8 = int(eval(input()))\n var_2 = []\n for var_4 in range(var_8):\n var_3 = list(map(int, input().split()))\n var_2.append(var_3)\n var_9 = []\n for var_4 in range(var_8):\n var_10 = list(map(int, input().split()))\n var_9.append(var_10)\nelif var_5 == 1:\n var_8 = 1\n var_2 = [[1, 1, 0, 1, 0, 0, 0, 1, 0, 1]]\n var_9 = [[3, 4, 5, 6, 7, 8, 9, -2, -3, 4, -2]]\nelif var_5 == 2:\n var_8 = 2\n var_2 = [[1, 1, 1, 1, 1, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 1, 1, 1, 1, 1]]\n var_9 = [\n [0, -2, -2, -2, -2, -2, -1, -1, -1, -1, -1],\n [0, -2, -2, -2, -2, -2, -1, -1, -1, -1, -1],\n ]\nelif var_5 == 3:\n var_8 = 3\n var_2 = [\n [1, 1, 1, 1, 1, 1, 0, 0, 1, 1],\n [0, 1, 0, 1, 1, 1, 1, 0, 1, 0],\n [1, 0, 1, 1, 0, 1, 0, 1, 0, 1],\n ]\n var_9 = [\n [-8, 6, -2, -8, -8, 4, 8, 7, -6, 2, 2],\n [-9, 2, 0, 1, 7, -5, 0, -2, -6, 5, 5],\n [6, -6, 7, -9, 6, -5, 8, 0, -9, -7, -7],\n ]\nimport itertools\n\nvar_13 = -(10**11)\nfor var_4 in itertools.product([0, 1], repeat=10):\n var_11 = list(var_4)\n var_12 = 0\n if sum(var_11) != 0:\n for var_7 in range(var_8):\n var_1 = 0\n for var_6 in range(10):\n var_1 = var_1 + var_11[var_6] * var_2[var_7][var_6]\n var_12 = var_12 + var_9[var_7][var_1]\n\n var_13 = max(var_12, var_13)\nprint(var_13)\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\n\nvar_7 = sys.stdin.readline\nfrom itertools import combinations\n\n\ndef func_3(var_10):\n for _ in range(var_10):\n yield list(map(int, var_7().split()))\n\n\ndef func_1(var_9, var_5, var_11):\n var_3 = len([0 for var_8 in var_9 if var_5[var_8] == 1])\n return var_11[var_3]\n\n\ndef func_2():\n var_10 = int(eval(var_7()))\n var_1 = list(func_3(var_10))\n var_2 = list(func_3(var_10))\n for var_6 in range(1, 11):\n for var_4 in combinations(list(range(10)), var_6):\n yield sum(\n func_1(var_4, var_5, var_11) for var_5, var_11 in zip(var_1, var_2)\n )\n\n\nprint((max(func_2())))\n```", "output": "FASTER 2.018", "pair_id": "python_p03503_pair0040_forward", "problem_id": "p03503", "language": "python", "direction": "forward", "speedup_ratio": 4.0503} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_6 in range(var_1, var_2 + 1):\n var_3 = str(var_6)\n var_5 = True\n for var_7 in range(len(var_3) // 2):\n if var_3[var_7] != var_3[-var_7 - 1] and var_5:\n var_5 = not var_5\n if var_5:\n var_4 += 1\nprint(var_4)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = str(var_4)\n if var_5[0] == var_5[4] and var_5[1] == var_5[3]:\n var_3 += 1\nprint(var_3)\n```", "output": "FASTER 1.7261", "pair_id": "python_p03416_pair0193_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 3.3083} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\ndef func_1():\n var_1, var_2 = list(map(int, input().rstrip().split()))\n var_3 = 0\n for var_4 in range(var_1, var_2 + 1):\n var_5 = str(var_4)\n if var_5 == var_5[::-1]:\n var_3 += 1\n print(var_3)\n\n\nif __name__ == \"__main__\":\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = [0] * (var_2 + 1)\nfor var_3 in range(1, var_2 + 1):\n if str(var_3) == str(var_3)[::-1]:\n var_4[var_3] = var_4[var_3 - 1] + 1\n else:\n var_4[var_3] = var_4[var_3 - 1]\nprint((var_4[var_2] - var_4[var_1 - 1]))\n```", "output": "SLOWER 2.6882", "pair_id": "python_p03416_pair0155_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 6.4453} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = [\n var_3 for var_3 in map(str, list(range(var_1, var_2 + 1))) if var_3 == var_3[::-1]\n]\nprint((len(var_4)))\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_6 in range(var_1, var_2 + 1):\n var_3 = str(var_6)\n var_5 = True\n for var_7 in range(len(var_3) // 2):\n if var_3[var_7] != var_3[-var_7 - 1] and var_5:\n var_5 = not var_5\n if var_5:\n var_4 += 1\nprint(var_4)\n```", "output": "SLOWER 2.1585", "pair_id": "python_p03416_pair0243_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 4.4645} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_5 in range(10):\n for var_6 in range(10):\n for var_7 in range(10):\n var_3 = 10000 * var_5 + 1000 * var_6 + 100 * var_7 + 10 * var_6 + var_5\n if var_1 <= var_3 <= var_2:\n var_4 += 1\nprint(var_4)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_6 = str(var_4)\n var_5 = var_6[::-1]\n if var_6 == var_5:\n var_3 += 1\nprint(var_3)\n```", "output": "SLOWER 4.076", "pair_id": "python_p03416_pair0203_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 16.8649} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n if str(var_4) == \"\".join(reversed(str(var_4))):\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\n\n\ndef func_1(var_5, var_6):\n var_4 = 0\n for var_3 in range(var_5, var_6 + 1):\n if str(var_3) == str(var_3)[::-1]:\n var_4 += 1\n return var_4\n\n\nprint((func_1(var_1, var_2)))\n```", "output": "FASTER 1.3999", "pair_id": "python_p03416_pair0134_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 2.6388} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_4 = {}\nvar_5 = 0\nfor var_6 in range(10000, 100000):\n var_3 = list(str(var_6))\n if var_3 == list(reversed(var_3)):\n var_5 += 1\n var_4[var_6] = var_5\nvar_1, var_2 = list(map(int, input().split()))\nprint((var_4[var_2] - var_4[var_1 - 1] if var_1 > 10000 else var_4[var_2]))\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\n\n\ndef func_1(var_5):\n var_4 = 0\n for var_3 in range(1, var_5 + 1):\n if str(var_3) == str(var_3)[::-1]:\n var_4 += 1\n return var_4\n\n\nprint((func_1(var_2) - func_1(var_1 - 1)))\n```", "output": "FASTER 1.983", "pair_id": "python_p03416_pair0244_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 3.9531} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport math\nfrom decimal import Decimal\n\nvar_1, var_2 = list(map(Decimal, input().split()))\nprint((math.floor(var_1 * var_2)))\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\nimport math\nfrom collections import defaultdict\nfrom bisect import bisect_left, bisect_right\n\nsys.setrecursionlimit(10**7)\n\n\ndef func_4():\n return sys.stdin.readline()[:-1]\n\n\nvar_4 = 10**9 + 7\n\n\ndef func_1():\n return int(eval(func_4()))\n\n\ndef func_2():\n return list(map(int, func_4().split()))\n\n\ndef func_3(var_6, var_3):\n if var_6 <= 0:\n return [[] for _ in range(var_3)]\n elif var_3 == 1:\n return [func_1() for _ in range(var_6)]\n else:\n var_5 = [func_2() for _ in range(var_6)]\n return list(map(list, list(zip(*var_5))))\n\n\nfrom decimal import getcontext, Decimal\n\ngetcontext().prec = 28\nvar_1, var_2 = list(map(str, func_4().split()))\nvar_1 = int(var_1)\nvar_2 = Decimal(var_2)\nprint((int(var_1 * var_2)))\n```", "output": "SLOWER 2.4359", "pair_id": "python_p02659_pair0008_reversed", "problem_id": "p02659", "language": "python", "direction": "reversed", "speedup_ratio": 5.4109} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\ndef func_1():\n var_2, var_3, *var_1 = list(map(int, open(0).read().split()))\n var_4 = [0] * (var_3 + max(var_1[::2]))\n for var_7, var_6 in sorted(zip(*[iter(var_1)] * 2)):\n for var_5 in reversed(list(range(var_3))):\n var_4[var_5 + var_7] = max(var_4[var_5 + var_7], var_4[var_5] + var_6)\n print((max(var_4)))\n\n\nfunc_1()\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\n\nvar_9 = sys.stdin.readline\nfrom operator import itemgetter\n\nvar_3, var_4 = list(map(int, var_9().split()))\nvar_1 = [list(map(int, var_9().split())) for _ in range(var_3)]\nvar_1.sort(key=itemgetter(0))\nvar_8 = [[0 for _ in range(var_3 + 1)] for _ in range(var_4 + 1)]\n\nvar_2 = []\nfor var_10 in range(var_3):\n var_5, var_7 = var_1[var_10]\n for var_11 in range(var_4):\n if var_5 > var_11:\n var_8[var_11][var_10 + 1] = var_8[var_11][var_10]\n else:\n if var_7 + var_8[var_11 - var_5][var_10] >= var_8[var_11][var_10]:\n var_8[var_11][var_10 + 1] = var_8[var_11 - var_5][var_10] + var_7\n else:\n var_8[var_11][var_10 + 1] = var_8[var_11][var_10]\n var_2.append(var_8[var_4 - 1][var_10] + var_7)\nvar_6 = max(var_2)\nprint(var_6)\n```", "output": "SLOWER 1.2754", "pair_id": "python_p02863_pair0064_reversed", "problem_id": "p02863", "language": "python", "direction": "reversed", "speedup_ratio": 2.4207} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\ndef func_1():\n var_1, var_2 = list(map(int, input().rstrip().split()))\n var_3 = 0\n for var_4 in range(var_1, var_2 + 1):\n var_5 = str(var_4)\n if var_5 == var_5[::-1]:\n var_3 += 1\n print(var_3)\n\n\nif __name__ == \"__main__\":\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_6 in range(var_1, var_2 + 1):\n var_3 = str(var_6)\n var_5 = True\n for var_7 in range(len(var_3) // 2):\n if var_3[var_7] != var_3[-var_7 - 1] and var_5:\n var_5 = not var_5\n if var_5:\n var_4 += 1\nprint(var_4)\n```", "output": "SLOWER 2.2059", "pair_id": "python_p03416_pair0063_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 4.6137} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = list(reversed(list(str(var_4))))\n if var_5 == list(str(var_4)):\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = str(var_4)\n if var_5 == var_5[::-1]:\n var_3 += 1\nprint(var_3)\n```", "output": "FASTER 1.6614", "pair_id": "python_p03416_pair0228_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 3.1633} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_6 = sorted([list(map(int, input().split())) for var_5 in range(var_1)])\n\nvar_4 = [[0] * (var_2 + 1) for var_5 in range(var_1 + 1)]\n\nfor var_5 in range(var_1):\n var_9, var_8 = var_6[var_5]\n for var_7 in range(var_2 + 1):\n if var_7 + var_9 <= var_2:\n var_4[var_5 + 1][var_7 + var_9] = max(\n var_4[var_5 + 1][var_7 + var_9], var_4[var_5][var_7] + var_8\n )\n var_4[var_5 + 1][var_7] = max(var_4[var_5][var_7], var_4[var_5 + 1][var_7])\nvar_3 = 0\nfor var_5, (var_9, var_8) in enumerate(var_6):\n var_3 = max(var_3, var_4[var_5][var_2 - 1] + var_8)\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_6, var_7 = list(map(int, input().split()))\nvar_1 = [list(map(int, input().split())) for _ in range(var_6)]\nvar_1.sort()\nvar_3 = [(6007) * [0] for _ in range(var_6 + 1)]\nvar_3[0][0] = 0\nvar_2 = 0\nfor var_4 in range(var_6):\n for var_5 in range(6007):\n var_3[var_4 + 1][var_5] = max(var_3[var_4 + 1][var_5], var_3[var_4][var_5])\n if var_5 < var_7:\n var_3[var_4 + 1][var_5 + var_1[var_4][0]] = max(\n var_3[var_4][var_5] + var_1[var_4][1],\n var_3[var_4][var_5 + var_1[var_4][0]],\n )\n var_2 = max(var_2, var_3[var_4 + 1][var_5])\nprint(var_2)\n```", "output": "SLOWER 5.3151", "pair_id": "python_p02863_pair0048_reversed", "problem_id": "p02863", "language": "python", "direction": "reversed", "speedup_ratio": 39.8117} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_4 = {}\nvar_5 = 0\nfor var_6 in range(10000, 100000):\n var_3 = list(str(var_6))\n if var_3 == list(reversed(var_3)):\n var_5 += 1\n var_4[var_6] = var_5\nvar_1, var_2 = list(map(int, input().split()))\nprint((var_4[var_2] - var_4[var_1 - 1] if var_1 > 10000 else var_4[var_2]))\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = str(var_4)\n if var_5[0] == var_5[4] and var_5[1] == var_5[3]:\n var_3 += 1\nprint(var_3)\n```", "output": "FASTER 3.8398", "pair_id": "python_p03416_pair0221_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 14.318} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\ndef func_1():\n from sys import setrecursionlimit, stdin\n from os import environ\n from collections import defaultdict, deque, Counter\n from math import ceil, floor, gcd\n from itertools import accumulate, combinations, combinations_with_replacement\n\n setrecursionlimit(10**6)\n var_7 = (\n (lambda *var_11: print(*var_11))\n if \"TERM_PROGRAM\" in environ\n else lambda *var_12: 0\n )\n var_8 = lambda: stdin.readline().rstrip()\n var_3 = lambda: list(map(int, var_8().split()))\n var_1 = lambda: int(var_8())\n var_4 = 10**9 + 7\n var_2 = 10**9 + 10\n var_9, var_10 = var_8().split()\n var_5 = int(var_9)\n var_10 = var_10.split(\".\")\n var_6 = int(var_10[0]) * 100\n if len(var_10) == 2:\n var_6 += int(var_10[1])\n print(var_5 * var_6 // 100)\n\n\nfunc_1()\n```\n\n=== Code B (Modified) ===\n```python\nfrom decimal import Decimal\nimport math\n\nvar_1, var_2 = list(map(str, input().split()))\nvar_1 = int(var_1)\nvar_2 = Decimal(var_2)\nvar_3 = math.floor(var_1 * var_2)\nprint((int(var_3)))\n```", "output": "FASTER 1.825", "pair_id": "python_p02659_pair0062_forward", "problem_id": "p02659", "language": "python", "direction": "forward", "speedup_ratio": 3.543} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nfrom collections import Counter, defaultdict, deque\nfrom heapq import heappop, heappush, heapify\nimport sys, bisect, math, itertools, fractions, pprint\n\nsys.setrecursionlimit(10**8)\nvar_6 = 10**9 + 7\nvar_1 = float(\"inf\")\n\n\ndef func_1():\n return int(sys.stdin.readline())\n\n\ndef func_2():\n return list(map(int, sys.stdin.readline().split()))\n\n\nvar_8, var_11 = func_2()\nvar_17 = [func_2() for _ in range(var_8)]\nvar_10 = var_17[::-1]\nvar_14 = [[0] * var_11 for _ in range(var_8)]\nvar_3 = [[0] * var_11 for _ in range(var_8)]\nfor var_4 in range(var_8 - 1):\n var_16, var_15 = var_17[var_4]\n for var_5 in range(var_11):\n if var_5 < var_16:\n var_14[var_4 + 1][var_5] = var_14[var_4][var_5]\n else:\n var_14[var_4 + 1][var_5] = max(\n var_14[var_4][var_5], var_14[var_4][var_5 - var_16] + var_15\n )\nvar_9 = var_14[var_8 - 1][var_11 - 1] + var_17[var_8 - 1][1]\nfor var_4 in range(var_8 - 1):\n var_16, var_15 = var_10[var_4]\n for var_5 in range(var_11):\n if var_5 < var_16:\n var_3[var_4 + 1][var_5] = var_3[var_4][var_5]\n else:\n var_3[var_4 + 1][var_5] = max(\n var_3[var_4][var_5], var_3[var_4][var_5 - var_16] + var_15\n )\n var_9 = max(var_9, var_3[var_8 - 1][var_11 - 1] + var_17[0][1])\n\nfor var_4 in range(1, var_8 - 1):\n var_13 = var_4\n var_2 = var_8 - var_4 - 1\n var_7 = 0\n for var_5 in range(var_11):\n var_12 = var_14[var_13][var_5] + var_3[var_2][var_11 - 1 - var_5]\n var_7 = max(var_7, var_12)\n var_9 = max(var_9, var_7 + var_17[var_4][1])\nprint(var_9)\n```\n\n=== Code B (Modified) ===\n```python\nvar_2, var_3, *var_1 = list(map(int, open(0).read().split()))\nvar_4 = [0] * (var_3 + max(var_1[::2]))\nfor var_7, var_6 in sorted(zip(*[iter(var_1)] * 2)):\n for var_5 in reversed(list(range(var_3))):\n var_4[var_5 + var_7] = max(var_4[var_5 + var_7], var_4[var_5] + var_6)\nprint((max(var_4)))\n```", "output": "FASTER 1.5875", "pair_id": "python_p02863_pair0009_forward", "problem_id": "p02863", "language": "python", "direction": "forward", "speedup_ratio": 3.0053} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_3 = list(map(int, input().split()))\nvar_2 = 0\nfor var_5 in range(var_3 + 1)[var_1:]:\n if len(str(var_5)) % 2 == 0:\n var_6 = list(str(var_5))[: len(str(var_5)) // 2]\n var_7 = list(reversed(list(str(var_5))[len(str(var_5)) // 2 :]))\n if var_6 == var_7:\n var_2 += 1\n else:\n var_8 = list(str(var_5))[: len(str(var_5)) // 2 + 1]\n var_4 = list(reversed(list(str(var_5))[len(str(var_5)) // 2 :]))\n if var_8 == var_4:\n var_2 += 1\nprint(var_2)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_4 = str(var_4)\n if var_4[0] == var_4[-1] and var_4[1] == var_4[-2]:\n var_3 += 1\nprint(var_3)\n```", "output": "FASTER 2.6583", "pair_id": "python_p03416_pair0245_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 6.3127} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport copy\n\nvar_8 = int(eval(input()))\nvar_10 = set([var_6 for var_6 in range(1, 10**5)])\nvar_5 = []\nvar_11 = {}\nvar_9 = []\nfor var_6 in range(var_8 - 1):\n var_1, var_2 = list(map(int, input().split(\" \")))\n var_5.append([var_1, var_2])\n var_11.setdefault(var_1, []).append(var_2)\n var_9.append([])\nvar_9.append([])\nvar_9.append([])\nvar_7 = 0\nfor var_12 in range(1, var_8 + 1):\n var_14 = var_11.get(var_12, [])\n var_3 = 1\n for var_13 in var_14:\n if var_3 in var_9[var_12]:\n var_3 += 1\n else:\n pass\n var_9[var_13].append(var_3)\n if var_3 >= var_7:\n var_7 = var_3\n var_3 += 1\nprint(var_7)\nfor var_4 in var_5:\n print((var_9[var_4[1]][0]))\n```\n\n=== Code B (Modified) ===\n```python\nfrom collections import deque\n\nvar_4, *var_2 = list(map(int, open(0).read().split()))\nvar_3 = [set() for _ in range(var_4 + 1)]\nfor var_9, (var_6, var_7) in enumerate(zip(*[iter(var_2)] * 2)):\n var_3[var_6].add((var_7, var_9))\n var_3[var_7].add((var_6, var_9))\nvar_1 = [0] * (var_4 - 1)\nvar_5 = deque([1])\nwhile var_5:\n var_10, var_12 = divmod(var_5.popleft(), var_4 + 1)\n var_8 = 0\n for var_11, var_9 in var_3[var_12]:\n var_3[var_11].remove((var_12, var_9))\n var_8 += 1 + (var_8 + 1 == var_10)\n var_5.append(var_8 * (var_4 + 1) + var_11)\n var_1[var_9] = var_8\nprint((max(var_1)))\nprint((\"\\n\".join(map(str, var_1))))\n```", "output": "FASTER 4.4548", "pair_id": "python_p02850_pair0009_forward", "problem_id": "p02850", "language": "python", "direction": "forward", "speedup_ratio": 21.93} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport bisect\nimport sys\n\nsys.setrecursionlimit(10**6)\nvar_17 = sys.stdout.write\nvar_7 = lambda *var_15: print(*var_15) if var_1 else 0\nvar_1 = True\n\n\ndef func_1(var_10=sys.stdin.readline):\n var_12 = lambda: var_10().rstrip()\n var_3 = lambda: list(map(int, var_12().split()))\n var_2 = lambda: int(var_12())\n var_4 = lambda var_18: [var_3() for _ in range(var_18)]\n var_14, var_16 = var_3()\n var_5 = var_4(var_14)\n var_8 = [[0] * var_16 for _ in range(var_14)]\n for var_11 in range(1, var_14):\n for var_13 in range(1, var_16):\n if var_13 < var_5[var_11 - 1][0]:\n var_8[var_11][var_13] = var_8[var_11 - 1][var_13]\n else:\n var_8[var_11][var_13] = max(\n var_8[var_11 - 1][var_13],\n var_8[var_11 - 1][var_13 - var_5[var_11 - 1][0]]\n + var_5[var_11 - 1][1],\n )\n var_9 = [[0] * var_16 for _ in range(var_14)]\n for var_11 in range(1, var_14):\n for var_13 in range(1, var_16):\n if var_13 < var_5[var_14 - var_11][0]:\n var_9[var_11][var_13] = var_9[var_11 - 1][var_13]\n else:\n var_9[var_11][var_13] = max(\n var_9[var_11 - 1][var_13],\n var_9[var_11 - 1][var_13 - var_5[var_14 - var_11][0]]\n + var_5[var_14 - var_11][1],\n )\n var_6 = 0\n for var_11 in range(var_14):\n for var_13 in range(var_16 - 1):\n var_6 = max(\n var_6,\n var_8[var_11][var_13]\n + var_9[var_14 - var_11 - 1][var_16 - var_13 - 1]\n + var_5[var_11][1],\n )\n print(var_6)\n\n\nif __name__ == \"__main__\":\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nfrom collections import Counter, defaultdict, deque\nfrom heapq import heappop, heappush, heapify\nimport sys, bisect, math, itertools, fractions, pprint\n\nsys.setrecursionlimit(10**8)\nvar_6 = 10**9 + 7\nvar_1 = float(\"inf\")\n\n\ndef func_1():\n return int(sys.stdin.readline())\n\n\ndef func_2():\n return list(map(int, sys.stdin.readline().split()))\n\n\nvar_7, var_9 = func_2()\nvar_13 = [func_2() for _ in range(var_7)]\nvar_13.sort(key=lambda var_14: var_14[1], reverse=True)\nvar_8 = 0\nvar_10 = min(var_7, 5)\nfor var_3 in range(var_10):\n var_2 = [[0] * (var_9 + 5) for _ in range(var_7 + 5)]\n for var_4 in range(var_7):\n var_12, var_11 = var_13[var_4]\n for var_5 in range(var_9):\n if var_5 < var_12 or var_3 == var_4:\n var_2[var_4 + 1][var_5] = var_2[var_4][var_5]\n else:\n var_2[var_4 + 1][var_5] = max(\n var_2[var_4][var_5], var_2[var_4][var_5 - var_12] + var_11\n )\n\n var_8 = max(var_2[var_7][var_9 - 1] + var_13[var_3][1], var_8)\nprint(var_8)\n```", "output": "SLOWER 1.236", "pair_id": "python_p02863_pair0054_reversed", "problem_id": "p02863", "language": "python", "direction": "reversed", "speedup_ratio": 2.3555} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_7 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_3 = True\n var_8 = str(var_4)\n var_6 = len(var_8)\n for var_5 in range(var_6 // 2 + 1):\n if var_8[var_5] != var_8[-var_5 - 1]:\n var_3 = False\n break\n if var_3:\n var_7 += 1\nprint(var_7)\n```\n\n=== Code B (Modified) ===\n```python\nfrom sys import stdin\n\nvar_6 = lambda: list(map(int, stdin.readline().split()))\nvar_5 = lambda: list(map(int, stdin.readline().split()))\nvar_1, var_3 = var_6()\nvar_2 = 0\nfor var_4 in range(var_1, var_3 + 1):\n var_7 = str(var_4)\n if var_7 == var_7[::-1]:\n var_2 += 1\nprint(var_2)\n```", "output": "FASTER 1.1067", "pair_id": "python_p03416_pair0149_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 2.1535} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nfrom itertools import product\n\nvar_6 = int(eval(input()))\nvar_1 = list(map(int, input().split()))\nvar_5 = 0\nfor var_2 in product((-1, 0, 1), repeat=var_6):\n var_7 = 1\n for var_3, var_4 in zip(var_1, var_2):\n var_7 *= var_3 + var_4\n if var_7 % 2 == 0:\n var_5 += 1\nprint(var_5)\n```\n\n=== Code B (Modified) ===\n```python\nimport math\nimport string\n\n\ndef func_5():\n return list(map(int, input().split()))\n\n\ndef func_4(var_7, var_8):\n return math.factorial(var_7) // (\n math.factorial(var_7 - var_8) * math.factorial(var_8)\n )\n\n\ndef func_3(var_10):\n var_9 = []\n for var_5 in var_10:\n if not (var_5 in var_9):\n var_9.append(var_5)\n return len(var_10) != len(var_9)\n\n\ndef func_1(var_7):\n func_1 = []\n for var_4 in range(1, var_7 + 1):\n if var_7 % var_4 == 0:\n func_1.append(var_4)\n return func_1\n\n\nvar_2 = [-1, -1, -1, 0, 0, 1, 1, 1]\nvar_3 = [-1, 0, 1, -1, 1, -1, 0, 1]\nvar_7 = int(eval(input()))\nvar_1 = func_5()\n\n\ndef func_2(var_6):\n if len(var_6) == var_7:\n for var_4 in range(len(var_6)):\n if var_6[var_4] % 2 == 0:\n return 1\n return 0\n return (\n func_2(var_6 + [var_1[len(var_6)]])\n + func_2(var_6 + [var_1[len(var_6)] - 1])\n + func_2(var_6 + [var_1[len(var_6)] + 1])\n )\n\n\nprint((func_2([])))\n```", "output": "FASTER 2.3865", "pair_id": "python_p03568_pair0050_forward", "problem_id": "p03568", "language": "python", "direction": "forward", "speedup_ratio": 5.2288} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_8 = int(eval(input()))\nvar_4 = []\nfor var_5 in range(var_8):\n var_11 = 0\n var_9 = list(map(int, input().split()))\n for var_6 in range(10):\n var_11 += var_9[var_6] << var_6\n var_4.append(var_11)\nvar_10 = []\nfor var_5 in range(var_8):\n var_10.append(list(map(int, input().split())))\nvar_1 = -(10**12)\nfor var_5 in range(1, 1 << 10):\n var_11 = 0\n for var_6 in range(var_8):\n var_3 = var_4[var_6] & var_5\n var_2 = 0\n for var_7 in range(10):\n if (var_3 >> var_7) % 2:\n var_2 += 1\n var_11 += var_10[var_6][var_2]\n var_1 = max(var_1, var_11)\nprint(var_1)\n```\n\n=== Code B (Modified) ===\n```python\nfrom sys import stdin\n\n\ndef func_1():\n\n var_11 = stdin.readline\n var_2 = int(var_11())\n var_1 = []\n for var_6 in range(var_2):\n var_5 = int(\"\".join(var_11().strip().split(\" \")), 2)\n var_1.append(var_5)\n var_3 = []\n for var_6 in range(var_2):\n var_10 = list(map(int, var_11().split()))\n var_3.append(var_10)\n var_8 = float(\"-inf\")\n for var_9 in range(1, 1 << 10):\n var_12 = 0\n for var_7 in range(var_2):\n var_4 = bin(var_9 & var_1[var_7]).count(\"1\")\n var_12 += var_3[var_7][var_4]\n var_8 = max(var_12, var_8)\n print(var_8)\n\n\nif __name__ == \"__main__\":\n func_1()\n```", "output": "FASTER 2.7133", "pair_id": "python_p03503_pair0049_forward", "problem_id": "p03503", "language": "python", "direction": "forward", "speedup_ratio": 6.558} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\nimport itertools\n\n\ndef func_2(var_4):\n return bin(eval(\"0b\" + str(var_4)))\n\n\ndef func_1():\n var_4 = int(sys.stdin.readline().rstrip())\n var_9 = [\n func_2(\"\".join(str(var_10) for var_10 in sys.stdin.readline().split()))\n for _ in range(var_4)\n ]\n var_8 = [\n [int(var_10) for var_10 in sys.stdin.readline().split()] for _ in range(var_4)\n ]\n var_3 = -(10**10)\n for var_6 in itertools.product(\"01\", repeat=10):\n var_6 = func_2(\"\".join(var_6))\n if var_6 == \"0b0\":\n continue\n var_7 = 0\n for var_2 in range(var_4):\n var_1 = var_9[var_2]\n var_5 = bin(eval(var_1) & eval(var_6)).count(\"1\")\n var_7 += var_8[var_2][var_5]\n var_3 = max(var_3, var_7)\n print(var_3)\n\n\nif __name__ == \"__main__\":\n\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nvar_8 = int(eval(input()))\nvar_4 = []\nfor var_5 in range(var_8):\n var_11 = 0\n var_9 = list(map(int, input().split()))\n for var_6 in range(10):\n var_11 += var_9[var_6] << var_6\n var_4.append(var_11)\nvar_10 = []\nfor var_5 in range(var_8):\n var_10.append(list(map(int, input().split())))\nvar_1 = -(10**12)\nfor var_5 in range(1, 1 << 10):\n var_11 = 0\n for var_6 in range(var_8):\n var_3 = list(bin(var_4[var_6] & var_5)[2:])\n var_2 = 0\n for var_7 in var_3:\n if var_7 == \"1\":\n var_2 += 1\n var_11 += var_10[var_6][var_2]\n var_1 = max(var_1, var_11)\nprint(var_1)\n```", "output": "FASTER 3.1052", "pair_id": "python_p03503_pair0016_forward", "problem_id": "p03503", "language": "python", "direction": "forward", "speedup_ratio": 8.605} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\nfrom operator import itemgetter\nfrom heapq import heapify, heappop, heappush\n\nvar_1 = int(10e15)\nvar_2 = -var_1\nvar_11 = 1000000007\nsys.setrecursionlimit(1000000)\n\n\ndef func_2():\n return list(map(int, input().split()))\n\n\ndef func_4():\n return input().split()\n\n\ndef func_1():\n return int(sys.stdin.readline())\n\n\ndef func_3():\n return eval(input())\n\n\nvar_3, var_4 = func_2()\nvar_5 = [func_2() for var_9 in range(var_3)]\nvar_5.sort(key=itemgetter(0))\n\nvar_8 = [[0] * (var_4 + 1 + 3000 + 1) for _ in range(var_3 + 1)]\nvar_6 = 0\nfor var_9 in range(var_3):\n for var_10 in range(var_4 + 1 + 3000 + 1):\n var_12, var_7 = var_5[var_9]\n if 0 <= var_10 - var_12 < var_4:\n var_8[var_9 + 1][var_10] = max(\n var_8[var_9][var_10], var_8[var_9][var_10 - var_12] + var_7\n )\n else:\n var_8[var_9 + 1][var_10] = var_8[var_9][var_10]\n var_6 = max(var_6, var_8[var_9 + 1][var_10])\nprint(var_6)\n```\n\n=== Code B (Modified) ===\n```python\nfrom sys import stdin\n\n\ndef func_1():\n\n var_9 = stdin.readline\n var_8, var_10 = list(map(int, var_9().split()))\n var_7 = [list(map(int, var_9().split())) for _ in range(var_8)]\n var_7.sort()\n var_1 = [0] * var_8\n var_2 = [0] * var_8\n for var_4 in range(var_8):\n var_1[var_4], var_2[var_4] = var_7[var_4][0], var_7[var_4][1]\n\n var_5 = -float(\"inf\")\n var_3 = [[var_5] * (var_10 + 1) for _ in range(var_8 + 1)]\n var_3[0][0] = 0\n for var_4 in range(var_8):\n for var_6 in range(var_10 + 1):\n\n if var_6 != var_10:\n var_3[var_4 + 1][min(var_10, var_6 + var_1[var_4])] = max(\n var_3[var_4 + 1][min(var_10, var_6 + var_1[var_4])],\n var_3[var_4][var_6] + var_2[var_4],\n )\n\n var_3[var_4 + 1][var_6] = max(var_3[var_4 + 1][var_6], var_3[var_4][var_6])\n print((max(var_3[var_8])))\n\n\nif __name__ == \"__main__\":\n func_1()\n```", "output": "FASTER 4.8948", "pair_id": "python_p02863_pair0068_forward", "problem_id": "p02863", "language": "python", "direction": "forward", "speedup_ratio": 29.7492} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_5 = 0\nif var_5 == 0:\n var_8 = int(eval(input()))\n var_2 = []\n for var_4 in range(var_8):\n var_3 = list(map(int, input().split()))\n var_2.append(var_3)\n var_9 = []\n for var_4 in range(var_8):\n var_10 = list(map(int, input().split()))\n var_9.append(var_10)\nelif var_5 == 1:\n var_8 = 1\n var_2 = [[1, 1, 0, 1, 0, 0, 0, 1, 0, 1]]\n var_9 = [[3, 4, 5, 6, 7, 8, 9, -2, -3, 4, -2]]\nelif var_5 == 2:\n var_8 = 2\n var_2 = [[1, 1, 1, 1, 1, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 1, 1, 1, 1, 1]]\n var_9 = [\n [0, -2, -2, -2, -2, -2, -1, -1, -1, -1, -1],\n [0, -2, -2, -2, -2, -2, -1, -1, -1, -1, -1],\n ]\nelif var_5 == 3:\n var_8 = 3\n var_2 = [\n [1, 1, 1, 1, 1, 1, 0, 0, 1, 1],\n [0, 1, 0, 1, 1, 1, 1, 0, 1, 0],\n [1, 0, 1, 1, 0, 1, 0, 1, 0, 1],\n ]\n var_9 = [\n [-8, 6, -2, -8, -8, 4, 8, 7, -6, 2, 2],\n [-9, 2, 0, 1, 7, -5, 0, -2, -6, 5, 5],\n [6, -6, 7, -9, 6, -5, 8, 0, -9, -7, -7],\n ]\nimport itertools\n\nvar_13 = -(10**11)\nfor var_4 in itertools.product([0, 1], repeat=10):\n var_11 = list(var_4)\n var_12 = 0\n if sum(var_11) != 0:\n for var_7 in range(var_8):\n var_1 = 0\n for var_6 in range(10):\n var_1 = var_1 + var_11[var_6] * var_2[var_7][var_6]\n var_12 = var_12 + var_9[var_7][var_1]\n\n var_13 = max(var_12, var_13)\nprint(var_13)\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\n\nvar_7 = sys.stdin.readline\nfrom itertools import combinations\n\n\ndef func_3(var_10):\n for _ in range(var_10):\n yield list(map(int, var_7().split()))\n\n\ndef func_1(var_9, var_5, var_11):\n var_3 = sum(1 if var_5[var_8] == 1 else 0 for var_8 in var_9)\n return var_11[var_3]\n\n\ndef func_2():\n var_10 = int(eval(var_7()))\n var_1 = list(func_3(var_10))\n var_2 = list(func_3(var_10))\n for var_6 in range(1, 11):\n for var_4 in combinations(list(range(10)), var_6):\n yield sum(\n func_1(var_4, var_5, var_11) for var_5, var_11 in zip(var_1, var_2)\n )\n\n\nprint((max(func_2())))\n```", "output": "FASTER 1.4725", "pair_id": "python_p03503_pair0004_forward", "problem_id": "p03503", "language": "python", "direction": "forward", "speedup_ratio": 2.775} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport itertools\n\nvar_6 = int(eval(input()))\nvar_2 = [[]] * var_6\nfor var_4 in range(var_6):\n var_3 = list(map(int, input().split()))\n\n var_2[var_4] = var_3\nvar_8 = [[]] * var_6\nfor var_4 in range(var_6):\n var_9 = list(map(int, input().split()))\n var_8[var_4] = var_9\nvar_10 = -(10**11)\nfor var_1 in itertools.product([0, 1], repeat=10):\n if sum(var_1) == 0:\n continue\n var_11 = 0\n for var_7 in range(var_6):\n var_5 = 0\n for var_4 in range(10):\n if var_2[var_7][var_4] == 1 and var_1[var_4] == 1:\n var_5 += 1\n var_11 = var_11 + var_8[var_7][var_5]\n var_10 = max(var_10, var_11)\nprint(var_10)\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\nimport itertools\n\n\ndef func_2(var_4):\n return bin(eval(\"0b\" + str(var_4)))\n\n\ndef func_1():\n var_4 = int(sys.stdin.readline().rstrip())\n var_9 = [\n func_2(\"\".join(str(var_10) for var_10 in sys.stdin.readline().split()))\n for _ in range(var_4)\n ]\n var_8 = [\n [int(var_10) for var_10 in sys.stdin.readline().split()] for _ in range(var_4)\n ]\n var_3 = -(10**10)\n for var_6 in itertools.product(\"01\", repeat=10):\n var_6 = func_2(\"\".join(var_6))\n if var_6 == \"0b0\":\n continue\n var_7 = 0\n for var_2 in range(var_4):\n var_1 = var_9[var_2]\n var_5 = bin(eval(var_1) & eval(var_6)).count(\"1\")\n var_7 += var_8[var_2][var_5]\n var_3 = max(var_3, var_7)\n print(var_3)\n\n\nif __name__ == \"__main__\":\n\n func_1()\n```", "output": "SLOWER 2.6006", "pair_id": "python_p03503_pair0027_reversed", "problem_id": "p03503", "language": "python", "direction": "reversed", "speedup_ratio": 6.0652} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_5 = input()[::-1]\nvar_2 = [0] * 2019\nvar_2[0] = 1\nvar_4 = 0\nvar_6 = 1\nvar_1 = 0\nfor var_3 in var_5:\n var_4 = (var_4 + int(var_3) * var_6) % 2019\n var_6 = var_6 * 10 % 2019\n var_2[var_4] += 1\nfor var_3 in var_2:\n var_1 += var_3 * (var_3 - 1) // 2\nprint(var_1)\n```\n\n=== Code B (Modified) ===\n```python\nvar_6 = 2019\nvar_1 = [0] * var_6\nvar_3 = 1\nvar_5 = var_4 = 0\nfor var_2 in input()[::-1]:\n var_1[var_4] += 1\n var_4 -= int(var_2) * var_3\n var_4 %= var_6\n var_5 += var_1[var_4]\n var_3 *= 10\n var_3 %= var_6\nprint(var_5)\n```", "output": "FASTER 2.8509", "pair_id": "python_p02702_pair0014_forward", "problem_id": "p02702", "language": "python", "direction": "forward", "speedup_ratio": 7.2145} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_2, var_1 = list(map(int, input().split()))\nvar_3 = 0\nvar_8 = 0\nvar_4 = [0] * (var_2 + 1)\nvar_9 = [0] * (var_2 + 1)\nfor var_5 in range(var_1):\n var_6, var_7 = input().split()\n var_6 = int(var_6)\n if var_7 == \"AC\":\n if var_4[var_6] == 0:\n var_3 += 1\n var_8 += var_9[var_6]\n var_4[var_6] = 1\n else:\n var_9[var_6] += 1\nprint((var_3, var_8))\n```\n\n=== Code B (Modified) ===\n```python\nvar_7, var_6 = list(map(int, input().split()))\nvar_5 = [tuple(input().split()) for _ in range(var_6)]\nvar_9 = [[] for _ in range(var_7)]\nfor var_2 in range(var_6):\n var_9[int(var_5[var_2][0]) - 1].append(var_5[var_2][1])\nvar_1, var_8 = 0, 0\nfor var_3 in range(var_7):\n if \"AC\" in var_9[var_3]:\n var_1 += 1\n for var_4 in range(len(var_9[var_3])):\n if var_9[var_3][var_4] == \"WA\":\n var_8 += 1\n else:\n break\nprint((var_1, var_8))\n```", "output": "SLOWER 4.4932", "pair_id": "python_p02802_pair0009_reversed", "problem_id": "p02802", "language": "python", "direction": "reversed", "speedup_ratio": 22.5216} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nfrom sys import stdin\n\n\ndef func_1():\n\n var_9 = stdin.readline\n var_8, var_10 = list(map(int, var_9().split()))\n var_7 = [list(map(int, var_9().split())) for _ in range(var_8)]\n var_7.sort()\n var_1 = [0] * var_8\n var_2 = [0] * var_8\n for var_4 in range(var_8):\n var_1[var_4], var_2[var_4] = var_7[var_4][0], var_7[var_4][1]\n\n var_5 = -float(\"inf\")\n var_3 = [[var_5] * (var_10 + 1) for _ in range(var_8 + 1)]\n var_3[0][0] = 0\n for var_4 in range(var_8):\n for var_6 in range(var_10 + 1):\n\n if var_6 != var_10:\n var_3[var_4 + 1][min(var_10, var_6 + var_1[var_4])] = max(\n var_3[var_4 + 1][min(var_10, var_6 + var_1[var_4])],\n var_3[var_4][var_6] + var_2[var_4],\n )\n\n var_3[var_4 + 1][var_6] = max(var_3[var_4 + 1][var_6], var_3[var_4][var_6])\n print((max(var_3[var_8])))\n\n\nif __name__ == \"__main__\":\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nvar_6, var_7 = list(map(int, input().split()))\nvar_1 = [list(map(int, input().split())) for _ in range(var_6)]\nvar_1.sort()\nvar_3 = [(6007) * [0] for _ in range(var_6 + 1)]\nvar_3[0][0] = 0\nvar_2 = 0\nfor var_4 in range(var_6):\n for var_5 in range(6007):\n var_3[var_4 + 1][var_5] = max(var_3[var_4 + 1][var_5], var_3[var_4][var_5])\n if var_5 < var_7:\n var_3[var_4 + 1][var_5 + var_1[var_4][0]] = max(\n var_3[var_4][var_5] + var_1[var_4][1],\n var_3[var_4][var_5 + var_1[var_4][0]],\n )\n var_2 = max(var_2, var_3[var_4 + 1][var_5])\nprint(var_2)\n```", "output": "SLOWER 5.7996", "pair_id": "python_p02863_pair0035_reversed", "problem_id": "p02863", "language": "python", "direction": "reversed", "speedup_ratio": 55.7009} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\n_, var_1 = open(0)\nvar_1, *var_2 = list(map(int, var_1.split()))\nfor var_2 in var_2:\n var_1 ^= var_2\nprint((\"YNeos\"[var_1 > 0 :: 2]))\n```\n\n=== Code B (Modified) ===\n```python\nfrom collections import Counter\n\nvar_4 = int(eval(input()))\nvar_1 = list(map(int, input().split()))\nvar_2 = Counter(var_1)\nvar_3 = list(var_2)\nif sum(var_1) == 0:\n print(\"Yes\")\nelif len(var_1) % 3 != 0:\n print(\"No\")\nelif len(var_2) > 3 or len(var_2) <= 1:\n print(\"No\")\nelif len(var_2) == 3:\n if (\n var_2[var_3[0]] == var_4 // 3\n and var_2[var_3[1]] == var_4 // 3\n and var_2[var_3[2]] == var_4 // 3\n ):\n if var_3[0] ^ var_3[1] ^ var_3[2] == 0:\n print(\"Yes\")\n else:\n print(\"No\")\n else:\n print(\"No\")\nelse:\n var_3.sort()\n if var_3[0] == 0 and var_2[var_3[0]] == var_4 // 3:\n print(\"Yes\")\n else:\n print(\"No\")\n```", "output": "SLOWER 1.4077", "pair_id": "python_p02975_pair0008_reversed", "problem_id": "p02975", "language": "python", "direction": "reversed", "speedup_ratio": 2.6532} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nfrom itertools import product\n\nvar_6 = int(eval(input()))\nvar_1 = list(map(int, input().split()))\nvar_5 = 0\nfor var_2 in product((-1, 0, 1), repeat=var_6):\n var_7 = 1\n for var_3, var_4 in zip(var_1, var_2):\n var_7 *= var_3 + var_4\n if var_7 % 2 == 0:\n var_5 += 1\nprint(var_5)\n```\n\n=== Code B (Modified) ===\n```python\ndef func_1():\n var_2 = int(input())\n var_1 = [int(var_6) for var_6 in input().split()]\n if var_2 == 1:\n return print(1 if var_1[0] % 2 == 0 else 2)\n var_3 = 0\n var_5 = (-1, 0, 1)\n from itertools import product\n\n for var_6 in product(range(3), repeat=var_2):\n var_4 = 1\n for var_7 in range(var_2):\n var_4 *= var_1[var_7] + var_5[var_6[var_7]]\n if var_4 % 2 == 0:\n var_3 += 1\n print(var_3)\n\n\nif __name__ == \"__main__\":\n func_1()\n```", "output": "FASTER 1.47", "pair_id": "python_p03568_pair0042_forward", "problem_id": "p03568", "language": "python", "direction": "forward", "speedup_ratio": 2.7702} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\n\nvar_8 = sys.stdin.readline\n\n\ndef func_1():\n var_2 = int(eval(var_8()))\n var_1 = []\n for _ in range(var_2):\n var_1.append(list(map(int, var_8().split())))\n var_3 = []\n for _ in range(var_2):\n var_3.append(list(map(int, var_8().split())))\n var_4 = -(10**7) * var_2\n for var_7 in range(1, 1 << 10):\n var_11 = 0\n for var_10, var_6 in enumerate(var_1):\n var_5 = 0\n for var_9 in range(10):\n if (var_7 >> var_9) & 1 & var_6[var_9]:\n var_5 += 1\n var_11 += var_3[var_10][var_5]\n var_4 = max(var_4, var_11)\n print(var_4)\n\n\nif __name__ == \"__main__\":\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\nimport itertools\n\n\ndef func_2(var_4):\n return bin(eval(\"0b\" + str(var_4)))\n\n\ndef func_1():\n var_4 = int(sys.stdin.readline().rstrip())\n var_9 = [\n func_2(\"\".join(str(var_10) for var_10 in sys.stdin.readline().split()))\n for _ in range(var_4)\n ]\n var_8 = [\n [int(var_10) for var_10 in sys.stdin.readline().split()] for _ in range(var_4)\n ]\n var_3 = -(10**10)\n for var_6 in itertools.product(\"01\", repeat=10):\n var_6 = func_2(\"\".join(var_6))\n if var_6 == \"0b0\":\n continue\n var_7 = 0\n for var_2 in range(var_4):\n var_1 = var_9[var_2]\n var_5 = bin(eval(var_1) & eval(var_6)).count(\"1\")\n var_7 += var_8[var_2][var_5]\n var_3 = max(var_3, var_7)\n print(var_3)\n\n\nif __name__ == \"__main__\":\n\n func_1()\n```", "output": "SLOWER 3.5396", "pair_id": "python_p03503_pair0050_reversed", "problem_id": "p03503", "language": "python", "direction": "reversed", "speedup_ratio": 11.6284} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\nfrom operator import itemgetter\nfrom heapq import heapify, heappop, heappush\n\nvar_1 = int(10e15)\nvar_2 = -var_1\nvar_11 = 1000000007\nsys.setrecursionlimit(1000000)\n\n\ndef func_2():\n return list(map(int, input().split()))\n\n\ndef func_4():\n return input().split()\n\n\ndef func_1():\n return int(sys.stdin.readline())\n\n\ndef func_3():\n return eval(input())\n\n\nvar_3, var_4 = func_2()\nvar_5 = [func_2() for var_9 in range(var_3)]\nvar_5.sort(key=itemgetter(0))\n\nvar_8 = [[0] * (var_4 + 1 + 3000 + 1) for _ in range(var_3 + 1)]\nvar_6 = 0\nfor var_9 in range(var_3):\n for var_10 in range(var_4 + 1 + 3000 + 1):\n var_12, var_7 = var_5[var_9]\n if 0 <= var_10 - var_12 < var_4:\n var_8[var_9 + 1][var_10] = max(\n var_8[var_9][var_10], var_8[var_9][var_10 - var_12] + var_7\n )\n else:\n var_8[var_9 + 1][var_10] = var_8[var_9][var_10]\n var_6 = max(var_6, var_8[var_9 + 1][var_10])\nprint(var_6)\n```\n\n=== Code B (Modified) ===\n```python\nfrom sys import stdin\n\n\ndef func_1():\n\n var_9 = stdin.readline\n var_8, var_10 = list(map(int, var_9().split()))\n var_7 = [list(map(int, var_9().split())) for _ in range(var_8)]\n var_7.sort()\n var_1 = [0] * var_8\n var_2 = [0] * var_8\n for var_4 in range(var_8):\n var_1[var_4], var_2[var_4] = var_7[var_4][0], var_7[var_4][1]\n\n var_5 = -(10**9)\n var_3 = [[var_5] * (var_10 + 1) for _ in range(var_8 + 1)]\n var_3[0][0] = 0\n for var_4 in range(var_8):\n for var_6 in range(var_10 + 1):\n\n if var_6 != var_10:\n var_3[var_4 + 1][min(var_10, var_6 + var_1[var_4])] = max(\n var_3[var_4 + 1][min(var_10, var_6 + var_1[var_4])],\n var_3[var_4][var_6] + var_2[var_4],\n )\n\n var_3[var_4 + 1][var_6] = max(var_3[var_4 + 1][var_6], var_3[var_4][var_6])\n print((max(var_3[var_8])))\n\n\nif __name__ == \"__main__\":\n func_1()\n```", "output": "FASTER 4.9179", "pair_id": "python_p02863_pair0020_forward", "problem_id": "p02863", "language": "python", "direction": "forward", "speedup_ratio": 30.2293} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_8, var_9 = list(map(int, input().split()))\nvar_5 = [[0] * (var_9 + 3001) for _ in range(var_8 + 1)]\nvar_3 = 0\nvar_2 = [list(map(int, input().split())) for _ in range(var_8)]\nvar_2.sort()\nfor var_6 in range(1, var_8 + 1):\n var_1, var_4 = var_2[var_6 - 1]\n for var_7 in range(var_9):\n var_5[var_6][var_7] = max(var_5[var_6 - 1][var_7], var_5[var_6][var_7])\n var_5[var_6][var_7 + var_1] = var_5[var_6 - 1][var_7] + var_4\n var_3 = max(var_5[var_6][var_7], var_5[var_6][var_7 + var_1], var_3)\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\nfrom operator import itemgetter\nfrom heapq import heapify, heappop, heappush\n\nvar_1 = int(10e15)\nvar_2 = -var_1\nvar_11 = 1000000007\nsys.setrecursionlimit(1000000)\n\n\ndef func_2():\n return list(map(int, input().split()))\n\n\ndef func_4():\n return input().split()\n\n\ndef func_1():\n return int(sys.stdin.readline())\n\n\ndef func_3():\n return eval(input())\n\n\nvar_3, var_4 = func_2()\nvar_5 = [func_2() for var_9 in range(var_3)]\nvar_5.sort(key=itemgetter(0))\n\nvar_8 = [[0] * (var_4 + 1 + 3000 + 1) for _ in range(var_3 + 1)]\nvar_6 = 0\nfor var_9 in range(var_3):\n for var_10 in range(var_4 + 1 + 3000 + 1):\n var_12, var_7 = var_5[var_9]\n if 0 <= var_10 - var_12 < var_4:\n var_8[var_9 + 1][var_10] = max(\n var_8[var_9][var_10], var_8[var_9][var_10 - var_12] + var_7\n )\n else:\n var_8[var_9 + 1][var_10] = var_8[var_9][var_10]\n var_6 = max(var_6, var_8[var_9 + 1][var_10])\nprint(var_6)\n```", "output": "SLOWER 4.3053", "pair_id": "python_p02863_pair0053_reversed", "problem_id": "p02863", "language": "python", "direction": "reversed", "speedup_ratio": 19.7702} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = input().split()\nvar_1 = int(var_1)\nvar_3, var_4 = list(map(int, var_2.split(\".\")))\nvar_5 = var_1 * (var_3 * 100 + var_4)\nprint((int(var_5 // 100)))\n```\n\n=== Code B (Modified) ===\n```python\ndef func_1():\n from sys import setrecursionlimit, stdin\n from os import environ\n from collections import defaultdict, deque, Counter\n from math import ceil, floor, gcd\n from itertools import accumulate, combinations, combinations_with_replacement\n\n setrecursionlimit(10**6)\n var_7 = (\n (lambda *var_11: print(*var_11))\n if \"TERM_PROGRAM\" in environ\n else lambda *var_12: 0\n )\n var_8 = lambda: stdin.readline().rstrip()\n var_3 = lambda: list(map(int, var_8().split()))\n var_1 = lambda: int(var_8())\n var_4 = 10**9 + 7\n var_2 = 10**9 + 10\n var_9, var_10 = var_8().split()\n var_5 = int(var_9)\n var_10 = var_10.split(\".\")\n var_6 = int(var_10[0]) * 100\n if len(var_10) == 2:\n var_6 += int(var_10[1])\n print(var_5 * var_6 // 100)\n\n\nfunc_1()\n```", "output": "SLOWER 1.9258", "pair_id": "python_p02659_pair0002_reversed", "problem_id": "p02659", "language": "python", "direction": "reversed", "speedup_ratio": 3.7995} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n if list(str(var_4)) == list(reversed(str(var_4))):\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1 = list(map(int, input().split()))\nvar_2 = 0\nfor var_3 in range(var_1[0], var_1[1] + 1):\n var_4 = str(var_3)\n if var_4[0] == var_4[4] and var_4[1] == var_4[3]:\n var_2 += 1\nprint(var_2)\n```", "output": "FASTER 1.6892", "pair_id": "python_p03416_pair0132_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 3.2247} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nfrom sys import stdin\n\nvar_6 = lambda: list(map(int, stdin.readline().split()))\nvar_5 = lambda: list(map(int, stdin.readline().split()))\nvar_1, var_3 = var_6()\nvar_2 = 0\nfor var_4 in range(var_1, var_3 + 1):\n var_7 = str(var_4)\n if var_7 == var_7[::-1]:\n var_2 += 1\nprint(var_2)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_8 in range(var_1, var_2 + 1):\n var_7 = str(var_8)\n var_6 = len(var_7)\n var_4 = True\n for var_5 in range(var_6 // 2):\n if var_7[var_5] != var_7[var_6 - 1 - var_5]:\n var_4 = False\n break\n if var_4:\n var_3 += 1\nprint(var_3)\n```", "output": "SLOWER 1.1078", "pair_id": "python_p03416_pair0154_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 2.1552} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\n\n\ndef func_1(var_5, var_6):\n var_4 = 0\n for var_3 in range(var_5, var_6 + 1):\n if str(var_3) == str(var_3)[::-1]:\n var_4 += 1\n return var_4\n\n\nprint((func_1(var_1, var_2)))\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_6 in range(var_1, var_2 + 1):\n var_3 = str(var_6)\n var_5 = True\n for var_7 in range(len(var_3) // 2):\n if var_3[var_7] != var_3[-var_7 - 1] and var_5:\n var_5 = not var_5\n if var_5:\n var_4 += 1\nprint(var_4)\n```", "output": "SLOWER 1.7836", "pair_id": "python_p03416_pair0118_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 3.4428} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = str(var_4)\n if var_5[0] == var_5[4] and var_5[1] == var_5[3]:\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\ndef func_1():\n var_1, var_2 = list(map(int, input().split()))\n var_3 = 0\n for var_4 in range(var_1, var_2 + 1):\n\n if (var_4 % 10) == (var_4 // 10000 % 10) and (var_4 // 10 % 10) == (\n var_4 // 1000 % 10\n ):\n var_3 += 1\n print(var_3)\n\n\nif __name__ == \"__main__\":\n func_1()\n```", "output": "FASTER 1.3979", "pair_id": "python_p03416_pair0246_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 2.6352} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = list(reversed(list(str(var_4))))\n if var_5 == list(str(var_4)):\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().strip().split(\" \")))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n if str(var_4) == str(var_4)[::-1]:\n var_3 += 1\nprint(var_3)\n```", "output": "FASTER 1.3497", "pair_id": "python_p03416_pair0206_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 2.5486} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nfrom itertools import product\n\nvar_6 = int(eval(input()))\nvar_1 = list(map(int, input().split()))\nvar_5 = 0\nfor var_2 in product((-1, 0, 1), repeat=var_6):\n var_7 = 1\n for var_3, var_4 in zip(var_1, var_2):\n var_7 *= var_3 + var_4\n if var_7 % 2 == 0:\n var_5 += 1\nprint(var_5)\n```\n\n=== Code B (Modified) ===\n```python\nvar_2 = int(eval(input()))\n(*var_1,) = list(map(int, input().split()))\nvar_5 = 0\nfor var_3 in var_1:\n if var_3 % 2 == 0:\n var_5 += 1\nvar_4 = 3**var_2 - 2**var_5\nprint(var_4)\n```", "output": "FASTER 10.0319", "pair_id": "python_p03568_pair0024_forward", "problem_id": "p03568", "language": "python", "direction": "forward", "speedup_ratio": 1046.9079} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\n\nsys.setrecursionlimit(2147483647)\nvar_2 = float(\"inf\")\nvar_3 = 10**9 + 7\nvar_10 = lambda: sys.stdin.readline().rstrip()\n\n\ndef func_1():\n var_11, var_4 = list(map(int, var_10().split()))\n var_1 = [tuple(map(int, var_10().split())) for _ in range(var_11)]\n var_1.sort()\n var_8 = [0] * var_4\n var_6 = -var_2\n for var_9 in range(var_11):\n var_5, var_7 = var_1[var_9]\n var_12 = var_8[:]\n for var_13 in range(var_4):\n if var_13 + var_5 < var_4:\n var_12[var_13 + var_5] = max(\n var_12[var_13 + var_5], var_8[var_13] + var_7\n )\n else:\n var_6 = max(var_6, var_8[var_13] + var_7)\n var_8 = var_12\n print((max(var_6, max(var_8))))\n\n\nfunc_1()\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\n\nvar_9 = sys.stdin.readline\nfrom operator import itemgetter\n\nvar_3, var_4 = list(map(int, var_9().split()))\nvar_1 = [list(map(int, var_9().split())) for _ in range(var_3)]\nvar_1.sort(key=itemgetter(0))\nvar_8 = [[0 for _ in range(var_3 + 1)] for _ in range(var_4 + 1)]\n\nvar_2 = []\nfor var_10 in range(var_3):\n var_5, var_7 = var_1[var_10]\n for var_11 in range(var_4):\n if var_5 > var_11:\n var_8[var_11][var_10 + 1] = var_8[var_11][var_10]\n else:\n if var_7 + var_8[var_11 - var_5][var_10] >= var_8[var_11][var_10]:\n var_8[var_11][var_10 + 1] = var_8[var_11 - var_5][var_10] + var_7\n else:\n var_8[var_11][var_10 + 1] = var_8[var_11][var_10]\n var_2.append(var_8[var_4 - 1][var_10] + var_7)\nvar_6 = max(var_2)\nprint(var_6)\n```", "output": "SLOWER 1.0161", "pair_id": "python_p02863_pair0065_reversed", "problem_id": "p02863", "language": "python", "direction": "reversed", "speedup_ratio": 2.0224} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_2, var_3, *var_1 = list(map(int, open(0).read().split()))\nvar_4 = [0] * (var_3 + max(var_1[::2]))\nfor var_7, var_6 in sorted(zip(*[iter(var_1)] * 2)):\n for var_5 in reversed(list(range(var_3))):\n var_4[var_5 + var_7] = max(var_4[var_5 + var_7], var_4[var_5] + var_6)\nprint((max(var_4)))\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\n\nvar_10 = sys.stdin.readline\nvar_2, var_3 = list(map(int, var_10().split()))\nvar_1 = [list(map(int, var_10().split())) for _ in range(var_2)]\nvar_8 = [[0 for _ in range(var_2 + 1)] for _ in range(var_3 + 1)]\n\nvar_13 = [[0 for _ in range(var_2 + 1)] for _ in range(var_3 + 1)]\nfor var_11 in range(var_2):\n var_4, var_6 = var_1[var_11]\n for var_15 in range(var_3):\n if var_4 > var_15:\n var_8[var_15][var_11 + 1] = var_8[var_15][var_11]\n var_13[var_15][var_11 + 1] = var_15\n else:\n if var_6 + var_8[var_15 - var_4][var_11] >= var_8[var_15][var_11]:\n var_8[var_15][var_11 + 1] = var_8[var_15 - var_4][var_11] + var_6\n var_13[var_15][var_11 + 1] = var_15 - var_4\n else:\n var_8[var_15][var_11 + 1] = var_8[var_15][var_11]\n var_13[var_15][var_11 + 1] = var_15\nvar_5 = var_8[var_3 - 1][var_2]\nvar_14 = [False] * var_2\nvar_7 = var_3 - 1\nfor var_9 in reversed(list(range(var_2))):\n if var_13[var_7][var_9 + 1] == var_7 - var_1[var_9][0]:\n var_14[var_9] = True\n var_7 = var_13[var_7][var_9 + 1]\nvar_12 = 0\nfor var_9 in range(var_2):\n if not var_14[var_9] and var_1[var_9][1] > var_12:\n var_12 = var_1[var_9][1]\nprint((var_5 + var_12))\n```", "output": "SLOWER 1.0715", "pair_id": "python_p02863_pair0069_reversed", "problem_id": "p02863", "language": "python", "direction": "reversed", "speedup_ratio": 2.1016} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_6 in range(var_1, var_2 + 1):\n var_3 = str(var_6)\n var_5 = True\n for var_7 in range(len(var_3) // 2):\n if var_3[var_7] != var_3[-var_7 - 1] and var_5:\n var_5 = not var_5\n if var_5:\n var_4 += 1\nprint(var_4)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = [\n var_3 for var_3 in map(str, list(range(var_1, var_2 + 1))) if var_3 == var_3[::-1]\n]\nprint((len(var_4)))\n```", "output": "FASTER 2.1585", "pair_id": "python_p03416_pair0243_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 4.4645} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = input().split()\nvar_1 = int(var_1)\nvar_2 = int(var_2)\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = list(str(var_4))\n if (var_5[0] == var_5[4]) and (var_5[1] == var_5[3]):\n var_3 = var_3 + 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_4 = {}\nvar_5 = 0\nfor var_6 in range(10000, 100000):\n var_3 = list(str(var_6))\n if var_3 == list(reversed(var_3)):\n var_5 += 1\n var_4[var_6] = var_5\nvar_1, var_2 = list(map(int, input().split()))\nprint((var_4[var_2] - var_4[var_1 - 1] if var_1 > 10000 else var_4[var_2]))\n```", "output": "SLOWER 3.1693", "pair_id": "python_p03416_pair0247_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 8.996} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_3, var_2 = map(int, input().split())\nvar_4 = [0] * var_3\n[\n exec(\n \"roads[%d] += 1; roads[%d] += 1\"\n % tuple(map(lambda var_1: int(var_1) - 1, input().split()))\n )\n for _ in range(var_2)\n]\nprint(*var_4, sep=\"\\n\", end=\"\")\n```\n\n=== Code B (Modified) ===\n```python\nvar_6, var_5 = list(map(int, input().split()))\nvar_1 = [0] * var_6\nfor var_4 in range(var_5):\n var_2, var_3 = list(map(int, input().split()))\n var_1[var_2 - 1] += 1\n var_1[var_3 - 1] += 1\nfor var_4 in range(var_6):\n print((var_1[var_4]))\n```", "output": "FASTER 1.1224", "pair_id": "python_p03720_pair0001_forward", "problem_id": "p03720", "language": "python", "direction": "forward", "speedup_ratio": 2.1771} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_4 = str(var_4)\n if var_4[0] == var_4[-1] and var_4[1] == var_4[-2]:\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_7 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_3 = True\n var_8 = str(var_4)\n var_6 = len(var_8)\n for var_5 in range(var_6 // 2 + 1):\n if var_8[var_5] != var_8[-var_5 - 1]:\n var_3 = False\n break\n if var_3:\n var_7 += 1\nprint(var_7)\n```", "output": "SLOWER 1.3088", "pair_id": "python_p03416_pair0186_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 2.4774} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\ndef func_1():\n from sys import setrecursionlimit, stdin\n from os import environ\n from collections import defaultdict, deque, Counter\n from math import ceil, floor, gcd\n from itertools import accumulate, combinations, combinations_with_replacement\n\n setrecursionlimit(10**6)\n var_7 = (\n (lambda *var_11: print(*var_11))\n if \"TERM_PROGRAM\" in environ\n else lambda *var_12: 0\n )\n var_8 = lambda: stdin.readline().rstrip()\n var_3 = lambda: list(map(int, var_8().split()))\n var_1 = lambda: int(var_8())\n var_4 = 10**9 + 7\n var_2 = 10**9 + 10\n var_9, var_10 = var_8().split()\n var_5 = int(var_9)\n var_10 = var_10.split(\".\")\n var_6 = int(var_10[0]) * 100\n if len(var_10) == 2:\n var_6 += int(var_10[1])\n print(var_5 * var_6 // 100)\n\n\nfunc_1()\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\n\nvar_5 = sys.stdin.readline\nif __name__ == \"__main__\":\n var_1, var_3 = var_5().split()\n var_2 = int(var_1)\n var_4 = round(float(var_3) * 100)\n print((var_2 * var_4 // 100))\n```", "output": "FASTER 1.8866", "pair_id": "python_p02659_pair0017_forward", "problem_id": "p02659", "language": "python", "direction": "forward", "speedup_ratio": 3.6977} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport decimal\n\n\ndef func_1():\n var_1, var_2 = list(map(decimal.Decimal, input().split()))\n print((var_1 * var_2 // 1))\n\n\nif __name__ == \"__main__\":\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\nimport math\nfrom collections import defaultdict\nfrom bisect import bisect_left, bisect_right\n\nsys.setrecursionlimit(10**7)\n\n\ndef func_4():\n return sys.stdin.readline()[:-1]\n\n\nvar_4 = 10**9 + 7\n\n\ndef func_1():\n return int(eval(func_4()))\n\n\ndef func_2():\n return list(map(int, func_4().split()))\n\n\ndef func_3(var_6, var_3):\n if var_6 <= 0:\n return [[] for _ in range(var_3)]\n elif var_3 == 1:\n return [func_1() for _ in range(var_6)]\n else:\n var_5 = [func_2() for _ in range(var_6)]\n return list(map(list, list(zip(*var_5))))\n\n\nfrom decimal import getcontext, Decimal\n\ngetcontext().prec = 28\nvar_1, var_2 = list(map(str, func_4().split()))\nvar_1 = int(var_1)\nvar_2 = Decimal(var_2)\nprint((int(var_1 * var_2)))\n```", "output": "SLOWER 2.0487", "pair_id": "python_p02659_pair0023_reversed", "problem_id": "p02659", "language": "python", "direction": "reversed", "speedup_ratio": 4.1373} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\nimport numpy as np\n\nvar_6 = int(eval(input()))\n\nvar_1 = [input().replace(\" \", \"\") for var_4 in range(var_6)]\n\nvar_7 = [list(map(int, input().split())) for var_4 in range(var_6)]\nvar_11 = -999999999999999\nfor var_4 in range(1, 1024):\n var_3 = format(var_4, \"010b\")\n var_9 = 0\n for var_2, var_8 in zip(var_1, var_7):\n var_10 = 0\n for var_5 in range(10):\n if var_2[var_5] == \"1\" and var_3[var_5] == \"1\":\n var_10 += 1\n var_9 += var_8[var_10]\n if var_9 > var_11:\n if var_9 == 0:\n print((str(var_4)))\n break\n var_11 = var_9\nprint(var_11)\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\nimport itertools\n\n\ndef func_2(var_4):\n return bin(eval(\"0b\" + str(var_4)))\n\n\ndef func_1():\n var_4 = int(sys.stdin.readline().rstrip())\n var_9 = [\n func_2(\"\".join(str(var_10) for var_10 in sys.stdin.readline().split()))\n for _ in range(var_4)\n ]\n var_8 = [\n [int(var_10) for var_10 in sys.stdin.readline().split()] for _ in range(var_4)\n ]\n var_3 = -(10**10)\n for var_6 in itertools.product(\"01\", repeat=10):\n var_6 = func_2(\"\".join(var_6))\n if var_6 == \"0b0\":\n continue\n var_7 = 0\n for var_2 in range(var_4):\n var_1 = var_9[var_2]\n var_5 = bin(eval(var_1) & eval(var_6)).count(\"1\")\n var_7 += var_8[var_2][var_5]\n var_3 = max(var_3, var_7)\n print(var_3)\n\n\nif __name__ == \"__main__\":\n\n func_1()\n```", "output": "SLOWER 3.0752", "pair_id": "python_p03503_pair0023_reversed", "problem_id": "p03503", "language": "python", "direction": "reversed", "speedup_ratio": 8.4281} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_4 = str(var_4)\n if var_4[0] == var_4[-1] and var_4[1] == var_4[-2]:\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_3 = list(map(int, input().split()))\nvar_2 = 0\nfor var_5 in range(var_3 + 1)[var_1:]:\n if len(str(var_5)) % 2 == 0:\n var_6 = list(str(var_5))[: len(str(var_5)) // 2]\n var_7 = list(reversed(list(str(var_5))[len(str(var_5)) // 2 :]))\n if var_6 == var_7:\n var_2 += 1\n else:\n var_8 = list(str(var_5))[: len(str(var_5)) // 2 + 1]\n var_4 = list(reversed(list(str(var_5))[len(str(var_5)) // 2 :]))\n if var_8 == var_4:\n var_2 += 1\nprint(var_2)\n```", "output": "SLOWER 2.6583", "pair_id": "python_p03416_pair0245_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 6.3127} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = input().split()\nvar_1 = int(var_1)\nvar_2 = int(var_2.replace(\".\", \"\"))\nprint((var_1 * var_2 // 100))\n```\n\n=== Code B (Modified) ===\n```python\ndef func_1():\n from sys import setrecursionlimit, stdin\n from os import environ\n from collections import defaultdict, deque, Counter\n from math import ceil, floor, gcd\n from itertools import accumulate, combinations, combinations_with_replacement\n\n setrecursionlimit(10**6)\n var_7 = (\n (lambda *var_11: print(*var_11))\n if \"TERM_PROGRAM\" in environ\n else lambda *var_12: 0\n )\n var_8 = lambda: stdin.readline().rstrip()\n var_3 = lambda: list(map(int, var_8().split()))\n var_1 = lambda: int(var_8())\n var_4 = 10**9 + 7\n var_2 = 10**9 + 10\n var_9, var_10 = var_8().split()\n var_5 = int(var_9)\n var_10 = var_10.split(\".\")\n var_6 = int(var_10[0]) * 100\n if len(var_10) == 2:\n var_6 += int(var_10[1])\n print(var_5 * var_6 // 100)\n\n\nfunc_1()\n```", "output": "SLOWER 2.4306", "pair_id": "python_p02659_pair0040_reversed", "problem_id": "p02659", "language": "python", "direction": "reversed", "speedup_ratio": 5.3911} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_4, var_3 = list(map(int, input().split()))\nvar_1 = 0\nfor var_2 in range(var_4, var_3 + 1):\n if str(var_2)[0] + str(var_2)[1] == str(var_2)[-1] + str(var_2)[-2]:\n var_1 += 1\nprint(var_1)\n```\n\n=== Code B (Modified) ===\n```python\nvar_4 = {}\nvar_5 = 0\nfor var_6 in range(10000, 100000):\n var_3 = list(str(var_6))\n if var_3 == list(reversed(var_3)):\n var_5 += 1\n var_4[var_6] = var_5\nvar_1, var_2 = list(map(int, input().split()))\nprint((var_4[var_2] - var_4[var_1 - 1] if var_1 > 10000 else var_4[var_2]))\n```", "output": "SLOWER 2.2325", "pair_id": "python_p03416_pair0240_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 4.6995} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_6 = sorted([list(map(int, input().split())) for var_5 in range(var_1)])\n\nvar_4 = [[0] * (var_2 + 1) for var_5 in range(var_1 + 1)]\n\nfor var_5 in range(var_1):\n var_9, var_8 = var_6[var_5]\n for var_7 in range(var_2 + 1):\n if var_7 + var_9 <= var_2:\n var_4[var_5 + 1][var_7 + var_9] = max(\n var_4[var_5 + 1][var_7 + var_9], var_4[var_5][var_7] + var_8\n )\n var_4[var_5 + 1][var_7] = max(var_4[var_5][var_7], var_4[var_5 + 1][var_7])\nvar_3 = 0\nfor var_5, (var_9, var_8) in enumerate(var_6):\n var_3 = max(var_3, var_4[var_5][var_2 - 1] + var_8)\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nfrom collections import Counter, defaultdict, deque\nfrom heapq import heappop, heappush, heapify\nimport sys, bisect, math, itertools, fractions, pprint\n\nsys.setrecursionlimit(10**8)\nvar_6 = 10**9 + 7\nvar_1 = float(\"inf\")\n\n\ndef func_1():\n return int(sys.stdin.readline())\n\n\ndef func_2():\n return list(map(int, sys.stdin.readline().split()))\n\n\nvar_7, var_9 = func_2()\nvar_13 = [func_2() for _ in range(var_7)]\nvar_13.sort(key=lambda var_14: var_14[1], reverse=True)\nvar_8 = 0\nvar_10 = min(var_7, 5)\nfor var_3 in range(var_10):\n var_2 = [[0] * (var_9 + 5) for _ in range(var_7 + 5)]\n for var_4 in range(var_7):\n var_12, var_11 = var_13[var_4]\n for var_5 in range(var_9):\n if var_5 < var_12 or var_3 == var_4:\n var_2[var_4 + 1][var_5] = var_2[var_4][var_5]\n else:\n var_2[var_4 + 1][var_5] = max(\n var_2[var_4][var_5], var_2[var_4][var_5 - var_12] + var_11\n )\n\n var_8 = max(var_2[var_7][var_9 - 1] + var_13[var_3][1], var_8)\nprint(var_8)\n```", "output": "SLOWER 1.2339", "pair_id": "python_p02863_pair0066_reversed", "problem_id": "p02863", "language": "python", "direction": "reversed", "speedup_ratio": 2.352} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\nimport numpy as np\n\nvar_5 = sys.stdin.readline\n\nvar_7 = int(eval(var_5()))\n\nvar_1 = [var_5().replace(\" \", \"\") for var_4 in range(var_7)]\n\nvar_8 = [list(map(int, var_5().split())) for var_4 in range(var_7)]\n\n\nvar_12 = -999999999999999\n\nfor var_4 in range(1, 1024):\n\n var_3 = format(var_4, \"010b\")\n\n var_10 = 0\n for var_2, var_9 in zip(var_1, var_8):\n\n var_11 = 0\n for var_6 in range(10):\n\n if var_2[var_6] == \"1\" and var_3[var_6] == \"1\":\n\n var_11 += 1\n\n var_10 += var_9[var_11]\n if var_10 > var_12:\n\n var_12 = var_10\nprint(var_12)\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\n\nvar_7 = sys.stdin.readline\nfrom itertools import combinations\n\n\ndef func_3(var_10):\n for _ in range(var_10):\n yield list(map(int, var_7().split()))\n\n\ndef func_1(var_9, var_5, var_11):\n var_3 = sum(1 if var_5[var_8] == 1 else 0 for var_8 in var_9)\n return var_11[var_3]\n\n\ndef func_2():\n var_10 = int(eval(var_7()))\n var_1 = list(func_3(var_10))\n var_2 = list(func_3(var_10))\n for var_6 in range(1, 11):\n for var_4 in combinations(list(range(10)), var_6):\n yield sum(\n func_1(var_4, var_5, var_11) for var_5, var_11 in zip(var_1, var_2)\n )\n\n\nprint((max(func_2())))\n```", "output": "FASTER 1.0796", "pair_id": "python_p03503_pair0019_forward", "problem_id": "p03503", "language": "python", "direction": "forward", "speedup_ratio": 2.1134} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_6, var_7 = list(map(int, input().split()))\nvar_1 = [list(map(int, input().split())) for _ in range(var_6)]\nvar_1.sort()\nvar_3 = [(6007) * [0] for _ in range(var_6 + 1)]\nvar_3[0][0] = 0\nvar_2 = 0\nfor var_4 in range(var_6):\n for var_5 in range(6007):\n var_3[var_4 + 1][var_5] = max(var_3[var_4 + 1][var_5], var_3[var_4][var_5])\n if var_5 < var_7:\n var_3[var_4 + 1][var_5 + var_1[var_4][0]] = max(\n var_3[var_4][var_5] + var_1[var_4][1],\n var_3[var_4][var_5 + var_1[var_4][0]],\n )\n var_2 = max(var_2, var_3[var_4 + 1][var_5])\nprint(var_2)\n```\n\n=== Code B (Modified) ===\n```python\nimport bisect\nimport sys\n\nsys.setrecursionlimit(10**6)\nvar_17 = sys.stdout.write\nvar_7 = lambda *var_15: print(*var_15) if var_1 else 0\nvar_1 = True\n\n\ndef func_1(var_10=sys.stdin.readline):\n var_12 = lambda: var_10().rstrip()\n var_3 = lambda: list(map(int, var_12().split()))\n var_2 = lambda: int(var_12())\n var_4 = lambda var_18: [var_3() for _ in range(var_18)]\n var_14, var_16 = var_3()\n var_5 = var_4(var_14)\n var_8 = [[0] * var_16 for _ in range(var_14)]\n for var_11 in range(1, var_14):\n for var_13 in range(1, var_16):\n if var_13 < var_5[var_11 - 1][0]:\n var_8[var_11][var_13] = var_8[var_11 - 1][var_13]\n else:\n var_8[var_11][var_13] = max(\n var_8[var_11 - 1][var_13],\n var_8[var_11 - 1][var_13 - var_5[var_11 - 1][0]]\n + var_5[var_11 - 1][1],\n )\n var_9 = [[0] * var_16 for _ in range(var_14)]\n for var_11 in range(1, var_14):\n for var_13 in range(1, var_16):\n if var_13 < var_5[var_14 - var_11][0]:\n var_9[var_11][var_13] = var_9[var_11 - 1][var_13]\n else:\n var_9[var_11][var_13] = max(\n var_9[var_11 - 1][var_13],\n var_9[var_11 - 1][var_13 - var_5[var_14 - var_11][0]]\n + var_5[var_14 - var_11][1],\n )\n var_6 = 0\n for var_11 in range(var_14):\n for var_13 in range(var_16 - 1):\n var_6 = max(\n var_6,\n var_8[var_11][var_13]\n + var_9[var_14 - var_11 - 1][var_16 - var_13 - 1]\n + var_5[var_11][1],\n )\n print(var_6)\n\n\nif __name__ == \"__main__\":\n func_1()\n```", "output": "FASTER 5.3172", "pair_id": "python_p02863_pair0036_forward", "problem_id": "p02863", "language": "python", "direction": "forward", "speedup_ratio": 39.8704} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_2 = int(eval(input()))\n(*var_1,) = list(map(int, input().split()))\nvar_5 = 0\nfor var_3 in var_1:\n if var_3 % 2 == 0:\n var_5 += 1\nvar_4 = 3**var_2 - 2**var_5\nprint(var_4)\n```\n\n=== Code B (Modified) ===\n```python\nvar_4 = int(eval(input()))\nvar_2 = list(map(int, input().split()))\n\n\ndef func_1(var_1, var_8, var_3):\n if var_8 == var_4:\n var_9 = 1\n for var_5 in var_3:\n var_9 *= var_5\n return 1 if var_9 % 2 == 0 else 0\n var_6 = var_3.copy()\n var_6.append(var_1[var_8] - 1)\n var_5 = var_3.copy()\n var_5.append(var_1[var_8])\n var_7 = var_3.copy()\n var_7.append(var_1[var_8] + 1)\n return (\n func_1(var_1, var_8 + 1, var_6)\n + func_1(var_1, var_8 + 1, var_5)\n + func_1(var_1, var_8 + 1, var_7)\n )\n\n\nprint((func_1(var_2, 0, [])))\n```", "output": "SLOWER 8.2861", "pair_id": "python_p03568_pair0019_reversed", "problem_id": "p03568", "language": "python", "direction": "reversed", "speedup_ratio": 312.1488} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_5 in range(10):\n for var_6 in range(10):\n for var_7 in range(10):\n var_3 = 10000 * var_5 + 1000 * var_6 + 100 * var_7 + 10 * var_6 + var_5\n if var_1 <= var_3 <= var_2:\n var_4 += 1\nprint(var_4)\n```\n\n=== Code B (Modified) ===\n```python\nvar_4, var_3 = list(map(int, input().split()))\nvar_1 = 0\nfor var_2 in range(var_4, var_3 + 1):\n if str(var_2)[0] + str(var_2)[1] == str(var_2)[-1] + str(var_2)[-2]:\n var_1 += 1\nprint(var_1)\n```", "output": "SLOWER 5.1667", "pair_id": "python_p03416_pair0150_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 35.9185} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\n\nvar_3 = sys.stdin.readline\nif __name__ == \"__main__\":\n var_1, var_2 = var_3().split()\n print((int(var_1) * round(float(var_2) * 100) // 100))\n```\n\n=== Code B (Modified) ===\n```python\ndef func_1():\n from sys import setrecursionlimit, stdin\n from os import environ\n from collections import defaultdict, deque, Counter\n from math import ceil, floor, gcd\n from itertools import accumulate, combinations, combinations_with_replacement\n\n setrecursionlimit(10**6)\n var_7 = (\n (lambda *var_11: print(*var_11))\n if \"TERM_PROGRAM\" in environ\n else lambda *var_12: 0\n )\n var_8 = lambda: stdin.readline().rstrip()\n var_3 = lambda: list(map(int, var_8().split()))\n var_1 = lambda: int(var_8())\n var_4 = 10**9 + 7\n var_2 = 10**9 + 10\n var_9, var_10 = var_8().split()\n var_5 = int(var_9)\n var_6 = int(float(var_10) * 100 + 0.5)\n print(var_5 * var_6 // 100)\n\n\nfunc_1()\n```", "output": "SLOWER 1.9665", "pair_id": "python_p02659_pair0064_reversed", "problem_id": "p02659", "language": "python", "direction": "reversed", "speedup_ratio": 3.9083} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\n_, var_1 = open(0)\nvar_1, *var_2 = list(map(int, var_1.split()))\nfor var_2 in var_2:\n var_1 ^= var_2\nprint((\"YNeos\"[var_1 > 0 :: 2]))\n```\n\n=== Code B (Modified) ===\n```python\nfrom collections import Counter\n\nvar_4 = int(eval(input()))\nvar_1 = list(map(int, input().split()))\nvar_2 = Counter(var_1)\nvar_3 = list(var_2.keys())\nvar_5 = list(var_2.values())\nif (\n len(var_2) == 3\n and var_3[0] ^ var_3[1] ^ var_3[2] == 0\n and var_5[0] == var_5[1] == var_5[2]\n):\n print(\"Yes\")\nelif (\n len(var_2) == 2\n and 0 in var_3\n and (var_5[0] == var_5[1] * 2 or var_5[1] == var_5[0] * 2)\n):\n print(\"Yes\")\nelif len(var_2) == 1 and 0 in var_3:\n print(\"Yes\")\nelse:\n print(\"No\")\n```", "output": "SLOWER 1.0753", "pair_id": "python_p02975_pair0003_reversed", "problem_id": "p02975", "language": "python", "direction": "reversed", "speedup_ratio": 2.1071} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_7 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_3 = True\n var_8 = str(var_4)\n var_6 = len(var_8)\n for var_5 in range(var_6 // 2 + 1):\n if var_8[var_5] != var_8[-var_5 - 1]:\n var_3 = False\n break\n if var_3:\n var_7 += 1\nprint(var_7)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_5 in range(var_1, var_2 + 1):\n var_3 = str(var_5)\n if var_3[0] == var_3[-1] and var_3[1] == var_3[-2]:\n var_4 += 1\nprint(var_4)\n```", "output": "FASTER 1.2167", "pair_id": "python_p03416_pair0201_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 2.3241} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport math\nimport string\n\n\ndef func_4():\n return list(map(int, input().split()))\n\n\ndef func_3(var_6, var_7):\n return math.factorial(var_6) // (\n math.factorial(var_6 - var_7) * math.factorial(var_7)\n )\n\n\ndef func_2(var_9):\n var_8 = []\n for var_5 in var_9:\n if not (var_5 in var_8):\n var_8.append(var_5)\n return len(var_9) != len(var_8)\n\n\ndef func_1(var_6):\n func_1 = []\n for var_4 in range(1, var_6 + 1):\n if var_6 % var_4 == 0:\n func_1.append(var_4)\n return func_1\n\n\nvar_2 = [-1, -1, -1, 0, 0, 1, 1, 1]\nvar_3 = [-1, 0, 1, -1, 1, -1, 0, 1]\nvar_6 = int(eval(input()))\nvar_1 = func_4()\nvar_10 = 1\nfor var_4 in range(len(var_1)):\n if var_1[var_4] % 2 == 0:\n var_10 *= 2\n else:\n var_10 *= 1\nprint((3 ** len(var_1) - var_10))\n```\n\n=== Code B (Modified) ===\n```python\nfrom functools import reduce\nfrom itertools import product\n\nvar_2 = int(eval(input()))\n(*var_1,) = list(map(int, input().split()))\nvar_4 = 0\nfor var_7 in product([-1, 0, 1], repeat=var_2):\n var_6 = reduce(\n lambda var_8, var_9: var_8 * var_9,\n [var_3 + var_7[var_5] for var_5, var_3 in enumerate(var_1)],\n )\n if var_6 % 2 == 0:\n var_4 += 1\nprint(var_4)\n```", "output": "SLOWER 8.0685", "pair_id": "python_p03568_pair0028_reversed", "problem_id": "p03568", "language": "python", "direction": "reversed", "speedup_ratio": 268.4525} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_7, var_6 = list(map(int, input().split(\" \")))\nvar_2 = [list(map(int, input().split(\" \"))) for _ in range(var_6)]\nvar_2.sort(key=lambda var_8: var_8[1])\nvar_5 = 0\nvar_4 = 0\nfor var_1, var_3 in var_2:\n if var_4 > var_1:\n continue\n var_4 = var_3\n var_5 += 1\nprint(var_5)\n```\n\n=== Code B (Modified) ===\n```python\nvar_2, var_1 = [int(var_12) for var_12 in input().split()]\nvar_3 = []\nfor var_8 in range(var_1):\n var_5, var_6 = [int(var_12) for var_12 in input().split()]\n var_3.append((var_5, var_6))\nvar_3.sort()\nvar_9 = float(\"inf\")\nvar_4 = [var_9 for var_5 in range(var_2 + 1)]\nfor var_5, var_6 in var_3:\n var_4[var_5] = min(var_4[var_5], var_6)\nvar_3 = [\n (var_5, var_4[var_5]) for var_5 in range(1, var_2 + 1) if var_4[var_5] != var_9\n]\nvar_3.sort(key=lambda var_11: var_11[1])\nvar_7 = [True] * (var_2)\nvar_10 = None\nfor var_5, var_6 in var_3:\n if var_10 == None or var_10 < var_5:\n var_7[var_6 - 1] = False\n var_10 = var_6 - 1\nprint((sum(1 for var_6 in var_7 if not var_6)))\n```", "output": "SLOWER 1.0821", "pair_id": "python_p03295_pair0003_reversed", "problem_id": "p03295", "language": "python", "direction": "reversed", "speedup_ratio": 2.1171} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_4, var_3 = list(map(int, input().split()))\nvar_1 = 0\nfor var_2 in range(var_4, var_3 + 1):\n if str(var_2)[0] + str(var_2)[1] == str(var_2)[-1] + str(var_2)[-2]:\n var_1 += 1\nprint(var_1)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_4 = str(var_4)\n if var_4 == var_4[::-1]:\n var_3 += 1\nprint(var_3)\n```", "output": "FASTER 1.1941", "pair_id": "python_p03416_pair0120_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 2.288} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport numpy as np\nfrom bisect import bisect_left\n\n\ndef func_1():\n var_4 = []\n var_1 = np.ones(10**5 + 10)\n var_1[0] = var_1[1] = 0\n for var_3, var_2 in enumerate(var_1):\n if var_2:\n var_4.append(var_3)\n var_1[2 * var_3 : 10**5 + 10 : var_3] = 0\n return var_4\n\n\ndef func_2(var_6):\n var_7 = int(var_6)\n var_5 = func_1()\n return str(var_5[bisect_left(var_5, var_7)])\n\n\nif __name__ == \"__main__\":\n import sys\n\n print((func_2(sys.stdin.read().strip())))\n```\n\n=== Code B (Modified) ===\n```python\nvar_4 = int(eval(input()))\nvar_1 = 0\nif var_4 == 2:\n print((2))\nelse:\n for var_2 in range(var_4, 10**6):\n for var_3 in range(2, var_2 // 2 + 2):\n if var_2 % var_3 == 0:\n break\n else:\n var_1 = var_2\n break\n print(var_1)\n```", "output": "FASTER 7.742", "pair_id": "python_p02819_pair0007_forward", "problem_id": "p02819", "language": "python", "direction": "forward", "speedup_ratio": 214.0828} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\ndef func_1():\n var_1, var_2 = list(map(int, input().split()))\n var_3 = 0\n for var_4 in range(var_1, var_2 + 1):\n\n if (var_4 % 10) == (var_4 // 10000 % 10) and (var_4 // 10 % 10) == (\n var_4 // 1000 % 10\n ):\n var_3 += 1\n print(var_3)\n\n\nif __name__ == \"__main__\":\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = str(var_4)\n if var_5[0] == var_5[4] and var_5[1] == var_5[3]:\n var_3 += 1\nprint(var_3)\n```", "output": "SLOWER 1.3979", "pair_id": "python_p03416_pair0246_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 2.6352} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().strip().split(\" \")))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n if str(var_4) == str(var_4)[::-1]:\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_3 in range(var_1, var_2 + 1):\n var_5 = list(str(var_3))\n var_6 = list(reversed(var_5))\n if var_5 == var_6:\n var_4 += 1\nprint(var_4)\n```", "output": "SLOWER 1.0014", "pair_id": "python_p03416_pair0185_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 2.0019} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nfrom sys import stdin\n\nvar_5 = stdin.readline\nvar_2, var_1 = list(map(int, var_5().split()))\nvar_3 = [False] * var_2\nvar_8 = [0] * var_2\nvar_9 = 0\nfor var_4 in range(var_1):\n var_6, var_7 = var_5().split()\n var_6 = int(var_6) - 1\n if var_3[var_6] is False and var_7 == \"AC\":\n var_9 += var_8[var_6]\n var_3[var_6] = True\n elif var_7 == \"WA\":\n var_8[var_6] += 1\nprint((var_3.count(True), var_9))\n```\n\n=== Code B (Modified) ===\n```python\nvar_2, var_1 = list(map(int, input().split()))\nvar_6 = {}\nvar_3 = {}\nfor var_4 in range(var_1):\n var_5, var_7 = input().split()\n var_5 = int(var_5)\n if not var_5 in var_6:\n var_6[var_5] = 0\n var_3[var_5] = 0\n if var_7 == \"WA\" and var_3[var_5] == 0:\n var_6[var_5] += 1\n elif var_7 == \"AC\" and var_3[var_5] == 0:\n var_3[var_5] += 1\nfor var_4 in var_6:\n if var_6[var_4] != 0 and var_3[var_4] == 0:\n var_6[var_4] = 0\nprint((sum(var_3.values()), sum(var_6.values())))\n```", "output": "FASTER 1.107", "pair_id": "python_p02802_pair0005_forward", "problem_id": "p02802", "language": "python", "direction": "forward", "speedup_ratio": 2.154} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_4 = {}\nvar_5 = 0\nfor var_6 in range(10000, 100000):\n var_3 = list(str(var_6))\n if var_3 == list(reversed(var_3)):\n var_5 += 1\n var_4[var_6] = var_5\nvar_1, var_2 = list(map(int, input().split()))\nprint((var_4[var_2] - var_4[var_1 - 1] if var_1 > 10000 else var_4[var_2]))\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_4 = str(var_4)\n if var_4 == var_4[::-1]:\n var_3 += 1\nprint(var_3)\n```", "output": "FASTER 3.4266", "pair_id": "python_p03416_pair0248_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 10.7526} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_2 = int(eval(input()))\nvar_1 = list(map(int, input().split()))\nvar_4 = 1\nfor var_3 in range(var_2):\n if var_1[var_3] % 2 == 0:\n var_4 *= 2\nprint((3**var_2 - var_4))\n```\n\n=== Code B (Modified) ===\n```python\nimport math\nimport string\n\n\ndef func_5():\n return list(map(int, input().split()))\n\n\ndef func_4(var_7, var_8):\n return math.factorial(var_7) // (\n math.factorial(var_7 - var_8) * math.factorial(var_8)\n )\n\n\ndef func_3(var_10):\n var_9 = []\n for var_5 in var_10:\n if not (var_5 in var_9):\n var_9.append(var_5)\n return len(var_10) != len(var_9)\n\n\ndef func_1(var_7):\n func_1 = []\n for var_4 in range(1, var_7 + 1):\n if var_7 % var_4 == 0:\n func_1.append(var_4)\n return func_1\n\n\nvar_2 = [-1, -1, -1, 0, 0, 1, 1, 1]\nvar_3 = [-1, 0, 1, -1, 1, -1, 0, 1]\nvar_7 = int(eval(input()))\nvar_1 = func_5()\n\n\ndef func_2(var_6):\n if len(var_6) == var_7:\n for var_4 in range(len(var_6)):\n if var_6[var_4] % 2 == 0:\n return 1\n return 0\n return (\n func_2(var_6 + [var_1[len(var_6)]])\n + func_2(var_6 + [var_1[len(var_6)] - 1])\n + func_2(var_6 + [var_1[len(var_6)] + 1])\n )\n\n\nprint((func_2([])))\n```", "output": "SLOWER 7.6602", "pair_id": "python_p03568_pair0044_reversed", "problem_id": "p03568", "language": "python", "direction": "reversed", "speedup_ratio": 202.2771} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\n\nvar_3 = sys.stdin.readline\nvar_1, var_2 = var_3().split()\nvar_1 = int(var_1)\nvar_2 = int(float(var_2) * 100 + 0.5)\nprint((var_1 * var_2 // 100))\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\nimport math\nfrom collections import defaultdict\nfrom bisect import bisect_left, bisect_right\n\nsys.setrecursionlimit(10**7)\n\n\ndef func_4():\n return sys.stdin.readline()[:-1]\n\n\nvar_4 = 10**9 + 7\n\n\ndef func_1():\n return int(eval(func_4()))\n\n\ndef func_2():\n return list(map(int, func_4().split()))\n\n\ndef func_3(var_6, var_3):\n if var_6 <= 0:\n return [[] for _ in range(var_3)]\n elif var_3 == 1:\n return [func_1() for _ in range(var_6)]\n else:\n var_5 = [func_2() for _ in range(var_6)]\n return list(map(list, list(zip(*var_5))))\n\n\nfrom decimal import getcontext, Decimal\n\ngetcontext().prec = 28\nvar_1, var_2 = list(map(str, func_4().split()))\nvar_1 = int(var_1)\nvar_2 = Decimal(var_2)\nprint((int(var_1 * var_2)))\n```", "output": "SLOWER 2.2902", "pair_id": "python_p02659_pair0046_reversed", "problem_id": "p02659", "language": "python", "direction": "reversed", "speedup_ratio": 4.8913} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = str(var_4)\n if var_5 == var_5[::-1]:\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n if list(str(var_4)) == list(reversed(str(var_4))):\n var_3 += 1\nprint(var_3)\n```", "output": "SLOWER 1.4048", "pair_id": "python_p03416_pair0043_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 2.6479} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2, var_8 = list(map(int, input().split()))\nvar_4 = list(map(int, input().split()))\nvar_9 = list(map(int, input().split()))\nvar_10 = [list(map(int, input().split())) for var_6 in range(var_8)]\nvar_7 = 200001\nfor var_6 in range(var_8):\n var_5 = var_10[var_6][0] - 1\n var_3 = var_10[var_6][1] - 1\n if var_7 >= var_4[var_5] + var_9[var_3] - var_10[var_6][2]:\n var_7 = var_4[var_5] + var_9[var_3] - var_10[var_6][2]\nvar_4.sort()\nvar_9.sort()\nif var_7 >= (var_4[0] + var_9[0]):\n print((var_4[0] + var_9[0]))\nelse:\n print(var_7)\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\nfrom collections import Counter\n\n\ndef func_10():\n return sys.stdin.readline().strip()\n\n\ndef func_11(var_12, var_13, var_14):\n return [[var_14] * var_13 for var_17 in range(var_12)]\n\n\ndef func_12(var_12, var_13, var_14, var_15):\n return [[[var_15] * var_14 for var_18 in range(var_13)] for var_17 in range(var_12)]\n\n\ndef func_13(var_12, var_13, var_14, var_15, var_16):\n return [\n [[[var_16] * var_15 for var_18 in range(var_14)] for var_18 in range(var_13)]\n for var_17 in range(var_12)\n ]\n\n\ndef func_8(var_22, var_23=1):\n return int(-(-var_22 // var_23))\n\n\ndef func_1():\n return int(eval(func_10()))\n\n\ndef func_3():\n return list(map(int, func_10().split()))\n\n\ndef func_2(var_11=None):\n return list(func_3()) if var_11 is None else [func_1() for var_17 in range(var_11)]\n\n\ndef func_7():\n print(\"Yes\")\n\n\ndef func_5():\n print(\"No\")\n\n\ndef func_6():\n print(\"YES\")\n\n\ndef func_4():\n print(\"NO\")\n\n\nsys.setrecursionlimit(10**9)\nvar_5 = 10**18\nvar_10 = 10**9 + 7\n\n\ndef func_9(var_1, var_2):\n \"\"\"\"\"\"\n import numpy as np\n from numpy.fft import rfft, irfft\n\n var_8 = max(var_1)\n var_9 = max(var_2)\n var_3 = [0] * (var_8 + 1)\n var_4 = [0] * (var_9 + 1)\n for var_12 in var_1:\n var_3[var_12] += 1\n for var_13 in var_2:\n var_4[var_13] += 1\n\n var_6 = 1\n var_19 = 0\n while var_6 <= var_8 + var_9:\n var_19 += 1\n var_6 = 2**var_19\n\n var_21 = irfft(rfft(var_3, var_6) * rfft(var_4, var_6), var_6)\n\n var_21 = np.rint(var_21).astype(np.int64)\n return var_21\n\n\nvar_11, var_7, var_6 = func_3()\nvar_1 = func_2()\nvar_2 = func_2()\nvar_21 = list(func_9(var_1, var_2))\nvar_20 = var_5\nfor var_17, var_12 in enumerate(var_21):\n if var_12 != 0:\n var_20 = var_17\n break\nfor _ in range(var_6):\n var_22, var_23, var_14 = func_3()\n var_22 -= 1\n var_23 -= 1\n var_20 = min(var_20, var_1[var_22] + var_2[var_23] - var_14)\nprint(var_20)\n```", "output": "SLOWER 2.5091", "pair_id": "python_p02748_pair0009_reversed", "problem_id": "p02748", "language": "python", "direction": "reversed", "speedup_ratio": 5.6927} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_5 in range(var_1, var_2 + 1):\n var_3 = str(var_5)\n if var_3[0] == var_3[-1] and var_3[1] == var_3[-2]:\n var_4 += 1\nprint(var_4)\n```\n\n=== Code B (Modified) ===\n```python\nvar_4 = {}\nvar_5 = 0\nfor var_6 in range(10000, 100000):\n var_3 = list(str(var_6))\n if var_3 == list(reversed(var_3)):\n var_5 += 1\n var_4[var_6] = var_5\nvar_1, var_2 = list(map(int, input().split()))\nprint((var_4[var_2] - var_4[var_1 - 1] if var_1 > 10000 else var_4[var_2]))\n```", "output": "SLOWER 3.6652", "pair_id": "python_p03416_pair0180_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 12.6861} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_8 = int(eval(input()))\nvar_5 = []\nvar_10 = {}\nvar_9 = [0, 0]\nfor var_6 in range(var_8 - 1):\n var_1, var_2 = list(map(int, input().split(\" \")))\n var_5.append([var_1, var_2])\n var_10.setdefault(var_1, []).append(var_2)\n var_9.append(0)\nvar_7 = 0\nfor var_11 in range(1, var_8 + 1):\n var_13 = var_10.get(var_11, [])\n var_3 = 1\n for var_12 in var_13:\n if var_3 == var_9[var_11]:\n var_3 += 1\n else:\n pass\n var_9[var_12] = var_3\n if var_3 >= var_7:\n var_7 = var_3\n var_3 += 1\nprint(var_7)\nfor var_4 in var_5:\n print((var_9[var_4[1]]))\n```\n\n=== Code B (Modified) ===\n```python\nvar_11 = int(eval(input()))\nvar_12 = {var_8: [] for var_8 in range(1, var_11 + 1)}\nvar_19 = [False for var_8 in range(var_11 + 1)]\nvar_16 = []\nfor _ in range(var_11 - 1):\n var_2, var_3 = list(map(int, input().split()))\n var_12[var_2].append(var_3)\n var_12[var_3].append(var_2)\n var_16.append((var_2, var_3))\nvar_9 = var_16[0][0]\nvar_19[var_9] = True\nvar_6 = []\nvar_7 = []\nvar_14 = {var_8: {} for var_8 in range(1, var_11 + 1)}\nvar_10 = [0 for var_8 in range(var_11 + 1)]\n\nvar_4 = 1\nfor var_5 in var_12[var_9]:\n var_19[var_5] = True\n var_14[var_9][var_5] = var_4\n var_14[var_5][var_9] = var_4\n var_10[var_5] = var_4\n var_4 += 1\n var_6.append(var_5)\nwhile var_6:\n for var_15 in var_6:\n var_13 = 1\n for var_5 in var_12[var_15]:\n if var_19[var_5] == False:\n var_19[var_5] = True\n if var_13 != var_10[var_15]:\n var_14[var_15][var_5] = var_13\n var_14[var_5][var_15] = var_13\n var_10[var_5] = var_13\n var_13 += 1\n var_7.append(var_5)\n else:\n var_13 += 1\n var_14[var_15][var_5] = var_13\n var_14[var_5][var_15] = var_13\n var_10[var_5] = var_13\n var_13 += 1\n var_7.append(var_5)\n if var_7:\n var_6 = var_7\n var_7 = []\n else:\n var_6 = []\n var_7 = []\nvar_1 = 0\nfor var_8 in range(1, var_11 + 1):\n var_1 = max(var_1, len(var_12[var_8]))\nprint(var_1)\nfor var_8 in range(var_11 - 1):\n var_17, var_18 = var_16[var_8][0], var_16[var_8][1]\n print((var_14[var_17][var_18]))\n```", "output": "SLOWER 1.1629", "pair_id": "python_p02850_pair0034_reversed", "problem_id": "p02850", "language": "python", "direction": "reversed", "speedup_ratio": 2.239} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_2, var_1 = [int(var_12) for var_12 in input().split()]\nvar_3 = []\nfor var_8 in range(var_1):\n var_5, var_6 = [int(var_12) for var_12 in input().split()]\n var_3.append((var_5, var_6))\nvar_3.sort()\nvar_9 = float(\"inf\")\nvar_4 = [var_9 for var_5 in range(var_2 + 1)]\nfor var_5, var_6 in var_3:\n var_4[var_5] = min(var_4[var_5], var_6)\nvar_3 = [\n (var_5, var_4[var_5]) for var_5 in range(1, var_2 + 1) if var_4[var_5] != var_9\n]\nvar_3.sort(key=lambda var_11: var_11[1])\nvar_7 = [True] * (var_2)\nvar_10 = None\nfor var_5, var_6 in var_3:\n if var_10 == None or var_10 < var_5:\n var_7[var_6 - 1] = False\n var_10 = var_6 - 1\nprint((sum(1 for var_6 in var_7 if not var_6)))\n```\n\n=== Code B (Modified) ===\n```python\nvar_4, var_3 = list(map(int, input().split()))\nvar_1 = [tuple(map(int, input().split())) for _ in range(var_3)]\nvar_1.sort(key=lambda var_8: var_8[0])\nvar_7 = 1\nvar_2 = 10**9\nfor var_5, var_6 in var_1:\n if var_5 < var_2:\n var_2 = min(var_2, var_6)\n else:\n var_7 += 1\n var_2 = var_6\nprint(var_7)\n```", "output": "FASTER 1.0247", "pair_id": "python_p03295_pair0002_forward", "problem_id": "p03295", "language": "python", "direction": "forward", "speedup_ratio": 2.0345} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1 = list(map(int, input().split()))\nvar_2 = 0\nfor var_3 in range(var_1[0], var_1[1] + 1):\n var_4 = str(var_3)\n if var_4[0] == var_4[4] and var_4[1] == var_4[3]:\n var_2 += 1\nprint(var_2)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\n\n\ndef func_1(var_5):\n var_4 = 0\n for var_3 in range(1, var_5 + 1):\n if str(var_3) == str(var_3)[::-1]:\n var_4 += 1\n return var_4\n\n\nprint((func_1(var_2) - func_1(var_1 - 1)))\n```", "output": "SLOWER 1.8794", "pair_id": "python_p03416_pair0249_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 3.6793} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\ndef func_1(var_3):\n var_4 = int(var_3)\n for var_1 in range(var_4, 2 * var_4):\n for var_2 in range(2, int(var_1**0.5)):\n if var_1 % var_2 == 0:\n break\n else:\n return str(var_1)\n\n\nif __name__ == \"__main__\":\n import sys\n\n print((func_1(sys.stdin.read().strip())))\n```\n\n=== Code B (Modified) ===\n```python\nimport numpy as np\nfrom bisect import bisect_left\n\n\ndef func_1():\n var_4 = []\n var_1 = np.ones(10**5 + 10)\n var_1[0] = var_1[1] = 0\n for var_3, var_2 in enumerate(var_1):\n if var_2:\n var_4.append(var_3)\n var_1[2 * var_3 : 10**5 + 10 : var_3] = 0\n return var_4\n\n\ndef func_2(var_6):\n var_7 = int(var_6)\n var_5 = func_1()\n return str(var_5[bisect_left(var_5, var_7)])\n\n\nif __name__ == \"__main__\":\n import sys\n\n print((func_2(sys.stdin.read().strip())))\n```", "output": "SLOWER 7.8177", "pair_id": "python_p02819_pair0005_reversed", "problem_id": "p02819", "language": "python", "direction": "reversed", "speedup_ratio": 225.6147} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_3 in range(var_1, var_2 + 1):\n var_5 = list(str(var_3))\n var_6 = list(reversed(var_5))\n if var_5 == var_6:\n var_4 += 1\nprint(var_4)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\n\n\ndef func_1(var_5, var_6):\n var_4 = 0\n for var_3 in range(var_5, var_6 + 1):\n if str(var_3) == str(var_3)[::-1]:\n var_4 += 1\n return var_4\n\n\nprint((func_1(var_1, var_2)))\n```", "output": "FASTER 1.6323", "pair_id": "python_p03416_pair0152_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 3.1} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_4 = int(eval(input()))\nvar_1 = list(map(int, input().split()))\nvar_3 = 1\nfor var_2 in var_1:\n var_3 *= 2 if var_2 % 2 == 0 else 1\nprint((3**var_4 - var_3))\n```\n\n=== Code B (Modified) ===\n```python\nfrom functools import reduce\nfrom itertools import product\n\nvar_2 = int(eval(input()))\n(*var_1,) = list(map(int, input().split()))\nvar_4 = 0\nfor var_7 in product([-1, 0, 1], repeat=var_2):\n var_6 = reduce(\n lambda var_8, var_9: var_8 * var_9,\n [var_3 + var_7[var_5] for var_5, var_3 in enumerate(var_1)],\n )\n if var_6 % 2 == 0:\n var_4 += 1\nprint(var_4)\n```", "output": "SLOWER 9.8819", "pair_id": "python_p03568_pair0051_reversed", "problem_id": "p03568", "language": "python", "direction": "reversed", "speedup_ratio": 943.5387} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nfrom itertools import accumulate, count\nfrom bisect import bisect_right\n\neval(input())\nvar_1 = [0] + list(accumulate(list(map(int, input().split()))))\nvar_2 = bisect_right(var_1, var_1[-1] // 2)\nprint((min(2 * var_1[var_2] - var_1[-1], var_1[-1] - 2 * var_1[var_2 - 1])))\n```\n\n=== Code B (Modified) ===\n```python\nvar_8 = int(eval(input()))\nvar_1 = list(map(int, input().split()))\nvar_3 = 0\nvar_9 = sum(var_1)\nvar_2 = []\nvar_10 = 0\nfor var_6 in range(0, var_8):\n\n var_10 += var_1[var_6]\n var_11 = var_9 - var_10\n\n var_2.append(abs(var_10 - var_11))\n if var_10 == var_11:\n print((0))\n exit()\nvar_7 = var_2.index(min(var_2))\n\n\nvar_12 = sum(var_1[0:var_7])\nvar_13 = sum(var_1[var_7:])\n\n\nvar_4 = abs(var_12 - var_13)\nvar_14 = sum(var_1[0 : var_7 + 1])\nvar_15 = sum(var_1[var_7 + 1 :])\n\n\nvar_5 = abs(var_14 - var_15)\nprint((min(var_4, var_5)))\n```", "output": "SLOWER 1.1094", "pair_id": "python_p02854_pair0001_reversed", "problem_id": "p02854", "language": "python", "direction": "reversed", "speedup_ratio": 2.1576} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_4 = {}\nvar_5 = 0\nfor var_6 in range(10000, 100000):\n var_3 = list(str(var_6))\n if var_3 == list(reversed(var_3)):\n var_5 += 1\n var_4[var_6] = var_5\nvar_1, var_2 = list(map(int, input().split()))\nprint((var_4[var_2] - var_4[var_1 - 1] if var_1 > 10000 else var_4[var_2]))\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_3 = list(map(int, input().split()))\nvar_2 = 0\nfor var_5 in range(var_3 + 1)[var_1:]:\n if len(str(var_5)) % 2 == 0:\n var_6 = list(str(var_5))[: len(str(var_5)) // 2]\n var_7 = list(reversed(list(str(var_5))[len(str(var_5)) // 2 :]))\n if var_6 == var_7:\n var_2 += 1\n else:\n var_8 = list(str(var_5))[: len(str(var_5)) // 2 + 1]\n var_4 = list(reversed(list(str(var_5))[len(str(var_5)) // 2 :]))\n if var_8 == var_4:\n var_2 += 1\nprint(var_2)\n```", "output": "FASTER 1.0991", "pair_id": "python_p03416_pair0123_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 2.1422} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_4 = {}\nvar_5 = 0\nfor var_6 in range(10000, 100000):\n var_3 = list(str(var_6))\n if var_3 == list(reversed(var_3)):\n var_5 += 1\n var_4[var_6] = var_5\nvar_1, var_2 = list(map(int, input().split()))\nprint((var_4[var_2] - var_4[var_1 - 1] if var_1 > 10000 else var_4[var_2]))\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n if str(var_4) == \"\".join(reversed(str(var_4))):\n var_3 += 1\nprint(var_3)\n```", "output": "FASTER 2.4974", "pair_id": "python_p03416_pair0233_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 5.6465} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_4 = str(var_4)\n if var_4 == var_4[::-1]:\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = [0] * (var_2 + 1)\nfor var_3 in range(1, var_2 + 1):\n if str(var_3) == str(var_3)[::-1]:\n var_4[var_3] = var_4[var_3 - 1] + 1\n else:\n var_4[var_3] = var_4[var_3 - 1]\nprint((var_4[var_2] - var_4[var_1 - 1]))\n```", "output": "SLOWER 1.7953", "pair_id": "python_p03416_pair0250_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 3.4708} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\nimport math\nfrom collections import defaultdict\nfrom bisect import bisect_left, bisect_right\n\nsys.setrecursionlimit(10**7)\n\n\ndef func_4():\n return sys.stdin.readline()[:-1]\n\n\nvar_4 = 10**9 + 7\n\n\ndef func_1():\n return int(eval(func_4()))\n\n\ndef func_2():\n return list(map(int, func_4().split()))\n\n\ndef func_3(var_6, var_3):\n if var_6 <= 0:\n return [[] for _ in range(var_3)]\n elif var_3 == 1:\n return [func_1() for _ in range(var_6)]\n else:\n var_5 = [func_2() for _ in range(var_6)]\n return list(map(list, list(zip(*var_5))))\n\n\nvar_1, var_2 = list(map(str, func_4().split()))\nvar_1 = int(var_1)\nvar_2 = 100 * int(var_2[0]) + 10 * int(var_2[2]) + int(var_2[3])\nprint((var_1 * var_2 // 100))\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\n\nvar_3 = sys.stdin.readline\nif __name__ == \"__main__\":\n var_1, var_2 = var_3().split()\n print((int(var_1) * round(float(var_2) * 100) // 100))\n```", "output": "FASTER 2.2625", "pair_id": "python_p02659_pair0039_forward", "problem_id": "p02659", "language": "python", "direction": "forward", "speedup_ratio": 4.7983} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nfrom collections import Counter\n\nvar_1 = input()[::-1]\nvar_5 = [0]\nvar_4 = 0\nvar_6 = 2019\nfor var_7 in var_1:\n var_8 = int(var_7) * pow(10, var_4, var_6) % var_6\n var_8 = var_5[-1] + var_8\n var_5.append(var_8 % var_6)\n var_4 += 1\nvar_3 = Counter(var_5)\nvar_2 = sum(var_9 * (var_9 - 1) // 2 for var_9 in list(var_3.values()))\nprint(var_2)\n```\n\n=== Code B (Modified) ===\n```python\nvar_6 = input()[::-1]\nvar_4 = len(var_6)\nvar_2 = [0] * 2019\nvar_2[0] = 1\nvar_7 = 1\nvar_5 = 0\nvar_1 = 0\nfor var_3 in range(var_4):\n var_5 = (var_5 + int(var_6[var_3]) * var_7) % 2019\n var_7 = var_7 * 10 % 2019\n var_2[var_5] += 1\nfor var_3 in var_2:\n var_1 += var_3 * (var_3 - 1) // 2\nprint(var_1)\n```", "output": "SLOWER 1.9664", "pair_id": "python_p02702_pair0008_reversed", "problem_id": "p02702", "language": "python", "direction": "reversed", "speedup_ratio": 3.908} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\nfrom operator import itemgetter\nfrom heapq import heapify, heappop, heappush\n\nvar_1 = int(10e15)\nvar_2 = -var_1\nvar_11 = 1000000007\nsys.setrecursionlimit(1000000)\n\n\ndef func_2():\n return list(map(int, input().split()))\n\n\ndef func_4():\n return input().split()\n\n\ndef func_1():\n return int(sys.stdin.readline())\n\n\ndef func_3():\n return eval(input())\n\n\nvar_3, var_4 = func_2()\nvar_5 = [func_2() for var_9 in range(var_3)]\nvar_5.sort(key=itemgetter(0))\n\nvar_8 = [[0] * (var_4 + 1 + 3000 + 1) for _ in range(var_3 + 1)]\nvar_6 = 0\nfor var_9 in range(var_3):\n for var_10 in range(var_4 + 1 + 3000 + 1):\n var_12, var_7 = var_5[var_9]\n if 0 <= var_10 - var_12 < var_4:\n var_8[var_9 + 1][var_10] = max(\n var_8[var_9][var_10], var_8[var_9][var_10 - var_12] + var_7\n )\n else:\n var_8[var_9 + 1][var_10] = var_8[var_9][var_10]\n var_6 = max(var_6, var_8[var_9 + 1][var_10])\nprint(var_6)\n```\n\n=== Code B (Modified) ===\n```python\nfrom collections import Counter, defaultdict, deque\nfrom heapq import heappop, heappush, heapify\nimport sys, bisect, math, itertools, fractions, pprint\n\nsys.setrecursionlimit(10**8)\nvar_6 = 10**9 + 7\nvar_1 = float(\"inf\")\n\n\ndef func_1():\n return int(sys.stdin.readline())\n\n\ndef func_2():\n return list(map(int, sys.stdin.readline().split()))\n\n\nvar_8, var_11 = func_2()\nvar_17 = [func_2() for _ in range(var_8)]\nvar_10 = var_17[::-1]\nvar_14 = [[0] * var_11 for _ in range(var_8)]\nvar_3 = [[0] * var_11 for _ in range(var_8)]\nfor var_4 in range(var_8 - 1):\n var_16, var_15 = var_17[var_4]\n for var_5 in range(var_11):\n if var_5 < var_16:\n var_14[var_4 + 1][var_5] = var_14[var_4][var_5]\n else:\n var_14[var_4 + 1][var_5] = max(\n var_14[var_4][var_5], var_14[var_4][var_5 - var_16] + var_15\n )\nvar_9 = var_14[var_8 - 1][var_11 - 1] + var_17[var_8 - 1][1]\nfor var_4 in range(var_8 - 1):\n var_16, var_15 = var_10[var_4]\n for var_5 in range(var_11):\n if var_5 < var_16:\n var_3[var_4 + 1][var_5] = var_3[var_4][var_5]\n else:\n var_3[var_4 + 1][var_5] = max(\n var_3[var_4][var_5], var_3[var_4][var_5 - var_16] + var_15\n )\n var_9 = max(var_9, var_3[var_8 - 1][var_11 - 1] + var_17[0][1])\n\nfor var_4 in range(1, var_8 - 1):\n var_13 = var_4\n var_2 = var_8 - var_4 - 1\n var_7 = 0\n for var_5 in range(var_11):\n var_12 = var_14[var_13][var_5] + var_3[var_2][var_11 - 1 - var_5]\n var_7 = max(var_7, var_12)\n var_9 = max(var_9, var_7 + var_17[var_4][1])\nprint(var_9)\n```", "output": "FASTER 3.8148", "pair_id": "python_p02863_pair0023_forward", "problem_id": "p02863", "language": "python", "direction": "forward", "speedup_ratio": 14.0727} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_4 = str(var_4)\n if var_4 == var_4[::-1]:\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = list(str(var_4))\n if var_5 == list(reversed(var_5)):\n var_3 += 1\nprint(var_3)\n```", "output": "SLOWER 1.0852", "pair_id": "python_p03416_pair0032_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 2.1216} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\n\n\ndef func_1(var_5):\n var_4 = 0\n for var_3 in range(1, var_5 + 1):\n if str(var_3) == str(var_3)[::-1]:\n var_4 += 1\n return var_4\n\n\nprint((func_1(var_2) - func_1(var_1 - 1)))\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = str(var_4)\n if var_5[0] == var_5[4] and var_5[1] == var_5[3]:\n var_3 += 1\nprint(var_3)\n```", "output": "FASTER 1.8568", "pair_id": "python_p03416_pair0232_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 3.622} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\ndef func_1():\n var_1, var_2 = list(map(int, input().split()))\n var_3 = 0\n for var_4 in range(var_1, var_2 + 1):\n\n if (var_4 % 10) == (var_4 // 10000 % 10) and (var_4 // 10 % 10) == (\n var_4 // 1000 % 10\n ):\n var_3 += 1\n print(var_3)\n\n\nif __name__ == \"__main__\":\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = input().split()\nvar_1 = int(var_1)\nvar_2 = int(var_2)\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = list(str(var_4))\n if (var_5[0] == var_5[4]) and (var_5[1] == var_5[3]):\n var_3 = var_3 + 1\nprint(var_3)\n```", "output": "SLOWER 2.0684", "pair_id": "python_p03416_pair0171_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 4.1941} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_8 in range(var_1, var_2 + 1):\n var_7 = str(var_8)\n var_6 = len(var_7)\n var_4 = True\n for var_5 in range(var_6 // 2):\n if var_7[var_5] != var_7[var_6 - 1 - var_5]:\n var_4 = False\n break\n if var_4:\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\ndef func_1():\n var_1, var_2 = list(map(int, input().split()))\n var_3 = 0\n for var_4 in range(var_1, var_2 + 1):\n\n if (var_4 % 10) == (var_4 // 10000 % 10) and (var_4 // 10 % 10) == (\n var_4 // 1000 % 10\n ):\n var_3 += 1\n print(var_3)\n\n\nif __name__ == \"__main__\":\n func_1()\n```", "output": "FASTER 2.7903", "pair_id": "python_p03416_pair0223_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 6.9176} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\nimport itertools\n\n\ndef func_2(var_4):\n return bin(eval(\"0b\" + str(var_4)))\n\n\ndef func_1():\n var_4 = int(sys.stdin.readline().rstrip())\n var_9 = [\n func_2(\"\".join(str(var_10) for var_10 in sys.stdin.readline().split()))\n for _ in range(var_4)\n ]\n var_8 = [\n [int(var_10) for var_10 in sys.stdin.readline().split()] for _ in range(var_4)\n ]\n var_3 = -(10**10)\n for var_6 in itertools.product(\"01\", repeat=10):\n var_6 = func_2(\"\".join(var_6))\n if var_6 == \"0b0\":\n continue\n var_7 = 0\n for var_2 in range(var_4):\n var_1 = var_9[var_2]\n var_5 = bin(eval(var_1) & eval(var_6)).count(\"1\")\n var_7 += var_8[var_2][var_5]\n var_3 = max(var_3, var_7)\n print(var_3)\n\n\nif __name__ == \"__main__\":\n\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\n\nvar_8 = sys.stdin.readline\n\n\ndef func_1():\n var_2 = int(eval(var_8()))\n var_1 = []\n for _ in range(var_2):\n var_1.append(list(map(int, var_8().split())))\n var_3 = []\n for _ in range(var_2):\n var_3.append(list(map(int, var_8().split())))\n var_4 = -(10**7) * var_2\n for var_7 in range(1, 1 << 10):\n var_11 = 0\n for var_10, var_6 in enumerate(var_1):\n var_5 = 0\n for var_9 in range(10):\n if (var_7 >> var_9) & 1 & var_6[var_9]:\n var_5 += 1\n var_11 += var_3[var_10][var_5]\n var_4 = max(var_4, var_11)\n print(var_4)\n\n\nif __name__ == \"__main__\":\n func_1()\n```", "output": "FASTER 3.5396", "pair_id": "python_p03503_pair0050_forward", "problem_id": "p03503", "language": "python", "direction": "forward", "speedup_ratio": 11.6284} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nfrom sys import stdin\n\nvar_5 = stdin.readline\nvar_2, var_1 = list(map(int, var_5().split()))\nvar_3 = [False] * var_2\nvar_8 = [0] * var_2\nvar_9 = 0\nfor var_4 in range(var_1):\n var_6, var_7 = var_5().split()\n var_6 = int(var_6) - 1\n if var_3[var_6] is False and var_7 == \"AC\":\n var_9 += var_8[var_6]\n var_3[var_6] = True\n elif var_7 == \"WA\":\n var_8[var_6] += 1\nprint((var_3.count(True), var_9))\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\n\nvar_2, var_1, *var_3 = sys.stdin.read().strip().split()\nvar_2 = int(var_2)\nvar_5 = [0] * var_2\nvar_10 = [0] * var_2\nfor var_6, var_8 in zip(*[iter(var_3)] * 2):\n var_6 = int(var_6) - 1\n if var_8 == \"AC\":\n var_5[var_6] = 1\n elif var_5[var_6] == 0:\n var_10[var_6] += 1\nvar_7 = sum([var_9 * var_4 for var_4, var_9 in zip(var_5, var_10)])\nprint((\"{} {}\".format(sum(var_5), var_7)))\n```", "output": "SLOWER 1.5188", "pair_id": "python_p02802_pair0011_reversed", "problem_id": "p02802", "language": "python", "direction": "reversed", "speedup_ratio": 2.8656} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nfrom math import sqrt\n\nvar_2 = int(eval(input()))\n\n\ndef func_1(var_2):\n if var_2 < 2:\n return False\n for var_1 in range(2, int(sqrt(var_2)) + 1):\n if var_2 % var_1 == 0:\n return False\n return True\n\n\nwhile not func_1(var_2):\n var_2 += 1\nprint(var_2)\n```\n\n=== Code B (Modified) ===\n```python\nimport numpy as np\nfrom bisect import bisect_left\n\n\ndef func_1():\n var_4 = []\n var_1 = np.ones(10**5 + 10)\n var_1[0] = var_1[1] = 0\n for var_3, var_2 in enumerate(var_1):\n if var_2:\n var_4.append(var_3)\n var_1[2 * var_3 : 10**5 + 10 : var_3] = 0\n return var_4\n\n\ndef func_2(var_6):\n var_7 = int(var_6)\n var_5 = func_1()\n return str(var_5[bisect_left(var_5, var_7)])\n\n\nif __name__ == \"__main__\":\n import sys\n\n print((func_2(sys.stdin.read().strip())))\n```", "output": "SLOWER 7.7622", "pair_id": "python_p02819_pair0009_reversed", "problem_id": "p02819", "language": "python", "direction": "reversed", "speedup_ratio": 217.0952} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport math\n\n\ndef func_1():\n var_1, var_2 = list(map(int, input().split()))\n\n var_5 = max(math.ceil(var_1 / 0.08), math.ceil(var_2 / 0.1))\n\n var_4 = min((math.ceil((var_1 + 1) / 0.08), math.ceil((var_2 + 1) / 0.1)))\n\n for var_3 in range(var_5, var_4 + 1):\n if (math.floor(var_3 * 0.08) == var_1) and (math.floor(var_3 * 0.1) == var_2):\n print(var_3)\n quit()\n\n print((-1))\n\n\nif __name__ == \"__main__\":\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nfor var_3 in range(1, 1009):\n if int(var_3 * 0.08) == var_1 and int(var_3 * 0.1) == var_2:\n print((int(var_3)))\n exit()\nprint(\"-1\")\n```", "output": "SLOWER 1.1794", "pair_id": "python_p02755_pair0013_reversed", "problem_id": "p02755", "language": "python", "direction": "reversed", "speedup_ratio": 2.2649} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\nimport math\nfrom collections import defaultdict\nfrom bisect import bisect_left, bisect_right\n\nsys.setrecursionlimit(10**7)\n\n\ndef func_4():\n return sys.stdin.readline()[:-1]\n\n\nvar_4 = 10**9 + 7\n\n\ndef func_1():\n return int(eval(func_4()))\n\n\ndef func_2():\n return list(map(int, func_4().split()))\n\n\ndef func_3(var_6, var_3):\n if var_6 <= 0:\n return [[] for _ in range(var_3)]\n elif var_3 == 1:\n return [func_1() for _ in range(var_6)]\n else:\n var_5 = [func_2() for _ in range(var_6)]\n return list(map(list, list(zip(*var_5))))\n\n\nfrom decimal import getcontext, Decimal\n\ngetcontext().prec = 28\nvar_1, var_2 = list(map(str, func_4().split()))\nvar_1 = int(var_1)\nvar_2 = Decimal(var_2)\nprint((int(var_1 * var_2)))\n```\n\n=== Code B (Modified) ===\n```python\nimport math\n\nvar_1, var_2 = input().split()\nvar_1 = int(var_1)\nvar_3 = int(var_2[0] + var_2[2] + var_2[3])\nprint((int(var_1 * var_3) // 100))\n```", "output": "FASTER 2.2596", "pair_id": "python_p02659_pair0050_forward", "problem_id": "p02659", "language": "python", "direction": "forward", "speedup_ratio": 4.7885} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\nimport itertools\n\n\ndef func_2(var_4):\n return eval(\"0b\" + var_4)\n\n\ndef func_1():\n var_4 = int(sys.stdin.readline().rstrip())\n var_9 = [\n func_2(\"\".join(str(var_10) for var_10 in sys.stdin.readline().split()))\n for _ in range(var_4)\n ]\n var_8 = [\n [int(var_10) for var_10 in sys.stdin.readline().split()] for _ in range(var_4)\n ]\n var_3 = -(10**10)\n for var_6 in itertools.product(\"01\", repeat=10):\n var_6 = func_2(\"\".join(var_6))\n if var_6 == 0:\n continue\n var_7 = 0\n for var_2 in range(var_4):\n var_1 = var_9[var_2]\n var_5 = bin(var_1 & var_6).count(\"1\")\n var_7 += var_8[var_2][var_5]\n var_3 = max(var_3, var_7)\n print(var_3)\n\n\nif __name__ == \"__main__\":\n\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\n\nvar_8 = sys.stdin.readline\n\n\ndef func_1():\n var_2 = int(eval(var_8()))\n var_1 = [int(var_8().replace(\" \", \"\"), 2) for _ in range(var_2)]\n var_3 = [list(map(int, var_8().split())) for _ in range(var_2)]\n var_4 = -(10**7) * var_2\n for var_7 in range(1, 1 << 10):\n var_10 = 0\n for var_9, var_6 in enumerate(var_1):\n var_5 = bin(var_7 & var_6).count(\"1\")\n var_10 += var_3[var_9][var_5]\n var_4 = max(var_4, var_10)\n print(var_4)\n\n\nif __name__ == \"__main__\":\n func_1()\n```", "output": "FASTER 3.1382", "pair_id": "python_p03503_pair0029_forward", "problem_id": "p03503", "language": "python", "direction": "forward", "speedup_ratio": 8.8042} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\nimport math\nfrom collections import defaultdict\nfrom bisect import bisect_left, bisect_right\n\nsys.setrecursionlimit(10**7)\n\n\ndef func_4():\n return sys.stdin.readline()[:-1]\n\n\nvar_4 = 10**9 + 7\n\n\ndef func_1():\n return int(eval(func_4()))\n\n\ndef func_2():\n return list(map(int, func_4().split()))\n\n\ndef func_3(var_6, var_3):\n if var_6 <= 0:\n return [[] for _ in range(var_3)]\n elif var_3 == 1:\n return [func_1() for _ in range(var_6)]\n else:\n var_5 = [func_2() for _ in range(var_6)]\n return list(map(list, list(zip(*var_5))))\n\n\nvar_1, var_2 = list(map(str, func_4().split()))\nvar_1 = int(var_1)\nvar_2 = 100 * int(var_2[0]) + 10 * int(var_2[2]) + int(var_2[3])\nprint((var_1 * var_2 // 100))\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = input().split()\nvar_1 = int(var_1)\nvar_2 = int(\"\".join(var_2.split(\".\")))\nprint(((var_1 * var_2) // 100))\n```", "output": "FASTER 2.5041", "pair_id": "python_p02659_pair0063_forward", "problem_id": "p02659", "language": "python", "direction": "forward", "speedup_ratio": 5.673} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n if list(str(var_4)) == list(reversed(str(var_4))):\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_5 in range(var_1, var_2 + 1):\n var_3 = str(var_5)\n if var_3[0] == var_3[-1] and var_3[1] == var_3[-2]:\n var_4 += 1\nprint(var_4)\n```", "output": "FASTER 1.492", "pair_id": "python_p03416_pair0234_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 2.8127} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = str(var_4)\n if var_5 == var_5[::-1]:\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\n\n\ndef func_1(var_5):\n var_4 = 0\n for var_3 in range(1, var_5 + 1):\n if str(var_3) == str(var_3)[::-1]:\n var_4 += 1\n return var_4\n\n\nprint((func_1(var_2) - func_1(var_1 - 1)))\n```", "output": "SLOWER 1.5951", "pair_id": "python_p03416_pair0213_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 3.0211} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nfrom fractions import Fraction\n\nvar_1, var_2 = input().split()\n\n\nfrom decimal import *\n\nvar_4 = var_3(var_1)\nvar_6 = var_3(var_2)\nvar_7().prec = 28\nvar_5 = var_4 * var_6\nprint((int(var_5)))\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\nimport math\nfrom collections import defaultdict\nfrom bisect import bisect_left, bisect_right\n\nsys.setrecursionlimit(10**7)\n\n\ndef func_4():\n return sys.stdin.readline()[:-1]\n\n\nvar_4 = 10**9 + 7\n\n\ndef func_1():\n return int(eval(func_4()))\n\n\ndef func_2():\n return list(map(int, func_4().split()))\n\n\ndef func_3(var_6, var_3):\n if var_6 <= 0:\n return [[] for _ in range(var_3)]\n elif var_3 == 1:\n return [func_1() for _ in range(var_6)]\n else:\n var_5 = [func_2() for _ in range(var_6)]\n return list(map(list, list(zip(*var_5))))\n\n\nvar_1, var_2 = list(map(str, func_4().split()))\nvar_1 = int(var_1)\nvar_2 = 100 * int(var_2[0]) + 10 * int(var_2[2]) + int(var_2[3])\nprint((var_1 * var_2 // 100))\n```", "output": "SLOWER 1.9202", "pair_id": "python_p02659_pair0025_reversed", "problem_id": "p02659", "language": "python", "direction": "reversed", "speedup_ratio": 3.7848} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_4 = {}\nvar_5 = 0\nfor var_6 in range(10000, 100000):\n var_3 = list(str(var_6))\n if var_3 == list(reversed(var_3)):\n var_5 += 1\n var_4[var_6] = var_5\nvar_1, var_2 = list(map(int, input().split()))\nprint((var_4[var_2] - var_4[var_1 - 1] if var_1 > 10000 else var_4[var_2]))\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = input().split()\nvar_1 = int(var_1)\nvar_2 = int(var_2)\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = list(str(var_4))\n if (var_5[0] == var_5[4]) and (var_5[1] == var_5[3]):\n var_3 = var_3 + 1\nprint(var_3)\n```", "output": "FASTER 3.1693", "pair_id": "python_p03416_pair0247_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 8.996} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_5 in range(10):\n for var_6 in range(10):\n for var_7 in range(10):\n var_3 = 10000 * var_5 + 1000 * var_6 + 100 * var_7 + 10 * var_6 + var_5\n if var_1 <= var_3 <= var_2:\n var_4 += 1\nprint(var_4)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_3 in range(var_1, var_2 + 1):\n var_5 = list(str(var_3))\n var_6 = list(reversed(var_5))\n if var_5 == var_6:\n var_4 += 1\nprint(var_4)\n```", "output": "SLOWER 5.1342", "pair_id": "python_p03416_pair0251_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 35.1196} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\ndef func_1():\n var_1, var_2 = list(map(int, input().rstrip().split()))\n var_3 = 0\n for var_4 in range(var_1, var_2 + 1):\n var_5 = str(var_4)\n if var_5 == var_5[::-1]:\n var_3 += 1\n print(var_3)\n\n\nif __name__ == \"__main__\":\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nvar_10 = []\nvar_10 = input().rstrip().split(\" \")\nvar_1 = int(var_10[0])\nvar_3 = int(var_10[1])\nvar_2 = 0\nvar_6 = var_1\nwhile var_6 <= var_3:\n var_4 = var_6 // 10000\n var_5 = (var_6 - var_4 * 10000) // 1000\n var_7 = var_6 // 100\n var_8 = (var_6 - var_7 * 100) // 10\n var_9 = var_6 % 10\n if (var_4 == var_9) and (var_5 == var_8):\n var_2 += 1\n var_6 += 1\nprint(var_2)\n```", "output": "SLOWER 1.555", "pair_id": "python_p03416_pair0072_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 2.9383} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = [\n var_3 for var_3 in map(str, list(range(var_1, var_2 + 1))) if var_3 == var_3[::-1]\n]\nprint((len(var_4)))\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_3 = list(map(int, input().split()))\nvar_2 = 0\nfor var_5 in range(var_3 + 1)[var_1:]:\n if len(str(var_5)) % 2 == 0:\n var_6 = list(str(var_5))[: len(str(var_5)) // 2]\n var_7 = list(reversed(list(str(var_5))[len(str(var_5)) // 2 :]))\n if var_6 == var_7:\n var_2 += 1\n else:\n var_8 = list(str(var_5))[: len(str(var_5)) // 2 + 1]\n var_4 = list(reversed(list(str(var_5))[len(str(var_5)) // 2 :]))\n if var_8 == var_4:\n var_2 += 1\nprint(var_2)\n```", "output": "SLOWER 3.1731", "pair_id": "python_p03416_pair0241_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 9.0199} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_11 = int(eval(input()))\nvar_12 = {var_8: [] for var_8 in range(1, var_11 + 1)}\nvar_19 = [False for var_8 in range(var_11 + 1)]\nvar_16 = []\nfor _ in range(var_11 - 1):\n var_2, var_3 = list(map(int, input().split()))\n var_12[var_2].append(var_3)\n var_12[var_3].append(var_2)\n var_16.append((var_2, var_3))\nvar_9 = var_16[0][0]\nvar_19[var_9] = True\nvar_6 = []\nvar_7 = []\nvar_14 = {var_8: {} for var_8 in range(1, var_11 + 1)}\nvar_10 = [0 for var_8 in range(var_11 + 1)]\n\nvar_4 = 1\nfor var_5 in var_12[var_9]:\n var_19[var_5] = True\n var_14[var_9][var_5] = var_4\n var_14[var_5][var_9] = var_4\n var_10[var_5] = var_4\n var_4 += 1\n var_6.append(var_5)\nwhile var_6:\n for var_15 in var_6:\n var_13 = 1\n for var_5 in var_12[var_15]:\n if var_19[var_5] == False:\n var_19[var_5] = True\n if var_13 != var_10[var_15]:\n var_14[var_15][var_5] = var_13\n var_14[var_5][var_15] = var_13\n var_10[var_5] = var_13\n var_13 += 1\n var_7.append(var_5)\n else:\n var_13 += 1\n var_14[var_15][var_5] = var_13\n var_14[var_5][var_15] = var_13\n var_10[var_5] = var_13\n var_13 += 1\n var_7.append(var_5)\n if var_7:\n var_6 = var_7\n var_7 = []\n else:\n var_6 = []\n var_7 = []\nvar_1 = 0\nfor var_8 in range(1, var_11 + 1):\n var_1 = max(var_1, len(var_12[var_8]))\nprint(var_1)\nfor var_8 in range(var_11 - 1):\n var_17, var_18 = var_16[var_8][0], var_16[var_8][1]\n print((var_14[var_17][var_18]))\n```\n\n=== Code B (Modified) ===\n```python\nvar_8 = int(eval(input()))\nvar_5 = []\nvar_10 = {}\nvar_9 = [0, 0]\nfor var_6 in range(var_8 - 1):\n var_1, var_2 = list(map(int, input().split(\" \")))\n var_5.append([var_1, var_2])\n var_10.setdefault(var_1, []).append(var_2)\n var_9.append(0)\nvar_7 = 0\nfor var_11 in range(1, var_8 + 1):\n var_13 = var_10.get(var_11, [])\n var_3 = 1\n for var_12 in var_13:\n if var_3 == var_9[var_11]:\n var_3 += 1\n else:\n pass\n var_9[var_12] = var_3\n if var_3 >= var_7:\n var_7 = var_3\n var_3 += 1\nprint(var_7)\nfor var_4 in var_5:\n print((var_9[var_4[1]]))\n```", "output": "FASTER 1.1629", "pair_id": "python_p02850_pair0034_forward", "problem_id": "p02850", "language": "python", "direction": "forward", "speedup_ratio": 2.239} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_4 = str(var_4)\n if var_4 == var_4[::-1]:\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_4 = {}\nvar_5 = 0\nfor var_6 in range(10000, 100000):\n var_3 = list(str(var_6))\n if var_3 == list(reversed(var_3)):\n var_5 += 1\n var_4[var_6] = var_5\nvar_1, var_2 = list(map(int, input().split()))\nprint((var_4[var_2] - var_4[var_1 - 1] if var_1 > 10000 else var_4[var_2]))\n```", "output": "SLOWER 3.4266", "pair_id": "python_p03416_pair0248_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 10.7526} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_8, var_9 = list(map(int, input().split()))\nvar_5 = [[0] * (var_9 + 3001) for _ in range(var_8 + 1)]\nvar_3 = 0\nvar_2 = [list(map(int, input().split())) for _ in range(var_8)]\nvar_2.sort()\nfor var_6 in range(1, var_8 + 1):\n var_1, var_4 = var_2[var_6 - 1]\n for var_7 in range(var_9):\n var_5[var_6][var_7] = max(var_5[var_6 - 1][var_7], var_5[var_6][var_7])\n var_5[var_6][var_7 + var_1] = var_5[var_6 - 1][var_7] + var_4\n var_3 = max(var_5[var_6][var_7], var_5[var_6][var_7 + var_1], var_3)\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nfrom collections import Counter, defaultdict, deque\nfrom heapq import heappop, heappush, heapify\nimport sys, bisect, math, itertools, fractions, pprint\n\nsys.setrecursionlimit(10**8)\nvar_6 = 10**9 + 7\nvar_1 = float(\"inf\")\n\n\ndef func_1():\n return int(sys.stdin.readline())\n\n\ndef func_2():\n return list(map(int, sys.stdin.readline().split()))\n\n\nvar_7, var_9 = func_2()\nvar_13 = [func_2() for _ in range(var_7)]\nvar_13.sort(key=lambda var_14: var_14[1], reverse=True)\nvar_8 = 0\nvar_10 = min(var_7, 5)\nfor var_3 in range(var_10):\n var_2 = [[0] * (var_9 + 5) for _ in range(var_7 + 5)]\n for var_4 in range(var_7):\n var_12, var_11 = var_13[var_4]\n for var_5 in range(var_9):\n if var_5 < var_12 or var_3 == var_4:\n var_2[var_4 + 1][var_5] = var_2[var_4][var_5]\n else:\n var_2[var_4 + 1][var_5] = max(\n var_2[var_4][var_5], var_2[var_4][var_5 - var_12] + var_11\n )\n\n var_8 = max(var_2[var_7][var_9 - 1] + var_13[var_3][1], var_8)\nprint(var_8)\n```", "output": "SLOWER 1.1289", "pair_id": "python_p02863_pair0031_reversed", "problem_id": "p02863", "language": "python", "direction": "reversed", "speedup_ratio": 2.1869} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_7, var_6 = list(map(int, input().split()))\nvar_5 = [tuple(input().split()) for _ in range(var_6)]\nvar_9 = [[] for _ in range(var_7)]\nfor var_2 in range(var_6):\n var_9[int(var_5[var_2][0]) - 1].append(var_5[var_2][1])\nvar_1, var_8 = 0, 0\nfor var_3 in range(var_7):\n if \"AC\" in var_9[var_3]:\n var_1 += 1\n for var_4 in range(len(var_9[var_3])):\n if var_9[var_3][var_4] == \"WA\":\n var_8 += 1\n else:\n break\nprint((var_1, var_8))\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\n\nvar_2, var_1, *var_3 = sys.stdin.read().strip().split()\nvar_2 = int(var_2)\nvar_5 = [0] * var_2\nvar_10 = [0] * var_2\nfor var_6, var_8 in zip(*[iter(var_3)] * 2):\n var_6 = int(var_6) - 1\n if var_8 == \"AC\":\n var_5[var_6] = 1\n elif var_5[var_6] == 0:\n var_10[var_6] += 1\nvar_7 = sum([var_9 * var_4 for var_4, var_9 in zip(var_5, var_10)])\nprint((\"{} {}\".format(sum(var_5), var_7)))\n```", "output": "FASTER 1.5456", "pair_id": "python_p02802_pair0004_forward", "problem_id": "p02802", "language": "python", "direction": "forward", "speedup_ratio": 2.9193} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nfrom collections import deque\n\n\ndef func_2(var_9, var_2, var_4):\n\n var_6 = {var_7: dict() for var_7 in range(var_9)}\n for var_7 in range(var_9 - 1):\n var_1, var_3 = var_2[var_7] - 1, var_4[var_7] - 1\n var_6[var_1][var_3] = -1\n var_6[var_3][var_1] = -1\n var_8 = max([len(var_6[var_1]) for var_1 in range(var_9)])\n var_14 = [-1] * var_9\n var_14[0] = var_8 - 1\n\n var_12 = deque([0])\n while len(var_12) > 0:\n var_10 = var_12.popleft()\n var_5 = var_14[var_10]\n for var_11 in list(var_6[var_10].keys()):\n if var_14[var_11] != -1:\n continue\n var_5 += 1\n var_5 %= var_8\n\n var_6[var_10][var_11] = var_5\n var_6[var_11][var_10] = var_5\n var_14[var_11] = var_5\n var_12.append(var_11)\n var_13 = [0] * (var_9 - 1)\n for var_7 in range(var_9 - 1):\n var_13[var_7] = var_6[var_2[var_7] - 1][var_4[var_7] - 1] + 1\n return var_8, var_13\n\n\ndef func_1():\n var_9 = int(eval(input()))\n var_2 = [0] * (var_9 - 1)\n var_4 = [0] * (var_9 - 1)\n for var_7 in range(var_9 - 1):\n var_1, var_3 = list(map(int, input().split()))\n var_2[var_7] = var_1\n var_4[var_7] = var_3\n var_8, var_13 = func_2(var_9, var_2, var_4)\n print(var_8)\n for var_7 in range(var_9 - 1):\n print((var_13[var_7]))\n\n\ndef func_3():\n print((func_2(3, [1, 2], [2, 3])))\n print((func_2(8, [1, 2, 2, 2, 4, 5, 6], [2, 3, 4, 5, 7, 6, 8])))\n\n\nif __name__ == \"__main__\":\n\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\nfrom collections import deque\n\nvar_13 = sys.stdin.readline\nvar_2 = int(eval(var_13()))\nvar_5 = [[] for _ in range(var_2)]\nvar_3 = [-1] * var_2\nfor var_12 in range(var_2 - 1):\n var_6, var_8 = list(map(int, var_13().split()))\n var_5[var_6 - 1].append((var_12, var_8 - 1))\n\n\nvar_4 = deque([(0, -1)])\nvar_1 = [-1] * (var_2 - 1)\nvar_11 = 0\nwhile var_4:\n var_14, var_10 = var_4.pop()\n var_9 = 1\n for var_12, var_15 in var_5[var_14]:\n if var_9 == var_10:\n var_9 += 1\n var_1[var_12] = var_9\n var_4.appendleft((var_15, var_9))\n var_9 += 1\n var_11 = max(var_11, var_9 - 1)\nprint(var_11)\nfor var_7 in var_1:\n print(var_7)\n```", "output": "FASTER 1.0324", "pair_id": "python_p02850_pair0032_forward", "problem_id": "p02850", "language": "python", "direction": "forward", "speedup_ratio": 2.0454} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nfrom math import floor\n\nvar_1, var_2 = list(map(int, input().split()))\n\n\nfor var_3 in range(1010):\n if (floor(var_3 * 0.08) == var_1) and (floor(var_3 * 0.1) == var_2):\n\n print(var_3)\n quit()\n\n\nprint((-1))\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nimport math\n\nif math.ceil((var_1 + 1) * 12.5) <= math.ceil(var_2 * 10) or math.ceil(\n var_1 * 12.5\n) >= math.ceil((var_2 + 1) * 10):\n print((-1))\nelse:\n print((max(math.ceil(var_1 * 12.5), math.ceil(var_2 * 10))))\n```", "output": "FASTER 1.8508", "pair_id": "python_p02755_pair0010_forward", "problem_id": "p02755", "language": "python", "direction": "forward", "speedup_ratio": 3.6071} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1 = list(map(int, input().split()))\nvar_2 = 0\nfor var_3 in range(var_1[0], var_1[1] + 1):\n var_4 = str(var_3)\n if var_4[0] == var_4[4] and var_4[1] == var_4[3]:\n var_2 += 1\nprint(var_2)\n```\n\n=== Code B (Modified) ===\n```python\nvar_4 = {}\nvar_5 = 0\nfor var_6 in range(10000, 100000):\n var_3 = list(str(var_6))\n if var_3 == list(reversed(var_3)):\n var_5 += 1\n var_4[var_6] = var_5\nvar_1, var_2 = list(map(int, input().split()))\nprint((var_4[var_2] - var_4[var_1 - 1] if var_1 > 10000 else var_4[var_2]))\n```", "output": "SLOWER 3.8624", "pair_id": "python_p03416_pair0159_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 14.5446} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_4 = {}\nvar_5 = 0\nfor var_6 in range(10000, 100000):\n var_3 = list(str(var_6))\n if var_3 == list(reversed(var_3)):\n var_5 += 1\n var_4[var_6] = var_5\nvar_1, var_2 = list(map(int, input().split()))\nprint((var_4[var_2] - var_4[var_1 - 1] if var_1 > 10000 else var_4[var_2]))\n```\n\n=== Code B (Modified) ===\n```python\ndef func_1():\n var_1, var_2 = list(map(int, input().split()))\n var_3 = 0\n for var_4 in range(var_1, var_2 + 1):\n\n if (var_4 % 10) == (var_4 // 10000 % 10) and (var_4 // 10 % 10) == (\n var_4 // 1000 % 10\n ):\n var_3 += 1\n print(var_3)\n\n\nif __name__ == \"__main__\":\n func_1()\n```", "output": "FASTER 5.2377", "pair_id": "python_p03416_pair0209_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 37.7303} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_3 = list(map(int, input().split()))\nvar_2 = 0\nfor var_5 in range(var_3 + 1)[var_1:]:\n if len(str(var_5)) % 2 == 0:\n var_6 = list(str(var_5))[: len(str(var_5)) // 2]\n var_7 = list(reversed(list(str(var_5))[len(str(var_5)) // 2 :]))\n if var_6 == var_7:\n var_2 += 1\n else:\n var_8 = list(str(var_5))[: len(str(var_5)) // 2 + 1]\n var_4 = list(reversed(list(str(var_5))[len(str(var_5)) // 2 :]))\n if var_8 == var_4:\n var_2 += 1\nprint(var_2)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_5 in range(var_1, var_2 + 1):\n var_3 = str(var_5)\n if var_3[0] == var_3[-1] and var_3[1] == var_3[-2]:\n var_4 += 1\nprint(var_4)\n```", "output": "FASTER 2.5661", "pair_id": "python_p03416_pair0215_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 5.9221} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_2, var_3, *var_1 = list(map(int, open(0).read().split()))\nvar_4 = [0] * (var_3 + max(var_1[::2]))\nfor var_7, var_6 in sorted(zip(*[iter(var_1)] * 2)):\n for var_5 in reversed(list(range(var_3))):\n var_4[var_5 + var_7] = max(var_4[var_5 + var_7], var_4[var_5] + var_6)\nprint((max(var_4)))\n```\n\n=== Code B (Modified) ===\n```python\nvar_8, var_9 = list(map(int, input().split()))\nvar_5 = [[0] * (var_9 + 3001) for _ in range(var_8 + 1)]\nvar_3 = 0\nvar_2 = [list(map(int, input().split())) for _ in range(var_8)]\nvar_2.sort()\nfor var_6 in range(1, var_8 + 1):\n var_1, var_4 = var_2[var_6 - 1]\n for var_7 in range(var_9):\n var_5[var_6][var_7] = max(var_5[var_6 - 1][var_7], var_5[var_6][var_7])\n var_5[var_6][var_7 + var_1] = var_5[var_6 - 1][var_7] + var_4\n var_3 = max(var_5[var_6][var_7], var_5[var_6][var_7 + var_1], var_3)\nprint(var_3)\n```", "output": "SLOWER 1.0971", "pair_id": "python_p02863_pair0037_reversed", "problem_id": "p02863", "language": "python", "direction": "reversed", "speedup_ratio": 2.1392} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_4 = int(eval(input()))\nvar_2 = list(map(int, input().split()))\n\n\ndef func_1(var_1, var_8, var_3):\n if var_8 == var_4:\n var_9 = 1\n for var_5 in var_3:\n var_9 *= var_5\n return 1 if var_9 % 2 == 0 else 0\n var_6 = var_3.copy()\n var_6.append(var_1[var_8] - 1)\n var_5 = var_3.copy()\n var_5.append(var_1[var_8])\n var_7 = var_3.copy()\n var_7.append(var_1[var_8] + 1)\n return (\n func_1(var_1, var_8 + 1, var_6)\n + func_1(var_1, var_8 + 1, var_5)\n + func_1(var_1, var_8 + 1, var_7)\n )\n\n\nprint((func_1(var_2, 0, [])))\n```\n\n=== Code B (Modified) ===\n```python\ndef func_1():\n var_2 = int(eval(input()))\n var_1 = [int(var_6) for var_6 in input().split()]\n var_4 = 3**var_2\n var_5 = len([var_3 for var_3 in var_1 if var_3 % 2 == 0])\n var_4 -= 2**var_5\n print(var_4)\n\n\nif __name__ == \"__main__\":\n func_1()\n```", "output": "FASTER 7.7739", "pair_id": "python_p03568_pair0015_forward", "problem_id": "p03568", "language": "python", "direction": "forward", "speedup_ratio": 218.8599} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\n\nvar_10 = sys.stdin.readline\nvar_2, var_3 = list(map(int, var_10().split()))\nvar_1 = [list(map(int, var_10().split())) for _ in range(var_2)]\nvar_8 = [[0 for _ in range(var_2 + 1)] for _ in range(var_3 + 1)]\n\nvar_13 = [[0 for _ in range(var_2 + 1)] for _ in range(var_3 + 1)]\nfor var_11 in range(var_2):\n var_4, var_6 = var_1[var_11]\n for var_15 in range(var_3):\n if var_4 > var_15:\n var_8[var_15][var_11 + 1] = var_8[var_15][var_11]\n var_13[var_15][var_11 + 1] = var_15\n else:\n if var_6 + var_8[var_15 - var_4][var_11] >= var_8[var_15][var_11]:\n var_8[var_15][var_11 + 1] = var_8[var_15 - var_4][var_11] + var_6\n var_13[var_15][var_11 + 1] = var_15 - var_4\n else:\n var_8[var_15][var_11 + 1] = var_8[var_15][var_11]\n var_13[var_15][var_11 + 1] = var_15\nvar_5 = var_8[var_3 - 1][var_2]\nvar_14 = [False] * var_2\nvar_7 = var_3 - 1\nfor var_9 in reversed(list(range(var_2))):\n if var_13[var_7][var_9 + 1] == var_7 - var_1[var_9][0]:\n var_14[var_9] = True\n var_7 = var_13[var_7][var_9 + 1]\nvar_12 = 0\nfor var_9 in range(var_2):\n if not var_14[var_9] and var_1[var_9][1] > var_12:\n var_12 = var_1[var_9][1]\nprint((var_5 + var_12))\n```\n\n=== Code B (Modified) ===\n```python\nvar_2, var_3, *var_1 = list(map(int, open(0).read().split()))\nvar_4 = [0] * (var_3 + max(var_1[::2]))\nfor var_7, var_6 in sorted(zip(*[iter(var_1)] * 2)):\n for var_5 in reversed(list(range(var_3))):\n var_4[var_5 + var_7] = max(var_4[var_5 + var_7], var_4[var_5] + var_6)\nprint((max(var_4)))\n```", "output": "FASTER 1.0715", "pair_id": "python_p02863_pair0069_forward", "problem_id": "p02863", "language": "python", "direction": "forward", "speedup_ratio": 2.1016} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nfrom sys import stdin\n\n\ndef func_1():\n\n var_13 = stdin.readline\n var_2 = int(var_13())\n var_1 = []\n for var_6 in range(var_2):\n var_5 = list(map(int, var_13().split()))\n var_1.append(var_5)\n var_3 = []\n for var_6 in range(var_2):\n var_12 = list(map(int, var_13().split()))\n var_3.append(var_12)\n var_9 = -float(\"inf\")\n for var_6 in range(1 << 10):\n if var_6 == 0:\n continue\n else:\n var_11 = []\n for var_7 in range(10):\n if (var_6 >> var_7) & 1:\n var_11.append(var_7)\n var_10 = [0] * 10\n for var_7 in var_11:\n var_10[var_7] = 1\n var_14 = 0\n for var_7 in range(var_2):\n var_4 = 0\n for var_8 in range(10):\n if var_10[var_8] == 1 and var_1[var_7][var_8] == 1:\n var_4 += 1\n var_14 += var_3[var_7][var_4]\n var_9 = max(var_14, var_9)\n print(var_9)\n\n\nif __name__ == \"__main__\":\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\nimport itertools\n\n\ndef func_2(var_4):\n return eval(\"0b\" + var_4)\n\n\ndef func_1():\n var_4 = int(sys.stdin.readline().rstrip())\n var_9 = [\n func_2(\"\".join(str(var_10) for var_10 in sys.stdin.readline().split()))\n for _ in range(var_4)\n ]\n var_8 = [\n [int(var_10) for var_10 in sys.stdin.readline().split()] for _ in range(var_4)\n ]\n var_3 = -(10**10)\n for var_6 in itertools.product(\"01\", repeat=10):\n var_6 = func_2(\"\".join(var_6))\n if var_6 == 0:\n continue\n var_7 = 0\n for var_2 in range(var_4):\n var_1 = var_9[var_2]\n var_5 = bin(var_1 & var_6).count(\"1\")\n var_7 += var_8[var_2][var_5]\n var_3 = max(var_3, var_7)\n print(var_3)\n\n\nif __name__ == \"__main__\":\n\n func_1()\n```", "output": "SLOWER 1.1909", "pair_id": "python_p03503_pair0044_reversed", "problem_id": "p03503", "language": "python", "direction": "reversed", "speedup_ratio": 2.2829} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nfrom collections import deque\n\n\ndef func_2(var_9, var_2, var_4):\n\n var_6 = {var_7: dict() for var_7 in range(var_9)}\n for var_7 in range(var_9 - 1):\n var_1, var_3 = var_2[var_7] - 1, var_4[var_7] - 1\n var_6[var_1][var_3] = -1\n var_6[var_3][var_1] = -1\n var_8 = max([len(var_6[var_1]) for var_1 in range(var_9)])\n var_14 = [-1] * var_9\n var_14[0] = var_8 - 1\n\n var_12 = deque([0])\n while len(var_12) > 0:\n var_10 = var_12.popleft()\n var_5 = var_14[var_10]\n for var_11 in list(var_6[var_10].keys()):\n if var_14[var_11] != -1:\n continue\n var_5 += 1\n var_5 %= var_8\n\n var_6[var_10][var_11] = var_5\n var_6[var_11][var_10] = var_5\n var_14[var_11] = var_5\n var_12.append(var_11)\n var_13 = [0] * (var_9 - 1)\n for var_7 in range(var_9 - 1):\n var_13[var_7] = var_6[var_2[var_7] - 1][var_4[var_7] - 1] + 1\n return var_8, var_13\n\n\ndef func_1():\n var_9 = int(eval(input()))\n var_2 = [0] * (var_9 - 1)\n var_4 = [0] * (var_9 - 1)\n for var_7 in range(var_9 - 1):\n var_1, var_3 = list(map(int, input().split()))\n var_2[var_7] = var_1\n var_4[var_7] = var_3\n var_8, var_13 = func_2(var_9, var_2, var_4)\n print(var_8)\n for var_7 in range(var_9 - 1):\n print((var_13[var_7]))\n\n\ndef func_3():\n print((func_2(3, [1, 2], [2, 3])))\n print((func_2(8, [1, 2, 2, 2, 4, 5, 6], [2, 3, 4, 5, 7, 6, 8])))\n\n\nif __name__ == \"__main__\":\n\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\nfrom collections import deque\n\nvar_13 = sys.stdin.readline\nvar_2 = int(eval(var_13()))\nvar_5 = [deque() for _ in range(var_2)]\nvar_3 = [-1] * var_2\nfor var_12 in range(var_2 - 1):\n var_6, var_8 = list(map(int, var_13().split()))\n var_5[var_6 - 1].append((var_12, var_8 - 1))\n\n\nvar_4 = deque([(0, -1)])\nvar_1 = [-1] * (var_2 - 1)\nvar_11 = 0\nwhile var_4:\n var_14, var_10 = var_4.pop()\n var_9 = 1\n for var_12, var_15 in var_5[var_14]:\n if var_9 == var_10:\n var_9 += 1\n var_1[var_12] = var_9\n var_4.appendleft((var_15, var_9))\n var_9 += 1\n var_11 = max(var_11, var_9 - 1)\nprint(var_11)\nfor var_7 in var_1:\n print(var_7)\n```", "output": "FASTER 1.0091", "pair_id": "python_p02850_pair0029_forward", "problem_id": "p02850", "language": "python", "direction": "forward", "speedup_ratio": 2.0126} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\ndef func_1():\n var_1, var_2 = list(map(int, input().rstrip().split()))\n var_3 = 0\n for var_4 in range(var_1, var_2 + 1):\n var_5 = str(var_4)\n if var_5 == var_5[::-1]:\n var_3 += 1\n print(var_3)\n\n\nif __name__ == \"__main__\":\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_7 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_3 = True\n var_8 = str(var_4)\n var_6 = len(var_8)\n for var_5 in range(var_6 // 2 + 1):\n if var_8[var_5] != var_8[-var_5 - 1]:\n var_3 = False\n break\n if var_3:\n var_7 += 1\nprint(var_7)\n```", "output": "SLOWER 1.8711", "pair_id": "python_p03416_pair0165_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 3.6581} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\ndef func_1():\n var_2 = int(input())\n var_1 = [int(var_6) for var_6 in input().split()]\n if var_2 == 1:\n return print(1 if var_1[0] % 2 == 0 else 2)\n var_3 = 0\n var_5 = (-1, 0, 1)\n from itertools import product\n\n for var_6 in product(range(3), repeat=var_2):\n var_4 = 1\n for var_7 in range(var_2):\n var_4 *= var_1[var_7] + var_5[var_6[var_7]]\n if var_4 % 2 == 0:\n var_3 += 1\n print(var_3)\n\n\nif __name__ == \"__main__\":\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\ndef func_1():\n var_2 = int(eval(input()))\n var_1 = [int(var_6) for var_6 in input().split()]\n var_4 = 3**var_2\n var_5 = len([var_3 for var_3 in var_1 if var_3 % 2 == 0])\n var_4 -= 2**var_5\n print(var_4)\n\n\nif __name__ == \"__main__\":\n func_1()\n```", "output": "FASTER 8.0497", "pair_id": "python_p03568_pair0034_forward", "problem_id": "p03568", "language": "python", "direction": "forward", "speedup_ratio": 264.9728} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\n\nvar_2, var_1, *var_3 = sys.stdin.read().strip().split()\nvar_2 = int(var_2)\nvar_5 = [0] * var_2\nvar_10 = [0] * var_2\nfor var_6, var_8 in zip(*[iter(var_3)] * 2):\n var_6 = int(var_6) - 1\n if var_8 == \"AC\":\n var_5[var_6] = 1\n elif var_5[var_6] == 0:\n var_10[var_6] += 1\nvar_7 = sum([var_9 * var_4 for var_4, var_9 in zip(var_5, var_10)])\nprint((\"{} {}\".format(sum(var_5), var_7)))\n```\n\n=== Code B (Modified) ===\n```python\nfrom sys import stdin\n\nvar_5 = stdin.readline\nvar_2, var_1 = list(map(int, var_5().split()))\nvar_3 = [False] * var_2\nvar_8 = [0] * var_2\nvar_9 = 0\nfor var_4 in range(var_1):\n var_6, var_7 = var_5().split()\n var_6 = int(var_6) - 1\n if var_3[var_6] is False and var_7 == \"AC\":\n var_9 += var_8[var_6]\n var_3[var_6] = True\n elif var_7 == \"WA\":\n var_8[var_6] += 1\nprint((var_3.count(True), var_9))\n```", "output": "FASTER 1.5188", "pair_id": "python_p02802_pair0011_forward", "problem_id": "p02802", "language": "python", "direction": "forward", "speedup_ratio": 2.8656} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nfrom sys import stdin\n\n\ndef func_1():\n\n var_9 = stdin.readline\n var_8, var_10 = list(map(int, var_9().split()))\n var_7 = [list(map(int, var_9().split())) for _ in range(var_8)]\n var_7.sort()\n var_1 = [0] * var_8\n var_2 = [0] * var_8\n for var_4 in range(var_8):\n var_1[var_4], var_2[var_4] = var_7[var_4][0], var_7[var_4][1]\n\n var_5 = -float(\"inf\")\n var_3 = [[var_5] * (var_10 + 1) for _ in range(var_8 + 1)]\n var_3[0][0] = 0\n for var_4 in range(var_8):\n for var_6 in range(var_10 + 1):\n\n if var_6 != var_10:\n var_3[var_4 + 1][min(var_10, var_6 + var_1[var_4])] = max(\n var_3[var_4 + 1][min(var_10, var_6 + var_1[var_4])],\n var_3[var_4][var_6] + var_2[var_4],\n )\n\n var_3[var_4 + 1][var_6] = max(var_3[var_4 + 1][var_6], var_3[var_4][var_6])\n print((max(var_3[var_8])))\n\n\nif __name__ == \"__main__\":\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\nfrom operator import itemgetter\nfrom heapq import heapify, heappop, heappush\n\nvar_1 = int(10e15)\nvar_2 = -var_1\nvar_11 = 1000000007\nsys.setrecursionlimit(1000000)\n\n\ndef func_2():\n return list(map(int, input().split()))\n\n\ndef func_4():\n return input().split()\n\n\ndef func_1():\n return int(sys.stdin.readline())\n\n\ndef func_3():\n return eval(input())\n\n\nvar_3, var_4 = func_2()\nvar_5 = [func_2() for var_9 in range(var_3)]\nvar_5.sort(key=itemgetter(0))\n\nvar_8 = [[0] * (var_4 + 1 + 3000 + 1) for _ in range(var_3 + 1)]\nvar_6 = 0\nfor var_9 in range(var_3):\n for var_10 in range(var_4 + 1 + 3000 + 1):\n var_12, var_7 = var_5[var_9]\n if 0 <= var_10 - var_12 < var_4:\n var_8[var_9 + 1][var_10] = max(\n var_8[var_9][var_10], var_8[var_9][var_10 - var_12] + var_7\n )\n else:\n var_8[var_9 + 1][var_10] = var_8[var_9][var_10]\n var_6 = max(var_6, var_8[var_9 + 1][var_10])\nprint(var_6)\n```", "output": "SLOWER 4.8948", "pair_id": "python_p02863_pair0068_reversed", "problem_id": "p02863", "language": "python", "direction": "reversed", "speedup_ratio": 29.7492} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\nimport itertools\n\n\ndef func_2(var_4):\n return bin(eval(\"0b\" + str(var_4)))\n\n\ndef func_1():\n var_4 = int(sys.stdin.readline().rstrip())\n var_9 = [\n func_2(\"\".join(str(var_10) for var_10 in sys.stdin.readline().split()))\n for _ in range(var_4)\n ]\n var_8 = [\n [int(var_10) for var_10 in sys.stdin.readline().split()] for _ in range(var_4)\n ]\n var_3 = -(10**10)\n for var_6 in itertools.product(\"01\", repeat=10):\n var_6 = func_2(\"\".join(var_6))\n if var_6 == \"0b0\":\n continue\n var_7 = 0\n for var_2 in range(var_4):\n var_1 = var_9[var_2]\n var_5 = bin(eval(var_1) & eval(var_6)).count(\"1\")\n var_7 += var_8[var_2][var_5]\n var_3 = max(var_3, var_7)\n print(var_3)\n\n\nif __name__ == \"__main__\":\n\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\n\nvar_7 = sys.stdin.readline\nfrom itertools import combinations\n\n\ndef func_3(var_10):\n for _ in range(var_10):\n yield list(map(int, var_7().split()))\n\n\ndef func_1(var_9, var_5, var_11):\n var_3 = len([0 for var_8 in var_9 if var_5[var_8] == 1])\n return var_11[var_3]\n\n\ndef func_2():\n var_10 = int(eval(var_7()))\n var_1 = list(func_3(var_10))\n var_2 = list(func_3(var_10))\n for var_6 in range(1, 11):\n for var_4 in combinations(list(range(10)), var_6):\n yield sum(\n func_1(var_4, var_5, var_11) for var_5, var_11 in zip(var_1, var_2)\n )\n\n\nprint((max(func_2())))\n```", "output": "FASTER 4.1946", "pair_id": "python_p03503_pair0021_forward", "problem_id": "p03503", "language": "python", "direction": "forward", "speedup_ratio": 18.3107} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_6 = int(eval(input()))\nvar_2 = list(map(int, input().split()))\nfrom itertools import product\n\nvar_5 = [-1, 0, 1]\nvar_3 = 0\nfor var_7 in product(var_5, repeat=var_6):\n var_1 = []\n for var_4 in range(var_6):\n var_1.append(var_7[var_4] + var_2[var_4])\n if any(var_8 % 2 == 0 for var_8 in var_1):\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nimport math\nimport string\n\n\ndef func_4():\n return list(map(int, input().split()))\n\n\ndef func_3(var_6, var_7):\n return math.factorial(var_6) // (\n math.factorial(var_6 - var_7) * math.factorial(var_7)\n )\n\n\ndef func_2(var_9):\n var_8 = []\n for var_5 in var_9:\n if not (var_5 in var_8):\n var_8.append(var_5)\n return len(var_9) != len(var_8)\n\n\ndef func_1(var_6):\n func_1 = []\n for var_4 in range(1, var_6 + 1):\n if var_6 % var_4 == 0:\n func_1.append(var_4)\n return func_1\n\n\nvar_2 = [-1, -1, -1, 0, 0, 1, 1, 1]\nvar_3 = [-1, 0, 1, -1, 1, -1, 0, 1]\nvar_6 = int(eval(input()))\nvar_1 = func_4()\nvar_10 = 1\nfor var_4 in range(len(var_1)):\n if var_1[var_4] % 2 == 0:\n var_10 *= 2\n else:\n var_10 *= 1\nprint((3 ** len(var_1) - var_10))\n```", "output": "FASTER 8.1431", "pair_id": "python_p03568_pair0010_forward", "problem_id": "p03568", "language": "python", "direction": "forward", "speedup_ratio": 282.6949} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport bisect\nimport sys\n\nsys.setrecursionlimit(10**6)\nvar_16 = sys.stdout.write\nvar_7 = lambda *var_14: print(*var_14) if var_1 else 0\nvar_1 = True\n\n\ndef func_1(var_9=sys.stdin.readline):\n var_11 = lambda: var_9().rstrip()\n var_3 = lambda: list(map(int, var_11().split()))\n var_2 = lambda: int(var_11())\n var_4 = lambda var_17: [var_3() for _ in range(var_17)]\n var_13, var_15 = var_3()\n var_5 = var_4(var_13)\n var_5.sort()\n var_8 = [[0] * var_15 for _ in range(var_13 + 1)]\n for var_10 in range(1, var_13 + 1):\n for var_12 in range(1, var_15):\n if var_12 < var_5[var_10 - 1][0]:\n var_8[var_10][var_12] = var_8[var_10 - 1][var_12]\n else:\n var_8[var_10][var_12] = max(\n var_8[var_10 - 1][var_12],\n var_8[var_10 - 1][var_12 - var_5[var_10 - 1][0]]\n + var_5[var_10 - 1][1],\n )\n var_6 = 0\n for var_10 in range(var_13):\n var_6 = max(var_6, var_8[var_10][var_15 - 1] + var_5[var_10][1])\n print(var_6)\n\n\nif __name__ == \"__main__\":\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nfrom collections import Counter, defaultdict, deque\nfrom heapq import heappop, heappush, heapify\nimport sys, bisect, math, itertools, fractions, pprint\n\nsys.setrecursionlimit(10**8)\nvar_6 = 10**9 + 7\nvar_1 = float(\"inf\")\n\n\ndef func_1():\n return int(sys.stdin.readline())\n\n\ndef func_2():\n return list(map(int, sys.stdin.readline().split()))\n\n\nvar_8, var_11 = func_2()\nvar_17 = [func_2() for _ in range(var_8)]\nvar_10 = var_17[::-1]\nvar_14 = [[0] * var_11 for _ in range(var_8)]\nvar_3 = [[0] * var_11 for _ in range(var_8)]\nfor var_4 in range(var_8 - 1):\n var_16, var_15 = var_17[var_4]\n for var_5 in range(var_11):\n if var_5 < var_16:\n var_14[var_4 + 1][var_5] = var_14[var_4][var_5]\n else:\n var_14[var_4 + 1][var_5] = max(\n var_14[var_4][var_5], var_14[var_4][var_5 - var_16] + var_15\n )\nvar_9 = var_14[var_8 - 1][var_11 - 1] + var_17[var_8 - 1][1]\nfor var_4 in range(var_8 - 1):\n var_16, var_15 = var_10[var_4]\n for var_5 in range(var_11):\n if var_5 < var_16:\n var_3[var_4 + 1][var_5] = var_3[var_4][var_5]\n else:\n var_3[var_4 + 1][var_5] = max(\n var_3[var_4][var_5], var_3[var_4][var_5 - var_16] + var_15\n )\n var_9 = max(var_9, var_3[var_8 - 1][var_11 - 1] + var_17[0][1])\n\nfor var_4 in range(1, var_8 - 1):\n var_13 = var_4\n var_2 = var_8 - var_4 - 1\n var_7 = 0\n for var_5 in range(var_11):\n var_12 = var_14[var_13][var_5] + var_3[var_2][var_11 - 1 - var_5]\n var_7 = max(var_7, var_12)\n var_9 = max(var_9, var_7 + var_17[var_4][1])\nprint(var_9)\n```", "output": "SLOWER 1.4049", "pair_id": "python_p02863_pair0063_reversed", "problem_id": "p02863", "language": "python", "direction": "reversed", "speedup_ratio": 2.648} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_3 = list(map(int, input().split()))\nvar_2 = 0\nfor var_5 in range(var_3 + 1)[var_1:]:\n if len(str(var_5)) % 2 == 0:\n var_6 = list(str(var_5))[: len(str(var_5)) // 2]\n var_7 = list(reversed(list(str(var_5))[len(str(var_5)) // 2 :]))\n if var_6 == var_7:\n var_2 += 1\n else:\n var_8 = list(str(var_5))[: len(str(var_5)) // 2 + 1]\n var_4 = list(reversed(list(str(var_5))[len(str(var_5)) // 2 :]))\n if var_8 == var_4:\n var_2 += 1\nprint(var_2)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().strip().split(\" \")))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n if str(var_4) == str(var_4)[::-1]:\n var_3 += 1\nprint(var_3)\n```", "output": "FASTER 2.1673", "pair_id": "python_p03416_pair0238_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 4.4917} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport copy\n\nvar_8 = int(eval(input()))\nvar_10 = set([var_6 for var_6 in range(1, 10**5)])\nvar_5 = []\nvar_11 = {}\nvar_9 = []\nfor var_6 in range(var_8 - 1):\n var_1, var_2 = list(map(int, input().split(\" \")))\n var_5.append([var_1, var_2])\n var_11.setdefault(var_1, []).append(var_2)\n var_9.append([])\nvar_9.append([])\nvar_9.append([])\nvar_7 = 0\nfor var_12 in range(1, var_8 + 1):\n var_14 = var_11.get(var_12, [])\n var_3 = 1\n for var_13 in var_14:\n if var_3 in var_9[var_12]:\n var_3 += 1\n else:\n pass\n var_9[var_13].append(var_3)\n if var_3 >= var_7:\n var_7 = var_3\n var_3 += 1\nprint(var_7)\nfor var_4 in var_5:\n print((var_9[var_4[1]][0]))\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\nfrom collections import deque\n\nvar_13 = sys.stdin.readline\nvar_2 = int(eval(var_13()))\nvar_5 = [deque() for _ in range(var_2)]\nvar_3 = [-1] * var_2\nfor var_12 in range(var_2 - 1):\n var_6, var_8 = list(map(int, var_13().split()))\n var_5[var_6 - 1].append((var_12, var_8 - 1))\n\n\nvar_4 = deque([(0, -1)])\nvar_1 = [-1] * (var_2 - 1)\nvar_11 = 0\nwhile var_4:\n var_14, var_10 = var_4.pop()\n var_9 = 1\n for var_12, var_15 in var_5[var_14]:\n if var_9 == var_10:\n var_9 += 1\n var_1[var_12] = var_9\n var_4.appendleft((var_15, var_9))\n var_9 += 1\n var_11 = max(var_11, var_9 - 1)\nprint(var_11)\nfor var_7 in var_1:\n print(var_7)\n```", "output": "FASTER 4.6519", "pair_id": "python_p02850_pair0033_forward", "problem_id": "p02850", "language": "python", "direction": "forward", "speedup_ratio": 25.1403} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\ndef func_1():\n var_1, var_2 = list(map(int, input().split()))\n var_3 = 0\n for var_4 in range(var_1, var_2 + 1):\n\n if (var_4 % 10) == (var_4 // 10000 % 10) and (var_4 // 10 % 10) == (\n var_4 // 1000 % 10\n ):\n var_3 += 1\n print(var_3)\n\n\nif __name__ == \"__main__\":\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_6 = str(var_4)\n var_5 = var_6[::-1]\n if var_6 == var_5:\n var_3 += 1\nprint(var_3)\n```", "output": "SLOWER 1.9144", "pair_id": "python_p03416_pair0025_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 3.7697} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_8 in range(var_1, var_2 + 1):\n var_7 = str(var_8)\n var_6 = len(var_7)\n var_4 = True\n for var_5 in range(var_6 // 2):\n if var_7[var_5] != var_7[var_6 - 1 - var_5]:\n var_4 = False\n break\n if var_4:\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = str(var_4)\n if var_5[0] == var_5[4] and var_5[1] == var_5[3]:\n var_3 += 1\nprint(var_3)\n```", "output": "FASTER 1.3924", "pair_id": "python_p03416_pair0184_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 2.6251} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport numpy as np\nfrom bisect import bisect_left\n\n\ndef func_1():\n var_4 = []\n var_1 = np.ones(10**5 + 10)\n var_1[0] = var_1[1] = 0\n for var_3, var_2 in enumerate(var_1):\n if var_2:\n var_4.append(var_3)\n var_1[2 * var_3 : 10**5 + 10 : var_3] = 0\n return var_4\n\n\ndef func_2(var_6):\n var_7 = int(var_6)\n var_5 = func_1()\n return str(var_5[bisect_left(var_5, var_7)])\n\n\nif __name__ == \"__main__\":\n import sys\n\n print((func_2(sys.stdin.read().strip())))\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\n\n\ndef func_1():\n return sys.stdin.readline()[:-1]\n\n\nvar_3 = int(eval(func_1()))\nwhile 1:\n var_1 = 0\n for var_2 in range(2, int(var_3 ** (1 / 2))):\n if var_3 % var_2 == 0:\n var_1 = 1\n break\n if var_1 == 0:\n break\n var_3 += 1\nprint(var_3)\n```", "output": "FASTER 7.7323", "pair_id": "python_p02819_pair0008_forward", "problem_id": "p02819", "language": "python", "direction": "forward", "speedup_ratio": 212.6457} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_6, var_5 = list(map(int, input().split()))\nvar_8 = [[] for _ in range(var_6)]\nfor var_2 in range(var_5):\n var_10, var_11 = input().split()\n var_8[int(var_10) - 1].append(var_11)\n\nvar_1, var_7 = 0, 0\nfor var_3 in range(var_6):\n var_9 = var_8[var_3]\n if \"AC\" in var_9:\n var_1 += 1\n for var_4 in var_9:\n if var_4 == \"WA\":\n var_7 += 1\n else:\n break\nprint((var_1, var_7))\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\n\nvar_2, var_1, *var_3 = sys.stdin.read().strip().split()\nvar_2 = int(var_2)\nvar_5 = [0] * var_2\nvar_10 = [0] * var_2\nfor var_6, var_8 in zip(*[iter(var_3)] * 2):\n var_6 = int(var_6) - 1\n if var_8 == \"AC\":\n var_5[var_6] = 1\n elif var_5[var_6] == 0:\n var_10[var_6] += 1\nvar_7 = sum([var_9 * var_4 for var_4, var_9 in zip(var_5, var_10)])\nprint((\"{} {}\".format(sum(var_5), var_7)))\n```", "output": "FASTER 1.7771", "pair_id": "python_p02802_pair0010_forward", "problem_id": "p02802", "language": "python", "direction": "forward", "speedup_ratio": 3.4274} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_4 = str(var_4)\n if var_4 == var_4[::-1]:\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\n\n\ndef func_1(var_5):\n var_4 = 0\n for var_3 in range(1, var_5 + 1):\n if str(var_3) == str(var_3)[::-1]:\n var_4 += 1\n return var_4\n\n\nprint((func_1(var_2) - func_1(var_1 - 1)))\n```", "output": "SLOWER 1.4436", "pair_id": "python_p03416_pair0181_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 2.72} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\nfrom collections import Counter\n\n\ndef func_9():\n return sys.stdin.readline().strip()\n\n\ndef func_10(var_8, var_9, var_10):\n return [[var_10] * var_9 for var_13 in range(var_8)]\n\n\ndef func_11(var_8, var_9, var_10, var_11):\n return [[[var_11] * var_10 for var_14 in range(var_9)] for var_13 in range(var_8)]\n\n\ndef func_12(var_8, var_9, var_10, var_11, var_12):\n return [\n [[[var_12] * var_11 for var_14 in range(var_10)] for var_14 in range(var_9)]\n for var_13 in range(var_8)\n ]\n\n\ndef func_8(var_16, var_17=1):\n return int(-(-var_16 // var_17))\n\n\ndef func_1():\n return int(eval(func_9()))\n\n\ndef func_3():\n return list(map(int, func_9().split()))\n\n\ndef func_2(var_7=None):\n return list(func_3()) if var_7 is None else [func_1() for var_13 in range(var_7)]\n\n\ndef func_7():\n print(\"Yes\")\n\n\ndef func_5():\n print(\"No\")\n\n\ndef func_6():\n print(\"YES\")\n\n\ndef func_4():\n print(\"NO\")\n\n\nsys.setrecursionlimit(10**9)\nvar_3 = 10**18\nvar_6 = 10**9 + 7\nvar_7, var_5, var_4 = func_3()\nvar_1 = func_2()\nvar_2 = func_2()\nvar_15 = min(var_1) + min(var_2)\nfor _ in range(var_4):\n var_16, var_17, var_10 = func_3()\n var_16 -= 1\n var_17 -= 1\n var_15 = min(var_15, var_1[var_16] + var_2[var_17] - var_10)\nprint(var_15)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2, var_3 = list(map(int, input().split()))\nvar_4 = list(map(int, input().split()))\nvar_6 = list(map(int, input().split()))\nvar_5 = min(var_4) + min(var_6)\nfor var_8 in range(var_3):\n var_7 = list(map(int, input().split()))\n var_9 = var_4[var_7[0] - 1] + var_6[var_7[1] - 1] - var_7[2]\n var_5 = min(var_9, var_5)\nprint(var_5)\n```", "output": "FASTER 1.7949", "pair_id": "python_p02748_pair0013_forward", "problem_id": "p02748", "language": "python", "direction": "forward", "speedup_ratio": 3.47} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\nimport itertools\n\n\ndef func_2(var_4):\n return bin(eval(\"0b\" + str(var_4)))\n\n\ndef func_1():\n var_4 = int(sys.stdin.readline().rstrip())\n var_9 = [\n func_2(\"\".join(str(var_10) for var_10 in sys.stdin.readline().split()))\n for _ in range(var_4)\n ]\n var_8 = [\n [int(var_10) for var_10 in sys.stdin.readline().split()] for _ in range(var_4)\n ]\n var_3 = -(10**10)\n for var_6 in itertools.product(\"01\", repeat=10):\n var_6 = func_2(\"\".join(var_6))\n if var_6 == \"0b0\":\n continue\n var_7 = 0\n for var_2 in range(var_4):\n var_1 = var_9[var_2]\n var_5 = bin(eval(var_1) & eval(var_6)).count(\"1\")\n var_7 += var_8[var_2][var_5]\n var_3 = max(var_3, var_7)\n print(var_3)\n\n\nif __name__ == \"__main__\":\n\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\nimport numpy as np\n\nvar_5 = sys.stdin.readline\n\nvar_7 = int(eval(var_5()))\n\nvar_1 = [var_5().replace(\" \", \"\") for var_4 in range(var_7)]\n\nvar_8 = [list(map(int, var_5().split())) for var_4 in range(var_7)]\n\n\nvar_12 = -999999999999999\n\nfor var_4 in range(1, 1024):\n\n var_3 = format(var_4, \"010b\")\n\n var_10 = 0\n for var_2, var_9 in zip(var_1, var_8):\n\n var_11 = 0\n for var_6 in range(10):\n\n if var_2[var_6] == \"1\" and var_3[var_6] == \"1\":\n\n var_11 += 1\n\n var_10 += var_9[var_11]\n if var_10 > var_12:\n\n var_12 = var_10\nprint(var_12)\n```", "output": "FASTER 2.5695", "pair_id": "python_p03503_pair0020_forward", "problem_id": "p03503", "language": "python", "direction": "forward", "speedup_ratio": 5.9361} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport copy\n\nvar_8 = int(eval(input()))\nvar_10 = set([var_6 for var_6 in range(1, 10**5)])\nvar_5 = []\nvar_11 = {}\nvar_9 = []\nfor var_6 in range(var_8 - 1):\n var_1, var_2 = list(map(int, input().split(\" \")))\n var_5.append([var_1, var_2])\n var_11.setdefault(var_1, []).append(var_2)\n var_9.append([])\nvar_9.append([])\nvar_9.append([])\nvar_7 = 0\nfor var_12 in range(1, var_8 + 1):\n var_14 = var_11.get(var_12, [])\n var_3 = 1\n for var_13 in var_14:\n if var_3 in var_9[var_12]:\n var_3 += 1\n else:\n pass\n var_9[var_13].append(var_3)\n if var_3 >= var_7:\n var_7 = var_3\n var_3 += 1\nprint(var_7)\nfor var_4 in var_5:\n print((var_9[var_4[1]][0]))\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\nfrom collections import deque\n\nvar_13 = sys.stdin.readline\nvar_2 = int(eval(var_13()))\nvar_5 = [[] for _ in range(var_2)]\nvar_3 = [-1] * var_2\nfor var_12 in range(var_2 - 1):\n var_6, var_8 = list(map(int, var_13().split()))\n var_5[var_6 - 1].append((var_12, var_8 - 1))\n\n\nvar_4 = deque([(0, -1)])\nvar_1 = [-1] * (var_2 - 1)\nvar_11 = 0\nwhile var_4:\n var_14, var_10 = var_4.pop()\n var_9 = 1\n for var_12, var_15 in var_5[var_14]:\n if var_9 == var_10:\n var_9 += 1\n var_1[var_12] = var_9\n var_4.appendleft((var_15, var_9))\n var_9 += 1\n var_11 = max(var_11, var_9 - 1)\nprint(var_11)\nfor var_7 in var_1:\n print(var_7)\n```", "output": "FASTER 4.6753", "pair_id": "python_p02850_pair0005_forward", "problem_id": "p02850", "language": "python", "direction": "forward", "speedup_ratio": 25.551} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\n\nsys.setrecursionlimit(2147483647)\nvar_2 = float(\"inf\")\nvar_3 = 10**9 + 7\nvar_10 = lambda: sys.stdin.readline().rstrip()\n\n\ndef func_1():\n var_11, var_4 = list(map(int, var_10().split()))\n var_1 = [tuple(map(int, var_10().split())) for _ in range(var_11)]\n var_1.sort()\n var_8 = [0] * var_4\n var_6 = -var_2\n for var_9 in range(var_11):\n var_5, var_7 = var_1[var_9]\n var_12 = var_8[:]\n for var_13 in range(var_4):\n if var_13 + var_5 < var_4:\n var_12[var_13 + var_5] = max(\n var_12[var_13 + var_5], var_8[var_13] + var_7\n )\n else:\n var_6 = max(var_6, var_8[var_13] + var_7)\n var_8 = var_12\n print((max(var_6, max(var_8))))\n\n\nfunc_1()\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\nfrom operator import itemgetter\nfrom heapq import heapify, heappop, heappush\n\nvar_1 = int(10e15)\nvar_2 = -var_1\nvar_11 = 1000000007\nsys.setrecursionlimit(1000000)\n\n\ndef func_2():\n return list(map(int, input().split()))\n\n\ndef func_4():\n return input().split()\n\n\ndef func_1():\n return int(sys.stdin.readline())\n\n\ndef func_3():\n return eval(input())\n\n\nvar_3, var_4 = func_2()\nvar_5 = [func_2() for var_9 in range(var_3)]\nvar_5.sort(key=itemgetter(0))\n\nvar_8 = [[0] * (var_4 + 1 + 3000 + 1) for _ in range(var_3 + 1)]\nvar_6 = 0\nfor var_9 in range(var_3):\n for var_10 in range(var_4 + 1 + 3000 + 1):\n var_12, var_7 = var_5[var_9]\n if 0 <= var_10 - var_12 < var_4:\n var_8[var_9 + 1][var_10] = max(\n var_8[var_9][var_10], var_8[var_9][var_10 - var_12] + var_7\n )\n else:\n var_8[var_9 + 1][var_10] = var_8[var_9][var_10]\n var_6 = max(var_6, var_8[var_9 + 1][var_10])\nprint(var_6)\n```", "output": "SLOWER 5.855", "pair_id": "python_p02863_pair0033_reversed", "problem_id": "p02863", "language": "python", "direction": "reversed", "speedup_ratio": 57.8788} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_5 in range(10):\n for var_6 in range(10):\n for var_7 in range(10):\n var_3 = 10000 * var_5 + 1000 * var_6 + 100 * var_7 + 10 * var_6 + var_5\n if var_1 <= var_3 <= var_2:\n var_4 += 1\nprint(var_4)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().strip().split(\" \")))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n if str(var_4) == str(var_4)[::-1]:\n var_3 += 1\nprint(var_3)\n```", "output": "SLOWER 4.1328", "pair_id": "python_p03416_pair0040_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 17.5431} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_4 = {}\nvar_5 = 0\nfor var_6 in range(10000, 100000):\n var_3 = list(str(var_6))\n if var_3 == list(reversed(var_3)):\n var_5 += 1\n var_4[var_6] = var_5\nvar_1, var_2 = list(map(int, input().split()))\nprint((var_4[var_2] - var_4[var_1 - 1] if var_1 > 10000 else var_4[var_2]))\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_5 in range(10):\n for var_6 in range(10):\n for var_7 in range(10):\n var_3 = 10000 * var_5 + 1000 * var_6 + 100 * var_7 + 10 * var_6 + var_5\n if var_1 <= var_3 <= var_2:\n var_4 += 1\nprint(var_4)\n```", "output": "FASTER 7.3992", "pair_id": "python_p03416_pair0222_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 168.7989} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\n\n\ndef func_1():\n return sys.stdin.readline()[:-1]\n\n\nvar_3 = int(eval(func_1()))\nwhile 1:\n var_1 = 0\n for var_2 in range(2, int(var_3 ** (1 / 2))):\n if var_3 % var_2 == 0:\n var_1 = 1\n break\n if var_1 == 0:\n break\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nimport bisect, copy, heapq, math, sys\nfrom collections import *\nfrom functools import lru_cache\nfrom itertools import accumulate, combinations, permutations, product\n\n\ndef func_2():\n return sys.stdin.readline()[:-1]\n\n\ndef func_4(var_8):\n return [0] + list(accumulate(var_8))\n\n\ndef func_1(var_1, var_4):\n return -(-var_1 // var_4)\n\n\nsys.setrecursionlimit(5000000)\nvar_9 = pow(10, 9) + 7\nvar_2 = [chr(ord(\"a\") + var_6) for var_6 in range(26)]\nvar_5 = [[1, 0], [0, 1], [-1, 0], [0, -1]]\nvar_11 = int(eval(func_2()))\n\n\ndef func_3(var_10):\n if var_10 == 1:\n return False\n for var_7 in range(2, int(math.sqrt(var_10)) + 1):\n if var_10 % var_7 == 0:\n return False\n return True\n\n\nvar_3 = var_11\nwhile not func_3(var_3):\n var_3 += 1\nprint(var_3)\n```", "output": "SLOWER 1.4121", "pair_id": "python_p02819_pair0004_reversed", "problem_id": "p02819", "language": "python", "direction": "reversed", "speedup_ratio": 2.6613} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_5 in range(10):\n for var_6 in range(10):\n for var_7 in range(10):\n var_3 = 10000 * var_5 + 1000 * var_6 + 100 * var_7 + 10 * var_6 + var_5\n if var_1 <= var_3 <= var_2:\n var_4 += 1\nprint(var_4)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_6 in range(var_1, var_2 + 1):\n var_3 = str(var_6)\n var_5 = True\n for var_7 in range(len(var_3) // 2):\n if var_3[var_7] != var_3[-var_7 - 1] and var_5:\n var_5 = not var_5\n if var_5:\n var_4 += 1\nprint(var_4)\n```", "output": "SLOWER 5.2855", "pair_id": "python_p03416_pair0216_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 39.0027} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\n\n\ndef func_1(var_5):\n var_4 = 0\n for var_3 in range(1, var_5 + 1):\n if str(var_3) == str(var_3)[::-1]:\n var_4 += 1\n return var_4\n\n\nprint((func_1(var_2) - func_1(var_1 - 1)))\n```\n\n=== Code B (Modified) ===\n```python\nvar_1 = list(map(int, input().split()))\nvar_2 = 0\nfor var_3 in range(var_1[0], var_1[1] + 1):\n var_4 = str(var_3)\n if var_4[0] == var_4[4] and var_4[1] == var_4[3]:\n var_2 += 1\nprint(var_2)\n```", "output": "FASTER 1.8794", "pair_id": "python_p03416_pair0249_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 3.6793} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = [0] * (var_2 + 1)\nfor var_3 in range(1, var_2 + 1):\n if str(var_3) == str(var_3)[::-1]:\n var_4[var_3] = var_4[var_3 - 1] + 1\n else:\n var_4[var_3] = var_4[var_3 - 1]\nprint((var_4[var_2] - var_4[var_1 - 1]))\n```\n\n=== Code B (Modified) ===\n```python\nvar_4 = {}\nvar_5 = 0\nfor var_6 in range(10000, 100000):\n var_3 = list(str(var_6))\n if var_3 == list(reversed(var_3)):\n var_5 += 1\n var_4[var_6] = var_5\nvar_1, var_2 = list(map(int, input().split()))\nprint((var_4[var_2] - var_4[var_1 - 1] if var_1 > 10000 else var_4[var_2]))\n```", "output": "SLOWER 1.6313", "pair_id": "python_p03416_pair0167_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 3.098} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\n\n\ndef func_1(var_5):\n var_4 = 0\n for var_3 in range(1, var_5 + 1):\n if str(var_3) == str(var_3)[::-1]:\n var_4 += 1\n return var_4\n\n\nprint((func_1(var_2) - func_1(var_1 - 1)))\n```\n\n=== Code B (Modified) ===\n```python\nvar_4 = {}\nvar_5 = 0\nfor var_6 in range(10000, 100000):\n var_3 = list(str(var_6))\n if var_3 == list(reversed(var_3)):\n var_5 += 1\n var_4[var_6] = var_5\nvar_1, var_2 = list(map(int, input().split()))\nprint((var_4[var_2] - var_4[var_1 - 1] if var_1 > 10000 else var_4[var_2]))\n```", "output": "SLOWER 1.983", "pair_id": "python_p03416_pair0244_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 3.9531} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\ndef func_1():\n from sys import setrecursionlimit, stdin\n from os import environ\n from collections import defaultdict, deque, Counter\n from math import ceil, floor, gcd\n from itertools import accumulate, combinations, combinations_with_replacement\n\n setrecursionlimit(10**6)\n var_7 = (\n (lambda *var_11: print(*var_11))\n if \"TERM_PROGRAM\" in environ\n else lambda *var_12: 0\n )\n var_8 = lambda: stdin.readline().rstrip()\n var_3 = lambda: list(map(int, var_8().split()))\n var_1 = lambda: int(var_8())\n var_4 = 10**9 + 7\n var_2 = 10**9 + 10\n var_9, var_10 = var_8().split()\n var_5 = int(var_9)\n var_10 = var_10.split(\".\")\n var_6 = int(var_10[0]) * 100\n if len(var_10) == 2:\n var_6 += int(var_10[1])\n print(var_5 * var_6 // 100)\n\n\nfunc_1()\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(str, input().split()))\nvar_1 = int(var_1)\nvar_2 = int(float(var_2) * 1000)\nprint((var_1 * var_2 // 1000))\n```", "output": "FASTER 2.1723", "pair_id": "python_p02659_pair0033_forward", "problem_id": "p02659", "language": "python", "direction": "forward", "speedup_ratio": 4.5074} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_7, var_6 = list(map(int, input().split()))\nvar_5 = [tuple(input().split()) for _ in range(var_6)]\nvar_9 = [[] for _ in range(var_7)]\nfor var_2 in range(var_6):\n var_9[int(var_5[var_2][0]) - 1].append(var_5[var_2][1])\nvar_1, var_8 = 0, 0\nfor var_3 in range(var_7):\n if \"AC\" in var_9[var_3]:\n var_1 += 1\n for var_4 in range(len(var_9[var_3])):\n if var_9[var_3][var_4] == \"WA\":\n var_8 += 1\n else:\n break\nprint((var_1, var_8))\n```\n\n=== Code B (Modified) ===\n```python\nvar_2, var_1 = list(map(int, input().split()))\nvar_6 = {}\nvar_3 = {}\nfor var_4 in range(var_1):\n var_5, var_7 = input().split()\n var_5 = int(var_5)\n if not var_5 in var_6:\n var_6[var_5] = 0\n var_3[var_5] = 0\n if var_7 == \"WA\" and var_3[var_5] == 0:\n var_6[var_5] += 1\n elif var_7 == \"AC\" and var_3[var_5] == 0:\n var_3[var_5] += 1\nfor var_4 in var_6:\n if var_6[var_4] != 0 and var_3[var_4] == 0:\n var_6[var_4] = 0\nprint((sum(var_3.values()), sum(var_6.values())))\n```", "output": "FASTER 4.1714", "pair_id": "python_p02802_pair0002_forward", "problem_id": "p02802", "language": "python", "direction": "forward", "speedup_ratio": 18.0189} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\n\n\nclass Class_1:\n \"\"\"\"\"\"\n\n def __init__(self, var_1):\n self.__n = len(var_1)\n self.__node = [0] * (self.__n + 1)\n self.__data = [0] * (self.__n + 1)\n var_7 = [0] * (self.__n + 1)\n for var_11 in range(self.__n):\n var_7[var_11 + 1] = var_7[var_11] + var_1[var_11]\n for var_11 in range(1, self.__n + 1):\n self.__data[var_11] = var_1[var_11 - 1]\n self.__node[var_11] = var_7[var_11] - var_7[var_11 - (var_11 & -var_11)]\n\n def func_1(self, var_11, var_22):\n self.__data[var_11] += var_22\n while var_11 <= self.__n:\n self.__node[var_11] += var_22\n var_11 += var_11 & -var_11\n\n def func_4(self, var_11):\n \"\"\"\"\"\"\n var_19 = 0\n while var_11 > 0:\n var_19 += self.__node[var_11]\n var_11 -= var_11 & -var_11\n return var_19\n\n def func_2(self, var_11, var_12):\n \"\"\"\"\"\"\n if var_11 == var_12:\n return self.__data[var_11]\n else:\n return self.sum(var_12) - self.sum(var_11 - 1)\n\n\ndef func_3():\n var_4, var_6 = map(int, input().split())\n var_3 = list(map(int, input().split()))\n var_5 = [[] for _ in range(var_4)]\n for var_11, var_9 in enumerate(var_3):\n var_5[var_9 - 1].append(var_11)\n var_18 = [0] * var_4\n for var_14 in var_5:\n if len(var_14):\n var_18[var_14.pop()] = 1\n var_2 = Class_1(var_18)\n var_16 = [[] for _ in range(var_4)]\n for var_11, var_20 in enumerate(sys.stdin.readlines()):\n var_13, var_17 = map(int, var_20.split())\n var_16[var_17 - 1].append((var_13 - 1, var_11))\n var_8 = [None] * var_6\n var_10 = var_4 - 1\n for var_17, var_15 in enumerate(reversed(var_16)):\n var_17 = (var_4 - 1) - var_17\n while var_15:\n var_13, var_11 = var_15.pop()\n while var_17 < var_10:\n var_9 = var_3[var_10] - 1\n var_14 = var_5[var_9]\n if len(var_14):\n var_2.add(var_14.pop() + 1, 1)\n var_10 -= 1\n var_21 = var_2.get(var_13 + 1, var_17 + 1)\n var_8[var_11] = var_21\n print(*var_8, sep=\"\\n\")\n\n\nif __name__ == \"__main__\":\n func_3()\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\n\nvar_20 = sys.stdin.read\nvar_21 = sys.stdin.readline\nvar_22 = sys.stdin.readlines\nsys.setrecursionlimit(10**9)\nvar_2 = 1 << 60\nvar_5 = 1000000007\n\n\nvar_4 = 1000001\n\n\nclass Class_1:\n def __init__(self, var_13, var_19, var_12):\n self.l = var_13\n self.r = var_19\n self.idx = var_12\n\n\ndef func_4(var_12, var_24, var_10, var_15):\n while var_12 <= var_15:\n var_10[var_12] += var_24\n var_12 += var_12 & -var_12\n\n\ndef func_3(var_12, var_10, var_15):\n var_23 = 0\n while var_12:\n var_23 += var_10[var_12]\n var_12 -= var_12 & -var_12\n return var_23\n\n\ndef func_1(var_9, var_15, var_17, var_16):\n\n var_10 = [0] * (var_15 + 1)\n\n var_14 = [-1] * var_4\n\n var_8 = [0] * var_16\n var_18 = 0\n for var_11 in range(var_15):\n\n if var_14[var_9[var_11]] != -1:\n func_4(var_14[var_9[var_11]] + 1, -1, var_10, var_15)\n\n var_14[var_9[var_11]] = var_11\n func_4(var_11 + 1, 1, var_10, var_15)\n\n while var_18 < var_16 and var_17[var_18].r == var_11:\n var_8[var_17[var_18].idx] = func_3(\n var_17[var_18].r + 1, var_10, var_15\n ) - func_3(var_17[var_18].l, var_10, var_15)\n var_18 += 1\n\n for var_11 in range(var_16):\n print((var_8[var_11]))\n\n\ndef func_2():\n var_6, var_7 = list(map(int, var_21().split()))\n var_1 = list(map(int, var_21().split()))\n (*var_3,) = list(map(int, var_20().split()))\n var_17 = [0] * var_7\n for var_11, (var_13, var_19) in enumerate(zip(*[iter(var_3)] * 2)):\n var_17[var_11] = Class_1(var_13 - 1, var_19 - 1, var_11)\n var_17.sort(key=lambda var_25: var_25.r)\n func_1(var_1, var_6, var_17, var_7)\n return\n\n\nif __name__ == \"__main__\":\n func_2()\n```", "output": "SLOWER 1.7958", "pair_id": "python_p02599_pair0005_reversed", "problem_id": "p02599", "language": "python", "direction": "reversed", "speedup_ratio": 3.472} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport math\nimport string\n\n\ndef func_4():\n return list(map(int, input().split()))\n\n\ndef func_3(var_6, var_7):\n return math.factorial(var_6) // (\n math.factorial(var_6 - var_7) * math.factorial(var_7)\n )\n\n\ndef func_2(var_9):\n var_8 = []\n for var_5 in var_9:\n if not (var_5 in var_8):\n var_8.append(var_5)\n return len(var_9) != len(var_8)\n\n\ndef func_1(var_6):\n func_1 = []\n for var_4 in range(1, var_6 + 1):\n if var_6 % var_4 == 0:\n func_1.append(var_4)\n return func_1\n\n\nvar_2 = [-1, -1, -1, 0, 0, 1, 1, 1]\nvar_3 = [-1, 0, 1, -1, 1, -1, 0, 1]\nvar_6 = int(eval(input()))\nvar_1 = func_4()\nvar_10 = 1\nfor var_4 in range(len(var_1)):\n if var_1[var_4] % 2 == 0:\n var_10 *= 2\n else:\n var_10 *= 1\nprint((3 ** len(var_1) - var_10))\n```\n\n=== Code B (Modified) ===\n```python\nvar_4 = int(eval(input()))\nvar_1 = list(map(int, input().split()))\nvar_3 = 1\nfor var_2 in var_1:\n var_3 *= 2 if var_2 % 2 == 0 else 1\nprint((3**var_4 - var_3))\n```", "output": "FASTER 1.8134", "pair_id": "python_p03568_pair0049_forward", "problem_id": "p03568", "language": "python", "direction": "forward", "speedup_ratio": 3.5147} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nfrom collections import Counter, defaultdict, deque\nfrom heapq import heappop, heappush, heapify\nimport sys, bisect, math, itertools, fractions, pprint\n\nsys.setrecursionlimit(10**8)\nvar_6 = 10**9 + 7\nvar_1 = float(\"inf\")\n\n\ndef func_1():\n return int(sys.stdin.readline())\n\n\ndef func_2():\n return list(map(int, sys.stdin.readline().split()))\n\n\nvar_7, var_9 = func_2()\nvar_13 = [func_2() for _ in range(var_7)]\nvar_13.sort(key=lambda var_14: var_14[1], reverse=True)\nvar_8 = 0\nvar_10 = min(var_7, 5)\nfor var_3 in range(var_10):\n var_2 = [[0] * (var_9 + 5) for _ in range(var_7 + 5)]\n for var_4 in range(var_7):\n var_12, var_11 = var_13[var_4]\n for var_5 in range(var_9):\n if var_5 < var_12 or var_3 == var_4:\n var_2[var_4 + 1][var_5] = var_2[var_4][var_5]\n else:\n var_2[var_4 + 1][var_5] = max(\n var_2[var_4][var_5], var_2[var_4][var_5 - var_12] + var_11\n )\n\n var_8 = max(var_2[var_7][var_9 - 1] + var_13[var_3][1], var_8)\nprint(var_8)\n```\n\n=== Code B (Modified) ===\n```python\nfrom sys import stdin\n\n\ndef func_1():\n\n var_9 = stdin.readline\n var_8, var_10 = list(map(int, var_9().split()))\n var_7 = [list(map(int, var_9().split())) for _ in range(var_8)]\n var_7.sort()\n var_1 = [0] * var_8\n var_2 = [0] * var_8\n for var_4 in range(var_8):\n var_1[var_4], var_2[var_4] = var_7[var_4][0], var_7[var_4][1]\n\n var_5 = -float(\"inf\")\n var_3 = [[var_5] * (var_10 + 1) for _ in range(var_8 + 1)]\n var_3[0][0] = 0\n for var_4 in range(var_8):\n for var_6 in range(var_10 + 1):\n\n if var_6 != var_10:\n var_3[var_4 + 1][min(var_10, var_6 + var_1[var_4])] = max(\n var_3[var_4 + 1][min(var_10, var_6 + var_1[var_4])],\n var_3[var_4][var_6] + var_2[var_4],\n )\n\n var_3[var_4 + 1][var_6] = max(var_3[var_4 + 1][var_6], var_3[var_4][var_6])\n print((max(var_3[var_8])))\n\n\nif __name__ == \"__main__\":\n func_1()\n```", "output": "FASTER 1.7184", "pair_id": "python_p02863_pair0052_forward", "problem_id": "p02863", "language": "python", "direction": "forward", "speedup_ratio": 3.2907} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\n\nvar_8 = sys.stdin.readline\n\n\ndef func_1():\n var_2 = int(eval(var_8()))\n var_1 = [int(var_8().replace(\" \", \"\"), 2) for _ in range(var_2)]\n var_3 = [list(map(int, var_8().split())) for _ in range(var_2)]\n var_4 = -(10**7) * var_2\n for var_7 in range(1, 1 << 10):\n var_10 = 0\n for var_9, var_6 in enumerate(var_1):\n var_5 = bin(var_7 & var_6).count(\"1\")\n var_10 += var_3[var_9][var_5]\n var_4 = max(var_4, var_10)\n print(var_4)\n\n\nif __name__ == \"__main__\":\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\nimport numpy as np\n\nvar_5 = sys.stdin.readline\n\nvar_7 = int(eval(var_5()))\n\nvar_1 = [var_5().replace(\" \", \"\") for var_4 in range(var_7)]\n\nvar_8 = [list(map(int, var_5().split())) for var_4 in range(var_7)]\n\n\nvar_12 = -999999999999999\n\nfor var_4 in range(1, 1024):\n\n var_3 = format(var_4, \"010b\")\n\n var_10 = 0\n for var_2, var_9 in zip(var_1, var_8):\n\n var_11 = 0\n for var_6 in range(10):\n\n if var_2[var_6] == \"1\" and var_3[var_6] == \"1\":\n\n var_11 += 1\n\n var_10 += var_9[var_11]\n if var_10 > var_12:\n\n var_12 = var_10\nprint(var_12)\n```", "output": "SLOWER 2.7422", "pair_id": "python_p03503_pair0011_reversed", "problem_id": "p03503", "language": "python", "direction": "reversed", "speedup_ratio": 6.6909} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\nimport itertools\n\n\ndef func_2(var_4):\n return bin(eval(\"0b\" + str(var_4)))\n\n\ndef func_1():\n var_4 = int(sys.stdin.readline().rstrip())\n var_9 = [\n func_2(\"\".join(str(var_10) for var_10 in sys.stdin.readline().split()))\n for _ in range(var_4)\n ]\n var_8 = [\n [int(var_10) for var_10 in sys.stdin.readline().split()] for _ in range(var_4)\n ]\n var_3 = -(10**10)\n for var_6 in itertools.product(\"01\", repeat=10):\n var_6 = func_2(\"\".join(var_6))\n if var_6 == \"0b0\":\n continue\n var_7 = 0\n for var_2 in range(var_4):\n var_1 = var_9[var_2]\n var_5 = bin(eval(var_1) & eval(var_6)).count(\"1\")\n var_7 += var_8[var_2][var_5]\n var_3 = max(var_3, var_7)\n print(var_3)\n\n\nif __name__ == \"__main__\":\n\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nvar_8 = int(eval(input()))\nvar_4 = []\nfor var_5 in range(var_8):\n var_11 = 0\n var_9 = list(map(int, input().split()))\n for var_6 in range(10):\n var_11 += var_9[var_6] << var_6\n var_4.append(var_11)\nvar_10 = []\nfor var_5 in range(var_8):\n var_10.append(list(map(int, input().split())))\nvar_1 = -(10**12)\nfor var_5 in range(1, 1 << 10):\n var_11 = 0\n for var_6 in range(var_8):\n var_3 = var_4[var_6] & var_5\n var_2 = 0\n for var_7 in range(10):\n if (var_3 >> var_7) % 2:\n var_2 += 1\n var_11 += var_10[var_6][var_2]\n var_1 = max(var_1, var_11)\nprint(var_1)\n```", "output": "FASTER 2.7368", "pair_id": "python_p03503_pair0048_forward", "problem_id": "p03503", "language": "python", "direction": "forward", "speedup_ratio": 6.6658} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\ndef func_1():\n var_2, var_3, *var_1 = list(map(int, open(0).read().split()))\n var_4 = [0] * (var_3 + max(var_1[::2]))\n for var_7, var_6 in sorted(zip(*[iter(var_1)] * 2)):\n for var_5 in reversed(list(range(var_3))):\n var_4[var_5 + var_7] = max(var_4[var_5 + var_7], var_4[var_5] + var_6)\n print((max(var_4)))\n\n\nfunc_1()\n```\n\n=== Code B (Modified) ===\n```python\nimport bisect\nimport sys\n\nsys.setrecursionlimit(10**6)\nvar_17 = sys.stdout.write\nvar_7 = lambda *var_15: print(*var_15) if var_1 else 0\nvar_1 = True\n\n\ndef func_1(var_10=sys.stdin.readline):\n var_12 = lambda: var_10().rstrip()\n var_3 = lambda: list(map(int, var_12().split()))\n var_2 = lambda: int(var_12())\n var_4 = lambda var_18: [var_3() for _ in range(var_18)]\n var_14, var_16 = var_3()\n var_5 = var_4(var_14)\n var_8 = [[0] * var_16 for _ in range(var_14)]\n for var_11 in range(1, var_14):\n for var_13 in range(1, var_16):\n if var_13 < var_5[var_11 - 1][0]:\n var_8[var_11][var_13] = var_8[var_11 - 1][var_13]\n else:\n var_8[var_11][var_13] = max(\n var_8[var_11 - 1][var_13],\n var_8[var_11 - 1][var_13 - var_5[var_11 - 1][0]]\n + var_5[var_11 - 1][1],\n )\n var_9 = [[0] * var_16 for _ in range(var_14)]\n for var_11 in range(1, var_14):\n for var_13 in range(1, var_16):\n if var_13 < var_5[var_14 - var_11][0]:\n var_9[var_11][var_13] = var_9[var_11 - 1][var_13]\n else:\n var_9[var_11][var_13] = max(\n var_9[var_11 - 1][var_13],\n var_9[var_11 - 1][var_13 - var_5[var_14 - var_11][0]]\n + var_5[var_14 - var_11][1],\n )\n var_6 = 0\n for var_11 in range(var_14):\n for var_13 in range(var_16 - 1):\n var_6 = max(\n var_6,\n var_8[var_11][var_13]\n + var_9[var_14 - var_11 - 1][var_16 - var_13 - 1]\n + var_5[var_11][1],\n )\n print(var_6)\n\n\nif __name__ == \"__main__\":\n func_1()\n```", "output": "SLOWER 1.7019", "pair_id": "python_p02863_pair0067_reversed", "problem_id": "p02863", "language": "python", "direction": "reversed", "speedup_ratio": 3.2534} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_4 = {}\nvar_5 = 0\nfor var_6 in range(10000, 100000):\n var_3 = list(str(var_6))\n if var_3 == list(reversed(var_3)):\n var_5 += 1\n var_4[var_6] = var_5\nvar_1, var_2 = list(map(int, input().split()))\nprint((var_4[var_2] - var_4[var_1 - 1] if var_1 > 10000 else var_4[var_2]))\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_3 in range(var_1, var_2 + 1):\n var_5 = list(str(var_3))\n var_6 = list(reversed(var_5))\n if var_5 == var_6:\n var_4 += 1\nprint(var_4)\n```", "output": "FASTER 2.265", "pair_id": "python_p03416_pair0196_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 4.8064} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_3 in range(var_1, var_2 + 1):\n var_5 = list(str(var_3))\n var_6 = list(reversed(var_5))\n if var_5 == var_6:\n var_4 += 1\nprint(var_4)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_5 in range(10):\n for var_6 in range(10):\n for var_7 in range(10):\n var_3 = 10000 * var_5 + 1000 * var_6 + 100 * var_7 + 10 * var_6 + var_5\n if var_1 <= var_3 <= var_2:\n var_4 += 1\nprint(var_4)\n```", "output": "FASTER 5.1342", "pair_id": "python_p03416_pair0251_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 35.1196} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nfrom functools import reduce\nfrom itertools import product\n\nvar_2 = int(eval(input()))\n(*var_1,) = list(map(int, input().split()))\nvar_4 = 0\nfor var_7 in product([-1, 0, 1], repeat=var_2):\n var_6 = reduce(\n lambda var_8, var_9: var_8 * var_9,\n [var_3 + var_7[var_5] for var_5, var_3 in enumerate(var_1)],\n )\n if var_6 % 2 == 0:\n var_4 += 1\nprint(var_4)\n```\n\n=== Code B (Modified) ===\n```python\nvar_4 = int(eval(input()))\nvar_1 = list(map(int, input().split()))\nvar_3 = 1\nfor var_2 in var_1:\n var_3 *= 2 if var_2 % 2 == 0 else 1\nprint((3**var_4 - var_3))\n```", "output": "FASTER 9.8819", "pair_id": "python_p03568_pair0051_forward", "problem_id": "p03568", "language": "python", "direction": "forward", "speedup_ratio": 943.5387} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_6 in range(var_1, var_2 + 1):\n var_3 = str(var_6)\n var_5 = True\n for var_7 in range(len(var_3) // 2):\n if var_3[var_7] != var_3[-var_7 - 1] and var_5:\n var_5 = not var_5\n if var_5:\n var_4 += 1\nprint(var_4)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().strip().split(\" \")))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n if str(var_4) == str(var_4)[::-1]:\n var_3 += 1\nprint(var_3)\n```", "output": "FASTER 1.1527", "pair_id": "python_p03416_pair0224_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 2.2233} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\n\n\nclass Class_1:\n \"\"\"\"\"\"\n\n def __init__(self, var_1):\n self.__n = len(var_1)\n self.__node = [0] * (self.__n + 1)\n self.__data = [0] * (self.__n + 1)\n var_7 = [0] * (self.__n + 1)\n for var_11 in range(1, self.__n + 1):\n var_7[var_11] = var_7[var_11 - 1] + var_1[var_11 - 1]\n self.__data[var_11] = var_1[var_11 - 1]\n self.__node[var_11] = var_7[var_11] - var_7[var_11 - (var_11 & -var_11)]\n\n def func_1(self, var_11, var_22):\n self.__data[var_11] += var_22\n while var_11 <= self.__n:\n self.__node[var_11] += var_22\n var_11 += var_11 & -var_11\n\n def func_4(self, var_11):\n \"\"\"\"\"\"\n var_19 = 0\n while var_11 > 0:\n var_19 += self.__node[var_11]\n var_11 -= var_11 & -var_11\n return var_19\n\n def func_2(self, var_11, var_12):\n \"\"\"\"\"\"\n if var_11 == var_12:\n return self.__data[var_11]\n else:\n return self.sum(var_12) - self.sum(var_11 - 1)\n\n\ndef func_3():\n var_4, var_6 = map(int, input().split())\n var_3 = list(map(int, input().split()))\n var_5 = [[] for _ in range(var_4)]\n for var_11, var_9 in enumerate(var_3):\n var_5[var_9 - 1].append(var_11)\n var_18 = [0] * var_4\n for var_14 in var_5:\n if len(var_14):\n var_18[var_14.pop()] = 1\n var_2 = Class_1(var_18)\n var_16 = [[] for _ in range(var_4)]\n for var_11, var_20 in enumerate(sys.stdin.readlines()):\n var_13, var_17 = map(int, var_20.split())\n var_16[var_17 - 1].append((var_13 - 1, var_11))\n var_8 = [None] * var_6\n var_10 = var_4 - 1\n for var_17, var_15 in enumerate(reversed(var_16)):\n var_17 = (var_4 - 1) - var_17\n while var_15:\n var_13, var_11 = var_15.pop()\n while var_17 < var_10:\n var_9 = var_3[var_10] - 1\n var_14 = var_5[var_9]\n if len(var_14):\n var_2.add(var_14.pop() + 1, 1)\n var_10 -= 1\n var_21 = var_2.get(var_13 + 1, var_17 + 1)\n var_8[var_11] = var_21\n print(*var_8, sep=\"\\n\")\n\n\nif __name__ == \"__main__\":\n func_3()\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\n\nvar_20 = sys.stdin.read\nvar_21 = sys.stdin.readline\nvar_22 = sys.stdin.readlines\nsys.setrecursionlimit(10**9)\nvar_2 = 1 << 60\nvar_5 = 1000000007\n\n\nvar_4 = 1000001\n\n\nclass Class_1:\n def __init__(self, var_13, var_19, var_12):\n self.l = var_13\n self.r = var_19\n self.idx = var_12\n\n\ndef func_4(var_12, var_24, var_10, var_15):\n while var_12 <= var_15:\n var_10[var_12] += var_24\n var_12 += var_12 & -var_12\n\n\ndef func_3(var_12, var_10, var_15):\n var_23 = 0\n while var_12:\n var_23 += var_10[var_12]\n var_12 -= var_12 & -var_12\n return var_23\n\n\ndef func_1(var_9, var_15, var_17, var_16):\n\n var_10 = [0] * (var_15 + 1)\n\n var_14 = [-1] * var_4\n\n var_8 = [0] * var_16\n var_18 = 0\n for var_11 in range(var_15):\n\n if var_14[var_9[var_11]] != -1:\n func_4(var_14[var_9[var_11]] + 1, -1, var_10, var_15)\n\n var_14[var_9[var_11]] = var_11\n func_4(var_11 + 1, 1, var_10, var_15)\n\n while var_18 < var_16 and var_17[var_18].r == var_11:\n var_8[var_17[var_18].idx] = func_3(\n var_17[var_18].r + 1, var_10, var_15\n ) - func_3(var_17[var_18].l, var_10, var_15)\n var_18 += 1\n\n for var_11 in range(var_16):\n print((var_8[var_11]))\n\n\ndef func_2():\n var_6, var_7 = list(map(int, var_21().split()))\n var_1 = list(map(int, var_21().split()))\n (*var_3,) = list(map(int, var_20().split()))\n var_17 = [0] * var_7\n for var_11, (var_13, var_19) in enumerate(zip(*[iter(var_3)] * 2)):\n var_17[var_11] = Class_1(var_13 - 1, var_19 - 1, var_11)\n var_17.sort(key=lambda var_25: var_25.r)\n func_1(var_1, var_6, var_17, var_7)\n return\n\n\nif __name__ == \"__main__\":\n func_2()\n```", "output": "SLOWER 1.8099", "pair_id": "python_p02599_pair0002_reversed", "problem_id": "p02599", "language": "python", "direction": "reversed", "speedup_ratio": 3.5063} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\ndef func_1():\n var_1, var_2 = list(map(int, input().split()))\n var_3 = 0\n for var_4 in range(var_1, var_2 + 1):\n\n if (var_4 % 10) == (var_4 // 10000 % 10) and (var_4 // 10 % 10) == (\n var_4 // 1000 % 10\n ):\n var_3 += 1\n print(var_3)\n\n\nif __name__ == \"__main__\":\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_4 = str(var_4)\n if var_4 == var_4[::-1]:\n var_3 += 1\nprint(var_3)\n```", "output": "SLOWER 1.8111", "pair_id": "python_p03416_pair0086_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 3.509} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport decimal\n\n\ndef func_1():\n var_1, var_2 = list(map(decimal.Decimal, input().split()))\n print((var_1 * var_2 // 1))\n\n\nif __name__ == \"__main__\":\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\ndef func_1():\n from sys import setrecursionlimit, stdin\n from os import environ\n from collections import defaultdict, deque, Counter\n from math import ceil, floor, gcd\n from itertools import accumulate, combinations, combinations_with_replacement\n\n setrecursionlimit(10**6)\n var_7 = (\n (lambda *var_11: print(*var_11))\n if \"TERM_PROGRAM\" in environ\n else lambda *var_12: 0\n )\n var_8 = lambda: stdin.readline().rstrip()\n var_3 = lambda: list(map(int, var_8().split()))\n var_1 = lambda: int(var_8())\n var_4 = 10**9 + 7\n var_2 = 10**9 + 10\n var_9, var_10 = var_8().split()\n var_5 = int(var_9)\n var_10 = var_10.split(\".\")\n var_6 = int(var_10[0]) * 100\n if len(var_10) == 2:\n var_6 += int(var_10[1])\n print(var_5 * var_6 // 100)\n\n\nfunc_1()\n```", "output": "SLOWER 1.9156", "pair_id": "python_p02659_pair0058_reversed", "problem_id": "p02659", "language": "python", "direction": "reversed", "speedup_ratio": 3.7726} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = [0] * (var_2 + 1)\nfor var_3 in range(1, var_2 + 1):\n if str(var_3) == str(var_3)[::-1]:\n var_4[var_3] = var_4[var_3 - 1] + 1\n else:\n var_4[var_3] = var_4[var_3 - 1]\nprint((var_4[var_2] - var_4[var_1 - 1]))\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_4 = str(var_4)\n if var_4 == var_4[::-1]:\n var_3 += 1\nprint(var_3)\n```", "output": "FASTER 1.7953", "pair_id": "python_p03416_pair0250_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 3.4708} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_10 = []\nvar_10 = input().rstrip().split(\" \")\nvar_1 = int(var_10[0])\nvar_3 = int(var_10[1])\nvar_2 = 0\nvar_6 = var_1\nwhile var_6 <= var_3:\n var_4 = var_6 // 10000\n var_5 = (var_6 - var_4 * 10000) // 1000\n var_7 = var_6 // 100\n var_8 = (var_6 - var_7 * 100) // 10\n var_9 = var_6 % 10\n if (var_4 == var_9) and (var_5 == var_8):\n var_2 += 1\n var_6 += 1\nprint(var_2)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = str(var_4)\n if var_5[0] == var_5[4] and var_5[1] == var_5[3]:\n var_3 += 1\nprint(var_3)\n```", "output": "FASTER 1.0752", "pair_id": "python_p03416_pair0236_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 2.107} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_8 = int(eval(input()))\nvar_4 = []\nfor var_5 in range(var_8):\n var_11 = 0\n var_9 = list(map(int, input().split()))\n for var_6 in range(10):\n var_11 += var_9[var_6] << var_6\n var_4.append(var_11)\nvar_10 = []\nfor var_5 in range(var_8):\n var_10.append(list(map(int, input().split())))\nvar_1 = -(10**12)\nfor var_5 in range(1, 1 << 10):\n var_11 = 0\n for var_6 in range(var_8):\n var_3 = var_4[var_6] & var_5\n var_2 = 0\n for var_7 in range(10):\n if (var_3 >> var_7) % 2:\n var_2 += 1\n var_11 += var_10[var_6][var_2]\n var_1 = max(var_1, var_11)\nprint(var_1)\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\n\nvar_8 = sys.stdin.readline\n\n\ndef func_1():\n var_2 = int(eval(var_8()))\n var_1 = [int(var_8().replace(\" \", \"\"), 2) for _ in range(var_2)]\n var_3 = [list(map(int, var_8().split())) for _ in range(var_2)]\n var_4 = -(10**7) * var_2\n for var_7 in range(1, 1 << 10):\n var_10 = 0\n for var_9, var_6 in enumerate(var_1):\n var_5 = bin(var_7 & var_6).count(\"1\")\n var_10 += var_3[var_9][var_5]\n var_4 = max(var_4, var_10)\n print(var_4)\n\n\nif __name__ == \"__main__\":\n func_1()\n```", "output": "FASTER 2.5749", "pair_id": "python_p03503_pair0015_forward", "problem_id": "p03503", "language": "python", "direction": "forward", "speedup_ratio": 5.9584} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_8 = int(eval(input()))\nvar_5 = []\nvar_10 = {}\nvar_9 = [0, 0]\nfor var_6 in range(var_8 - 1):\n var_1, var_2 = list(map(int, input().split(\" \")))\n var_5.append([var_1, var_2])\n var_10.setdefault(var_1, []).append(var_2)\n var_9.append(0)\nvar_7 = 0\nfor var_11 in range(1, var_8 + 1):\n var_13 = var_10.get(var_11, [])\n var_3 = 1\n for var_12 in var_13:\n if var_3 == var_9[var_11]:\n var_3 += 1\n else:\n pass\n var_9[var_12] = var_3\n if var_3 >= var_7:\n var_7 = var_3\n var_3 += 1\nprint(var_7)\nfor var_4 in var_5:\n print((var_9[var_4[1]]))\n```\n\n=== Code B (Modified) ===\n```python\nimport copy\n\nvar_8 = int(eval(input()))\nvar_10 = set([var_6 for var_6 in range(1, 10**5)])\nvar_5 = []\nvar_11 = {}\nvar_9 = []\nfor var_6 in range(var_8 - 1):\n var_1, var_2 = list(map(int, input().split(\" \")))\n var_5.append([var_1, var_2])\n var_11.setdefault(var_1, []).append(var_2)\n var_9.append([])\nvar_9.append([])\nvar_9.append([])\nvar_7 = 0\nfor var_12 in range(1, var_8 + 1):\n var_14 = var_11.get(var_12, [])\n var_3 = 1\n for var_13 in var_14:\n if var_3 in var_9[var_12]:\n var_3 += 1\n else:\n pass\n var_9[var_13].append(var_3)\n if var_3 >= var_7:\n var_7 = var_3\n var_3 += 1\nprint(var_7)\nfor var_4 in var_5:\n print((var_9[var_4[1]][0]))\n```", "output": "SLOWER 4.7706", "pair_id": "python_p02850_pair0023_reversed", "problem_id": "p02850", "language": "python", "direction": "reversed", "speedup_ratio": 27.2957} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\ndef func_1():\n var_1, var_2 = list(map(int, input().rstrip().split()))\n var_3 = 0\n for var_4 in range(var_1, var_2 + 1):\n var_5 = str(var_4)\n if var_5 == var_5[::-1]:\n var_3 += 1\n print(var_3)\n\n\nif __name__ == \"__main__\":\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_5 in range(10):\n for var_6 in range(10):\n for var_7 in range(10):\n var_3 = 10000 * var_5 + 1000 * var_6 + 100 * var_7 + 10 * var_6 + var_5\n if var_1 <= var_3 <= var_2:\n var_4 += 1\nprint(var_4)\n```", "output": "FASTER 3.0796", "pair_id": "python_p03416_pair0098_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 8.4536} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_5 in range(10):\n for var_6 in range(10):\n for var_7 in range(10):\n var_3 = 10000 * var_5 + 1000 * var_6 + 100 * var_7 + 10 * var_6 + var_5\n if var_1 <= var_3 <= var_2:\n var_4 += 1\nprint(var_4)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_7 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_3 = True\n var_8 = str(var_4)\n var_6 = len(var_8)\n for var_5 in range(var_6 // 2 + 1):\n if var_8[var_5] != var_8[-var_5 - 1]:\n var_3 = False\n break\n if var_3:\n var_7 += 1\nprint(var_7)\n```", "output": "SLOWER 4.9507", "pair_id": "python_p03416_pair0227_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 30.924} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\ndef func_1():\n from sys import setrecursionlimit, stdin\n from os import environ\n from collections import defaultdict, deque, Counter\n from math import ceil, floor, gcd\n from itertools import accumulate, combinations, combinations_with_replacement\n\n setrecursionlimit(10**6)\n var_7 = (\n (lambda *var_11: print(*var_11))\n if \"TERM_PROGRAM\" in environ\n else lambda *var_12: 0\n )\n var_8 = lambda: stdin.readline().rstrip()\n var_3 = lambda: list(map(int, var_8().split()))\n var_1 = lambda: int(var_8())\n var_4 = 10**9 + 7\n var_2 = 10**9 + 10\n var_9, var_10 = var_8().split()\n var_5 = int(var_9)\n var_10 = var_10.split(\".\")\n var_6 = int(var_10[0]) * 100\n if len(var_10) == 2:\n var_6 += int(var_10[1])\n print(var_5 * var_6 // 100)\n\n\nfunc_1()\n```\n\n=== Code B (Modified) ===\n```python\nimport math\n\nvar_1, var_2 = input().split()\nvar_1 = int(var_1)\nvar_3 = int(var_2[0] + var_2[2] + var_2[3])\nprint((var_1 * var_3 // 100))\n```", "output": "FASTER 2.2041", "pair_id": "python_p02659_pair0054_forward", "problem_id": "p02659", "language": "python", "direction": "forward", "speedup_ratio": 4.6079} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().strip().split(\" \")))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n if str(var_4) == str(var_4)[::-1]:\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\ndef func_1():\n var_1, var_2 = list(map(int, input().split()))\n var_3 = 0\n for var_4 in range(var_1, var_2 + 1):\n\n if (var_4 % 10) == (var_4 // 10000 % 10) and (var_4 // 10 % 10) == (\n var_4 // 1000 % 10\n ):\n var_3 += 1\n print(var_3)\n\n\nif __name__ == \"__main__\":\n func_1()\n```", "output": "FASTER 1.9713", "pair_id": "python_p03416_pair0151_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 3.9213} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport math\nfrom decimal import Decimal\n\nvar_1, var_2 = list(map(Decimal, input().split()))\nprint((math.floor(var_1 * var_2)))\n```\n\n=== Code B (Modified) ===\n```python\ndef func_1():\n from sys import setrecursionlimit, stdin\n from os import environ\n from collections import defaultdict, deque, Counter\n from math import ceil, floor, gcd\n from itertools import accumulate, combinations, combinations_with_replacement\n\n setrecursionlimit(10**6)\n var_7 = (\n (lambda *var_11: print(*var_11))\n if \"TERM_PROGRAM\" in environ\n else lambda *var_12: 0\n )\n var_8 = lambda: stdin.readline().rstrip()\n var_3 = lambda: list(map(int, var_8().split()))\n var_1 = lambda: int(var_8())\n var_4 = 10**9 + 7\n var_2 = 10**9 + 10\n var_9, var_10 = var_8().split()\n var_5 = int(var_9)\n var_6 = int(float(var_10) * 100 + 0.5)\n print(var_5 * var_6 // 100)\n\n\nfunc_1()\n```", "output": "SLOWER 2.159", "pair_id": "python_p02659_pair0032_reversed", "problem_id": "p02659", "language": "python", "direction": "reversed", "speedup_ratio": 4.466} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nfrom sys import stdin\n\nvar_5 = stdin.readline\nvar_2, var_1 = list(map(int, var_5().split()))\nvar_3 = [False] * var_2\nvar_8 = [0] * var_2\nvar_9 = 0\nfor var_4 in range(var_1):\n var_6, var_7 = var_5().split()\n var_6 = int(var_6) - 1\n if var_3[var_6] is False and var_7 == \"AC\":\n var_9 += var_8[var_6]\n var_3[var_6] = True\n elif var_7 == \"WA\":\n var_8[var_6] += 1\nprint((var_3.count(True), var_9))\n```\n\n=== Code B (Modified) ===\n```python\nvar_6, var_5 = list(map(int, input().split()))\nvar_8 = [[] for _ in range(var_6)]\nfor var_2 in range(var_5):\n var_10, var_11 = input().split()\n var_8[int(var_10) - 1].append(var_11)\n\nvar_1, var_7 = 0, 0\nfor var_3 in range(var_6):\n var_9 = var_8[var_3]\n if \"AC\" in var_9:\n var_1 += 1\n for var_4 in var_9:\n if var_4 == \"WA\":\n var_7 += 1\n else:\n break\nprint((var_1, var_7))\n```", "output": "SLOWER 3.2959", "pair_id": "python_p02802_pair0012_reversed", "problem_id": "p02802", "language": "python", "direction": "reversed", "speedup_ratio": 9.8215} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\ndef func_1():\n var_2 = int(input())\n var_1 = [int(var_6) for var_6 in input().split()]\n if var_2 == 1:\n return print(1 if var_1[0] % 2 == 0 else 2)\n var_3 = 0\n var_5 = (-1, 0, 1)\n from itertools import product\n\n for var_6 in product(range(3), repeat=var_2):\n var_4 = 1\n for var_7 in range(var_2):\n var_4 *= var_1[var_7] + var_5[var_6[var_7]]\n if var_4 % 2 == 0:\n var_3 += 1\n print(var_3)\n\n\nif __name__ == \"__main__\":\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nvar_6 = int(eval(input()))\nvar_2 = list(map(int, input().split()))\nfrom itertools import product\n\nvar_5 = [-1, 0, 1]\nvar_3 = 0\nfor var_7 in product(var_5, repeat=var_6):\n var_1 = []\n for var_4 in range(var_6):\n var_1.append(var_7[var_4] + var_2[var_4])\n if any(var_8 % 2 == 0 for var_8 in var_1):\n var_3 += 1\nprint(var_3)\n```", "output": "SLOWER 1.2741", "pair_id": "python_p03568_pair0007_reversed", "problem_id": "p03568", "language": "python", "direction": "reversed", "speedup_ratio": 2.4185} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nfrom collections import Counter, defaultdict, deque\nfrom heapq import heappop, heappush, heapify\nimport sys, bisect, math, itertools, fractions, pprint\n\nsys.setrecursionlimit(10**8)\nvar_6 = 10**9 + 7\nvar_1 = float(\"inf\")\n\n\ndef func_1():\n return int(sys.stdin.readline())\n\n\ndef func_2():\n return list(map(int, sys.stdin.readline().split()))\n\n\nvar_7, var_9 = func_2()\nvar_13 = [func_2() for _ in range(var_7)]\nvar_13.sort(key=lambda var_14: var_14[1], reverse=True)\nvar_8 = 0\nvar_10 = min(var_7, 5)\nfor var_3 in range(var_10):\n var_2 = [[0] * (var_9 + 5) for _ in range(var_7 + 5)]\n for var_4 in range(var_7):\n var_12, var_11 = var_13[var_4]\n for var_5 in range(var_9):\n if var_5 < var_12 or var_3 == var_4:\n var_2[var_4 + 1][var_5] = var_2[var_4][var_5]\n else:\n var_2[var_4 + 1][var_5] = max(\n var_2[var_4][var_5], var_2[var_4][var_5 - var_12] + var_11\n )\n\n var_8 = max(var_2[var_7][var_9 - 1] + var_13[var_3][1], var_8)\nprint(var_8)\n```\n\n=== Code B (Modified) ===\n```python\nvar_2, var_3, *var_1 = list(map(int, open(0).read().split()))\nvar_4 = [0] * (var_3 + max(var_1[::2]))\nfor var_7, var_6 in sorted(zip(*[iter(var_1)] * 2)):\n for var_5 in reversed(list(range(var_3))):\n var_4[var_5 + var_7] = max(var_4[var_5 + var_7], var_4[var_5] + var_6)\nprint((max(var_4)))\n```", "output": "FASTER 2.226", "pair_id": "python_p02863_pair0057_forward", "problem_id": "p02863", "language": "python", "direction": "forward", "speedup_ratio": 4.6782} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_3 = list(map(int, input().split()))\nvar_2 = -1\nfor var_4 in range(10, 12501):\n if int(var_4 * 0.08) == var_1 and int(var_4 * 0.1) == var_3:\n var_2 = var_4\n break\nprint(var_2)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nfor var_3 in range(1, 1009):\n if int(var_3 * 0.08) == var_1 and int(var_3 * 0.1) == var_2:\n print((int(var_3)))\n exit()\nprint(\"-1\")\n```", "output": "FASTER 3.3967", "pair_id": "python_p02755_pair0008_forward", "problem_id": "p02755", "language": "python", "direction": "forward", "speedup_ratio": 10.5316} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\n\nvar_2, var_1, *var_3 = sys.stdin.read().strip().split()\nvar_2 = int(var_2)\nvar_5 = [0] * var_2\nvar_10 = [0] * var_2\nfor var_6, var_8 in zip(*[iter(var_3)] * 2):\n var_6 = int(var_6) - 1\n if var_8 == \"AC\":\n var_5[var_6] = 1\n elif var_5[var_6] == 0:\n var_10[var_6] += 1\nvar_7 = sum([var_9 * var_4 for var_4, var_9 in zip(var_5, var_10)])\nprint((\"{} {}\".format(sum(var_5), var_7)))\n```\n\n=== Code B (Modified) ===\n```python\nvar_2, var_1 = list(map(int, input().split()))\nvar_3 = 0\nvar_8 = 0\nvar_4 = [0] * (var_2 + 1)\nvar_9 = [0] * (var_2 + 1)\nfor var_5 in range(var_1):\n var_6, var_7 = input().split()\n var_6 = int(var_6)\n if var_7 == \"AC\":\n if var_4[var_6] == 0:\n var_3 += 1\n var_8 += var_9[var_6]\n var_4[var_6] = 1\n else:\n var_9[var_6] += 1\nprint((var_3, var_8))\n```", "output": "FASTER 2.9476", "pair_id": "python_p02802_pair0013_forward", "problem_id": "p02802", "language": "python", "direction": "forward", "speedup_ratio": 7.7147} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport copy\nimport random\nimport bisect\nimport fractions\nimport math\nimport sys\nimport collections\nfrom decimal import Decimal\n\nvar_5 = 10**9 + 7\nsys.setrecursionlimit(var_5)\nvar_3 = collections.deque()\n\n\ndef func_1():\n return list(map(int, sys.stdin.readline().split()))\n\n\nvar_1 = int(eval(input()))\nvar_6 = [0 for var_4 in range(var_1)]\nfor var_4 in range(var_1):\n var_6[var_4] = int(eval(input()))\nvar_6.sort()\nvar_2 = sum(var_6)\nvar_2 -= var_6[-1] // 2\nprint(var_2)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1 = [int(eval(input())) for _ in range(int(eval(input())))]\nprint((sum(var_1) - max(var_1) // 2))\n```", "output": "FASTER 1.0725", "pair_id": "python_p03207_pair0003_forward", "problem_id": "p03207", "language": "python", "direction": "forward", "speedup_ratio": 2.1031} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = [\n var_3 for var_3 in map(str, list(range(var_1, var_2 + 1))) if var_3 == var_3[::-1]\n]\nprint((len(var_4)))\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n if list(str(var_4)) == list(reversed(str(var_4))):\n var_3 += 1\nprint(var_3)\n```", "output": "SLOWER 2.0989", "pair_id": "python_p03416_pair0252_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 4.2839} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport numpy as np\nfrom bisect import bisect_left\n\n\ndef func_1():\n var_4 = []\n var_1 = np.ones(10**5 + 10)\n var_1[0] = var_1[1] = 0\n for var_3, var_2 in enumerate(var_1):\n if var_2:\n var_4.append(var_3)\n var_1[2 * var_3 : 10**5 + 10 : var_3] = 0\n return var_4\n\n\ndef func_2(var_6):\n var_7 = int(var_6)\n var_5 = func_1()\n return str(var_5[bisect_left(var_5, var_7)])\n\n\nif __name__ == \"__main__\":\n import sys\n\n print((func_2(sys.stdin.read().strip())))\n```\n\n=== Code B (Modified) ===\n```python\nfrom math import sqrt\n\nvar_2 = int(eval(input()))\n\n\ndef func_1(var_2):\n if var_2 < 2:\n return False\n for var_1 in range(2, int(sqrt(var_2)) + 1):\n if var_2 % var_1 == 0:\n return False\n return True\n\n\nwhile not func_1(var_2):\n var_2 += 1\nprint(var_2)\n```", "output": "FASTER 7.7622", "pair_id": "python_p02819_pair0009_forward", "problem_id": "p02819", "language": "python", "direction": "forward", "speedup_ratio": 217.0952} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_6 = 2019\nvar_1 = [0] * var_6\nvar_3 = 1\nvar_5 = var_4 = 0\nfor var_2 in input()[::-1]:\n var_1[var_4] += 1\n var_4 -= int(var_2) * var_3\n var_4 %= var_6\n var_5 += var_1[var_4]\n var_3 *= 10\n var_3 %= var_6\nprint(var_5)\n```\n\n=== Code B (Modified) ===\n```python\nvar_6 = input()[::-1]\nvar_5 = len(var_6)\nvar_1 = [0] * var_5\nvar_3 = [0] * var_5\nvar_2 = [0] * 2019\nvar_7 = 10\nvar_1[0] = int(var_6[0])\nvar_3[0] = var_1[0]\nvar_2[var_3[0]] += 1\nfor var_4 in range(1, var_5):\n var_1[var_4] = int(var_6[var_4]) * var_7 % 2019\n var_3[var_4] = (var_3[var_4 - 1] + var_1[var_4]) % 2019\n var_2[var_3[var_4]] += 1\n var_7 = var_7 * 10 % 2019\nprint(\n (\n int(sum([var_2[var_4] * (var_2[var_4] - 1) for var_4 in range(2019)]) / 2)\n + var_2[0]\n )\n)\n```", "output": "SLOWER 2.581", "pair_id": "python_p02702_pair0004_reversed", "problem_id": "p02702", "language": "python", "direction": "reversed", "speedup_ratio": 5.9835} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\n\nsys.setrecursionlimit(500000)\nvar_4 = int(eval(input()))\nvar_2 = [[] for _ in range(var_4 + 1)]\nfor var_9 in range(var_4 - 1):\n var_5, var_6 = list(map(int, input().split()))\n var_2[var_5].append((var_6, var_9))\n var_2[var_6].append((var_5, var_9))\nvar_3 = max(len(var_8) for var_8 in var_2)\nprint(var_3)\nvar_1 = [-1] * (var_4 - 1)\n\n\ndef func_1(var_14=1, var_11=0, var_12=-1):\n var_7 = 1\n for var_13, var_10 in var_2[var_14]:\n if var_13 != var_11:\n if var_7 == var_12:\n var_7 += 1\n var_1[var_10] = var_7\n\n func_1(var_13, var_14, var_7)\n var_7 += 1\n\n\nfunc_1()\nprint((\"\\n\".join(map(str, var_1))))\n```\n\n=== Code B (Modified) ===\n```python\nimport copy\n\nvar_8 = int(eval(input()))\nvar_10 = set([var_6 for var_6 in range(1, 10**5)])\nvar_5 = []\nvar_11 = {}\nvar_9 = []\nfor var_6 in range(var_8 - 1):\n var_1, var_2 = list(map(int, input().split(\" \")))\n var_5.append([var_1, var_2])\n var_11.setdefault(var_1, []).append(var_2)\n var_9.append([])\nvar_9.append([])\nvar_9.append([])\nvar_7 = 0\nfor var_12 in range(1, var_8 + 1):\n var_14 = var_11.get(var_12, [])\n var_3 = 1\n for var_13 in var_14:\n if var_3 in var_9[var_12]:\n var_3 += 1\n else:\n pass\n var_9[var_13].append(var_3)\n if var_3 >= var_7:\n var_7 = var_3\n var_3 += 1\nprint(var_7)\nfor var_4 in var_5:\n print((var_9[var_4[1]][0]))\n```", "output": "SLOWER 4.54", "pair_id": "python_p02850_pair0015_reversed", "problem_id": "p02850", "language": "python", "direction": "reversed", "speedup_ratio": 23.264} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nfrom sys import stdin\n\nvar_5 = stdin.readline\nvar_2, var_1 = list(map(int, var_5().split()))\nvar_3 = [False] * var_2\nvar_8 = [0] * var_2\nvar_9 = 0\nfor var_4 in range(var_1):\n var_6, var_7 = var_5().split()\n var_6 = int(var_6) - 1\n if var_3[var_6] is False and var_7 == \"AC\":\n var_9 += var_8[var_6]\n var_3[var_6] = True\n elif var_7 == \"WA\":\n var_8[var_6] += 1\nprint((var_3.count(True), var_9))\n```\n\n=== Code B (Modified) ===\n```python\nvar_2, var_1 = list(map(int, input().split()))\nvar_3 = 0\nvar_8 = 0\nvar_4 = [0] * (var_2 + 1)\nvar_9 = [0] * (var_2 + 1)\nfor var_5 in range(var_1):\n var_6, var_7 = input().split()\n var_6 = int(var_6)\n if var_7 == \"AC\":\n if var_4[var_6] == 0:\n var_3 += 1\n var_8 += var_9[var_6]\n var_4[var_6] = 1\n else:\n var_9[var_6] += 1\nprint((var_3, var_8))\n```", "output": "FASTER 1.4288", "pair_id": "python_p02802_pair0003_forward", "problem_id": "p02802", "language": "python", "direction": "forward", "speedup_ratio": 2.6922} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1 = list(map(int, input().split()))\nvar_2 = 0\nfor var_3 in range(var_1[0], var_1[1] + 1):\n var_4 = str(var_3)\n if var_4[0] == var_4[4] and var_4[1] == var_4[3]:\n var_2 += 1\nprint(var_2)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = list(str(var_4))\n if var_5 == list(reversed(var_5)):\n var_3 += 1\nprint(var_3)\n```", "output": "SLOWER 1.521", "pair_id": "python_p03416_pair0242_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 2.8699} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport bisect\nimport sys\n\nsys.setrecursionlimit(10**6)\nvar_16 = sys.stdout.write\nvar_7 = lambda *var_14: print(*var_14) if var_1 else 0\nvar_1 = True\n\n\ndef func_1(var_9=sys.stdin.readline):\n var_11 = lambda: var_9().rstrip()\n var_3 = lambda: list(map(int, var_11().split()))\n var_2 = lambda: int(var_11())\n var_4 = lambda var_17: [var_3() for _ in range(var_17)]\n var_13, var_15 = var_3()\n var_5 = var_4(var_13)\n var_5.sort()\n var_8 = [[0] * var_15 for _ in range(var_13 + 1)]\n for var_10 in range(1, var_13 + 1):\n for var_12 in range(1, var_15):\n if var_12 < var_5[var_10 - 1][0]:\n var_8[var_10][var_12] = var_8[var_10 - 1][var_12]\n else:\n var_8[var_10][var_12] = max(\n var_8[var_10 - 1][var_12],\n var_8[var_10 - 1][var_12 - var_5[var_10 - 1][0]]\n + var_5[var_10 - 1][1],\n )\n var_6 = 0\n for var_10 in range(var_13):\n var_6 = max(var_6, var_8[var_10][var_15 - 1] + var_5[var_10][1])\n print(var_6)\n\n\nif __name__ == \"__main__\":\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nfrom collections import Counter, defaultdict, deque\nfrom heapq import heappop, heappush, heapify\nimport sys, bisect, math, itertools, fractions, pprint\n\nsys.setrecursionlimit(10**8)\nvar_6 = 10**9 + 7\nvar_1 = float(\"inf\")\n\n\ndef func_1():\n return int(sys.stdin.readline())\n\n\ndef func_2():\n return list(map(int, sys.stdin.readline().split()))\n\n\nvar_7, var_9 = func_2()\nvar_13 = [func_2() for _ in range(var_7)]\nvar_13.sort(key=lambda var_14: var_14[1], reverse=True)\nvar_8 = 0\nvar_10 = min(var_7, 5)\nfor var_3 in range(var_10):\n var_2 = [[0] * (var_9 + 5) for _ in range(var_7 + 5)]\n for var_4 in range(var_7):\n var_12, var_11 = var_13[var_4]\n for var_5 in range(var_9):\n if var_5 < var_12 or var_3 == var_4:\n var_2[var_4 + 1][var_5] = var_2[var_4][var_5]\n else:\n var_2[var_4 + 1][var_5] = max(\n var_2[var_4][var_5], var_2[var_4][var_5 - var_12] + var_11\n )\n\n var_8 = max(var_2[var_7][var_9 - 1] + var_13[var_3][1], var_8)\nprint(var_8)\n```", "output": "SLOWER 2.0434", "pair_id": "python_p02863_pair0047_reversed", "problem_id": "p02863", "language": "python", "direction": "reversed", "speedup_ratio": 4.1221} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = [\n var_3 for var_3 in map(str, list(range(var_1, var_2 + 1))) if var_3 == var_3[::-1]\n]\nprint((len(var_4)))\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = list(str(var_4))\n if var_5 == list(reversed(var_5)):\n var_3 += 1\nprint(var_3)\n```", "output": "SLOWER 1.9307", "pair_id": "python_p03416_pair0225_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 3.8125} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_6, var_5 = list(map(int, input().split()))\nvar_8 = [[] for _ in range(var_6)]\nfor var_2 in range(var_5):\n var_10, var_11 = input().split()\n var_8[int(var_10) - 1].append(var_11)\n\nvar_1, var_7 = 0, 0\nfor var_3 in range(var_6):\n var_9 = var_8[var_3]\n if \"AC\" in var_9:\n var_1 += 1\n for var_4 in var_9:\n if var_4 == \"WA\":\n var_7 += 1\n else:\n break\nprint((var_1, var_7))\n```\n\n=== Code B (Modified) ===\n```python\nfrom sys import stdin\n\nvar_5 = stdin.readline\nvar_2, var_1 = list(map(int, var_5().split()))\nvar_3 = [False] * var_2\nvar_8 = [0] * var_2\nvar_9 = 0\nfor var_4 in range(var_1):\n var_6, var_7 = var_5().split()\n var_6 = int(var_6) - 1\n if var_3[var_6] is False and var_7 == \"AC\":\n var_9 += var_8[var_6]\n var_3[var_6] = True\n elif var_7 == \"WA\":\n var_8[var_6] += 1\nprint((var_3.count(True), var_9))\n```", "output": "FASTER 3.2959", "pair_id": "python_p02802_pair0012_forward", "problem_id": "p02802", "language": "python", "direction": "forward", "speedup_ratio": 9.8215} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\ndef func_1():\n var_2, var_3, *var_1 = list(map(int, open(0).read().split()))\n var_4 = [0] * (var_3 + max(var_1[::2]))\n for var_7, var_6 in sorted(zip(*[iter(var_1)] * 2)):\n for var_5 in reversed(list(range(var_3))):\n var_4[var_5 + var_7] = max(var_4[var_5 + var_7], var_4[var_5] + var_6)\n print((max(var_4)))\n\n\nfunc_1()\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\nfrom operator import itemgetter\nfrom heapq import heapify, heappop, heappush\n\nvar_1 = int(10e15)\nvar_2 = -var_1\nvar_11 = 1000000007\nsys.setrecursionlimit(1000000)\n\n\ndef func_2():\n return list(map(int, input().split()))\n\n\ndef func_4():\n return input().split()\n\n\ndef func_1():\n return int(sys.stdin.readline())\n\n\ndef func_3():\n return eval(input())\n\n\nvar_3, var_4 = func_2()\nvar_5 = [func_2() for var_9 in range(var_3)]\nvar_5.sort(key=itemgetter(0))\n\nvar_8 = [[0] * (var_4 + 1 + 3000 + 1) for _ in range(var_3 + 1)]\nvar_6 = 0\nfor var_9 in range(var_3):\n for var_10 in range(var_4 + 1 + 3000 + 1):\n var_12, var_7 = var_5[var_9]\n if 0 <= var_10 - var_12 < var_4:\n var_8[var_9 + 1][var_10] = max(\n var_8[var_9][var_10], var_8[var_9][var_10 - var_12] + var_7\n )\n else:\n var_8[var_9 + 1][var_10] = var_8[var_9][var_10]\n var_6 = max(var_6, var_8[var_9 + 1][var_10])\nprint(var_6)\n```", "output": "SLOWER 6.1143", "pair_id": "python_p02863_pair0038_reversed", "problem_id": "p02863", "language": "python", "direction": "reversed", "speedup_ratio": 69.2784} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = input().split()\nvar_1 = int(var_1)\nvar_2 = int(var_2)\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = list(str(var_4))\n if (var_5[0] == var_5[4]) and (var_5[1] == var_5[3]):\n var_3 = var_3 + 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = list(reversed(list(str(var_4))))\n if var_5 == list(str(var_4)):\n var_3 += 1\nprint(var_3)\n```", "output": "SLOWER 1.2527", "pair_id": "python_p03416_pair0231_reversed", "problem_id": "p03416", "language": "python", "direction": "reversed", "speedup_ratio": 2.3828} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\n\nvar_7 = sys.stdin.readline\nfrom itertools import combinations\n\n\ndef func_3(var_10):\n for _ in range(var_10):\n yield list(map(int, var_7().split()))\n\n\ndef func_1(var_9, var_5, var_11):\n var_3 = sum(1 if var_5[var_8] == 1 else 0 for var_8 in var_9)\n return var_11[var_3]\n\n\ndef func_2():\n var_10 = int(eval(var_7()))\n var_1 = list(func_3(var_10))\n var_2 = list(func_3(var_10))\n for var_6 in range(1, 11):\n for var_4 in combinations(list(range(10)), var_6):\n yield sum(\n func_1(var_4, var_5, var_11) for var_5, var_11 in zip(var_1, var_2)\n )\n\n\nprint((max(func_2())))\n```\n\n=== Code B (Modified) ===\n```python\nfrom sys import stdin\n\n\ndef func_1():\n\n var_11 = stdin.readline\n var_2 = int(var_11())\n var_1 = []\n for var_6 in range(var_2):\n var_5 = int(\"\".join(var_11().strip().split(\" \")), 2)\n var_1.append(var_5)\n var_3 = []\n for var_6 in range(var_2):\n var_10 = list(map(int, var_11().split()))\n var_3.append(var_10)\n var_8 = float(\"-inf\")\n for var_9 in range(1, 1 << 10):\n var_12 = 0\n for var_7 in range(var_2):\n var_4 = bin(var_9 & var_1[var_7]).count(\"1\")\n var_12 += var_3[var_7][var_4]\n var_8 = max(var_12, var_8)\n print(var_8)\n\n\nif __name__ == \"__main__\":\n func_1()\n```", "output": "FASTER 1.801", "pair_id": "python_p03503_pair0003_forward", "problem_id": "p03503", "language": "python", "direction": "forward", "speedup_ratio": 3.4845} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = 0\nfor var_3 in range(var_1, var_2 + 1):\n var_5 = list(str(var_3))\n var_6 = list(reversed(var_5))\n if var_5 == var_6:\n var_4 += 1\nprint(var_4)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = str(var_4)\n if var_5 == var_5[::-1]:\n var_3 += 1\nprint(var_3)\n```", "output": "FASTER 1.3131", "pair_id": "python_p03416_pair0082_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 2.4848} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\nfrom operator import itemgetter\nfrom heapq import heapify, heappop, heappush\n\nvar_1 = int(10e15)\nvar_2 = -var_1\nvar_11 = 1000000007\nsys.setrecursionlimit(1000000)\n\n\ndef func_2():\n return list(map(int, input().split()))\n\n\ndef func_4():\n return input().split()\n\n\ndef func_1():\n return int(sys.stdin.readline())\n\n\ndef func_3():\n return eval(input())\n\n\nvar_3, var_4 = func_2()\nvar_5 = [func_2() for var_9 in range(var_3)]\nvar_5.sort(key=itemgetter(0))\n\nvar_8 = [[0] * (var_4 + 1 + 3000 + 1) for _ in range(var_3 + 1)]\nvar_6 = 0\nfor var_9 in range(var_3):\n for var_10 in range(var_4 + 1 + 3000 + 1):\n var_12, var_7 = var_5[var_9]\n if 0 <= var_10 - var_12 < var_4:\n var_8[var_9 + 1][var_10] = max(\n var_8[var_9][var_10], var_8[var_9][var_10 - var_12] + var_7\n )\n else:\n var_8[var_9 + 1][var_10] = var_8[var_9][var_10]\n var_6 = max(var_6, var_8[var_9 + 1][var_10])\nprint(var_6)\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\n\nvar_9 = sys.stdin.readline\nfrom operator import itemgetter\n\nvar_3, var_4 = list(map(int, var_9().split()))\nvar_1 = [list(map(int, var_9().split())) for _ in range(var_3)]\nvar_1.sort(key=itemgetter(0))\nvar_8 = [[0 for _ in range(var_3 + 1)] for _ in range(var_4 + 1)]\n\nvar_2 = []\nfor var_10 in range(var_3):\n var_5, var_7 = var_1[var_10]\n for var_11 in range(var_4):\n if var_5 > var_11:\n var_8[var_11][var_10 + 1] = var_8[var_11][var_10]\n else:\n if var_7 + var_8[var_11 - var_5][var_10] >= var_8[var_11][var_10]:\n var_8[var_11][var_10 + 1] = var_8[var_11 - var_5][var_10] + var_7\n else:\n var_8[var_11][var_10 + 1] = var_8[var_11][var_10]\n var_2.append(var_8[var_4 - 1][var_10] + var_7)\nvar_6 = max(var_2)\nprint(var_6)\n```", "output": "FASTER 4.8389", "pair_id": "python_p02863_pair0045_forward", "problem_id": "p02863", "language": "python", "direction": "forward", "speedup_ratio": 28.619} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport bisect\nimport sys\n\nsys.setrecursionlimit(10**6)\nvar_16 = sys.stdout.write\nvar_7 = lambda *var_14: print(*var_14) if var_1 else 0\nvar_1 = True\n\n\ndef func_1(var_9=sys.stdin.readline):\n var_11 = lambda: var_9().rstrip()\n var_3 = lambda: list(map(int, var_11().split()))\n var_2 = lambda: int(var_11())\n var_4 = lambda var_17: [var_3() for _ in range(var_17)]\n var_13, var_15 = var_3()\n var_5 = var_4(var_13)\n var_5.sort()\n var_8 = [[0] * var_15 for _ in range(var_13 + 1)]\n for var_10 in range(1, var_13 + 1):\n for var_12 in range(1, var_15):\n if var_12 < var_5[var_10 - 1][0]:\n var_8[var_10][var_12] = var_8[var_10 - 1][var_12]\n else:\n var_8[var_10][var_12] = max(\n var_8[var_10 - 1][var_12],\n var_8[var_10 - 1][var_12 - var_5[var_10 - 1][0]]\n + var_5[var_10 - 1][1],\n )\n var_6 = 0\n for var_10 in range(var_13):\n var_6 = max(var_6, var_8[var_10][var_15 - 1] + var_5[var_10][1])\n print(var_6)\n\n\nif __name__ == \"__main__\":\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_6 = sorted([list(map(int, input().split())) for var_5 in range(var_1)])\n\nvar_4 = [[0] * (var_2 + 1) for var_5 in range(var_1 + 1)]\n\nfor var_5 in range(var_1):\n var_9, var_8 = var_6[var_5]\n for var_7 in range(var_2 + 1):\n if var_7 + var_9 <= var_2:\n var_4[var_5 + 1][var_7 + var_9] = max(\n var_4[var_5 + 1][var_7 + var_9], var_4[var_5][var_7] + var_8\n )\n var_4[var_5 + 1][var_7] = max(var_4[var_5][var_7], var_4[var_5 + 1][var_7])\nvar_3 = 0\nfor var_5, (var_9, var_8) in enumerate(var_6):\n for var_7 in range(var_2):\n var_3 = max(var_3, var_4[var_5][var_7] + var_8)\nprint(var_3)\n```", "output": "SLOWER 1.1662", "pair_id": "python_p02863_pair0058_reversed", "problem_id": "p02863", "language": "python", "direction": "reversed", "speedup_ratio": 2.2442} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport math\nfrom decimal import Decimal\n\nvar_1, var_2 = list(map(Decimal, input().split()))\nprint((math.floor(var_1 * var_2)))\n```\n\n=== Code B (Modified) ===\n```python\ndef func_1():\n from sys import setrecursionlimit, stdin\n from os import environ\n from collections import defaultdict, deque, Counter\n from math import ceil, floor, gcd\n from itertools import accumulate, combinations, combinations_with_replacement\n\n setrecursionlimit(10**6)\n var_7 = (\n (lambda *var_11: print(*var_11))\n if \"TERM_PROGRAM\" in environ\n else lambda *var_12: 0\n )\n var_8 = lambda: stdin.readline().rstrip()\n var_3 = lambda: list(map(int, var_8().split()))\n var_1 = lambda: int(var_8())\n var_4 = 10**9 + 7\n var_2 = 10**9 + 10\n var_9, var_10 = var_8().split()\n var_5 = int(var_9)\n var_10 = var_10.split(\".\")\n var_6 = int(var_10[0]) * 100\n if len(var_10) == 2:\n var_6 += int(var_10[1])\n print(var_5 * var_6 // 100)\n\n\nfunc_1()\n```", "output": "SLOWER 2.3027", "pair_id": "python_p02659_pair0060_reversed", "problem_id": "p02659", "language": "python", "direction": "reversed", "speedup_ratio": 4.9339} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nfrom sys import stdin\n\n\ndef func_1():\n\n var_11 = stdin.readline\n var_2 = int(var_11())\n var_1 = []\n for var_6 in range(var_2):\n var_5 = int(\"\".join(var_11().strip().split(\" \")), 2)\n var_1.append(var_5)\n var_3 = []\n for var_6 in range(var_2):\n var_10 = list(map(int, var_11().split()))\n var_3.append(var_10)\n var_8 = float(\"-inf\")\n for var_9 in range(1, 1 << 10):\n var_12 = 0\n for var_7 in range(var_2):\n var_4 = bin(var_9 & var_1[var_7]).count(\"1\")\n var_12 += var_3[var_7][var_4]\n var_8 = max(var_12, var_8)\n print(var_8)\n\n\nif __name__ == \"__main__\":\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nvar_8 = int(eval(input()))\nvar_4 = []\nfor var_5 in range(var_8):\n var_11 = 0\n var_9 = list(map(int, input().split()))\n for var_6 in range(10):\n var_11 += var_9[var_6] << var_6\n var_4.append(var_11)\nvar_10 = []\nfor var_5 in range(var_8):\n var_10.append(list(map(int, input().split())))\nvar_1 = -(10**12)\nfor var_5 in range(1, 1 << 10):\n var_11 = 0\n for var_6 in range(var_8):\n var_3 = list(bin(var_4[var_6] & var_5)[2:])\n var_2 = 0\n for var_7 in var_3:\n if var_7 == \"1\":\n var_2 += 1\n var_11 += var_10[var_6][var_2]\n var_1 = max(var_1, var_11)\nprint(var_1)\n```", "output": "SLOWER 2.3449", "pair_id": "python_p03503_pair0047_reversed", "problem_id": "p03503", "language": "python", "direction": "reversed", "speedup_ratio": 5.0801} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nfrom sys import stdin\n\n\ndef func_1():\n\n var_11 = stdin.readline\n var_2 = int(var_11())\n var_1 = []\n for var_6 in range(var_2):\n var_5 = int(\"\".join(var_11().strip().split(\" \")), 2)\n var_1.append(var_5)\n var_3 = []\n for var_6 in range(var_2):\n var_10 = list(map(int, var_11().split()))\n var_3.append(var_10)\n var_8 = float(\"-inf\")\n for var_9 in range(1, 1 << 10):\n var_12 = 0\n for var_7 in range(var_2):\n var_4 = bin(var_9 & var_1[var_7]).count(\"1\")\n var_12 += var_3[var_7][var_4]\n var_8 = max(var_12, var_8)\n print(var_8)\n\n\nif __name__ == \"__main__\":\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nvar_8 = int(eval(input()))\nvar_4 = []\nfor var_5 in range(var_8):\n var_11 = 0\n var_9 = list(map(int, input().split()))\n for var_6 in range(10):\n var_11 += var_9[var_6] << var_6\n var_4.append(var_11)\nvar_10 = []\nfor var_5 in range(var_8):\n var_10.append(list(map(int, input().split())))\nvar_1 = -(10**12)\nfor var_5 in range(1, 1 << 10):\n var_11 = 0\n for var_6 in range(var_8):\n var_3 = var_4[var_6] & var_5\n var_2 = 0\n for var_7 in range(10):\n if (var_3 >> var_7) % 2:\n var_2 += 1\n var_11 += var_10[var_6][var_2]\n var_1 = max(var_1, var_11)\nprint(var_1)\n```", "output": "SLOWER 2.7133", "pair_id": "python_p03503_pair0049_reversed", "problem_id": "p03503", "language": "python", "direction": "reversed", "speedup_ratio": 6.558} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n if list(str(var_4)) == list(reversed(str(var_4))):\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_4 = [\n var_3 for var_3 in map(str, list(range(var_1, var_2 + 1))) if var_3 == var_3[::-1]\n]\nprint((len(var_4)))\n```", "output": "FASTER 2.0989", "pair_id": "python_p03416_pair0252_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 4.2839} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_2, var_1 = list(map(int, input().split()))\nvar_3 = 0\nvar_8 = 0\nvar_4 = [0] * (var_2 + 1)\nvar_9 = [0] * (var_2 + 1)\nfor var_5 in range(var_1):\n var_6, var_7 = input().split()\n var_6 = int(var_6)\n if var_7 == \"AC\":\n if var_4[var_6] == 0:\n var_3 += 1\n var_8 += var_9[var_6]\n var_4[var_6] = 1\n else:\n var_9[var_6] += 1\nprint((var_3, var_8))\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\n\nvar_2, var_1, *var_3 = sys.stdin.read().strip().split()\nvar_2 = int(var_2)\nvar_5 = [0] * var_2\nvar_10 = [0] * var_2\nfor var_6, var_8 in zip(*[iter(var_3)] * 2):\n var_6 = int(var_6) - 1\n if var_8 == \"AC\":\n var_5[var_6] = 1\n elif var_5[var_6] == 0:\n var_10[var_6] += 1\nvar_7 = sum([var_9 * var_4 for var_4, var_9 in zip(var_5, var_10)])\nprint((\"{} {}\".format(sum(var_5), var_7)))\n```", "output": "SLOWER 2.9476", "pair_id": "python_p02802_pair0013_reversed", "problem_id": "p02802", "language": "python", "direction": "reversed", "speedup_ratio": 7.7147} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\nimport math\nfrom collections import defaultdict\nfrom bisect import bisect_left, bisect_right\n\nsys.setrecursionlimit(10**7)\n\n\ndef func_4():\n return sys.stdin.readline()[:-1]\n\n\nvar_4 = 10**9 + 7\n\n\ndef func_1():\n return int(eval(func_4()))\n\n\ndef func_2():\n return list(map(int, func_4().split()))\n\n\ndef func_3(var_6, var_3):\n if var_6 <= 0:\n return [[] for _ in range(var_3)]\n elif var_3 == 1:\n return [func_1() for _ in range(var_6)]\n else:\n var_5 = [func_2() for _ in range(var_6)]\n return list(map(list, list(zip(*var_5))))\n\n\nvar_1, var_2 = list(map(str, func_4().split()))\nvar_1 = int(var_1)\nvar_2 = 100 * int(var_2[0]) + 10 * int(var_2[2]) + int(var_2[3])\nprint((var_1 * var_2 // 100))\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = input().split()\nvar_1 = int(var_1)\nvar_2 = int(var_2.replace(\".\", \"\"))\nprint((var_1 * var_2 // 100))\n```", "output": "FASTER 2.5828", "pair_id": "python_p02659_pair0018_forward", "problem_id": "p02659", "language": "python", "direction": "forward", "speedup_ratio": 5.9911} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(int, input().rstrip().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_5 = list(map(int, list(str(var_4))))\n if var_5[0] == var_5[4] and var_5[1] == var_5[3]:\n var_3 += 1\nprint(var_3)\n```\n\n=== Code B (Modified) ===\n```python\nvar_1, var_2 = list(map(int, input().split()))\nvar_3 = 0\nfor var_4 in range(var_1, var_2 + 1):\n var_6 = str(var_4)\n var_5 = var_6[::-1]\n if var_6 == var_5:\n var_3 += 1\nprint(var_3)\n```", "output": "FASTER 1.4326", "pair_id": "python_p03416_pair0237_forward", "problem_id": "p03416", "language": "python", "direction": "forward", "speedup_ratio": 2.6994} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nvar_1, var_2 = list(map(str, input().split()))\nvar_1 = int(var_1)\nvar_2 = int(float(var_2) * 1000)\nprint((var_1 * var_2 // 1000))\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\nimport math\nfrom collections import defaultdict\nfrom bisect import bisect_left, bisect_right\n\nsys.setrecursionlimit(10**7)\n\n\ndef func_4():\n return sys.stdin.readline()[:-1]\n\n\nvar_4 = 10**9 + 7\n\n\ndef func_1():\n return int(eval(func_4()))\n\n\ndef func_2():\n return list(map(int, func_4().split()))\n\n\ndef func_3(var_6, var_3):\n if var_6 <= 0:\n return [[] for _ in range(var_3)]\n elif var_3 == 1:\n return [func_1() for _ in range(var_6)]\n else:\n var_5 = [func_2() for _ in range(var_6)]\n return list(map(list, list(zip(*var_5))))\n\n\nfrom decimal import getcontext, Decimal\n\ngetcontext().prec = 28\nvar_1, var_2 = list(map(str, func_4().split()))\nvar_1 = int(var_1)\nvar_2 = Decimal(var_2)\nprint((int(var_1 * var_2)))\n```", "output": "SLOWER 2.3054", "pair_id": "python_p02659_pair0059_reversed", "problem_id": "p02659", "language": "python", "direction": "reversed", "speedup_ratio": 4.9432} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\ndef func_1():\n var_1, var_3 = input().split()\n var_1 = int(var_1)\n var_3 = int(float(var_3) * 100 + 0.5)\n var_2 = var_1 * var_3\n print((var_2 // 100))\n\n\nif __name__ == \"__main__\":\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\ndef func_1():\n from sys import setrecursionlimit, stdin\n from os import environ\n from collections import defaultdict, deque, Counter\n from math import ceil, floor, gcd\n from itertools import accumulate, combinations, combinations_with_replacement\n\n setrecursionlimit(10**6)\n var_7 = (\n (lambda *var_11: print(*var_11))\n if \"TERM_PROGRAM\" in environ\n else lambda *var_12: 0\n )\n var_8 = lambda: stdin.readline().rstrip()\n var_3 = lambda: list(map(int, var_8().split()))\n var_1 = lambda: int(var_8())\n var_4 = 10**9 + 7\n var_2 = 10**9 + 10\n var_9, var_10 = var_8().split()\n var_5 = int(var_9)\n var_6 = int(float(var_10) * 100 + 0.5)\n print(var_5 * var_6 // 100)\n\n\nfunc_1()\n```", "output": "SLOWER 1.575", "pair_id": "python_p02659_pair0045_reversed", "problem_id": "p02659", "language": "python", "direction": "reversed", "speedup_ratio": 2.9793} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nfrom sys import stdin\n\n\ndef func_1():\n\n var_9 = stdin.readline\n var_8, var_10 = list(map(int, var_9().split()))\n var_7 = [list(map(int, var_9().split())) for _ in range(var_8)]\n var_7.sort()\n var_1 = [0] * var_8\n var_2 = [0] * var_8\n for var_4 in range(var_8):\n var_1[var_4], var_2[var_4] = var_7[var_4][0], var_7[var_4][1]\n\n var_5 = -(10**9)\n var_3 = [[var_5] * (var_10 + 1) for _ in range(var_8 + 1)]\n var_3[0][0] = 0\n for var_4 in range(var_8):\n for var_6 in range(var_10 + 1):\n\n if var_6 != var_10:\n var_3[var_4 + 1][min(var_10, var_6 + var_1[var_4])] = max(\n var_3[var_4 + 1][min(var_10, var_6 + var_1[var_4])],\n var_3[var_4][var_6] + var_2[var_4],\n )\n\n var_3[var_4 + 1][var_6] = max(var_3[var_4 + 1][var_6], var_3[var_4][var_6])\n print((max(var_3[var_8])))\n\n\nif __name__ == \"__main__\":\n func_1()\n```\n\n=== Code B (Modified) ===\n```python\nfrom collections import Counter, defaultdict, deque\nfrom heapq import heappop, heappush, heapify\nimport sys, bisect, math, itertools, fractions, pprint\n\nsys.setrecursionlimit(10**8)\nvar_6 = 10**9 + 7\nvar_1 = float(\"inf\")\n\n\ndef func_1():\n return int(sys.stdin.readline())\n\n\ndef func_2():\n return list(map(int, sys.stdin.readline().split()))\n\n\nvar_8, var_11 = func_2()\nvar_17 = [func_2() for _ in range(var_8)]\nvar_10 = var_17[::-1]\nvar_14 = [[0] * var_11 for _ in range(var_8)]\nvar_3 = [[0] * var_11 for _ in range(var_8)]\nfor var_4 in range(var_8 - 1):\n var_16, var_15 = var_17[var_4]\n for var_5 in range(var_11):\n if var_5 < var_16:\n var_14[var_4 + 1][var_5] = var_14[var_4][var_5]\n else:\n var_14[var_4 + 1][var_5] = max(\n var_14[var_4][var_5], var_14[var_4][var_5 - var_16] + var_15\n )\nvar_9 = var_14[var_8 - 1][var_11 - 1] + var_17[var_8 - 1][1]\nfor var_4 in range(var_8 - 1):\n var_16, var_15 = var_10[var_4]\n for var_5 in range(var_11):\n if var_5 < var_16:\n var_3[var_4 + 1][var_5] = var_3[var_4][var_5]\n else:\n var_3[var_4 + 1][var_5] = max(\n var_3[var_4][var_5], var_3[var_4][var_5 - var_16] + var_15\n )\n var_9 = max(var_9, var_3[var_8 - 1][var_11 - 1] + var_17[0][1])\n\nfor var_4 in range(1, var_8 - 1):\n var_13 = var_4\n var_2 = var_8 - var_4 - 1\n var_7 = 0\n for var_5 in range(var_11):\n var_12 = var_14[var_13][var_5] + var_3[var_2][var_11 - 1 - var_5]\n var_7 = max(var_7, var_12)\n var_9 = max(var_9, var_7 + var_17[var_4][1])\nprint(var_9)\n```", "output": "SLOWER 1.1031", "pair_id": "python_p02863_pair0049_reversed", "problem_id": "p02863", "language": "python", "direction": "reversed", "speedup_ratio": 2.1481} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nimport sys\n\nvar_10 = sys.stdin.readline\nvar_2, var_3 = list(map(int, var_10().split()))\nvar_1 = [list(map(int, var_10().split())) for _ in range(var_2)]\nvar_8 = [[0 for _ in range(var_2 + 1)] for _ in range(var_3 + 1)]\n\nvar_13 = [[0 for _ in range(var_2 + 1)] for _ in range(var_3 + 1)]\nfor var_11 in range(var_2):\n var_4, var_6 = var_1[var_11]\n for var_15 in range(var_3):\n if var_4 > var_15:\n var_8[var_15][var_11 + 1] = var_8[var_15][var_11]\n var_13[var_15][var_11 + 1] = var_15\n else:\n if var_6 + var_8[var_15 - var_4][var_11] >= var_8[var_15][var_11]:\n var_8[var_15][var_11 + 1] = var_8[var_15 - var_4][var_11] + var_6\n var_13[var_15][var_11 + 1] = var_15 - var_4\n else:\n var_8[var_15][var_11 + 1] = var_8[var_15][var_11]\n var_13[var_15][var_11 + 1] = var_15\nvar_5 = var_8[var_3 - 1][var_2]\nvar_14 = [False] * var_2\nvar_7 = var_3 - 1\nfor var_9 in reversed(list(range(var_2))):\n if var_13[var_7][var_9 + 1] == var_7 - var_1[var_9][0]:\n var_14[var_9] = True\n var_7 = var_13[var_7][var_9 + 1]\nvar_12 = 0\nfor var_9 in range(var_2):\n if not var_14[var_9] and var_1[var_9][1] > var_12:\n var_12 = var_1[var_9][1]\nprint((var_5 + var_12))\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\nfrom operator import itemgetter\nfrom heapq import heapify, heappop, heappush\n\nvar_1 = int(10e15)\nvar_2 = -var_1\nvar_11 = 1000000007\nsys.setrecursionlimit(1000000)\n\n\ndef func_2():\n return list(map(int, input().split()))\n\n\ndef func_4():\n return input().split()\n\n\ndef func_1():\n return int(sys.stdin.readline())\n\n\ndef func_3():\n return eval(input())\n\n\nvar_3, var_4 = func_2()\nvar_5 = [func_2() for var_9 in range(var_3)]\nvar_5.sort(key=itemgetter(0))\n\nvar_8 = [[0] * (var_4 + 1 + 3000 + 1) for _ in range(var_3 + 1)]\nvar_6 = 0\nfor var_9 in range(var_3):\n for var_10 in range(var_4 + 1 + 3000 + 1):\n var_12, var_7 = var_5[var_9]\n if 0 <= var_10 - var_12 < var_4:\n var_8[var_9 + 1][var_10] = max(\n var_8[var_9][var_10], var_8[var_9][var_10 - var_12] + var_7\n )\n else:\n var_8[var_9 + 1][var_10] = var_8[var_9][var_10]\n var_6 = max(var_6, var_8[var_9 + 1][var_10])\nprint(var_6)\n```", "output": "SLOWER 4.3309", "pair_id": "python_p02863_pair0062_reversed", "problem_id": "p02863", "language": "python", "direction": "reversed", "speedup_ratio": 20.1241} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\n\"\"\"\"\"\"\n\nfrom collections import deque\n\n\ndef func_1():\n var_5, *var_1 = list(map(int, open(0).read().split()))\n var_2 = var_1[1::2]\n var_4 = [[] for _ in range(var_5 + 1)]\n for var_7, var_8 in zip(*[iter(var_1)] * 2):\n var_4[var_7] += (var_8,)\n var_6 = deque([1])\n var_3 = [0] * (var_5 + 1)\n while var_6:\n var_11 = var_6.popleft()\n var_9 = 0\n for var_10 in var_4[var_11]:\n var_9 += 1 + (var_9 + 1 == var_3[var_11])\n var_3[var_10] = var_9\n var_6 += (var_10,)\n print((max(var_3)))\n for var_8 in var_2:\n print((var_3[var_8]))\n\n\nfunc_1()\n```\n\n=== Code B (Modified) ===\n```python\nvar_11 = int(eval(input()))\nvar_12 = {var_8: [] for var_8 in range(1, var_11 + 1)}\nvar_19 = [False for var_8 in range(var_11 + 1)]\nvar_16 = []\nfor _ in range(var_11 - 1):\n var_2, var_3 = list(map(int, input().split()))\n var_12[var_2].append(var_3)\n var_12[var_3].append(var_2)\n var_16.append((var_2, var_3))\nvar_9 = var_16[0][0]\nvar_19[var_9] = True\nvar_6 = []\nvar_7 = []\nvar_14 = {var_8: {} for var_8 in range(1, var_11 + 1)}\nvar_10 = [0 for var_8 in range(var_11 + 1)]\n\nvar_4 = 1\nfor var_5 in var_12[var_9]:\n var_19[var_5] = True\n var_14[var_9][var_5] = var_4\n var_14[var_5][var_9] = var_4\n var_10[var_5] = var_4\n var_4 += 1\n var_6.append(var_5)\nwhile var_6:\n for var_15 in var_6:\n var_13 = 1\n for var_5 in var_12[var_15]:\n if var_19[var_5] == False:\n var_19[var_5] = True\n if var_13 != var_10[var_15]:\n var_14[var_15][var_5] = var_13\n var_14[var_5][var_15] = var_13\n var_10[var_5] = var_13\n var_13 += 1\n var_7.append(var_5)\n else:\n var_13 += 1\n var_14[var_15][var_5] = var_13\n var_14[var_5][var_15] = var_13\n var_10[var_5] = var_13\n var_13 += 1\n var_7.append(var_5)\n if var_7:\n var_6 = var_7\n var_7 = []\n else:\n var_6 = []\n var_7 = []\nvar_1 = 0\nfor var_8 in range(1, var_11 + 1):\n var_1 = max(var_1, len(var_12[var_8]))\nprint(var_1)\nfor var_8 in range(var_11 - 1):\n var_17, var_18 = var_16[var_8][0], var_16[var_8][1]\n print((var_14[var_17][var_18]))\n```", "output": "SLOWER 1.0038", "pair_id": "python_p02850_pair0002_reversed", "problem_id": "p02850", "language": "python", "direction": "reversed", "speedup_ratio": 2.0053} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\nfrom functools import *\n\n_, var_1 = open(0)\nprint(\n (\n \"YNeos\"[\n var_2(lambda var_3, var_4: var_3 ^ var_4, list(map(int, var_1.split())))\n > 0 :: 2\n ]\n )\n)\n```\n\n=== Code B (Modified) ===\n```python\ndef func_1():\n from collections import Counter\n\n var_4 = int(eval(input()))\n (*var_1,) = list(map(int, input().split()))\n if var_4 % 3 == 0:\n var_2 = Counter(var_1)\n if len(var_2) == 1:\n print((\"Yes\" if 0 in var_2 else \"No\"))\n return\n elif len(var_2) == 2:\n print((\"Yes\" if var_2[0] == var_4 // 3 else \"No\"))\n return\n elif len(var_2) == 3:\n var_7 = 0\n var_5 = None\n for var_3, var_6 in list(var_2.items()):\n if var_5 is None:\n var_5 = var_6\n elif var_5 != var_6:\n print(\"No\")\n return\n var_7 ^= var_3\n print((\"Yes\" if var_7 == 0 else \"No\"))\n return\n else:\n print(\"No\")\n return\n else:\n print((\"Yes\" if all([var_7 == 0 for var_7 in var_1]) else \"No\"))\n return\n\n\nif __name__ == \"__main__\":\n func_1()\n```", "output": "SLOWER 1.4188", "pair_id": "python_p02975_pair0004_reversed", "problem_id": "p02975", "language": "python", "direction": "reversed", "speedup_ratio": 2.6736} +{"instruction": "You are a code performance analysis expert. Given an original code and a modified version, predict the performance change.\n\nAnalyze both code versions and determine:\n- FASTER: The modified code is faster than the original\n- SLOWER: The modified code is slower than the original\n\nOutput format: [direction] [log2(speedup)]\n\nExample outputs:\n- \"FASTER 2.5\" means approximately 5.7x faster (2^2.5)\n- \"SLOWER 1.5\" means approximately 2.8x slower (2^1.5)", "input": "=== Code A (Original) ===\n```python\ndef func_1():\n from sys import setrecursionlimit, stdin\n from os import environ\n from collections import defaultdict, deque, Counter\n from math import ceil, floor, gcd\n from itertools import accumulate, combinations, combinations_with_replacement\n\n setrecursionlimit(10**6)\n var_7 = (\n (lambda *var_11: print(*var_11))\n if \"TERM_PROGRAM\" in environ\n else lambda *var_12: 0\n )\n var_8 = lambda: stdin.readline().rstrip()\n var_3 = lambda: list(map(int, var_8().split()))\n var_1 = lambda: int(var_8())\n var_4 = 10**9 + 7\n var_2 = 10**9 + 10\n var_9, var_10 = var_8().split()\n var_5 = int(var_9)\n var_6 = int(float(var_10) * 100 + 0.5)\n print(var_5 * var_6 // 100)\n\n\nfunc_1()\n```\n\n=== Code B (Modified) ===\n```python\nimport sys\n\nvar_3 = sys.stdin.readline\nif __name__ == \"__main__\":\n var_1, var_2 = var_3().split()\n print((int(var_1) * round(float(var_2) * 100) // 100))\n```", "output": "FASTER 1.9665", "pair_id": "python_p02659_pair0064_forward", "problem_id": "p02659", "language": "python", "direction": "forward", "speedup_ratio": 3.9083}