Datasets:

---

codefuse-ai

/

GALLa

like 1

Follow

CodeFuse AI 144

[ 7, 0, 13, 4, 13, 13, 4, 18, 4, 18, 4, 13, 17, 13, 13, 13, 13, 13, 0, 13, 2, 2, 17, 17, 17, 0, 13, 2, 39, 17, 2, 2, 13, 13, 17, 0, 13, 2, 39, 17, 2, 2, 13, 13, 17, 28, 13, 4, 13, 2, 13, 13, 0, 18, 13, 2, 13, 17, 2, 2, 18, 13, 13, 2, 13, 17, 13, 28, 13, 4, 13, 2, 13, 13, 0, 18, 13, 2, 13, 17, 2, 2, 18, 13, 13, 4, 13, 2, 13, 17, 2, 13, 17, 13, 13, 12, 13, 29, 2, 2, 2, 2, 18, 13, 13, 18, 13, 13, 13, 18, 13, 2, 13, 13, 13, 23, 13, 23, 13, 23, 13, 0, 13, 17, 28, 13, 4, 13, 13, 13, 0, 13, 2, 2, 4, 13, 2, 2, 2, 13, 13, 17, 13, 13, 13, 4, 13, 2, 2, 2, 2, 13, 17, 13, 17, 13, 2, 2, 13, 17, 13, 13, 13, 0, 13, 13, 4, 13, 13, 10, 4, 13, 10, 4, 13, 10, 17, 13, 10, 4, 13, 10, 13, 13, 10, 2, 13, 10, 4, 13, 10, 2, 13, 10, 2, 13, 10, 2, 13, 10, 12, 13 ]

[ [ 188, 2 ], [ 188, 15 ], [ 188, 16 ], [ 188, 17 ], [ 185, 19 ], [ 197, 26 ], [ 174, 32 ], [ 171, 33 ], [ 191, 36 ], [ 174, 42 ], [ 171, 43 ], [ 47, 46 ], [ 174, 50 ], [ 171, 51 ], [ 58, 53 ], [ 198, 54 ], [ 46, 56 ], [ 198, 61 ], [ 46, 62 ], [ 46, 64 ], [ 186, 66 ], [ 69, 68 ], [ 174, 72 ], [ 171, 73 ], [ 80, 75 ], [ 192, 76 ], [ 68, 78 ], [ 192, 83 ], [ 68, 84 ], [ 68, 88 ], [ 186, 91 ], [ 186, 93 ], [ 186, 94 ], [ 198, 103 ], [ 116, 104 ], [ 192, 106 ], [ 118, 107 ], [ 186, 108 ], [ 192, 110 ], [ 116, 112 ], [ 118, 113 ], [ 186, 114 ], [ 116, 116 ], [ 118, 118 ], [ 120, 120 ], [ 176, 122 ], [ 126, 125 ], [ 189, 128 ], [ 171, 129 ], [ 194, 131 ], [ 201, 135 ], [ 174, 139 ], [ 180, 140 ], [ 125, 142 ], [ 125, 143 ], [ 186, 144 ], [ 201, 146 ], [ 180, 151 ], [ 171, 153 ], [ 125, 155 ], [ 171, 158 ], [ 125, 160 ], [ 186, 161 ], [ 186, 162 ], [ 182, 164 ], [ 186, 165 ], [ 183, 168 ], [ 195, 168 ], [ 177, 168 ], [ 188, 171 ], [ 188, 174 ], [ 176, 177 ], [ 188, 180 ], [ 186, 182 ], [ 182, 183 ], [ 185, 186 ], [ 188, 189 ], [ 191, 192 ], [ 194, 195 ], [ 197, 198 ] ]

[ "H, W, A, B = map(int, open(0).read().split())\nMOD = 10**9+7\n \nfactorials = [1] * (H + W + 1)\ninv_factorials = [1] * (H + W + 1)\n \nfor i in range(H + W):\n factorials[i+1] = factorials[i] * (i + 1) % MOD\n\nfor i in range(H + W):\n inv_factorials[i+1] = inv_factorials[i] * pow(i + 1, MOD - 2, MOD) % MOD\n\ndef modcomb(m, n, mod):\n return factorials[m] * inv_factorials[n] % MOD * inv_factorials[m - n] % MOD\n \n# total = modcomb(H + W - 2, W - 1, MOD)\ntotal = 0\n \n# for i in range(B):\nfor i in range(B, W):\n total += modcomb(H - A - 1 + i, i, MOD) * modcomb(A - 1 + W - 1 - i, W - 1 - i, MOD) % MOD\n total %= MOD\n\nprint(total)", "H, W, A, B = map(int, open(0).read().split())", "H", "map(int, open(0).read().split())", "map", "int", "open(0).read().split()", "(0).read().split", "(0).read()", "(0).read", "(0)", "open", "0", "read", "split", "W", "A", "B", "MOD = 10**9+7", "MOD", "10**9+7", "10**9", "10", "9", "7", "factorials = [1] * (H + W + 1)", "factorials", "[1] * (H + W + 1)", "[1]", "1", "H + W + 1", "H + W", "H", "W", "1", "inv_factorials = [1] * (H + W + 1)", "inv_factorials", "[1] * (H + W + 1)", "[1]", "1", "H + W + 1", "H + W", "H", "W", "1", "for i in range(H + W):\n factorials[i+1] = factorials[i] * (i + 1) % MOD", "i", "range(H + W)", "range", "H + W", "H", "W", "factorials[i+1] = factorials[i] * (i + 1) % MOD", "factorials[i+1]", "factorials", "i+1", "i", "1", "factorials[i] * (i + 1) % MOD", "factorials[i] * (i + 1)", "factorials[i]", "factorials", "i", "i + 1", "i", "1", "MOD", "for i in range(H + W):\n inv_factorials[i+1] = inv_factorials[i] * pow(i + 1, MOD - 2, MOD) % MOD", "i", "range(H + W)", "range", "H + W", "H", "W", "inv_factorials[i+1] = inv_factorials[i] * pow(i + 1, MOD - 2, MOD) % MOD", "inv_factorials[i+1]", "inv_factorials", "i+1", "i", "1", "inv_factorials[i] * pow(i + 1, MOD - 2, MOD) % MOD", "inv_factorials[i] * pow(i + 1, MOD - 2, MOD)", "inv_factorials[i]", "inv_factorials", "i", "pow(i + 1, MOD - 2, MOD)", "pow", "i + 1", "i", "1", "MOD - 2", "MOD", "2", "MOD", "MOD", "def modcomb(m, n, mod):\n return factorials[m] * inv_factorials[n] % MOD * inv_factorials[m - n] % MOD\n \n# total = modcomb(H + W - 2, W - 1, MOD)", "modcomb", "return factorials[m] * inv_factorials[n] % MOD * inv_factorials[m - n] % MOD", "factorials[m] * inv_factorials[n] % MOD * inv_factorials[m - n] % MOD", "factorials[m] * inv_factorials[n] % MOD * inv_factorials[m - n]", "factorials[m] * inv_factorials[n] % MOD", "factorials[m] * inv_factorials[n]", "factorials[m]", "factorials", "m", "inv_factorials[n]", "inv_factorials", "n", "MOD", "inv_factorials[m - n]", "inv_factorials", "m - n", "m", "n", "MOD", "m", "m", "n", "n", "mod", "mod", "total = 0", "total", "0", "for i in range(B, W):\n total += modcomb(H - A - 1 + i, i, MOD) * modcomb(A - 1 + W - 1 - i, W - 1 - i, MOD) % MOD\n total %= MOD", "i", "range(B, W)", "range", "B", "W", "total += modcomb(H - A - 1 + i, i, MOD) * modcomb(A - 1 + W - 1 - i, W - 1 - i, MOD) % MOD", "total", "modcomb(H - A - 1 + i, i, MOD) * modcomb(A - 1 + W - 1 - i, W - 1 - i, MOD) % MOD", "modcomb(H - A - 1 + i, i, MOD) * modcomb(A - 1 + W - 1 - i, W - 1 - i, MOD)", "modcomb(H - A - 1 + i, i, MOD)", "modcomb", "H - A - 1 + i", "H - A - 1", "H - A", "H", "A", "1", "i", "i", "MOD", "modcomb(A - 1 + W - 1 - i, W - 1 - i, MOD)", "modcomb", "A - 1 + W - 1 - i", "A - 1 + W - 1", "A - 1 + W", "A - 1", "A", "1", "W", "1", "i", "W - 1 - i", "W - 1", "W", "1", "i", "MOD", "MOD", "total %= MOD", "total", "MOD", "print(total)", "print", "total", "W, A, B = map(int, open(0).read().split())", "map(int, open(0).read().split())", "W", "H, W, A, B = map(int, open(0).read().split())", "map(int, open(0).read().split())", "H", "total = 0", "0", "total", "A, B = map(int, open(0).read().split())", "map(int, open(0).read().split())", "A", "total %= MOD", "MOD", "total", "MOD = 10**9+7", "10**9+7", "MOD", "B = map(int, open(0).read().split())", "map(int, open(0).read().split())", "B", "inv_factorials = [1] * (H + W + 1)", "[1] * (H + W + 1)", "inv_factorials", "total += modcomb(H - A - 1 + i, i, MOD) * modcomb(A - 1 + W - 1 - i, W - 1 - i, MOD) % MOD", "modcomb(H - A - 1 + i, i, MOD) * modcomb(A - 1 + W - 1 - i, W - 1 - i, MOD) % MOD", "total", "factorials = [1] * (H + W + 1)", "[1] * (H + W + 1)", "factorials", "def modcomb(m, n, mod):\n return factorials[m] * inv_factorials[n] % MOD * inv_factorials[m - n] % MOD\n \n# total = modcomb(H + W - 2, W - 1, MOD)", "def modcomb(m, n, mod):\n return factorials[m] * inv_factorials[n] % MOD * inv_factorials[m - n] % MOD\n \n# total = modcomb(H + W - 2, W - 1, MOD)", "modcomb" ]

[ 7, 12, 13, 41, 28, 13, 4, 18, 4, 13, 13, 4, 4, 13, 13, 0, 13, 13, 13, 13, 13, 0, 13, 2, 2, 13, 13, 17, 0, 13, 2, 2, 17, 17, 17, 0, 13, 2, 39, 17, 13, 0, 13, 2, 39, 17, 13, 0, 13, 2, 39, 17, 13, 12, 13, 0, 18, 13, 17, 17, 0, 18, 13, 17, 17, 14, 2, 13, 17, 0, 18, 13, 17, 17, 0, 18, 13, 17, 17, 0, 18, 13, 17, 17, 28, 13, 4, 13, 17, 13, 0, 18, 13, 13, 2, 2, 18, 13, 2, 13, 17, 13, 13, 0, 18, 13, 13, 2, 13, 2, 2, 18, 13, 2, 13, 13, 2, 13, 13, 13, 0, 18, 13, 13, 2, 2, 18, 13, 2, 13, 17, 18, 13, 13, 13, 23, 13, 12, 13, 14, 2, 13, 13, 29, 17, 14, 2, 2, 13, 17, 2, 13, 17, 29, 17, 29, 2, 2, 18, 13, 13, 2, 2, 18, 13, 13, 18, 13, 2, 13, 13, 13, 13, 23, 13, 23, 13, 4, 13, 13, 0, 13, 17, 28, 13, 4, 13, 2, 13, 13, 14, 2, 13, 17, 0, 13, 4, 13, 2, 2, 2, 2, 13, 13, 17, 13, 13, 2, 13, 13, 0, 13, 2, 4, 13, 2, 2, 2, 2, 13, 13, 17, 13, 13, 2, 13, 13, 4, 13, 2, 2, 2, 2, 2, 13, 13, 17, 13, 13, 17, 2, 2, 13, 13, 17, 0, 13, 4, 13, 2, 2, 2, 2, 13, 13, 17, 13, 13, 13, 0, 13, 2, 13, 13, 0, 13, 13, 4, 13, 2, 13, 13, 14, 2, 13, 17, 4, 13, 10, 12, 13 ]

[ [ 6, 5 ], [ 5, 14 ], [ 17, 16 ], [ 17, 18 ], [ 17, 19 ], [ 17, 20 ], [ 23, 22 ], [ 16, 25 ], [ 18, 26 ], [ 30, 29 ], [ 37, 36 ], [ 22, 40 ], [ 43, 42 ], [ 22, 46 ], [ 49, 48 ], [ 22, 52 ], [ 59, 56 ], [ 36, 57 ], [ 64, 61 ], [ 42, 62 ], [ 136, 67 ], [ 73, 70 ], [ 36, 71 ], [ 78, 75 ], [ 42, 76 ], [ 83, 80 ], [ 48, 81 ], [ 86, 85 ], [ 136, 89 ], [ 94, 91 ], [ 36, 92 ], [ 85, 93 ], [ 36, 97 ], [ 85, 99 ], [ 85, 101 ], [ 29, 102 ], [ 107, 104 ], [ 48, 105 ], [ 85, 106 ], [ 29, 108 ], [ 48, 112 ], [ 29, 114 ], [ 85, 115 ], [ 29, 117 ], [ 85, 118 ], [ 29, 119 ], [ 124, 121 ], [ 42, 122 ], [ 85, 123 ], [ 42, 127 ], [ 85, 129 ], [ 104, 131 ], [ 48, 132 ], [ 85, 133 ], [ 29, 134 ], [ 136, 136 ], [ 174, 141 ], [ 176, 142 ], [ 174, 148 ], [ 176, 151 ], [ 36, 159 ], [ 174, 160 ], [ 42, 164 ], [ 176, 165 ], [ 42, 167 ], [ 174, 169 ], [ 176, 170 ], [ 29, 171 ], [ 29, 172 ], [ 174, 174 ], [ 176, 176 ], [ 54, 178 ], [ 22, 179 ], [ 182, 181 ], [ 185, 184 ], [ 18, 188 ], [ 20, 189 ], [ 184, 192 ], [ 196, 195 ], [ 138, 197 ], [ 16, 202 ], [ 19, 203 ], [ 20, 205 ], [ 184, 206 ], [ 20, 208 ], [ 184, 209 ], [ 212, 211 ], [ 138, 214 ], [ 16, 219 ], [ 19, 220 ], [ 20, 222 ], [ 184, 223 ], [ 20, 225 ], [ 184, 226 ], [ 138, 228 ], [ 16, 234 ], [ 19, 235 ], [ 20, 237 ], [ 184, 238 ], [ 20, 242 ], [ 184, 243 ], [ 247, 246 ], [ 138, 248 ], [ 19, 253 ], [ 18, 254 ], [ 20, 256 ], [ 184, 257 ], [ 19, 258 ], [ 261, 260 ], [ 211, 262 ], [ 195, 262 ], [ 246, 263 ], [ 266, 265 ], [ 29, 266 ], [ 265, 270 ], [ 260, 270 ], [ 181, 270 ], [ 29, 271 ], [ 280, 277 ] ]

[ "def main():\n H, W, A, B = (int(i) for i in input().split())\n m = H + W + 3\n MOD = 10**9 + 7\n fac = [0] * m\n finv = [0] * m\n inv = [0] * m\n\n def COMBinitialize(m):\n fac[0] = 1\n finv[0] = 1\n if m > 1:\n fac[1] = 1\n finv[1] = 1\n inv[1] = 1\n for i in range(2, m):\n fac[i] = fac[i-1] * i % MOD\n inv[i] = MOD - inv[MOD % i] * (MOD // i) % MOD\n finv[i] = finv[i - 1] * inv[i] % MOD\n\n def COMB(n, k):\n if n < k:\n return 0\n if n < 0 or k < 0:\n return 0\n return fac[n] * (finv[k] * finv[n - k] % MOD) % MOD\n\n COMBinitialize(m)\n ans = 0\n for x in range(W-B):\n if x == 0:\n p = COMB(H-A-1 + B+x, B+x)\n else:\n p = COMB(H-A-1 + B+x, B+x) - COMB(H-A-1 + B+x-1, B+x-1)\n q = COMB(A+W-1-B-x, A)\n ans += p*q\n ans %= MOD\n print(ans % MOD)\n\n\nif __name__ == '__main__':\n main()", "def main():\n H, W, A, B = (int(i) for i in input().split())\n m = H + W + 3\n MOD = 10**9 + 7\n fac = [0] * m\n finv = [0] * m\n inv = [0] * m\n\n def COMBinitialize(m):\n fac[0] = 1\n finv[0] = 1\n if m > 1:\n fac[1] = 1\n finv[1] = 1\n inv[1] = 1\n for i in range(2, m):\n fac[i] = fac[i-1] * i % MOD\n inv[i] = MOD - inv[MOD % i] * (MOD // i) % MOD\n finv[i] = finv[i - 1] * inv[i] % MOD\n\n def COMB(n, k):\n if n < k:\n return 0\n if n < 0 or k < 0:\n return 0\n return fac[n] * (finv[k] * finv[n - k] % MOD) % MOD\n\n COMBinitialize(m)\n ans = 0\n for x in range(W-B):\n if x == 0:\n p = COMB(H-A-1 + B+x, B+x)\n else:\n p = COMB(H-A-1 + B+x, B+x) - COMB(H-A-1 + B+x-1, B+x-1)\n q = COMB(A+W-1-B-x, A)\n ans += p*q\n ans %= MOD\n print(ans % MOD)", "main", "int(i) for i in input().split()", "for i in input().split()", "i", "input().split()", "().split", "()", "input", "split", "for i in input().split()", "int(i)", "int", "i", "H, W, A, B = (int(i) for i in input().split())", "H", "(int(i) for i in input().split())", "W", "A", "B", "m = H + W + 3", "m", "H + W + 3", "H + W", "H", "W", "3", "MOD = 10**9 + 7", "MOD", "10**9 + 7", "10**9", "10", "9", "7", "fac = [0] * m", "fac", "[0] * m", "[0]", "0", "m", "finv = [0] * m", "finv", "[0] * m", "[0]", "0", "m", "inv = [0] * m", "inv", "[0] * m", "[0]", "0", "m", "def COMBinitialize(m):\n fac[0] = 1\n finv[0] = 1\n if m > 1:\n fac[1] = 1\n finv[1] = 1\n inv[1] = 1\n for i in range(2, m):\n fac[i] = fac[i-1] * i % MOD\n inv[i] = MOD - inv[MOD % i] * (MOD // i) % MOD\n finv[i] = finv[i - 1] * inv[i] % MOD\n\n ", "COMBinitialize", "fac[0] = 1", "fac[0]", "fac", "0", "1", "finv[0] = 1", "finv[0]", "finv", "0", "1", "if m > 1:\n fac[1] = 1\n finv[1] = 1\n inv[1] = 1\n for i in range(2, m):\n fac[i] = fac[i-1] * i % MOD\n inv[i] = MOD - inv[MOD % i] * (MOD // i) % MOD\n finv[i] = finv[i - 1] * inv[i] % MOD\n\n ", "m > 1", "m", "1", "fac[1] = 1", "fac[1]", "fac", "1", "1", "finv[1] = 1", "finv[1]", "finv", "1", "1", "inv[1] = 1", "inv[1]", "inv", "1", "1", "for i in range(2, m):\n fac[i] = fac[i-1] * i % MOD\n inv[i] = MOD - inv[MOD % i] * (MOD // i) % MOD\n finv[i] = finv[i - 1] * inv[i] % MOD\n\n ", "i", "range(2, m)", "range", "2", "m", "fac[i] = fac[i-1] * i % MOD", "fac[i]", "fac", "i", "fac[i-1] * i % MOD", "fac[i-1] * i", "fac[i-1]", "fac", "i-1", "i", "1", "i", "MOD", "inv[i] = MOD - inv[MOD % i] * (MOD // i) % MOD", "inv[i]", "inv", "i", "MOD - inv[MOD % i] * (MOD // i) % MOD", "MOD", "inv[MOD % i] * (MOD // i) % MOD", "inv[MOD % i] * (MOD // i)", "inv[MOD % i]", "inv", "MOD % i", "MOD", "i", "MOD // i", "MOD", "i", "MOD", "finv[i] = finv[i - 1] * inv[i] % MOD", "finv[i]", "finv", "i", "finv[i - 1] * inv[i] % MOD", "finv[i - 1] * inv[i]", "finv[i - 1]", "finv", "i - 1", "i", "1", "inv[i]", "inv", "i", "MOD", "m", "m", "def COMB(n, k):\n if n < k:\n return 0\n if n < 0 or k < 0:\n return 0\n return fac[n] * (finv[k] * finv[n - k] % MOD) % MOD\n\n ", "COMB", "if n < k:\n return 0\n ", "n < k", "n", "k", "return 0", "0", "if n < 0 or k < 0:\n return 0\n ", "n < 0 or k < 0", "n < 0", "n", "0", "k < 0", "k", "0", "return 0", "0", "return fac[n] * (finv[k] * finv[n - k] % MOD) % MOD", "fac[n] * (finv[k] * finv[n - k] % MOD) % MOD", "fac[n] * (finv[k] * finv[n - k] % MOD)", "fac[n]", "fac", "n", "finv[k] * finv[n - k] % MOD", "finv[k] * finv[n - k]", "finv[k]", "finv", "k", "finv[n - k]", "finv", "n - k", "n", "k", "MOD", "MOD", "n", "n", "k", "k", "COMBinitialize(m)", "COMBinitialize", "m", "ans = 0", "ans", "0", "for x in range(W-B):\n if x == 0:\n p = COMB(H-A-1 + B+x, B+x)\n else:\n p = COMB(H-A-1 + B+x, B+x) - COMB(H-A-1 + B+x-1, B+x-1)\n q = COMB(A+W-1-B-x, A)\n ans += p*q\n ans %= MOD\n ", "x", "range(W-B)", "range", "W-B", "W", "B", "if x == 0:\n p = COMB(H-A-1 + B+x, B+x)\n else:\n p = COMB(H-A-1 + B+x, B+x) - COMB(H-A-1 + B+x-1, B+x-1)\n ", "x == 0", "x", "0", "p = COMB(H-A-1 + B+x, B+x)", "p", "COMB(H-A-1 + B+x, B+x)", "COMB", "H-A-1 + B+x", "H-A-1 + B", "H-A-1", "H-A", "H", "A", "1", "B", "x", "B+x", "B", "x", "p = COMB(H-A-1 + B+x, B+x) - COMB(H-A-1 + B+x-1, B+x-1)", "p", "COMB(H-A-1 + B+x, B+x) - COMB(H-A-1 + B+x-1, B+x-1)", "COMB(H-A-1 + B+x, B+x)", "COMB", "H-A-1 + B+x", "H-A-1 + B", "H-A-1", "H-A", "H", "A", "1", "B", "x", "B+x", "B", "x", "COMB(H-A-1 + B+x-1, B+x-1)", "COMB", "H-A-1 + B+x-1", "H-A-1 + B+x", "H-A-1 + B", "H-A-1", "H-A", "H", "A", "1", "B", "x", "1", "B+x-1", "B+x", "B", "x", "1", "q = COMB(A+W-1-B-x, A)", "q", "COMB(A+W-1-B-x, A)", "COMB", "A+W-1-B-x", "A+W-1-B", "A+W-1", "A+W", "A", "W", "1", "B", "x", "A", "ans += p*q", "ans", "p*q", "p", "q", "ans %= MOD", "ans", "MOD", "print(ans % MOD)", "print", "ans % MOD", "ans", "MOD", "if __name__ == '__main__':\n main()", "__name__ == '__main__'", "__name__", "'__main__'", "main()", "main", "def main():\n H, W, A, B = (int(i) for i in input().split())\n m = H + W + 3\n MOD = 10**9 + 7\n fac = [0] * m\n finv = [0] * m\n inv = [0] * m\n\n def COMBinitialize(m):\n fac[0] = 1\n finv[0] = 1\n if m > 1:\n fac[1] = 1\n finv[1] = 1\n inv[1] = 1\n for i in range(2, m):\n fac[i] = fac[i-1] * i % MOD\n inv[i] = MOD - inv[MOD % i] * (MOD // i) % MOD\n finv[i] = finv[i - 1] * inv[i] % MOD\n\n def COMB(n, k):\n if n < k:\n return 0\n if n < 0 or k < 0:\n return 0\n return fac[n] * (finv[k] * finv[n - k] % MOD) % MOD\n\n COMBinitialize(m)\n ans = 0\n for x in range(W-B):\n if x == 0:\n p = COMB(H-A-1 + B+x, B+x)\n else:\n p = COMB(H-A-1 + B+x, B+x) - COMB(H-A-1 + B+x-1, B+x-1)\n q = COMB(A+W-1-B-x, A)\n ans += p*q\n ans %= MOD\n print(ans % MOD)", "def main():\n H, W, A, B = (int(i) for i in input().split())\n m = H + W + 3\n MOD = 10**9 + 7\n fac = [0] * m\n finv = [0] * m\n inv = [0] * m\n\n def COMBinitialize(m):\n fac[0] = 1\n finv[0] = 1\n if m > 1:\n fac[1] = 1\n finv[1] = 1\n inv[1] = 1\n for i in range(2, m):\n fac[i] = fac[i-1] * i % MOD\n inv[i] = MOD - inv[MOD % i] * (MOD // i) % MOD\n finv[i] = finv[i - 1] * inv[i] % MOD\n\n def COMB(n, k):\n if n < k:\n return 0\n if n < 0 or k < 0:\n return 0\n return fac[n] * (finv[k] * finv[n - k] % MOD) % MOD\n\n COMBinitialize(m)\n ans = 0\n for x in range(W-B):\n if x == 0:\n p = COMB(H-A-1 + B+x, B+x)\n else:\n p = COMB(H-A-1 + B+x, B+x) - COMB(H-A-1 + B+x-1, B+x-1)\n q = COMB(A+W-1-B-x, A)\n ans += p*q\n ans %= MOD\n print(ans % MOD)", "main" ]

[ 7, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 13, 13, 15, 13, 0, 13, 17, 0, 13, 2, 2, 17, 17, 17, 41, 28, 13, 4, 13, 17, 2, 2, 13, 13, 17, 4, 13, 0, 13, 13, 28, 13, 4, 13, 17, 2, 4, 13, 13, 17, 0, 18, 13, 2, 13, 17, 2, 2, 18, 13, 2, 13, 17, 18, 13, 13, 13, 0, 13, 2, 39, 17, 13, 41, 28, 13, 4, 13, 17, 4, 13, 13, 4, 4, 13, 18, 13, 13, 2, 13, 17, 13, 0, 13, 13, 0, 13, 2, 39, 17, 13, 28, 13, 4, 13, 17, 2, 2, 13, 13, 17, 0, 13, 2, 2, 2, 2, 2, 18, 13, 2, 2, 2, 2, 2, 13, 13, 17, 13, 13, 17, 18, 13, 2, 2, 2, 13, 2, 13, 13, 13, 17, 18, 13, 2, 2, 13, 13, 17, 18, 13, 2, 2, 13, 13, 17, 18, 13, 2, 13, 17, 18, 13, 2, 13, 2, 13, 13, 4, 13, 2, 4, 13, 13, 13, 10, 4, 13, 10, 17, 13, 10, 2, 13, 10, 2, 13, 10, 13, 13, 10, 13, 13, 10, 2, 13, 10, 4, 13, 10, 4, 13, 10, 4, 13, 10, 2, 13 ]

[ [ 205, 2 ], [ 205, 11 ], [ 205, 12 ], [ 205, 13 ], [ 181, 17 ], [ 187, 20 ], [ 29, 28 ], [ 206, 34 ], [ 203, 35 ], [ 28, 38 ], [ 190, 40 ], [ 44, 43 ], [ 191, 50 ], [ 58, 53 ], [ 191, 54 ], [ 43, 56 ], [ 191, 61 ], [ 43, 63 ], [ 191, 66 ], [ 43, 67 ], [ 188, 68 ], [ 208, 70 ], [ 191, 74 ], [ 78, 77 ], [ 209, 83 ], [ 191, 83 ], [ 209, 88 ], [ 191, 88 ], [ 77, 89 ], [ 188, 91 ], [ 188, 93 ], [ 193, 95 ], [ 196, 98 ], [ 194, 102 ], [ 105, 104 ], [ 203, 110 ], [ 179, 111 ], [ 184, 114 ], [ 209, 121 ], [ 191, 121 ], [ 206, 127 ], [ 200, 128 ], [ 179, 130 ], [ 104, 131 ], [ 209, 134 ], [ 191, 134 ], [ 203, 138 ], [ 179, 140 ], [ 104, 141 ], [ 200, 142 ], [ 197, 145 ], [ 194, 145 ], [ 206, 148 ], [ 200, 149 ], [ 197, 152 ], [ 194, 152 ], [ 179, 155 ], [ 104, 156 ], [ 197, 159 ], [ 194, 159 ], [ 200, 161 ], [ 197, 164 ], [ 194, 164 ], [ 203, 166 ], [ 179, 168 ], [ 104, 169 ], [ 185, 175 ], [ 182, 175 ], [ 188, 176 ], [ 205, 179 ], [ 181, 182 ], [ 184, 185 ], [ 187, 188 ], [ 190, 191 ], [ 193, 194 ], [ 196, 197 ], [ 205, 200 ], [ 205, 203 ], [ 205, 206 ], [ 208, 209 ] ]

[ "h,w,a,b = map(int, input().split())\nimport math\nans = 0\nmod = 10**9+7\nl =[i for i in range(1,h+w+2)]\nfor i in range(1,len(l)-1):\n l[i+1] = l[i+1]*l[i]%mod\nl = [1]+ l\ngyakugen = [pow(l[i], mod-2, mod) for i in range(1, len(l))]\ngyakugen = [1] + gyakugen\nfor p in range(1, w-b+1):\n ans += l[(h-a-1+b+p-1)]*l[w-(b+p)+a-1]*\\\n gyakugen[h-a-1]*gyakugen[b+p-1] * gyakugen[a-1]*gyakugen[w-(b+p)]\nprint(int(ans)%mod)", "h,w,a,b = map(int, input().split())", "h", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "w", "a", "b", "import math", "math", "ans = 0", "ans", "0", "mod = 10**9+7", "mod", "10**9+7", "10**9", "10", "9", "7", "i for i in range(1,h+w+2)", "for i in range(1,h+w+2)", "i", "range(1,h+w+2)", "range", "1", "h+w+2", "h+w", "h", "w", "2", "for i in range(1,h+w+2)", "i", "l =[i for i in range(1,h+w+2)]", "l", "[i for i in range(1,h+w+2)]", "for i in range(1,len(l)-1):\n l[i+1] = l[i+1]*l[i]%mod", "i", "range(1,len(l)-1)", "range", "1", "len(l)-1", "len(l)", "len", "l", "1", "l[i+1] = l[i+1]*l[i]%mod", "l[i+1]", "l", "i+1", "i", "1", "l[i+1]*l[i]%mod", "l[i+1]*l[i]", "l[i+1]", "l", "i+1", "i", "1", "l[i]", "l", "i", "mod", "l = [1]+ l", "l", "[1]+ l", "[1]", "1", "l", "pow(l[i], mod-2, mod) for i in range(1, len(l))", "for i in range(1, len(l))", "i", "range(1, len(l))", "range", "1", "len(l)", "len", "l", "for i in range(1, len(l))", "pow(l[i], mod-2, mod)", "pow", "l[i]", "l", "i", "mod-2", "mod", "2", "mod", "gyakugen = [pow(l[i], mod-2, mod) for i in range(1, len(l))]", "gyakugen", "[pow(l[i], mod-2, mod) for i in range(1, len(l))]", "gyakugen = [1] + gyakugen", "gyakugen", "[1] + gyakugen", "[1]", "1", "gyakugen", "for p in range(1, w-b+1):\n ans += l[(h-a-1+b+p-1)]*l[w-(b+p)+a-1]*\\\n gyakugen[h-a-1]*gyakugen[b+p-1] * gyakugen[a-1]*gyakugen[w-(b+p)]", "p", "range(1, w-b+1)", "range", "1", "w-b+1", "w-b", "w", "b", "1", "ans += l[(h-a-1+b+p-1)]*l[w-(b+p)+a-1]*\\\n gyakugen[h-a-1]*gyakugen[b+p-1] * gyakugen[a-1]*gyakugen[w-(b+p)]", "ans", "l[(h-a-1+b+p-1)]*l[w-(b+p)+a-1]*\\\n gyakugen[h-a-1]*gyakugen[b+p-1] * gyakugen[a-1]*gyakugen[w-(b+p)]", "l[(h-a-1+b+p-1)]*l[w-(b+p)+a-1]*\\\n gyakugen[h-a-1]*gyakugen[b+p-1] * gyakugen[a-1]", "l[(h-a-1+b+p-1)]*l[w-(b+p)+a-1]*\\\n gyakugen[h-a-1]*gyakugen[b+p-1]", "l[(h-a-1+b+p-1)]*l[w-(b+p)+a-1]*\\\n gyakugen[h-a-1]", "l[(h-a-1+b+p-1)]*l[w-(b+p)+a-1]", "l[(h-a-1+b+p-1)]", "l", "h-a-1+b+p-1", "h-a-1+b+p", "h-a-1+b", "h-a-1", "h-a", "h", "a", "1", "b", "p", "1", "l[w-(b+p)+a-1]", "l", "w-(b+p)+a-1", "w-(b+p)+a", "w-(b+p)", "w", "b+p", "b", "p", "a", "1", "gyakugen[h-a-1]", "gyakugen", "h-a-1", "h-a", "h", "a", "1", "gyakugen[b+p-1]", "gyakugen", "b+p-1", "b+p", "b", "p", "1", "gyakugen[a-1]", "gyakugen", "a-1", "a", "1", "gyakugen[w-(b+p)]", "gyakugen", "w-(b+p)", "w", "b+p", "b", "p", "print(int(ans)%mod)", "print", "int(ans)%mod", "int(ans)", "int", "ans", "mod", "b = map(int, input().split())", "map(int, input().split())", "b", "ans = 0", "0", "ans", "ans += l[(h-a-1+b+p-1)]*l[w-(b+p)+a-1]*\\\n gyakugen[h-a-1]*gyakugen[b+p-1] * gyakugen[a-1]*gyakugen[w-(b+p)]", "l[(h-a-1+b+p-1)]*l[w-(b+p)+a-1]*\\\n gyakugen[h-a-1]*gyakugen[b+p-1] * gyakugen[a-1]*gyakugen[w-(b+p)]", "ans", "mod = 10**9+7", "10**9+7", "mod", "l =[i for i in range(1,h+w+2)]", "[i for i in range(1,h+w+2)]", "l", "gyakugen = [pow(l[i], mod-2, mod) for i in range(1, len(l))]", "[pow(l[i], mod-2, mod) for i in range(1, len(l))]", "gyakugen", "gyakugen = [1] + gyakugen", "[1] + gyakugen", "gyakugen", "a,b = map(int, input().split())", "map(int, input().split())", "a", "w,a,b = map(int, input().split())", "map(int, input().split())", "w", "h,w,a,b = map(int, input().split())", "map(int, input().split())", "h", "l = [1]+ l", "[1]+ l", "l" ]

[ 7, 12, 13, 0, 13, 17, 42, 2, 13, 17, 14, 2, 13, 17, 0, 13, 2, 2, 13, 13, 13, 0, 13, 2, 2, 13, 13, 13, 0, 13, 17, 29, 13, 23, 13, 23, 13, 23, 13, 0, 13, 2, 2, 17, 17, 17, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 13, 13, 0, 13, 17, 41, 28, 13, 4, 13, 2, 2, 13, 13, 17, 4, 17, 0, 13, 13, 41, 28, 13, 4, 13, 2, 2, 13, 13, 17, 4, 17, 0, 13, 13, 0, 13, 17, 28, 13, 4, 13, 17, 2, 2, 13, 13, 17, 0, 13, 2, 2, 13, 13, 13, 0, 18, 13, 13, 13, 0, 18, 13, 13, 4, 13, 13, 2, 13, 17, 13, 28, 13, 4, 13, 2, 13, 13, 0, 13, 2, 2, 2, 18, 13, 2, 2, 2, 2, 13, 13, 13, 13, 17, 18, 13, 2, 13, 13, 18, 13, 2, 2, 13, 13, 17, 13, 0, 13, 2, 2, 2, 18, 13, 2, 2, 2, 2, 13, 13, 13, 17, 13, 18, 13, 2, 13, 17, 18, 13, 2, 2, 2, 13, 13, 17, 13, 13, 0, 13, 2, 2, 13, 13, 13, 0, 13, 4, 13, 13, 4, 13, 2, 13, 13, 10, 17, 13, 10, 2, 13, 10, 2, 13, 10, 4, 13, 10, 13, 13, 10, 2, 13, 10, 4, 13, 10, 4, 13, 10, 4, 13, 10, 4, 13, 10, 17, 13, 10, 13, 13, 10, 2, 13, 10, 2, 13, 10, 12, 13 ]

[ [ 5, 4 ], [ 36, 8 ], [ 29, 8 ], [ 36, 12 ], [ 29, 12 ], [ 16, 15 ], [ 4, 18 ], [ 15, 18 ], [ 34, 19 ], [ 22, 19 ], [ 38, 20 ], [ 23, 22 ], [ 34, 25 ], [ 22, 25 ], [ 34, 26 ], [ 22, 26 ], [ 38, 27 ], [ 30, 29 ], [ 15, 32 ], [ 4, 32 ], [ 34, 34 ], [ 36, 36 ], [ 38, 38 ], [ 249, 40 ], [ 240, 47 ], [ 240, 56 ], [ 240, 57 ], [ 240, 58 ], [ 213, 60 ], [ 65, 64 ], [ 238, 69 ], [ 223, 70 ], [ 225, 75 ], [ 80, 79 ], [ 238, 84 ], [ 223, 85 ], [ 246, 90 ], [ 243, 93 ], [ 97, 96 ], [ 238, 102 ], [ 223, 103 ], [ 228, 106 ], [ 244, 109 ], [ 229, 109 ], [ 96, 110 ], [ 250, 111 ], [ 116, 113 ], [ 226, 114 ], [ 96, 115 ], [ 229, 116 ], [ 244, 116 ], [ 121, 118 ], [ 247, 119 ], [ 96, 120 ], [ 256, 122 ], [ 229, 123 ], [ 244, 123 ], [ 250, 125 ], [ 250, 127 ], [ 130, 129 ], [ 223, 133 ], [ 235, 134 ], [ 219, 136 ], [ 226, 141 ], [ 238, 146 ], [ 129, 147 ], [ 235, 148 ], [ 241, 149 ], [ 247, 152 ], [ 235, 154 ], [ 129, 155 ], [ 247, 157 ], [ 238, 160 ], [ 241, 161 ], [ 250, 163 ], [ 216, 165 ], [ 226, 170 ], [ 223, 175 ], [ 241, 176 ], [ 235, 177 ], [ 129, 179 ], [ 247, 181 ], [ 241, 183 ], [ 247, 186 ], [ 223, 190 ], [ 235, 191 ], [ 129, 193 ], [ 250, 194 ], [ 252, 196 ], [ 220, 199 ], [ 217, 200 ], [ 250, 201 ], [ 231, 203 ], [ 253, 206 ], [ 214, 206 ], [ 232, 210 ], [ 253, 210 ], [ 214, 210 ], [ 250, 211 ], [ 213, 214 ], [ 216, 217 ], [ 219, 220 ], [ 240, 223 ], [ 225, 226 ], [ 228, 229 ], [ 231, 232 ], [ 240, 235 ], [ 240, 238 ], [ 240, 241 ], [ 243, 244 ], [ 246, 247 ], [ 249, 250 ], [ 252, 253 ] ]

[ "def modpow(a, n, mod):\n res = 1\n while n > 0:\n if (n & 1):\n res = res * a % mod\n a = a * a % mod\n n >>= 1\n return res\n\nDIV = 10**9 + 7\nh, w, a, b = map(int, input().split())\nans = 0\n#最大h+w!までの元と逆元の階乗テーブルを求めておく\n#逆元をFermatの小定理により計算\n#p-2乗は二分累乗法にて高速に計算可能\ntable = [1 for i in range(h + w + 1)]\ninv_table = [1 for i in range(h + w + 1)]\ntemp = 1\nfor i in range(1, h + w + 1):\n temp = temp * i % DIV\n table[i] = temp\n inv_table[i] = modpow(temp, DIV - 2, DIV)\n\nfor i in range(w - b):\n n1 = table[h + i + b - a - 1] * inv_table[b + i] * inv_table[h - a - 1] % DIV\n n2 = table[w + a - b - 2 - i] * inv_table[a - 1] * inv_table[w - b - 1 - i] % DIV\n ans += n1 * n2 % DIV\nans = int(ans)\nprint(ans%DIV)", "def modpow(a, n, mod):\n res = 1\n while n > 0:\n if (n & 1):\n res = res * a % mod\n a = a * a % mod\n n >>= 1\n return res", "modpow", "res = 1", "res", "1", "while n > 0:\n if (n & 1):\n res = res * a % mod\n a = a * a % mod\n n >>= 1\n ", "n > 0", "n", "0", "if (n & 1):\n res = res * a % mod\n ", "n & 1", "n", "1", "res = res * a % mod", "res", "res * a % mod", "res * a", "res", "a", "mod", "a = a * a % mod", "a", "a * a % mod", "a * a", "a", "a", "mod", "n >>= 1", "n", "1", "return res", "res", "a", "a", "n", "n", "mod", "mod", "DIV = 10**9 + 7", "DIV", "10**9 + 7", "10**9", "10", "9", "7", "h, w, a, b = map(int, input().split())", "h", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "w", "a", "b", "ans = 0", "ans", "0", "1 for i in range(h + w + 1)", "for i in range(h + w + 1)", "i", "range(h + w + 1)", "range", "h + w + 1", "h + w", "h", "w", "1", "for i in range(h + w + 1)", "1", "table = [1 for i in range(h + w + 1)]", "table", "[1 for i in range(h + w + 1)]", "1 for i in range(h + w + 1)", "for i in range(h + w + 1)", "i", "range(h + w + 1)", "range", "h + w + 1", "h + w", "h", "w", "1", "for i in range(h + w + 1)", "1", "inv_table = [1 for i in range(h + w + 1)]", "inv_table", "[1 for i in range(h + w + 1)]", "temp = 1", "temp", "1", "for i in range(1, h + w + 1):\n temp = temp * i % DIV\n table[i] = temp\n inv_table[i] = modpow(temp, DIV - 2, DIV)", "i", "range(1, h + w + 1)", "range", "1", "h + w + 1", "h + w", "h", "w", "1", "temp = temp * i % DIV", "temp", "temp * i % DIV", "temp * i", "temp", "i", "DIV", "table[i] = temp", "table[i]", "table", "i", "temp", "inv_table[i] = modpow(temp, DIV - 2, DIV)", "inv_table[i]", "inv_table", "i", "modpow(temp, DIV - 2, DIV)", "modpow", "temp", "DIV - 2", "DIV", "2", "DIV", "for i in range(w - b):\n n1 = table[h + i + b - a - 1] * inv_table[b + i] * inv_table[h - a - 1] % DIV\n n2 = table[w + a - b - 2 - i] * inv_table[a - 1] * inv_table[w - b - 1 - i] % DIV\n ans += n1 * n2 % DIV", "i", "range(w - b)", "range", "w - b", "w", "b", "n1 = table[h + i + b - a - 1] * inv_table[b + i] * inv_table[h - a - 1] % DIV", "n1", "table[h + i + b - a - 1] * inv_table[b + i] * inv_table[h - a - 1] % DIV", "table[h + i + b - a - 1] * inv_table[b + i] * inv_table[h - a - 1]", "table[h + i + b - a - 1] * inv_table[b + i]", "table[h + i + b - a - 1]", "table", "h + i + b - a - 1", "h + i + b - a", "h + i + b", "h + i", "h", "i", "b", "a", "1", "inv_table[b + i]", "inv_table", "b + i", "b", "i", "inv_table[h - a - 1]", "inv_table", "h - a - 1", "h - a", "h", "a", "1", "DIV", "n2 = table[w + a - b - 2 - i] * inv_table[a - 1] * inv_table[w - b - 1 - i] % DIV", "n2", "table[w + a - b - 2 - i] * inv_table[a - 1] * inv_table[w - b - 1 - i] % DIV", "table[w + a - b - 2 - i] * inv_table[a - 1] * inv_table[w - b - 1 - i]", "table[w + a - b - 2 - i] * inv_table[a - 1]", "table[w + a - b - 2 - i]", "table", "w + a - b - 2 - i", "w + a - b - 2", "w + a - b", "w + a", "w", "a", "b", "2", "i", "inv_table[a - 1]", "inv_table", "a - 1", "a", "1", "inv_table[w - b - 1 - i]", "inv_table", "w - b - 1 - i", "w - b - 1", "w - b", "w", "b", "1", "i", "DIV", "ans += n1 * n2 % DIV", "ans", "n1 * n2 % DIV", "n1 * n2", "n1", "n2", "DIV", "ans = int(ans)", "ans", "int(ans)", "int", "ans", "print(ans%DIV)", "print", "ans%DIV", "ans", "DIV", "ans = 0", "0", "ans", "n2 = table[w + a - b - 2 - i] * inv_table[a - 1] * inv_table[w - b - 1 - i] % DIV", "table[w + a - b - 2 - i] * inv_table[a - 1] * inv_table[w - b - 1 - i] % DIV", "n2", "n1 = table[h + i + b - a - 1] * inv_table[b + i] * inv_table[h - a - 1] % DIV", "table[h + i + b - a - 1] * inv_table[b + i] * inv_table[h - a - 1] % DIV", "n1", "w, a, b = map(int, input().split())", "map(int, input().split())", "w", "table = [1 for i in range(h + w + 1)]", "[1 for i in range(h + w + 1)]", "table", "temp = temp * i % DIV", "temp * i % DIV", "temp", "ans = int(ans)", "int(ans)", "ans", "b = map(int, input().split())", "map(int, input().split())", "b", "h, w, a, b = map(int, input().split())", "map(int, input().split())", "h", "a, b = map(int, input().split())", "map(int, input().split())", "a", "temp = 1", "1", "temp", "inv_table = [1 for i in range(h + w + 1)]", "[1 for i in range(h + w + 1)]", "inv_table", "DIV = 10**9 + 7", "10**9 + 7", "DIV", "ans += n1 * n2 % DIV", "n1 * n2 % DIV", "ans", "def modpow(a, n, mod):\n res = 1\n while n > 0:\n if (n & 1):\n res = res * a % mod\n a = a * a % mod\n n >>= 1\n return res", "def modpow(a, n, mod):\n res = 1\n while n > 0:\n if (n & 1):\n res = res * a % mod\n a = a * a % mod\n n >>= 1\n return res", "modpow" ]

[ 7, 0, 13, 2, 39, 17, 2, 2, 17, 17, 17, 0, 18, 13, 17, 17, 0, 18, 13, 17, 17, 0, 13, 2, 2, 17, 17, 17, 28, 13, 4, 13, 17, 2, 2, 17, 17, 17, 0, 18, 13, 13, 2, 2, 18, 13, 2, 13, 17, 13, 13, 12, 13, 29, 2, 2, 2, 18, 13, 13, 4, 13, 18, 13, 13, 2, 13, 17, 13, 4, 13, 18, 13, 2, 13, 13, 2, 13, 17, 13, 13, 23, 13, 23, 13, 23, 13, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 13, 13, 0, 13, 17, 28, 13, 4, 13, 2, 13, 13, 0, 13, 2, 2, 4, 13, 2, 2, 13, 13, 17, 13, 13, 4, 13, 2, 2, 2, 2, 2, 13, 13, 17, 13, 13, 17, 2, 2, 13, 13, 17, 13, 13, 0, 13, 13, 4, 13, 13, 10, 2, 13, 10, 4, 13, 10, 2, 13, 10, 12, 13, 10, 4, 13, 10, 17, 13, 10, 2, 13, 10, 4, 13, 10, 4, 13, 10, 13, 13 ]

[ [ 150, 2 ], [ 20, 12 ], [ 151, 13 ], [ 20, 17 ], [ 151, 18 ], [ 168, 22 ], [ 30, 29 ], [ 42, 39 ], [ 151, 40 ], [ 29, 41 ], [ 151, 45 ], [ 29, 47 ], [ 29, 49 ], [ 169, 50 ], [ 151, 58 ], [ 82, 59 ], [ 151, 63 ], [ 84, 64 ], [ 86, 66 ], [ 86, 68 ], [ 151, 72 ], [ 82, 74 ], [ 84, 75 ], [ 86, 77 ], [ 86, 79 ], [ 169, 80 ], [ 82, 82 ], [ 84, 84 ], [ 86, 86 ], [ 174, 88 ], [ 174, 97 ], [ 174, 98 ], [ 174, 99 ], [ 165, 101 ], [ 105, 104 ], [ 172, 108 ], [ 154, 109 ], [ 156, 111 ], [ 160, 115 ], [ 163, 118 ], [ 104, 119 ], [ 104, 121 ], [ 169, 122 ], [ 160, 124 ], [ 172, 130 ], [ 104, 131 ], [ 175, 133 ], [ 163, 134 ], [ 175, 138 ], [ 163, 139 ], [ 169, 141 ], [ 169, 142 ], [ 177, 144 ], [ 169, 145 ], [ 178, 148 ], [ 157, 148 ], [ 166, 148 ], [ 150, 151 ], [ 174, 154 ], [ 156, 157 ], [ 174, 163 ], [ 165, 166 ], [ 168, 169 ], [ 174, 172 ], [ 174, 175 ], [ 169, 177 ], [ 177, 178 ] ]

[ "memo=[0]*(10**6+1)\nmemo[0]=memo[1]=1\nmod=10**9+7\nfor i in range(2,10**6+1):\n memo[i]=(memo[i-1]*i)%mod\ndef comb(n,k,p):\n return (memo[n]*pow(memo[k],p-2,p)*pow(memo[n-k],p-2,p))%mod\nh,w,a,b=map(int,input().split())\nans=0\nfor i in range(h-a):\n ans+=(comb(b+i-1,i,mod)*comb(h-i-1+w-b-1,w-b-1,mod))%mod\n ans%=mod\nprint(ans)", "memo=[0]*(10**6+1)", "memo", "[0]*(10**6+1)", "[0]", "0", "10**6+1", "10**6", "10", "6", "1", "memo[0]=memo[1]=1", "memo[0]", "memo", "0", "1", "=memo[1]=1", "memo[1]", "memo", "1", "1", "mod=10**9+7", "mod", "10**9+7", "10**9", "10", "9", "7", "for i in range(2,10**6+1):\n memo[i]=(memo[i-1]*i)%mod", "i", "range(2,10**6+1)", "range", "2", "10**6+1", "10**6", "10", "6", "1", "memo[i]=(memo[i-1]*i)%mod", "memo[i]", "memo", "i", "(memo[i-1]*i)%mod", "memo[i-1]*i", "memo[i-1]", "memo", "i-1", "i", "1", "i", "mod", "def comb(n,k,p):\n return (memo[n]*pow(memo[k],p-2,p)*pow(memo[n-k],p-2,p))%mod", "comb", "return (memo[n]*pow(memo[k],p-2,p)*pow(memo[n-k],p-2,p))%mod", "(memo[n]*pow(memo[k],p-2,p)*pow(memo[n-k],p-2,p))%mod", "memo[n]*pow(memo[k],p-2,p)*pow(memo[n-k],p-2,p)", "memo[n]*pow(memo[k],p-2,p)", "memo[n]", "memo", "n", "pow(memo[k],p-2,p)", "pow", "memo[k]", "memo", "k", "p-2", "p", "2", "p", "pow(memo[n-k],p-2,p)", "pow", "memo[n-k]", "memo", "n-k", "n", "k", "p-2", "p", "2", "p", "mod", "n", "n", "k", "k", "p", "p", "h,w,a,b=map(int,input().split())", "h", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "w", "a", "b", "ans=0", "ans", "0", "for i in range(h-a):\n ans+=(comb(b+i-1,i,mod)*comb(h-i-1+w-b-1,w-b-1,mod))%mod\n ans%=mod", "i", "range(h-a)", "range", "h-a", "h", "a", "ans+=(comb(b+i-1,i,mod)*comb(h-i-1+w-b-1,w-b-1,mod))%mod", "ans", "(comb(b+i-1,i,mod)*comb(h-i-1+w-b-1,w-b-1,mod))%mod", "comb(b+i-1,i,mod)*comb(h-i-1+w-b-1,w-b-1,mod)", "comb(b+i-1,i,mod)", "comb", "b+i-1", "b+i", "b", "i", "1", "i", "mod", "comb(h-i-1+w-b-1,w-b-1,mod)", "comb", "h-i-1+w-b-1", "h-i-1+w-b", "h-i-1+w", "h-i-1", "h-i", "h", "i", "1", "w", "b", "1", "w-b-1", "w-b", "w", "b", "1", "mod", "mod", "ans%=mod", "ans", "mod", "print(ans)", "print", "ans", "memo=[0]*(10**6+1)", "[0]*(10**6+1)", "memo", "a,b=map(int,input().split())", "map(int,input().split())", "a", "ans+=(comb(b+i-1,i,mod)*comb(h-i-1+w-b-1,w-b-1,mod))%mod", "(comb(b+i-1,i,mod)*comb(h-i-1+w-b-1,w-b-1,mod))%mod", "ans", "def comb(n,k,p):\n return (memo[n]*pow(memo[k],p-2,p)*pow(memo[n-k],p-2,p))%mod", "def comb(n,k,p):\n return (memo[n]*pow(memo[k],p-2,p)*pow(memo[n-k],p-2,p))%mod", "comb", "b=map(int,input().split())", "map(int,input().split())", "b", "ans=0", "0", "ans", "mod=10**9+7", "10**9+7", "mod", "h,w,a,b=map(int,input().split())", "map(int,input().split())", "h", "w,a,b=map(int,input().split())", "map(int,input().split())", "w", "ans%=mod", "mod", "ans" ]

[ 7, 15, 13, 0, 13, 18, 18, 13, 13, 13, 0, 13, 2, 2, 17, 17, 17, 0, 13, 4, 13, 17, 4, 18, 13, 13, 2, 17, 17, 12, 13, 0, 13, 17, 0, 13, 4, 13, 2, 13, 13, 13, 28, 13, 4, 13, 13, 0, 13, 2, 13, 13, 0, 13, 13, 0, 13, 4, 13, 2, 13, 13, 2, 13, 17, 13, 29, 13, 23, 13, 23, 13, 12, 13, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 13, 13, 0, 13, 17, 0, 13, 17, 0, 13, 4, 13, 2, 2, 2, 2, 13, 13, 17, 13, 17, 2, 2, 13, 13, 17, 28, 13, 4, 13, 2, 13, 13, 0, 13, 2, 13, 13, 0, 13, 13, 0, 13, 2, 2, 2, 13, 17, 13, 17, 0, 13, 13, 0, 13, 4, 13, 2, 13, 17, 2, 13, 17, 13, 0, 13, 13, 0, 13, 4, 13, 2, 2, 2, 2, 2, 13, 17, 13, 13, 17, 13, 2, 13, 17, 13, 0, 13, 13, 0, 13, 2, 2, 2, 2, 2, 2, 13, 17, 13, 13, 17, 13, 2, 2, 13, 13, 17, 0, 13, 13, 4, 13, 13, 14, 2, 13, 17, 4, 13, 10, 2, 13, 10, 18, 13, 10, 12, 13, 10, 4, 13, 10, 12, 13 ]

[ [ 209, 4 ], [ 206, 11 ], [ 215, 18 ], [ 33, 32 ], [ 36, 35 ], [ 69, 39 ], [ 71, 40 ], [ 71, 41 ], [ 44, 43 ], [ 35, 46 ], [ 71, 46 ], [ 49, 48 ], [ 69, 50 ], [ 43, 51 ], [ 54, 53 ], [ 207, 54 ], [ 57, 56 ], [ 35, 60 ], [ 71, 60 ], [ 43, 61 ], [ 207, 63 ], [ 207, 65 ], [ 56, 67 ], [ 53, 67 ], [ 48, 67 ], [ 32, 67 ], [ 69, 69 ], [ 71, 71 ], [ 76, 75 ], [ 210, 82 ], [ 76, 84 ], [ 76, 85 ], [ 76, 86 ], [ 89, 88 ], [ 92, 91 ], [ 95, 94 ], [ 213, 96 ], [ 84, 101 ], [ 86, 102 ], [ 75, 104 ], [ 84, 108 ], [ 86, 109 ], [ 113, 112 ], [ 75, 116 ], [ 85, 117 ], [ 120, 119 ], [ 91, 121 ], [ 150, 121 ], [ 139, 121 ], [ 136, 121 ], [ 127, 121 ], [ 94, 122 ], [ 194, 122 ], [ 175, 122 ], [ 172, 122 ], [ 153, 122 ], [ 125, 124 ], [ 207, 125 ], [ 128, 127 ], [ 86, 131 ], [ 112, 133 ], [ 137, 136 ], [ 207, 137 ], [ 140, 139 ], [ 112, 143 ], [ 207, 146 ], [ 207, 148 ], [ 151, 150 ], [ 207, 151 ], [ 154, 153 ], [ 84, 161 ], [ 86, 163 ], [ 75, 164 ], [ 112, 166 ], [ 207, 168 ], [ 207, 170 ], [ 173, 172 ], [ 207, 173 ], [ 176, 175 ], [ 84, 182 ], [ 86, 184 ], [ 75, 185 ], [ 112, 187 ], [ 84, 190 ], [ 86, 191 ], [ 195, 194 ], [ 207, 195 ], [ 124, 198 ], [ 119, 198 ], [ 88, 198 ], [ 219, 204 ], [ 206, 207 ], [ 209, 210 ], [ 215, 216 ] ]

[ "import sys\n\nreadline = sys.stdin.readline\nMOD = 10 ** 9 + 7\nINF = float('INF')\nsys.setrecursionlimit(10 ** 5)\n\n\ndef comb_mod(n, r):\n res = 1\n r = min(n - r, r)\n\n for i in range(r):\n res *= (n - i)\n res %= MOD\n res *= pow((r - i), MOD - 2, MOD)\n\n return res\n\n\ndef main():\n h, w, a, b = map(int, readline().split())\n\n ans = 0\n comb1 = 1\n comb2 = comb_mod(w - b - 1 + h - 1, w - b - 1)\n\n for i in range(h - a):\n ans += comb1 * comb2\n ans %= MOD\n comb1 *= (b - 1 + i + 1)\n comb1 %= MOD\n comb1 *= pow(i + 1, MOD - 2, MOD)\n comb1 %= MOD\n comb2 *= pow(w - 1 - b + h - 1 - i, MOD - 2, MOD)\n comb2 %= MOD\n comb2 *= w - 1 - b + h- 1 - i - (w - b - 1)\n comb2 %= MOD\n\n print(ans)\n\n\nif __name__ == '__main__':\n main()", "import sys", "sys", "readline = sys.stdin.readline", "readline", "sys.stdin.readline", "sys.stdin", "sys", "stdin", "readline", "MOD = 10 ** 9 + 7", "MOD", "10 ** 9 + 7", "10 ** 9", "10", "9", "7", "INF = float('INF')", "INF", "float('INF')", "float", "'INF'", "sys.setrecursionlimit(10 ** 5)", "sys.setrecursionlimit", "sys", "setrecursionlimit", "10 ** 5", "10", "5", "def comb_mod(n, r):\n res = 1\n r = min(n - r, r)\n\n for i in range(r):\n res *= (n - i)\n res %= MOD\n res *= pow((r - i), MOD - 2, MOD)\n\n return res", "comb_mod", "res = 1", "res", "1", "r = min(n - r, r)", "r", "min(n - r, r)", "min", "n - r", "n", "r", "r", "for i in range(r):\n res *= (n - i)\n res %= MOD\n res *= pow((r - i), MOD - 2, MOD)\n\n ", "i", "range(r)", "range", "r", "res *= (n - i)", "res", "n - i", "n", "i", "res %= MOD", "res", "MOD", "res *= pow((r - i), MOD - 2, MOD)", "res", "pow((r - i), MOD - 2, MOD)", "pow", "r - i", "r", "i", "MOD - 2", "MOD", "2", "MOD", "return res", "res", "n", "n", "r", "r", "def main():\n h, w, a, b = map(int, readline().split())\n\n ans = 0\n comb1 = 1\n comb2 = comb_mod(w - b - 1 + h - 1, w - b - 1)\n\n for i in range(h - a):\n ans += comb1 * comb2\n ans %= MOD\n comb1 *= (b - 1 + i + 1)\n comb1 %= MOD\n comb1 *= pow(i + 1, MOD - 2, MOD)\n comb1 %= MOD\n comb2 *= pow(w - 1 - b + h - 1 - i, MOD - 2, MOD)\n comb2 %= MOD\n comb2 *= w - 1 - b + h- 1 - i - (w - b - 1)\n comb2 %= MOD\n\n print(ans)", "main", "h, w, a, b = map(int, readline().split())", "h", "map(int, readline().split())", "map", "int", "readline().split()", "().split", "()", "readline", "split", "w", "a", "b", "ans = 0", "ans", "0", "comb1 = 1", "comb1", "1", "comb2 = comb_mod(w - b - 1 + h - 1, w - b - 1)", "comb2", "comb_mod(w - b - 1 + h - 1, w - b - 1)", "comb_mod", "w - b - 1 + h - 1", "w - b - 1 + h", "w - b - 1", "w - b", "w", "b", "1", "h", "1", "w - b - 1", "w - b", "w", "b", "1", "for i in range(h - a):\n ans += comb1 * comb2\n ans %= MOD\n comb1 *= (b - 1 + i + 1)\n comb1 %= MOD\n comb1 *= pow(i + 1, MOD - 2, MOD)\n comb1 %= MOD\n comb2 *= pow(w - 1 - b + h - 1 - i, MOD - 2, MOD)\n comb2 %= MOD\n comb2 *= w - 1 - b + h- 1 - i - (w - b - 1)\n comb2 %= MOD\n\n ", "i", "range(h - a)", "range", "h - a", "h", "a", "ans += comb1 * comb2", "ans", "comb1 * comb2", "comb1", "comb2", "ans %= MOD", "ans", "MOD", "comb1 *= (b - 1 + i + 1)", "comb1", "b - 1 + i + 1", "b - 1 + i", "b - 1", "b", "1", "i", "1", "comb1 %= MOD", "comb1", "MOD", "comb1 *= pow(i + 1, MOD - 2, MOD)", "comb1", "pow(i + 1, MOD - 2, MOD)", "pow", "i + 1", "i", "1", "MOD - 2", "MOD", "2", "MOD", "comb1 %= MOD", "comb1", "MOD", "comb2 *= pow(w - 1 - b + h - 1 - i, MOD - 2, MOD)", "comb2", "pow(w - 1 - b + h - 1 - i, MOD - 2, MOD)", "pow", "w - 1 - b + h - 1 - i", "w - 1 - b + h - 1", "w - 1 - b + h", "w - 1 - b", "w - 1", "w", "1", "b", "h", "1", "i", "MOD - 2", "MOD", "2", "MOD", "comb2 %= MOD", "comb2", "MOD", "comb2 *= w - 1 - b + h- 1 - i - (w - b - 1)", "comb2", "w - 1 - b + h- 1 - i - (w - b - 1)", "w - 1 - b + h- 1 - i", "w - 1 - b + h- 1", "w - 1 - b + h", "w - 1 - b", "w - 1", "w", "1", "b", "h", "1", "i", "w - b - 1", "w - b", "w", "b", "1", "comb2 %= MOD", "comb2", "MOD", "print(ans)", "print", "ans", "if __name__ == '__main__':\n main()", "__name__ == '__main__'", "__name__", "'__main__'", "main()", "main", "MOD = 10 ** 9 + 7", "10 ** 9 + 7", "MOD", "readline = sys.stdin.readline", "sys.stdin.readline", "readline", "def comb_mod(n, r):\n res = 1\n r = min(n - r, r)\n\n for i in range(r):\n res *= (n - i)\n res %= MOD\n res *= pow((r - i), MOD - 2, MOD)\n\n return res", "def comb_mod(n, r):\n res = 1\n r = min(n - r, r)\n\n for i in range(r):\n res *= (n - i)\n res %= MOD\n res *= pow((r - i), MOD - 2, MOD)\n\n return res", "comb_mod", "INF = float('INF')", "float('INF')", "INF", "def main():\n h, w, a, b = map(int, readline().split())\n\n ans = 0\n comb1 = 1\n comb2 = comb_mod(w - b - 1 + h - 1, w - b - 1)\n\n for i in range(h - a):\n ans += comb1 * comb2\n ans %= MOD\n comb1 *= (b - 1 + i + 1)\n comb1 %= MOD\n comb1 *= pow(i + 1, MOD - 2, MOD)\n comb1 %= MOD\n comb2 *= pow(w - 1 - b + h - 1 - i, MOD - 2, MOD)\n comb2 %= MOD\n comb2 *= w - 1 - b + h- 1 - i - (w - b - 1)\n comb2 %= MOD\n\n print(ans)", "def main():\n h, w, a, b = map(int, readline().split())\n\n ans = 0\n comb1 = 1\n comb2 = comb_mod(w - b - 1 + h - 1, w - b - 1)\n\n for i in range(h - a):\n ans += comb1 * comb2\n ans %= MOD\n comb1 *= (b - 1 + i + 1)\n comb1 %= MOD\n comb1 *= pow(i + 1, MOD - 2, MOD)\n comb1 %= MOD\n comb2 *= pow(w - 1 - b + h - 1 - i, MOD - 2, MOD)\n comb2 %= MOD\n comb2 *= w - 1 - b + h- 1 - i - (w - b - 1)\n comb2 %= MOD\n\n print(ans)", "main" ]

[ 7, 15, 13, 4, 18, 13, 13, 2, 17, 17, 0, 13, 18, 18, 13, 13, 13, 0, 13, 4, 13, 17, 0, 13, 2, 2, 17, 17, 17, 6, 13, 12, 13, 17, 0, 18, 13, 13, 13, 0, 18, 13, 13, 13, 0, 18, 13, 13, 39, 17, 17, 0, 18, 13, 13, 39, 17, 17, 0, 18, 13, 13, 39, 17, 17, 23, 13, 23, 13, 23, 13, 12, 13, 17, 0, 13, 17, 13, 17, 28, 13, 4, 13, 13, 0, 13, 2, 2, 13, 2, 13, 13, 18, 13, 13, 0, 13, 2, 2, 13, 2, 13, 17, 18, 13, 13, 29, 2, 2, 13, 4, 13, 13, 2, 18, 13, 13, 17, 18, 13, 13, 18, 13, 13, 23, 13, 23, 13, 23, 13, 12, 13, 17, 28, 13, 4, 13, 17, 2, 18, 13, 13, 17, 4, 18, 18, 13, 13, 13, 2, 2, 18, 18, 13, 13, 17, 13, 18, 13, 13, 4, 18, 18, 13, 13, 13, 2, 2, 40, 18, 18, 13, 13, 2, 18, 13, 13, 13, 2, 18, 13, 13, 13, 18, 13, 13, 4, 18, 18, 13, 13, 13, 2, 2, 18, 18, 13, 13, 17, 18, 18, 13, 13, 17, 18, 13, 13, 23, 13, 12, 13, 17, 14, 2, 2, 13, 17, 2, 13, 13, 29, 17, 0, 13, 4, 13, 13, 2, 13, 13, 29, 2, 2, 2, 18, 18, 13, 13, 13, 18, 18, 13, 13, 13, 18, 18, 13, 13, 2, 13, 13, 18, 13, 13, 23, 13, 23, 13, 23, 13, 12, 13, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 13, 13, 0, 13, 17, 0, 13, 17, 0, 13, 4, 13, 2, 13, 13, 13, 4, 18, 13, 13, 0, 13, 4, 18, 13, 13, 2, 13, 13, 13, 28, 13, 4, 13, 13, 0, 13, 2, 2, 4, 18, 13, 13, 2, 2, 13, 13, 13, 13, 4, 18, 13, 13, 2, 2, 2, 13, 17, 13, 13, 2, 13, 17, 13, 0, 13, 13, 0, 13, 13, 4, 13, 13, 14, 2, 13, 17, 4, 13, 10, 4, 13, 10, 12, 13, 10, 6, 13, 10, 2, 13, 10, 18, 13 ]

[ [ 365, 11 ], [ 353, 18 ], [ 362, 23 ], [ 38, 35 ], [ 66, 36 ], [ 68, 37 ], [ 68, 38 ], [ 43, 40 ], [ 66, 41 ], [ 70, 42 ], [ 70, 43 ], [ 48, 45 ], [ 66, 46 ], [ 55, 52 ], [ 66, 53 ], [ 62, 59 ], [ 66, 60 ], [ 66, 66 ], [ 68, 68 ], [ 70, 70 ], [ 76, 75 ], [ 78, 77 ], [ 81, 80 ], [ 129, 83 ], [ 86, 85 ], [ 75, 88 ], [ 85, 88 ], [ 127, 90 ], [ 80, 91 ], [ 125, 93 ], [ 97, 96 ], [ 77, 99 ], [ 96, 99 ], [ 80, 101 ], [ 125, 104 ], [ 85, 109 ], [ 75, 109 ], [ 96, 112 ], [ 77, 112 ], [ 125, 115 ], [ 125, 119 ], [ 125, 122 ], [ 125, 125 ], [ 127, 127 ], [ 129, 129 ], [ 135, 134 ], [ 208, 140 ], [ 208, 146 ], [ 208, 153 ], [ 134, 156 ], [ 208, 158 ], [ 208, 163 ], [ 208, 171 ], [ 208, 175 ], [ 134, 177 ], [ 208, 180 ], [ 134, 182 ], [ 208, 184 ], [ 208, 189 ], [ 208, 196 ], [ 208, 201 ], [ 208, 205 ], [ 208, 208 ], [ 259, 215 ], [ 257, 218 ], [ 259, 219 ], [ 224, 223 ], [ 259, 226 ], [ 257, 228 ], [ 259, 229 ], [ 255, 236 ], [ 257, 238 ], [ 255, 241 ], [ 223, 243 ], [ 259, 243 ], [ 255, 246 ], [ 257, 249 ], [ 223, 250 ], [ 259, 250 ], [ 255, 252 ], [ 255, 255 ], [ 257, 257 ], [ 259, 259 ], [ 264, 263 ], [ 366, 270 ], [ 264, 272 ], [ 264, 273 ], [ 264, 274 ], [ 277, 276 ], [ 280, 279 ], [ 283, 282 ], [ 276, 286 ], [ 263, 286 ], [ 279, 287 ], [ 272, 287 ], [ 363, 288 ], [ 282, 291 ], [ 131, 292 ], [ 295, 294 ], [ 282, 297 ], [ 210, 298 ], [ 276, 300 ], [ 263, 300 ], [ 279, 301 ], [ 272, 301 ], [ 276, 302 ], [ 263, 302 ], [ 305, 304 ], [ 274, 307 ], [ 310, 309 ], [ 282, 314 ], [ 210, 315 ], [ 276, 318 ], [ 263, 318 ], [ 273, 319 ], [ 304, 320 ], [ 304, 321 ], [ 282, 324 ], [ 210, 325 ], [ 273, 329 ], [ 279, 331 ], [ 272, 331 ], [ 304, 332 ], [ 273, 334 ], [ 363, 336 ], [ 339, 338 ], [ 309, 339 ], [ 342, 341 ], [ 363, 342 ], [ 341, 345 ], [ 338, 345 ], [ 294, 345 ], [ 357, 351 ], [ 353, 354 ], [ 362, 363 ], [ 365, 366 ] ]

[ "import sys\n\nsys.setrecursionlimit(10 ** 7)\ninput = sys.stdin.readline\nf_inf = float('inf')\nmod = 10 ** 9 + 7\n\nclass CmbMod:\n def __init__(self, n, p):\n \"\"\"\n 二項係数nCr(n個の区別できるものからr個のものを選ぶ組み合わせの数)をpで割った余りを求める\n \"\"\"\n self.n = n\n self.p = p\n self.fact = [1, 1]\n self.factinv = [1, 1]\n self.inv = [0, 1]\n\n def cmb_mod(self, n, r):\n \"\"\"\n 二項係数nCr(mod p)をO(r)にて計算。nが大きいがrは小さい時に使用。\n \"\"\"\n numer, denom = 1, 1\n for i in range(r):\n numer = (numer * (n - i)) % self.p\n denom = (denom * (i + 1)) % self.p\n return (numer * pow(denom, self.p - 2, self.p)) % self.p\n\n def prep(self):\n \"\"\"\n 二項係数nCr(mod p)をO(1)で求める為の前処理をO(N)にて実行。\n \"\"\"\n for i in range(2, self.n + 1):\n self.fact.append((self.fact[-1] * i) % self.p)\n self.inv.append((-self.inv[self.p % i] * (self.p // i)) % self.p)\n self.factinv.append((self.factinv[-1] * self.inv[-1]) % self.p)\n\n def cmb_mod_with_prep(self, n, r):\n \"\"\"\n 二項係数nCr(mod p)をO(1)で求める。事前にprepを実行する事。\n \"\"\"\n if (r < 0) or (n < r):\n return 0\n r = min(r, n - r)\n return self.fact[n] * self.factinv[r] * self.factinv[n - r] % self.p\n\n\ndef resolve():\n H, W, A, B = map(int, input().split())\n H -= 1\n W -= 1\n cmb = CmbMod(H + W, mod)\n cmb.prep()\n total = cmb.cmb_mod_with_prep(H + W, H)\n for w in range(B):\n tmp = (cmb.cmb_mod_with_prep(H - A + w, w) * cmb.cmb_mod_with_prep(A - 1 + W - w, A - 1)) % mod\n total -= tmp\n total %= mod\n print(total)\n\n\nif __name__ == '__main__':\n resolve()", "import sys", "sys", "sys.setrecursionlimit(10 ** 7)", "sys.setrecursionlimit", "sys", "setrecursionlimit", "10 ** 7", "10", "7", "input = sys.stdin.readline", "input", "sys.stdin.readline", "sys.stdin", "sys", "stdin", "readline", "f_inf = float('inf')", "f_inf", "float('inf')", "float", "'inf'", "mod = 10 ** 9 + 7", "mod", "10 ** 9 + 7", "10 ** 9", "10", "9", "7", "class CmbMod:\n def __init__(self, n, p):\n \"\"\"\n 二項係数nCr(n個の区別できるものからr個のものを選ぶ組み合わせの数)をpで割った余りを求める\n \"\"\"\n self.n = n\n self.p = p\n self.fact = [1, 1]\n self.factinv = [1, 1]\n self.inv = [0, 1]\n\n def cmb_mod(self, n, r):\n \"\"\"\n 二項係数nCr(mod p)をO(r)にて計算。nが大きいがrは小さい時に使用。\n \"\"\"\n numer, denom = 1, 1\n for i in range(r):\n numer = (numer * (n - i)) % self.p\n denom = (denom * (i + 1)) % self.p\n return (numer * pow(denom, self.p - 2, self.p)) % self.p\n\n def prep(self):\n \"\"\"\n 二項係数nCr(mod p)をO(1)で求める為の前処理をO(N)にて実行。\n \"\"\"\n for i in range(2, self.n + 1):\n self.fact.append((self.fact[-1] * i) % self.p)\n self.inv.append((-self.inv[self.p % i] * (self.p // i)) % self.p)\n self.factinv.append((self.factinv[-1] * self.inv[-1]) % self.p)\n\n def cmb_mod_with_prep(self, n, r):\n \"\"\"\n 二項係数nCr(mod p)をO(1)で求める。事前にprepを実行する事。\n \"\"\"\n if (r < 0) or (n < r):\n return 0\n r = min(r, n - r)\n return self.fact[n] * self.factinv[r] * self.factinv[n - r] % self.p", "CmbMod", "def __init__(self, n, p):\n \"\"\"\n 二項係数nCr(n個の区別できるものからr個のものを選ぶ組み合わせの数)をpで割った余りを求める\n \"\"\"\n self.n = n\n self.p = p\n self.fact = [1, 1]\n self.factinv = [1, 1]\n self.inv = [0, 1]\n\n ", "__init__", "\"\"\"\n 二項係数nCr(n個の区別できるものからr個のものを選ぶ組み合わせの数)をpで割った余りを求める\n \"\"\"", "self.n = n", "self.n", "self", "n", "n", "self.p = p", "self.p", "self", "p", "p", "self.fact = [1, 1]", "self.fact", "self", "fact", "[1, 1]", "1", "1", "self.factinv = [1, 1]", "self.factinv", "self", "factinv", "[1, 1]", "1", "1", "self.inv = [0, 1]", "self.inv", "self", "inv", "[0, 1]", "0", "1", "self", "self", "n", "n", "p", "p", "def cmb_mod(self, n, r):\n \"\"\"\n 二項係数nCr(mod p)をO(r)にて計算。nが大きいがrは小さい時に使用。\n \"\"\"\n numer, denom = 1, 1\n for i in range(r):\n numer = (numer * (n - i)) % self.p\n denom = (denom * (i + 1)) % self.p\n return (numer * pow(denom, self.p - 2, self.p)) % self.p\n\n ", "cmb_mod", "\"\"\"\n 二項係数nCr(mod p)をO(r)にて計算。nが大きいがrは小さい時に使用。\n \"\"\"", "numer, denom = 1, 1", "numer", "1", "denom", "1", "for i in range(r):\n numer = (numer * (n - i)) % self.p\n denom = (denom * (i + 1)) % self.p\n ", "i", "range(r)", "range", "r", "numer = (numer * (n - i)) % self.p", "numer", "(numer * (n - i)) % self.p", "numer * (n - i)", "numer", "n - i", "n", "i", "self.p", "self", "p", "denom = (denom * (i + 1)) % self.p", "denom", "(denom * (i + 1)) % self.p", "denom * (i + 1)", "denom", "i + 1", "i", "1", "self.p", "self", "p", "return (numer * pow(denom, self.p - 2, self.p)) % self.p", "(numer * pow(denom, self.p - 2, self.p)) % self.p", "numer * pow(denom, self.p - 2, self.p)", "numer", "pow(denom, self.p - 2, self.p)", "pow", "denom", "self.p - 2", "self.p", "self", "p", "2", "self.p", "self", "p", "self.p", "self", "p", "self", "self", "n", "n", "r", "r", "def prep(self):\n \"\"\"\n 二項係数nCr(mod p)をO(1)で求める為の前処理をO(N)にて実行。\n \"\"\"\n for i in range(2, self.n + 1):\n self.fact.append((self.fact[-1] * i) % self.p)\n self.inv.append((-self.inv[self.p % i] * (self.p // i)) % self.p)\n self.factinv.append((self.factinv[-1] * self.inv[-1]) % self.p)\n\n ", "prep", "\"\"\"\n 二項係数nCr(mod p)をO(1)で求める為の前処理をO(N)にて実行。\n \"\"\"", "for i in range(2, self.n + 1):\n self.fact.append((self.fact[-1] * i) % self.p)\n self.inv.append((-self.inv[self.p % i] * (self.p // i)) % self.p)\n self.factinv.append((self.factinv[-1] * self.inv[-1]) % self.p)\n\n ", "i", "range(2, self.n + 1)", "range", "2", "self.n + 1", "self.n", "self", "n", "1", "self.fact.append((self.fact[-1] * i) % self.p)", "self.fact.append", "self.fact", "self", "fact", "append", "(self.fact[-1] * i) % self.p", "self.fact[-1] * i", "self.fact[-1]", "self.fact", "self", "fact", "-1", "i", "self.p", "self", "p", "self.inv.append((-self.inv[self.p % i] * (self.p // i)) % self.p)", "self.inv.append", "self.inv", "self", "inv", "append", "(-self.inv[self.p % i] * (self.p // i)) % self.p", "-self.inv[self.p % i] * (self.p // i)", "-self.inv[self.p % i]", "self.inv[self.p % i]", "self.inv", "self", "inv", "self.p % i", "self.p", "self", "p", "i", "self.p // i", "self.p", "self", "p", "i", "self.p", "self", "p", "self.factinv.append((self.factinv[-1] * self.inv[-1]) % self.p)", "self.factinv.append", "self.factinv", "self", "factinv", "append", "(self.factinv[-1] * self.inv[-1]) % self.p", "self.factinv[-1] * self.inv[-1]", "self.factinv[-1]", "self.factinv", "self", "factinv", "-1", "self.inv[-1]", "self.inv", "self", "inv", "-1", "self.p", "self", "p", "self", "self", "def cmb_mod_with_prep(self, n, r):\n \"\"\"\n 二項係数nCr(mod p)をO(1)で求める。事前にprepを実行する事。\n \"\"\"\n if (r < 0) or (n < r):\n return 0\n r = min(r, n - r)\n return self.fact[n] * self.factinv[r] * self.factinv[n - r] % self.p", "cmb_mod_with_prep", "\"\"\"\n 二項係数nCr(mod p)をO(1)で求める。事前にprepを実行する事。\n \"\"\"", "if (r < 0) or (n < r):\n return 0\n ", "(r < 0) or (n < r)", "r < 0", "r", "0", "n < r", "n", "r", "return 0", "0", "r = min(r, n - r)", "r", "min(r, n - r)", "min", "r", "n - r", "n", "r", "return self.fact[n] * self.factinv[r] * self.factinv[n - r] % self.p", "self.fact[n] * self.factinv[r] * self.factinv[n - r] % self.p", "self.fact[n] * self.factinv[r] * self.factinv[n - r]", "self.fact[n] * self.factinv[r]", "self.fact[n]", "self.fact", "self", "fact", "n", "self.factinv[r]", "self.factinv", "self", "factinv", "r", "self.factinv[n - r]", "self.factinv", "self", "factinv", "n - r", "n", "r", "self.p", "self", "p", "self", "self", "n", "n", "r", "r", "def resolve():\n H, W, A, B = map(int, input().split())\n H -= 1\n W -= 1\n cmb = CmbMod(H + W, mod)\n cmb.prep()\n total = cmb.cmb_mod_with_prep(H + W, H)\n for w in range(B):\n tmp = (cmb.cmb_mod_with_prep(H - A + w, w) * cmb.cmb_mod_with_prep(A - 1 + W - w, A - 1)) % mod\n total -= tmp\n total %= mod\n print(total)", "resolve", "H, W, A, B = map(int, input().split())", "H", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "W", "A", "B", "H -= 1", "H", "1", "W -= 1", "W", "1", "cmb = CmbMod(H + W, mod)", "cmb", "CmbMod(H + W, mod)", "CmbMod", "H + W", "H", "W", "mod", "cmb.prep()", "cmb.prep", "cmb", "prep", "total = cmb.cmb_mod_with_prep(H + W, H)", "total", "cmb.cmb_mod_with_prep(H + W, H)", "cmb.cmb_mod_with_prep", "cmb", "cmb_mod_with_prep", "H + W", "H", "W", "H", "for w in range(B):\n tmp = (cmb.cmb_mod_with_prep(H - A + w, w) * cmb.cmb_mod_with_prep(A - 1 + W - w, A - 1)) % mod\n total -= tmp\n total %= mod\n ", "w", "range(B)", "range", "B", "tmp = (cmb.cmb_mod_with_prep(H - A + w, w) * cmb.cmb_mod_with_prep(A - 1 + W - w, A - 1)) % mod", "tmp", "(cmb.cmb_mod_with_prep(H - A + w, w) * cmb.cmb_mod_with_prep(A - 1 + W - w, A - 1)) % mod", "cmb.cmb_mod_with_prep(H - A + w, w) * cmb.cmb_mod_with_prep(A - 1 + W - w, A - 1)", "cmb.cmb_mod_with_prep(H - A + w, w)", "cmb.cmb_mod_with_prep", "cmb", "cmb_mod_with_prep", "H - A + w", "H - A", "H", "A", "w", "w", "cmb.cmb_mod_with_prep(A - 1 + W - w, A - 1)", "cmb.cmb_mod_with_prep", "cmb", "cmb_mod_with_prep", "A - 1 + W - w", "A - 1 + W", "A - 1", "A", "1", "W", "w", "A - 1", "A", "1", "mod", "total -= tmp", "total", "tmp", "total %= mod", "total", "mod", "print(total)", "print", "total", "if __name__ == '__main__':\n resolve()", "__name__ == '__main__'", "__name__", "'__main__'", "resolve()", "resolve", "f_inf = float('inf')", "float('inf')", "f_inf", "def resolve():\n H, W, A, B = map(int, input().split())\n H -= 1\n W -= 1\n cmb = CmbMod(H + W, mod)\n cmb.prep()\n total = cmb.cmb_mod_with_prep(H + W, H)\n for w in range(B):\n tmp = (cmb.cmb_mod_with_prep(H - A + w, w) * cmb.cmb_mod_with_prep(A - 1 + W - w, A - 1)) % mod\n total -= tmp\n total %= mod\n print(total)", "def resolve():\n H, W, A, B = map(int, input().split())\n H -= 1\n W -= 1\n cmb = CmbMod(H + W, mod)\n cmb.prep()\n total = cmb.cmb_mod_with_prep(H + W, H)\n for w in range(B):\n tmp = (cmb.cmb_mod_with_prep(H - A + w, w) * cmb.cmb_mod_with_prep(A - 1 + W - w, A - 1)) % mod\n total -= tmp\n total %= mod\n print(total)", "resolve", "class CmbMod:\n def __init__(self, n, p):\n \"\"\"\n 二項係数nCr(n個の区別できるものからr個のものを選ぶ組み合わせの数)をpで割った余りを求める\n \"\"\"\n self.n = n\n self.p = p\n self.fact = [1, 1]\n self.factinv = [1, 1]\n self.inv = [0, 1]\n\n def cmb_mod(self, n, r):\n \"\"\"\n 二項係数nCr(mod p)をO(r)にて計算。nが大きいがrは小さい時に使用。\n \"\"\"\n numer, denom = 1, 1\n for i in range(r):\n numer = (numer * (n - i)) % self.p\n denom = (denom * (i + 1)) % self.p\n return (numer * pow(denom, self.p - 2, self.p)) % self.p\n\n def prep(self):\n \"\"\"\n 二項係数nCr(mod p)をO(1)で求める為の前処理をO(N)にて実行。\n \"\"\"\n for i in range(2, self.n + 1):\n self.fact.append((self.fact[-1] * i) % self.p)\n self.inv.append((-self.inv[self.p % i] * (self.p // i)) % self.p)\n self.factinv.append((self.factinv[-1] * self.inv[-1]) % self.p)\n\n def cmb_mod_with_prep(self, n, r):\n \"\"\"\n 二項係数nCr(mod p)をO(1)で求める。事前にprepを実行する事。\n \"\"\"\n if (r < 0) or (n < r):\n return 0\n r = min(r, n - r)\n return self.fact[n] * self.factinv[r] * self.factinv[n - r] % self.p", "class CmbMod:\n def __init__(self, n, p):\n \"\"\"\n 二項係数nCr(n個の区別できるものからr個のものを選ぶ組み合わせの数)をpで割った余りを求める\n \"\"\"\n self.n = n\n self.p = p\n self.fact = [1, 1]\n self.factinv = [1, 1]\n self.inv = [0, 1]\n\n def cmb_mod(self, n, r):\n \"\"\"\n 二項係数nCr(mod p)をO(r)にて計算。nが大きいがrは小さい時に使用。\n \"\"\"\n numer, denom = 1, 1\n for i in range(r):\n numer = (numer * (n - i)) % self.p\n denom = (denom * (i + 1)) % self.p\n return (numer * pow(denom, self.p - 2, self.p)) % self.p\n\n def prep(self):\n \"\"\"\n 二項係数nCr(mod p)をO(1)で求める為の前処理をO(N)にて実行。\n \"\"\"\n for i in range(2, self.n + 1):\n self.fact.append((self.fact[-1] * i) % self.p)\n self.inv.append((-self.inv[self.p % i] * (self.p // i)) % self.p)\n self.factinv.append((self.factinv[-1] * self.inv[-1]) % self.p)\n\n def cmb_mod_with_prep(self, n, r):\n \"\"\"\n 二項係数nCr(mod p)をO(1)で求める。事前にprepを実行する事。\n \"\"\"\n if (r < 0) or (n < r):\n return 0\n r = min(r, n - r)\n return self.fact[n] * self.factinv[r] * self.factinv[n - r] % self.p", "CmbMod", "mod = 10 ** 9 + 7", "10 ** 9 + 7", "mod", "input = sys.stdin.readline", "sys.stdin.readline", "input" ]

[ 7, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 13, 13, 12, 13, 14, 2, 2, 13, 17, 2, 13, 13, 29, 17, 0, 13, 4, 13, 13, 2, 13, 13, 29, 2, 2, 2, 18, 13, 13, 18, 13, 13, 18, 13, 2, 13, 13, 13, 23, 13, 23, 13, 23, 13, 0, 13, 2, 2, 17, 17, 17, 0, 13, 2, 17, 2, 17, 17, 0, 13, 39, 17, 17, 0, 13, 39, 17, 17, 0, 13, 39, 17, 17, 28, 13, 4, 13, 17, 2, 13, 17, 4, 18, 13, 13, 2, 2, 18, 13, 17, 13, 13, 4, 18, 13, 13, 2, 2, 40, 18, 13, 2, 13, 13, 2, 13, 13, 13, 4, 18, 13, 13, 2, 2, 18, 13, 17, 18, 13, 17, 13, 0, 13, 39, 0, 13, 2, 13, 13, 0, 13, 2, 13, 17, 42, 2, 2, 13, 17, 40, 13, 13, 4, 18, 13, 13, 39, 13, 13, 0, 13, 17, 0, 13, 17, 0, 13, 17, 28, 13, 13, 0, 13, 18, 13, 17, 0, 13, 18, 13, 17, 0, 13, 2, 2, 4, 13, 2, 2, 13, 13, 17, 2, 13, 17, 13, 4, 13, 2, 2, 2, 13, 13, 13, 13, 2, 13, 13, 13, 13, 0, 13, 13, 4, 13, 13, 10, 39, 13, 10, 17, 13, 10, 2, 13, 10, 17, 13, 10, 17, 13, 10, 2, 13, 10, 18, 13, 10, 2, 13, 10, 12, 13, 10, 4, 13, 10, 18, 13, 10, 39, 13, 10, 4, 13, 10, 2, 13, 10, 2, 13, 10, 13, 13, 10, 4, 13, 10, 4, 13, 10, 39, 13, 10, 39, 13 ]

[ [ 270, 2 ], [ 270, 11 ], [ 270, 12 ], [ 270, 13 ], [ 53, 19 ], [ 53, 22 ], [ 51, 23 ], [ 28, 27 ], [ 53, 30 ], [ 51, 32 ], [ 53, 33 ], [ 51, 40 ], [ 27, 43 ], [ 53, 43 ], [ 51, 47 ], [ 27, 48 ], [ 53, 48 ], [ 55, 49 ], [ 51, 51 ], [ 53, 53 ], [ 55, 55 ], [ 234, 57 ], [ 261, 64 ], [ 273, 71 ], [ 219, 76 ], [ 252, 81 ], [ 87, 86 ], [ 262, 91 ], [ 274, 95 ], [ 274, 100 ], [ 86, 102 ], [ 235, 103 ], [ 253, 106 ], [ 253, 112 ], [ 235, 114 ], [ 86, 115 ], [ 235, 117 ], [ 86, 118 ], [ 235, 119 ], [ 220, 122 ], [ 220, 127 ], [ 253, 130 ], [ 235, 132 ], [ 276, 134 ], [ 240, 137 ], [ 268, 139 ], [ 247, 140 ], [ 258, 142 ], [ 271, 144 ], [ 241, 149 ], [ 223, 149 ], [ 259, 152 ], [ 229, 152 ], [ 256, 153 ], [ 277, 156 ], [ 222, 162 ], [ 228, 165 ], [ 231, 168 ], [ 172, 171 ], [ 277, 171 ], [ 237, 174 ], [ 171, 176 ], [ 249, 179 ], [ 171, 181 ], [ 225, 184 ], [ 244, 188 ], [ 238, 191 ], [ 223, 191 ], [ 241, 191 ], [ 250, 192 ], [ 229, 192 ], [ 259, 192 ], [ 238, 195 ], [ 223, 195 ], [ 241, 195 ], [ 235, 197 ], [ 244, 199 ], [ 268, 203 ], [ 238, 204 ], [ 223, 204 ], [ 241, 204 ], [ 256, 205 ], [ 250, 206 ], [ 229, 206 ], [ 259, 206 ], [ 268, 208 ], [ 238, 209 ], [ 223, 209 ], [ 241, 209 ], [ 235, 210 ], [ 235, 211 ], [ 264, 213 ], [ 235, 214 ], [ 265, 217 ], [ 226, 217 ], [ 232, 217 ], [ 219, 220 ], [ 222, 223 ], [ 225, 226 ], [ 228, 229 ], [ 231, 232 ], [ 234, 235 ], [ 237, 238 ], [ 240, 241 ], [ 270, 247 ], [ 249, 250 ], [ 252, 253 ], [ 270, 256 ], [ 258, 259 ], [ 261, 262 ], [ 235, 264 ], [ 264, 265 ], [ 270, 268 ], [ 270, 271 ], [ 273, 274 ], [ 276, 277 ] ]

[ "H,W,A,B = map(int, input().split())\n\ndef cmb(n, r, mod):\n if ( r<0 or r>n ):\n return 0\n r = min(r, n-r)\n return g1[n] * g2[r] * g2[n-r] % mod\n\nmod = 10**9+7 #出力の制限\nn = 3*10**5\ng1 = [1, 1] # 元テーブル\ng2 = [1, 1] #逆元テーブル\ninverse = [0, 1] #逆元テーブル計算用テーブル\n\nfor i in range( 2, n + 1 ):\n g1.append( ( g1[-1] * i ) % mod )\n inverse.append( ( -inverse[mod % i] * (mod//i) ) % mod )\n g2.append( (g2[-1] * inverse[-1]) % mod )\n\nL = []\ni = H-A\nj = B+1\nwhile i > 0 and j <= W:\n L.append((i, j))\n i -= 1\n j += 1\n \nans = 0\nfor t in L:\n i = t[0]\n j = t[1]\n ans += (cmb(i+j-2, i-1, mod) * cmb(H-i+W-j, H-i, mod)) % mod\n ans %= mod\n \nprint(ans)", "H,W,A,B = map(int, input().split())", "H", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "W", "A", "B", "def cmb(n, r, mod):\n if ( r<0 or r>n ):\n return 0\n r = min(r, n-r)\n return g1[n] * g2[r] * g2[n-r] % mod", "cmb", "if ( r<0 or r>n ):\n return 0\n ", "r<0 or r>n", "r<0", "r", "0", "r>n", "r", "n", "return 0", "0", "r = min(r, n-r)", "r", "min(r, n-r)", "min", "r", "n-r", "n", "r", "return g1[n] * g2[r] * g2[n-r] % mod", "g1[n] * g2[r] * g2[n-r] % mod", "g1[n] * g2[r] * g2[n-r]", "g1[n] * g2[r]", "g1[n]", "g1", "n", "g2[r]", "g2", "r", "g2[n-r]", "g2", "n-r", "n", "r", "mod", "n", "n", "r", "r", "mod", "mod", "mod = 10**9+7", "mod", "10**9+7", "10**9", "10", "9", "7", "n = 3*10**5", "n", "3*10**5", "3", "10**5", "10", "5", "g1 = [1, 1]", "g1", "[1, 1]", "1", "1", "g2 = [1, 1]", "g2", "[1, 1]", "1", "1", "inverse = [0, 1]", "inverse", "[0, 1]", "0", "1", "for i in range( 2, n + 1 ):\n g1.append( ( g1[-1] * i ) % mod )\n inverse.append( ( -inverse[mod % i] * (mod//i) ) % mod )\n g2.append( (g2[-1] * inverse[-1]) % mod )", "i", "range( 2, n + 1 )", "range", "2", "n + 1", "n", "1", "g1.append( ( g1[-1] * i ) % mod )", "g1.append", "g1", "append", "( g1[-1] * i ) % mod", "g1[-1] * i", "g1[-1]", "g1", "-1", "i", "mod", "inverse.append( ( -inverse[mod % i] * (mod//i) ) % mod )", "inverse.append", "inverse", "append", "( -inverse[mod % i] * (mod//i) ) % mod", "-inverse[mod % i] * (mod//i)", "-inverse[mod % i]", "inverse[mod % i]", "inverse", "mod % i", "mod", "i", "mod//i", "mod", "i", "mod", "g2.append( (g2[-1] * inverse[-1]) % mod )", "g2.append", "g2", "append", "(g2[-1] * inverse[-1]) % mod", "g2[-1] * inverse[-1]", "g2[-1]", "g2", "-1", "inverse[-1]", "inverse", "-1", "mod", "L = []", "L", "[]", "i = H-A", "i", "H-A", "H", "A", "j = B+1", "j", "B+1", "B", "1", "while i > 0 and j <= W:\n L.append((i, j))\n i -= 1\n j += 1\n ", "i > 0 and j <= W", "i > 0", "i", "0", "j <= W", "j", "W", "L.append((i, j))", "L.append", "L", "append", "(i, j)", "i", "j", "i -= 1", "i", "1", "j += 1", "j", "1", "ans = 0", "ans", "0", "for t in L:\n i = t[0]\n j = t[1]\n ans += (cmb(i+j-2, i-1, mod) * cmb(H-i+W-j, H-i, mod)) % mod\n ans %= mod\n ", "t", "L", "i = t[0]", "i", "t[0]", "t", "0", "j = t[1]", "j", "t[1]", "t", "1", "ans += (cmb(i+j-2, i-1, mod) * cmb(H-i+W-j, H-i, mod)) % mod", "ans", "(cmb(i+j-2, i-1, mod) * cmb(H-i+W-j, H-i, mod)) % mod", "cmb(i+j-2, i-1, mod) * cmb(H-i+W-j, H-i, mod)", "cmb(i+j-2, i-1, mod)", "cmb", "i+j-2", "i+j", "i", "j", "2", "i-1", "i", "1", "mod", "cmb(H-i+W-j, H-i, mod)", "cmb", "H-i+W-j", "H-i+W", "H-i", "H", "i", "W", "j", "H-i", "H", "i", "mod", "mod", "ans %= mod", "ans", "mod", "print(ans)", "print", "ans", "g2 = [1, 1]", "[1, 1]", "g2", "i -= 1", "1", "i", "ans += (cmb(i+j-2, i-1, mod) * cmb(H-i+W-j, H-i, mod)) % mod", "(cmb(i+j-2, i-1, mod) * cmb(H-i+W-j, H-i, mod)) % mod", "ans", "j += 1", "1", "j", "ans = 0", "0", "ans", "mod = 10**9+7", "10**9+7", "mod", "i = t[0]", "t[0]", "i", "i = H-A", "H-A", "i", "def cmb(n, r, mod):\n if ( r<0 or r>n ):\n return 0\n r = min(r, n-r)\n return g1[n] * g2[r] * g2[n-r] % mod", "def cmb(n, r, mod):\n if ( r<0 or r>n ):\n return 0\n r = min(r, n-r)\n return g1[n] * g2[r] * g2[n-r] % mod", "cmb", "A,B = map(int, input().split())", "map(int, input().split())", "A", "j = t[1]", "t[1]", "j", "inverse = [0, 1]", "[0, 1]", "inverse", "W,A,B = map(int, input().split())", "map(int, input().split())", "W", "j = B+1", "B+1", "j", "n = 3*10**5", "3*10**5", "n", "ans %= mod", "mod", "ans", "H,W,A,B = map(int, input().split())", "map(int, input().split())", "H", "B = map(int, input().split())", "map(int, input().split())", "B", "g1 = [1, 1]", "[1, 1]", "g1", "L = []", "[]", "L" ]

[ 7, 12, 13, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 13, 13, 0, 13, 2, 13, 17, 13, 2, 13, 17, 0, 13, 2, 2, 17, 17, 17, 0, 13, 2, 2, 13, 13, 17, 0, 13, 2, 39, 17, 13, 0, 13, 2, 39, 17, 13, 0, 13, 2, 39, 17, 13, 0, 18, 13, 39, 17, 39, 17, 17, 0, 18, 13, 39, 17, 39, 17, 17, 0, 18, 13, 39, 17, 39, 17, 17, 28, 13, 4, 13, 17, 13, 0, 18, 13, 13, 2, 2, 18, 13, 2, 13, 17, 13, 13, 0, 18, 13, 13, 2, 2, 40, 18, 13, 2, 13, 13, 2, 13, 13, 13, 0, 18, 13, 13, 2, 2, 18, 13, 2, 13, 17, 18, 13, 13, 13, 12, 13, 0, 13, 2, 2, 18, 13, 13, 18, 13, 13, 13, 29, 2, 2, 13, 18, 13, 2, 13, 13, 13, 23, 13, 23, 13, 0, 13, 17, 28, 13, 4, 13, 13, 2, 13, 17, 0, 13, 2, 13, 13, 0, 13, 2, 2, 4, 13, 2, 13, 13, 13, 4, 13, 2, 2, 2, 2, 13, 13, 13, 13, 17, 2, 13, 13, 13, 0, 13, 13, 0, 13, 13, 4, 13, 13, 14, 2, 13, 17, 4, 13, 10, 12, 13 ]

[ [ 5, 4 ], [ 5, 13 ], [ 5, 14 ], [ 5, 15 ], [ 18, 17 ], [ 4, 19 ], [ 22, 21 ], [ 13, 23 ], [ 27, 26 ], [ 34, 33 ], [ 17, 36 ], [ 4, 36 ], [ 21, 37 ], [ 13, 37 ], [ 41, 40 ], [ 33, 44 ], [ 47, 46 ], [ 33, 50 ], [ 53, 52 ], [ 33, 56 ], [ 62, 58 ], [ 40, 59 ], [ 70, 66 ], [ 46, 67 ], [ 78, 74 ], [ 52, 75 ], [ 83, 82 ], [ 33, 86 ], [ 91, 88 ], [ 40, 89 ], [ 82, 90 ], [ 40, 94 ], [ 82, 96 ], [ 82, 98 ], [ 26, 99 ], [ 104, 101 ], [ 52, 102 ], [ 82, 103 ], [ 52, 108 ], [ 26, 110 ], [ 82, 111 ], [ 26, 113 ], [ 82, 114 ], [ 26, 115 ], [ 120, 117 ], [ 46, 118 ], [ 82, 119 ], [ 46, 123 ], [ 82, 125 ], [ 101, 127 ], [ 52, 128 ], [ 82, 129 ], [ 26, 130 ], [ 135, 134 ], [ 40, 138 ], [ 155, 139 ], [ 46, 141 ], [ 157, 142 ], [ 26, 143 ], [ 134, 147 ], [ 46, 149 ], [ 155, 151 ], [ 157, 152 ], [ 26, 153 ], [ 155, 155 ], [ 157, 157 ], [ 160, 159 ], [ 163, 162 ], [ 15, 165 ], [ 21, 167 ], [ 13, 167 ], [ 171, 170 ], [ 17, 172 ], [ 4, 172 ], [ 14, 173 ], [ 176, 175 ], [ 132, 179 ], [ 162, 181 ], [ 170, 182 ], [ 162, 183 ], [ 132, 185 ], [ 17, 190 ], [ 4, 190 ], [ 21, 191 ], [ 13, 191 ], [ 162, 192 ], [ 170, 193 ], [ 21, 196 ], [ 13, 196 ], [ 162, 197 ], [ 26, 198 ], [ 201, 200 ], [ 175, 201 ], [ 204, 203 ], [ 26, 204 ], [ 203, 207 ], [ 200, 207 ], [ 159, 207 ], [ 216, 213 ] ]

[ "def main():\n\tH, W, A, B = map(int, input().split())\n\tH, W= H-1, W-1\n\tDIV = 10**9+7\n\tsize = H+W+1\n\n\tfact = [0]*size\n\tinverse = [0]*size\n\tinv_cal = [0]*size\n\tfact[:2] = [1, 1]\n\tinverse[:2] = [1, 1]\n\tinv_cal[:2] = [0, 1]\n\n\tfor i in range(2, size):\n\t\tfact[i] = (fact[i-1]*i%DIV)\n\t\tinv_cal[i] = (-inv_cal[DIV%i]*(DIV//i))%DIV\n\t\tinverse[i] = inverse[i-1]*inv_cal[i]%DIV\n\n\tdef C(n, r):\n\t\tans = fact[n]*inverse[r]%DIV\n\t\treturn ans*inverse[n-r]%DIV\n\n\tans = 0\n\tfor x in range(B, W+1):\n\t\ty = H-A\n\t\ttmp = (C(x+y, x)*C(H+W-x-y-1, W-x))%DIV\n\t\tans += tmp\n\t\tans %= DIV\n\n\tprint(ans)\n\n\nif __name__ == '__main__':\n\tmain()", "def main():\n\tH, W, A, B = map(int, input().split())\n\tH, W= H-1, W-1\n\tDIV = 10**9+7\n\tsize = H+W+1\n\n\tfact = [0]*size\n\tinverse = [0]*size\n\tinv_cal = [0]*size\n\tfact[:2] = [1, 1]\n\tinverse[:2] = [1, 1]\n\tinv_cal[:2] = [0, 1]\n\n\tfor i in range(2, size):\n\t\tfact[i] = (fact[i-1]*i%DIV)\n\t\tinv_cal[i] = (-inv_cal[DIV%i]*(DIV//i))%DIV\n\t\tinverse[i] = inverse[i-1]*inv_cal[i]%DIV\n\n\tdef C(n, r):\n\t\tans = fact[n]*inverse[r]%DIV\n\t\treturn ans*inverse[n-r]%DIV\n\n\tans = 0\n\tfor x in range(B, W+1):\n\t\ty = H-A\n\t\ttmp = (C(x+y, x)*C(H+W-x-y-1, W-x))%DIV\n\t\tans += tmp\n\t\tans %= DIV\n\n\tprint(ans)", "main", "H, W, A, B = map(int, input().split())", "H", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "W", "A", "B", "H, W= H-1, W-1", "H", "H-1", "H", "1", "W", "W-1", "W", "1", "DIV = 10**9+7", "DIV", "10**9+7", "10**9", "10", "9", "7", "size = H+W+1", "size", "H+W+1", "H+W", "H", "W", "1", "fact = [0]*size", "fact", "[0]*size", "[0]", "0", "size", "inverse = [0]*size", "inverse", "[0]*size", "[0]", "0", "size", "inv_cal = [0]*size", "inv_cal", "[0]*size", "[0]", "0", "size", "fact[:2] = [1, 1]", "fact[:2]", "fact", ":2", "2", "[1, 1]", "1", "1", "inverse[:2] = [1, 1]", "inverse[:2]", "inverse", ":2", "2", "[1, 1]", "1", "1", "inv_cal[:2] = [0, 1]", "inv_cal[:2]", "inv_cal", ":2", "2", "[0, 1]", "0", "1", "for i in range(2, size):\n\t\tfact[i] = (fact[i-1]*i%DIV)\n\t\tinv_cal[i] = (-inv_cal[DIV%i]*(DIV//i))%DIV\n\t\tinverse[i] = inverse[i-1]*inv_cal[i]%DIV\n\n\t", "i", "range(2, size)", "range", "2", "size", "fact[i] = (fact[i-1]*i%DIV)", "fact[i]", "fact", "i", "fact[i-1]*i%DIV", "fact[i-1]*i", "fact[i-1]", "fact", "i-1", "i", "1", "i", "DIV", "inv_cal[i] = (-inv_cal[DIV%i]*(DIV//i))%DIV", "inv_cal[i]", "inv_cal", "i", "(-inv_cal[DIV%i]*(DIV//i))%DIV", "-inv_cal[DIV%i]*(DIV//i)", "-inv_cal[DIV%i]", "inv_cal[DIV%i]", "inv_cal", "DIV%i", "DIV", "i", "DIV//i", "DIV", "i", "DIV", "inverse[i] = inverse[i-1]*inv_cal[i]%DIV", "inverse[i]", "inverse", "i", "inverse[i-1]*inv_cal[i]%DIV", "inverse[i-1]*inv_cal[i]", "inverse[i-1]", "inverse", "i-1", "i", "1", "inv_cal[i]", "inv_cal", "i", "DIV", "def C(n, r):\n\t\tans = fact[n]*inverse[r]%DIV\n\t\treturn ans*inverse[n-r]%DIV\n\n\t", "C", "ans = fact[n]*inverse[r]%DIV", "ans", "fact[n]*inverse[r]%DIV", "fact[n]*inverse[r]", "fact[n]", "fact", "n", "inverse[r]", "inverse", "r", "DIV", "return ans*inverse[n-r]%DIV", "ans*inverse[n-r]%DIV", "ans*inverse[n-r]", "ans", "inverse[n-r]", "inverse", "n-r", "n", "r", "DIV", "n", "n", "r", "r", "ans = 0", "ans", "0", "for x in range(B, W+1):\n\t\ty = H-A\n\t\ttmp = (C(x+y, x)*C(H+W-x-y-1, W-x))%DIV\n\t\tans += tmp\n\t\tans %= DIV\n\n\t", "x", "range(B, W+1)", "range", "B", "W+1", "W", "1", "y = H-A", "y", "H-A", "H", "A", "tmp = (C(x+y, x)*C(H+W-x-y-1, W-x))%DIV", "tmp", "(C(x+y, x)*C(H+W-x-y-1, W-x))%DIV", "C(x+y, x)*C(H+W-x-y-1, W-x)", "C(x+y, x)", "C", "x+y", "x", "y", "x", "C(H+W-x-y-1, W-x)", "C", "H+W-x-y-1", "H+W-x-y", "H+W-x", "H+W", "H", "W", "x", "y", "1", "W-x", "W", "x", "DIV", "ans += tmp", "ans", "tmp", "ans %= DIV", "ans", "DIV", "print(ans)", "print", "ans", "if __name__ == '__main__':\n\tmain()", "__name__ == '__main__'", "__name__", "'__main__'", "main()", "main", "def main():\n\tH, W, A, B = map(int, input().split())\n\tH, W= H-1, W-1\n\tDIV = 10**9+7\n\tsize = H+W+1\n\n\tfact = [0]*size\n\tinverse = [0]*size\n\tinv_cal = [0]*size\n\tfact[:2] = [1, 1]\n\tinverse[:2] = [1, 1]\n\tinv_cal[:2] = [0, 1]\n\n\tfor i in range(2, size):\n\t\tfact[i] = (fact[i-1]*i%DIV)\n\t\tinv_cal[i] = (-inv_cal[DIV%i]*(DIV//i))%DIV\n\t\tinverse[i] = inverse[i-1]*inv_cal[i]%DIV\n\n\tdef C(n, r):\n\t\tans = fact[n]*inverse[r]%DIV\n\t\treturn ans*inverse[n-r]%DIV\n\n\tans = 0\n\tfor x in range(B, W+1):\n\t\ty = H-A\n\t\ttmp = (C(x+y, x)*C(H+W-x-y-1, W-x))%DIV\n\t\tans += tmp\n\t\tans %= DIV\n\n\tprint(ans)", "def main():\n\tH, W, A, B = map(int, input().split())\n\tH, W= H-1, W-1\n\tDIV = 10**9+7\n\tsize = H+W+1\n\n\tfact = [0]*size\n\tinverse = [0]*size\n\tinv_cal = [0]*size\n\tfact[:2] = [1, 1]\n\tinverse[:2] = [1, 1]\n\tinv_cal[:2] = [0, 1]\n\n\tfor i in range(2, size):\n\t\tfact[i] = (fact[i-1]*i%DIV)\n\t\tinv_cal[i] = (-inv_cal[DIV%i]*(DIV//i))%DIV\n\t\tinverse[i] = inverse[i-1]*inv_cal[i]%DIV\n\n\tdef C(n, r):\n\t\tans = fact[n]*inverse[r]%DIV\n\t\treturn ans*inverse[n-r]%DIV\n\n\tans = 0\n\tfor x in range(B, W+1):\n\t\ty = H-A\n\t\ttmp = (C(x+y, x)*C(H+W-x-y-1, W-x))%DIV\n\t\tans += tmp\n\t\tans %= DIV\n\n\tprint(ans)", "main" ]

[ 7, 12, 13, 14, 2, 2, 13, 17, 2, 13, 13, 29, 17, 0, 13, 4, 13, 13, 2, 13, 13, 29, 2, 2, 2, 18, 13, 13, 18, 13, 13, 18, 13, 2, 13, 13, 13, 23, 13, 23, 13, 23, 13, 0, 13, 2, 2, 17, 17, 17, 0, 13, 2, 2, 17, 17, 17, 0, 13, 39, 17, 17, 0, 13, 39, 17, 17, 0, 13, 39, 17, 17, 28, 13, 4, 13, 17, 2, 13, 17, 4, 18, 13, 13, 2, 2, 18, 13, 17, 13, 13, 4, 18, 13, 13, 2, 2, 40, 18, 13, 2, 13, 13, 2, 13, 13, 13, 4, 18, 13, 13, 2, 2, 18, 13, 17, 18, 13, 17, 13, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 13, 13, 0, 13, 17, 28, 13, 4, 13, 2, 13, 13, 0, 13, 2, 13, 2, 4, 13, 2, 2, 13, 13, 17, 13, 13, 4, 13, 2, 2, 2, 2, 13, 13, 13, 13, 17, 2, 2, 13, 13, 17, 13, 4, 13, 2, 13, 13, 10, 2, 13, 10, 4, 13, 10, 39, 13, 10, 4, 13, 10, 4, 13, 10, 39, 13, 10, 39, 13, 10, 2, 13, 10, 2, 13, 10, 4, 13, 10, 12, 13, 10, 17, 13 ]

[ [ 40, 6 ], [ 40, 9 ], [ 38, 10 ], [ 15, 14 ], [ 40, 17 ], [ 38, 19 ], [ 40, 20 ], [ 38, 27 ], [ 14, 30 ], [ 40, 30 ], [ 38, 34 ], [ 14, 35 ], [ 40, 35 ], [ 42, 36 ], [ 38, 38 ], [ 40, 40 ], [ 42, 42 ], [ 180, 44 ], [ 201, 51 ], [ 186, 58 ], [ 195, 63 ], [ 198, 68 ], [ 74, 73 ], [ 202, 78 ], [ 187, 82 ], [ 187, 87 ], [ 73, 89 ], [ 181, 90 ], [ 199, 93 ], [ 199, 99 ], [ 181, 101 ], [ 73, 102 ], [ 181, 104 ], [ 73, 105 ], [ 181, 106 ], [ 196, 109 ], [ 196, 114 ], [ 199, 117 ], [ 181, 119 ], [ 207, 121 ], [ 207, 130 ], [ 207, 131 ], [ 207, 132 ], [ 213, 134 ], [ 138, 137 ], [ 184, 141 ], [ 193, 142 ], [ 204, 144 ], [ 214, 146 ], [ 205, 146 ], [ 211, 149 ], [ 190, 152 ], [ 137, 153 ], [ 137, 155 ], [ 181, 156 ], [ 211, 158 ], [ 208, 163 ], [ 184, 164 ], [ 190, 165 ], [ 137, 166 ], [ 208, 170 ], [ 190, 171 ], [ 181, 173 ], [ 205, 177 ], [ 214, 177 ], [ 181, 178 ], [ 180, 181 ], [ 207, 184 ], [ 186, 187 ], [ 207, 190 ], [ 207, 193 ], [ 195, 196 ], [ 198, 199 ], [ 201, 202 ], [ 204, 205 ], [ 207, 208 ], [ 213, 214 ] ]

[ "def cmb(n, r, mod):\n if ( r<0 or r>n ):\n return 0\n r = min(r, n-r)\n return g1[n] * g2[r] * g2[n-r] % mod\n\nmod = 10**9+7 #出力の制限\nN = 10**6+3\ng1 = [1, 1] # 元テーブル\ng2 = [1, 1] #逆元テーブル\ninverse = [0, 1] #逆元テーブル計算用テーブル\n\nfor i in range( 2, N + 1 ):\n g1.append( ( g1[-1] * i ) % mod )\n inverse.append( ( -inverse[mod % i] * (mod//i) ) % mod )\n g2.append( (g2[-1] * inverse[-1]) % mod )\n\nh,w,a,b=map(int,input().split())\nans=0\nfor j in range(h-a):\n ans=ans+cmb(b+j-1,j,mod)*cmb(w+h-b-j-2,w-b-1,mod)\nprint(ans%mod)", "def cmb(n, r, mod):\n if ( r<0 or r>n ):\n return 0\n r = min(r, n-r)\n return g1[n] * g2[r] * g2[n-r] % mod", "cmb", "if ( r<0 or r>n ):\n return 0\n ", "r<0 or r>n", "r<0", "r", "0", "r>n", "r", "n", "return 0", "0", "r = min(r, n-r)", "r", "min(r, n-r)", "min", "r", "n-r", "n", "r", "return g1[n] * g2[r] * g2[n-r] % mod", "g1[n] * g2[r] * g2[n-r] % mod", "g1[n] * g2[r] * g2[n-r]", "g1[n] * g2[r]", "g1[n]", "g1", "n", "g2[r]", "g2", "r", "g2[n-r]", "g2", "n-r", "n", "r", "mod", "n", "n", "r", "r", "mod", "mod", "mod = 10**9+7", "mod", "10**9+7", "10**9", "10", "9", "7", "N = 10**6+3", "N", "10**6+3", "10**6", "10", "6", "3", "g1 = [1, 1]", "g1", "[1, 1]", "1", "1", "g2 = [1, 1]", "g2", "[1, 1]", "1", "1", "inverse = [0, 1]", "inverse", "[0, 1]", "0", "1", "for i in range( 2, N + 1 ):\n g1.append( ( g1[-1] * i ) % mod )\n inverse.append( ( -inverse[mod % i] * (mod//i) ) % mod )\n g2.append( (g2[-1] * inverse[-1]) % mod )", "i", "range( 2, N + 1 )", "range", "2", "N + 1", "N", "1", "g1.append( ( g1[-1] * i ) % mod )", "g1.append", "g1", "append", "( g1[-1] * i ) % mod", "g1[-1] * i", "g1[-1]", "g1", "-1", "i", "mod", "inverse.append( ( -inverse[mod % i] * (mod//i) ) % mod )", "inverse.append", "inverse", "append", "( -inverse[mod % i] * (mod//i) ) % mod", "-inverse[mod % i] * (mod//i)", "-inverse[mod % i]", "inverse[mod % i]", "inverse", "mod % i", "mod", "i", "mod//i", "mod", "i", "mod", "g2.append( (g2[-1] * inverse[-1]) % mod )", "g2.append", "g2", "append", "(g2[-1] * inverse[-1]) % mod", "g2[-1] * inverse[-1]", "g2[-1]", "g2", "-1", "inverse[-1]", "inverse", "-1", "mod", "h,w,a,b=map(int,input().split())", "h", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "w", "a", "b", "ans=0", "ans", "0", "for j in range(h-a):\n ans=ans+cmb(b+j-1,j,mod)*cmb(w+h-b-j-2,w-b-1,mod)", "j", "range(h-a)", "range", "h-a", "h", "a", "ans=ans+cmb(b+j-1,j,mod)*cmb(w+h-b-j-2,w-b-1,mod)", "ans", "ans+cmb(b+j-1,j,mod)*cmb(w+h-b-j-2,w-b-1,mod)", "ans", "cmb(b+j-1,j,mod)*cmb(w+h-b-j-2,w-b-1,mod)", "cmb(b+j-1,j,mod)", "cmb", "b+j-1", "b+j", "b", "j", "1", "j", "mod", "cmb(w+h-b-j-2,w-b-1,mod)", "cmb", "w+h-b-j-2", "w+h-b-j", "w+h-b", "w+h", "w", "h", "b", "j", "2", "w-b-1", "w-b", "w", "b", "1", "mod", "print(ans%mod)", "print", "ans%mod", "ans", "mod", "mod = 10**9+7", "10**9+7", "mod", "h,w,a,b=map(int,input().split())", "map(int,input().split())", "h", "g1 = [1, 1]", "[1, 1]", "g1", "b=map(int,input().split())", "map(int,input().split())", "b", "a,b=map(int,input().split())", "map(int,input().split())", "a", "g2 = [1, 1]", "[1, 1]", "g2", "inverse = [0, 1]", "[0, 1]", "inverse", "N = 10**6+3", "10**6+3", "N", "ans=ans+cmb(b+j-1,j,mod)*cmb(w+h-b-j-2,w-b-1,mod)", "ans+cmb(b+j-1,j,mod)*cmb(w+h-b-j-2,w-b-1,mod)", "ans", "w,a,b=map(int,input().split())", "map(int,input().split())", "w", "def cmb(n, r, mod):\n if ( r<0 or r>n ):\n return 0\n r = min(r, n-r)\n return g1[n] * g2[r] * g2[n-r] % mod", "def cmb(n, r, mod):\n if ( r<0 or r>n ):\n return 0\n r = min(r, n-r)\n return g1[n] * g2[r] * g2[n-r] % mod", "cmb", "ans=0", "0", "ans" ]

[ 7, 15, 0, 13, 18, 13, 13, 0, 13, 17, 0, 13, 2, 2, 17, 17, 17, 12, 13, 0, 18, 13, 17, 17, 18, 13, 17, 17, 0, 18, 13, 17, 17, 18, 13, 17, 17, 0, 18, 13, 17, 17, 28, 13, 4, 13, 17, 13, 0, 18, 13, 13, 2, 2, 18, 13, 2, 13, 17, 13, 13, 0, 18, 13, 13, 2, 13, 2, 2, 18, 13, 2, 13, 13, 2, 13, 13, 13, 0, 18, 13, 13, 2, 2, 18, 13, 2, 13, 17, 18, 13, 13, 13, 12, 13, 14, 2, 13, 13, 29, 17, 14, 2, 2, 13, 17, 2, 13, 17, 29, 17, 29, 2, 2, 18, 13, 13, 2, 2, 18, 13, 13, 18, 13, 2, 13, 13, 13, 13, 23, 13, 23, 13, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 13, 13, 0, 13, 2, 39, 17, 13, 0, 13, 2, 39, 17, 13, 0, 13, 2, 39, 17, 13, 0, 13, 4, 13, 2, 13, 13, 2, 13, 13, 0, 13, 17, 13, 17, 0, 13, 17, 4, 13, 28, 13, 4, 13, 13, 0, 13, 2, 2, 2, 2, 2, 13, 13, 17, 13, 13, 13, 0, 13, 2, 2, 2, 2, 2, 13, 13, 17, 13, 13, 13, 0, 13, 2, 2, 4, 13, 13, 2, 13, 13, 4, 13, 13, 2, 13, 13, 13, 0, 13, 17, 0, 13, 17, 4, 13, 2, 13, 13, 10, 17, 13, 10, 4, 13, 10, 2, 13, 10, 2, 13, 10, 12, 13, 10, 2, 13, 10, 2, 13, 10, 4, 13, 10, 17, 13, 10, 18, 13, 10, 4, 13, 10, 2, 13, 10, 4, 13, 10, 12, 13, 10, 17, 13, 10, 2, 13, 10, 17, 13, 10, 17, 13, 10, 2, 13, 10, 17, 13, 10, 4, 13 ]

[ [ 271, 3 ], [ 292, 8 ], [ 289, 11 ], [ 23, 20 ], [ 27, 24 ], [ 32, 29 ], [ 36, 33 ], [ 41, 38 ], [ 44, 43 ], [ 293, 47 ], [ 52, 49 ], [ 43, 51 ], [ 43, 57 ], [ 43, 59 ], [ 290, 60 ], [ 65, 62 ], [ 43, 64 ], [ 290, 66 ], [ 290, 72 ], [ 43, 73 ], [ 290, 75 ], [ 43, 76 ], [ 290, 77 ], [ 82, 79 ], [ 43, 81 ], [ 43, 87 ], [ 62, 89 ], [ 43, 91 ], [ 290, 92 ], [ 130, 97 ], [ 132, 98 ], [ 130, 104 ], [ 132, 107 ], [ 130, 116 ], [ 132, 121 ], [ 130, 125 ], [ 132, 126 ], [ 290, 127 ], [ 290, 128 ], [ 130, 130 ], [ 132, 132 ], [ 304, 134 ], [ 272, 141 ], [ 304, 143 ], [ 304, 144 ], [ 304, 145 ], [ 298, 147 ], [ 293, 151 ], [ 262, 153 ], [ 293, 157 ], [ 277, 159 ], [ 293, 163 ], [ 274, 165 ], [ 266, 169 ], [ 248, 170 ], [ 305, 172 ], [ 281, 173 ], [ 295, 175 ], [ 268, 177 ], [ 244, 180 ], [ 284, 183 ], [ 186, 185 ], [ 275, 188 ], [ 259, 190 ], [ 266, 196 ], [ 248, 197 ], [ 281, 199 ], [ 296, 200 ], [ 302, 200 ], [ 269, 201 ], [ 287, 201 ], [ 250, 203 ], [ 248, 209 ], [ 305, 210 ], [ 281, 212 ], [ 296, 213 ], [ 302, 213 ], [ 269, 214 ], [ 287, 214 ], [ 253, 216 ], [ 257, 220 ], [ 260, 221 ], [ 281, 223 ], [ 296, 224 ], [ 302, 224 ], [ 257, 226 ], [ 251, 227 ], [ 248, 229 ], [ 269, 230 ], [ 287, 230 ], [ 290, 231 ], [ 301, 233 ], [ 286, 236 ], [ 254, 241 ], [ 245, 241 ], [ 290, 242 ], [ 244, 245 ], [ 304, 248 ], [ 250, 251 ], [ 253, 254 ], [ 259, 260 ], [ 262, 263 ], [ 304, 266 ], [ 268, 269 ], [ 271, 272 ], [ 274, 275 ], [ 277, 278 ], [ 304, 281 ], [ 286, 287 ], [ 289, 290 ], [ 292, 293 ], [ 295, 296 ], [ 298, 299 ], [ 301, 302 ], [ 304, 305 ] ]

[ "from sys import stdin\ninput = stdin.readline\n\nMAX = 510000\nMOD = 10**9 + 7\n\ndef MakeTable():\n fac[0], fac[1] = 1, 1\n finv[0], finv[1] = 1, 1\n inv[1] = 1\n for i in range(2, MAX):\n fac[i] = fac[i - 1] * i % MOD\n inv[i] = MOD - inv[MOD%i] * (MOD // i) % MOD\n finv[i] = finv[i - 1] * inv[i] % MOD\n\ndef COM(n, k):\n if n < k:\n return 0\n elif n < 0 or k < 0:\n return 0\n else:\n return fac[n] * (finv[k] * finv[n - k] % MOD) % MOD\n\nH, W, A, B = map(int, input().split())\nfac = [0] * MAX\nfinv = [0] * MAX\ninv = [0] * MAX\n\nN = min(H-A, W-B)\nx, y = 0, 0\nresult = 0\n\nMakeTable()\n\nfor _ in range(N):\n n1 = H-A-1+B+x-y\n n2 = A+W-1-B-x+y\n result += (COM(n1, B+x) * COM(n2, A+y)) % MOD\n x += 1\n y += 1\n\nprint(result%MOD)", "from sys import stdin", "input = stdin.readline", "input", "stdin.readline", "stdin", "readline", "MAX = 510000", "MAX", "510000", "MOD = 10**9 + 7", "MOD", "10**9 + 7", "10**9", "10", "9", "7", "def MakeTable():\n fac[0], fac[1] = 1, 1\n finv[0], finv[1] = 1, 1\n inv[1] = 1\n for i in range(2, MAX):\n fac[i] = fac[i - 1] * i % MOD\n inv[i] = MOD - inv[MOD%i] * (MOD // i) % MOD\n finv[i] = finv[i - 1] * inv[i] % MOD", "MakeTable", "fac[0], fac[1] = 1, 1", "fac[0]", "fac", "0", "1", "fac[1]", "fac", "1", "1", "finv[0], finv[1] = 1, 1", "finv[0]", "finv", "0", "1", "finv[1]", "finv", "1", "1", "inv[1] = 1", "inv[1]", "inv", "1", "1", "for i in range(2, MAX):\n fac[i] = fac[i - 1] * i % MOD\n inv[i] = MOD - inv[MOD%i] * (MOD // i) % MOD\n finv[i] = finv[i - 1] * inv[i] % MOD", "i", "range(2, MAX)", "range", "2", "MAX", "fac[i] = fac[i - 1] * i % MOD", "fac[i]", "fac", "i", "fac[i - 1] * i % MOD", "fac[i - 1] * i", "fac[i - 1]", "fac", "i - 1", "i", "1", "i", "MOD", "inv[i] = MOD - inv[MOD%i] * (MOD // i) % MOD", "inv[i]", "inv", "i", "MOD - inv[MOD%i] * (MOD // i) % MOD", "MOD", "inv[MOD%i] * (MOD // i) % MOD", "inv[MOD%i] * (MOD // i)", "inv[MOD%i]", "inv", "MOD%i", "MOD", "i", "MOD // i", "MOD", "i", "MOD", "finv[i] = finv[i - 1] * inv[i] % MOD", "finv[i]", "finv", "i", "finv[i - 1] * inv[i] % MOD", "finv[i - 1] * inv[i]", "finv[i - 1]", "finv", "i - 1", "i", "1", "inv[i]", "inv", "i", "MOD", "def COM(n, k):\n if n < k:\n return 0\n elif n < 0 or k < 0:\n return 0\n else:\n return fac[n] * (finv[k] * finv[n - k] % MOD) % MOD", "COM", "if n < k:\n return 0\n elif n < 0 or k < 0:\n return 0\n else:\n return fac[n] * (finv[k] * finv[n - k] % MOD) % MOD", "n < k", "n", "k", "return 0", "0", "elif n < 0 or k < 0:\n return 0\n ", "n < 0 or k < 0", "n < 0", "n", "0", "k < 0", "k", "0", "return 0", "0", "return fac[n] * (finv[k] * finv[n - k] % MOD) % MOD", "fac[n] * (finv[k] * finv[n - k] % MOD) % MOD", "fac[n] * (finv[k] * finv[n - k] % MOD)", "fac[n]", "fac", "n", "finv[k] * finv[n - k] % MOD", "finv[k] * finv[n - k]", "finv[k]", "finv", "k", "finv[n - k]", "finv", "n - k", "n", "k", "MOD", "MOD", "n", "n", "k", "k", "H, W, A, B = map(int, input().split())", "H", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "W", "A", "B", "fac = [0] * MAX", "fac", "[0] * MAX", "[0]", "0", "MAX", "finv = [0] * MAX", "finv", "[0] * MAX", "[0]", "0", "MAX", "inv = [0] * MAX", "inv", "[0] * MAX", "[0]", "0", "MAX", "N = min(H-A, W-B)", "N", "min(H-A, W-B)", "min", "H-A", "H", "A", "W-B", "W", "B", "x, y = 0, 0", "x", "0", "y", "0", "result = 0", "result", "0", "MakeTable()", "MakeTable", "for _ in range(N):\n n1 = H-A-1+B+x-y\n n2 = A+W-1-B-x+y\n result += (COM(n1, B+x) * COM(n2, A+y)) % MOD\n x += 1\n y += 1", "_", "range(N)", "range", "N", "n1 = H-A-1+B+x-y", "n1", "H-A-1+B+x-y", "H-A-1+B+x", "H-A-1+B", "H-A-1", "H-A", "H", "A", "1", "B", "x", "y", "n2 = A+W-1-B-x+y", "n2", "A+W-1-B-x+y", "A+W-1-B-x", "A+W-1-B", "A+W-1", "A+W", "A", "W", "1", "B", "x", "y", "result += (COM(n1, B+x) * COM(n2, A+y)) % MOD", "result", "(COM(n1, B+x) * COM(n2, A+y)) % MOD", "COM(n1, B+x) * COM(n2, A+y)", "COM(n1, B+x)", "COM", "n1", "B+x", "B", "x", "COM(n2, A+y)", "COM", "n2", "A+y", "A", "y", "MOD", "x += 1", "x", "1", "y += 1", "y", "1", "print(result%MOD)", "print", "result%MOD", "result", "MOD", "result = 0", "0", "result", "A, B = map(int, input().split())", "map(int, input().split())", "A", "n2 = A+W-1-B-x+y", "A+W-1-B-x+y", "n2", "result += (COM(n1, B+x) * COM(n2, A+y)) % MOD", "(COM(n1, B+x) * COM(n2, A+y)) % MOD", "result", "def COM(n, k):\n if n < k:\n return 0\n elif n < 0 or k < 0:\n return 0\n else:\n return fac[n] * (finv[k] * finv[n - k] % MOD) % MOD", "def COM(n, k):\n if n < k:\n return 0\n elif n < 0 or k < 0:\n return 0\n else:\n return fac[n] * (finv[k] * finv[n - k] % MOD) % MOD", "COM", "n1 = H-A-1+B+x-y", "H-A-1+B+x-y", "n1", "finv = [0] * MAX", "[0] * MAX", "finv", "H, W, A, B = map(int, input().split())", "map(int, input().split())", "H", "y = 0, 0", "0", "y", "input = stdin.readline", "stdin.readline", "input", "N = min(H-A, W-B)", "min(H-A, W-B)", "N", "inv = [0] * MAX", "[0] * MAX", "inv", "B = map(int, input().split())", "map(int, input().split())", "B", "def MakeTable():\n fac[0], fac[1] = 1, 1\n finv[0], finv[1] = 1, 1\n inv[1] = 1\n for i in range(2, MAX):\n fac[i] = fac[i - 1] * i % MOD\n inv[i] = MOD - inv[MOD%i] * (MOD // i) % MOD\n finv[i] = finv[i - 1] * inv[i] % MOD", "def MakeTable():\n fac[0], fac[1] = 1, 1\n finv[0], finv[1] = 1, 1\n inv[1] = 1\n for i in range(2, MAX):\n fac[i] = fac[i - 1] * i % MOD\n inv[i] = MOD - inv[MOD%i] * (MOD // i) % MOD\n finv[i] = finv[i - 1] * inv[i] % MOD", "MakeTable", "y += 1", "1", "y", "MOD = 10**9 + 7", "10**9 + 7", "MOD", "MAX = 510000", "510000", "MAX", "x, y = 0, 0", "0", "x", "fac = [0] * MAX", "[0] * MAX", "fac", "x += 1", "1", "x", "W, A, B = map(int, input().split())", "map(int, input().split())", "W" ]

[ 7, 0, 13, 2, 2, 17, 17, 17, 12, 13, 41, 0, 13, 2, 39, 17, 2, 13, 17, 0, 18, 13, 17, 17, 28, 13, 4, 13, 13, 0, 18, 13, 2, 13, 17, 2, 2, 18, 13, 13, 2, 13, 17, 13, 0, 13, 2, 39, 17, 2, 13, 17, 0, 18, 13, 13, 4, 13, 18, 13, 13, 2, 13, 17, 13, 28, 13, 4, 13, 13, 17, 17, 0, 18, 13, 2, 13, 17, 2, 2, 18, 13, 13, 13, 13, 29, 39, 13, 13, 23, 13, 12, 13, 0, 13, 2, 13, 13, 0, 13, 2, 13, 13, 0, 13, 18, 13, 2, 13, 13, 0, 13, 2, 18, 13, 13, 18, 13, 13, 0, 13, 13, 29, 13, 23, 13, 23, 13, 23, 13, 23, 13, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 13, 13, 0, 13, 4, 13, 2, 13, 13, 13, 0, 13, 17, 42, 2, 2, 13, 17, 2, 13, 17, 0, 13, 2, 13, 13, 0, 13, 2, 13, 17, 0, 13, 4, 13, 17, 17, 13, 13, 0, 13, 4, 13, 13, 13, 2, 13, 17, 2, 13, 17, 0, 13, 2, 13, 13, 0, 13, 13, 0, 13, 17, 0, 13, 17, 0, 13, 4, 13, 17, 17, 2, 13, 17, 2, 13, 17, 4, 13, 2, 2, 13, 13, 13, 10, 17, 13, 10, 12, 13, 10, 4, 13, 10, 4, 13, 10, 13, 13, 10, 4, 13, 10, 2, 13, 10, 4, 13, 10, 4, 13, 10, 4, 13, 10, 4, 13, 10, 4, 13, 10, 17, 13, 10, 2, 13, 10, 12, 13, 10, 17, 13, 10, 2, 13, 10, 2, 13, 10, 4, 13 ]

[ [ 276, 2 ], [ 13, 12 ], [ 90, 17 ], [ 23, 20 ], [ 12, 21 ], [ 26, 25 ], [ 90, 28 ], [ 35, 30 ], [ 12, 31 ], [ 25, 33 ], [ 12, 38 ], [ 25, 39 ], [ 25, 41 ], [ 46, 45 ], [ 90, 50 ], [ 56, 53 ], [ 45, 54 ], [ 90, 55 ], [ 12, 59 ], [ 90, 60 ], [ 67, 66 ], [ 90, 69 ], [ 78, 73 ], [ 45, 74 ], [ 66, 76 ], [ 45, 81 ], [ 66, 82 ], [ 66, 83 ], [ 90, 90 ], [ 95, 94 ], [ 129, 96 ], [ 125, 97 ], [ 100, 99 ], [ 131, 101 ], [ 127, 102 ], [ 105, 104 ], [ 94, 108 ], [ 99, 109 ], [ 112, 111 ], [ 94, 115 ], [ 99, 118 ], [ 121, 120 ], [ 277, 121 ], [ 120, 123 ], [ 111, 123 ], [ 104, 123 ], [ 125, 125 ], [ 127, 127 ], [ 129, 129 ], [ 131, 131 ], [ 261, 133 ], [ 261, 142 ], [ 261, 143 ], [ 261, 144 ], [ 237, 146 ], [ 271, 148 ], [ 259, 150 ], [ 262, 151 ], [ 237, 152 ], [ 264, 154 ], [ 244, 159 ], [ 274, 159 ], [ 250, 162 ], [ 229, 162 ], [ 246, 165 ], [ 259, 167 ], [ 244, 168 ], [ 274, 168 ], [ 267, 170 ], [ 250, 172 ], [ 229, 172 ], [ 255, 175 ], [ 232, 177 ], [ 247, 180 ], [ 268, 181 ], [ 252, 183 ], [ 232, 185 ], [ 247, 186 ], [ 268, 187 ], [ 259, 189 ], [ 262, 192 ], [ 279, 195 ], [ 256, 197 ], [ 253, 198 ], [ 240, 200 ], [ 277, 201 ], [ 273, 203 ], [ 228, 206 ], [ 282, 209 ], [ 232, 211 ], [ 259, 215 ], [ 262, 218 ], [ 283, 224 ], [ 241, 225 ], [ 280, 225 ], [ 265, 225 ], [ 277, 226 ], [ 228, 229 ], [ 237, 235 ], [ 237, 238 ], [ 277, 240 ], [ 240, 241 ], [ 261, 244 ], [ 246, 247 ], [ 261, 250 ], [ 252, 253 ], [ 255, 256 ], [ 261, 259 ], [ 261, 262 ], [ 264, 265 ], [ 267, 268 ], [ 273, 274 ], [ 276, 277 ], [ 279, 280 ], [ 282, 283 ] ]

[ "MOD = 10 ** 9 + 7\n\n\ndef prepare(n):\n global MOD\n modFacts = [0] * (n + 1)\n modFacts[0] = 1\n for i in range(n):\n modFacts[i + 1] = (modFacts[i] * (i + 1)) % MOD\n\n invs = [1] * (n + 1)\n invs[n] = pow(modFacts[n], MOD - 2, MOD)\n for i in range(n, 1, -1):\n invs[i - 1] = (invs[i] * i) % MOD\n\n return modFacts, invs\n\n\ndef pathVar(sx, sy, gx, gy):\n x = gx - sx\n y = gy - sy\n rst = modFacts[x + y]\n rst *= invs[x] * invs[y]\n rst %= MOD\n return rst\n\n\nH, W, A, B = map(int, input().split())\n# H -= 1; W -= 1\nmodFacts, invs = prepare(H + W)\n\ncnt = 0\nwhile A > 0 and B > 0:\n x = H - A\n y = B - 1\n path1 = pathVar(0, 0, x, y)\n path2 = pathVar(x, y, H - 1, W - 1)\n cnt += path1 * path2\n cnt %= MOD\n A -= 1; B -= 1\n\nans = pathVar(0, 0, H - 1, W - 1)\nprint((ans - cnt) % MOD)", "MOD = 10 ** 9 + 7", "MOD", "10 ** 9 + 7", "10 ** 9", "10", "9", "7", "def prepare(n):\n global MOD\n modFacts = [0] * (n + 1)\n modFacts[0] = 1\n for i in range(n):\n modFacts[i + 1] = (modFacts[i] * (i + 1)) % MOD\n\n invs = [1] * (n + 1)\n invs[n] = pow(modFacts[n], MOD - 2, MOD)\n for i in range(n, 1, -1):\n invs[i - 1] = (invs[i] * i) % MOD\n\n return modFacts, invs", "prepare", "global MOD", "modFacts = [0] * (n + 1)", "modFacts", "[0] * (n + 1)", "[0]", "0", "n + 1", "n", "1", "modFacts[0] = 1", "modFacts[0]", "modFacts", "0", "1", "for i in range(n):\n modFacts[i + 1] = (modFacts[i] * (i + 1)) % MOD\n\n ", "i", "range(n)", "range", "n", "modFacts[i + 1] = (modFacts[i] * (i + 1)) % MOD", "modFacts[i + 1]", "modFacts", "i + 1", "i", "1", "(modFacts[i] * (i + 1)) % MOD", "modFacts[i] * (i + 1)", "modFacts[i]", "modFacts", "i", "i + 1", "i", "1", "MOD", "invs = [1] * (n + 1)", "invs", "[1] * (n + 1)", "[1]", "1", "n + 1", "n", "1", "invs[n] = pow(modFacts[n], MOD - 2, MOD)", "invs[n]", "invs", "n", "pow(modFacts[n], MOD - 2, MOD)", "pow", "modFacts[n]", "modFacts", "n", "MOD - 2", "MOD", "2", "MOD", "for i in range(n, 1, -1):\n invs[i - 1] = (invs[i] * i) % MOD\n\n ", "i", "range(n, 1, -1)", "range", "n", "1", "-1", "invs[i - 1] = (invs[i] * i) % MOD", "invs[i - 1]", "invs", "i - 1", "i", "1", "(invs[i] * i) % MOD", "invs[i] * i", "invs[i]", "invs", "i", "i", "MOD", "return modFacts, invs", "return modFacts, invs", "modFacts", "invs", "n", "n", "def pathVar(sx, sy, gx, gy):\n x = gx - sx\n y = gy - sy\n rst = modFacts[x + y]\n rst *= invs[x] * invs[y]\n rst %= MOD\n return rst", "pathVar", "x = gx - sx", "x", "gx - sx", "gx", "sx", "y = gy - sy", "y", "gy - sy", "gy", "sy", "rst = modFacts[x + y]", "rst", "modFacts[x + y]", "modFacts", "x + y", "x", "y", "rst *= invs[x] * invs[y]", "rst", "invs[x] * invs[y]", "invs[x]", "invs", "x", "invs[y]", "invs", "y", "rst %= MOD", "rst", "MOD", "return rst", "rst", "sx", "sx", "sy", "sy", "gx", "gx", "gy", "gy", "H, W, A, B = map(int, input().split())", "H", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "W", "A", "B", "modFacts, invs = prepare(H + W)", "modFacts", "prepare(H + W)", "prepare", "H + W", "H", "W", "invs", "cnt = 0", "cnt", "0", "while A > 0 and B > 0:\n x = H - A\n y = B - 1\n path1 = pathVar(0, 0, x, y)\n path2 = pathVar(x, y, H - 1, W - 1)\n cnt += path1 * path2\n cnt %= MOD\n A -= 1; B -= 1", "A > 0 and B > 0", "A > 0", "A", "0", "B > 0", "B", "0", "x = H - A", "x", "H - A", "H", "A", "y = B - 1", "y", "B - 1", "B", "1", "path1 = pathVar(0, 0, x, y)", "path1", "pathVar(0, 0, x, y)", "pathVar", "0", "0", "x", "y", "path2 = pathVar(x, y, H - 1, W - 1)", "path2", "pathVar(x, y, H - 1, W - 1)", "pathVar", "x", "y", "H - 1", "H", "1", "W - 1", "W", "1", "cnt += path1 * path2", "cnt", "path1 * path2", "path1", "path2", "cnt %= MOD", "cnt", "MOD", "A -= 1", "A", "1", "B -= 1", "B", "1", "ans = pathVar(0, 0, H - 1, W - 1)", "ans", "pathVar(0, 0, H - 1, W - 1)", "pathVar", "0", "0", "H - 1", "H", "1", "W - 1", "W", "1", "print((ans - cnt) % MOD)", "print", "(ans - cnt) % MOD", "ans - cnt", "ans", "cnt", "MOD", "B -= 1", "1", "B", "def pathVar(sx, sy, gx, gy):\n x = gx - sx\n y = gy - sy\n rst = modFacts[x + y]\n rst *= invs[x] * invs[y]\n rst %= MOD\n return rst", "def pathVar(sx, sy, gx, gy):\n x = gx - sx\n y = gy - sy\n rst = modFacts[x + y]\n rst *= invs[x] * invs[y]\n rst %= MOD\n return rst", "pathVar", "invs = prepare(H + W)", "prepare(H + W)", "invs", "modFacts, invs = prepare(H + W)", "prepare(H + W)", "modFacts", "cnt %= MOD", "MOD", "cnt", "A, B = map(int, input().split())", "map(int, input().split())", "A", "x = H - A", "H - A", "x", "B = map(int, input().split())", "map(int, input().split())", "B", "path2 = pathVar(x, y, H - 1, W - 1)", "pathVar(x, y, H - 1, W - 1)", "path2", "path1 = pathVar(0, 0, x, y)", "pathVar(0, 0, x, y)", "path1", "H, W, A, B = map(int, input().split())", "map(int, input().split())", "H", "W, A, B = map(int, input().split())", "map(int, input().split())", "W", "cnt = 0", "0", "cnt", "y = B - 1", "B - 1", "y", "def prepare(n):\n global MOD\n modFacts = [0] * (n + 1)\n modFacts[0] = 1\n for i in range(n):\n modFacts[i + 1] = (modFacts[i] * (i + 1)) % MOD\n\n invs = [1] * (n + 1)\n invs[n] = pow(modFacts[n], MOD - 2, MOD)\n for i in range(n, 1, -1):\n invs[i - 1] = (invs[i] * i) % MOD\n\n return modFacts, invs", "def prepare(n):\n global MOD\n modFacts = [0] * (n + 1)\n modFacts[0] = 1\n for i in range(n):\n modFacts[i + 1] = (modFacts[i] * (i + 1)) % MOD\n\n invs = [1] * (n + 1)\n invs[n] = pow(modFacts[n], MOD - 2, MOD)\n for i in range(n, 1, -1):\n invs[i - 1] = (invs[i] * i) % MOD\n\n return modFacts, invs", "prepare", "A -= 1", "1", "A", "MOD = 10 ** 9 + 7", "10 ** 9 + 7", "MOD", "cnt += path1 * path2", "path1 * path2", "cnt", "ans = pathVar(0, 0, H - 1, W - 1)", "pathVar(0, 0, H - 1, W - 1)", "ans" ]

[ 7, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 13, 13, 0, 13, 17, 0, 13, 17, 0, 13, 39, 17, 28, 13, 4, 13, 17, 2, 13, 13, 4, 18, 13, 13, 2, 2, 18, 13, 2, 13, 17, 13, 13, 12, 13, 14, 2, 13, 17, 29, 17, 14, 2, 13, 17, 29, 2, 13, 13, 14, 2, 2, 13, 17, 17, 29, 2, 2, 4, 13, 13, 2, 13, 17, 17, 13, 0, 13, 2, 4, 13, 13, 2, 13, 17, 17, 29, 2, 2, 13, 13, 13, 23, 13, 23, 13, 0, 13, 2, 39, 17, 2, 13, 13, 0, 18, 13, 2, 2, 13, 13, 17, 4, 13, 18, 13, 2, 2, 13, 13, 17, 2, 13, 17, 28, 13, 4, 13, 2, 2, 13, 13, 17, 17, 17, 0, 18, 13, 13, 2, 2, 18, 13, 2, 13, 17, 2, 13, 17, 13, 12, 13, 29, 2, 2, 2, 18, 13, 13, 18, 13, 13, 18, 13, 2, 13, 13, 13, 23, 13, 23, 13, 28, 13, 4, 13, 2, 13, 17, 2, 13, 17, 0, 13, 2, 2, 13, 2, 4, 13, 2, 2, 2, 13, 13, 17, 13, 2, 13, 17, 4, 13, 2, 2, 2, 13, 13, 13, 17, 2, 13, 13, 13, 4, 13, 13, 10, 4, 13, 10, 4, 13, 10, 39, 13, 10, 2, 13, 10, 2, 13, 10, 12, 13, 10, 17, 13, 10, 4, 13, 10, 4, 13, 10, 12, 13, 10, 17, 13 ]

[ [ 243, 2 ], [ 243, 11 ], [ 243, 12 ], [ 243, 13 ], [ 249, 15 ], [ 237, 18 ], [ 225, 21 ], [ 26, 25 ], [ 244, 30 ], [ 220, 31 ], [ 226, 34 ], [ 226, 39 ], [ 25, 41 ], [ 25, 43 ], [ 238, 44 ], [ 97, 49 ], [ 97, 55 ], [ 95, 59 ], [ 238, 60 ], [ 97, 64 ], [ 95, 72 ], [ 97, 74 ], [ 238, 77 ], [ 80, 79 ], [ 95, 83 ], [ 97, 85 ], [ 79, 91 ], [ 95, 92 ], [ 238, 93 ], [ 95, 95 ], [ 97, 97 ], [ 231, 99 ], [ 244, 104 ], [ 220, 105 ], [ 114, 107 ], [ 232, 108 ], [ 244, 111 ], [ 220, 112 ], [ 247, 115 ], [ 226, 117 ], [ 244, 120 ], [ 220, 121 ], [ 238, 124 ], [ 128, 127 ], [ 244, 132 ], [ 220, 133 ], [ 141, 138 ], [ 232, 139 ], [ 127, 140 ], [ 232, 144 ], [ 127, 146 ], [ 127, 149 ], [ 238, 151 ], [ 226, 159 ], [ 171, 160 ], [ 232, 162 ], [ 173, 163 ], [ 232, 165 ], [ 171, 167 ], [ 173, 168 ], [ 238, 169 ], [ 171, 171 ], [ 173, 173 ], [ 176, 175 ], [ 241, 179 ], [ 220, 182 ], [ 228, 185 ], [ 250, 188 ], [ 229, 188 ], [ 235, 191 ], [ 244, 195 ], [ 223, 196 ], [ 175, 198 ], [ 175, 200 ], [ 235, 203 ], [ 223, 207 ], [ 220, 208 ], [ 175, 209 ], [ 220, 212 ], [ 175, 213 ], [ 238, 214 ], [ 229, 217 ], [ 250, 217 ], [ 243, 220 ], [ 243, 223 ], [ 225, 226 ], [ 228, 229 ], [ 231, 232 ], [ 237, 238 ], [ 243, 241 ], [ 243, 244 ], [ 249, 250 ] ]

[ "H, W, A, B = map(int, input().split())\nanswer = 0\nmod = 1000000007\nfactorial = [1]\nfor n in range(1, H+W):\n factorial.append(factorial[n-1]*n%mod)\ndef power(x, y):\n if y == 0:\n return 1\n elif y == 1:\n return x % mod\n elif y % 2 == 0:\n return power(x, y//2) ** 2 % mod\n else:\n a = power(x, y//2) ** 2\n return a * x % mod\ninverseFactorial = [0] * (H+W)\ninverseFactorial[H+W-1] = power(factorial[H+W-1], mod-2)\nfor n in range(H+W-2, -1, -1):\n inverseFactorial[n] = inverseFactorial[n+1] * (n+1) % mod\ndef combi(n, m):\n return factorial[n] * inverseFactorial[m] *inverseFactorial[n-m]%mod\n\nfor i in range(B+1, W+1):\n answer = (answer + combi(H-A-2+i, i-1)*combi(A+W-i-1,W-i)) % mod\nprint(answer)", "H, W, A, B = map(int, input().split())", "H", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "W", "A", "B", "answer = 0", "answer", "0", "mod = 1000000007", "mod", "1000000007", "factorial = [1]", "factorial", "[1]", "1", "for n in range(1, H+W):\n factorial.append(factorial[n-1]*n%mod)", "n", "range(1, H+W)", "range", "1", "H+W", "H", "W", "factorial.append(factorial[n-1]*n%mod)", "factorial.append", "factorial", "append", "factorial[n-1]*n%mod", "factorial[n-1]*n", "factorial[n-1]", "factorial", "n-1", "n", "1", "n", "mod", "def power(x, y):\n if y == 0:\n return 1\n elif y == 1:\n return x % mod\n elif y % 2 == 0:\n return power(x, y//2) ** 2 % mod\n else:\n a = power(x, y//2) ** 2\n return a * x % mod", "power", "if y == 0:\n return 1\n elif y == 1:\n return x % mod\n elif y % 2 == 0:\n return power(x, y//2) ** 2 % mod\n else:\n a = power(x, y//2) ** 2\n return a * x % mod", "y == 0", "y", "0", "return 1", "1", "elif y == 1:\n return x % mod\n ", "y == 1", "y", "1", "return x % mod", "x % mod", "x", "mod", "elif y % 2 == 0:\n return power(x, y//2) ** 2 % mod\n ", "y % 2 == 0", "y % 2", "y", "2", "0", "return power(x, y//2) ** 2 % mod", "power(x, y//2) ** 2 % mod", "power(x, y//2) ** 2", "power(x, y//2)", "power", "x", "y//2", "y", "2", "2", "mod", "a = power(x, y//2) ** 2", "a", "power(x, y//2) ** 2", "power(x, y//2)", "power", "x", "y//2", "y", "2", "2", "return a * x % mod", "a * x % mod", "a * x", "a", "x", "mod", "x", "x", "y", "y", "inverseFactorial = [0] * (H+W)", "inverseFactorial", "[0] * (H+W)", "[0]", "0", "H+W", "H", "W", "inverseFactorial[H+W-1] = power(factorial[H+W-1], mod-2)", "inverseFactorial[H+W-1]", "inverseFactorial", "H+W-1", "H+W", "H", "W", "1", "power(factorial[H+W-1], mod-2)", "power", "factorial[H+W-1]", "factorial", "H+W-1", "H+W", "H", "W", "1", "mod-2", "mod", "2", "for n in range(H+W-2, -1, -1):\n inverseFactorial[n] = inverseFactorial[n+1] * (n+1) % mod", "n", "range(H+W-2, -1, -1)", "range", "H+W-2", "H+W", "H", "W", "2", "-1", "-1", "inverseFactorial[n] = inverseFactorial[n+1] * (n+1) % mod", "inverseFactorial[n]", "inverseFactorial", "n", "inverseFactorial[n+1] * (n+1) % mod", "inverseFactorial[n+1] * (n+1)", "inverseFactorial[n+1]", "inverseFactorial", "n+1", "n", "1", "n+1", "n", "1", "mod", "def combi(n, m):\n return factorial[n] * inverseFactorial[m] *inverseFactorial[n-m]%mod", "combi", "return factorial[n] * inverseFactorial[m] *inverseFactorial[n-m]%mod", "factorial[n] * inverseFactorial[m] *inverseFactorial[n-m]%mod", "factorial[n] * inverseFactorial[m] *inverseFactorial[n-m]", "factorial[n] * inverseFactorial[m]", "factorial[n]", "factorial", "n", "inverseFactorial[m]", "inverseFactorial", "m", "inverseFactorial[n-m]", "inverseFactorial", "n-m", "n", "m", "mod", "n", "n", "m", "m", "for i in range(B+1, W+1):\n answer = (answer + combi(H-A-2+i, i-1)*combi(A+W-i-1,W-i)) % mod", "i", "range(B+1, W+1)", "range", "B+1", "B", "1", "W+1", "W", "1", "answer = (answer + combi(H-A-2+i, i-1)*combi(A+W-i-1,W-i)) % mod", "answer", "(answer + combi(H-A-2+i, i-1)*combi(A+W-i-1,W-i)) % mod", "answer + combi(H-A-2+i, i-1)*combi(A+W-i-1,W-i)", "answer", "combi(H-A-2+i, i-1)*combi(A+W-i-1,W-i)", "combi(H-A-2+i, i-1)", "combi", "H-A-2+i", "H-A-2", "H-A", "H", "A", "2", "i", "i-1", "i", "1", "combi(A+W-i-1,W-i)", "combi", "A+W-i-1", "A+W-i", "A+W", "A", "W", "i", "1", "W-i", "W", "i", "mod", "print(answer)", "print", "answer", "W, A, B = map(int, input().split())", "map(int, input().split())", "W", "A, B = map(int, input().split())", "map(int, input().split())", "A", "factorial = [1]", "[1]", "factorial", "answer = (answer + combi(H-A-2+i, i-1)*combi(A+W-i-1,W-i)) % mod", "(answer + combi(H-A-2+i, i-1)*combi(A+W-i-1,W-i)) % mod", "answer", "inverseFactorial = [0] * (H+W)", "[0] * (H+W)", "inverseFactorial", "def combi(n, m):\n return factorial[n] * inverseFactorial[m] *inverseFactorial[n-m]%mod", "def combi(n, m):\n return factorial[n] * inverseFactorial[m] *inverseFactorial[n-m]%mod", "combi", "mod = 1000000007", "1000000007", "mod", "B = map(int, input().split())", "map(int, input().split())", "B", "H, W, A, B = map(int, input().split())", "map(int, input().split())", "H", "def power(x, y):\n if y == 0:\n return 1\n elif y == 1:\n return x % mod\n elif y % 2 == 0:\n return power(x, y//2) ** 2 % mod\n else:\n a = power(x, y//2) ** 2\n return a * x % mod", "def power(x, y):\n if y == 0:\n return 1\n elif y == 1:\n return x % mod\n elif y % 2 == 0:\n return power(x, y//2) ** 2 % mod\n else:\n a = power(x, y//2) ** 2\n return a * x % mod", "power", "answer = 0", "0", "answer" ]

[ 7, 0, 13, 4, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 13, 13, 0, 13, 17, 0, 13, 2, 39, 17, 2, 2, 13, 13, 17, 0, 13, 17, 28, 13, 4, 13, 17, 2, 2, 13, 13, 17, 0, 13, 13, 0, 13, 13, 0, 18, 13, 13, 13, 0, 13, 2, 39, 17, 2, 2, 13, 13, 17, 0, 13, 18, 13, 2, 13, 13, 0, 13, 2, 13, 17, 42, 2, 13, 17, 14, 2, 13, 17, 0, 18, 13, 2, 13, 13, 2, 13, 13, 0, 13, 2, 13, 13, 0, 13, 17, 28, 13, 4, 13, 2, 2, 13, 13, 17, 17, 17, 0, 18, 13, 13, 2, 2, 18, 13, 2, 13, 17, 2, 13, 17, 13, 12, 13, 29, 2, 2, 2, 18, 13, 13, 18, 13, 13, 18, 13, 2, 13, 13, 13, 23, 13, 23, 13, 0, 13, 17, 28, 13, 4, 13, 2, 13, 13, 0, 13, 2, 4, 13, 2, 2, 13, 13, 17, 13, 4, 13, 2, 2, 2, 2, 13, 13, 13, 13, 17, 2, 2, 13, 13, 17, 0, 13, 13, 4, 13, 13, 10, 2, 13, 10, 4, 13, 10, 17, 13, 10, 18, 13, 10, 12, 13, 10, 2, 13, 10, 4, 13, 10, 4, 13, 10, 13, 13, 10, 17, 13, 10, 2, 13, 10, 2, 13, 10, 17, 13, 10, 17, 13, 10, 13, 13, 10, 2, 13, 10, 4, 13, 10, 13, 13 ]

[ [ 240, 2 ], [ 240, 13 ], [ 240, 14 ], [ 240, 15 ], [ 231, 17 ], [ 192, 20 ], [ 196, 26 ], [ 211, 27 ], [ 228, 30 ], [ 34, 33 ], [ 196, 39 ], [ 211, 40 ], [ 216, 43 ], [ 33, 44 ], [ 234, 46 ], [ 232, 47 ], [ 52, 49 ], [ 193, 50 ], [ 33, 51 ], [ 235, 52 ], [ 217, 52 ], [ 229, 52 ], [ 222, 54 ], [ 196, 60 ], [ 211, 61 ], [ 201, 64 ], [ 193, 66 ], [ 196, 68 ], [ 211, 69 ], [ 237, 71 ], [ 232, 73 ], [ 238, 77 ], [ 199, 77 ], [ 238, 81 ], [ 199, 81 ], [ 89, 84 ], [ 223, 85 ], [ 196, 87 ], [ 211, 88 ], [ 202, 90 ], [ 235, 90 ], [ 217, 90 ], [ 229, 90 ], [ 226, 90 ], [ 232, 91 ], [ 225, 93 ], [ 202, 95 ], [ 235, 95 ], [ 217, 95 ], [ 229, 95 ], [ 226, 95 ], [ 232, 96 ], [ 198, 98 ], [ 102, 101 ], [ 196, 106 ], [ 211, 107 ], [ 115, 112 ], [ 223, 113 ], [ 101, 114 ], [ 223, 118 ], [ 101, 120 ], [ 101, 123 ], [ 232, 125 ], [ 193, 133 ], [ 145, 134 ], [ 223, 136 ], [ 147, 137 ], [ 223, 139 ], [ 145, 141 ], [ 147, 142 ], [ 232, 143 ], [ 145, 145 ], [ 147, 147 ], [ 219, 149 ], [ 153, 152 ], [ 196, 156 ], [ 241, 157 ], [ 207, 159 ], [ 205, 162 ], [ 214, 165 ], [ 152, 166 ], [ 152, 168 ], [ 205, 170 ], [ 211, 175 ], [ 214, 176 ], [ 196, 177 ], [ 152, 178 ], [ 196, 182 ], [ 152, 183 ], [ 243, 186 ], [ 232, 187 ], [ 244, 190 ], [ 208, 190 ], [ 220, 190 ], [ 192, 193 ], [ 240, 196 ], [ 198, 199 ], [ 201, 202 ], [ 207, 208 ], [ 240, 211 ], [ 240, 214 ], [ 33, 216 ], [ 216, 217 ], [ 219, 220 ], [ 222, 223 ], [ 225, 226 ], [ 228, 229 ], [ 231, 232 ], [ 232, 234 ], [ 234, 235 ], [ 237, 238 ], [ 240, 241 ], [ 232, 243 ], [ 243, 244 ] ]

[ "H, W, A, B = list(map(int, input().split()))\np = 1000000007\n\nfac = [1] * (H + W + 1)\nx = 1\nfor i in range(1, H + W + 1):\n x *= i\n x %= p\n fac[i] = x\n\nifac = [1] * (H + W + 1)\nx = fac[H + W]\nq = p - 2\n\nwhile q > 0:\n if q & 1:\n ifac[H + W] *= x % p\n x *= x % p\n q >>= 1\n\nfor i in range(H + W - 1, 0, -1):\n ifac[i] = ifac[i + 1] * (i + 1) % p\n\ndef com(a, b):\n return (fac[a] * ifac[b] * ifac[a-b]) % p\n\nans = 0\n\nfor i in range(H-A):\n ans += com(B+i-1, i) * com(W-B+H-i-2, H-i-1)\n ans %= p\n\nprint(ans)", "H, W, A, B = list(map(int, input().split()))", "H", "list(map(int, input().split()))", "list", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "W", "A", "B", "p = 1000000007", "p", "1000000007", "fac = [1] * (H + W + 1)", "fac", "[1] * (H + W + 1)", "[1]", "1", "H + W + 1", "H + W", "H", "W", "1", "x = 1", "x", "1", "for i in range(1, H + W + 1):\n x *= i\n x %= p\n fac[i] = x", "i", "range(1, H + W + 1)", "range", "1", "H + W + 1", "H + W", "H", "W", "1", "x *= i", "x", "i", "x %= p", "x", "p", "fac[i] = x", "fac[i]", "fac", "i", "x", "ifac = [1] * (H + W + 1)", "ifac", "[1] * (H + W + 1)", "[1]", "1", "H + W + 1", "H + W", "H", "W", "1", "x = fac[H + W]", "x", "fac[H + W]", "fac", "H + W", "H", "W", "q = p - 2", "q", "p - 2", "p", "2", "while q > 0:\n if q & 1:\n ifac[H + W] *= x % p\n x *= x % p\n q >>= 1", "q > 0", "q", "0", "if q & 1:\n ifac[H + W] *= x % p\n ", "q & 1", "q", "1", "ifac[H + W] *= x % p", "ifac[H + W]", "ifac", "H + W", "H", "W", "x % p", "x", "p", "x *= x % p", "x", "x % p", "x", "p", "q >>= 1", "q", "1", "for i in range(H + W - 1, 0, -1):\n ifac[i] = ifac[i + 1] * (i + 1) % p", "i", "range(H + W - 1, 0, -1)", "range", "H + W - 1", "H + W", "H", "W", "1", "0", "-1", "ifac[i] = ifac[i + 1] * (i + 1) % p", "ifac[i]", "ifac", "i", "ifac[i + 1] * (i + 1) % p", "ifac[i + 1] * (i + 1)", "ifac[i + 1]", "ifac", "i + 1", "i", "1", "i + 1", "i", "1", "p", "def com(a, b):\n return (fac[a] * ifac[b] * ifac[a-b]) % p", "com", "return (fac[a] * ifac[b] * ifac[a-b]) % p", "(fac[a] * ifac[b] * ifac[a-b]) % p", "fac[a] * ifac[b] * ifac[a-b]", "fac[a] * ifac[b]", "fac[a]", "fac", "a", "ifac[b]", "ifac", "b", "ifac[a-b]", "ifac", "a-b", "a", "b", "p", "a", "a", "b", "b", "ans = 0", "ans", "0", "for i in range(H-A):\n ans += com(B+i-1, i) * com(W-B+H-i-2, H-i-1)\n ans %= p", "i", "range(H-A)", "range", "H-A", "H", "A", "ans += com(B+i-1, i) * com(W-B+H-i-2, H-i-1)", "ans", "com(B+i-1, i) * com(W-B+H-i-2, H-i-1)", "com(B+i-1, i)", "com", "B+i-1", "B+i", "B", "i", "1", "i", "com(W-B+H-i-2, H-i-1)", "com", "W-B+H-i-2", "W-B+H-i", "W-B+H", "W-B", "W", "B", "H", "i", "2", "H-i-1", "H-i", "H", "i", "1", "ans %= p", "ans", "p", "print(ans)", "print", "ans", "fac = [1] * (H + W + 1)", "[1] * (H + W + 1)", "fac", "H, W, A, B = list(map(int, input().split()))", "list(map(int, input().split()))", "H", "q >>= 1", "1", "q", "x = fac[H + W]", "fac[H + W]", "x", "def com(a, b):\n return (fac[a] * ifac[b] * ifac[a-b]) % p", "def com(a, b):\n return (fac[a] * ifac[b] * ifac[a-b]) % p", "com", "ans += com(B+i-1, i) * com(W-B+H-i-2, H-i-1)", "com(B+i-1, i) * com(W-B+H-i-2, H-i-1)", "ans", "W, A, B = list(map(int, input().split()))", "list(map(int, input().split()))", "W", "B = list(map(int, input().split()))", "list(map(int, input().split()))", "B", "x *= i", "i", "x", "ans = 0", "0", "ans", "ifac = [1] * (H + W + 1)", "[1] * (H + W + 1)", "ifac", "x *= x % p", "x % p", "x", "x = 1", "1", "x", "p = 1000000007", "1000000007", "p", "x %= p", "p", "x", "q = p - 2", "p - 2", "q", "A, B = list(map(int, input().split()))", "list(map(int, input().split()))", "A", "ans %= p", "p", "ans" ]

[ 7, 15, 13, 0, 13, 18, 18, 13, 13, 13, 0, 13, 18, 18, 13, 13, 13, 0, 13, 18, 18, 13, 13, 13, 0, 13, 2, 2, 17, 17, 17, 0, 13, 39, 17, 17, 0, 13, 39, 17, 17, 0, 13, 39, 17, 17, 12, 13, 14, 2, 2, 2, 13, 17, 2, 13, 17, 2, 13, 13, 29, 17, 29, 2, 2, 2, 18, 13, 13, 18, 13, 13, 18, 13, 2, 13, 13, 13, 23, 13, 23, 13, 23, 13, 12, 13, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 13, 13, 0, 13, 2, 2, 13, 13, 17, 28, 13, 4, 13, 17, 13, 4, 18, 13, 13, 2, 2, 18, 13, 17, 13, 13, 4, 18, 13, 13, 2, 2, 40, 18, 13, 2, 13, 13, 2, 13, 13, 13, 4, 18, 13, 13, 2, 2, 18, 13, 17, 18, 13, 17, 13, 0, 13, 17, 28, 13, 4, 13, 2, 13, 13, 0, 13, 2, 2, 4, 13, 2, 2, 13, 17, 13, 2, 13, 17, 13, 4, 13, 2, 2, 2, 2, 13, 13, 13, 17, 13, 2, 2, 13, 17, 13, 13, 13, 0, 13, 13, 4, 13, 13, 14, 2, 13, 17, 4, 13, 10, 39, 13, 10, 18, 13, 10, 12, 13, 10, 18, 13, 10, 39, 13, 10, 18, 13, 10, 2, 13, 10, 12, 13, 10, 39, 13 ]

[ [ 223, 4 ], [ 217, 11 ], [ 211, 18 ], [ 226, 25 ], [ 232, 32 ], [ 220, 37 ], [ 208, 42 ], [ 79, 52 ], [ 81, 55 ], [ 81, 58 ], [ 79, 59 ], [ 233, 67 ], [ 79, 68 ], [ 221, 70 ], [ 81, 71 ], [ 221, 73 ], [ 79, 75 ], [ 81, 76 ], [ 83, 77 ], [ 79, 79 ], [ 81, 81 ], [ 83, 83 ], [ 88, 87 ], [ 218, 94 ], [ 88, 96 ], [ 88, 97 ], [ 88, 98 ], [ 101, 100 ], [ 87, 103 ], [ 96, 104 ], [ 108, 107 ], [ 100, 111 ], [ 233, 114 ], [ 233, 119 ], [ 107, 121 ], [ 227, 122 ], [ 209, 125 ], [ 209, 131 ], [ 227, 133 ], [ 107, 134 ], [ 227, 136 ], [ 107, 137 ], [ 227, 138 ], [ 221, 141 ], [ 221, 146 ], [ 209, 149 ], [ 227, 151 ], [ 154, 153 ], [ 157, 156 ], [ 87, 160 ], [ 97, 161 ], [ 164, 163 ], [ 215, 167 ], [ 98, 170 ], [ 156, 172 ], [ 98, 174 ], [ 227, 176 ], [ 215, 178 ], [ 87, 183 ], [ 96, 184 ], [ 98, 185 ], [ 156, 187 ], [ 96, 190 ], [ 98, 192 ], [ 227, 193 ], [ 227, 194 ], [ 197, 196 ], [ 227, 197 ], [ 196, 200 ], [ 163, 200 ], [ 153, 200 ], [ 230, 206 ], [ 208, 209 ], [ 211, 212 ], [ 217, 218 ], [ 220, 221 ], [ 223, 224 ], [ 226, 227 ], [ 232, 233 ] ]

[ "import sys\nread = sys.stdin.read\nreadline = sys.stdin.readline\nreadlines = sys.stdin.readlines\n\nMOD = 10**9+7\nfac = [1, 1]\nf_inv = [1, 1]\ninv = [0, 1]\n\ndef modcmb(n, r, mod):\n if n < 0 or r < 0 or r > n:\n return 0\n\n return fac[n] * f_inv[r] * f_inv[n-r] % mod\n\n\ndef main():\n H,W,A,B = map(int, readline().split())\n\n n = H+W+1\n for i in range(2,n):\n fac.append((fac[-1] * i) % MOD)\n inv.append((-inv[MOD % i] * (MOD//i)) % MOD)\n f_inv.append((f_inv[-1] * inv[-1]) % MOD)\n\n ans = 0\n for i in range(H-A):\n ans += modcmb(B-1+i, B-1, MOD) * modcmb(H+W-B-2-i, W-1-B, MOD) % MOD\n ans %= MOD\n\n print(ans)\n\n\nif __name__ == \"__main__\":\n main()", "import sys", "sys", "read = sys.stdin.read", "read", "sys.stdin.read", "sys.stdin", "sys", "stdin", "read", "readline = sys.stdin.readline", "readline", "sys.stdin.readline", "sys.stdin", "sys", "stdin", "readline", "readlines = sys.stdin.readlines", "readlines", "sys.stdin.readlines", "sys.stdin", "sys", "stdin", "readlines", "MOD = 10**9+7", "MOD", "10**9+7", "10**9", "10", "9", "7", "fac = [1, 1]", "fac", "[1, 1]", "1", "1", "f_inv = [1, 1]", "f_inv", "[1, 1]", "1", "1", "inv = [0, 1]", "inv", "[0, 1]", "0", "1", "def modcmb(n, r, mod):\n if n < 0 or r < 0 or r > n:\n return 0\n\n return fac[n] * f_inv[r] * f_inv[n-r] % mod", "modcmb", "if n < 0 or r < 0 or r > n:\n return 0\n\n ", "n < 0 or r < 0 or r > n", "n < 0 or r < 0", "n < 0", "n", "0", "r < 0", "r", "0", "r > n", "r", "n", "return 0", "0", "return fac[n] * f_inv[r] * f_inv[n-r] % mod", "fac[n] * f_inv[r] * f_inv[n-r] % mod", "fac[n] * f_inv[r] * f_inv[n-r]", "fac[n] * f_inv[r]", "fac[n]", "fac", "n", "f_inv[r]", "f_inv", "r", "f_inv[n-r]", "f_inv", "n-r", "n", "r", "mod", "n", "n", "r", "r", "mod", "mod", "def main():\n H,W,A,B = map(int, readline().split())\n\n n = H+W+1\n for i in range(2,n):\n fac.append((fac[-1] * i) % MOD)\n inv.append((-inv[MOD % i] * (MOD//i)) % MOD)\n f_inv.append((f_inv[-1] * inv[-1]) % MOD)\n\n ans = 0\n for i in range(H-A):\n ans += modcmb(B-1+i, B-1, MOD) * modcmb(H+W-B-2-i, W-1-B, MOD) % MOD\n ans %= MOD\n\n print(ans)", "main", "H,W,A,B = map(int, readline().split())", "H", "map(int, readline().split())", "map", "int", "readline().split()", "().split", "()", "readline", "split", "W", "A", "B", "n = H+W+1", "n", "H+W+1", "H+W", "H", "W", "1", "for i in range(2,n):\n fac.append((fac[-1] * i) % MOD)\n inv.append((-inv[MOD % i] * (MOD//i)) % MOD)\n f_inv.append((f_inv[-1] * inv[-1]) % MOD)\n\n ", "i", "range(2,n)", "range", "2", "n", "fac.append((fac[-1] * i) % MOD)", "fac.append", "fac", "append", "(fac[-1] * i) % MOD", "fac[-1] * i", "fac[-1]", "fac", "-1", "i", "MOD", "inv.append((-inv[MOD % i] * (MOD//i)) % MOD)", "inv.append", "inv", "append", "(-inv[MOD % i] * (MOD//i)) % MOD", "-inv[MOD % i] * (MOD//i)", "-inv[MOD % i]", "inv[MOD % i]", "inv", "MOD % i", "MOD", "i", "MOD//i", "MOD", "i", "MOD", "f_inv.append((f_inv[-1] * inv[-1]) % MOD)", "f_inv.append", "f_inv", "append", "(f_inv[-1] * inv[-1]) % MOD", "f_inv[-1] * inv[-1]", "f_inv[-1]", "f_inv", "-1", "inv[-1]", "inv", "-1", "MOD", "ans = 0", "ans", "0", "for i in range(H-A):\n ans += modcmb(B-1+i, B-1, MOD) * modcmb(H+W-B-2-i, W-1-B, MOD) % MOD\n ans %= MOD\n\n ", "i", "range(H-A)", "range", "H-A", "H", "A", "ans += modcmb(B-1+i, B-1, MOD) * modcmb(H+W-B-2-i, W-1-B, MOD) % MOD", "ans", "modcmb(B-1+i, B-1, MOD) * modcmb(H+W-B-2-i, W-1-B, MOD) % MOD", "modcmb(B-1+i, B-1, MOD) * modcmb(H+W-B-2-i, W-1-B, MOD)", "modcmb(B-1+i, B-1, MOD)", "modcmb", "B-1+i", "B-1", "B", "1", "i", "B-1", "B", "1", "MOD", "modcmb(H+W-B-2-i, W-1-B, MOD)", "modcmb", "H+W-B-2-i", "H+W-B-2", "H+W-B", "H+W", "H", "W", "B", "2", "i", "W-1-B", "W-1", "W", "1", "B", "MOD", "MOD", "ans %= MOD", "ans", "MOD", "print(ans)", "print", "ans", "if __name__ == \"__main__\":\n main()", "__name__ == \"__main__\"", "__name__", "\"__main__\"", "main()", "main", "inv = [0, 1]", "[0, 1]", "inv", "readlines = sys.stdin.readlines", "sys.stdin.readlines", "readlines", "def modcmb(n, r, mod):\n if n < 0 or r < 0 or r > n:\n return 0\n\n return fac[n] * f_inv[r] * f_inv[n-r] % mod", "def modcmb(n, r, mod):\n if n < 0 or r < 0 or r > n:\n return 0\n\n return fac[n] * f_inv[r] * f_inv[n-r] % mod", "modcmb", "readline = sys.stdin.readline", "sys.stdin.readline", "readline", "f_inv = [1, 1]", "[1, 1]", "f_inv", "read = sys.stdin.read", "sys.stdin.read", "read", "MOD = 10**9+7", "10**9+7", "MOD", "def main():\n H,W,A,B = map(int, readline().split())\n\n n = H+W+1\n for i in range(2,n):\n fac.append((fac[-1] * i) % MOD)\n inv.append((-inv[MOD % i] * (MOD//i)) % MOD)\n f_inv.append((f_inv[-1] * inv[-1]) % MOD)\n\n ans = 0\n for i in range(H-A):\n ans += modcmb(B-1+i, B-1, MOD) * modcmb(H+W-B-2-i, W-1-B, MOD) % MOD\n ans %= MOD\n\n print(ans)", "def main():\n H,W,A,B = map(int, readline().split())\n\n n = H+W+1\n for i in range(2,n):\n fac.append((fac[-1] * i) % MOD)\n inv.append((-inv[MOD % i] * (MOD//i)) % MOD)\n f_inv.append((f_inv[-1] * inv[-1]) % MOD)\n\n ans = 0\n for i in range(H-A):\n ans += modcmb(B-1+i, B-1, MOD) * modcmb(H+W-B-2-i, W-1-B, MOD) % MOD\n ans %= MOD\n\n print(ans)", "main", "fac = [1, 1]", "[1, 1]", "fac" ]

[ 7, 41, 28, 13, 4, 18, 4, 13, 13, 4, 4, 13, 13, 0, 13, 13, 13, 13, 13, 0, 13, 2, 2, 17, 17, 17, 12, 13, 0, 13, 17, 42, 2, 13, 17, 14, 2, 2, 13, 17, 17, 0, 13, 2, 2, 13, 13, 13, 0, 13, 2, 13, 17, 0, 13, 2, 2, 13, 13, 13, 0, 13, 2, 13, 17, 29, 13, 23, 13, 23, 13, 23, 13, 12, 13, 14, 2, 2, 13, 17, 2, 13, 17, 29, 17, 0, 13, 17, 28, 13, 4, 13, 13, 2, 13, 17, 0, 13, 13, 29, 13, 23, 13, 23, 13, 17, 12, 13, 14, 2, 13, 17, 29, 17, 29, 2, 4, 13, 13, 2, 13, 17, 4, 13, 2, 13, 13, 23, 13, 23, 13, 0, 13, 2, 39, 17, 2, 2, 13, 13, 17, 28, 13, 4, 13, 17, 2, 2, 13, 13, 17, 0, 18, 13, 13, 2, 2, 18, 13, 2, 13, 17, 13, 13, 0, 13, 2, 39, 17, 2, 2, 13, 13, 17, 0, 18, 13, 2, 2, 13, 13, 17, 4, 13, 18, 13, 2, 2, 13, 13, 17, 2, 13, 17, 13, 28, 13, 4, 13, 2, 2, 13, 13, 17, 17, 17, 0, 18, 13, 2, 13, 17, 2, 2, 18, 13, 13, 13, 13, 0, 13, 17, 28, 13, 4, 13, 17, 2, 13, 13, 0, 13, 2, 2, 2, 2, 2, 18, 13, 2, 2, 13, 13, 17, 18, 13, 13, 18, 13, 2, 13, 17, 13, 2, 2, 18, 13, 2, 2, 2, 2, 13, 13, 13, 13, 17, 18, 13, 2, 2, 13, 13, 17, 18, 13, 2, 2, 13, 13, 17, 13, 0, 13, 13, 0, 13, 13, 4, 13, 13, 10, 12, 13, 10, 2, 13, 10, 13, 13, 10, 13, 13, 10, 13, 13, 10, 2, 13, 10, 13, 13, 10, 2, 13, 10, 13, 13, 10, 2, 13, 10, 17, 13, 10, 13, 13, 10, 12, 13, 10, 12, 13 ]

[ [ 4, 3 ], [ 3, 12 ], [ 315, 14 ], [ 315, 16 ], [ 315, 17 ], [ 315, 18 ], [ 318, 20 ], [ 30, 29 ], [ 70, 33 ], [ 61, 33 ], [ 49, 33 ], [ 70, 38 ], [ 61, 38 ], [ 49, 38 ], [ 43, 42 ], [ 68, 45 ], [ 42, 45 ], [ 68, 46 ], [ 42, 46 ], [ 72, 47 ], [ 50, 49 ], [ 70, 51 ], [ 61, 51 ], [ 49, 51 ], [ 55, 54 ], [ 68, 57 ], [ 42, 57 ], [ 29, 58 ], [ 54, 58 ], [ 72, 59 ], [ 62, 61 ], [ 70, 63 ], [ 61, 63 ], [ 49, 63 ], [ 54, 66 ], [ 29, 66 ], [ 68, 68 ], [ 70, 70 ], [ 72, 72 ], [ 104, 78 ], [ 102, 81 ], [ 87, 86 ], [ 90, 89 ], [ 104, 92 ], [ 102, 94 ], [ 98, 97 ], [ 89, 98 ], [ 97, 100 ], [ 86, 100 ], [ 102, 102 ], [ 105, 104 ], [ 130, 110 ], [ 292, 117 ], [ 128, 118 ], [ 130, 120 ], [ 292, 123 ], [ 128, 125 ], [ 130, 126 ], [ 128, 128 ], [ 130, 130 ], [ 312, 132 ], [ 301, 138 ], [ 298, 139 ], [ 143, 142 ], [ 301, 148 ], [ 298, 149 ], [ 155, 152 ], [ 313, 153 ], [ 142, 154 ], [ 313, 158 ], [ 142, 160 ], [ 142, 162 ], [ 319, 163 ], [ 294, 165 ], [ 301, 171 ], [ 298, 172 ], [ 182, 175 ], [ 295, 176 ], [ 301, 179 ], [ 298, 180 ], [ 328, 183 ], [ 313, 185 ], [ 301, 188 ], [ 298, 189 ], [ 319, 192 ], [ 319, 194 ], [ 197, 196 ], [ 301, 201 ], [ 298, 202 ], [ 212, 207 ], [ 295, 208 ], [ 196, 210 ], [ 295, 215 ], [ 196, 216 ], [ 196, 217 ], [ 319, 218 ], [ 321, 220 ], [ 224, 223 ], [ 301, 228 ], [ 316, 229 ], [ 306, 231 ], [ 313, 238 ], [ 223, 241 ], [ 310, 242 ], [ 295, 245 ], [ 223, 246 ], [ 295, 248 ], [ 310, 250 ], [ 319, 252 ], [ 313, 256 ], [ 298, 261 ], [ 310, 262 ], [ 301, 263 ], [ 223, 264 ], [ 295, 267 ], [ 298, 270 ], [ 310, 271 ], [ 295, 274 ], [ 301, 277 ], [ 223, 278 ], [ 319, 280 ], [ 303, 282 ], [ 319, 283 ], [ 324, 285 ], [ 319, 286 ], [ 325, 289 ], [ 304, 289 ], [ 307, 289 ], [ 322, 289 ], [ 294, 295 ], [ 315, 298 ], [ 315, 301 ], [ 319, 303 ], [ 303, 304 ], [ 306, 307 ], [ 315, 310 ], [ 312, 313 ], [ 315, 316 ], [ 318, 319 ], [ 321, 322 ], [ 319, 324 ], [ 324, 325 ] ]

[ "iH,iW,iA,iB = [int(x) for x in input().split()]\niD = 10**9+7 #法\n\n#初等整数論勉強して解説通りキッチリ実装したった\n\n#二分累乗法 iDを法として\ndef fBiPow(iX,iN,iD):\n iY = 1\n while iN > 0:\n if iN % 2 == 0:\n iX = iX * iX % iD\n iN = iN // 2\n else:\n iY = iX * iY % iD\n iN = iN - 1\n return iY\n\n#nCr = n!/r!(n-r)!\n#ループ回すだけ版や\ndef fFr(iX,iR=1):\n if iR == 0 or iX == 0:\n return 1\n else :\n iRet = 1\n for i in range(iR,iX+1):\n iRet *= i\n return iRet\n\ndef fnCr(iN,iR):\n if iR == 0:\n return 1\n else:\n return fFr(iN,iR+1) // fFr(iN-iR)\n\n#階乗(iDを法とした)の配列\naM = [1]*(iH+iW-1)\nfor i in range(1,iH+iW-1):\n aM[i]=aM[i-1]*i %iD\n#各階乗のiDを法とした逆元の配列\naInvM = [1]*(iH+iW-1)\naInvM[iH+iW-2] = fBiPow(aM[iH+iW-2],iD-2,iD)\nfor i in range(iH+iW-2,0,-1):\n aInvM[i-1]=aInvM[i]*i % iD\n\niRet = 0\nfor iL in range(0,iH-iA):\n #iRet += (fnCr(iL+iB-1,iL) * fnCr(iW-iB+iH-iL-2,iW-iB-1))%iD\n iRet += (aM[iL+iB-1]*aInvM[iL]*aInvM[iB-1]) % iD * (aM[iW-iB+iH-iL-2]*aInvM[iW-iB-1]*aInvM[iH-iL-1])%iD\n iRet %= iD\niRet %= iD\nprint(iRet)", "int(x) for x in input().split()", "for x in input().split()", "x", "input().split()", "().split", "()", "input", "split", "for x in input().split()", "int(x)", "int", "x", "iH,iW,iA,iB = [int(x) for x in input().split()]", "iH", "[int(x) for x in input().split()]", "iW", "iA", "iB", "iD = 10**9+7", "iD", "10**9+7", "10**9", "10", "9", "7", "def fBiPow(iX,iN,iD):\n iY = 1\n while iN > 0:\n if iN % 2 == 0:\n iX = iX * iX % iD\n iN = iN // 2\n else:\n iY = iX * iY % iD\n iN = iN - 1\n return iY\n\n#nCr = n!/r!(n-r)!\n#ループ回すだけ版や", "fBiPow", "iY = 1", "iY", "1", "while iN > 0:\n if iN % 2 == 0:\n iX = iX * iX % iD\n iN = iN // 2\n else:\n iY = iX * iY % iD\n iN = iN - 1\n ", "iN > 0", "iN", "0", "if iN % 2 == 0:\n iX = iX * iX % iD\n iN = iN // 2\n else:\n iY = iX * iY % iD\n iN = iN - 1\n ", "iN % 2 == 0", "iN % 2", "iN", "2", "0", "iX = iX * iX % iD", "iX", "iX * iX % iD", "iX * iX", "iX", "iX", "iD", "iN = iN // 2", "iN", "iN // 2", "iN", "2", "iY = iX * iY % iD", "iY", "iX * iY % iD", "iX * iY", "iX", "iY", "iD", "iN = iN - 1", "iN", "iN - 1", "iN", "1", "return iY", "iY", "iX", "iX", "iN", "iN", "iD", "iD", "def fFr(iX,iR=1):\n if iR == 0 or iX == 0:\n return 1\n else :\n iRet = 1\n for i in range(iR,iX+1):\n iRet *= i\n return iRet", "fFr", "if iR == 0 or iX == 0:\n return 1\n else :\n iRet = 1\n for i in range(iR,iX+1):\n iRet *= i\n return iRet", "iR == 0 or iX == 0", "iR == 0", "iR", "0", "iX == 0", "iX", "0", "return 1", "1", "iRet = 1", "iRet", "1", "for i in range(iR,iX+1):\n iRet *= i\n ", "i", "range(iR,iX+1)", "range", "iR", "iX+1", "iX", "1", "iRet *= i", "iRet", "i", "return iRet", "iRet", "iX", "iX", "iR=1", "iR", "1", "def fnCr(iN,iR):\n if iR == 0:\n return 1\n else:\n return fFr(iN,iR+1) // fFr(iN-iR)\n\n#階乗(iDを法とした)の配列", "fnCr", "if iR == 0:\n return 1\n else:\n return fFr(iN,iR+1) // fFr(iN-iR)\n\n#階乗(iDを法とした)の配列", "iR == 0", "iR", "0", "return 1", "1", "return fFr(iN,iR+1) // fFr(iN-iR)", "fFr(iN,iR+1) // fFr(iN-iR)", "fFr(iN,iR+1)", "fFr", "iN", "iR+1", "iR", "1", "fFr(iN-iR)", "fFr", "iN-iR", "iN", "iR", "iN", "iN", "iR", "iR", "aM = [1]*(iH+iW-1)", "aM", "[1]*(iH+iW-1)", "[1]", "1", "iH+iW-1", "iH+iW", "iH", "iW", "1", "for i in range(1,iH+iW-1):\n aM[i]=aM[i-1]*i %iD\n#各階乗のiDを法とした逆元の配列", "i", "range(1,iH+iW-1)", "range", "1", "iH+iW-1", "iH+iW", "iH", "iW", "1", "aM[i]=aM[i-1]*i %iD", "aM[i]", "aM", "i", "aM[i-1]*i %iD", "aM[i-1]*i", "aM[i-1]", "aM", "i-1", "i", "1", "i", "iD", "aInvM = [1]*(iH+iW-1)", "aInvM", "[1]*(iH+iW-1)", "[1]", "1", "iH+iW-1", "iH+iW", "iH", "iW", "1", "aInvM[iH+iW-2] = fBiPow(aM[iH+iW-2],iD-2,iD)", "aInvM[iH+iW-2]", "aInvM", "iH+iW-2", "iH+iW", "iH", "iW", "2", "fBiPow(aM[iH+iW-2],iD-2,iD)", "fBiPow", "aM[iH+iW-2]", "aM", "iH+iW-2", "iH+iW", "iH", "iW", "2", "iD-2", "iD", "2", "iD", "for i in range(iH+iW-2,0,-1):\n aInvM[i-1]=aInvM[i]*i % iD", "i", "range(iH+iW-2,0,-1)", "range", "iH+iW-2", "iH+iW", "iH", "iW", "2", "0", "-1", "aInvM[i-1]=aInvM[i]*i % iD", "aInvM[i-1]", "aInvM", "i-1", "i", "1", "aInvM[i]*i % iD", "aInvM[i]*i", "aInvM[i]", "aInvM", "i", "i", "iD", "iRet = 0", "iRet", "0", "for iL in range(0,iH-iA):\n #iRet += (fnCr(iL+iB-1,iL) * fnCr(iW-iB+iH-iL-2,iW-iB-1))%iD\n iRet += (aM[iL+iB-1]*aInvM[iL]*aInvM[iB-1]) % iD * (aM[iW-iB+iH-iL-2]*aInvM[iW-iB-1]*aInvM[iH-iL-1])%iD\n iRet %= iD", "iL", "range(0,iH-iA)", "range", "0", "iH-iA", "iH", "iA", "iRet += (aM[iL+iB-1]*aInvM[iL]*aInvM[iB-1]) % iD * (aM[iW-iB+iH-iL-2]*aInvM[iW-iB-1]*aInvM[iH-iL-1])%iD", "iRet", "(aM[iL+iB-1]*aInvM[iL]*aInvM[iB-1]) % iD * (aM[iW-iB+iH-iL-2]*aInvM[iW-iB-1]*aInvM[iH-iL-1])%iD", "(aM[iL+iB-1]*aInvM[iL]*aInvM[iB-1]) % iD * (aM[iW-iB+iH-iL-2]*aInvM[iW-iB-1]*aInvM[iH-iL-1])", "(aM[iL+iB-1]*aInvM[iL]*aInvM[iB-1]) % iD", "aM[iL+iB-1]*aInvM[iL]*aInvM[iB-1]", "aM[iL+iB-1]*aInvM[iL]", "aM[iL+iB-1]", "aM", "iL+iB-1", "iL+iB", "iL", "iB", "1", "aInvM[iL]", "aInvM", "iL", "aInvM[iB-1]", "aInvM", "iB-1", "iB", "1", "iD", "aM[iW-iB+iH-iL-2]*aInvM[iW-iB-1]*aInvM[iH-iL-1]", "aM[iW-iB+iH-iL-2]*aInvM[iW-iB-1]", "aM[iW-iB+iH-iL-2]", "aM", "iW-iB+iH-iL-2", "iW-iB+iH-iL", "iW-iB+iH", "iW-iB", "iW", "iB", "iH", "iL", "2", "aInvM[iW-iB-1]", "aInvM", "iW-iB-1", "iW-iB", "iW", "iB", "1", "aInvM[iH-iL-1]", "aInvM", "iH-iL-1", "iH-iL", "iH", "iL", "1", "iD", "iRet %= iD", "iRet", "iD", "iRet %= iD", "iRet", "iD", "print(iRet)", "print", "iRet", "def fFr(iX,iR=1):\n if iR == 0 or iX == 0:\n return 1\n else :\n iRet = 1\n for i in range(iR,iX+1):\n iRet *= i\n return iRet", "def fFr(iX,iR=1):\n if iR == 0 or iX == 0:\n return 1\n else :\n iRet = 1\n for i in range(iR,iX+1):\n iRet *= i\n return iRet", "fFr", "aInvM = [1]*(iH+iW-1)", "[1]*(iH+iW-1)", "aInvM", "iW,iA,iB = [int(x) for x in input().split()]", "[int(x) for x in input().split()]", "iW", "iH,iW,iA,iB = [int(x) for x in input().split()]", "[int(x) for x in input().split()]", "iH", "iRet %= iD", "iD", "iRet", "iRet += (aM[iL+iB-1]*aInvM[iL]*aInvM[iB-1]) % iD * (aM[iW-iB+iH-iL-2]*aInvM[iW-iB-1]*aInvM[iH-iL-1])%iD", "(aM[iL+iB-1]*aInvM[iL]*aInvM[iB-1]) % iD * (aM[iW-iB+iH-iL-2]*aInvM[iW-iB-1]*aInvM[iH-iL-1])%iD", "iRet", "iB = [int(x) for x in input().split()]", "[int(x) for x in input().split()]", "iB", "aM = [1]*(iH+iW-1)", "[1]*(iH+iW-1)", "aM", "iA,iB = [int(x) for x in input().split()]", "[int(x) for x in input().split()]", "iA", "iD = 10**9+7", "10**9+7", "iD", "iRet = 0", "0", "iRet", "iRet %= iD", "iD", "iRet", "def fBiPow(iX,iN,iD):\n iY = 1\n while iN > 0:\n if iN % 2 == 0:\n iX = iX * iX % iD\n iN = iN // 2\n else:\n iY = iX * iY % iD\n iN = iN - 1\n return iY\n\n#nCr = n!/r!(n-r)!\n#ループ回すだけ版や", "def fBiPow(iX,iN,iD):\n iY = 1\n while iN > 0:\n if iN % 2 == 0:\n iX = iX * iX % iD\n iN = iN // 2\n else:\n iY = iX * iY % iD\n iN = iN - 1\n return iY\n\n#nCr = n!/r!(n-r)!\n#ループ回すだけ版や", "fBiPow", "def fnCr(iN,iR):\n if iR == 0:\n return 1\n else:\n return fFr(iN,iR+1) // fFr(iN-iR)\n\n#階乗(iDを法とした)の配列", "def fnCr(iN,iR):\n if iR == 0:\n return 1\n else:\n return fFr(iN,iR+1) // fFr(iN-iR)\n\n#階乗(iDを法とした)の配列", "fnCr" ]

[ 7, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 13, 13, 0, 13, 2, 2, 17, 17, 17, 0, 13, 39, 17, 28, 13, 4, 13, 2, 13, 13, 4, 18, 13, 13, 2, 2, 18, 13, 13, 2, 13, 17, 13, 12, 13, 29, 2, 2, 2, 18, 13, 13, 4, 13, 18, 13, 13, 2, 13, 17, 13, 4, 13, 18, 13, 2, 13, 13, 2, 13, 17, 13, 13, 23, 13, 23, 13, 23, 13, 0, 13, 17, 28, 13, 4, 13, 13, 13, 0, 13, 2, 2, 4, 13, 2, 2, 2, 13, 13, 13, 17, 13, 13, 4, 13, 2, 2, 2, 13, 13, 13, 17, 2, 13, 17, 13, 13, 4, 13, 2, 13, 13, 10, 4, 13, 10, 4, 13, 10, 12, 13, 10, 4, 13, 10, 2, 13, 10, 39, 13, 10, 2, 13, 10, 4, 13, 10, 17, 13 ]

[ [ 146, 2 ], [ 146, 11 ], [ 146, 12 ], [ 146, 13 ], [ 137, 15 ], [ 140, 22 ], [ 27, 26 ], [ 147, 30 ], [ 135, 31 ], [ 141, 34 ], [ 141, 39 ], [ 26, 40 ], [ 26, 42 ], [ 138, 44 ], [ 141, 52 ], [ 76, 53 ], [ 141, 57 ], [ 78, 58 ], [ 80, 60 ], [ 80, 62 ], [ 141, 66 ], [ 76, 68 ], [ 78, 69 ], [ 80, 71 ], [ 80, 73 ], [ 80, 74 ], [ 76, 76 ], [ 78, 78 ], [ 80, 80 ], [ 149, 82 ], [ 86, 85 ], [ 126, 88 ], [ 135, 89 ], [ 143, 91 ], [ 132, 95 ], [ 147, 99 ], [ 129, 100 ], [ 85, 101 ], [ 85, 103 ], [ 138, 104 ], [ 132, 106 ], [ 129, 110 ], [ 135, 111 ], [ 85, 112 ], [ 129, 115 ], [ 138, 117 ], [ 138, 118 ], [ 144, 122 ], [ 150, 122 ], [ 138, 123 ], [ 146, 126 ], [ 146, 129 ], [ 146, 135 ], [ 137, 138 ], [ 140, 141 ], [ 143, 144 ], [ 146, 147 ], [ 149, 150 ] ]

[ "H,W,A,B = map(int,input().split())\n\nmod = 10**9 + 7\n\nf = [1]\nfor i in range(H+W):\n f.append(f[i]*(i+1)%mod)\n\ndef comb(A,B,mod):\n return f[A] * pow(f[B],mod-2,mod) * pow(f[A-B],mod-2,mod) % mod\n\nres = 0\n\nfor i in range(B,W):\n res += comb(H-A+i-1,i,mod) * comb(A+W-i-2,A-1,mod) % mod\n\nprint(res%mod)", "H,W,A,B = map(int,input().split())", "H", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "W", "A", "B", "mod = 10**9 + 7", "mod", "10**9 + 7", "10**9", "10", "9", "7", "f = [1]", "f", "[1]", "1", "for i in range(H+W):\n f.append(f[i]*(i+1)%mod)", "i", "range(H+W)", "range", "H+W", "H", "W", "f.append(f[i]*(i+1)%mod)", "f.append", "f", "append", "f[i]*(i+1)%mod", "f[i]*(i+1)", "f[i]", "f", "i", "i+1", "i", "1", "mod", "def comb(A,B,mod):\n return f[A] * pow(f[B],mod-2,mod) * pow(f[A-B],mod-2,mod) % mod", "comb", "return f[A] * pow(f[B],mod-2,mod) * pow(f[A-B],mod-2,mod) % mod", "f[A] * pow(f[B],mod-2,mod) * pow(f[A-B],mod-2,mod) % mod", "f[A] * pow(f[B],mod-2,mod) * pow(f[A-B],mod-2,mod)", "f[A] * pow(f[B],mod-2,mod)", "f[A]", "f", "A", "pow(f[B],mod-2,mod)", "pow", "f[B]", "f", "B", "mod-2", "mod", "2", "mod", "pow(f[A-B],mod-2,mod)", "pow", "f[A-B]", "f", "A-B", "A", "B", "mod-2", "mod", "2", "mod", "mod", "A", "A", "B", "B", "mod", "mod", "res = 0", "res", "0", "for i in range(B,W):\n res += comb(H-A+i-1,i,mod) * comb(A+W-i-2,A-1,mod) % mod", "i", "range(B,W)", "range", "B", "W", "res += comb(H-A+i-1,i,mod) * comb(A+W-i-2,A-1,mod) % mod", "res", "comb(H-A+i-1,i,mod) * comb(A+W-i-2,A-1,mod) % mod", "comb(H-A+i-1,i,mod) * comb(A+W-i-2,A-1,mod)", "comb(H-A+i-1,i,mod)", "comb", "H-A+i-1", "H-A+i", "H-A", "H", "A", "i", "1", "i", "mod", "comb(A+W-i-2,A-1,mod)", "comb", "A+W-i-2", "A+W-i", "A+W", "A", "W", "i", "2", "A-1", "A", "1", "mod", "mod", "print(res%mod)", "print", "res%mod", "res", "mod", "B = map(int,input().split())", "map(int,input().split())", "B", "A,B = map(int,input().split())", "map(int,input().split())", "A", "def comb(A,B,mod):\n return f[A] * pow(f[B],mod-2,mod) * pow(f[A-B],mod-2,mod) % mod", "def comb(A,B,mod):\n return f[A] * pow(f[B],mod-2,mod) * pow(f[A-B],mod-2,mod) % mod", "comb", "W,A,B = map(int,input().split())", "map(int,input().split())", "W", "mod = 10**9 + 7", "10**9 + 7", "mod", "f = [1]", "[1]", "f", "res += comb(H-A+i-1,i,mod) * comb(A+W-i-2,A-1,mod) % mod", "comb(H-A+i-1,i,mod) * comb(A+W-i-2,A-1,mod) % mod", "res", "H,W,A,B = map(int,input().split())", "map(int,input().split())", "H", "res = 0", "0", "res" ]

[ 7, 0, 13, 2, 17, 2, 17, 17, 0, 13, 2, 2, 17, 17, 17, 0, 13, 2, 39, 17, 2, 13, 17, 0, 13, 2, 39, 17, 2, 13, 17, 28, 13, 4, 13, 17, 2, 13, 17, 0, 18, 13, 13, 2, 2, 18, 13, 2, 13, 17, 13, 13, 0, 18, 13, 13, 4, 13, 18, 13, 13, 2, 13, 17, 13, 28, 13, 4, 13, 13, 17, 17, 0, 18, 13, 2, 13, 17, 2, 2, 18, 13, 13, 13, 13, 12, 13, 14, 2, 2, 13, 17, 2, 13, 13, 29, 17, 0, 13, 18, 13, 13, 0, 13, 18, 13, 13, 0, 13, 13, 0, 13, 18, 13, 2, 13, 13, 0, 13, 13, 29, 13, 23, 13, 23, 13, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 13, 13, 0, 13, 17, 28, 13, 4, 13, 2, 13, 13, 0, 13, 2, 4, 13, 2, 2, 13, 13, 17, 13, 4, 13, 2, 2, 2, 2, 13, 13, 13, 13, 17, 2, 2, 13, 13, 17, 0, 13, 13, 4, 13, 13, 10, 12, 13, 10, 4, 13, 10, 4, 13, 10, 2, 13, 10, 4, 13, 10, 2, 13, 10, 17, 13, 10, 4, 13, 10, 2, 13, 10, 2, 13, 10, 2, 13, 10, 13, 13 ]

[ [ 210, 2 ], [ 192, 9 ], [ 207, 16 ], [ 211, 21 ], [ 198, 24 ], [ 211, 29 ], [ 33, 32 ], [ 211, 37 ], [ 43, 40 ], [ 208, 41 ], [ 32, 42 ], [ 208, 46 ], [ 32, 48 ], [ 32, 50 ], [ 193, 51 ], [ 56, 53 ], [ 199, 54 ], [ 211, 55 ], [ 208, 59 ], [ 211, 60 ], [ 193, 62 ], [ 193, 64 ], [ 67, 66 ], [ 211, 69 ], [ 78, 73 ], [ 199, 74 ], [ 66, 76 ], [ 199, 81 ], [ 66, 82 ], [ 66, 83 ], [ 193, 84 ], [ 125, 90 ], [ 125, 93 ], [ 123, 94 ], [ 99, 98 ], [ 208, 100 ], [ 123, 101 ], [ 104, 103 ], [ 199, 105 ], [ 125, 106 ], [ 109, 108 ], [ 193, 109 ], [ 112, 111 ], [ 199, 113 ], [ 123, 115 ], [ 125, 116 ], [ 119, 118 ], [ 193, 119 ], [ 118, 121 ], [ 111, 121 ], [ 108, 121 ], [ 103, 121 ], [ 98, 121 ], [ 123, 123 ], [ 125, 125 ], [ 204, 127 ], [ 204, 136 ], [ 204, 137 ], [ 204, 138 ], [ 201, 140 ], [ 144, 143 ], [ 205, 147 ], [ 187, 148 ], [ 213, 150 ], [ 184, 153 ], [ 190, 156 ], [ 143, 157 ], [ 143, 159 ], [ 184, 161 ], [ 196, 166 ], [ 205, 167 ], [ 190, 168 ], [ 143, 169 ], [ 205, 173 ], [ 143, 174 ], [ 216, 177 ], [ 193, 178 ], [ 217, 181 ], [ 214, 181 ], [ 202, 181 ], [ 204, 187 ], [ 204, 190 ], [ 192, 193 ], [ 204, 196 ], [ 198, 199 ], [ 201, 202 ], [ 204, 205 ], [ 207, 208 ], [ 210, 211 ], [ 213, 214 ], [ 193, 216 ], [ 216, 217 ] ]

[ "U = 2*10**6\nMOD = 10**9+7\n \nfact = [1]*(U+1)\nfact_inv = [1]*(U+1)\n \nfor i in range(1,U+1):\n fact[i] = (fact[i-1]*i)%MOD\nfact_inv[U] = pow(fact[U],MOD-2,MOD)\n \nfor i in range(U,0,-1):\n fact_inv[i-1] = (fact_inv[i]*i)%MOD\n \ndef comb(n,k):\n if k < 0 or k > n:\n return 0\n z = fact[n]\n z *= fact_inv[k]\n z %= MOD\n z *= fact_inv[n-k]\n z %= MOD\n return z\n\nh, w, a, b = map(int, input().split())\nans = 0\nfor i in range(h-a):\n ans += comb(b+i-1, i) * comb(w+h-b-i-2, h-i-1)\n ans %= MOD\nprint(ans)", "U = 2*10**6", "U", "2*10**6", "2", "10**6", "10", "6", "MOD = 10**9+7", "MOD", "10**9+7", "10**9", "10", "9", "7", "fact = [1]*(U+1)", "fact", "[1]*(U+1)", "[1]", "1", "U+1", "U", "1", "fact_inv = [1]*(U+1)", "fact_inv", "[1]*(U+1)", "[1]", "1", "U+1", "U", "1", "for i in range(1,U+1):\n fact[i] = (fact[i-1]*i)%MOD", "i", "range(1,U+1)", "range", "1", "U+1", "U", "1", "fact[i] = (fact[i-1]*i)%MOD", "fact[i]", "fact", "i", "(fact[i-1]*i)%MOD", "fact[i-1]*i", "fact[i-1]", "fact", "i-1", "i", "1", "i", "MOD", "fact_inv[U] = pow(fact[U],MOD-2,MOD)", "fact_inv[U]", "fact_inv", "U", "pow(fact[U],MOD-2,MOD)", "pow", "fact[U]", "fact", "U", "MOD-2", "MOD", "2", "MOD", "for i in range(U,0,-1):\n fact_inv[i-1] = (fact_inv[i]*i)%MOD\n ", "i", "range(U,0,-1)", "range", "U", "0", "-1", "fact_inv[i-1] = (fact_inv[i]*i)%MOD", "fact_inv[i-1]", "fact_inv", "i-1", "i", "1", "(fact_inv[i]*i)%MOD", "fact_inv[i]*i", "fact_inv[i]", "fact_inv", "i", "i", "MOD", "def comb(n,k):\n if k < 0 or k > n:\n return 0\n z = fact[n]\n z *= fact_inv[k]\n z %= MOD\n z *= fact_inv[n-k]\n z %= MOD\n return z", "comb", "if k < 0 or k > n:\n return 0\n ", "k < 0 or k > n", "k < 0", "k", "0", "k > n", "k", "n", "return 0", "0", "z = fact[n]", "z", "fact[n]", "fact", "n", "z *= fact_inv[k]", "z", "fact_inv[k]", "fact_inv", "k", "z %= MOD", "z", "MOD", "z *= fact_inv[n-k]", "z", "fact_inv[n-k]", "fact_inv", "n-k", "n", "k", "z %= MOD", "z", "MOD", "return z", "z", "n", "n", "k", "k", "h, w, a, b = map(int, input().split())", "h", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "w", "a", "b", "ans = 0", "ans", "0", "for i in range(h-a):\n ans += comb(b+i-1, i) * comb(w+h-b-i-2, h-i-1)\n ans %= MOD", "i", "range(h-a)", "range", "h-a", "h", "a", "ans += comb(b+i-1, i) * comb(w+h-b-i-2, h-i-1)", "ans", "comb(b+i-1, i) * comb(w+h-b-i-2, h-i-1)", "comb(b+i-1, i)", "comb", "b+i-1", "b+i", "b", "i", "1", "i", "comb(w+h-b-i-2, h-i-1)", "comb", "w+h-b-i-2", "w+h-b-i", "w+h-b", "w+h", "w", "h", "b", "i", "2", "h-i-1", "h-i", "h", "i", "1", "ans %= MOD", "ans", "MOD", "print(ans)", "print", "ans", "def comb(n,k):\n if k < 0 or k > n:\n return 0\n z = fact[n]\n z *= fact_inv[k]\n z %= MOD\n z *= fact_inv[n-k]\n z %= MOD\n return z", "def comb(n,k):\n if k < 0 or k > n:\n return 0\n z = fact[n]\n z *= fact_inv[k]\n z %= MOD\n z *= fact_inv[n-k]\n z %= MOD\n return z", "comb", "a, b = map(int, input().split())", "map(int, input().split())", "a", "b = map(int, input().split())", "map(int, input().split())", "b", "MOD = 10**9+7", "10**9+7", "MOD", "w, a, b = map(int, input().split())", "map(int, input().split())", "w", "fact_inv = [1]*(U+1)", "[1]*(U+1)", "fact_inv", "ans = 0", "0", "ans", "h, w, a, b = map(int, input().split())", "map(int, input().split())", "h", "fact = [1]*(U+1)", "[1]*(U+1)", "fact", "U = 2*10**6", "2*10**6", "U", "ans += comb(b+i-1, i) * comb(w+h-b-i-2, h-i-1)", "comb(b+i-1, i) * comb(w+h-b-i-2, h-i-1)", "ans", "ans %= MOD", "MOD", "ans" ]

[ 7, 15, 15, 13, 0, 13, 39, 0, 13, 39, 0, 13, 2, 2, 17, 17, 17, 12, 13, 29, 18, 13, 13, 23, 13, 12, 13, 29, 18, 13, 13, 23, 13, 12, 13, 29, 2, 2, 4, 13, 13, 4, 13, 2, 13, 13, 4, 13, 13, 23, 13, 23, 13, 12, 13, 0, 13, 4, 18, 4, 18, 4, 13, 13, 13, 17, 0, 13, 4, 13, 18, 13, 17, 0, 13, 4, 13, 18, 13, 17, 0, 13, 4, 13, 18, 13, 17, 0, 13, 4, 13, 18, 13, 17, 41, 0, 13, 2, 39, 17, 2, 2, 13, 13, 17, 0, 13, 17, 28, 13, 4, 13, 17, 2, 2, 13, 13, 17, 0, 13, 13, 0, 13, 13, 0, 18, 13, 13, 13, 41, 0, 13, 2, 39, 17, 2, 2, 13, 13, 17, 0, 18, 13, 2, 13, 13, 4, 13, 18, 13, 2, 13, 13, 2, 13, 17, 13, 0, 13, 18, 13, 2, 13, 13, 28, 13, 4, 13, 2, 2, 13, 13, 17, 17, 17, 0, 13, 2, 13, 17, 0, 13, 13, 0, 18, 13, 13, 13, 0, 13, 17, 28, 13, 4, 13, 13, 13, 0, 13, 2, 4, 13, 2, 2, 2, 13, 13, 13, 17, 13, 4, 13, 2, 2, 2, 2, 13, 13, 17, 13, 17, 2, 13, 17, 4, 13, 2, 13, 13, 14, 2, 13, 17, 4, 13, 10, 39, 13, 10, 39, 13, 10, 12, 13, 10, 2, 13, 10, 12, 13, 10, 12, 13, 10, 12, 13 ]

[ [ 236, 5 ], [ 239, 8 ], [ 245, 11 ], [ 237, 21 ], [ 24, 22 ], [ 24, 24 ], [ 240, 29 ], [ 32, 30 ], [ 32, 32 ], [ 255, 39 ], [ 50, 40 ], [ 252, 42 ], [ 50, 44 ], [ 52, 45 ], [ 252, 47 ], [ 52, 48 ], [ 50, 50 ], [ 52, 52 ], [ 57, 56 ], [ 68, 67 ], [ 56, 71 ], [ 75, 74 ], [ 56, 78 ], [ 82, 81 ], [ 56, 85 ], [ 89, 88 ], [ 56, 92 ], [ 97, 96 ], [ 67, 102 ], [ 74, 103 ], [ 107, 106 ], [ 110, 109 ], [ 67, 115 ], [ 74, 116 ], [ 120, 119 ], [ 109, 120 ], [ 123, 122 ], [ 246, 123 ], [ 128, 125 ], [ 96, 126 ], [ 109, 127 ], [ 122, 128 ], [ 119, 128 ], [ 106, 128 ], [ 132, 131 ], [ 67, 137 ], [ 74, 138 ], [ 146, 141 ], [ 131, 142 ], [ 67, 144 ], [ 74, 145 ], [ 96, 149 ], [ 67, 151 ], [ 74, 152 ], [ 246, 154 ], [ 246, 156 ], [ 159, 158 ], [ 131, 160 ], [ 67, 162 ], [ 74, 163 ], [ 166, 165 ], [ 67, 170 ], [ 74, 171 ], [ 177, 176 ], [ 165, 178 ], [ 182, 181 ], [ 246, 182 ], [ 187, 184 ], [ 131, 185 ], [ 165, 186 ], [ 181, 187 ], [ 176, 187 ], [ 158, 187 ], [ 190, 189 ], [ 193, 192 ], [ 88, 195 ], [ 74, 196 ], [ 199, 198 ], [ 243, 201 ], [ 192, 205 ], [ 67, 206 ], [ 81, 207 ], [ 192, 209 ], [ 243, 211 ], [ 74, 216 ], [ 192, 217 ], [ 81, 219 ], [ 81, 222 ], [ 198, 227 ], [ 189, 227 ], [ 246, 228 ], [ 249, 234 ], [ 236, 237 ], [ 239, 240 ], [ 245, 246 ] ]

[ "from functools import reduce\nimport math\n\nmemo = []\nmemo_inv = []\nMOD = 10**9+7\n \ndef get_factorial(i):\n return memo[i]\n\ndef get_factorial_inv(i):\n return memo_inv[i]\n\ndef nCr(n, r):\n return get_factorial(n) * get_factorial_inv(n-r) * get_factorial_inv(r)\n\ndef main():\n # 一文字のみを読み込み\n # s = input().rstrip().split(' ')\n \n # スペース区切りで標準入力を配列として読み込み\n # s = input().rstrip().split(' ')\n\n # 位置文字ずつ標準入力を配列として読み込み\n # s = list(input().rstrip())\n \n slist = input().rstrip().split(' ')\n H = int(slist[0])\n W = int(slist[1])\n A = int(slist[2])\n B = int(slist[3])\n global memo\n memo = [1]*(H+W+1)\n f= 1\n for i in range(1,H+W+1):\n f *=i\n f %=MOD\n memo[i] = f\n \n global memo_inv\n memo_inv = [1]*(H+W+1)\n memo_inv[H+W] = pow(memo[H+W],MOD-2,MOD)\n f_inv = memo_inv[H+W]\n for i in range(H+W-1,0,-1):\n f_inv *= i +1\n f_inv %= MOD\n memo_inv[i] = f_inv\n \n ans = 0\n for i in range(B,W):\n ans += nCr(i+H-A-1,i) * nCr(W-i-1+A-1,A-1)\n print(ans % MOD)\n \nif __name__ == '__main__':\n main()", "from functools import reduce", "import math", "math", "memo = []", "memo", "[]", "memo_inv = []", "memo_inv", "[]", "MOD = 10**9+7", "MOD", "10**9+7", "10**9", "10", "9", "7", "def get_factorial(i):\n return memo[i]", "get_factorial", "return memo[i]", "memo[i]", "memo", "i", "i", "i", "def get_factorial_inv(i):\n return memo_inv[i]", "get_factorial_inv", "return memo_inv[i]", "memo_inv[i]", "memo_inv", "i", "i", "i", "def nCr(n, r):\n return get_factorial(n) * get_factorial_inv(n-r) * get_factorial_inv(r)", "nCr", "return get_factorial(n) * get_factorial_inv(n-r) * get_factorial_inv(r)", "get_factorial(n) * get_factorial_inv(n-r) * get_factorial_inv(r)", "get_factorial(n) * get_factorial_inv(n-r)", "get_factorial(n)", "get_factorial", "n", "get_factorial_inv(n-r)", "get_factorial_inv", "n-r", "n", "r", "get_factorial_inv(r)", "get_factorial_inv", "r", "n", "n", "r", "r", "def main():\n # 一文字のみを読み込み\n # s = input().rstrip().split(' ')\n \n # スペース区切りで標準入力を配列として読み込み\n # s = input().rstrip().split(' ')\n\n # 位置文字ずつ標準入力を配列として読み込み\n # s = list(input().rstrip())\n \n slist = input().rstrip().split(' ')\n H = int(slist[0])\n W = int(slist[1])\n A = int(slist[2])\n B = int(slist[3])\n global memo\n memo = [1]*(H+W+1)\n f= 1\n for i in range(1,H+W+1):\n f *=i\n f %=MOD\n memo[i] = f\n \n global memo_inv\n memo_inv = [1]*(H+W+1)\n memo_inv[H+W] = pow(memo[H+W],MOD-2,MOD)\n f_inv = memo_inv[H+W]\n for i in range(H+W-1,0,-1):\n f_inv *= i +1\n f_inv %= MOD\n memo_inv[i] = f_inv\n \n ans = 0\n for i in range(B,W):\n ans += nCr(i+H-A-1,i) * nCr(W-i-1+A-1,A-1)\n print(ans % MOD)\n ", "main", "slist = input().rstrip().split(' ')", "slist", "input().rstrip().split(' ')", "().rstrip().split", "().rstrip()", "().rstrip", "()", "input", "rstrip", "split", "' '", "H = int(slist[0])", "H", "int(slist[0])", "int", "slist[0]", "slist", "0", "W = int(slist[1])", "W", "int(slist[1])", "int", "slist[1]", "slist", "1", "A = int(slist[2])", "A", "int(slist[2])", "int", "slist[2]", "slist", "2", "B = int(slist[3])", "B", "int(slist[3])", "int", "slist[3]", "slist", "3", "global memo", "memo = [1]*(H+W+1)", "memo", "[1]*(H+W+1)", "[1]", "1", "H+W+1", "H+W", "H", "W", "1", "f= 1", "f", "1", "for i in range(1,H+W+1):\n f *=i\n f %=MOD\n memo[i] = f\n \n ", "i", "range(1,H+W+1)", "range", "1", "H+W+1", "H+W", "H", "W", "1", "f *=i", "f", "i", "f %=MOD", "f", "MOD", "memo[i] = f", "memo[i]", "memo", "i", "f", "global memo_inv", "memo_inv = [1]*(H+W+1)", "memo_inv", "[1]*(H+W+1)", "[1]", "1", "H+W+1", "H+W", "H", "W", "1", "memo_inv[H+W] = pow(memo[H+W],MOD-2,MOD)", "memo_inv[H+W]", "memo_inv", "H+W", "H", "W", "pow(memo[H+W],MOD-2,MOD)", "pow", "memo[H+W]", "memo", "H+W", "H", "W", "MOD-2", "MOD", "2", "MOD", "f_inv = memo_inv[H+W]", "f_inv", "memo_inv[H+W]", "memo_inv", "H+W", "H", "W", "for i in range(H+W-1,0,-1):\n f_inv *= i +1\n f_inv %= MOD\n memo_inv[i] = f_inv\n \n ", "i", "range(H+W-1,0,-1)", "range", "H+W-1", "H+W", "H", "W", "1", "0", "-1", "f_inv *= i +1", "f_inv", "i +1", "i", "1", "f_inv %= MOD", "f_inv", "MOD", "memo_inv[i] = f_inv", "memo_inv[i]", "memo_inv", "i", "f_inv", "ans = 0", "ans", "0", "for i in range(B,W):\n ans += nCr(i+H-A-1,i) * nCr(W-i-1+A-1,A-1)\n ", "i", "range(B,W)", "range", "B", "W", "ans += nCr(i+H-A-1,i) * nCr(W-i-1+A-1,A-1)", "ans", "nCr(i+H-A-1,i) * nCr(W-i-1+A-1,A-1)", "nCr(i+H-A-1,i)", "nCr", "i+H-A-1", "i+H-A", "i+H", "i", "H", "A", "1", "i", "nCr(W-i-1+A-1,A-1)", "nCr", "W-i-1+A-1", "W-i-1+A", "W-i-1", "W-i", "W", "i", "1", "A", "1", "A-1", "A", "1", "print(ans % MOD)", "print", "ans % MOD", "ans", "MOD", "if __name__ == '__main__':\n main()", "__name__ == '__main__'", "__name__", "'__main__'", "main()", "main", "memo = []", "[]", "memo", "memo_inv = []", "[]", "memo_inv", "def nCr(n, r):\n return get_factorial(n) * get_factorial_inv(n-r) * get_factorial_inv(r)", "def nCr(n, r):\n return get_factorial(n) * get_factorial_inv(n-r) * get_factorial_inv(r)", "nCr", "MOD = 10**9+7", "10**9+7", "MOD", "def main():\n # 一文字のみを読み込み\n # s = input().rstrip().split(' ')\n \n # スペース区切りで標準入力を配列として読み込み\n # s = input().rstrip().split(' ')\n\n # 位置文字ずつ標準入力を配列として読み込み\n # s = list(input().rstrip())\n \n slist = input().rstrip().split(' ')\n H = int(slist[0])\n W = int(slist[1])\n A = int(slist[2])\n B = int(slist[3])\n global memo\n memo = [1]*(H+W+1)\n f= 1\n for i in range(1,H+W+1):\n f *=i\n f %=MOD\n memo[i] = f\n \n global memo_inv\n memo_inv = [1]*(H+W+1)\n memo_inv[H+W] = pow(memo[H+W],MOD-2,MOD)\n f_inv = memo_inv[H+W]\n for i in range(H+W-1,0,-1):\n f_inv *= i +1\n f_inv %= MOD\n memo_inv[i] = f_inv\n \n ans = 0\n for i in range(B,W):\n ans += nCr(i+H-A-1,i) * nCr(W-i-1+A-1,A-1)\n print(ans % MOD)\n ", "def main():\n # 一文字のみを読み込み\n # s = input().rstrip().split(' ')\n \n # スペース区切りで標準入力を配列として読み込み\n # s = input().rstrip().split(' ')\n\n # 位置文字ずつ標準入力を配列として読み込み\n # s = list(input().rstrip())\n \n slist = input().rstrip().split(' ')\n H = int(slist[0])\n W = int(slist[1])\n A = int(slist[2])\n B = int(slist[3])\n global memo\n memo = [1]*(H+W+1)\n f= 1\n for i in range(1,H+W+1):\n f *=i\n f %=MOD\n memo[i] = f\n \n global memo_inv\n memo_inv = [1]*(H+W+1)\n memo_inv[H+W] = pow(memo[H+W],MOD-2,MOD)\n f_inv = memo_inv[H+W]\n for i in range(H+W-1,0,-1):\n f_inv *= i +1\n f_inv %= MOD\n memo_inv[i] = f_inv\n \n ans = 0\n for i in range(B,W):\n ans += nCr(i+H-A-1,i) * nCr(W-i-1+A-1,A-1)\n print(ans % MOD)\n ", "main", "def get_factorial_inv(i):\n return memo_inv[i]", "def get_factorial_inv(i):\n return memo_inv[i]", "get_factorial_inv", "def get_factorial(i):\n return memo[i]", "def get_factorial(i):\n return memo[i]", "get_factorial" ]

[ 7, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 13, 13, 0, 13, 17, 12, 13, 0, 13, 17, 42, 2, 13, 17, 14, 40, 2, 13, 17, 17, 0, 13, 2, 2, 13, 13, 13, 0, 13, 2, 2, 13, 13, 13, 0, 13, 17, 29, 13, 23, 13, 23, 13, 23, 13, 0, 13, 2, 39, 17, 17, 28, 13, 4, 13, 17, 17, 0, 18, 13, 17, 17, 0, 18, 13, 13, 2, 2, 13, 18, 13, 2, 13, 17, 13, 12, 13, 0, 13, 2, 2, 18, 13, 2, 13, 13, 18, 13, 13, 13, 29, 2, 2, 18, 13, 13, 4, 13, 13, 2, 13, 17, 13, 13, 23, 13, 23, 13, 12, 13, 0, 13, 2, 2, 13, 13, 17, 0, 13, 2, 13, 17, 29, 4, 13, 13, 13, 23, 13, 23, 13, 0, 13, 17, 28, 13, 4, 13, 2, 13, 17, 2, 13, 17, 0, 13, 2, 4, 13, 2, 13, 13, 13, 4, 13, 13, 2, 2, 13, 13, 17, 4, 13, 4, 13, 2, 13, 13, 10, 12, 13, 10, 4, 13, 10, 2, 13, 10, 4, 13, 10, 12, 13, 10, 17, 13, 10, 4, 13, 10, 12, 13, 10, 4, 13, 10, 17, 13, 10, 2, 13 ]

[ [ 205, 2 ], [ 205, 11 ], [ 205, 12 ], [ 205, 13 ], [ 208, 15 ], [ 21, 20 ], [ 54, 24 ], [ 47, 24 ], [ 54, 29 ], [ 47, 29 ], [ 34, 33 ], [ 20, 36 ], [ 33, 36 ], [ 52, 37 ], [ 40, 37 ], [ 56, 38 ], [ 41, 40 ], [ 52, 43 ], [ 40, 43 ], [ 52, 44 ], [ 40, 44 ], [ 56, 45 ], [ 48, 47 ], [ 33, 50 ], [ 20, 50 ], [ 52, 52 ], [ 54, 54 ], [ 56, 56 ], [ 211, 58 ], [ 65, 64 ], [ 73, 70 ], [ 212, 71 ], [ 78, 75 ], [ 212, 76 ], [ 64, 77 ], [ 64, 80 ], [ 212, 82 ], [ 64, 84 ], [ 209, 86 ], [ 91, 90 ], [ 212, 94 ], [ 117, 96 ], [ 119, 97 ], [ 212, 99 ], [ 119, 100 ], [ 209, 101 ], [ 212, 106 ], [ 117, 107 ], [ 90, 110 ], [ 209, 112 ], [ 209, 114 ], [ 209, 115 ], [ 117, 117 ], [ 119, 119 ], [ 124, 123 ], [ 140, 126 ], [ 142, 127 ], [ 131, 130 ], [ 140, 132 ], [ 182, 136 ], [ 123, 137 ], [ 130, 138 ], [ 140, 140 ], [ 142, 142 ], [ 196, 144 ], [ 148, 147 ], [ 200, 151 ], [ 191, 154 ], [ 187, 157 ], [ 194, 160 ], [ 185, 162 ], [ 206, 163 ], [ 147, 164 ], [ 194, 166 ], [ 206, 167 ], [ 191, 170 ], [ 147, 171 ], [ 188, 178 ], [ 197, 178 ], [ 209, 179 ], [ 205, 185 ], [ 187, 188 ], [ 205, 191 ], [ 196, 197 ], [ 205, 200 ], [ 205, 206 ], [ 208, 209 ], [ 211, 212 ] ]

[ "h, w, a, b = map(int, input().split())\n\nMOD = 1000000007\n\n\ndef modPow(a, x, p):\n res = 1\n while (x > 0):\n if (x % 2 != 0):\n res = (res * a) % p\n a = (a * a) % p\n x /= 2\n return res\n\n\nfact = [None] * 220000\n\nfor i in range(1, 220000):\n fact[0] = 1\n fact[i] = i * fact[i - 1] % MOD\n # inv[i] = modPow(fact[i], MOD-2, MOD)\n\n\ndef ncr(n, r):\n den = fact[n - r] * fact[r] % MOD\n return fact[n] * pow(den, MOD - 2, MOD) % MOD\n\n\ndef number_of_paths(h, w):\n n = h + w - 2\n r = h - 1\n return ncr(n, r)\n\n\nans = 0\nfor i in range(b + 1, w + 1):\n # print('first', h-a, i)\n ans += number_of_paths(h - a, i) * number_of_paths(a, w - i + 1)\n\nprint(int(ans % MOD))", "h, w, a, b = map(int, input().split())", "h", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "w", "a", "b", "MOD = 1000000007", "MOD", "1000000007", "def modPow(a, x, p):\n res = 1\n while (x > 0):\n if (x % 2 != 0):\n res = (res * a) % p\n a = (a * a) % p\n x /= 2\n return res", "modPow", "res = 1", "res", "1", "while (x > 0):\n if (x % 2 != 0):\n res = (res * a) % p\n a = (a * a) % p\n x /= 2\n ", "x > 0", "x", "0", "if (x % 2 != 0):\n res = (res * a) % p\n ", "x % 2 != 0", "x % 2", "x", "2", "0", "res = (res * a) % p", "res", "(res * a) % p", "res * a", "res", "a", "p", "a = (a * a) % p", "a", "(a * a) % p", "a * a", "a", "a", "p", "x /= 2", "x", "2", "return res", "res", "a", "a", "x", "x", "p", "p", "fact = [None] * 220000", "fact", "[None] * 220000", "[None]", "None", "220000", "for i in range(1, 220000):\n fact[0] = 1\n fact[i] = i * fact[i - 1] % MOD\n # inv[i] = modPow(fact[i], MOD-2, MOD)", "i", "range(1, 220000)", "range", "1", "220000", "fact[0] = 1", "fact[0]", "fact", "0", "1", "fact[i] = i * fact[i - 1] % MOD", "fact[i]", "fact", "i", "i * fact[i - 1] % MOD", "i * fact[i - 1]", "i", "fact[i - 1]", "fact", "i - 1", "i", "1", "MOD", "def ncr(n, r):\n den = fact[n - r] * fact[r] % MOD\n return fact[n] * pow(den, MOD - 2, MOD) % MOD", "ncr", "den = fact[n - r] * fact[r] % MOD", "den", "fact[n - r] * fact[r] % MOD", "fact[n - r] * fact[r]", "fact[n - r]", "fact", "n - r", "n", "r", "fact[r]", "fact", "r", "MOD", "return fact[n] * pow(den, MOD - 2, MOD) % MOD", "fact[n] * pow(den, MOD - 2, MOD) % MOD", "fact[n] * pow(den, MOD - 2, MOD)", "fact[n]", "fact", "n", "pow(den, MOD - 2, MOD)", "pow", "den", "MOD - 2", "MOD", "2", "MOD", "MOD", "n", "n", "r", "r", "def number_of_paths(h, w):\n n = h + w - 2\n r = h - 1\n return ncr(n, r)", "number_of_paths", "n = h + w - 2", "n", "h + w - 2", "h + w", "h", "w", "2", "r = h - 1", "r", "h - 1", "h", "1", "return ncr(n, r)", "ncr(n, r)", "ncr", "n", "r", "h", "h", "w", "w", "ans = 0", "ans", "0", "for i in range(b + 1, w + 1):\n # print('first', h-a, i)\n ans += number_of_paths(h - a, i) * number_of_paths(a, w - i + 1)", "i", "range(b + 1, w + 1)", "range", "b + 1", "b", "1", "w + 1", "w", "1", "ans += number_of_paths(h - a, i) * number_of_paths(a, w - i + 1)", "ans", "number_of_paths(h - a, i) * number_of_paths(a, w - i + 1)", "number_of_paths(h - a, i)", "number_of_paths", "h - a", "h", "a", "i", "number_of_paths(a, w - i + 1)", "number_of_paths", "a", "w - i + 1", "w - i", "w", "i", "1", "print(int(ans % MOD))", "print", "int(ans % MOD)", "int", "ans % MOD", "ans", "MOD", "def ncr(n, r):\n den = fact[n - r] * fact[r] % MOD\n return fact[n] * pow(den, MOD - 2, MOD) % MOD", "def ncr(n, r):\n den = fact[n - r] * fact[r] % MOD\n return fact[n] * pow(den, MOD - 2, MOD) % MOD", "ncr", "h, w, a, b = map(int, input().split())", "map(int, input().split())", "h", "ans += number_of_paths(h - a, i) * number_of_paths(a, w - i + 1)", "number_of_paths(h - a, i) * number_of_paths(a, w - i + 1)", "ans", "w, a, b = map(int, input().split())", "map(int, input().split())", "w", "def number_of_paths(h, w):\n n = h + w - 2\n r = h - 1\n return ncr(n, r)", "def number_of_paths(h, w):\n n = h + w - 2\n r = h - 1\n return ncr(n, r)", "number_of_paths", "ans = 0", "0", "ans", "b = map(int, input().split())", "map(int, input().split())", "b", "def modPow(a, x, p):\n res = 1\n while (x > 0):\n if (x % 2 != 0):\n res = (res * a) % p\n a = (a * a) % p\n x /= 2\n return res", "def modPow(a, x, p):\n res = 1\n while (x > 0):\n if (x % 2 != 0):\n res = (res * a) % p\n a = (a * a) % p\n x /= 2\n return res", "modPow", "a, b = map(int, input().split())", "map(int, input().split())", "a", "MOD = 1000000007", "1000000007", "MOD", "fact = [None] * 220000", "[None] * 220000", "fact" ]

[ 7, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 13, 13, 0, 13, 2, 2, 13, 13, 17, 0, 13, 2, 2, 17, 17, 17, 0, 13, 2, 39, 17, 17, 2, 39, 17, 13, 0, 13, 2, 39, 17, 17, 2, 39, 17, 13, 0, 13, 2, 39, 17, 17, 2, 39, 17, 13, 28, 13, 4, 13, 17, 2, 13, 17, 0, 18, 13, 13, 2, 2, 18, 13, 2, 13, 17, 13, 13, 0, 18, 13, 13, 2, 2, 40, 18, 13, 2, 13, 13, 2, 13, 13, 13, 0, 18, 13, 13, 2, 2, 18, 13, 2, 13, 17, 18, 13, 13, 13, 12, 13, 14, 2, 13, 13, 14, 2, 2, 13, 17, 2, 13, 17, 29, 2, 2, 18, 13, 13, 2, 2, 18, 13, 13, 18, 13, 2, 13, 13, 13, 13, 23, 13, 23, 13, 0, 13, 17, 28, 13, 4, 13, 2, 13, 13, 0, 13, 2, 4, 13, 2, 2, 2, 2, 13, 17, 13, 13, 13, 2, 2, 13, 17, 13, 4, 13, 2, 2, 2, 2, 2, 13, 17, 13, 17, 13, 13, 2, 13, 17, 0, 13, 13, 4, 13, 13, 10, 17, 13, 10, 2, 13, 10, 4, 13, 10, 2, 13, 10, 13, 13, 10, 4, 13, 10, 2, 13, 10, 2, 13, 10, 4, 13, 10, 12, 13, 10, 2, 13, 10, 2, 13, 10, 4, 13 ]

[ [ 234, 2 ], [ 234, 11 ], [ 234, 12 ], [ 234, 13 ], [ 228, 15 ], [ 214, 18 ], [ 223, 19 ], [ 216, 22 ], [ 201, 29 ], [ 229, 37 ], [ 231, 39 ], [ 229, 47 ], [ 219, 49 ], [ 229, 57 ], [ 60, 59 ], [ 229, 64 ], [ 70, 67 ], [ 202, 68 ], [ 59, 69 ], [ 202, 73 ], [ 59, 75 ], [ 59, 77 ], [ 217, 78 ], [ 83, 80 ], [ 220, 81 ], [ 59, 82 ], [ 220, 87 ], [ 217, 89 ], [ 59, 90 ], [ 217, 92 ], [ 59, 93 ], [ 217, 94 ], [ 99, 96 ], [ 232, 97 ], [ 59, 98 ], [ 232, 102 ], [ 59, 104 ], [ 80, 106 ], [ 220, 107 ], [ 59, 108 ], [ 217, 109 ], [ 143, 114 ], [ 145, 115 ], [ 143, 119 ], [ 145, 122 ], [ 202, 128 ], [ 143, 129 ], [ 232, 133 ], [ 145, 134 ], [ 232, 136 ], [ 143, 138 ], [ 145, 139 ], [ 217, 140 ], [ 217, 141 ], [ 143, 143 ], [ 145, 145 ], [ 198, 147 ], [ 151, 150 ], [ 223, 154 ], [ 235, 155 ], [ 207, 157 ], [ 226, 160 ], [ 214, 165 ], [ 205, 167 ], [ 235, 168 ], [ 150, 169 ], [ 214, 172 ], [ 205, 174 ], [ 226, 176 ], [ 205, 182 ], [ 223, 184 ], [ 235, 186 ], [ 150, 187 ], [ 205, 189 ], [ 210, 192 ], [ 217, 193 ], [ 211, 196 ], [ 208, 196 ], [ 199, 196 ], [ 198, 199 ], [ 201, 202 ], [ 234, 205 ], [ 207, 208 ], [ 217, 210 ], [ 210, 211 ], [ 234, 214 ], [ 216, 217 ], [ 219, 220 ], [ 234, 223 ], [ 228, 229 ], [ 231, 232 ], [ 234, 235 ] ]

[ "H,W,A,B = map(int,input().split())\n\nN = H+W+10\nMOD = 10**9+7\n\nfac = [1,1] + [0]*N\nfinv = [1,1] + [0]*N\ninv = [0,1] + [0]*N\nfor i in range(2,N+2):\n fac[i] = fac[i-1] * i % MOD\n inv[i] = -inv[MOD%i] * (MOD // i) % MOD\n finv[i] = finv[i-1] * inv[i] % MOD\n\ndef ncr(n,r):\n if n < r: return 0\n if n < 0 or r < 0: return 0\n return fac[n] * (finv[r] * finv[n-r] % MOD) % MOD\n\nans = 0\nfor i in range(W-B):\n ans += ncr(H-1-A+B+i, H-1-A) * ncr(A-1+W-1-B-i, A-1)\n ans %= MOD\nprint(ans)", "H,W,A,B = map(int,input().split())", "H", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "W", "A", "B", "N = H+W+10", "N", "H+W+10", "H+W", "H", "W", "10", "MOD = 10**9+7", "MOD", "10**9+7", "10**9", "10", "9", "7", "fac = [1,1] + [0]*N", "fac", "[1,1] + [0]*N", "[1,1]", "1", "1", "[0]*N", "[0]", "0", "N", "finv = [1,1] + [0]*N", "finv", "[1,1] + [0]*N", "[1,1]", "1", "1", "[0]*N", "[0]", "0", "N", "inv = [0,1] + [0]*N", "inv", "[0,1] + [0]*N", "[0,1]", "0", "1", "[0]*N", "[0]", "0", "N", "for i in range(2,N+2):\n fac[i] = fac[i-1] * i % MOD\n inv[i] = -inv[MOD%i] * (MOD // i) % MOD\n finv[i] = finv[i-1] * inv[i] % MOD", "i", "range(2,N+2)", "range", "2", "N+2", "N", "2", "fac[i] = fac[i-1] * i % MOD", "fac[i]", "fac", "i", "fac[i-1] * i % MOD", "fac[i-1] * i", "fac[i-1]", "fac", "i-1", "i", "1", "i", "MOD", "inv[i] = -inv[MOD%i] * (MOD // i) % MOD", "inv[i]", "inv", "i", "-inv[MOD%i] * (MOD // i) % MOD", "-inv[MOD%i] * (MOD // i)", "-inv[MOD%i]", "inv[MOD%i]", "inv", "MOD%i", "MOD", "i", "MOD // i", "MOD", "i", "MOD", "finv[i] = finv[i-1] * inv[i] % MOD", "finv[i]", "finv", "i", "finv[i-1] * inv[i] % MOD", "finv[i-1] * inv[i]", "finv[i-1]", "finv", "i-1", "i", "1", "inv[i]", "inv", "i", "MOD", "def ncr(n,r):\n if n < r: return 0\n if n < 0 or r < 0: return 0\n return fac[n] * (finv[r] * finv[n-r] % MOD) % MOD", "ncr", "if n < r: return 0\n ", "n < r", "n", "r", "if n < 0 or r < 0: return 0\n ", "n < 0 or r < 0", "n < 0", "n", "0", "r < 0", "r", "0", "return fac[n] * (finv[r] * finv[n-r] % MOD) % MOD", "fac[n] * (finv[r] * finv[n-r] % MOD) % MOD", "fac[n] * (finv[r] * finv[n-r] % MOD)", "fac[n]", "fac", "n", "finv[r] * finv[n-r] % MOD", "finv[r] * finv[n-r]", "finv[r]", "finv", "r", "finv[n-r]", "finv", "n-r", "n", "r", "MOD", "MOD", "n", "n", "r", "r", "ans = 0", "ans", "0", "for i in range(W-B):\n ans += ncr(H-1-A+B+i, H-1-A) * ncr(A-1+W-1-B-i, A-1)\n ans %= MOD", "i", "range(W-B)", "range", "W-B", "W", "B", "ans += ncr(H-1-A+B+i, H-1-A) * ncr(A-1+W-1-B-i, A-1)", "ans", "ncr(H-1-A+B+i, H-1-A) * ncr(A-1+W-1-B-i, A-1)", "ncr(H-1-A+B+i, H-1-A)", "ncr", "H-1-A+B+i", "H-1-A+B", "H-1-A", "H-1", "H", "1", "A", "B", "i", "H-1-A", "H-1", "H", "1", "A", "ncr(A-1+W-1-B-i, A-1)", "ncr", "A-1+W-1-B-i", "A-1+W-1-B", "A-1+W-1", "A-1+W", "A-1", "A", "1", "W", "1", "B", "i", "A-1", "A", "1", "ans %= MOD", "ans", "MOD", "print(ans)", "print", "ans", "ans = 0", "0", "ans", "fac = [1,1] + [0]*N", "[1,1] + [0]*N", "fac", "A,B = map(int,input().split())", "map(int,input().split())", "A", "ans += ncr(H-1-A+B+i, H-1-A) * ncr(A-1+W-1-B-i, A-1)", "ncr(H-1-A+B+i, H-1-A) * ncr(A-1+W-1-B-i, A-1)", "ans", "ans %= MOD", "MOD", "ans", "H,W,A,B = map(int,input().split())", "map(int,input().split())", "H", "MOD = 10**9+7", "10**9+7", "MOD", "inv = [0,1] + [0]*N", "[0,1] + [0]*N", "inv", "W,A,B = map(int,input().split())", "map(int,input().split())", "W", "def ncr(n,r):\n if n < r: return 0\n if n < 0 or r < 0: return 0\n return fac[n] * (finv[r] * finv[n-r] % MOD) % MOD", "def ncr(n,r):\n if n < r: return 0\n if n < 0 or r < 0: return 0\n return fac[n] * (finv[r] * finv[n-r] % MOD) % MOD", "ncr", "N = H+W+10", "H+W+10", "N", "finv = [1,1] + [0]*N", "[1,1] + [0]*N", "finv", "B = map(int,input().split())", "map(int,input().split())", "B" ]

[ 7, 0, 13, 2, 2, 17, 17, 17, 0, 13, 2, 17, 2, 17, 17, 0, 13, 2, 39, 17, 13, 0, 13, 2, 39, 17, 13, 0, 13, 2, 39, 17, 13, 12, 13, 41, 0, 18, 13, 17, 17, 0, 18, 13, 17, 17, 0, 18, 13, 17, 17, 0, 18, 13, 17, 17, 0, 18, 13, 17, 17, 28, 13, 4, 13, 17, 13, 0, 18, 13, 13, 2, 2, 18, 13, 2, 13, 17, 13, 13, 0, 18, 13, 13, 2, 13, 2, 2, 18, 13, 2, 13, 13, 2, 13, 13, 13, 0, 18, 13, 13, 2, 2, 18, 13, 2, 13, 17, 18, 13, 13, 13, 12, 13, 41, 14, 2, 13, 13, 29, 17, 14, 2, 2, 13, 17, 2, 13, 17, 29, 17, 29, 2, 2, 18, 13, 13, 2, 2, 18, 13, 13, 18, 13, 2, 13, 13, 13, 13, 23, 13, 23, 13, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 13, 13, 4, 13, 0, 13, 17, 28, 13, 4, 13, 2, 13, 13, 0, 13, 4, 13, 2, 2, 13, 17, 13, 13, 0, 13, 2, 2, 13, 17, 13, 0, 13, 2, 2, 13, 17, 13, 0, 13, 4, 13, 2, 13, 13, 13, 0, 13, 13, 0, 13, 13, 0, 13, 13, 4, 13, 13, 10, 12, 13, 10, 4, 13, 10, 2, 13, 10, 2, 13, 10, 4, 13, 10, 4, 13, 10, 13, 13, 10, 2, 13, 10, 13, 13, 10, 2, 13, 10, 2, 13, 10, 4, 13, 10, 4, 13, 10, 2, 13, 10, 17, 13, 10, 2, 13, 10, 12, 13, 10, 4, 13, 10, 13, 13 ]

[ [ 262, 2 ], [ 229, 9 ], [ 244, 16 ], [ 230, 20 ], [ 253, 22 ], [ 230, 26 ], [ 250, 28 ], [ 230, 32 ], [ 45, 37 ], [ 45, 42 ], [ 55, 47 ], [ 55, 52 ], [ 60, 57 ], [ 63, 62 ], [ 230, 66 ], [ 71, 68 ], [ 62, 70 ], [ 62, 76 ], [ 62, 78 ], [ 263, 79 ], [ 84, 81 ], [ 62, 83 ], [ 263, 85 ], [ 263, 91 ], [ 62, 92 ], [ 263, 94 ], [ 62, 95 ], [ 263, 96 ], [ 101, 98 ], [ 62, 100 ], [ 62, 106 ], [ 81, 108 ], [ 62, 110 ], [ 263, 111 ], [ 150, 117 ], [ 152, 118 ], [ 150, 124 ], [ 152, 127 ], [ 150, 136 ], [ 152, 141 ], [ 150, 145 ], [ 152, 146 ], [ 263, 147 ], [ 263, 148 ], [ 150, 150 ], [ 152, 152 ], [ 274, 154 ], [ 274, 163 ], [ 274, 164 ], [ 274, 165 ], [ 272, 167 ], [ 265, 169 ], [ 173, 172 ], [ 227, 176 ], [ 260, 177 ], [ 238, 179 ], [ 224, 181 ], [ 257, 184 ], [ 172, 186 ], [ 172, 187 ], [ 232, 189 ], [ 227, 192 ], [ 172, 194 ], [ 268, 196 ], [ 275, 199 ], [ 257, 201 ], [ 235, 203 ], [ 224, 205 ], [ 233, 207 ], [ 269, 208 ], [ 233, 209 ], [ 241, 211 ], [ 263, 212 ], [ 247, 214 ], [ 242, 215 ], [ 236, 215 ], [ 239, 215 ], [ 277, 217 ], [ 263, 218 ], [ 278, 221 ], [ 248, 221 ], [ 266, 221 ], [ 274, 227 ], [ 229, 230 ], [ 232, 233 ], [ 235, 236 ], [ 238, 239 ], [ 263, 241 ], [ 241, 242 ], [ 244, 245 ], [ 242, 247 ], [ 236, 247 ], [ 239, 247 ], [ 247, 248 ], [ 250, 251 ], [ 253, 254 ], [ 274, 257 ], [ 274, 260 ], [ 262, 263 ], [ 265, 266 ], [ 268, 269 ], [ 274, 275 ], [ 263, 277 ], [ 277, 278 ] ]

[ "MOD = 10**9 + 7\nMAX = 2*10**5\nfac = [0]*MAX # fac[n]: (n!) mod p\nfinv = [0]*MAX # finv[n]: (n!)^-1 mod p\ninv = [0]*MAX # inv[n]: (n)^-1 mod -p\n\n\ndef comb_init():\n global fac, finv, inv\n fac[0] = fac[1] = 1\n finv[0] = finv[1] = 1\n inv[1] = 1\n for i in range(2, MAX):\n fac[i] = fac[i-1] * i % MOD\n inv[i] = MOD - inv[MOD % i] * (MOD//i) % MOD\n finv[i] = finv[i-1] * inv[i] % MOD\n\n\ndef comb(n: int, r: int) -> int:\n global fac, finv\n if n < r:\n return 0\n if n < 0 or r < 0:\n return 0\n return fac[n] * (finv[r] * finv[n-r] % MOD) % MOD\n\n\nH, W, A, B = map(int, input().split())\ncomb_init()\nans = 0\n\nfor i in range(H-A):\n x = comb(B-1+i, i)\n a = H-1-i\n b = W-1-B\n x *= comb(a+b, a)\n x %= MOD\n ans += x\nans %= MOD\nprint(ans)", "MOD = 10**9 + 7", "MOD", "10**9 + 7", "10**9", "10", "9", "7", "MAX = 2*10**5", "MAX", "2*10**5", "2", "10**5", "10", "5", "fac = [0]*MAX", "fac", "[0]*MAX", "[0]", "0", "MAX", "finv = [0]*MAX", "finv", "[0]*MAX", "[0]", "0", "MAX", "inv = [0]*MAX", "inv", "[0]*MAX", "[0]", "0", "MAX", "def comb_init():\n global fac, finv, inv\n fac[0] = fac[1] = 1\n finv[0] = finv[1] = 1\n inv[1] = 1\n for i in range(2, MAX):\n fac[i] = fac[i-1] * i % MOD\n inv[i] = MOD - inv[MOD % i] * (MOD//i) % MOD\n finv[i] = finv[i-1] * inv[i] % MOD", "comb_init", "global fac, finv, inv", "fac[0] = fac[1] = 1", "fac[0]", "fac", "0", "1", "= fac[1] = 1", "fac[1]", "fac", "1", "1", "finv[0] = finv[1] = 1", "finv[0]", "finv", "0", "1", "= finv[1] = 1", "finv[1]", "finv", "1", "1", "inv[1] = 1", "inv[1]", "inv", "1", "1", "for i in range(2, MAX):\n fac[i] = fac[i-1] * i % MOD\n inv[i] = MOD - inv[MOD % i] * (MOD//i) % MOD\n finv[i] = finv[i-1] * inv[i] % MOD", "i", "range(2, MAX)", "range", "2", "MAX", "fac[i] = fac[i-1] * i % MOD", "fac[i]", "fac", "i", "fac[i-1] * i % MOD", "fac[i-1] * i", "fac[i-1]", "fac", "i-1", "i", "1", "i", "MOD", "inv[i] = MOD - inv[MOD % i] * (MOD//i) % MOD", "inv[i]", "inv", "i", "MOD - inv[MOD % i] * (MOD//i) % MOD", "MOD", "inv[MOD % i] * (MOD//i) % MOD", "inv[MOD % i] * (MOD//i)", "inv[MOD % i]", "inv", "MOD % i", "MOD", "i", "MOD//i", "MOD", "i", "MOD", "finv[i] = finv[i-1] * inv[i] % MOD", "finv[i]", "finv", "i", "finv[i-1] * inv[i] % MOD", "finv[i-1] * inv[i]", "finv[i-1]", "finv", "i-1", "i", "1", "inv[i]", "inv", "i", "MOD", "def comb(n: int, r: int) -> int:\n global fac, finv\n if n < r:\n return 0\n if n < 0 or r < 0:\n return 0\n return fac[n] * (finv[r] * finv[n-r] % MOD) % MOD", "comb", "global fac, finv", "if n < r:\n return 0\n ", "n < r", "n", "r", "return 0", "0", "if n < 0 or r < 0:\n return 0\n ", "n < 0 or r < 0", "n < 0", "n", "0", "r < 0", "r", "0", "return 0", "0", "return fac[n] * (finv[r] * finv[n-r] % MOD) % MOD", "fac[n] * (finv[r] * finv[n-r] % MOD) % MOD", "fac[n] * (finv[r] * finv[n-r] % MOD)", "fac[n]", "fac", "n", "finv[r] * finv[n-r] % MOD", "finv[r] * finv[n-r]", "finv[r]", "finv", "r", "finv[n-r]", "finv", "n-r", "n", "r", "MOD", "MOD", "n: int", "n", "r: int", "r", "H, W, A, B = map(int, input().split())", "H", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "W", "A", "B", "comb_init()", "comb_init", "ans = 0", "ans", "0", "for i in range(H-A):\n x = comb(B-1+i, i)\n a = H-1-i\n b = W-1-B\n x *= comb(a+b, a)\n x %= MOD\n ans += x", "i", "range(H-A)", "range", "H-A", "H", "A", "x = comb(B-1+i, i)", "x", "comb(B-1+i, i)", "comb", "B-1+i", "B-1", "B", "1", "i", "i", "a = H-1-i", "a", "H-1-i", "H-1", "H", "1", "i", "b = W-1-B", "b", "W-1-B", "W-1", "W", "1", "B", "x *= comb(a+b, a)", "x", "comb(a+b, a)", "comb", "a+b", "a", "b", "a", "x %= MOD", "x", "MOD", "ans += x", "ans", "x", "ans %= MOD", "ans", "MOD", "print(ans)", "print", "ans", "def comb(n: int, r: int) -> int:\n global fac, finv\n if n < r:\n return 0\n if n < 0 or r < 0:\n return 0\n return fac[n] * (finv[r] * finv[n-r] % MOD) % MOD", "def comb(n: int, r: int) -> int:\n global fac, finv\n if n < r:\n return 0\n if n < 0 or r < 0:\n return 0\n return fac[n] * (finv[r] * finv[n-r] % MOD) % MOD", "comb", "H, W, A, B = map(int, input().split())", "map(int, input().split())", "H", "MAX = 2*10**5", "2*10**5", "MAX", "a = H-1-i", "H-1-i", "a", "x *= comb(a+b, a)", "comb(a+b, a)", "x", "x = comb(B-1+i, i)", "comb(B-1+i, i)", "x", "x %= MOD", "MOD", "x", "fac = [0]*MAX", "[0]*MAX", "fac", "ans += x", "x", "ans", "inv = [0]*MAX", "[0]*MAX", "inv", "finv = [0]*MAX", "[0]*MAX", "finv", "B = map(int, input().split())", "map(int, input().split())", "B", "A, B = map(int, input().split())", "map(int, input().split())", "A", "MOD = 10**9 + 7", "10**9 + 7", "MOD", "ans = 0", "0", "ans", "b = W-1-B", "W-1-B", "b", "def comb_init():\n global fac, finv, inv\n fac[0] = fac[1] = 1\n finv[0] = finv[1] = 1\n inv[1] = 1\n for i in range(2, MAX):\n fac[i] = fac[i-1] * i % MOD\n inv[i] = MOD - inv[MOD % i] * (MOD//i) % MOD\n finv[i] = finv[i-1] * inv[i] % MOD", "def comb_init():\n global fac, finv, inv\n fac[0] = fac[1] = 1\n finv[0] = finv[1] = 1\n inv[1] = 1\n for i in range(2, MAX):\n fac[i] = fac[i-1] * i % MOD\n inv[i] = MOD - inv[MOD % i] * (MOD//i) % MOD\n finv[i] = finv[i-1] * inv[i] % MOD", "comb_init", "W, A, B = map(int, input().split())", "map(int, input().split())", "W", "ans %= MOD", "MOD", "ans" ]

[ 7, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 13, 13, 0, 13, 2, 2, 17, 17, 17, 15, 13, 12, 13, 29, 2, 2, 2, 18, 13, 2, 13, 13, 18, 13, 13, 18, 13, 13, 13, 23, 13, 23, 13, 0, 13, 4, 4, 13, 0, 13, 17, 13, 0, 13, 2, 39, 17, 2, 13, 13, 28, 13, 4, 13, 17, 2, 13, 13, 0, 18, 13, 13, 2, 2, 18, 13, 2, 13, 17, 13, 13, 41, 28, 13, 13, 4, 4, 13, 13, 2, 13, 17, 13, 0, 13, 13, 0, 13, 17, 28, 13, 4, 13, 13, 13, 0, 13, 2, 2, 4, 13, 13, 2, 2, 13, 17, 13, 4, 13, 2, 2, 13, 17, 13, 2, 13, 17, 13, 4, 13, 2, 13, 13, 10, 4, 13, 10, 12, 13, 10, 2, 13, 10, 4, 13, 10, 2, 13, 10, 4, 13, 10, 13, 13, 10, 2, 13, 10, 17, 13, 10, 4, 13 ]

[ [ 163, 2 ], [ 163, 11 ], [ 163, 12 ], [ 163, 13 ], [ 148, 15 ], [ 140, 24 ], [ 47, 24 ], [ 42, 32 ], [ 44, 33 ], [ 42, 36 ], [ 44, 39 ], [ 149, 40 ], [ 42, 42 ], [ 44, 44 ], [ 140, 46 ], [ 47, 46 ], [ 52, 51 ], [ 140, 53 ], [ 47, 53 ], [ 157, 55 ], [ 164, 60 ], [ 152, 61 ], [ 64, 63 ], [ 164, 68 ], [ 152, 69 ], [ 74, 71 ], [ 158, 72 ], [ 63, 73 ], [ 158, 77 ], [ 63, 79 ], [ 63, 81 ], [ 149, 82 ], [ 86, 85 ], [ 158, 85 ], [ 85, 90 ], [ 149, 92 ], [ 149, 94 ], [ 154, 96 ], [ 160, 99 ], [ 103, 102 ], [ 146, 105 ], [ 152, 106 ], [ 142, 108 ], [ 140, 112 ], [ 102, 113 ], [ 164, 116 ], [ 137, 118 ], [ 140, 120 ], [ 152, 123 ], [ 102, 125 ], [ 137, 127 ], [ 149, 129 ], [ 143, 133 ], [ 161, 133 ], [ 149, 134 ], [ 163, 137 ], [ 140, 140 ], [ 47, 140 ], [ 142, 143 ], [ 163, 146 ], [ 148, 149 ], [ 163, 152 ], [ 154, 155 ], [ 157, 158 ], [ 160, 161 ], [ 163, 164 ] ]

[ "H, W, A, B = map(int, input().split())\n\nm = 10**9 + 7\n\nimport functools\[email protected]_cache(maxsize=None)\ndef cr(c, r):\n return fc[c + r] * ic[c] * ic[r] % m\n\nfc = [1] * (H + W)\nfor i in range(2, H+W):\n fc[i] = fc[i - 1] * i % m\nic = [pow(x, m-2, m) for x in fc]\n\nans = 0\nfor c in range(B, W):\n ans += cr(c, H - 1 - A) * cr(W - 1 - c, A - 1) % m\nprint(ans % m)", "H, W, A, B = map(int, input().split())", "H", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "W", "A", "B", "m = 10**9 + 7", "m", "10**9 + 7", "10**9", "10", "9", "7", "import functools", "functools", "def cr(c, r):\n return fc[c + r] * ic[c] * ic[r] % m", "cr", "return fc[c + r] * ic[c] * ic[r] % m", "fc[c + r] * ic[c] * ic[r] % m", "fc[c + r] * ic[c] * ic[r]", "fc[c + r] * ic[c]", "fc[c + r]", "fc", "c + r", "c", "r", "ic[c]", "ic", "c", "ic[r]", "ic", "r", "m", "c", "c", "r", "r", "@functools.lru_cache(maxsize=None)", "cr", "maxsize=None", "@functools.lru_cache(maxsize=None)", "functools.lru_cache", "maxsize=None", "maxsize", "None", "cr", "fc = [1] * (H + W)", "fc", "[1] * (H + W)", "[1]", "1", "H + W", "H", "W", "for i in range(2, H+W):\n fc[i] = fc[i - 1] * i % m", "i", "range(2, H+W)", "range", "2", "H+W", "H", "W", "fc[i] = fc[i - 1] * i % m", "fc[i]", "fc", "i", "fc[i - 1] * i % m", "fc[i - 1] * i", "fc[i - 1]", "fc", "i - 1", "i", "1", "i", "m", "pow(x, m-2, m) for x in fc", "for x in fc", "x", "fc", "for x in fc", "pow(x, m-2, m)", "pow", "x", "m-2", "m", "2", "m", "ic = [pow(x, m-2, m) for x in fc]", "ic", "[pow(x, m-2, m) for x in fc]", "ans = 0", "ans", "0", "for c in range(B, W):\n ans += cr(c, H - 1 - A) * cr(W - 1 - c, A - 1) % m", "c", "range(B, W)", "range", "B", "W", "ans += cr(c, H - 1 - A) * cr(W - 1 - c, A - 1) % m", "ans", "cr(c, H - 1 - A) * cr(W - 1 - c, A - 1) % m", "cr(c, H - 1 - A) * cr(W - 1 - c, A - 1)", "cr(c, H - 1 - A)", "cr", "c", "H - 1 - A", "H - 1", "H", "1", "A", "cr(W - 1 - c, A - 1)", "cr", "W - 1 - c", "W - 1", "W", "1", "c", "A - 1", "A", "1", "m", "print(ans % m)", "print", "ans % m", "ans", "m", "A, B = map(int, input().split())", "map(int, input().split())", "A", "def cr(c, r):\n return fc[c + r] * ic[c] * ic[r] % m", "def cr(c, r):\n return fc[c + r] * ic[c] * ic[r] % m", "cr", "ans += cr(c, H - 1 - A) * cr(W - 1 - c, A - 1) % m", "cr(c, H - 1 - A) * cr(W - 1 - c, A - 1) % m", "ans", "B = map(int, input().split())", "map(int, input().split())", "B", "m = 10**9 + 7", "10**9 + 7", "m", "W, A, B = map(int, input().split())", "map(int, input().split())", "W", "ic = [pow(x, m-2, m) for x in fc]", "[pow(x, m-2, m) for x in fc]", "ic", "fc = [1] * (H + W)", "[1] * (H + W)", "fc", "ans = 0", "0", "ans", "H, W, A, B = map(int, input().split())", "map(int, input().split())", "H" ]

[ 7, 6, 13, 17, 12, 13, 0, 18, 13, 13, 13, 0, 18, 13, 13, 4, 18, 13, 13, 13, 18, 13, 13, 23, 13, 23, 13, 23, 13, 2, 2, 17, 17, 17, 12, 13, 14, 2, 2, 13, 17, 2, 13, 13, 29, 17, 0, 13, 2, 2, 18, 18, 13, 13, 13, 18, 18, 13, 13, 13, 18, 13, 13, 0, 13, 2, 2, 13, 18, 18, 13, 13, 2, 13, 13, 18, 13, 13, 29, 13, 23, 13, 23, 13, 23, 13, 12, 13, 0, 13, 2, 39, 17, 2, 13, 17, 0, 13, 2, 39, 17, 2, 13, 17, 0, 13, 18, 13, 13, 28, 13, 4, 13, 17, 2, 13, 17, 0, 18, 13, 13, 2, 2, 18, 13, 2, 13, 17, 13, 13, 0, 18, 13, 13, 4, 13, 18, 13, 13, 2, 13, 17, 13, 28, 13, 4, 13, 13, 17, 17, 0, 18, 13, 2, 13, 17, 2, 2, 18, 13, 13, 13, 13, 29, 39, 13, 13, 23, 13, 23, 13, 14, 2, 13, 17, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 13, 13, 0, 13, 2, 2, 17, 17, 17, 0, 13, 4, 13, 2, 2, 17, 2, 17, 17, 17, 13, 0, 13, 17, 0, 13, 2, 13, 13, 0, 13, 2, 13, 17, 42, 17, 0, 13, 4, 13, 2, 2, 13, 13, 17, 2, 13, 17, 0, 13, 2, 13, 13, 0, 13, 2, 13, 13, 0, 13, 4, 13, 2, 13, 13, 13, 0, 13, 2, 2, 13, 13, 13, 0, 13, 13, 0, 13, 17, 0, 13, 17, 14, 2, 40, 13, 17, 2, 13, 13, 3, 4, 13, 13, 10, 2, 13, 10, 4, 13, 10, 4, 13, 10, 13, 13, 10, 6, 13, 10, 4, 13, 10, 17, 13, 10, 2, 13, 10, 2, 13, 10, 17, 13, 10, 4, 13, 10, 17, 13, 10, 4, 13, 10, 2, 13, 10, 2, 13, 10, 2, 13, 10, 4, 13, 10, 4, 13 ]

[ [ 10, 7 ], [ 24, 8 ], [ 28, 9 ], [ 28, 10 ], [ 15, 12 ], [ 24, 13 ], [ 24, 17 ], [ 26, 19 ], [ 15, 20 ], [ 24, 21 ], [ 24, 24 ], [ 26, 26 ], [ 29, 28 ], [ 85, 39 ], [ 85, 42 ], [ 83, 43 ], [ 48, 47 ], [ 81, 52 ], [ 83, 54 ], [ 81, 57 ], [ 85, 59 ], [ 81, 61 ], [ 65, 64 ], [ 47, 67 ], [ 81, 70 ], [ 83, 73 ], [ 85, 74 ], [ 81, 76 ], [ 64, 79 ], [ 47, 79 ], [ 81, 81 ], [ 83, 83 ], [ 85, 85 ], [ 90, 89 ], [ 170, 94 ], [ 98, 97 ], [ 170, 102 ], [ 106, 105 ], [ 168, 107 ], [ 111, 110 ], [ 170, 115 ], [ 121, 118 ], [ 89, 119 ], [ 110, 120 ], [ 89, 124 ], [ 110, 126 ], [ 110, 128 ], [ 105, 129 ], [ 134, 131 ], [ 97, 132 ], [ 170, 133 ], [ 89, 137 ], [ 170, 138 ], [ 105, 140 ], [ 105, 142 ], [ 145, 144 ], [ 170, 147 ], [ 156, 151 ], [ 97, 152 ], [ 144, 154 ], [ 97, 159 ], [ 144, 160 ], [ 144, 161 ], [ 105, 162 ], [ 168, 168 ], [ 170, 170 ], [ 332, 176 ], [ 332, 185 ], [ 332, 186 ], [ 332, 187 ], [ 302, 189 ], [ 311, 196 ], [ 303, 206 ], [ 299, 208 ], [ 320, 211 ], [ 297, 213 ], [ 333, 214 ], [ 281, 216 ], [ 318, 218 ], [ 284, 223 ], [ 312, 225 ], [ 321, 228 ], [ 309, 228 ], [ 282, 229 ], [ 315, 229 ], [ 321, 232 ], [ 309, 232 ], [ 323, 235 ], [ 297, 237 ], [ 321, 238 ], [ 309, 238 ], [ 305, 240 ], [ 288, 242 ], [ 282, 243 ], [ 315, 243 ], [ 329, 245 ], [ 312, 247 ], [ 324, 249 ], [ 306, 250 ], [ 324, 251 ], [ 326, 253 ], [ 285, 256 ], [ 330, 257 ], [ 303, 258 ], [ 290, 260 ], [ 303, 261 ], [ 308, 263 ], [ 314, 266 ], [ 309, 271 ], [ 321, 271 ], [ 315, 274 ], [ 282, 274 ], [ 288, 275 ], [ 291, 279 ], [ 327, 279 ], [ 300, 279 ], [ 281, 282 ], [ 284, 285 ], [ 332, 288 ], [ 303, 290 ], [ 290, 291 ], [ 332, 297 ], [ 299, 300 ], [ 302, 303 ], [ 305, 306 ], [ 308, 309 ], [ 311, 312 ], [ 314, 315 ], [ 332, 318 ], [ 320, 321 ], [ 323, 324 ], [ 326, 327 ], [ 329, 330 ], [ 332, 333 ] ]

[ "class Combination:\n \"\"\"\n SIZEが10^6程度以下の二項係数を何回も呼び出したいときに使う\n 使い方:\n comb = Combination(SIZE, MOD)\n comb(10, 3) => 120\n \"\"\"\n\n def __init__(self, N, MOD=10 ** 9 + 7):\n self.MOD = MOD\n self.fact, self.inv = self._make_factorial_list(N)\n\n def __call__(self, n, k):\n if k < 0 or k > n:\n return 0\n res = self.fact[n] * self.inv[k] % self.MOD\n res = res * self.inv[n - k] % self.MOD\n return res\n\n def _make_factorial_list(self, N):\n fact = [1] * (N + 1)\n inv = [1] * (N + 1)\n MOD = self.MOD\n for i in range(1, N + 1):\n fact[i] = (fact[i - 1] * i) % MOD\n inv[N] = pow(fact[N], MOD - 2, MOD)\n for i in range(N, 0, -1):\n inv[i - 1] = (inv[i] * i) % MOD\n return fact, inv\n\n\nif __name__ == \"__main__\":\n H, W, A, B = map(int, input().split())\n mod = 10**9+7\n comb = Combination(2*10**5+10, mod)\n\n ans = 0\n h1 = H - A\n w1 = B + 1\n while True:\n X = comb(h1 + w1 - 2, h1 - 1)\n h2 = H - h1\n w2 = W - w1\n Y = comb(h2 + w2, h2)\n ans += X * Y % mod\n ans %= mod\n\n h1 -= 1\n w1 += 1\n if h1 <= 0 or w1 > W:\n break\n\n print(ans)", "class Combination:\n \"\"\"\n SIZEが10^6程度以下の二項係数を何回も呼び出したいときに使う\n 使い方:\n comb = Combination(SIZE, MOD)\n comb(10, 3) => 120\n \"\"\"\n\n def __init__(self, N, MOD=10 ** 9 + 7):\n self.MOD = MOD\n self.fact, self.inv = self._make_factorial_list(N)\n\n def __call__(self, n, k):\n if k < 0 or k > n:\n return 0\n res = self.fact[n] * self.inv[k] % self.MOD\n res = res * self.inv[n - k] % self.MOD\n return res\n\n def _make_factorial_list(self, N):\n fact = [1] * (N + 1)\n inv = [1] * (N + 1)\n MOD = self.MOD\n for i in range(1, N + 1):\n fact[i] = (fact[i - 1] * i) % MOD\n inv[N] = pow(fact[N], MOD - 2, MOD)\n for i in range(N, 0, -1):\n inv[i - 1] = (inv[i] * i) % MOD\n return fact, inv", "Combination", "\"\"\"\n SIZEが10^6程度以下の二項係数を何回も呼び出したいときに使う\n 使い方:\n comb = Combination(SIZE, MOD)\n comb(10, 3) => 120\n \"\"\"", "def __init__(self, N, MOD=10 ** 9 + 7):\n self.MOD = MOD\n self.fact, self.inv = self._make_factorial_list(N)\n\n ", "__init__", "self.MOD = MOD", "self.MOD", "self", "MOD", "MOD", "self.fact, self.inv = self._make_factorial_list(N)", "self.fact", "self", "fact", "self._make_factorial_list(N)", "self._make_factorial_list", "self", "_make_factorial_list", "N", "self.inv", "self", "inv", "self", "self", "N", "N", "MOD=10 ** 9 + 7", "MOD", "10 ** 9 + 7", "10 ** 9", "10", "9", "7", "def __call__(self, n, k):\n if k < 0 or k > n:\n return 0\n res = self.fact[n] * self.inv[k] % self.MOD\n res = res * self.inv[n - k] % self.MOD\n return res\n\n ", "__call__", "if k < 0 or k > n:\n return 0\n ", "k < 0 or k > n", "k < 0", "k", "0", "k > n", "k", "n", "return 0", "0", "res = self.fact[n] * self.inv[k] % self.MOD", "res", "self.fact[n] * self.inv[k] % self.MOD", "self.fact[n] * self.inv[k]", "self.fact[n]", "self.fact", "self", "fact", "n", "self.inv[k]", "self.inv", "self", "inv", "k", "self.MOD", "self", "MOD", "res = res * self.inv[n - k] % self.MOD", "res", "res * self.inv[n - k] % self.MOD", "res * self.inv[n - k]", "res", "self.inv[n - k]", "self.inv", "self", "inv", "n - k", "n", "k", "self.MOD", "self", "MOD", "return res", "res", "self", "self", "n", "n", "k", "k", "def _make_factorial_list(self, N):\n fact = [1] * (N + 1)\n inv = [1] * (N + 1)\n MOD = self.MOD\n for i in range(1, N + 1):\n fact[i] = (fact[i - 1] * i) % MOD\n inv[N] = pow(fact[N], MOD - 2, MOD)\n for i in range(N, 0, -1):\n inv[i - 1] = (inv[i] * i) % MOD\n return fact, inv", "_make_factorial_list", "fact = [1] * (N + 1)", "fact", "[1] * (N + 1)", "[1]", "1", "N + 1", "N", "1", "inv = [1] * (N + 1)", "inv", "[1] * (N + 1)", "[1]", "1", "N + 1", "N", "1", "MOD = self.MOD", "MOD", "self.MOD", "self", "MOD", "for i in range(1, N + 1):\n fact[i] = (fact[i - 1] * i) % MOD\n ", "i", "range(1, N + 1)", "range", "1", "N + 1", "N", "1", "fact[i] = (fact[i - 1] * i) % MOD", "fact[i]", "fact", "i", "(fact[i - 1] * i) % MOD", "fact[i - 1] * i", "fact[i - 1]", "fact", "i - 1", "i", "1", "i", "MOD", "inv[N] = pow(fact[N], MOD - 2, MOD)", "inv[N]", "inv", "N", "pow(fact[N], MOD - 2, MOD)", "pow", "fact[N]", "fact", "N", "MOD - 2", "MOD", "2", "MOD", "for i in range(N, 0, -1):\n inv[i - 1] = (inv[i] * i) % MOD\n ", "i", "range(N, 0, -1)", "range", "N", "0", "-1", "inv[i - 1] = (inv[i] * i) % MOD", "inv[i - 1]", "inv", "i - 1", "i", "1", "(inv[i] * i) % MOD", "inv[i] * i", "inv[i]", "inv", "i", "i", "MOD", "return fact, inv", "return fact, inv", "fact", "inv", "self", "self", "N", "N", "if __name__ == \"__main__\":\n H, W, A, B = map(int, input().split())\n mod = 10**9+7\n comb = Combination(2*10**5+10, mod)\n\n ans = 0\n h1 = H - A\n w1 = B + 1\n while True:\n X = comb(h1 + w1 - 2, h1 - 1)\n h2 = H - h1\n w2 = W - w1\n Y = comb(h2 + w2, h2)\n ans += X * Y % mod\n ans %= mod\n\n h1 -= 1\n w1 += 1\n if h1 <= 0 or w1 > W:\n break\n\n print(ans)", "__name__ == \"__main__\"", "__name__", "\"__main__\"", "H, W, A, B = map(int, input().split())", "H", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "W", "A", "B", "mod = 10**9+7", "mod", "10**9+7", "10**9", "10", "9", "7", "comb = Combination(2*10**5+10, mod)", "comb", "Combination(2*10**5+10, mod)", "Combination", "2*10**5+10", "2*10**5", "2", "10**5", "10", "5", "10", "mod", "ans = 0", "ans", "0", "h1 = H - A", "h1", "H - A", "H", "A", "w1 = B + 1", "w1", "B + 1", "B", "1", "while True:\n X = comb(h1 + w1 - 2, h1 - 1)\n h2 = H - h1\n w2 = W - w1\n Y = comb(h2 + w2, h2)\n ans += X * Y % mod\n ans %= mod\n\n h1 -= 1\n w1 += 1\n if h1 <= 0 or w1 > W:\n break\n\n ", "True", "X = comb(h1 + w1 - 2, h1 - 1)", "X", "comb(h1 + w1 - 2, h1 - 1)", "comb", "h1 + w1 - 2", "h1 + w1", "h1", "w1", "2", "h1 - 1", "h1", "1", "h2 = H - h1", "h2", "H - h1", "H", "h1", "w2 = W - w1", "w2", "W - w1", "W", "w1", "Y = comb(h2 + w2, h2)", "Y", "comb(h2 + w2, h2)", "comb", "h2 + w2", "h2", "w2", "h2", "ans += X * Y % mod", "ans", "X * Y % mod", "X * Y", "X", "Y", "mod", "ans %= mod", "ans", "mod", "h1 -= 1", "h1", "1", "w1 += 1", "w1", "1", "if h1 <= 0 or w1 > W:\n break\n\n ", "h1 <= 0 or w1 > W", "h1 <= 0", "h1", "0", "w1 > W", "w1", "W", "break", "print(ans)", "print", "ans", "w1 = B + 1", "B + 1", "w1", "X = comb(h1 + w1 - 2, h1 - 1)", "comb(h1 + w1 - 2, h1 - 1)", "X", "W, A, B = map(int, input().split())", "map(int, input().split())", "W", "ans %= mod", "mod", "ans", "class Combination:\n \"\"\"\n SIZEが10^6程度以下の二項係数を何回も呼び出したいときに使う\n 使い方:\n comb = Combination(SIZE, MOD)\n comb(10, 3) => 120\n \"\"\"\n\n def __init__(self, N, MOD=10 ** 9 + 7):\n self.MOD = MOD\n self.fact, self.inv = self._make_factorial_list(N)\n\n def __call__(self, n, k):\n if k < 0 or k > n:\n return 0\n res = self.fact[n] * self.inv[k] % self.MOD\n res = res * self.inv[n - k] % self.MOD\n return res\n\n def _make_factorial_list(self, N):\n fact = [1] * (N + 1)\n inv = [1] * (N + 1)\n MOD = self.MOD\n for i in range(1, N + 1):\n fact[i] = (fact[i - 1] * i) % MOD\n inv[N] = pow(fact[N], MOD - 2, MOD)\n for i in range(N, 0, -1):\n inv[i - 1] = (inv[i] * i) % MOD\n return fact, inv", "class Combination:\n \"\"\"\n SIZEが10^6程度以下の二項係数を何回も呼び出したいときに使う\n 使い方:\n comb = Combination(SIZE, MOD)\n comb(10, 3) => 120\n \"\"\"\n\n def __init__(self, N, MOD=10 ** 9 + 7):\n self.MOD = MOD\n self.fact, self.inv = self._make_factorial_list(N)\n\n def __call__(self, n, k):\n if k < 0 or k > n:\n return 0\n res = self.fact[n] * self.inv[k] % self.MOD\n res = res * self.inv[n - k] % self.MOD\n return res\n\n def _make_factorial_list(self, N):\n fact = [1] * (N + 1)\n inv = [1] * (N + 1)\n MOD = self.MOD\n for i in range(1, N + 1):\n fact[i] = (fact[i - 1] * i) % MOD\n inv[N] = pow(fact[N], MOD - 2, MOD)\n for i in range(N, 0, -1):\n inv[i - 1] = (inv[i] * i) % MOD\n return fact, inv", "Combination", "H, W, A, B = map(int, input().split())", "map(int, input().split())", "H", "ans = 0", "0", "ans", "mod = 10**9+7", "10**9+7", "mod", "w2 = W - w1", "W - w1", "w2", "h1 -= 1", "1", "h1", "comb = Combination(2*10**5+10, mod)", "Combination(2*10**5+10, mod)", "comb", "w1 += 1", "1", "w1", "B = map(int, input().split())", "map(int, input().split())", "B", "h1 = H - A", "H - A", "h1", "h2 = H - h1", "H - h1", "h2", "ans += X * Y % mod", "X * Y % mod", "ans", "Y = comb(h2 + w2, h2)", "comb(h2 + w2, h2)", "Y", "A, B = map(int, input().split())", "map(int, input().split())", "A" ]

[ 7, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 13, 13, 0, 13, 17, 0, 13, 17, 0, 13, 2, 39, 17, 13, 0, 13, 2, 39, 17, 13, 0, 13, 2, 39, 17, 13, 0, 18, 13, 17, 17, 0, 18, 13, 17, 17, 0, 18, 13, 17, 17, 0, 18, 13, 17, 17, 0, 18, 13, 17, 17, 28, 13, 4, 13, 17, 13, 0, 18, 13, 13, 2, 2, 18, 13, 2, 13, 17, 13, 13, 0, 18, 13, 13, 2, 13, 2, 2, 18, 13, 2, 13, 13, 2, 13, 13, 13, 0, 18, 13, 13, 2, 2, 18, 13, 2, 13, 17, 18, 13, 13, 13, 0, 13, 17, 28, 13, 4, 13, 13, 13, 0, 13, 2, 2, 2, 2, 2, 18, 13, 2, 2, 2, 13, 13, 17, 13, 2, 2, 18, 13, 2, 2, 13, 13, 17, 18, 13, 13, 13, 13, 18, 13, 2, 2, 2, 13, 13, 13, 17, 2, 2, 18, 13, 2, 13, 17, 18, 13, 2, 2, 13, 17, 13, 13, 13, 0, 13, 2, 13, 13, 4, 13, 13, 10, 4, 13, 10, 4, 13, 10, 4, 13, 10, 2, 13, 10, 2, 13, 10, 17, 13, 10, 17, 13, 10, 2, 13, 10, 4, 13, 10, 17, 13, 10, 2, 13, 10, 2, 13 ]

[ [ 211, 2 ], [ 211, 11 ], [ 211, 12 ], [ 211, 13 ], [ 202, 15 ], [ 214, 18 ], [ 208, 21 ], [ 203, 25 ], [ 220, 27 ], [ 203, 31 ], [ 217, 33 ], [ 203, 37 ], [ 42, 39 ], [ 209, 40 ], [ 47, 44 ], [ 209, 45 ], [ 52, 49 ], [ 221, 50 ], [ 57, 54 ], [ 221, 55 ], [ 62, 59 ], [ 218, 60 ], [ 65, 64 ], [ 203, 68 ], [ 73, 70 ], [ 209, 71 ], [ 64, 72 ], [ 209, 76 ], [ 64, 78 ], [ 64, 80 ], [ 215, 81 ], [ 86, 83 ], [ 218, 84 ], [ 64, 85 ], [ 215, 87 ], [ 218, 91 ], [ 215, 93 ], [ 64, 94 ], [ 215, 96 ], [ 64, 97 ], [ 215, 98 ], [ 103, 100 ], [ 221, 101 ], [ 64, 102 ], [ 221, 106 ], [ 64, 108 ], [ 83, 110 ], [ 218, 111 ], [ 64, 112 ], [ 215, 113 ], [ 205, 115 ], [ 119, 118 ], [ 212, 121 ], [ 188, 122 ], [ 196, 124 ], [ 209, 131 ], [ 194, 135 ], [ 191, 136 ], [ 118, 138 ], [ 221, 142 ], [ 194, 145 ], [ 191, 146 ], [ 100, 148 ], [ 221, 149 ], [ 118, 150 ], [ 215, 151 ], [ 215, 152 ], [ 209, 154 ], [ 191, 158 ], [ 188, 159 ], [ 118, 160 ], [ 221, 165 ], [ 191, 167 ], [ 221, 170 ], [ 188, 173 ], [ 118, 175 ], [ 215, 176 ], [ 215, 177 ], [ 199, 179 ], [ 197, 181 ], [ 206, 181 ], [ 200, 181 ], [ 215, 182 ], [ 200, 185 ], [ 197, 185 ], [ 206, 185 ], [ 211, 188 ], [ 211, 191 ], [ 211, 194 ], [ 196, 197 ], [ 199, 200 ], [ 202, 203 ], [ 205, 206 ], [ 208, 209 ], [ 211, 212 ], [ 214, 215 ], [ 217, 218 ], [ 220, 221 ] ]

[ "H, W, A, B = map(int, input().split())\nMAX = 200000\nMOD = 1000000007\nfac = [0]*MAX\nfinv = [0]*MAX\ninv = [0]*MAX\nfac[0] = 1\nfac[1] = 1\nfinv[0] = 1\nfinv[1] = 1\ninv[1] = 1\nfor i in range(2, MAX):\n fac[i] = fac[i-1]*i%MOD\n inv[i] = MOD - inv[MOD%i]*(MOD//i)%MOD\n finv[i] = finv[i-1]*inv[i]%MOD \n# sum_{i=B}^{W-1} C_{H-A-1+i}_{i}C_{A+W-i-2}_{A-1}\nr = 0\nfor i in range(B, W):\n r += fac[H-A-1+i]*(finv[H-A-1]*finv[i]%MOD)%MOD * fac[A+W-i-2]*(finv[A-1]*finv[W-1-i]%MOD)%MOD\n r = r%MOD\nprint(r)", "H, W, A, B = map(int, input().split())", "H", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "W", "A", "B", "MAX = 200000", "MAX", "200000", "MOD = 1000000007", "MOD", "1000000007", "fac = [0]*MAX", "fac", "[0]*MAX", "[0]", "0", "MAX", "finv = [0]*MAX", "finv", "[0]*MAX", "[0]", "0", "MAX", "inv = [0]*MAX", "inv", "[0]*MAX", "[0]", "0", "MAX", "fac[0] = 1", "fac[0]", "fac", "0", "1", "fac[1] = 1", "fac[1]", "fac", "1", "1", "finv[0] = 1", "finv[0]", "finv", "0", "1", "finv[1] = 1", "finv[1]", "finv", "1", "1", "inv[1] = 1", "inv[1]", "inv", "1", "1", "for i in range(2, MAX):\n fac[i] = fac[i-1]*i%MOD\n inv[i] = MOD - inv[MOD%i]*(MOD//i)%MOD\n finv[i] = finv[i-1]*inv[i]%MOD \n# sum_{i=B}^{W-1} C_{H-A-1+i}_{i}C_{A+W-i-2}_{A-1}", "i", "range(2, MAX)", "range", "2", "MAX", "fac[i] = fac[i-1]*i%MOD", "fac[i]", "fac", "i", "fac[i-1]*i%MOD", "fac[i-1]*i", "fac[i-1]", "fac", "i-1", "i", "1", "i", "MOD", "inv[i] = MOD - inv[MOD%i]*(MOD//i)%MOD", "inv[i]", "inv", "i", "MOD - inv[MOD%i]*(MOD//i)%MOD", "MOD", "inv[MOD%i]*(MOD//i)%MOD", "inv[MOD%i]*(MOD//i)", "inv[MOD%i]", "inv", "MOD%i", "MOD", "i", "MOD//i", "MOD", "i", "MOD", "finv[i] = finv[i-1]*inv[i]%MOD", "finv[i]", "finv", "i", "finv[i-1]*inv[i]%MOD", "finv[i-1]*inv[i]", "finv[i-1]", "finv", "i-1", "i", "1", "inv[i]", "inv", "i", "MOD", "r = 0", "r", "0", "for i in range(B, W):\n r += fac[H-A-1+i]*(finv[H-A-1]*finv[i]%MOD)%MOD * fac[A+W-i-2]*(finv[A-1]*finv[W-1-i]%MOD)%MOD\n r = r%MOD", "i", "range(B, W)", "range", "B", "W", "r += fac[H-A-1+i]*(finv[H-A-1]*finv[i]%MOD)%MOD * fac[A+W-i-2]*(finv[A-1]*finv[W-1-i]%MOD)%MOD", "r", "fac[H-A-1+i]*(finv[H-A-1]*finv[i]%MOD)%MOD * fac[A+W-i-2]*(finv[A-1]*finv[W-1-i]%MOD)%MOD", "fac[H-A-1+i]*(finv[H-A-1]*finv[i]%MOD)%MOD * fac[A+W-i-2]*(finv[A-1]*finv[W-1-i]%MOD)", "fac[H-A-1+i]*(finv[H-A-1]*finv[i]%MOD)%MOD * fac[A+W-i-2]", "fac[H-A-1+i]*(finv[H-A-1]*finv[i]%MOD)%MOD", "fac[H-A-1+i]*(finv[H-A-1]*finv[i]%MOD)", "fac[H-A-1+i]", "fac", "H-A-1+i", "H-A-1", "H-A", "H", "A", "1", "i", "finv[H-A-1]*finv[i]%MOD", "finv[H-A-1]*finv[i]", "finv[H-A-1]", "finv", "H-A-1", "H-A", "H", "A", "1", "finv[i]", "finv", "i", "MOD", "MOD", "fac[A+W-i-2]", "fac", "A+W-i-2", "A+W-i", "A+W", "A", "W", "i", "2", "finv[A-1]*finv[W-1-i]%MOD", "finv[A-1]*finv[W-1-i]", "finv[A-1]", "finv", "A-1", "A", "1", "finv[W-1-i]", "finv", "W-1-i", "W-1", "W", "1", "i", "MOD", "MOD", "r = r%MOD", "r", "r%MOD", "r", "MOD", "print(r)", "print", "r", "W, A, B = map(int, input().split())", "map(int, input().split())", "W", "A, B = map(int, input().split())", "map(int, input().split())", "A", "H, W, A, B = map(int, input().split())", "map(int, input().split())", "H", "r += fac[H-A-1+i]*(finv[H-A-1]*finv[i]%MOD)%MOD * fac[A+W-i-2]*(finv[A-1]*finv[W-1-i]%MOD)%MOD", "fac[H-A-1+i]*(finv[H-A-1]*finv[i]%MOD)%MOD * fac[A+W-i-2]*(finv[A-1]*finv[W-1-i]%MOD)%MOD", "r", "r = r%MOD", "r%MOD", "r", "MAX = 200000", "200000", "MAX", "r = 0", "0", "r", "fac = [0]*MAX", "[0]*MAX", "fac", "B = map(int, input().split())", "map(int, input().split())", "B", "MOD = 1000000007", "1000000007", "MOD", "inv = [0]*MAX", "[0]*MAX", "inv", "finv = [0]*MAX", "[0]*MAX", "finv" ]

[ 7, 0, 13, 2, 2, 17, 17, 17, 12, 13, 0, 13, 17, 42, 2, 13, 17, 14, 2, 13, 17, 0, 13, 2, 2, 13, 13, 13, 0, 13, 2, 2, 13, 17, 13, 0, 13, 17, 29, 13, 23, 13, 23, 13, 23, 13, 12, 13, 29, 2, 2, 13, 13, 13, 23, 13, 23, 13, 23, 13, 12, 13, 0, 13, 2, 39, 17, 2, 2, 13, 13, 17, 0, 18, 13, 17, 17, 0, 13, 2, 39, 17, 2, 2, 13, 13, 17, 0, 18, 13, 17, 17, 28, 13, 4, 13, 17, 2, 13, 13, 0, 18, 13, 13, 2, 2, 18, 13, 2, 13, 17, 13, 13, 0, 18, 13, 13, 4, 13, 18, 13, 13, 2, 13, 17, 13, 0, 13, 17, 28, 13, 4, 13, 13, 13, 0, 13, 4, 13, 4, 13, 18, 13, 2, 2, 2, 13, 13, 17, 13, 18, 13, 2, 2, 13, 13, 17, 13, 18, 13, 13, 13, 0, 13, 4, 13, 4, 13, 18, 13, 2, 2, 13, 17, 2, 2, 13, 13, 17, 18, 13, 2, 2, 13, 13, 17, 13, 18, 13, 2, 13, 17, 13, 0, 13, 2, 2, 13, 4, 13, 13, 13, 13, 13, 29, 13, 23, 13, 23, 13, 23, 13, 23, 13, 14, 2, 13, 17, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 13, 13, 4, 13, 4, 13, 13, 13, 13, 13, 10, 12, 13, 10, 4, 13, 10, 4, 13, 10, 4, 13, 10, 2, 13, 10, 12, 13, 10, 12, 13, 10, 4, 13 ]

[ [ 252, 2 ], [ 12, 11 ], [ 43, 15 ], [ 36, 15 ], [ 43, 19 ], [ 36, 19 ], [ 23, 22 ], [ 11, 25 ], [ 22, 25 ], [ 41, 26 ], [ 29, 26 ], [ 45, 27 ], [ 30, 29 ], [ 41, 32 ], [ 29, 32 ], [ 45, 34 ], [ 37, 36 ], [ 22, 39 ], [ 11, 39 ], [ 41, 41 ], [ 43, 43 ], [ 45, 45 ], [ 55, 51 ], [ 57, 52 ], [ 59, 53 ], [ 55, 55 ], [ 57, 57 ], [ 59, 59 ], [ 64, 63 ], [ 207, 69 ], [ 209, 70 ], [ 76, 73 ], [ 63, 74 ], [ 79, 78 ], [ 207, 84 ], [ 209, 85 ], [ 91, 88 ], [ 78, 89 ], [ 94, 93 ], [ 207, 98 ], [ 209, 99 ], [ 104, 101 ], [ 63, 102 ], [ 93, 103 ], [ 63, 107 ], [ 93, 109 ], [ 93, 111 ], [ 253, 112 ], [ 117, 114 ], [ 78, 115 ], [ 93, 116 ], [ 256, 118 ], [ 101, 119 ], [ 63, 120 ], [ 93, 121 ], [ 253, 123 ], [ 253, 125 ], [ 128, 127 ], [ 131, 130 ], [ 213, 133 ], [ 209, 134 ], [ 137, 136 ], [ 241, 138 ], [ 241, 140 ], [ 63, 142 ], [ 207, 146 ], [ 211, 147 ], [ 130, 149 ], [ 78, 151 ], [ 207, 154 ], [ 211, 155 ], [ 253, 157 ], [ 78, 159 ], [ 130, 160 ], [ 253, 161 ], [ 164, 163 ], [ 241, 165 ], [ 241, 167 ], [ 63, 169 ], [ 211, 172 ], [ 209, 176 ], [ 130, 177 ], [ 78, 180 ], [ 209, 183 ], [ 130, 184 ], [ 253, 186 ], [ 78, 188 ], [ 211, 190 ], [ 253, 192 ], [ 195, 194 ], [ 127, 197 ], [ 194, 197 ], [ 241, 199 ], [ 136, 200 ], [ 163, 201 ], [ 253, 202 ], [ 253, 203 ], [ 194, 205 ], [ 127, 205 ], [ 207, 207 ], [ 209, 209 ], [ 211, 211 ], [ 213, 213 ], [ 261, 219 ], [ 261, 228 ], [ 261, 229 ], [ 261, 230 ], [ 259, 234 ], [ 247, 235 ], [ 250, 236 ], [ 244, 237 ], [ 262, 238 ], [ 261, 244 ], [ 261, 247 ], [ 261, 250 ], [ 252, 253 ], [ 261, 262 ] ]

[ "MOD = 10**9+7\n\ndef modpow(base, pow, mod):\n res = 1\n while pow > 0:\n if pow & 1:\n res = res * base % mod\n base = base**2 % mod\n pow >>= 1\n return res\n\ndef modmul(a, b, mod):\n return a*b % mod\n\ndef solve(h,w,a,b):\n fact = [0]*(h+w+1)\n fact[0] = 1\n fact_inv = [0]*(h+w+1)\n fact_inv[0] = 1\n for i in range(1, h+w):\n fact[i] = fact[i-1]*i % MOD\n fact_inv[i] = modpow(fact[i], MOD-2, MOD)\n\n ans = 0\n for col_idx in range(b, w):\n before_checkpoint = modmul(modmul(fact[h-a-1+col_idx], fact_inv[h-a-1], MOD), fact_inv[col_idx], MOD)\n from_checkpoint = modmul(modmul(fact[(a-1) + (w-col_idx-1)], fact_inv[w-col_idx-1], MOD), fact_inv[a-1], MOD)\n ans = (ans + modmul(before_checkpoint, from_checkpoint, MOD)) % MOD\n\n return ans\n\nif __name__ == \"__main__\":\n h,w,a,b = map(int, input().split())\n print(solve(h,w,a,b))", "MOD = 10**9+7", "MOD", "10**9+7", "10**9", "10", "9", "7", "def modpow(base, pow, mod):\n res = 1\n while pow > 0:\n if pow & 1:\n res = res * base % mod\n base = base**2 % mod\n pow >>= 1\n return res", "modpow", "res = 1", "res", "1", "while pow > 0:\n if pow & 1:\n res = res * base % mod\n base = base**2 % mod\n pow >>= 1\n ", "pow > 0", "pow", "0", "if pow & 1:\n res = res * base % mod\n ", "pow & 1", "pow", "1", "res = res * base % mod", "res", "res * base % mod", "res * base", "res", "base", "mod", "base = base**2 % mod", "base", "base**2 % mod", "base**2", "base", "2", "mod", "pow >>= 1", "pow", "1", "return res", "res", "base", "base", "pow", "pow", "mod", "mod", "def modmul(a, b, mod):\n return a*b % mod", "modmul", "return a*b % mod", "a*b % mod", "a*b", "a", "b", "mod", "a", "a", "b", "b", "mod", "mod", "def solve(h,w,a,b):\n fact = [0]*(h+w+1)\n fact[0] = 1\n fact_inv = [0]*(h+w+1)\n fact_inv[0] = 1\n for i in range(1, h+w):\n fact[i] = fact[i-1]*i % MOD\n fact_inv[i] = modpow(fact[i], MOD-2, MOD)\n\n ans = 0\n for col_idx in range(b, w):\n before_checkpoint = modmul(modmul(fact[h-a-1+col_idx], fact_inv[h-a-1], MOD), fact_inv[col_idx], MOD)\n from_checkpoint = modmul(modmul(fact[(a-1) + (w-col_idx-1)], fact_inv[w-col_idx-1], MOD), fact_inv[a-1], MOD)\n ans = (ans + modmul(before_checkpoint, from_checkpoint, MOD)) % MOD\n\n return ans", "solve", "fact = [0]*(h+w+1)", "fact", "[0]*(h+w+1)", "[0]", "0", "h+w+1", "h+w", "h", "w", "1", "fact[0] = 1", "fact[0]", "fact", "0", "1", "fact_inv = [0]*(h+w+1)", "fact_inv", "[0]*(h+w+1)", "[0]", "0", "h+w+1", "h+w", "h", "w", "1", "fact_inv[0] = 1", "fact_inv[0]", "fact_inv", "0", "1", "for i in range(1, h+w):\n fact[i] = fact[i-1]*i % MOD\n fact_inv[i] = modpow(fact[i], MOD-2, MOD)\n\n ", "i", "range(1, h+w)", "range", "1", "h+w", "h", "w", "fact[i] = fact[i-1]*i % MOD", "fact[i]", "fact", "i", "fact[i-1]*i % MOD", "fact[i-1]*i", "fact[i-1]", "fact", "i-1", "i", "1", "i", "MOD", "fact_inv[i] = modpow(fact[i], MOD-2, MOD)", "fact_inv[i]", "fact_inv", "i", "modpow(fact[i], MOD-2, MOD)", "modpow", "fact[i]", "fact", "i", "MOD-2", "MOD", "2", "MOD", "ans = 0", "ans", "0", "for col_idx in range(b, w):\n before_checkpoint = modmul(modmul(fact[h-a-1+col_idx], fact_inv[h-a-1], MOD), fact_inv[col_idx], MOD)\n from_checkpoint = modmul(modmul(fact[(a-1) + (w-col_idx-1)], fact_inv[w-col_idx-1], MOD), fact_inv[a-1], MOD)\n ans = (ans + modmul(before_checkpoint, from_checkpoint, MOD)) % MOD\n\n ", "col_idx", "range(b, w)", "range", "b", "w", "before_checkpoint = modmul(modmul(fact[h-a-1+col_idx], fact_inv[h-a-1], MOD), fact_inv[col_idx], MOD)", "before_checkpoint", "modmul(modmul(fact[h-a-1+col_idx], fact_inv[h-a-1], MOD), fact_inv[col_idx], MOD)", "modmul", "modmul(fact[h-a-1+col_idx], fact_inv[h-a-1], MOD)", "modmul", "fact[h-a-1+col_idx]", "fact", "h-a-1+col_idx", "h-a-1", "h-a", "h", "a", "1", "col_idx", "fact_inv[h-a-1]", "fact_inv", "h-a-1", "h-a", "h", "a", "1", "MOD", "fact_inv[col_idx]", "fact_inv", "col_idx", "MOD", "from_checkpoint = modmul(modmul(fact[(a-1) + (w-col_idx-1)], fact_inv[w-col_idx-1], MOD), fact_inv[a-1], MOD)", "from_checkpoint", "modmul(modmul(fact[(a-1) + (w-col_idx-1)], fact_inv[w-col_idx-1], MOD), fact_inv[a-1], MOD)", "modmul", "modmul(fact[(a-1) + (w-col_idx-1)], fact_inv[w-col_idx-1], MOD)", "modmul", "fact[(a-1) + (w-col_idx-1)]", "fact", "(a-1) + (w-col_idx-1)", "a-1", "a", "1", "w-col_idx-1", "w-col_idx", "w", "col_idx", "1", "fact_inv[w-col_idx-1]", "fact_inv", "w-col_idx-1", "w-col_idx", "w", "col_idx", "1", "MOD", "fact_inv[a-1]", "fact_inv", "a-1", "a", "1", "MOD", "ans = (ans + modmul(before_checkpoint, from_checkpoint, MOD)) % MOD", "ans", "(ans + modmul(before_checkpoint, from_checkpoint, MOD)) % MOD", "ans + modmul(before_checkpoint, from_checkpoint, MOD)", "ans", "modmul(before_checkpoint, from_checkpoint, MOD)", "modmul", "before_checkpoint", "from_checkpoint", "MOD", "MOD", "return ans", "ans", "h", "h", "w", "w", "a", "a", "b", "b", "if __name__ == \"__main__\":\n h,w,a,b = map(int, input().split())\n print(solve(h,w,a,b))", "__name__ == \"__main__\"", "__name__", "\"__main__\"", "h,w,a,b = map(int, input().split())", "h", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "w", "a", "b", "print(solve(h,w,a,b))", "print", "solve(h,w,a,b)", "solve", "h", "w", "a", "b", "def modmul(a, b, mod):\n return a*b % mod", "def modmul(a, b, mod):\n return a*b % mod", "modmul", "a,b = map(int, input().split())", "map(int, input().split())", "a", "h,w,a,b = map(int, input().split())", "map(int, input().split())", "h", "w,a,b = map(int, input().split())", "map(int, input().split())", "w", "MOD = 10**9+7", "10**9+7", "MOD", "def modpow(base, pow, mod):\n res = 1\n while pow > 0:\n if pow & 1:\n res = res * base % mod\n base = base**2 % mod\n pow >>= 1\n return res", "def modpow(base, pow, mod):\n res = 1\n while pow > 0:\n if pow & 1:\n res = res * base % mod\n base = base**2 % mod\n pow >>= 1\n return res", "modpow", "def solve(h,w,a,b):\n fact = [0]*(h+w+1)\n fact[0] = 1\n fact_inv = [0]*(h+w+1)\n fact_inv[0] = 1\n for i in range(1, h+w):\n fact[i] = fact[i-1]*i % MOD\n fact_inv[i] = modpow(fact[i], MOD-2, MOD)\n\n ans = 0\n for col_idx in range(b, w):\n before_checkpoint = modmul(modmul(fact[h-a-1+col_idx], fact_inv[h-a-1], MOD), fact_inv[col_idx], MOD)\n from_checkpoint = modmul(modmul(fact[(a-1) + (w-col_idx-1)], fact_inv[w-col_idx-1], MOD), fact_inv[a-1], MOD)\n ans = (ans + modmul(before_checkpoint, from_checkpoint, MOD)) % MOD\n\n return ans", "def solve(h,w,a,b):\n fact = [0]*(h+w+1)\n fact[0] = 1\n fact_inv = [0]*(h+w+1)\n fact_inv[0] = 1\n for i in range(1, h+w):\n fact[i] = fact[i-1]*i % MOD\n fact_inv[i] = modpow(fact[i], MOD-2, MOD)\n\n ans = 0\n for col_idx in range(b, w):\n before_checkpoint = modmul(modmul(fact[h-a-1+col_idx], fact_inv[h-a-1], MOD), fact_inv[col_idx], MOD)\n from_checkpoint = modmul(modmul(fact[(a-1) + (w-col_idx-1)], fact_inv[w-col_idx-1], MOD), fact_inv[a-1], MOD)\n ans = (ans + modmul(before_checkpoint, from_checkpoint, MOD)) % MOD\n\n return ans", "solve", "b = map(int, input().split())", "map(int, input().split())", "b" ]

[ 7, 15, 13, 0, 13, 2, 2, 17, 17, 17, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 13, 13, 0, 13, 2, 13, 13, 0, 13, 2, 39, 17, 13, 13, 2, 39, 17, 13, 28, 13, 4, 13, 17, 13, 0, 18, 13, 13, 2, 2, 13, 18, 13, 2, 13, 17, 13, 0, 18, 13, 2, 13, 17, 4, 13, 18, 13, 2, 13, 17, 2, 13, 17, 13, 28, 13, 4, 13, 2, 13, 17, 17, 17, 0, 18, 13, 2, 13, 17, 2, 2, 18, 13, 13, 13, 13, 0, 13, 12, 2, 2, 2, 18, 13, 2, 13, 13, 18, 13, 13, 18, 13, 13, 13, 23, 23, 0, 13, 17, 28, 13, 4, 13, 13, 13, 0, 13, 2, 2, 4, 13, 13, 2, 2, 13, 13, 17, 4, 13, 2, 2, 13, 17, 13, 2, 13, 17, 13, 4, 13, 2, 13, 13, 10, 4, 13, 10, 2, 13, 10, 2, 13, 10, 17, 13, 10, 4, 13, 10, 2, 13, 10, 2, 13, 10, 4, 13, 10, 12, 13, 10, 2, 13, 10, 4, 13 ]

[ [ 170, 4 ], [ 185, 11 ], [ 185, 20 ], [ 185, 21 ], [ 185, 22 ], [ 182, 24 ], [ 177, 26 ], [ 168, 27 ], [ 173, 29 ], [ 183, 33 ], [ 161, 34 ], [ 183, 38 ], [ 41, 40 ], [ 183, 44 ], [ 49, 46 ], [ 174, 47 ], [ 40, 48 ], [ 40, 51 ], [ 174, 53 ], [ 40, 55 ], [ 171, 57 ], [ 64, 59 ], [ 162, 60 ], [ 183, 62 ], [ 174, 67 ], [ 183, 69 ], [ 171, 72 ], [ 171, 74 ], [ 77, 76 ], [ 183, 80 ], [ 90, 85 ], [ 162, 86 ], [ 76, 88 ], [ 162, 93 ], [ 76, 94 ], [ 76, 95 ], [ 171, 96 ], [ 179, 98 ], [ 174, 104 ], [ 162, 109 ], [ 162, 112 ], [ 171, 114 ], [ 164, 118 ], [ 122, 121 ], [ 186, 124 ], [ 168, 125 ], [ 158, 127 ], [ 180, 131 ], [ 121, 132 ], [ 177, 135 ], [ 156, 136 ], [ 180, 139 ], [ 168, 142 ], [ 121, 144 ], [ 156, 146 ], [ 171, 148 ], [ 159, 152 ], [ 165, 152 ], [ 171, 153 ], [ 185, 156 ], [ 158, 159 ], [ 161, 162 ], [ 164, 165 ], [ 185, 168 ], [ 170, 171 ], [ 173, 174 ], [ 185, 177 ], [ 179, 180 ], [ 182, 183 ], [ 185, 186 ] ]

[ "import math\nMOD = 10 ** 9 + 7\nH, W, A, B = map(int, input().split())\nmaxf = H + W\n\nf, invf = [1] * maxf, [1] * maxf\n\nfor i in range(1, maxf):\n f[i] = i * f[i - 1] % MOD\ninvf[maxf - 1] = pow(f[maxf - 1], MOD - 2, MOD)\nfor i in range(maxf - 1, 0, -1):\n invf[i - 1] = invf[i] * i % MOD\n\ncomb = lambda a, b: f[a + b] * invf[a] * invf[b] % MOD\n\nans = 0\nfor x in range(B, W):\n ans += comb(x, H - A - 1) * comb(W - 1 - x, A - 1) % MOD\nprint(ans % MOD)", "import math", "math", "MOD = 10 ** 9 + 7", "MOD", "10 ** 9 + 7", "10 ** 9", "10", "9", "7", "H, W, A, B = map(int, input().split())", "H", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "W", "A", "B", "maxf = H + W", "maxf", "H + W", "H", "W", "f, invf = [1] * maxf, [1] * maxf", "f", "[1] * maxf", "[1]", "1", "maxf", "invf", "[1] * maxf", "[1]", "1", "maxf", "for i in range(1, maxf):\n f[i] = i * f[i - 1] % MOD", "i", "range(1, maxf)", "range", "1", "maxf", "f[i] = i * f[i - 1] % MOD", "f[i]", "f", "i", "i * f[i - 1] % MOD", "i * f[i - 1]", "i", "f[i - 1]", "f", "i - 1", "i", "1", "MOD", "invf[maxf - 1] = pow(f[maxf - 1], MOD - 2, MOD)", "invf[maxf - 1]", "invf", "maxf - 1", "maxf", "1", "pow(f[maxf - 1], MOD - 2, MOD)", "pow", "f[maxf - 1]", "f", "maxf - 1", "maxf", "1", "MOD - 2", "MOD", "2", "MOD", "for i in range(maxf - 1, 0, -1):\n invf[i - 1] = invf[i] * i % MOD", "i", "range(maxf - 1, 0, -1)", "range", "maxf - 1", "maxf", "1", "0", "-1", "invf[i - 1] = invf[i] * i % MOD", "invf[i - 1]", "invf", "i - 1", "i", "1", "invf[i] * i % MOD", "invf[i] * i", "invf[i]", "invf", "i", "i", "MOD", "comb = lambda a, b: f[a + b] * invf[a] * invf[b] % MOD", "comb", "lambda a, b: f[a + b] * invf[a] * invf[b] % MOD", "f[a + b] * invf[a] * invf[b] % MOD", "f[a + b] * invf[a] * invf[b]", "f[a + b] * invf[a]", "f[a + b]", "f", "a + b", "a", "b", "invf[a]", "invf", "a", "invf[b]", "invf", "b", "MOD", "a", "b", "ans = 0", "ans", "0", "for x in range(B, W):\n ans += comb(x, H - A - 1) * comb(W - 1 - x, A - 1) % MOD", "x", "range(B, W)", "range", "B", "W", "ans += comb(x, H - A - 1) * comb(W - 1 - x, A - 1) % MOD", "ans", "comb(x, H - A - 1) * comb(W - 1 - x, A - 1) % MOD", "comb(x, H - A - 1) * comb(W - 1 - x, A - 1)", "comb(x, H - A - 1)", "comb", "x", "H - A - 1", "H - A", "H", "A", "1", "comb(W - 1 - x, A - 1)", "comb", "W - 1 - x", "W - 1", "W", "1", "x", "A - 1", "A", "1", "MOD", "print(ans % MOD)", "print", "ans % MOD", "ans", "MOD", "A, B = map(int, input().split())", "map(int, input().split())", "A", "ans += comb(x, H - A - 1) * comb(W - 1 - x, A - 1) % MOD", "comb(x, H - A - 1) * comb(W - 1 - x, A - 1) % MOD", "ans", "invf = [1] * maxf, [1] * maxf", "[1] * maxf", "invf", "ans = 0", "0", "ans", "W, A, B = map(int, input().split())", "map(int, input().split())", "W", "MOD = 10 ** 9 + 7", "10 ** 9 + 7", "MOD", "f, invf = [1] * maxf, [1] * maxf", "[1] * maxf", "f", "H, W, A, B = map(int, input().split())", "map(int, input().split())", "H", "comb = lambda a, b: f[a + b] * invf[a] * invf[b] % MOD", "lambda a, b: f[a + b] * invf[a] * invf[b] % MOD", "comb", "maxf = H + W", "H + W", "maxf", "B = map(int, input().split())", "map(int, input().split())", "B" ]

[ 7, 6, 13, 12, 13, 0, 18, 13, 13, 13, 0, 18, 13, 13, 39, 17, 0, 13, 17, 28, 13, 4, 13, 17, 2, 13, 17, 0, 13, 13, 0, 13, 13, 4, 18, 18, 13, 13, 13, 13, 0, 13, 4, 13, 13, 2, 13, 17, 13, 41, 28, 13, 4, 13, 2, 13, 17, 4, 17, 0, 18, 13, 13, 13, 0, 18, 18, 13, 13, 13, 13, 28, 13, 4, 13, 2, 13, 17, 17, 17, 0, 13, 2, 13, 17, 0, 13, 13, 0, 18, 18, 13, 13, 13, 13, 23, 13, 23, 13, 23, 13, 12, 13, 29, 2, 2, 2, 18, 18, 13, 13, 13, 18, 18, 13, 13, 13, 18, 18, 13, 13, 2, 13, 13, 18, 13, 13, 23, 13, 23, 13, 23, 13, 12, 13, 29, 2, 2, 18, 18, 13, 13, 13, 18, 18, 13, 13, 2, 13, 13, 18, 13, 13, 23, 13, 23, 13, 23, 13, 12, 13, 29, 18, 18, 13, 13, 13, 23, 13, 23, 13, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 13, 13, 0, 13, 2, 2, 17, 17, 17, 0, 13, 4, 13, 2, 17, 2, 17, 17, 13, 14, 2, 2, 13, 13, 2, 13, 13, 0, 13, 2, 13, 13, 0, 13, 2, 13, 13, 0, 13, 17, 28, 13, 4, 13, 13, 0, 13, 2, 2, 13, 13, 13, 0, 13, 2, 2, 13, 13, 17, 0, 13, 2, 4, 18, 13, 13, 2, 2, 13, 13, 17, 2, 13, 17, 4, 18, 13, 13, 2, 2, 2, 13, 13, 13, 13, 2, 13, 13, 0, 13, 13, 4, 13, 13, 10, 17, 13, 10, 13, 13, 10, 4, 13, 10, 2, 13, 10, 2, 13, 10, 2, 13, 10, 2, 13, 10, 4, 13, 10, 4, 13, 10, 6, 13, 10, 2, 13, 10, 4, 13, 10, 4, 13, 10, 2, 13 ]

[ [ 9, 6 ], [ 96, 7 ], [ 100, 8 ], [ 100, 9 ], [ 14, 11 ], [ 96, 12 ], [ 18, 17 ], [ 21, 20 ], [ 98, 25 ], [ 29, 28 ], [ 20, 29 ], [ 32, 31 ], [ 100, 32 ], [ 11, 35 ], [ 96, 36 ], [ 31, 39 ], [ 28, 39 ], [ 17, 39 ], [ 42, 41 ], [ 31, 44 ], [ 28, 44 ], [ 17, 44 ], [ 100, 46 ], [ 100, 48 ], [ 52, 51 ], [ 98, 55 ], [ 63, 60 ], [ 96, 61 ], [ 70, 65 ], [ 60, 66 ], [ 96, 67 ], [ 98, 69 ], [ 41, 70 ], [ 31, 70 ], [ 28, 70 ], [ 17, 70 ], [ 73, 72 ], [ 98, 76 ], [ 82, 81 ], [ 72, 83 ], [ 87, 86 ], [ 100, 87 ], [ 94, 89 ], [ 60, 90 ], [ 96, 91 ], [ 72, 93 ], [ 86, 94 ], [ 81, 94 ], [ 41, 94 ], [ 31, 94 ], [ 28, 94 ], [ 17, 94 ], [ 96, 96 ], [ 98, 98 ], [ 100, 100 ], [ 128, 109 ], [ 130, 111 ], [ 128, 114 ], [ 132, 116 ], [ 128, 119 ], [ 130, 122 ], [ 132, 123 ], [ 128, 125 ], [ 128, 128 ], [ 130, 130 ], [ 132, 132 ], [ 154, 140 ], [ 156, 142 ], [ 154, 145 ], [ 156, 148 ], [ 158, 149 ], [ 154, 151 ], [ 154, 154 ], [ 156, 156 ], [ 158, 158 ], [ 168, 164 ], [ 170, 166 ], [ 168, 168 ], [ 170, 170 ], [ 313, 172 ], [ 313, 181 ], [ 313, 182 ], [ 313, 183 ], [ 292, 185 ], [ 301, 192 ], [ 293, 200 ], [ 314, 204 ], [ 311, 205 ], [ 299, 207 ], [ 284, 208 ], [ 307, 210 ], [ 314, 212 ], [ 311, 213 ], [ 316, 215 ], [ 299, 217 ], [ 284, 218 ], [ 277, 220 ], [ 224, 223 ], [ 317, 226 ], [ 308, 226 ], [ 286, 228 ], [ 314, 231 ], [ 311, 232 ], [ 223, 233 ], [ 295, 235 ], [ 284, 238 ], [ 223, 239 ], [ 289, 242 ], [ 302, 246 ], [ 102, 247 ], [ 287, 250 ], [ 296, 251 ], [ 287, 254 ], [ 302, 258 ], [ 102, 259 ], [ 314, 263 ], [ 299, 264 ], [ 287, 265 ], [ 296, 266 ], [ 314, 268 ], [ 287, 269 ], [ 280, 271 ], [ 293, 272 ], [ 281, 275 ], [ 290, 275 ], [ 278, 275 ], [ 277, 278 ], [ 293, 280 ], [ 280, 281 ], [ 313, 284 ], [ 286, 287 ], [ 289, 290 ], [ 292, 293 ], [ 295, 296 ], [ 313, 299 ], [ 301, 302 ], [ 307, 308 ], [ 313, 311 ], [ 313, 314 ], [ 316, 317 ] ]

[ "class Factorials:\n # nに十分大きい数を入力\n def __init__(self, n, mod):\n self.mod = mod\n\n # self.fac[i] ≡ i! (factorial:階乗)\n self.fac = [1]\n num = 1\n for i in range(1, n+1):\n num *= i\n num %= mod\n self.fac.append(num)\n\n # self.rec[i] ≡ 1 / i! (reciprocal:逆数)\n num = pow(num, mod-2, mod)\n self.rec = [1 for i in range(n+1)]\n self.rec[n] = num\n for i in range(n-1, 0, -1):\n num *= i + 1\n num %= mod\n self.rec[i] = num\n\n # comb(n, r) ≡ nCr\n def comb(self, n, r):\n return self.fac[n] * self.rec[r] * self.rec[n - r] % self.mod\n \n # perm(n, r) ≡ nPr\n def perm(self, n, r):\n return self.fac[n] * self.rec[n-r] % self.mod\n\n # fact(n) ≡ n!\n def fact(self, n):\n return self.fac[n]\n\nh, w, a, b = map(int, input().split())\nmod = 10**9 + 7\n\nf = Factorials(2 * (10 ** 5), mod)\nif h - a < w - b:\n num = h - a\nelse:\n num = w - b\n\nans = 0\nfor i in range(num):\n x = h - a - i\n y = b + i + 1\n\n ans += f.comb(x + y - 2, x - 1) * f.comb(h + w - x - y, h - x)\n ans %= mod\n\nprint(ans)", "class Factorials:\n # nに十分大きい数を入力\n def __init__(self, n, mod):\n self.mod = mod\n\n # self.fac[i] ≡ i! (factorial:階乗)\n self.fac = [1]\n num = 1\n for i in range(1, n+1):\n num *= i\n num %= mod\n self.fac.append(num)\n\n # self.rec[i] ≡ 1 / i! (reciprocal:逆数)\n num = pow(num, mod-2, mod)\n self.rec = [1 for i in range(n+1)]\n self.rec[n] = num\n for i in range(n-1, 0, -1):\n num *= i + 1\n num %= mod\n self.rec[i] = num\n\n # comb(n, r) ≡ nCr\n def comb(self, n, r):\n return self.fac[n] * self.rec[r] * self.rec[n - r] % self.mod\n \n # perm(n, r) ≡ nPr\n def perm(self, n, r):\n return self.fac[n] * self.rec[n-r] % self.mod\n\n # fact(n) ≡ n!\n def fact(self, n):\n return self.fac[n]", "Factorials", "def __init__(self, n, mod):\n self.mod = mod\n\n # self.fac[i] ≡ i! (factorial:階乗)\n self.fac = [1]\n num = 1\n for i in range(1, n+1):\n num *= i\n num %= mod\n self.fac.append(num)\n\n # self.rec[i] ≡ 1 / i! (reciprocal:逆数)\n num = pow(num, mod-2, mod)\n self.rec = [1 for i in range(n+1)]\n self.rec[n] = num\n for i in range(n-1, 0, -1):\n num *= i + 1\n num %= mod\n self.rec[i] = num\n\n # comb(n, r) ≡ nCr\n ", "__init__", "self.mod = mod", "self.mod", "self", "mod", "mod", "self.fac = [1]", "self.fac", "self", "fac", "[1]", "1", "num = 1", "num", "1", "for i in range(1, n+1):\n num *= i\n num %= mod\n self.fac.append(num)\n\n # self.rec[i] ≡ 1 / i! (reciprocal:逆数)\n ", "i", "range(1, n+1)", "range", "1", "n+1", "n", "1", "num *= i", "num", "i", "num %= mod", "num", "mod", "self.fac.append(num)", "self.fac.append", "self.fac", "self", "fac", "append", "num", "num = pow(num, mod-2, mod)", "num", "pow(num, mod-2, mod)", "pow", "num", "mod-2", "mod", "2", "mod", "1 for i in range(n+1)", "for i in range(n+1)", "i", "range(n+1)", "range", "n+1", "n", "1", "for i in range(n+1)", "1", "self.rec = [1 for i in range(n+1)]", "self.rec", "self", "rec", "[1 for i in range(n+1)]", "self.rec[n] = num", "self.rec[n]", "self.rec", "self", "rec", "n", "num", "for i in range(n-1, 0, -1):\n num *= i + 1\n num %= mod\n self.rec[i] = num\n\n # comb(n, r) ≡ nCr\n ", "i", "range(n-1, 0, -1)", "range", "n-1", "n", "1", "0", "-1", "num *= i + 1", "num", "i + 1", "i", "1", "num %= mod", "num", "mod", "self.rec[i] = num", "self.rec[i]", "self.rec", "self", "rec", "i", "num", "self", "self", "n", "n", "mod", "mod", "def comb(self, n, r):\n return self.fac[n] * self.rec[r] * self.rec[n - r] % self.mod\n \n # perm(n, r) ≡ nPr\n ", "comb", "return self.fac[n] * self.rec[r] * self.rec[n - r] % self.mod", "self.fac[n] * self.rec[r] * self.rec[n - r] % self.mod", "self.fac[n] * self.rec[r] * self.rec[n - r]", "self.fac[n] * self.rec[r]", "self.fac[n]", "self.fac", "self", "fac", "n", "self.rec[r]", "self.rec", "self", "rec", "r", "self.rec[n - r]", "self.rec", "self", "rec", "n - r", "n", "r", "self.mod", "self", "mod", "self", "self", "n", "n", "r", "r", "def perm(self, n, r):\n return self.fac[n] * self.rec[n-r] % self.mod\n\n # fact(n) ≡ n!\n ", "perm", "return self.fac[n] * self.rec[n-r] % self.mod", "self.fac[n] * self.rec[n-r] % self.mod", "self.fac[n] * self.rec[n-r]", "self.fac[n]", "self.fac", "self", "fac", "n", "self.rec[n-r]", "self.rec", "self", "rec", "n-r", "n", "r", "self.mod", "self", "mod", "self", "self", "n", "n", "r", "r", "def fact(self, n):\n return self.fac[n]", "fact", "return self.fac[n]", "self.fac[n]", "self.fac", "self", "fac", "n", "self", "self", "n", "n", "h, w, a, b = map(int, input().split())", "h", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "w", "a", "b", "mod = 10**9 + 7", "mod", "10**9 + 7", "10**9", "10", "9", "7", "f = Factorials(2 * (10 ** 5), mod)", "f", "Factorials(2 * (10 ** 5), mod)", "Factorials", "2 * (10 ** 5)", "2", "10 ** 5", "10", "5", "mod", "if h - a < w - b:\n num = h - a\nelse:\n num = w - b", "h - a < w - b", "h - a", "h", "a", "w - b", "w", "b", "num = h - a", "num", "h - a", "h", "a", "num = w - b", "num", "w - b", "w", "b", "ans = 0", "ans", "0", "for i in range(num):\n x = h - a - i\n y = b + i + 1\n\n ans += f.comb(x + y - 2, x - 1) * f.comb(h + w - x - y, h - x)\n ans %= mod", "i", "range(num)", "range", "num", "x = h - a - i", "x", "h - a - i", "h - a", "h", "a", "i", "y = b + i + 1", "y", "b + i + 1", "b + i", "b", "i", "1", "ans += f.comb(x + y - 2, x - 1) * f.comb(h + w - x - y, h - x)", "ans", "f.comb(x + y - 2, x - 1) * f.comb(h + w - x - y, h - x)", "f.comb(x + y - 2, x - 1)", "f.comb", "f", "comb", "x + y - 2", "x + y", "x", "y", "2", "x - 1", "x", "1", "f.comb(h + w - x - y, h - x)", "f.comb", "f", "comb", "h + w - x - y", "h + w - x", "h + w", "h", "w", "x", "y", "h - x", "h", "x", "ans %= mod", "ans", "mod", "print(ans)", "print", "ans", "ans = 0", "0", "ans", "ans %= mod", "mod", "ans", "b = map(int, input().split())", "map(int, input().split())", "b", "x = h - a - i", "h - a - i", "x", "ans += f.comb(x + y - 2, x - 1) * f.comb(h + w - x - y, h - x)", "f.comb(x + y - 2, x - 1) * f.comb(h + w - x - y, h - x)", "ans", "mod = 10**9 + 7", "10**9 + 7", "mod", "y = b + i + 1", "b + i + 1", "y", "w, a, b = map(int, input().split())", "map(int, input().split())", "w", "f = Factorials(2 * (10 ** 5), mod)", "Factorials(2 * (10 ** 5), mod)", "f", "class Factorials:\n # nに十分大きい数を入力\n def __init__(self, n, mod):\n self.mod = mod\n\n # self.fac[i] ≡ i! (factorial:階乗)\n self.fac = [1]\n num = 1\n for i in range(1, n+1):\n num *= i\n num %= mod\n self.fac.append(num)\n\n # self.rec[i] ≡ 1 / i! (reciprocal:逆数)\n num = pow(num, mod-2, mod)\n self.rec = [1 for i in range(n+1)]\n self.rec[n] = num\n for i in range(n-1, 0, -1):\n num *= i + 1\n num %= mod\n self.rec[i] = num\n\n # comb(n, r) ≡ nCr\n def comb(self, n, r):\n return self.fac[n] * self.rec[r] * self.rec[n - r] % self.mod\n \n # perm(n, r) ≡ nPr\n def perm(self, n, r):\n return self.fac[n] * self.rec[n-r] % self.mod\n\n # fact(n) ≡ n!\n def fact(self, n):\n return self.fac[n]", "class Factorials:\n # nに十分大きい数を入力\n def __init__(self, n, mod):\n self.mod = mod\n\n # self.fac[i] ≡ i! (factorial:階乗)\n self.fac = [1]\n num = 1\n for i in range(1, n+1):\n num *= i\n num %= mod\n self.fac.append(num)\n\n # self.rec[i] ≡ 1 / i! (reciprocal:逆数)\n num = pow(num, mod-2, mod)\n self.rec = [1 for i in range(n+1)]\n self.rec[n] = num\n for i in range(n-1, 0, -1):\n num *= i + 1\n num %= mod\n self.rec[i] = num\n\n # comb(n, r) ≡ nCr\n def comb(self, n, r):\n return self.fac[n] * self.rec[r] * self.rec[n - r] % self.mod\n \n # perm(n, r) ≡ nPr\n def perm(self, n, r):\n return self.fac[n] * self.rec[n-r] % self.mod\n\n # fact(n) ≡ n!\n def fact(self, n):\n return self.fac[n]", "Factorials", "num = h - a", "h - a", "num", "a, b = map(int, input().split())", "map(int, input().split())", "a", "h, w, a, b = map(int, input().split())", "map(int, input().split())", "h", "num = w - b", "w - b", "num" ]

[ 7, 15, 13, 0, 13, 18, 18, 13, 13, 13, 12, 13, 12, 13, 12, 13, 12, 13, 0, 13, 2, 2, 17, 17, 17, 0, 13, 4, 13, 13, 13, 13, 0, 13, 2, 13, 13, 12, 13, 14, 2, 2, 13, 17, 2, 13, 13, 29, 17, 0, 13, 4, 13, 13, 2, 13, 13, 29, 2, 2, 2, 18, 13, 13, 18, 13, 13, 18, 13, 2, 13, 13, 13, 23, 13, 23, 13, 23, 13, 0, 13, 39, 17, 17, 0, 13, 39, 17, 17, 0, 13, 39, 17, 17, 28, 13, 4, 13, 17, 2, 13, 17, 4, 18, 13, 13, 2, 2, 18, 13, 17, 13, 13, 4, 18, 13, 13, 2, 2, 40, 18, 13, 2, 13, 13, 2, 13, 13, 13, 4, 18, 13, 13, 2, 2, 18, 13, 17, 18, 13, 17, 13, 0, 13, 4, 13, 2, 13, 17, 2, 13, 17, 13, 28, 13, 4, 13, 4, 13, 13, 13, 0, 13, 2, 2, 2, 13, 13, 13, 17, 0, 13, 2, 13, 13, 0, 13, 2, 4, 13, 2, 2, 13, 13, 17, 2, 13, 17, 13, 4, 13, 2, 2, 13, 13, 2, 13, 13, 2, 13, 13, 13, 0, 13, 13, 4, 13, 2, 13, 13, 4, 13, 10, 12, 13, 10, 12, 13, 10, 12, 13, 10, 12, 13, 10, 18, 13 ]

[ [ 225, 4 ], [ 20, 19 ], [ 27, 26 ], [ 214, 28 ], [ 27, 29 ], [ 27, 30 ], [ 27, 31 ], [ 34, 33 ], [ 26, 35 ], [ 29, 36 ], [ 76, 42 ], [ 74, 45 ], [ 76, 46 ], [ 51, 50 ], [ 76, 53 ], [ 74, 55 ], [ 76, 56 ], [ 74, 63 ], [ 50, 66 ], [ 76, 66 ], [ 74, 70 ], [ 50, 71 ], [ 76, 71 ], [ 78, 72 ], [ 74, 74 ], [ 76, 76 ], [ 78, 78 ], [ 81, 80 ], [ 86, 85 ], [ 91, 90 ], [ 96, 95 ], [ 33, 100 ], [ 80, 104 ], [ 80, 109 ], [ 95, 111 ], [ 19, 112 ], [ 90, 115 ], [ 90, 121 ], [ 19, 123 ], [ 95, 124 ], [ 19, 126 ], [ 95, 127 ], [ 19, 128 ], [ 85, 131 ], [ 85, 136 ], [ 90, 139 ], [ 19, 141 ], [ 144, 143 ], [ 38, 145 ], [ 33, 147 ], [ 26, 150 ], [ 19, 152 ], [ 155, 154 ], [ 30, 159 ], [ 31, 160 ], [ 163, 162 ], [ 26, 166 ], [ 30, 167 ], [ 154, 168 ], [ 172, 171 ], [ 31, 173 ], [ 154, 174 ], [ 177, 176 ], [ 38, 179 ], [ 162, 182 ], [ 171, 183 ], [ 162, 186 ], [ 19, 188 ], [ 38, 190 ], [ 26, 193 ], [ 29, 194 ], [ 162, 196 ], [ 171, 197 ], [ 26, 199 ], [ 162, 200 ], [ 19, 201 ], [ 204, 203 ], [ 19, 204 ], [ 203, 208 ], [ 176, 208 ], [ 143, 208 ], [ 19, 209 ], [ 223, 211 ], [ 225, 226 ] ]

[ "import sys\ninput = sys.stdin.readline\n\ndef I(): return int(input())\ndef MI(): return map(int, input().split())\ndef LI(): return list(map(int, input().split()))\n\ndef main():\n mod=10**9+7\n H,W,A,B=MI()\n\n \n N=H+W\n \n def cmb(n, r, mod):\n if (r < 0) or (n < r):\n return 0\n r = min(r, n - r)\n return (fact[n] * factinv[r] * factinv[n-r])%mod\n\n fact=[1,1]\n factinv=[1,1]\n inv=[0,1]\n \n for i in range(2, N + 1):\n fact.append((fact[-1] * i) % mod)\n inv.append((-inv[mod % i] * (mod // i)) % mod)\n factinv.append((factinv[-1] * inv[-1]) % mod)\n \n \n ans=cmb(N-2,H-1,mod)\n \n for i in range(min(A,B)):\n h=H-A+i+1\n w=B-i\n #print(h,w,cmb(h+w-2,h-1,mod),cmb(H+W-(h+w),H-h,mod))\n ans-=cmb(h+w-2,h-1,mod)*cmb(H+W-(h+w),H-h,mod)\n ans%=mod\n \n print(ans%mod)\n\nmain()", "import sys", "sys", "input = sys.stdin.readline", "input", "sys.stdin.readline", "sys.stdin", "sys", "stdin", "readline", "def I(): return int(input())", "I", "def MI(): return map(int, input().split())", "MI", "def LI(): return list(map(int, input().split()))", "LI", "def main():\n mod=10**9+7\n H,W,A,B=MI()\n\n \n N=H+W\n \n def cmb(n, r, mod):\n if (r < 0) or (n < r):\n return 0\n r = min(r, n - r)\n return (fact[n] * factinv[r] * factinv[n-r])%mod\n\n fact=[1,1]\n factinv=[1,1]\n inv=[0,1]\n \n for i in range(2, N + 1):\n fact.append((fact[-1] * i) % mod)\n inv.append((-inv[mod % i] * (mod // i)) % mod)\n factinv.append((factinv[-1] * inv[-1]) % mod)\n \n \n ans=cmb(N-2,H-1,mod)\n \n for i in range(min(A,B)):\n h=H-A+i+1\n w=B-i\n #print(h,w,cmb(h+w-2,h-1,mod),cmb(H+W-(h+w),H-h,mod))\n ans-=cmb(h+w-2,h-1,mod)*cmb(H+W-(h+w),H-h,mod)\n ans%=mod\n \n print(ans%mod)", "main", "mod=10**9+7", "mod", "10**9+7", "10**9", "10", "9", "7", "H,W,A,B=MI()", "H", "MI()", "MI", "W", "A", "B", "N=H+W", "N", "H+W", "H", "W", "def cmb(n, r, mod):\n if (r < 0) or (n < r):\n return 0\n r = min(r, n - r)\n return (fact[n] * factinv[r] * factinv[n-r])%mod\n\n ", "cmb", "if (r < 0) or (n < r):\n return 0\n ", "(r < 0) or (n < r)", "r < 0", "r", "0", "n < r", "n", "r", "return 0", "0", "r = min(r, n - r)", "r", "min(r, n - r)", "min", "r", "n - r", "n", "r", "return (fact[n] * factinv[r] * factinv[n-r])%mod", "(fact[n] * factinv[r] * factinv[n-r])%mod", "fact[n] * factinv[r] * factinv[n-r]", "fact[n] * factinv[r]", "fact[n]", "fact", "n", "factinv[r]", "factinv", "r", "factinv[n-r]", "factinv", "n-r", "n", "r", "mod", "n", "n", "r", "r", "mod", "mod", "fact=[1,1]", "fact", "[1,1]", "1", "1", "factinv=[1,1]", "factinv", "[1,1]", "1", "1", "inv=[0,1]", "inv", "[0,1]", "0", "1", "for i in range(2, N + 1):\n fact.append((fact[-1] * i) % mod)\n inv.append((-inv[mod % i] * (mod // i)) % mod)\n factinv.append((factinv[-1] * inv[-1]) % mod)\n \n \n ", "i", "range(2, N + 1)", "range", "2", "N + 1", "N", "1", "fact.append((fact[-1] * i) % mod)", "fact.append", "fact", "append", "(fact[-1] * i) % mod", "fact[-1] * i", "fact[-1]", "fact", "-1", "i", "mod", "inv.append((-inv[mod % i] * (mod // i)) % mod)", "inv.append", "inv", "append", "(-inv[mod % i] * (mod // i)) % mod", "-inv[mod % i] * (mod // i)", "-inv[mod % i]", "inv[mod % i]", "inv", "mod % i", "mod", "i", "mod // i", "mod", "i", "mod", "factinv.append((factinv[-1] * inv[-1]) % mod)", "factinv.append", "factinv", "append", "(factinv[-1] * inv[-1]) % mod", "factinv[-1] * inv[-1]", "factinv[-1]", "factinv", "-1", "inv[-1]", "inv", "-1", "mod", "ans=cmb(N-2,H-1,mod)", "ans", "cmb(N-2,H-1,mod)", "cmb", "N-2", "N", "2", "H-1", "H", "1", "mod", "for i in range(min(A,B)):\n h=H-A+i+1\n w=B-i\n #print(h,w,cmb(h+w-2,h-1,mod),cmb(H+W-(h+w),H-h,mod))\n ans-=cmb(h+w-2,h-1,mod)*cmb(H+W-(h+w),H-h,mod)\n ans%=mod\n \n ", "i", "range(min(A,B))", "range", "min(A,B)", "min", "A", "B", "h=H-A+i+1", "h", "H-A+i+1", "H-A+i", "H-A", "H", "A", "i", "1", "w=B-i", "w", "B-i", "B", "i", "ans-=cmb(h+w-2,h-1,mod)*cmb(H+W-(h+w),H-h,mod)", "ans", "cmb(h+w-2,h-1,mod)*cmb(H+W-(h+w),H-h,mod)", "cmb(h+w-2,h-1,mod)", "cmb", "h+w-2", "h+w", "h", "w", "2", "h-1", "h", "1", "mod", "cmb(H+W-(h+w),H-h,mod)", "cmb", "H+W-(h+w)", "H+W", "H", "W", "h+w", "h", "w", "H-h", "H", "h", "mod", "ans%=mod", "ans", "mod", "print(ans%mod)", "print", "ans%mod", "ans", "mod", "main()", "main", "def MI(): return map(int, input().split())", "def MI(): return map(int, input().split())", "MI", "def I(): return int(input())", "def I(): return int(input())", "I", "def LI(): return list(map(int, input().split()))", "def LI(): return list(map(int, input().split()))", "LI", "def main():\n mod=10**9+7\n H,W,A,B=MI()\n\n \n N=H+W\n \n def cmb(n, r, mod):\n if (r < 0) or (n < r):\n return 0\n r = min(r, n - r)\n return (fact[n] * factinv[r] * factinv[n-r])%mod\n\n fact=[1,1]\n factinv=[1,1]\n inv=[0,1]\n \n for i in range(2, N + 1):\n fact.append((fact[-1] * i) % mod)\n inv.append((-inv[mod % i] * (mod // i)) % mod)\n factinv.append((factinv[-1] * inv[-1]) % mod)\n \n \n ans=cmb(N-2,H-1,mod)\n \n for i in range(min(A,B)):\n h=H-A+i+1\n w=B-i\n #print(h,w,cmb(h+w-2,h-1,mod),cmb(H+W-(h+w),H-h,mod))\n ans-=cmb(h+w-2,h-1,mod)*cmb(H+W-(h+w),H-h,mod)\n ans%=mod\n \n print(ans%mod)", "def main():\n mod=10**9+7\n H,W,A,B=MI()\n\n \n N=H+W\n \n def cmb(n, r, mod):\n if (r < 0) or (n < r):\n return 0\n r = min(r, n - r)\n return (fact[n] * factinv[r] * factinv[n-r])%mod\n\n fact=[1,1]\n factinv=[1,1]\n inv=[0,1]\n \n for i in range(2, N + 1):\n fact.append((fact[-1] * i) % mod)\n inv.append((-inv[mod % i] * (mod // i)) % mod)\n factinv.append((factinv[-1] * inv[-1]) % mod)\n \n \n ans=cmb(N-2,H-1,mod)\n \n for i in range(min(A,B)):\n h=H-A+i+1\n w=B-i\n #print(h,w,cmb(h+w-2,h-1,mod),cmb(H+W-(h+w),H-h,mod))\n ans-=cmb(h+w-2,h-1,mod)*cmb(H+W-(h+w),H-h,mod)\n ans%=mod\n \n print(ans%mod)", "main", "input = sys.stdin.readline", "sys.stdin.readline", "input" ]

[ 7, 0, 13, 17, 0, 13, 2, 2, 17, 17, 17, 12, 13, 14, 2, 13, 17, 14, 2, 2, 13, 17, 17, 0, 13, 4, 13, 13, 2, 13, 17, 13, 29, 2, 2, 13, 13, 13, 14, 2, 2, 13, 17, 17, 29, 2, 2, 13, 4, 13, 13, 2, 13, 17, 13, 13, 23, 13, 23, 13, 23, 13, 0, 13, 39, 17, 28, 13, 4, 13, 17, 2, 13, 17, 4, 18, 13, 13, 2, 2, 18, 13, 2, 13, 17, 13, 13, 0, 13, 2, 39, 17, 2, 13, 17, 28, 13, 4, 13, 17, 2, 13, 17, 0, 18, 13, 13, 4, 13, 18, 13, 13, 2, 13, 17, 13, 12, 13, 14, 2, 2, 2, 13, 17, 2, 13, 17, 2, 13, 13, 14, 2, 2, 13, 17, 2, 13, 17, 29, 2, 2, 2, 18, 13, 13, 18, 13, 13, 18, 13, 2, 13, 13, 13, 23, 13, 23, 13, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 13, 13, 14, 2, 2, 13, 13, 2, 13, 13, 0, 13, 13, 13, 13, 0, 13, 13, 13, 13, 0, 13, 17, 28, 13, 4, 13, 2, 13, 13, 0, 13, 2, 4, 13, 2, 2, 2, 13, 13, 13, 17, 2, 13, 13, 4, 13, 2, 2, 2, 13, 13, 13, 17, 2, 13, 13, 4, 13, 2, 13, 13, 10, 13, 13, 10, 2, 13, 10, 12, 13, 10, 4, 13, 10, 4, 13, 10, 17, 13, 10, 2, 13, 10, 13, 13, 10, 12, 13, 10, 4, 13, 10, 39, 13, 10, 13, 13, 10, 2, 13, 10, 13, 13, 10, 4, 13, 10, 17, 13 ]

[ [ 277, 2 ], [ 268, 5 ], [ 59, 15 ], [ 59, 20 ], [ 25, 24 ], [ 57, 27 ], [ 59, 29 ], [ 61, 31 ], [ 24, 35 ], [ 24, 36 ], [ 61, 37 ], [ 59, 41 ], [ 57, 47 ], [ 57, 50 ], [ 59, 52 ], [ 61, 54 ], [ 61, 55 ], [ 57, 57 ], [ 59, 59 ], [ 61, 61 ], [ 262, 63 ], [ 68, 67 ], [ 278, 72 ], [ 263, 76 ], [ 263, 81 ], [ 67, 83 ], [ 67, 85 ], [ 269, 86 ], [ 235, 88 ], [ 278, 93 ], [ 97, 96 ], [ 278, 101 ], [ 107, 104 ], [ 236, 105 ], [ 96, 106 ], [ 239, 108 ], [ 263, 110 ], [ 96, 111 ], [ 269, 113 ], [ 269, 115 ], [ 155, 122 ], [ 157, 125 ], [ 155, 128 ], [ 157, 129 ], [ 155, 133 ], [ 157, 136 ], [ 263, 143 ], [ 155, 144 ], [ 236, 146 ], [ 157, 147 ], [ 236, 149 ], [ 155, 151 ], [ 157, 152 ], [ 269, 153 ], [ 155, 155 ], [ 157, 157 ], [ 274, 159 ], [ 274, 168 ], [ 274, 169 ], [ 274, 170 ], [ 242, 174 ], [ 275, 175 ], [ 260, 177 ], [ 245, 178 ], [ 271, 180 ], [ 260, 181 ], [ 253, 182 ], [ 272, 183 ], [ 242, 183 ], [ 265, 185 ], [ 245, 186 ], [ 232, 187 ], [ 266, 188 ], [ 275, 188 ], [ 247, 190 ], [ 194, 193 ], [ 254, 197 ], [ 260, 197 ], [ 233, 198 ], [ 245, 198 ], [ 250, 200 ], [ 257, 203 ], [ 272, 207 ], [ 242, 207 ], [ 266, 208 ], [ 275, 208 ], [ 233, 209 ], [ 245, 209 ], [ 233, 212 ], [ 245, 212 ], [ 193, 213 ], [ 257, 215 ], [ 254, 219 ], [ 260, 219 ], [ 233, 220 ], [ 245, 220 ], [ 266, 221 ], [ 275, 221 ], [ 266, 224 ], [ 275, 224 ], [ 193, 225 ], [ 251, 229 ], [ 248, 229 ], [ 269, 230 ], [ 266, 232 ], [ 275, 232 ], [ 232, 233 ], [ 235, 236 ], [ 274, 242 ], [ 274, 245 ], [ 247, 248 ], [ 250, 251 ], [ 272, 253 ], [ 242, 253 ], [ 253, 254 ], [ 274, 260 ], [ 262, 263 ], [ 245, 265 ], [ 265, 266 ], [ 268, 269 ], [ 260, 271 ], [ 271, 272 ], [ 274, 275 ], [ 277, 278 ] ]

[ "n=200000\nmod=10**9+7\ndef pf(x,y,p):\n if y==0: return 1\n if y%2==0:\n d=pf(x,y//2,p)\n return d*d%p\n if y%2==1:\n return (x*pf(x,y-1,p))%p\nfacl=[1]\nfor i in range(1,n+2):\n facl.append(facl[i-1]*i%mod)\ninvl=[1]*(n+2)\nfor i in range(1,n+2):\n invl[i]=pf(facl[i],mod-2,mod)\ndef comb(x,k):\n if x<0 or k<0 or x<k: return 0\n if x==0 or k==0: return 1\n return (facl[x]*invl[k]*invl[x-k])%mod\nh,w,a,b=map(int,input().split())\nif h-a<w-b:\n h,w=w,h\n a,b=b,a\nt=0\nfor i in range(w-b):\n t+=comb(h-a+b-1,b+i)*comb(w-b+a-1,a+i)\nprint(t%mod)", "n=200000", "n", "200000", "mod=10**9+7", "mod", "10**9+7", "10**9", "10", "9", "7", "def pf(x,y,p):\n if y==0: return 1\n if y%2==0:\n d=pf(x,y//2,p)\n return d*d%p\n if y%2==1:\n return (x*pf(x,y-1,p))%p", "pf", "if y==0: return 1\n ", "y==0", "y", "0", "if y%2==0:\n d=pf(x,y//2,p)\n return d*d%p\n ", "y%2==0", "y%2", "y", "2", "0", "d=pf(x,y//2,p)", "d", "pf(x,y//2,p)", "pf", "x", "y//2", "y", "2", "p", "return d*d%p", "d*d%p", "d*d", "d", "d", "p", "if y%2==1:\n return (x*pf(x,y-1,p))%p", "y%2==1", "y%2", "y", "2", "1", "return (x*pf(x,y-1,p))%p", "(x*pf(x,y-1,p))%p", "x*pf(x,y-1,p)", "x", "pf(x,y-1,p)", "pf", "x", "y-1", "y", "1", "p", "p", "x", "x", "y", "y", "p", "p", "facl=[1]", "facl", "[1]", "1", "for i in range(1,n+2):\n facl.append(facl[i-1]*i%mod)", "i", "range(1,n+2)", "range", "1", "n+2", "n", "2", "facl.append(facl[i-1]*i%mod)", "facl.append", "facl", "append", "facl[i-1]*i%mod", "facl[i-1]*i", "facl[i-1]", "facl", "i-1", "i", "1", "i", "mod", "invl=[1]*(n+2)", "invl", "[1]*(n+2)", "[1]", "1", "n+2", "n", "2", "for i in range(1,n+2):\n invl[i]=pf(facl[i],mod-2,mod)", "i", "range(1,n+2)", "range", "1", "n+2", "n", "2", "invl[i]=pf(facl[i],mod-2,mod)", "invl[i]", "invl", "i", "pf(facl[i],mod-2,mod)", "pf", "facl[i]", "facl", "i", "mod-2", "mod", "2", "mod", "def comb(x,k):\n if x<0 or k<0 or x<k: return 0\n if x==0 or k==0: return 1\n return (facl[x]*invl[k]*invl[x-k])%mod", "comb", "if x<0 or k<0 or x<k: return 0\n ", "x<0 or k<0 or x<k", "x<0 or k<0", "x<0", "x", "0", "k<0", "k", "0", "x<k", "x", "k", "if x==0 or k==0: return 1\n ", "x==0 or k==0", "x==0", "x", "0", "k==0", "k", "0", "return (facl[x]*invl[k]*invl[x-k])%mod", "(facl[x]*invl[k]*invl[x-k])%mod", "facl[x]*invl[k]*invl[x-k]", "facl[x]*invl[k]", "facl[x]", "facl", "x", "invl[k]", "invl", "k", "invl[x-k]", "invl", "x-k", "x", "k", "mod", "x", "x", "k", "k", "h,w,a,b=map(int,input().split())", "h", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "w", "a", "b", "if h-a<w-b:\n h,w=w,h\n a,b=b,a", "h-a<w-b", "h-a", "h", "a", "w-b", "w", "b", "h,w=w,h", "h", "w", "w", "h", "a,b=b,a", "a", "b", "b", "a", "t=0", "t", "0", "for i in range(w-b):\n t+=comb(h-a+b-1,b+i)*comb(w-b+a-1,a+i)", "i", "range(w-b)", "range", "w-b", "w", "b", "t+=comb(h-a+b-1,b+i)*comb(w-b+a-1,a+i)", "t", "comb(h-a+b-1,b+i)*comb(w-b+a-1,a+i)", "comb(h-a+b-1,b+i)", "comb", "h-a+b-1", "h-a+b", "h-a", "h", "a", "b", "1", "b+i", "b", "i", "comb(w-b+a-1,a+i)", "comb", "w-b+a-1", "w-b+a", "w-b", "w", "b", "a", "1", "a+i", "a", "i", "print(t%mod)", "print", "t%mod", "t", "mod", "b=b,a", "a", "b", "invl=[1]*(n+2)", "[1]*(n+2)", "invl", "def pf(x,y,p):\n if y==0: return 1\n if y%2==0:\n d=pf(x,y//2,p)\n return d*d%p\n if y%2==1:\n return (x*pf(x,y-1,p))%p", "def pf(x,y,p):\n if y==0: return 1\n if y%2==0:\n d=pf(x,y//2,p)\n return d*d%p\n if y%2==1:\n return (x*pf(x,y-1,p))%p", "pf", "h,w,a,b=map(int,input().split())", "map(int,input().split())", "h", "b=map(int,input().split())", "map(int,input().split())", "b", "t=0", "0", "t", "t+=comb(h-a+b-1,b+i)*comb(w-b+a-1,a+i)", "comb(h-a+b-1,b+i)*comb(w-b+a-1,a+i)", "t", "w=w,h", "h", "w", "def comb(x,k):\n if x<0 or k<0 or x<k: return 0\n if x==0 or k==0: return 1\n return (facl[x]*invl[k]*invl[x-k])%mod", "def comb(x,k):\n if x<0 or k<0 or x<k: return 0\n if x==0 or k==0: return 1\n return (facl[x]*invl[k]*invl[x-k])%mod", "comb", "w,a,b=map(int,input().split())", "map(int,input().split())", "w", "facl=[1]", "[1]", "facl", "a,b=b,a", "b", "a", "mod=10**9+7", "10**9+7", "mod", "h,w=w,h", "w", "h", "a,b=map(int,input().split())", "map(int,input().split())", "a", "n=200000", "200000", "n" ]

[ 7, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 13, 13, 0, 13, 2, 13, 13, 0, 13, 2, 2, 17, 17, 17, 0, 13, 2, 39, 17, 2, 13, 17, 28, 13, 4, 13, 17, 2, 13, 17, 0, 18, 13, 13, 2, 2, 18, 13, 2, 13, 17, 13, 13, 0, 13, 2, 39, 17, 2, 13, 17, 0, 18, 13, 13, 4, 13, 18, 13, 13, 2, 13, 17, 13, 28, 13, 4, 13, 2, 13, 17, 17, 17, 0, 18, 13, 13, 2, 2, 18, 13, 2, 13, 17, 2, 13, 17, 13, 12, 13, 14, 2, 13, 13, 29, 17, 29, 2, 2, 2, 2, 18, 13, 13, 18, 13, 13, 13, 18, 13, 2, 13, 13, 13, 23, 13, 23, 13, 0, 13, 17, 0, 13, 2, 13, 13, 0, 13, 2, 13, 17, 42, 2, 2, 13, 17, 40, 13, 13, 0, 13, 2, 2, 13, 2, 2, 4, 13, 2, 2, 13, 13, 17, 2, 13, 17, 4, 13, 2, 2, 2, 13, 13, 13, 13, 2, 13, 13, 13, 13, 0, 13, 17, 0, 13, 17, 4, 13, 13, 10, 4, 13, 10, 2, 13, 10, 2, 13, 10, 12, 13, 10, 4, 13, 10, 17, 13, 10, 17, 13, 10, 2, 13, 10, 2, 13, 10, 17, 13, 10, 4, 13, 10, 2, 13, 10, 2, 13, 10, 4, 13, 10, 2, 13 ]

[ [ 231, 2 ], [ 231, 11 ], [ 231, 12 ], [ 231, 13 ], [ 225, 15 ], [ 223, 17 ], [ 232, 18 ], [ 228, 20 ], [ 213, 27 ], [ 226, 32 ], [ 36, 35 ], [ 226, 40 ], [ 46, 43 ], [ 214, 44 ], [ 35, 45 ], [ 214, 49 ], [ 35, 51 ], [ 35, 53 ], [ 229, 54 ], [ 216, 56 ], [ 226, 61 ], [ 67, 64 ], [ 217, 65 ], [ 226, 66 ], [ 214, 70 ], [ 226, 71 ], [ 229, 73 ], [ 229, 75 ], [ 78, 77 ], [ 226, 81 ], [ 89, 86 ], [ 217, 87 ], [ 77, 88 ], [ 217, 92 ], [ 77, 94 ], [ 77, 97 ], [ 229, 99 ], [ 129, 104 ], [ 127, 105 ], [ 214, 114 ], [ 127, 115 ], [ 217, 117 ], [ 129, 118 ], [ 229, 119 ], [ 217, 121 ], [ 127, 123 ], [ 129, 124 ], [ 229, 125 ], [ 127, 127 ], [ 129, 129 ], [ 210, 131 ], [ 198, 134 ], [ 223, 136 ], [ 193, 137 ], [ 195, 139 ], [ 205, 141 ], [ 199, 146 ], [ 208, 146 ], [ 196, 149 ], [ 220, 149 ], [ 232, 150 ], [ 234, 152 ], [ 211, 155 ], [ 235, 155 ], [ 202, 159 ], [ 199, 162 ], [ 208, 162 ], [ 196, 163 ], [ 220, 163 ], [ 199, 166 ], [ 208, 166 ], [ 202, 169 ], [ 223, 173 ], [ 232, 174 ], [ 199, 175 ], [ 208, 175 ], [ 196, 176 ], [ 220, 176 ], [ 223, 178 ], [ 199, 179 ], [ 208, 179 ], [ 229, 180 ], [ 229, 181 ], [ 207, 183 ], [ 219, 186 ], [ 235, 190 ], [ 211, 190 ], [ 231, 193 ], [ 195, 196 ], [ 198, 199 ], [ 231, 205 ], [ 207, 208 ], [ 210, 211 ], [ 213, 214 ], [ 216, 217 ], [ 219, 220 ], [ 231, 223 ], [ 225, 226 ], [ 228, 229 ], [ 231, 232 ], [ 234, 235 ] ]

[ "h,w,a,b = map(int,input().split())\nn = h+w\nmod = 10**9+7\nfun = [1]*(n+1)\nfor i in range(1,n+1):\n fun[i] = fun[i-1]*i%mod\nrev = [1]*(n+1)\nrev[n] = pow(fun[n],mod-2,mod)\nfor i in range(n-1,0,-1):\n rev[i] = rev[i+1]*(i+1)%mod\ndef nCr(n,r):\n if r > n:\n return 0\n return fun[n]*rev[r]%mod*rev[n-r]%mod\nans = 0\ni = h-a\nj = b+1\nwhile i > 0 and j <= w:\n ans = (ans+nCr(i+j-2,i-1)*nCr(h+w-i-j,h-i)%mod)%mod\n i -= 1\n j += 1\nprint(ans)", "h,w,a,b = map(int,input().split())", "h", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "w", "a", "b", "n = h+w", "n", "h+w", "h", "w", "mod = 10**9+7", "mod", "10**9+7", "10**9", "10", "9", "7", "fun = [1]*(n+1)", "fun", "[1]*(n+1)", "[1]", "1", "n+1", "n", "1", "for i in range(1,n+1):\n fun[i] = fun[i-1]*i%mod", "i", "range(1,n+1)", "range", "1", "n+1", "n", "1", "fun[i] = fun[i-1]*i%mod", "fun[i]", "fun", "i", "fun[i-1]*i%mod", "fun[i-1]*i", "fun[i-1]", "fun", "i-1", "i", "1", "i", "mod", "rev = [1]*(n+1)", "rev", "[1]*(n+1)", "[1]", "1", "n+1", "n", "1", "rev[n] = pow(fun[n],mod-2,mod)", "rev[n]", "rev", "n", "pow(fun[n],mod-2,mod)", "pow", "fun[n]", "fun", "n", "mod-2", "mod", "2", "mod", "for i in range(n-1,0,-1):\n rev[i] = rev[i+1]*(i+1)%mod", "i", "range(n-1,0,-1)", "range", "n-1", "n", "1", "0", "-1", "rev[i] = rev[i+1]*(i+1)%mod", "rev[i]", "rev", "i", "rev[i+1]*(i+1)%mod", "rev[i+1]*(i+1)", "rev[i+1]", "rev", "i+1", "i", "1", "i+1", "i", "1", "mod", "def nCr(n,r):\n if r > n:\n return 0\n return fun[n]*rev[r]%mod*rev[n-r]%mod", "nCr", "if r > n:\n return 0\n ", "r > n", "r", "n", "return 0", "0", "return fun[n]*rev[r]%mod*rev[n-r]%mod", "fun[n]*rev[r]%mod*rev[n-r]%mod", "fun[n]*rev[r]%mod*rev[n-r]", "fun[n]*rev[r]%mod", "fun[n]*rev[r]", "fun[n]", "fun", "n", "rev[r]", "rev", "r", "mod", "rev[n-r]", "rev", "n-r", "n", "r", "mod", "n", "n", "r", "r", "ans = 0", "ans", "0", "i = h-a", "i", "h-a", "h", "a", "j = b+1", "j", "b+1", "b", "1", "while i > 0 and j <= w:\n ans = (ans+nCr(i+j-2,i-1)*nCr(h+w-i-j,h-i)%mod)%mod\n i -= 1\n j += 1", "i > 0 and j <= w", "i > 0", "i", "0", "j <= w", "j", "w", "ans = (ans+nCr(i+j-2,i-1)*nCr(h+w-i-j,h-i)%mod)%mod", "ans", "(ans+nCr(i+j-2,i-1)*nCr(h+w-i-j,h-i)%mod)%mod", "ans+nCr(i+j-2,i-1)*nCr(h+w-i-j,h-i)%mod", "ans", "nCr(i+j-2,i-1)*nCr(h+w-i-j,h-i)%mod", "nCr(i+j-2,i-1)*nCr(h+w-i-j,h-i)", "nCr(i+j-2,i-1)", "nCr", "i+j-2", "i+j", "i", "j", "2", "i-1", "i", "1", "nCr(h+w-i-j,h-i)", "nCr", "h+w-i-j", "h+w-i", "h+w", "h", "w", "i", "j", "h-i", "h", "i", "mod", "mod", "i -= 1", "i", "1", "j += 1", "j", "1", "print(ans)", "print", "ans", "a,b = map(int,input().split())", "map(int,input().split())", "a", "j = b+1", "b+1", "j", "i = h-a", "h-a", "i", "def nCr(n,r):\n if r > n:\n return 0\n return fun[n]*rev[r]%mod*rev[n-r]%mod", "def nCr(n,r):\n if r > n:\n return 0\n return fun[n]*rev[r]%mod*rev[n-r]%mod", "nCr", "b = map(int,input().split())", "map(int,input().split())", "b", "i -= 1", "1", "i", "ans = 0", "0", "ans", "fun = [1]*(n+1)", "[1]*(n+1)", "fun", "rev = [1]*(n+1)", "[1]*(n+1)", "rev", "j += 1", "1", "j", "h,w,a,b = map(int,input().split())", "map(int,input().split())", "h", "n = h+w", "h+w", "n", "mod = 10**9+7", "10**9+7", "mod", "w,a,b = map(int,input().split())", "map(int,input().split())", "w", "ans = (ans+nCr(i+j-2,i-1)*nCr(h+w-i-j,h-i)%mod)%mod", "(ans+nCr(i+j-2,i-1)*nCr(h+w-i-j,h-i)%mod)%mod", "ans" ]

[ 7, 0, 13, 4, 18, 4, 13, 13, 17, 0, 13, 4, 13, 18, 13, 17, 0, 13, 4, 13, 18, 13, 17, 0, 13, 4, 13, 18, 13, 17, 0, 13, 4, 13, 18, 13, 17, 0, 13, 2, 2, 17, 17, 17, 0, 13, 39, 17, 0, 13, 39, 17, 28, 13, 4, 13, 17, 2, 2, 13, 13, 17, 4, 18, 13, 13, 2, 2, 13, 18, 13, 2, 13, 17, 13, 4, 18, 13, 13, 4, 13, 18, 13, 13, 2, 2, 17, 17, 17, 13, 0, 13, 2, 2, 18, 13, 2, 2, 13, 13, 17, 18, 13, 2, 13, 17, 13, 0, 13, 4, 13, 2, 2, 2, 2, 18, 13, 2, 2, 2, 13, 13, 13, 17, 18, 13, 13, 18, 13, 2, 2, 13, 13, 17, 18, 13, 2, 2, 2, 13, 13, 17, 13, 13, 4, 13, 2, 2, 13, 13, 13, 10, 39, 13, 10, 4, 13, 10, 4, 13, 10, 39, 13, 10, 4, 13, 10, 4, 13, 10, 2, 13, 10, 4, 13, 10, 2, 13, 10, 4, 13 ]

[ [ 164, 2 ], [ 167, 10 ], [ 165, 14 ], [ 158, 17 ], [ 165, 21 ], [ 173, 24 ], [ 165, 28 ], [ 179, 31 ], [ 165, 35 ], [ 170, 38 ], [ 152, 45 ], [ 161, 49 ], [ 54, 53 ], [ 168, 59 ], [ 159, 60 ], [ 153, 64 ], [ 53, 68 ], [ 153, 70 ], [ 53, 72 ], [ 171, 74 ], [ 162, 77 ], [ 153, 82 ], [ 53, 83 ], [ 171, 89 ], [ 176, 91 ], [ 162, 95 ], [ 168, 98 ], [ 174, 99 ], [ 162, 102 ], [ 174, 104 ], [ 171, 106 ], [ 155, 108 ], [ 153, 116 ], [ 168, 120 ], [ 174, 122 ], [ 162, 125 ], [ 162, 128 ], [ 159, 131 ], [ 153, 135 ], [ 159, 139 ], [ 174, 142 ], [ 171, 143 ], [ 156, 148 ], [ 177, 149 ], [ 171, 150 ], [ 152, 153 ], [ 155, 156 ], [ 158, 159 ], [ 161, 162 ], [ 164, 165 ], [ 167, 168 ], [ 170, 171 ], [ 173, 174 ], [ 176, 177 ], [ 179, 180 ] ]

[ "inp=input().split(\" \")\nH=int(inp[0])\nW=int(inp[1])\nA=int(inp[2])\nB=int(inp[3])\nmod=10**9+7\nfact=[1]\nfact_r=[1]\nfor i in range(1,H+W-1):\n fact.append(i*fact[i-1]%mod)\n fact_r.append(pow(fact[i],10**9+5,mod))\nconst=fact_r[H-A-1]*fact_r[A-1]%mod\nans=sum(fact[H+i-A-1]*fact_r[i]*fact_r[W-i-1]*fact[W-i-2+A]%mod for i in range(B,W))\nprint(ans*const%mod)", "inp=input().split(\" \")", "inp", "input().split(\" \")", "().split", "()", "input", "split", "\" \"", "H=int(inp[0])", "H", "int(inp[0])", "int", "inp[0]", "inp", "0", "W=int(inp[1])", "W", "int(inp[1])", "int", "inp[1]", "inp", "1", "A=int(inp[2])", "A", "int(inp[2])", "int", "inp[2]", "inp", "2", "B=int(inp[3])", "B", "int(inp[3])", "int", "inp[3]", "inp", "3", "mod=10**9+7", "mod", "10**9+7", "10**9", "10", "9", "7", "fact=[1]", "fact", "[1]", "1", "fact_r=[1]", "fact_r", "[1]", "1", "for i in range(1,H+W-1):\n fact.append(i*fact[i-1]%mod)\n fact_r.append(pow(fact[i],10**9+5,mod))", "i", "range(1,H+W-1)", "range", "1", "H+W-1", "H+W", "H", "W", "1", "fact.append(i*fact[i-1]%mod)", "fact.append", "fact", "append", "i*fact[i-1]%mod", "i*fact[i-1]", "i", "fact[i-1]", "fact", "i-1", "i", "1", "mod", "fact_r.append(pow(fact[i],10**9+5,mod))", "fact_r.append", "fact_r", "append", "pow(fact[i],10**9+5,mod)", "pow", "fact[i]", "fact", "i", "10**9+5", "10**9", "10", "9", "5", "mod", "const=fact_r[H-A-1]*fact_r[A-1]%mod", "const", "fact_r[H-A-1]*fact_r[A-1]%mod", "fact_r[H-A-1]*fact_r[A-1]", "fact_r[H-A-1]", "fact_r", "H-A-1", "H-A", "H", "A", "1", "fact_r[A-1]", "fact_r", "A-1", "A", "1", "mod", "ans=sum(fact[H+i-A-1]*fact_r[i]*fact_r[W-i-1]*fact[W-i-2+A]%mod for i in range(B,W))", "ans", "sum(fact[H+i-A-1]*fact_r[i]*fact_r[W-i-1]*fact[W-i-2+A]%mod for i in range(B,W))", "sum", "fact[H+i-A-1]*fact_r[i]*fact_r[W-i-1]*fact[W-i-2+A]%mod", "fact[H+i-A-1]*fact_r[i]*fact_r[W-i-1]*fact[W-i-2+A]", "fact[H+i-A-1]*fact_r[i]*fact_r[W-i-1]", "fact[H+i-A-1]*fact_r[i]", "fact[H+i-A-1]", "fact", "H+i-A-1", "H+i-A", "H+i", "H", "i", "A", "1", "fact_r[i]", "fact_r", "i", "fact_r[W-i-1]", "fact_r", "W-i-1", "W-i", "W", "i", "1", "fact[W-i-2+A]", "fact", "W-i-2+A", "W-i-2", "W-i", "W", "i", "2", "A", "mod", "print(ans*const%mod)", "print", "ans*const%mod", "ans*const", "ans", "const", "mod", "fact=[1]", "[1]", "fact", "ans=sum(fact[H+i-A-1]*fact_r[i]*fact_r[W-i-1]*fact[W-i-2+A]%mod for i in range(B,W))", "sum(fact[H+i-A-1]*fact_r[i]*fact_r[W-i-1]*fact[W-i-2+A]%mod for i in range(B,W))", "ans", "W=int(inp[1])", "int(inp[1])", "W", "fact_r=[1]", "[1]", "fact_r", "inp=input().split(\" \")", "input().split(\" \")", "inp", "H=int(inp[0])", "int(inp[0])", "H", "mod=10**9+7", "10**9+7", "mod", "A=int(inp[2])", "int(inp[2])", "A", "const=fact_r[H-A-1]*fact_r[A-1]%mod", "fact_r[H-A-1]*fact_r[A-1]%mod", "const", "B=int(inp[3])", "int(inp[3])", "B" ]

[ 7, 15, 13, 15, 0, 13, 2, 2, 17, 17, 17, 0, 13, 39, 17, 17, 0, 13, 39, 17, 17, 0, 13, 39, 17, 17, 28, 13, 4, 13, 17, 17, 4, 18, 13, 13, 2, 2, 18, 13, 2, 13, 17, 13, 13, 4, 18, 13, 13, 2, 13, 2, 2, 18, 13, 2, 13, 13, 2, 13, 13, 13, 4, 18, 13, 13, 2, 2, 18, 13, 2, 13, 17, 18, 13, 13, 13, 12, 13, 14, 2, 2, 2, 13, 13, 2, 13, 17, 2, 13, 17, 29, 17, 29, 2, 2, 18, 13, 13, 2, 2, 18, 13, 13, 18, 13, 2, 13, 13, 13, 13, 23, 13, 23, 13, 12, 13, 14, 2, 2, 2, 13, 13, 2, 13, 17, 2, 13, 17, 29, 17, 0, 13, 4, 13, 13, 2, 13, 13, 0, 13, 4, 13, 18, 13, 13, 4, 13, 13, 2, 13, 13, 17, 17, 0, 13, 4, 13, 18, 13, 13, 4, 13, 17, 2, 13, 17, 17, 29, 2, 13, 13, 23, 13, 23, 13, 4, 2, 4, 13, 17, 17, 17, 12, 13, 0, 13, 2, 39, 17, 13, 0, 13, 2, 39, 17, 13, 28, 13, 4, 13, 2, 13, 17, 0, 18, 13, 17, 17, 0, 13, 17, 14, 40, 13, 2, 2, 13, 17, 13, 0, 18, 13, 13, 18, 13, 13, 0, 13, 13, 28, 13, 4, 13, 2, 13, 17, 13, 0, 18, 13, 13, 2, 18, 13, 2, 13, 17, 18, 13, 13, 0, 18, 13, 13, 2, 18, 13, 13, 2, 17, 17, 0, 13, 13, 13, 13, 29, 18, 13, 17, 23, 13, 23, 13, 23, 13, 23, 13, 12, 13, 0, 13, 17, 0, 13, 2, 2, 13, 13, 17, 13, 2, 2, 13, 13, 17, 13, 2, 13, 17, 28, 13, 4, 13, 13, 13, 0, 13, 4, 13, 2, 13, 13, 13, 0, 13, 4, 13, 2, 13, 13, 13, 0, 13, 2, 13, 13, 0, 13, 13, 0, 13, 2, 13, 13, 29, 4, 13, 13, 23, 13, 23, 13, 23, 13, 23, 13, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 13, 13, 0, 13, 4, 13, 13, 13, 13, 13, 4, 13, 13, 10, 12, 13, 10, 4, 13, 10, 2, 13, 10, 12, 13, 10, 39, 13, 10, 39, 13, 10, 12, 13, 10, 4, 13, 10, 39, 13, 10, 4, 13, 10, 12, 13, 10, 4, 13, 10, 4, 13 ]

[ [ 379, 5 ], [ 388, 12 ], [ 385, 17 ], [ 397, 22 ], [ 28, 27 ], [ 389, 34 ], [ 389, 39 ], [ 27, 41 ], [ 27, 43 ], [ 380, 44 ], [ 398, 47 ], [ 380, 50 ], [ 398, 54 ], [ 380, 56 ], [ 27, 57 ], [ 380, 59 ], [ 27, 60 ], [ 380, 61 ], [ 386, 64 ], [ 386, 69 ], [ 27, 71 ], [ 398, 74 ], [ 27, 75 ], [ 380, 76 ], [ 112, 83 ], [ 114, 84 ], [ 112, 86 ], [ 114, 89 ], [ 389, 97 ], [ 112, 98 ], [ 386, 102 ], [ 114, 103 ], [ 386, 105 ], [ 112, 107 ], [ 114, 108 ], [ 380, 109 ], [ 380, 110 ], [ 112, 112 ], [ 114, 114 ], [ 173, 121 ], [ 175, 122 ], [ 173, 124 ], [ 175, 127 ], [ 133, 132 ], [ 175, 135 ], [ 173, 137 ], [ 175, 138 ], [ 141, 140 ], [ 173, 148 ], [ 173, 150 ], [ 132, 151 ], [ 175, 151 ], [ 156, 155 ], [ 132, 165 ], [ 175, 165 ], [ 140, 170 ], [ 155, 171 ], [ 173, 173 ], [ 175, 175 ], [ 374, 179 ], [ 187, 186 ], [ 274, 190 ], [ 193, 192 ], [ 274, 196 ], [ 199, 198 ], [ 272, 202 ], [ 208, 205 ], [ 192, 206 ], [ 265, 206 ], [ 211, 210 ], [ 198, 214 ], [ 272, 217 ], [ 276, 219 ], [ 224, 221 ], [ 192, 222 ], [ 265, 222 ], [ 278, 223 ], [ 186, 225 ], [ 263, 225 ], [ 278, 226 ], [ 229, 228 ], [ 278, 229 ], [ 232, 231 ], [ 228, 235 ], [ 210, 235 ], [ 274, 237 ], [ 242, 239 ], [ 192, 240 ], [ 265, 240 ], [ 231, 241 ], [ 192, 244 ], [ 265, 244 ], [ 231, 246 ], [ 186, 249 ], [ 263, 249 ], [ 231, 250 ], [ 255, 252 ], [ 192, 253 ], [ 265, 253 ], [ 231, 254 ], [ 239, 256 ], [ 252, 256 ], [ 192, 257 ], [ 265, 257 ], [ 231, 258 ], [ 264, 263 ], [ 192, 264 ], [ 265, 264 ], [ 266, 265 ], [ 263, 266 ], [ 186, 266 ], [ 263, 269 ], [ 186, 269 ], [ 272, 272 ], [ 274, 274 ], [ 276, 276 ], [ 278, 278 ], [ 283, 282 ], [ 286, 285 ], [ 341, 288 ], [ 345, 289 ], [ 292, 291 ], [ 343, 294 ], [ 345, 295 ], [ 298, 297 ], [ 345, 299 ], [ 303, 302 ], [ 347, 305 ], [ 343, 306 ], [ 309, 308 ], [ 392, 310 ], [ 285, 312 ], [ 302, 313 ], [ 302, 314 ], [ 317, 316 ], [ 392, 318 ], [ 291, 320 ], [ 302, 321 ], [ 297, 322 ], [ 325, 324 ], [ 308, 326 ], [ 316, 327 ], [ 330, 329 ], [ 324, 330 ], [ 333, 332 ], [ 329, 334 ], [ 282, 334 ], [ 332, 334 ], [ 380, 335 ], [ 332, 339 ], [ 329, 339 ], [ 282, 339 ], [ 341, 341 ], [ 343, 343 ], [ 345, 345 ], [ 347, 347 ], [ 406, 349 ], [ 406, 358 ], [ 406, 359 ], [ 406, 360 ], [ 409, 362 ], [ 383, 364 ], [ 407, 365 ], [ 377, 366 ], [ 395, 367 ], [ 401, 368 ], [ 410, 371 ], [ 406, 377 ], [ 379, 380 ], [ 385, 386 ], [ 388, 389 ], [ 406, 395 ], [ 397, 398 ], [ 406, 401 ], [ 406, 407 ], [ 409, 410 ] ]

[ "import operator as op\nfrom functools import reduce\n\nMOD = (10 ** 9) + 7\n\nfactors = [1, 1]\nfinv = [1, 1]\ninv = [0, 1]\n\nfor i in range(2, 200010):\n factors.append(factors[i - 1] * i % MOD)\n inv.append(MOD - inv[MOD % i] * (MOD // i) % MOD)\n finv.append(finv[i - 1] * inv[i] % MOD)\n\ndef nck(n, k):\n if n < k or n < 0 or k < 0:\n return 0\n return factors[n] * (finv[k] * finv[n - k] % MOD) % MOD\n\ndef ncr(n, r):\n if n < r or n < 0 or r < 0:\n return 0\n r = min(r, n-r)\n numer = reduce(op.mul, range(n, n-r, -1), 1)\n denom = reduce(op.mul, range(1, r+1), 1)\n return numer / denom\n\nassert ncr(3, 4) == 0\n\ndef g(h, w, a, b):\n prev = [1] * w\n cur = [0] * w\n\n for i in range(h - 1):\n cur[0] = 1\n start = 0\n if i >= h - 1 - a:\n cur[b] = prev[b]\n start = b\n for j in range(start + 1, w):\n cur[j] = cur[j - 1] + prev[j]\n cur[j] = cur[j] % (1e9 + 7)\n prev, cur = cur, prev\n return prev[-1]\n\ndef f(H, W, A, B):\n count = 0\n x, y, a = H - A - 1, W + A - 2, A - 1\n for i in range(B, W): # bottom-left to top-right\n c1 = nck(x + i, i)\n c2 = nck(y - i, a)\n c = c1 * c2\n count += c\n count = count % MOD\n return int(count)\n\n## assert f(4, 4, 0, 0) == 20\n# assert f(4, 4, 2, 2) == 10\n#assert f(2, 3, 1, 1) == 2\n#assert f(10, 7, 3, 4) == 3570\n#assert f(100000, 100000, 99999, 99999) == 1\n#assert f(100000, 100000, 44444, 55555) == 738162020\n\nH, W, A, B = map(int, input().split())\nans = f(H, W, A, B)\nprint(ans)", "import operator as op", "operator", "from functools import reduce", "MOD = (10 ** 9) + 7", "MOD", "(10 ** 9) + 7", "10 ** 9", "10", "9", "7", "factors = [1, 1]", "factors", "[1, 1]", "1", "1", "finv = [1, 1]", "finv", "[1, 1]", "1", "1", "inv = [0, 1]", "inv", "[0, 1]", "0", "1", "for i in range(2, 200010):\n factors.append(factors[i - 1] * i % MOD)\n inv.append(MOD - inv[MOD % i] * (MOD // i) % MOD)\n finv.append(finv[i - 1] * inv[i] % MOD)", "i", "range(2, 200010)", "range", "2", "200010", "factors.append(factors[i - 1] * i % MOD)", "factors.append", "factors", "append", "factors[i - 1] * i % MOD", "factors[i - 1] * i", "factors[i - 1]", "factors", "i - 1", "i", "1", "i", "MOD", "inv.append(MOD - inv[MOD % i] * (MOD // i) % MOD)", "inv.append", "inv", "append", "MOD - inv[MOD % i] * (MOD // i) % MOD", "MOD", "inv[MOD % i] * (MOD // i) % MOD", "inv[MOD % i] * (MOD // i)", "inv[MOD % i]", "inv", "MOD % i", "MOD", "i", "MOD // i", "MOD", "i", "MOD", "finv.append(finv[i - 1] * inv[i] % MOD)", "finv.append", "finv", "append", "finv[i - 1] * inv[i] % MOD", "finv[i - 1] * inv[i]", "finv[i - 1]", "finv", "i - 1", "i", "1", "inv[i]", "inv", "i", "MOD", "def nck(n, k):\n if n < k or n < 0 or k < 0:\n return 0\n return factors[n] * (finv[k] * finv[n - k] % MOD) % MOD", "nck", "if n < k or n < 0 or k < 0:\n return 0\n ", "n < k or n < 0 or k < 0", "n < k or n < 0", "n < k", "n", "k", "n < 0", "n", "0", "k < 0", "k", "0", "return 0", "0", "return factors[n] * (finv[k] * finv[n - k] % MOD) % MOD", "factors[n] * (finv[k] * finv[n - k] % MOD) % MOD", "factors[n] * (finv[k] * finv[n - k] % MOD)", "factors[n]", "factors", "n", "finv[k] * finv[n - k] % MOD", "finv[k] * finv[n - k]", "finv[k]", "finv", "k", "finv[n - k]", "finv", "n - k", "n", "k", "MOD", "MOD", "n", "n", "k", "k", "def ncr(n, r):\n if n < r or n < 0 or r < 0:\n return 0\n r = min(r, n-r)\n numer = reduce(op.mul, range(n, n-r, -1), 1)\n denom = reduce(op.mul, range(1, r+1), 1)\n return numer / denom", "ncr", "if n < r or n < 0 or r < 0:\n return 0\n ", "n < r or n < 0 or r < 0", "n < r or n < 0", "n < r", "n", "r", "n < 0", "n", "0", "r < 0", "r", "0", "return 0", "0", "r = min(r, n-r)", "r", "min(r, n-r)", "min", "r", "n-r", "n", "r", "numer = reduce(op.mul, range(n, n-r, -1), 1)", "numer", "reduce(op.mul, range(n, n-r, -1), 1)", "reduce", "op.mul", "op", "mul", "range(n, n-r, -1)", "range", "n", "n-r", "n", "r", "-1", "1", "denom = reduce(op.mul, range(1, r+1), 1)", "denom", "reduce(op.mul, range(1, r+1), 1)", "reduce", "op.mul", "op", "mul", "range(1, r+1)", "range", "1", "r+1", "r", "1", "1", "return numer / denom", "numer / denom", "numer", "denom", "n", "n", "r", "r", "assert ncr(3, 4) == 0", "ncr(3, 4) == 0", "ncr(3, 4)", "ncr", "3", "4", "0", "def g(h, w, a, b):\n prev = [1] * w\n cur = [0] * w\n\n for i in range(h - 1):\n cur[0] = 1\n start = 0\n if i >= h - 1 - a:\n cur[b] = prev[b]\n start = b\n for j in range(start + 1, w):\n cur[j] = cur[j - 1] + prev[j]\n cur[j] = cur[j] % (1e9 + 7)\n prev, cur = cur, prev\n return prev[-1]", "g", "prev = [1] * w", "prev", "[1] * w", "[1]", "1", "w", "cur = [0] * w", "cur", "[0] * w", "[0]", "0", "w", "for i in range(h - 1):\n cur[0] = 1\n start = 0\n if i >= h - 1 - a:\n cur[b] = prev[b]\n start = b\n for j in range(start + 1, w):\n cur[j] = cur[j - 1] + prev[j]\n cur[j] = cur[j] % (1e9 + 7)\n prev, cur = cur, prev\n ", "i", "range(h - 1)", "range", "h - 1", "h", "1", "cur[0] = 1", "cur[0]", "cur", "0", "1", "start = 0", "start", "0", "if i >= h - 1 - a:\n cur[b] = prev[b]\n start = b\n ", "i >= h - 1 - a", "i", "h - 1 - a", "h - 1", "h", "1", "a", "cur[b] = prev[b]", "cur[b]", "cur", "b", "prev[b]", "prev", "b", "start = b", "start", "b", "for j in range(start + 1, w):\n cur[j] = cur[j - 1] + prev[j]\n cur[j] = cur[j] % (1e9 + 7)\n ", "j", "range(start + 1, w)", "range", "start + 1", "start", "1", "w", "cur[j] = cur[j - 1] + prev[j]", "cur[j]", "cur", "j", "cur[j - 1] + prev[j]", "cur[j - 1]", "cur", "j - 1", "j", "1", "prev[j]", "prev", "j", "cur[j] = cur[j] % (1e9 + 7)", "cur[j]", "cur", "j", "cur[j] % (1e9 + 7)", "cur[j]", "cur", "j", "1e9 + 7", "1e9", "7", "prev, cur = cur, prev", "prev", "cur", "cur", "prev", "return prev[-1]", "prev[-1]", "prev", "-1", "h", "h", "w", "w", "a", "a", "b", "b", "def f(H, W, A, B):\n count = 0\n x, y, a = H - A - 1, W + A - 2, A - 1\n for i in range(B, W): # bottom-left to top-right\n c1 = nck(x + i, i)\n c2 = nck(y - i, a)\n c = c1 * c2\n count += c\n count = count % MOD\n return int(count)\n\n## assert f(4, 4, 0, 0) == 20\n# assert f(4, 4, 2, 2) == 10\n#assert f(2, 3, 1, 1) == 2\n#assert f(10, 7, 3, 4) == 3570\n#assert f(100000, 100000, 99999, 99999) == 1\n#assert f(100000, 100000, 44444, 55555) == 738162020", "f", "count = 0", "count", "0", "x, y, a = H - A - 1, W + A - 2, A - 1", "x", "H - A - 1", "H - A", "H", "A", "1", "y", "W + A - 2", "W + A", "W", "A", "2", "a", "A - 1", "A", "1", "for i in range(B, W): # bottom-left to top-right\n c1 = nck(x + i, i)\n c2 = nck(y - i, a)\n c = c1 * c2\n count += c\n count = count % MOD\n ", "i", "range(B, W)", "range", "B", "W", "c1 = nck(x + i, i)", "c1", "nck(x + i, i)", "nck", "x + i", "x", "i", "i", "c2 = nck(y - i, a)", "c2", "nck(y - i, a)", "nck", "y - i", "y", "i", "a", "c = c1 * c2", "c", "c1 * c2", "c1", "c2", "count += c", "count", "c", "count = count % MOD", "count", "count % MOD", "count", "MOD", "return int(count)", "int(count)", "int", "count", "H", "H", "W", "W", "A", "A", "B", "B", "H, W, A, B = map(int, input().split())", "H", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "W", "A", "B", "ans = f(H, W, A, B)", "ans", "f(H, W, A, B)", "f", "H", "W", "A", "B", "print(ans)", "print", "ans", "def ncr(n, r):\n if n < r or n < 0 or r < 0:\n return 0\n r = min(r, n-r)\n numer = reduce(op.mul, range(n, n-r, -1), 1)\n denom = reduce(op.mul, range(1, r+1), 1)\n return numer / denom", "def ncr(n, r):\n if n < r or n < 0 or r < 0:\n return 0\n r = min(r, n-r)\n numer = reduce(op.mul, range(n, n-r, -1), 1)\n denom = reduce(op.mul, range(1, r+1), 1)\n return numer / denom", "ncr", "W, A, B = map(int, input().split())", "map(int, input().split())", "W", "MOD = (10 ** 9) + 7", "(10 ** 9) + 7", "MOD", "def f(H, W, A, B):\n count = 0\n x, y, a = H - A - 1, W + A - 2, A - 1\n for i in range(B, W): # bottom-left to top-right\n c1 = nck(x + i, i)\n c2 = nck(y - i, a)\n c = c1 * c2\n count += c\n count = count % MOD\n return int(count)\n\n## assert f(4, 4, 0, 0) == 20\n# assert f(4, 4, 2, 2) == 10\n#assert f(2, 3, 1, 1) == 2\n#assert f(10, 7, 3, 4) == 3570\n#assert f(100000, 100000, 99999, 99999) == 1\n#assert f(100000, 100000, 44444, 55555) == 738162020", "def f(H, W, A, B):\n count = 0\n x, y, a = H - A - 1, W + A - 2, A - 1\n for i in range(B, W): # bottom-left to top-right\n c1 = nck(x + i, i)\n c2 = nck(y - i, a)\n c = c1 * c2\n count += c\n count = count % MOD\n return int(count)\n\n## assert f(4, 4, 0, 0) == 20\n# assert f(4, 4, 2, 2) == 10\n#assert f(2, 3, 1, 1) == 2\n#assert f(10, 7, 3, 4) == 3570\n#assert f(100000, 100000, 99999, 99999) == 1\n#assert f(100000, 100000, 44444, 55555) == 738162020", "f", "finv = [1, 1]", "[1, 1]", "finv", "factors = [1, 1]", "[1, 1]", "factors", "def nck(n, k):\n if n < k or n < 0 or k < 0:\n return 0\n return factors[n] * (finv[k] * finv[n - k] % MOD) % MOD", "def nck(n, k):\n if n < k or n < 0 or k < 0:\n return 0\n return factors[n] * (finv[k] * finv[n - k] % MOD) % MOD", "nck", "A, B = map(int, input().split())", "map(int, input().split())", "A", "inv = [0, 1]", "[0, 1]", "inv", "B = map(int, input().split())", "map(int, input().split())", "B", "def g(h, w, a, b):\n prev = [1] * w\n cur = [0] * w\n\n for i in range(h - 1):\n cur[0] = 1\n start = 0\n if i >= h - 1 - a:\n cur[b] = prev[b]\n start = b\n for j in range(start + 1, w):\n cur[j] = cur[j - 1] + prev[j]\n cur[j] = cur[j] % (1e9 + 7)\n prev, cur = cur, prev\n return prev[-1]", "def g(h, w, a, b):\n prev = [1] * w\n cur = [0] * w\n\n for i in range(h - 1):\n cur[0] = 1\n start = 0\n if i >= h - 1 - a:\n cur[b] = prev[b]\n start = b\n for j in range(start + 1, w):\n cur[j] = cur[j - 1] + prev[j]\n cur[j] = cur[j] % (1e9 + 7)\n prev, cur = cur, prev\n return prev[-1]", "g", "H, W, A, B = map(int, input().split())", "map(int, input().split())", "H", "ans = f(H, W, A, B)", "f(H, W, A, B)", "ans" ]

[ 7, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 13, 13, 0, 13, 2, 2, 17, 17, 17, 0, 13, 2, 2, 13, 13, 17, 12, 13, 14, 2, 13, 17, 29, 17, 14, 2, 2, 13, 17, 17, 29, 2, 2, 4, 13, 13, 2, 13, 17, 17, 13, 14, 2, 13, 17, 29, 2, 13, 13, 29, 2, 2, 2, 4, 13, 13, 2, 13, 17, 17, 13, 13, 23, 13, 23, 13, 41, 28, 13, 4, 13, 13, 4, 17, 0, 13, 13, 41, 28, 13, 4, 13, 13, 4, 17, 0, 13, 13, 0, 18, 13, 17, 17, 28, 13, 4, 13, 17, 13, 0, 18, 13, 13, 2, 2, 18, 13, 2, 13, 17, 13, 13, 0, 18, 13, 2, 13, 13, 4, 13, 18, 13, 2, 13, 13, 2, 13, 17, 28, 13, 4, 13, 17, 13, 0, 18, 13, 2, 2, 13, 17, 13, 2, 2, 18, 13, 2, 13, 13, 2, 13, 13, 13, 12, 13, 29, 2, 2, 2, 2, 18, 13, 13, 18, 13, 13, 13, 18, 13, 2, 13, 13, 13, 23, 13, 23, 13, 0, 13, 17, 28, 13, 4, 13, 17, 2, 2, 13, 13, 17, 0, 13, 2, 2, 4, 13, 2, 2, 2, 2, 13, 13, 13, 17, 13, 2, 2, 13, 13, 17, 4, 13, 2, 2, 2, 2, 13, 17, 13, 13, 13, 2, 13, 17, 13, 0, 13, 13, 4, 13, 2, 13, 13, 10, 2, 13, 10, 12, 13, 10, 2, 13, 10, 4, 13, 10, 12, 13, 10, 13, 13, 10, 4, 13, 10, 17, 13, 10, 13, 13, 10, 13, 13, 10, 4, 13, 10, 4, 13, 10, 2, 13 ]

[ [ 279, 2 ], [ 279, 11 ], [ 279, 12 ], [ 279, 13 ], [ 246, 15 ], [ 282, 22 ], [ 256, 25 ], [ 277, 26 ], [ 77, 32 ], [ 77, 39 ], [ 75, 47 ], [ 77, 49 ], [ 247, 52 ], [ 77, 55 ], [ 75, 59 ], [ 247, 60 ], [ 75, 67 ], [ 77, 69 ], [ 75, 72 ], [ 247, 73 ], [ 75, 75 ], [ 77, 77 ], [ 81, 80 ], [ 283, 83 ], [ 273, 87 ], [ 92, 91 ], [ 283, 94 ], [ 270, 98 ], [ 104, 101 ], [ 274, 102 ], [ 107, 106 ], [ 283, 110 ], [ 115, 112 ], [ 274, 113 ], [ 106, 114 ], [ 274, 118 ], [ 106, 120 ], [ 106, 122 ], [ 247, 123 ], [ 130, 125 ], [ 271, 126 ], [ 256, 128 ], [ 277, 129 ], [ 250, 131 ], [ 274, 133 ], [ 256, 135 ], [ 277, 136 ], [ 247, 138 ], [ 142, 141 ], [ 283, 145 ], [ 154, 147 ], [ 271, 148 ], [ 283, 151 ], [ 141, 153 ], [ 271, 157 ], [ 283, 159 ], [ 141, 160 ], [ 283, 162 ], [ 141, 163 ], [ 247, 164 ], [ 274, 173 ], [ 186, 174 ], [ 271, 176 ], [ 188, 177 ], [ 247, 178 ], [ 271, 180 ], [ 186, 182 ], [ 188, 183 ], [ 247, 184 ], [ 186, 186 ], [ 188, 188 ], [ 267, 190 ], [ 194, 193 ], [ 277, 199 ], [ 265, 200 ], [ 252, 203 ], [ 259, 207 ], [ 256, 212 ], [ 280, 213 ], [ 265, 214 ], [ 193, 216 ], [ 256, 219 ], [ 280, 220 ], [ 259, 223 ], [ 280, 228 ], [ 277, 230 ], [ 265, 231 ], [ 193, 232 ], [ 280, 234 ], [ 247, 236 ], [ 261, 238 ], [ 247, 239 ], [ 262, 243 ], [ 253, 243 ], [ 268, 243 ], [ 247, 244 ], [ 246, 247 ], [ 252, 253 ], [ 279, 256 ], [ 247, 261 ], [ 261, 262 ], [ 279, 265 ], [ 267, 268 ], [ 270, 271 ], [ 273, 274 ], [ 279, 277 ], [ 279, 280 ], [ 282, 283 ] ]

[ "H,W,A,B = map(int, input().split())\nMOD = 10 ** 9 + 7\n\nN = H+W+1\n\ndef power(base, num):\n if num == 0:\n return 1\n elif num % 2==0:\n return power(base, num//2) **2 % MOD\n elif num==1:\n return base % MOD\n else:\n return power(base, num//2) **2 * base % MOD\n\nfact = [0 for i in range(N)]\ninv_fact = [0 for i in range(N)]\n\nfact[0] = 1\nfor i in range(1, N):\n fact[i] = fact[i-1] * i % MOD\n \ninv_fact[H+W] = power(fact[H+W], MOD-2)\nfor i in range(1, N):\n inv_fact[N-1-i] = inv_fact[N-i] * (N-i) % MOD\n\n \ndef comb(x,y):\n return (fact[x] * inv_fact[y])%MOD * inv_fact[x-y] % MOD\n\nans = 0\n\nfor i in range(1, W-B+1):\n ans += comb(H-A+B-2+i, H-A-1) * comb(A-1+W-B-i, A-1) % MOD\n ans %= MOD\nprint(ans%MOD)", "H,W,A,B = map(int, input().split())", "H", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "W", "A", "B", "MOD = 10 ** 9 + 7", "MOD", "10 ** 9 + 7", "10 ** 9", "10", "9", "7", "N = H+W+1", "N", "H+W+1", "H+W", "H", "W", "1", "def power(base, num):\n if num == 0:\n return 1\n elif num % 2==0:\n return power(base, num//2) **2 % MOD\n elif num==1:\n return base % MOD\n else:\n return power(base, num//2) **2 * base % MOD", "power", "if num == 0:\n return 1\n elif num % 2==0:\n return power(base, num//2) **2 % MOD\n elif num==1:\n return base % MOD\n else:\n return power(base, num//2) **2 * base % MOD", "num == 0", "num", "0", "return 1", "1", "elif num % 2==0:\n return power(base, num//2) **2 % MOD\n ", "num % 2==0", "num % 2", "num", "2", "0", "return power(base, num//2) **2 % MOD", "power(base, num//2) **2 % MOD", "power(base, num//2) **2", "power(base, num//2)", "power", "base", "num//2", "num", "2", "2", "MOD", "elif num==1:\n return base % MOD\n ", "num==1", "num", "1", "return base % MOD", "base % MOD", "base", "MOD", "return power(base, num//2) **2 * base % MOD", "power(base, num//2) **2 * base % MOD", "power(base, num//2) **2 * base", "power(base, num//2) **2", "power(base, num//2)", "power", "base", "num//2", "num", "2", "2", "base", "MOD", "base", "base", "num", "num", "0 for i in range(N)", "for i in range(N)", "i", "range(N)", "range", "N", "for i in range(N)", "0", "fact = [0 for i in range(N)]", "fact", "[0 for i in range(N)]", "0 for i in range(N)", "for i in range(N)", "i", "range(N)", "range", "N", "for i in range(N)", "0", "inv_fact = [0 for i in range(N)]", "inv_fact", "[0 for i in range(N)]", "fact[0] = 1", "fact[0]", "fact", "0", "1", "for i in range(1, N):\n fact[i] = fact[i-1] * i % MOD\n ", "i", "range(1, N)", "range", "1", "N", "fact[i] = fact[i-1] * i % MOD", "fact[i]", "fact", "i", "fact[i-1] * i % MOD", "fact[i-1] * i", "fact[i-1]", "fact", "i-1", "i", "1", "i", "MOD", "inv_fact[H+W] = power(fact[H+W], MOD-2)", "inv_fact[H+W]", "inv_fact", "H+W", "H", "W", "power(fact[H+W], MOD-2)", "power", "fact[H+W]", "fact", "H+W", "H", "W", "MOD-2", "MOD", "2", "for i in range(1, N):\n inv_fact[N-1-i] = inv_fact[N-i] * (N-i) % MOD\n\n ", "i", "range(1, N)", "range", "1", "N", "inv_fact[N-1-i] = inv_fact[N-i] * (N-i) % MOD", "inv_fact[N-1-i]", "inv_fact", "N-1-i", "N-1", "N", "1", "i", "inv_fact[N-i] * (N-i) % MOD", "inv_fact[N-i] * (N-i)", "inv_fact[N-i]", "inv_fact", "N-i", "N", "i", "N-i", "N", "i", "MOD", "def comb(x,y):\n return (fact[x] * inv_fact[y])%MOD * inv_fact[x-y] % MOD", "comb", "return (fact[x] * inv_fact[y])%MOD * inv_fact[x-y] % MOD", "(fact[x] * inv_fact[y])%MOD * inv_fact[x-y] % MOD", "(fact[x] * inv_fact[y])%MOD * inv_fact[x-y]", "(fact[x] * inv_fact[y])%MOD", "fact[x] * inv_fact[y]", "fact[x]", "fact", "x", "inv_fact[y]", "inv_fact", "y", "MOD", "inv_fact[x-y]", "inv_fact", "x-y", "x", "y", "MOD", "x", "x", "y", "y", "ans = 0", "ans", "0", "for i in range(1, W-B+1):\n ans += comb(H-A+B-2+i, H-A-1) * comb(A-1+W-B-i, A-1) % MOD\n ans %= MOD", "i", "range(1, W-B+1)", "range", "1", "W-B+1", "W-B", "W", "B", "1", "ans += comb(H-A+B-2+i, H-A-1) * comb(A-1+W-B-i, A-1) % MOD", "ans", "comb(H-A+B-2+i, H-A-1) * comb(A-1+W-B-i, A-1) % MOD", "comb(H-A+B-2+i, H-A-1) * comb(A-1+W-B-i, A-1)", "comb(H-A+B-2+i, H-A-1)", "comb", "H-A+B-2+i", "H-A+B-2", "H-A+B", "H-A", "H", "A", "B", "2", "i", "H-A-1", "H-A", "H", "A", "1", "comb(A-1+W-B-i, A-1)", "comb", "A-1+W-B-i", "A-1+W-B", "A-1+W", "A-1", "A", "1", "W", "B", "i", "A-1", "A", "1", "MOD", "ans %= MOD", "ans", "MOD", "print(ans%MOD)", "print", "ans%MOD", "ans", "MOD", "MOD = 10 ** 9 + 7", "10 ** 9 + 7", "MOD", "def power(base, num):\n if num == 0:\n return 1\n elif num % 2==0:\n return power(base, num//2) **2 % MOD\n elif num==1:\n return base % MOD\n else:\n return power(base, num//2) **2 * base % MOD", "def power(base, num):\n if num == 0:\n return 1\n elif num % 2==0:\n return power(base, num//2) **2 % MOD\n elif num==1:\n return base % MOD\n else:\n return power(base, num//2) **2 * base % MOD", "power", "ans += comb(H-A+B-2+i, H-A-1) * comb(A-1+W-B-i, A-1) % MOD", "comb(H-A+B-2+i, H-A-1) * comb(A-1+W-B-i, A-1) % MOD", "ans", "H,W,A,B = map(int, input().split())", "map(int, input().split())", "H", "def comb(x,y):\n return (fact[x] * inv_fact[y])%MOD * inv_fact[x-y] % MOD", "def comb(x,y):\n return (fact[x] * inv_fact[y])%MOD * inv_fact[x-y] % MOD", "comb", "ans %= MOD", "MOD", "ans", "B = map(int, input().split())", "map(int, input().split())", "B", "ans = 0", "0", "ans", "inv_fact = [0 for i in range(N)]", "[0 for i in range(N)]", "inv_fact", "fact = [0 for i in range(N)]", "[0 for i in range(N)]", "fact", "W,A,B = map(int, input().split())", "map(int, input().split())", "W", "A,B = map(int, input().split())", "map(int, input().split())", "A", "N = H+W+1", "H+W+1", "N" ]

[ 7, 0, 13, 2, 2, 17, 17, 17, 0, 13, 4, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 13, 13, 0, 13, 2, 39, 17, 2, 2, 13, 13, 17, 28, 13, 4, 13, 17, 2, 2, 13, 13, 17, 0, 18, 13, 13, 2, 2, 13, 18, 13, 2, 13, 17, 13, 0, 13, 4, 13, 4, 13, 12, 4, 13, 13, 2, 13, 17, 13, 23, 13, 12, 13, 29, 2, 2, 2, 18, 13, 13, 18, 13, 13, 18, 13, 2, 13, 13, 13, 23, 13, 23, 13, 0, 13, 2, 2, 4, 13, 2, 2, 2, 13, 13, 17, 13, 13, 4, 13, 2, 2, 2, 13, 13, 17, 13, 13, 13, 28, 13, 4, 13, 17, 2, 13, 13, 0, 13, 2, 2, 2, 4, 13, 2, 2, 2, 2, 13, 13, 17, 13, 13, 2, 13, 13, 4, 13, 2, 2, 2, 2, 2, 13, 13, 17, 13, 13, 17, 2, 2, 13, 13, 17, 4, 13, 2, 2, 2, 2, 13, 13, 17, 13, 13, 13, 13, 4, 13, 2, 13, 13, 10, 2, 13, 10, 4, 13, 10, 4, 13, 10, 2, 13, 10, 4, 13, 10, 2, 13, 10, 4, 13, 10, 12, 13, 10, 2, 13, 10, 4, 13 ]

[ [ 198, 2 ], [ 210, 9 ], [ 210, 20 ], [ 210, 21 ], [ 210, 22 ], [ 207, 24 ], [ 187, 30 ], [ 202, 31 ], [ 35, 34 ], [ 187, 40 ], [ 202, 41 ], [ 47, 44 ], [ 208, 45 ], [ 34, 46 ], [ 34, 49 ], [ 208, 51 ], [ 34, 53 ], [ 199, 55 ], [ 195, 57 ], [ 199, 67 ], [ 199, 69 ], [ 208, 71 ], [ 208, 79 ], [ 91, 80 ], [ 196, 82 ], [ 93, 83 ], [ 196, 85 ], [ 91, 87 ], [ 93, 88 ], [ 199, 89 ], [ 91, 91 ], [ 93, 93 ], [ 192, 95 ], [ 205, 99 ], [ 187, 103 ], [ 211, 104 ], [ 190, 106 ], [ 190, 107 ], [ 205, 109 ], [ 211, 113 ], [ 202, 114 ], [ 190, 116 ], [ 211, 117 ], [ 199, 118 ], [ 121, 120 ], [ 202, 125 ], [ 190, 126 ], [ 183, 128 ], [ 205, 133 ], [ 187, 138 ], [ 211, 139 ], [ 190, 141 ], [ 120, 142 ], [ 190, 144 ], [ 120, 145 ], [ 205, 147 ], [ 187, 153 ], [ 211, 154 ], [ 190, 156 ], [ 120, 157 ], [ 190, 161 ], [ 120, 162 ], [ 205, 165 ], [ 211, 170 ], [ 202, 171 ], [ 190, 173 ], [ 120, 174 ], [ 211, 175 ], [ 199, 176 ], [ 184, 180 ], [ 193, 180 ], [ 199, 181 ], [ 183, 184 ], [ 210, 187 ], [ 210, 190 ], [ 192, 193 ], [ 195, 196 ], [ 198, 199 ], [ 210, 202 ], [ 207, 208 ], [ 210, 211 ] ]

[ "mod = 10**9 + 7\nh, w, a, b = list(map(int, input().split()))\n\nt_mod = [1] * (h+w-1) \nfor i in range(1, h+w-1):\n t_mod[i] = i * t_mod[i-1] % mod \n\nt_modinv = list(map(lambda v: pow(v, mod-2, mod), t_mod))\n\ndef comb(n, r):\n return t_mod[n] * t_modinv[r] * t_modinv[n-r] % mod\n\nans = comb(h-a-1+b, b) * comb(a+w-1-b, a) % mod\nfor i in range(1, w-b):\n ans += (comb(h-a-1+b+i, b+i) - comb(h-a-1+b+i-1, b+i-1)) * comb(a+w-1-b-i, a) % mod\n\nprint(ans % mod)", "mod = 10**9 + 7", "mod", "10**9 + 7", "10**9", "10", "9", "7", "h, w, a, b = list(map(int, input().split()))", "h", "list(map(int, input().split()))", "list", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "w", "a", "b", "t_mod = [1] * (h+w-1)", "t_mod", "[1] * (h+w-1)", "[1]", "1", "h+w-1", "h+w", "h", "w", "1", "for i in range(1, h+w-1):\n t_mod[i] = i * t_mod[i-1] % mod ", "i", "range(1, h+w-1)", "range", "1", "h+w-1", "h+w", "h", "w", "1", "t_mod[i] = i * t_mod[i-1] % mod", "t_mod[i]", "t_mod", "i", "i * t_mod[i-1] % mod", "i * t_mod[i-1]", "i", "t_mod[i-1]", "t_mod", "i-1", "i", "1", "mod", "t_modinv = list(map(lambda v: pow(v, mod-2, mod), t_mod))", "t_modinv", "list(map(lambda v: pow(v, mod-2, mod), t_mod))", "list", "map(lambda v: pow(v, mod-2, mod), t_mod)", "map", "lambda v: pow(v, mod-2, mod)", "pow(v, mod-2, mod)", "pow", "v", "mod-2", "mod", "2", "mod", "v", "t_mod", "def comb(n, r):\n return t_mod[n] * t_modinv[r] * t_modinv[n-r] % mod", "comb", "return t_mod[n] * t_modinv[r] * t_modinv[n-r] % mod", "t_mod[n] * t_modinv[r] * t_modinv[n-r] % mod", "t_mod[n] * t_modinv[r] * t_modinv[n-r]", "t_mod[n] * t_modinv[r]", "t_mod[n]", "t_mod", "n", "t_modinv[r]", "t_modinv", "r", "t_modinv[n-r]", "t_modinv", "n-r", "n", "r", "mod", "n", "n", "r", "r", "ans = comb(h-a-1+b, b) * comb(a+w-1-b, a) % mod", "ans", "comb(h-a-1+b, b) * comb(a+w-1-b, a) % mod", "comb(h-a-1+b, b) * comb(a+w-1-b, a)", "comb(h-a-1+b, b)", "comb", "h-a-1+b", "h-a-1", "h-a", "h", "a", "1", "b", "b", "comb(a+w-1-b, a)", "comb", "a+w-1-b", "a+w-1", "a+w", "a", "w", "1", "b", "a", "mod", "for i in range(1, w-b):\n ans += (comb(h-a-1+b+i, b+i) - comb(h-a-1+b+i-1, b+i-1)) * comb(a+w-1-b-i, a) % mod", "i", "range(1, w-b)", "range", "1", "w-b", "w", "b", "ans += (comb(h-a-1+b+i, b+i) - comb(h-a-1+b+i-1, b+i-1)) * comb(a+w-1-b-i, a) % mod", "ans", "(comb(h-a-1+b+i, b+i) - comb(h-a-1+b+i-1, b+i-1)) * comb(a+w-1-b-i, a) % mod", "(comb(h-a-1+b+i, b+i) - comb(h-a-1+b+i-1, b+i-1)) * comb(a+w-1-b-i, a)", "comb(h-a-1+b+i, b+i) - comb(h-a-1+b+i-1, b+i-1)", "comb(h-a-1+b+i, b+i)", "comb", "h-a-1+b+i", "h-a-1+b", "h-a-1", "h-a", "h", "a", "1", "b", "i", "b+i", "b", "i", "comb(h-a-1+b+i-1, b+i-1)", "comb", "h-a-1+b+i-1", "h-a-1+b+i", "h-a-1+b", "h-a-1", "h-a", "h", "a", "1", "b", "i", "1", "b+i-1", "b+i", "b", "i", "1", "comb(a+w-1-b-i, a)", "comb", "a+w-1-b-i", "a+w-1-b", "a+w-1", "a+w", "a", "w", "1", "b", "i", "a", "mod", "print(ans % mod)", "print", "ans % mod", "ans", "mod", "ans += (comb(h-a-1+b+i, b+i) - comb(h-a-1+b+i-1, b+i-1)) * comb(a+w-1-b-i, a) % mod", "(comb(h-a-1+b+i, b+i) - comb(h-a-1+b+i-1, b+i-1)) * comb(a+w-1-b-i, a) % mod", "ans", "h, w, a, b = list(map(int, input().split()))", "list(map(int, input().split()))", "h", "b = list(map(int, input().split()))", "list(map(int, input().split()))", "b", "ans = comb(h-a-1+b, b) * comb(a+w-1-b, a) % mod", "comb(h-a-1+b, b) * comb(a+w-1-b, a) % mod", "ans", "t_modinv = list(map(lambda v: pow(v, mod-2, mod), t_mod))", "list(map(lambda v: pow(v, mod-2, mod), t_mod))", "t_modinv", "mod = 10**9 + 7", "10**9 + 7", "mod", "w, a, b = list(map(int, input().split()))", "list(map(int, input().split()))", "w", "def comb(n, r):\n return t_mod[n] * t_modinv[r] * t_modinv[n-r] % mod", "def comb(n, r):\n return t_mod[n] * t_modinv[r] * t_modinv[n-r] % mod", "comb", "t_mod = [1] * (h+w-1)", "[1] * (h+w-1)", "t_mod", "a, b = list(map(int, input().split()))", "list(map(int, input().split()))", "a" ]

[ 7, 0, 13, 2, 2, 17, 17, 17, 6, 13, 12, 13, 0, 18, 13, 13, 2, 13, 13, 23, 13, 23, 13, 12, 13, 29, 4, 13, 18, 13, 13, 23, 13, 0, 13, 13, 12, 13, 29, 8, 4, 13, 13, 13, 4, 13, 2, 18, 13, 13, 18, 13, 13, 4, 13, 2, 18, 13, 13, 13, 23, 13, 23, 13, 12, 13, 29, 8, 4, 13, 13, 13, 4, 13, 2, 18, 13, 13, 18, 13, 13, 4, 13, 2, 18, 13, 13, 13, 23, 13, 23, 13, 12, 13, 29, 8, 4, 13, 13, 13, 4, 13, 2, 18, 13, 13, 18, 13, 13, 4, 13, 2, 18, 13, 13, 13, 23, 13, 23, 13, 12, 13, 29, 8, 4, 13, 13, 13, 4, 13, 2, 18, 13, 13, 4, 13, 18, 13, 13, 2, 13, 17, 13, 4, 13, 2, 18, 13, 13, 4, 13, 13, 2, 13, 17, 13, 23, 13, 23, 13, 12, 13, 29, 8, 4, 13, 13, 13, 4, 13, 4, 13, 18, 13, 13, 18, 13, 13, 13, 4, 13, 4, 13, 18, 13, 13, 13, 13, 23, 13, 23, 13, 0, 13, 13, 12, 13, 29, 8, 4, 13, 13, 13, 4, 13, 2, 18, 13, 13, 18, 13, 13, 4, 13, 2, 13, 18, 13, 13, 23, 13, 23, 13, 0, 13, 13, 12, 13, 29, 8, 4, 13, 13, 13, 4, 13, 2, 18, 13, 13, 4, 13, 18, 13, 13, 2, 13, 17, 13, 4, 13, 2, 13, 4, 13, 18, 13, 13, 2, 13, 17, 13, 23, 13, 23, 13, 12, 13, 29, 8, 4, 13, 13, 13, 4, 13, 4, 13, 18, 13, 13, 18, 13, 13, 13, 4, 13, 4, 13, 13, 18, 13, 13, 13, 23, 13, 23, 13, 12, 13, 28, 13, 4, 13, 17, 2, 13, 17, 0, 13, 2, 2, 13, 13, 13, 29, 13, 23, 13, 23, 13, 23, 13, 17, 12, 13, 14, 2, 13, 17, 14, 2, 2, 13, 17, 17, 29, 2, 4, 13, 2, 2, 13, 13, 13, 2, 13, 17, 13, 13, 14, 2, 2, 13, 17, 17, 29, 2, 2, 13, 4, 13, 13, 2, 13, 17, 13, 13, 23, 13, 23, 13, 23, 13, 12, 13, 0, 13, 4, 13, 13, 13, 0, 13, 4, 13, 13, 13, 0, 13, 4, 13, 2, 13, 13, 13, 29, 2, 2, 2, 13, 4, 13, 13, 2, 13, 17, 13, 4, 13, 13, 2, 13, 17, 13, 13, 23, 13, 23, 13, 23, 13, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 13, 13, 0, 13, 4, 13, 17, 0, 13, 2, 2, 17, 17, 17, 0, 13, 2, 13, 13, 41, 28, 13, 4, 13, 2, 13, 13, 4, 4, 13, 17, 0, 13, 13, 41, 28, 13, 4, 13, 2, 13, 13, 4, 4, 13, 17, 0, 13, 13, 0, 18, 13, 17, 4, 13, 4, 13, 2, 2, 13, 13, 17, 13, 13, 0, 18, 13, 17, 4, 13, 2, 13, 17, 17, 13, 28, 13, 4, 13, 17, 2, 13, 13, 0, 18, 13, 13, 2, 2, 18, 13, 2, 13, 17, 4, 13, 2, 2, 2, 13, 13, 13, 17, 4, 13, 2, 13, 13, 0, 18, 13, 13, 2, 2, 18, 13, 2, 13, 17, 4, 13, 2, 2, 13, 13, 17, 4, 13, 13, 4, 18, 13, 13, 28, 13, 4, 13, 2, 13, 17, 2, 13, 17, 0, 13, 2, 18, 13, 2, 2, 13, 13, 17, 18, 13, 2, 2, 13, 13, 17, 4, 13, 13, 10, 4, 13, 10, 2, 13, 10, 4, 13, 10, 12, 13, 10, 13, 13, 10, 6, 13, 10, 4, 13, 10, 4, 13, 10, 2, 13, 10, 12, 13, 10, 13, 13, 10, 2, 13, 10, 2, 13, 10, 12, 13, 10, 4, 13 ]

[ [ 630, 2 ], [ 16, 13 ], [ 20, 14 ], [ 22, 15 ], [ 22, 17 ], [ 631, 18 ], [ 20, 20 ], [ 22, 22 ], [ 32, 29 ], [ 32, 32 ], [ 35, 34 ], [ 24, 35 ], [ 63, 42 ], [ 61, 48 ], [ 63, 51 ], [ 61, 57 ], [ 63, 59 ], [ 61, 61 ], [ 63, 63 ], [ 91, 70 ], [ 89, 76 ], [ 91, 79 ], [ 89, 85 ], [ 91, 87 ], [ 89, 89 ], [ 91, 91 ], [ 119, 98 ], [ 117, 104 ], [ 119, 107 ], [ 117, 113 ], [ 119, 115 ], [ 117, 117 ], [ 119, 119 ], [ 159, 126 ], [ 157, 132 ], [ 159, 137 ], [ 631, 140 ], [ 631, 142 ], [ 157, 147 ], [ 159, 151 ], [ 631, 153 ], [ 631, 155 ], [ 157, 157 ], [ 159, 159 ], [ 191, 166 ], [ 189, 173 ], [ 191, 176 ], [ 631, 178 ], [ 189, 184 ], [ 191, 186 ], [ 631, 187 ], [ 189, 189 ], [ 191, 191 ], [ 194, 193 ], [ 37, 194 ], [ 222, 201 ], [ 222, 207 ], [ 220, 210 ], [ 222, 215 ], [ 220, 217 ], [ 220, 220 ], [ 222, 222 ], [ 225, 224 ], [ 93, 225 ], [ 265, 232 ], [ 265, 238 ], [ 263, 243 ], [ 631, 246 ], [ 631, 248 ], [ 265, 252 ], [ 263, 256 ], [ 631, 259 ], [ 631, 261 ], [ 263, 263 ], [ 265, 265 ], [ 297, 272 ], [ 297, 279 ], [ 295, 282 ], [ 631, 284 ], [ 297, 289 ], [ 295, 291 ], [ 631, 293 ], [ 295, 295 ], [ 297, 297 ], [ 302, 301 ], [ 318, 306 ], [ 310, 309 ], [ 322, 312 ], [ 309, 312 ], [ 301, 313 ], [ 320, 314 ], [ 309, 316 ], [ 322, 316 ], [ 318, 318 ], [ 320, 320 ], [ 323, 322 ], [ 371, 328 ], [ 371, 333 ], [ 369, 342 ], [ 369, 343 ], [ 373, 344 ], [ 371, 346 ], [ 373, 348 ], [ 373, 349 ], [ 371, 353 ], [ 369, 359 ], [ 369, 362 ], [ 371, 364 ], [ 373, 366 ], [ 373, 367 ], [ 369, 369 ], [ 371, 371 ], [ 373, 373 ], [ 378, 377 ], [ 637, 379 ], [ 417, 380 ], [ 421, 381 ], [ 384, 383 ], [ 637, 385 ], [ 419, 386 ], [ 421, 387 ], [ 390, 389 ], [ 637, 391 ], [ 417, 393 ], [ 419, 394 ], [ 421, 395 ], [ 377, 400 ], [ 607, 402 ], [ 383, 403 ], [ 421, 405 ], [ 421, 407 ], [ 607, 409 ], [ 389, 410 ], [ 421, 412 ], [ 421, 414 ], [ 421, 415 ], [ 417, 417 ], [ 419, 419 ], [ 421, 421 ], [ 639, 423 ], [ 639, 432 ], [ 639, 433 ], [ 639, 434 ], [ 618, 436 ], [ 633, 441 ], [ 600, 448 ], [ 616, 450 ], [ 640, 451 ], [ 455, 454 ], [ 604, 458 ], [ 598, 459 ], [ 627, 465 ], [ 470, 469 ], [ 604, 473 ], [ 598, 474 ], [ 609, 480 ], [ 486, 483 ], [ 628, 484 ], [ 625, 489 ], [ 601, 492 ], [ 598, 493 ], [ 598, 495 ], [ 634, 496 ], [ 501, 498 ], [ 610, 499 ], [ 625, 502 ], [ 640, 504 ], [ 634, 507 ], [ 510, 509 ], [ 604, 514 ], [ 598, 515 ], [ 520, 517 ], [ 628, 518 ], [ 509, 519 ], [ 628, 523 ], [ 509, 525 ], [ 601, 532 ], [ 598, 533 ], [ 509, 534 ], [ 598, 539 ], [ 509, 540 ], [ 545, 542 ], [ 610, 543 ], [ 509, 544 ], [ 610, 548 ], [ 509, 550 ], [ 640, 556 ], [ 509, 557 ], [ 509, 561 ], [ 610, 564 ], [ 568, 567 ], [ 598, 571 ], [ 604, 574 ], [ 621, 577 ], [ 628, 580 ], [ 567, 583 ], [ 598, 584 ], [ 610, 587 ], [ 567, 590 ], [ 598, 591 ], [ 622, 595 ], [ 619, 595 ], [ 639, 598 ], [ 600, 601 ], [ 639, 604 ], [ 609, 610 ], [ 639, 616 ], [ 618, 619 ], [ 621, 622 ], [ 627, 628 ], [ 630, 631 ], [ 633, 634 ], [ 639, 640 ] ]

[ "MOD=10**9+7\nclass ModInt:\n def __init__(self, x):\n self.x = x % MOD\n\n def __str__(self):\n return str(self.x)\n\n __repr__ = __str__\n\n def __add__(self, other):\n return (\n ModInt(self.x + other.x) if isinstance(other, ModInt) else\n ModInt(self.x + other)\n )\n\n def __sub__(self, other):\n return (\n ModInt(self.x - other.x) if isinstance(other, ModInt) else\n ModInt(self.x - other)\n )\n\n def __mul__(self, other):\n return (\n ModInt(self.x * other.x) if isinstance(other, ModInt) else\n ModInt(self.x * other)\n )\n\n def __truediv__(self, other):\n return (\n ModInt(\n self.x * pow(other.x, MOD - 2, MOD)\n ) if isinstance(other, ModInt) else\n ModInt(self.x * pow(other, MOD - 2, MOD))\n )\n\n def __pow__(self, other):\n return (\n ModInt(pow(self.x, other.x, MOD)) if isinstance(other, ModInt) else\n ModInt(pow(self.x, other, MOD))\n )\n\n __radd__ = __add__\n\n def __rsub__(self, other):\n return (\n ModInt(other.x - self.x) if isinstance(other, ModInt) else\n ModInt(other - self.x)\n )\n\n __rmul__ = __mul__\n\n def __rtruediv__(self, other):\n return (\n ModInt(\n other.x * pow(self.x, MOD - 2, MOD)\n ) if isinstance(other, ModInt) else\n ModInt(other * pow(self.x, MOD - 2, MOD))\n )\n\n def __rpow__(self, other):\n return (\n ModInt(pow(other.x, self.x, MOD)) if isinstance(other, ModInt) else\n ModInt(pow(other, self.x, MOD))\n )\ndef framod(n, mod, a=1):\n for i in range(1,n+1):\n a=a * i % mod\n return a\n\ndef pow(n, r, mod):\n if r == 0: return 1\n if r%2 == 0:\n return pow(n*n % mod, r//2, mod) % mod\n if r%2 == 1:\n return n * pow(n, r-1, mod) % mod\n\ndef com(n, k, mod):\n a=framod(n, mod)\n b=framod(k, mod)\n c=framod(n-k, mod)\n return (a * pow(b, mod-2, mod) * pow(c, mod-2, mod)) % mod\nh,w,a,b=map(int,input().split())\nans=ModInt(0)\nmod=10**9+7\nk=h-a\ncom1=[ModInt(0) for i in range(w-b)]\ncom2=[ModInt(0) for i in range(w-b)]\ncom1[0]=ModInt(com(k+b-1,b,mod))\ncom2[0]=com(a-1,0,mod)\nfor i in range(1,w-b):\n com1[i]=com1[i-1]*ModInt(k+b+i-1)/ModInt(b+i)\n com2[i]=com2[i-1]*ModInt(a+i-1)/ModInt(i)\n# print(com1)\ncom2.reverse()\n# print(com2)\nfor i in range(b+1,w+1):\n ans+=com1[i-b-1]*com2[i-b-1]\n # print(com1[i-b-1],com2[i-b-1])\n # print(com(k+i-2,i-1,mod),com(a+w-i-1,w-i,mod))\nprint(ans)", "MOD=10**9+7", "MOD", "10**9+7", "10**9", "10", "9", "7", "class ModInt:\n def __init__(self, x):\n self.x = x % MOD\n\n def __str__(self):\n return str(self.x)\n\n __repr__ = __str__\n\n def __add__(self, other):\n return (\n ModInt(self.x + other.x) if isinstance(other, ModInt) else\n ModInt(self.x + other)\n )\n\n def __sub__(self, other):\n return (\n ModInt(self.x - other.x) if isinstance(other, ModInt) else\n ModInt(self.x - other)\n )\n\n def __mul__(self, other):\n return (\n ModInt(self.x * other.x) if isinstance(other, ModInt) else\n ModInt(self.x * other)\n )\n\n def __truediv__(self, other):\n return (\n ModInt(\n self.x * pow(other.x, MOD - 2, MOD)\n ) if isinstance(other, ModInt) else\n ModInt(self.x * pow(other, MOD - 2, MOD))\n )\n\n def __pow__(self, other):\n return (\n ModInt(pow(self.x, other.x, MOD)) if isinstance(other, ModInt) else\n ModInt(pow(self.x, other, MOD))\n )\n\n __radd__ = __add__\n\n def __rsub__(self, other):\n return (\n ModInt(other.x - self.x) if isinstance(other, ModInt) else\n ModInt(other - self.x)\n )\n\n __rmul__ = __mul__\n\n def __rtruediv__(self, other):\n return (\n ModInt(\n other.x * pow(self.x, MOD - 2, MOD)\n ) if isinstance(other, ModInt) else\n ModInt(other * pow(self.x, MOD - 2, MOD))\n )\n\n def __rpow__(self, other):\n return (\n ModInt(pow(other.x, self.x, MOD)) if isinstance(other, ModInt) else\n ModInt(pow(other, self.x, MOD))\n )", "ModInt", "def __init__(self, x):\n self.x = x % MOD\n\n ", "__init__", "self.x = x % MOD", "self.x", "self", "x", "x % MOD", "x", "MOD", "self", "self", "x", "x", "def __str__(self):\n return str(self.x)\n\n ", "__str__", "return str(self.x)", "str(self.x)", "str", "self.x", "self", "x", "self", "self", "__repr__ = __str__", "__repr__", "__str__", "def __add__(self, other):\n return (\n ModInt(self.x + other.x) if isinstance(other, ModInt) else\n ModInt(self.x + other)\n )\n\n ", "__add__", "return (\n ModInt(self.x + other.x) if isinstance(other, ModInt) else\n ModInt(self.x + other)\n )", "ModInt(self.x + other.x) if isinstance(other, ModInt) else\n ModInt(self.x + other)", "isinstance(other, ModInt)", "isinstance", "other", "ModInt", "ModInt(self.x + other.x)", "ModInt", "self.x + other.x", "self.x", "self", "x", "other.x", "other", "x", "ModInt(self.x + other)", "ModInt", "self.x + other", "self.x", "self", "x", "other", "self", "self", "other", "other", "def __sub__(self, other):\n return (\n ModInt(self.x - other.x) if isinstance(other, ModInt) else\n ModInt(self.x - other)\n )\n\n ", "__sub__", "return (\n ModInt(self.x - other.x) if isinstance(other, ModInt) else\n ModInt(self.x - other)\n )", "ModInt(self.x - other.x) if isinstance(other, ModInt) else\n ModInt(self.x - other)", "isinstance(other, ModInt)", "isinstance", "other", "ModInt", "ModInt(self.x - other.x)", "ModInt", "self.x - other.x", "self.x", "self", "x", "other.x", "other", "x", "ModInt(self.x - other)", "ModInt", "self.x - other", "self.x", "self", "x", "other", "self", "self", "other", "other", "def __mul__(self, other):\n return (\n ModInt(self.x * other.x) if isinstance(other, ModInt) else\n ModInt(self.x * other)\n )\n\n ", "__mul__", "return (\n ModInt(self.x * other.x) if isinstance(other, ModInt) else\n ModInt(self.x * other)\n )", "ModInt(self.x * other.x) if isinstance(other, ModInt) else\n ModInt(self.x * other)", "isinstance(other, ModInt)", "isinstance", "other", "ModInt", "ModInt(self.x * other.x)", "ModInt", "self.x * other.x", "self.x", "self", "x", "other.x", "other", "x", "ModInt(self.x * other)", "ModInt", "self.x * other", "self.x", "self", "x", "other", "self", "self", "other", "other", "def __truediv__(self, other):\n return (\n ModInt(\n self.x * pow(other.x, MOD - 2, MOD)\n ) if isinstance(other, ModInt) else\n ModInt(self.x * pow(other, MOD - 2, MOD))\n )\n\n ", "__truediv__", "return (\n ModInt(\n self.x * pow(other.x, MOD - 2, MOD)\n ) if isinstance(other, ModInt) else\n ModInt(self.x * pow(other, MOD - 2, MOD))\n )", "ModInt(\n self.x * pow(other.x, MOD - 2, MOD)\n ) if isinstance(other, ModInt) else\n ModInt(self.x * pow(other, MOD - 2, MOD))", "isinstance(other, ModInt)", "isinstance", "other", "ModInt", "ModInt(\n self.x * pow(other.x, MOD - 2, MOD)\n )", "ModInt", "self.x * pow(other.x, MOD - 2, MOD)", "self.x", "self", "x", "pow(other.x, MOD - 2, MOD)", "pow", "other.x", "other", "x", "MOD - 2", "MOD", "2", "MOD", "ModInt(self.x * pow(other, MOD - 2, MOD))", "ModInt", "self.x * pow(other, MOD - 2, MOD)", "self.x", "self", "x", "pow(other, MOD - 2, MOD)", "pow", "other", "MOD - 2", "MOD", "2", "MOD", "self", "self", "other", "other", "def __pow__(self, other):\n return (\n ModInt(pow(self.x, other.x, MOD)) if isinstance(other, ModInt) else\n ModInt(pow(self.x, other, MOD))\n )\n\n ", "__pow__", "return (\n ModInt(pow(self.x, other.x, MOD)) if isinstance(other, ModInt) else\n ModInt(pow(self.x, other, MOD))\n )", "ModInt(pow(self.x, other.x, MOD)) if isinstance(other, ModInt) else\n ModInt(pow(self.x, other, MOD))", "isinstance(other, ModInt)", "isinstance", "other", "ModInt", "ModInt(pow(self.x, other.x, MOD))", "ModInt", "pow(self.x, other.x, MOD)", "pow", "self.x", "self", "x", "other.x", "other", "x", "MOD", "ModInt(pow(self.x, other, MOD))", "ModInt", "pow(self.x, other, MOD)", "pow", "self.x", "self", "x", "other", "MOD", "self", "self", "other", "other", "__radd__ = __add__", "__radd__", "__add__", "def __rsub__(self, other):\n return (\n ModInt(other.x - self.x) if isinstance(other, ModInt) else\n ModInt(other - self.x)\n )\n\n ", "__rsub__", "return (\n ModInt(other.x - self.x) if isinstance(other, ModInt) else\n ModInt(other - self.x)\n )", "ModInt(other.x - self.x) if isinstance(other, ModInt) else\n ModInt(other - self.x)", "isinstance(other, ModInt)", "isinstance", "other", "ModInt", "ModInt(other.x - self.x)", "ModInt", "other.x - self.x", "other.x", "other", "x", "self.x", "self", "x", "ModInt(other - self.x)", "ModInt", "other - self.x", "other", "self.x", "self", "x", "self", "self", "other", "other", "__rmul__ = __mul__", "__rmul__", "__mul__", "def __rtruediv__(self, other):\n return (\n ModInt(\n other.x * pow(self.x, MOD - 2, MOD)\n ) if isinstance(other, ModInt) else\n ModInt(other * pow(self.x, MOD - 2, MOD))\n )\n\n ", "__rtruediv__", "return (\n ModInt(\n other.x * pow(self.x, MOD - 2, MOD)\n ) if isinstance(other, ModInt) else\n ModInt(other * pow(self.x, MOD - 2, MOD))\n )", "ModInt(\n other.x * pow(self.x, MOD - 2, MOD)\n ) if isinstance(other, ModInt) else\n ModInt(other * pow(self.x, MOD - 2, MOD))", "isinstance(other, ModInt)", "isinstance", "other", "ModInt", "ModInt(\n other.x * pow(self.x, MOD - 2, MOD)\n )", "ModInt", "other.x * pow(self.x, MOD - 2, MOD)", "other.x", "other", "x", "pow(self.x, MOD - 2, MOD)", "pow", "self.x", "self", "x", "MOD - 2", "MOD", "2", "MOD", "ModInt(other * pow(self.x, MOD - 2, MOD))", "ModInt", "other * pow(self.x, MOD - 2, MOD)", "other", "pow(self.x, MOD - 2, MOD)", "pow", "self.x", "self", "x", "MOD - 2", "MOD", "2", "MOD", "self", "self", "other", "other", "def __rpow__(self, other):\n return (\n ModInt(pow(other.x, self.x, MOD)) if isinstance(other, ModInt) else\n ModInt(pow(other, self.x, MOD))\n )", "__rpow__", "return (\n ModInt(pow(other.x, self.x, MOD)) if isinstance(other, ModInt) else\n ModInt(pow(other, self.x, MOD))\n )", "ModInt(pow(other.x, self.x, MOD)) if isinstance(other, ModInt) else\n ModInt(pow(other, self.x, MOD))", "isinstance(other, ModInt)", "isinstance", "other", "ModInt", "ModInt(pow(other.x, self.x, MOD))", "ModInt", "pow(other.x, self.x, MOD)", "pow", "other.x", "other", "x", "self.x", "self", "x", "MOD", "ModInt(pow(other, self.x, MOD))", "ModInt", "pow(other, self.x, MOD)", "pow", "other", "self.x", "self", "x", "MOD", "self", "self", "other", "other", "def framod(n, mod, a=1):\n for i in range(1,n+1):\n a=a * i % mod\n return a", "framod", "for i in range(1,n+1):\n a=a * i % mod\n ", "i", "range(1,n+1)", "range", "1", "n+1", "n", "1", "a=a * i % mod", "a", "a * i % mod", "a * i", "a", "i", "mod", "return a", "a", "n", "n", "mod", "mod", "a=1", "a", "1", "def pow(n, r, mod):\n if r == 0: return 1\n if r%2 == 0:\n return pow(n*n % mod, r//2, mod) % mod\n if r%2 == 1:\n return n * pow(n, r-1, mod) % mod", "pow", "if r == 0: return 1\n ", "r == 0", "r", "0", "if r%2 == 0:\n return pow(n*n % mod, r//2, mod) % mod\n ", "r%2 == 0", "r%2", "r", "2", "0", "return pow(n*n % mod, r//2, mod) % mod", "pow(n*n % mod, r//2, mod) % mod", "pow(n*n % mod, r//2, mod)", "pow", "n*n % mod", "n*n", "n", "n", "mod", "r//2", "r", "2", "mod", "mod", "if r%2 == 1:\n return n * pow(n, r-1, mod) % mod", "r%2 == 1", "r%2", "r", "2", "1", "return n * pow(n, r-1, mod) % mod", "n * pow(n, r-1, mod) % mod", "n * pow(n, r-1, mod)", "n", "pow(n, r-1, mod)", "pow", "n", "r-1", "r", "1", "mod", "mod", "n", "n", "r", "r", "mod", "mod", "def com(n, k, mod):\n a=framod(n, mod)\n b=framod(k, mod)\n c=framod(n-k, mod)\n return (a * pow(b, mod-2, mod) * pow(c, mod-2, mod)) % mod", "com", "a=framod(n, mod)", "a", "framod(n, mod)", "framod", "n", "mod", "b=framod(k, mod)", "b", "framod(k, mod)", "framod", "k", "mod", "c=framod(n-k, mod)", "c", "framod(n-k, mod)", "framod", "n-k", "n", "k", "mod", "return (a * pow(b, mod-2, mod) * pow(c, mod-2, mod)) % mod", "(a * pow(b, mod-2, mod) * pow(c, mod-2, mod)) % mod", "a * pow(b, mod-2, mod) * pow(c, mod-2, mod)", "a * pow(b, mod-2, mod)", "a", "pow(b, mod-2, mod)", "pow", "b", "mod-2", "mod", "2", "mod", "pow(c, mod-2, mod)", "pow", "c", "mod-2", "mod", "2", "mod", "mod", "n", "n", "k", "k", "mod", "mod", "h,w,a,b=map(int,input().split())", "h", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "w", "a", "b", "ans=ModInt(0)", "ans", "ModInt(0)", "ModInt", "0", "mod=10**9+7", "mod", "10**9+7", "10**9", "10", "9", "7", "k=h-a", "k", "h-a", "h", "a", "ModInt(0) for i in range(w-b)", "for i in range(w-b)", "i", "range(w-b)", "range", "w-b", "w", "b", "for i in range(w-b)", "ModInt(0)", "ModInt", "0", "com1=[ModInt(0) for i in range(w-b)]", "com1", "[ModInt(0) for i in range(w-b)]", "ModInt(0) for i in range(w-b)", "for i in range(w-b)", "i", "range(w-b)", "range", "w-b", "w", "b", "for i in range(w-b)", "ModInt(0)", "ModInt", "0", "com2=[ModInt(0) for i in range(w-b)]", "com2", "[ModInt(0) for i in range(w-b)]", "com1[0]=ModInt(com(k+b-1,b,mod))", "com1[0]", "com1", "0", "ModInt(com(k+b-1,b,mod))", "ModInt", "com(k+b-1,b,mod)", "com", "k+b-1", "k+b", "k", "b", "1", "b", "mod", "com2[0]=com(a-1,0,mod)", "com2[0]", "com2", "0", "com(a-1,0,mod)", "com", "a-1", "a", "1", "0", "mod", "for i in range(1,w-b):\n com1[i]=com1[i-1]*ModInt(k+b+i-1)/ModInt(b+i)\n com2[i]=com2[i-1]*ModInt(a+i-1)/ModInt(i)\n# print(com1)", "i", "range(1,w-b)", "range", "1", "w-b", "w", "b", "com1[i]=com1[i-1]*ModInt(k+b+i-1)/ModInt(b+i)", "com1[i]", "com1", "i", "com1[i-1]*ModInt(k+b+i-1)/ModInt(b+i)", "com1[i-1]*ModInt(k+b+i-1)", "com1[i-1]", "com1", "i-1", "i", "1", "ModInt(k+b+i-1)", "ModInt", "k+b+i-1", "k+b+i", "k+b", "k", "b", "i", "1", "ModInt(b+i)", "ModInt", "b+i", "b", "i", "com2[i]=com2[i-1]*ModInt(a+i-1)/ModInt(i)", "com2[i]", "com2", "i", "com2[i-1]*ModInt(a+i-1)/ModInt(i)", "com2[i-1]*ModInt(a+i-1)", "com2[i-1]", "com2", "i-1", "i", "1", "ModInt(a+i-1)", "ModInt", "a+i-1", "a+i", "a", "i", "1", "ModInt(i)", "ModInt", "i", "com2.reverse()", "com2.reverse", "com2", "reverse", "for i in range(b+1,w+1):\n ans+=com1[i-b-1]*com2[i-b-1]\n # print(com1[i-b-1],com2[i-b-1])\n # print(com(k+i-2,i-1,mod),com(a+w-i-1,w-i,mod))", "i", "range(b+1,w+1)", "range", "b+1", "b", "1", "w+1", "w", "1", "ans+=com1[i-b-1]*com2[i-b-1]", "ans", "com1[i-b-1]*com2[i-b-1]", "com1[i-b-1]", "com1", "i-b-1", "i-b", "i", "b", "1", "com2[i-b-1]", "com2", "i-b-1", "i-b", "i", "b", "1", "print(ans)", "print", "ans", "b=map(int,input().split())", "map(int,input().split())", "b", "k=h-a", "h-a", "k", "w,a,b=map(int,input().split())", "map(int,input().split())", "w", "def pow(n, r, mod):\n if r == 0: return 1\n if r%2 == 0:\n return pow(n*n % mod, r//2, mod) % mod\n if r%2 == 1:\n return n * pow(n, r-1, mod) % mod", "def pow(n, r, mod):\n if r == 0: return 1\n if r%2 == 0:\n return pow(n*n % mod, r//2, mod) % mod\n if r%2 == 1:\n return n * pow(n, r-1, mod) % mod", "pow", "com2=[ModInt(0) for i in range(w-b)]", "[ModInt(0) for i in range(w-b)]", "com2", "class ModInt:\n def __init__(self, x):\n self.x = x % MOD\n\n def __str__(self):\n return str(self.x)\n\n __repr__ = __str__\n\n def __add__(self, other):\n return (\n ModInt(self.x + other.x) if isinstance(other, ModInt) else\n ModInt(self.x + other)\n )\n\n def __sub__(self, other):\n return (\n ModInt(self.x - other.x) if isinstance(other, ModInt) else\n ModInt(self.x - other)\n )\n\n def __mul__(self, other):\n return (\n ModInt(self.x * other.x) if isinstance(other, ModInt) else\n ModInt(self.x * other)\n )\n\n def __truediv__(self, other):\n return (\n ModInt(\n self.x * pow(other.x, MOD - 2, MOD)\n ) if isinstance(other, ModInt) else\n ModInt(self.x * pow(other, MOD - 2, MOD))\n )\n\n def __pow__(self, other):\n return (\n ModInt(pow(self.x, other.x, MOD)) if isinstance(other, ModInt) else\n ModInt(pow(self.x, other, MOD))\n )\n\n __radd__ = __add__\n\n def __rsub__(self, other):\n return (\n ModInt(other.x - self.x) if isinstance(other, ModInt) else\n ModInt(other - self.x)\n )\n\n __rmul__ = __mul__\n\n def __rtruediv__(self, other):\n return (\n ModInt(\n other.x * pow(self.x, MOD - 2, MOD)\n ) if isinstance(other, ModInt) else\n ModInt(other * pow(self.x, MOD - 2, MOD))\n )\n\n def __rpow__(self, other):\n return (\n ModInt(pow(other.x, self.x, MOD)) if isinstance(other, ModInt) else\n ModInt(pow(other, self.x, MOD))\n )", "class ModInt:\n def __init__(self, x):\n self.x = x % MOD\n\n def __str__(self):\n return str(self.x)\n\n __repr__ = __str__\n\n def __add__(self, other):\n return (\n ModInt(self.x + other.x) if isinstance(other, ModInt) else\n ModInt(self.x + other)\n )\n\n def __sub__(self, other):\n return (\n ModInt(self.x - other.x) if isinstance(other, ModInt) else\n ModInt(self.x - other)\n )\n\n def __mul__(self, other):\n return (\n ModInt(self.x * other.x) if isinstance(other, ModInt) else\n ModInt(self.x * other)\n )\n\n def __truediv__(self, other):\n return (\n ModInt(\n self.x * pow(other.x, MOD - 2, MOD)\n ) if isinstance(other, ModInt) else\n ModInt(self.x * pow(other, MOD - 2, MOD))\n )\n\n def __pow__(self, other):\n return (\n ModInt(pow(self.x, other.x, MOD)) if isinstance(other, ModInt) else\n ModInt(pow(self.x, other, MOD))\n )\n\n __radd__ = __add__\n\n def __rsub__(self, other):\n return (\n ModInt(other.x - self.x) if isinstance(other, ModInt) else\n ModInt(other - self.x)\n )\n\n __rmul__ = __mul__\n\n def __rtruediv__(self, other):\n return (\n ModInt(\n other.x * pow(self.x, MOD - 2, MOD)\n ) if isinstance(other, ModInt) else\n ModInt(other * pow(self.x, MOD - 2, MOD))\n )\n\n def __rpow__(self, other):\n return (\n ModInt(pow(other.x, self.x, MOD)) if isinstance(other, ModInt) else\n ModInt(pow(other, self.x, MOD))\n )", "ModInt", "h,w,a,b=map(int,input().split())", "map(int,input().split())", "h", "ans=ModInt(0)", "ModInt(0)", "ans", "ans+=com1[i-b-1]*com2[i-b-1]", "com1[i-b-1]*com2[i-b-1]", "ans", "def com(n, k, mod):\n a=framod(n, mod)\n b=framod(k, mod)\n c=framod(n-k, mod)\n return (a * pow(b, mod-2, mod) * pow(c, mod-2, mod)) % mod", "def com(n, k, mod):\n a=framod(n, mod)\n b=framod(k, mod)\n c=framod(n-k, mod)\n return (a * pow(b, mod-2, mod) * pow(c, mod-2, mod)) % mod", "com", "com1=[ModInt(0) for i in range(w-b)]", "[ModInt(0) for i in range(w-b)]", "com1", "MOD=10**9+7", "10**9+7", "MOD", "mod=10**9+7", "10**9+7", "mod", "def framod(n, mod, a=1):\n for i in range(1,n+1):\n a=a * i % mod\n return a", "def framod(n, mod, a=1):\n for i in range(1,n+1):\n a=a * i % mod\n return a", "framod", "a,b=map(int,input().split())", "map(int,input().split())", "a" ]

[ 7, 15, 15, 15, 13, 15, 13, 15, 13, 15, 13, 12, 13, 12, 13, 12, 13, 12, 13, 41, 28, 13, 4, 13, 13, 4, 4, 13, 12, 13, 23, 13, 41, 28, 13, 4, 13, 13, 4, 4, 13, 12, 13, 23, 13, 41, 28, 13, 4, 13, 13, 4, 4, 13, 12, 13, 23, 13, 41, 28, 13, 4, 13, 13, 4, 4, 13, 12, 13, 23, 13, 0, 13, 17, 17, 0, 13, 4, 13, 13, 13, 13, 0, 13, 17, 0, 13, 17, 41, 28, 13, 4, 13, 2, 2, 13, 13, 17, 4, 4, 13, 13, 2, 13, 17, 13, 0, 13, 13, 0, 13, 2, 13, 17, 0, 13, 2, 13, 17, 28, 13, 4, 13, 4, 13, 2, 13, 17, 2, 13, 13, 0, 13, 2, 2, 2, 2, 2, 2, 13, 17, 13, 13, 13, 18, 13, 2, 13, 17, 13, 0, 13, 13, 28, 13, 4, 13, 4, 13, 2, 13, 17, 2, 13, 13, 0, 13, 2, 2, 2, 2, 2, 2, 13, 17, 13, 13, 13, 18, 13, 2, 13, 17, 13, 0, 13, 13, 28, 13, 4, 13, 17, 2, 4, 13, 2, 13, 13, 2, 13, 13, 17, 0, 13, 13, 0, 13, 13, 0, 13, 2, 2, 2, 2, 2, 13, 13, 2, 13, 13, 18, 13, 13, 18, 13, 13, 13, 0, 13, 13, 0, 13, 17, 0, 13, 17, 4, 13, 13, 10, 4, 13, 10, 12, 13, 10, 13, 13, 10, 2, 13, 10, 13, 13, 10, 12, 13, 10, 12, 13, 10, 12, 13, 10, 4, 13, 10, 12, 13, 10, 17, 13, 10, 2, 13, 10, 4, 13, 10, 2, 13, 10, 17, 13, 10, 13, 13, 10, 13, 13, 10, 2, 13, 10, 4, 13, 10, 17, 13, 10, 17, 13, 10, 12, 13, 10, 2, 13, 10, 13, 13, 10, 17, 13, 10, 12, 13, 10, 13, 13, 10, 12, 13 ]

[ [ 22, 21 ], [ 244, 27 ], [ 31, 31 ], [ 35, 34 ], [ 256, 40 ], [ 44, 44 ], [ 48, 47 ], [ 316, 53 ], [ 57, 57 ], [ 61, 60 ], [ 322, 66 ], [ 70, 70 ], [ 270, 72 ], [ 294, 76 ], [ 256, 78 ], [ 294, 79 ], [ 294, 80 ], [ 294, 81 ], [ 282, 83 ], [ 297, 86 ], [ 91, 90 ], [ 265, 95 ], [ 241, 96 ], [ 90, 101 ], [ 271, 103 ], [ 271, 105 ], [ 252, 107 ], [ 279, 110 ], [ 295, 112 ], [ 306, 115 ], [ 277, 117 ], [ 121, 120 ], [ 280, 126 ], [ 265, 129 ], [ 307, 130 ], [ 291, 132 ], [ 280, 139 ], [ 265, 141 ], [ 307, 142 ], [ 120, 143 ], [ 253, 145 ], [ 120, 147 ], [ 271, 149 ], [ 318, 151 ], [ 271, 152 ], [ 155, 154 ], [ 307, 160 ], [ 241, 163 ], [ 280, 164 ], [ 273, 166 ], [ 307, 173 ], [ 241, 175 ], [ 280, 176 ], [ 154, 177 ], [ 253, 179 ], [ 154, 181 ], [ 271, 183 ], [ 285, 185 ], [ 271, 186 ], [ 189, 188 ], [ 241, 196 ], [ 295, 197 ], [ 265, 199 ], [ 277, 200 ], [ 246, 203 ], [ 286, 204 ], [ 274, 204 ], [ 319, 204 ], [ 292, 204 ], [ 298, 204 ], [ 289, 204 ], [ 250, 204 ], [ 309, 206 ], [ 271, 207 ], [ 249, 209 ], [ 265, 215 ], [ 307, 216 ], [ 313, 216 ], [ 241, 218 ], [ 280, 219 ], [ 301, 219 ], [ 253, 221 ], [ 280, 222 ], [ 301, 222 ], [ 253, 224 ], [ 307, 225 ], [ 313, 225 ], [ 271, 226 ], [ 288, 228 ], [ 271, 229 ], [ 300, 231 ], [ 312, 234 ], [ 310, 238 ], [ 247, 238 ], [ 283, 238 ], [ 294, 241 ], [ 286, 246 ], [ 274, 246 ], [ 319, 246 ], [ 292, 246 ], [ 298, 246 ], [ 289, 246 ], [ 250, 246 ], [ 246, 247 ], [ 249, 250 ], [ 252, 253 ], [ 294, 265 ], [ 270, 271 ], [ 273, 274 ], [ 294, 277 ], [ 279, 280 ], [ 282, 283 ], [ 271, 285 ], [ 285, 286 ], [ 271, 288 ], [ 288, 289 ], [ 291, 292 ], [ 294, 295 ], [ 297, 298 ], [ 300, 301 ], [ 306, 307 ], [ 271, 309 ], [ 309, 310 ], [ 312, 313 ], [ 271, 318 ], [ 318, 319 ] ]

[ "#!usr/bin/env python3\nfrom collections import defaultdict\nfrom heapq import heappush, heappop\nimport sys\nimport math\nimport bisect\nimport random\ndef LI(): return list(map(int, sys.stdin.readline().split()))\ndef I(): return int(sys.stdin.readline())\ndef LS(): return list(map(list, sys.stdin.readline().split()))\ndef S(): return list(sys.stdin.readline())[:-1]\ndef IR(n): return [I() for i in range(n)]\ndef LIR(n): return [LI() for i in range(n)]\ndef SR(n): return [S() for i in range(n)]\ndef LSR(n): return [LS() for i in range(n)]\nmod = 1000000007\n\n\n#A\n\"\"\"\ndef check(n):\n n = list(map(int,list(str(n))))\n s = 0\n for i in n:\n s += f[i]\n return s == 0\nn,k = LI()\nd = LI()\nf = [0 for i in range(10)]\nfor i in d:\n f[i] = 1\nwhile 1:\n if check(n):\n print(n)\n quit()\n n += 1\n\"\"\"\n#B\nh,w,a,b = LI()\nans = 0\nk = 1\ninv = [pow(i,mod-2,mod) for i in range(h+w+1)]\nx = b+1\ny = a+1\nfor i in range(min(x-1,h-y)):\n k *= (x-1+h-y-i)*inv[i+1]%mod\n k %= mod\nfor i in range(min(y-1,w-x)):\n k *= (y-1+w-x-i)*inv[i+1]%mod\n k %= mod\nfor i in range(1,min(w-b,h-a)+1):\n ans += k\n ans %= mod\n k *= (h-y)*(w-x)*inv[x]*inv[y]%mod\n k %= mod\n x += 1\n y += 1\nprint(ans)\n#C\n\n#D\n\n#E\n\n#F\n\n#G\n\n#H\n\n#I\n\n#J\n\n#K\n\n#L\n\n#M\n\n#N\n\n#O\n\n#P\n\n#Q\n\n#R\n\n#S\n\n#T", "from collections import defaultdict", "from heapq import heappush, heappop", "import sys", "sys", "import math", "math", "import bisect", "bisect", "import random", "random", "def LI(): return list(map(int, sys.stdin.readline().split()))", "LI", "def I(): return int(sys.stdin.readline())", "I", "def LS(): return list(map(list, sys.stdin.readline().split()))", "LS", "def S(): return list(sys.stdin.readline())[:-1]", "S", "I() for i in range(n)", "for i in range(n)", "i", "range(n)", "range", "n", "for i in range(n)", "I()", "I", "def IR(n): return [I() for i in range(n)]", "IR", "n", "n", "LI() for i in range(n)", "for i in range(n)", "i", "range(n)", "range", "n", "for i in range(n)", "LI()", "LI", "def LIR(n): return [LI() for i in range(n)]", "LIR", "n", "n", "S() for i in range(n)", "for i in range(n)", "i", "range(n)", "range", "n", "for i in range(n)", "S()", "S", "def SR(n): return [S() for i in range(n)]", "SR", "n", "n", "LS() for i in range(n)", "for i in range(n)", "i", "range(n)", "range", "n", "for i in range(n)", "LS()", "LS", "def LSR(n): return [LS() for i in range(n)]", "LSR", "n", "n", "mod = 1000000007", "mod", "1000000007", "\"\"\"\ndef check(n):\n n = list(map(int,list(str(n))))\n s = 0\n for i in n:\n s += f[i]\n return s == 0\nn,k = LI()\nd = LI()\nf = [0 for i in range(10)]\nfor i in d:\n f[i] = 1\nwhile 1:\n if check(n):\n print(n)\n quit()\n n += 1\n\"\"\"", "h,w,a,b = LI()", "h", "LI()", "LI", "w", "a", "b", "ans = 0", "ans", "0", "k = 1", "k", "1", "pow(i,mod-2,mod) for i in range(h+w+1)", "for i in range(h+w+1)", "i", "range(h+w+1)", "range", "h+w+1", "h+w", "h", "w", "1", "for i in range(h+w+1)", "pow(i,mod-2,mod)", "pow", "i", "mod-2", "mod", "2", "mod", "inv = [pow(i,mod-2,mod) for i in range(h+w+1)]", "inv", "[pow(i,mod-2,mod) for i in range(h+w+1)]", "x = b+1", "x", "b+1", "b", "1", "y = a+1", "y", "a+1", "a", "1", "for i in range(min(x-1,h-y)):\n k *= (x-1+h-y-i)*inv[i+1]%mod\n k %= mod", "i", "range(min(x-1,h-y))", "range", "min(x-1,h-y)", "min", "x-1", "x", "1", "h-y", "h", "y", "k *= (x-1+h-y-i)*inv[i+1]%mod", "k", "(x-1+h-y-i)*inv[i+1]%mod", "(x-1+h-y-i)*inv[i+1]", "x-1+h-y-i", "x-1+h-y", "x-1+h", "x-1", "x", "1", "h", "y", "i", "inv[i+1]", "inv", "i+1", "i", "1", "mod", "k %= mod", "k", "mod", "for i in range(min(y-1,w-x)):\n k *= (y-1+w-x-i)*inv[i+1]%mod\n k %= mod", "i", "range(min(y-1,w-x))", "range", "min(y-1,w-x)", "min", "y-1", "y", "1", "w-x", "w", "x", "k *= (y-1+w-x-i)*inv[i+1]%mod", "k", "(y-1+w-x-i)*inv[i+1]%mod", "(y-1+w-x-i)*inv[i+1]", "y-1+w-x-i", "y-1+w-x", "y-1+w", "y-1", "y", "1", "w", "x", "i", "inv[i+1]", "inv", "i+1", "i", "1", "mod", "k %= mod", "k", "mod", "for i in range(1,min(w-b,h-a)+1):\n ans += k\n ans %= mod\n k *= (h-y)*(w-x)*inv[x]*inv[y]%mod\n k %= mod\n x += 1\n y += 1", "i", "range(1,min(w-b,h-a)+1)", "range", "1", "min(w-b,h-a)+1", "min(w-b,h-a)", "min", "w-b", "w", "b", "h-a", "h", "a", "1", "ans += k", "ans", "k", "ans %= mod", "ans", "mod", "k *= (h-y)*(w-x)*inv[x]*inv[y]%mod", "k", "(h-y)*(w-x)*inv[x]*inv[y]%mod", "(h-y)*(w-x)*inv[x]*inv[y]", "(h-y)*(w-x)*inv[x]", "(h-y)*(w-x)", "h-y", "h", "y", "w-x", "w", "x", "inv[x]", "inv", "x", "inv[y]", "inv", "y", "mod", "k %= mod", "k", "mod", "x += 1", "x", "1", "y += 1", "y", "1", "print(ans)", "print", "ans", "w,a,b = LI()", "LI()", "w", "def I(): return int(sys.stdin.readline())", "def I(): return int(sys.stdin.readline())", "I", "ans += k", "k", "ans", "k *= (h-y)*(w-x)*inv[x]*inv[y]%mod", "(h-y)*(w-x)*inv[x]*inv[y]%mod", "k", "inv = [pow(i,mod-2,mod) for i in range(h+w+1)]", "[pow(i,mod-2,mod) for i in range(h+w+1)]", "inv", "def LI(): return list(map(int, sys.stdin.readline().split()))", "def LI(): return list(map(int, sys.stdin.readline().split()))", "LI", "def LSR(n): return [LS() for i in range(n)]", "def LSR(n): return [LS() for i in range(n)]", "LSR", "def SR(n): return [S() for i in range(n)]", "def SR(n): return [S() for i in range(n)]", "SR", "h,w,a,b = LI()", "LI()", "h", "def LIR(n): return [LI() for i in range(n)]", "def LIR(n): return [LI() for i in range(n)]", "LIR", "mod = 1000000007", "1000000007", "mod", "k *= (y-1+w-x-i)*inv[i+1]%mod", "(y-1+w-x-i)*inv[i+1]%mod", "k", "a,b = LI()", "LI()", "a", "x = b+1", "b+1", "x", "ans = 0", "0", "ans", "k %= mod", "mod", "k", "k %= mod", "mod", "k", "k *= (x-1+h-y-i)*inv[i+1]%mod", "(x-1+h-y-i)*inv[i+1]%mod", "k", "b = LI()", "LI()", "b", "k = 1", "1", "k", "x += 1", "1", "x", "def IR(n): return [I() for i in range(n)]", "def IR(n): return [I() for i in range(n)]", "IR", "y = a+1", "a+1", "y", "ans %= mod", "mod", "ans", "y += 1", "1", "y", "def S(): return list(sys.stdin.readline())[:-1]", "def S(): return list(sys.stdin.readline())[:-1]", "S", "k %= mod", "mod", "k", "def LS(): return list(map(list, sys.stdin.readline().split()))", "def LS(): return list(map(list, sys.stdin.readline().split()))", "LS" ]

[ 7, 0, 13, 2, 2, 17, 17, 17, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 13, 13, 0, 13, 2, 2, 13, 13, 17, 0, 13, 17, 0, 13, 2, 39, 17, 2, 13, 17, 0, 13, 2, 39, 17, 2, 13, 17, 28, 13, 4, 13, 17, 2, 13, 17, 0, 18, 13, 13, 2, 2, 13, 18, 13, 2, 13, 17, 13, 28, 13, 4, 13, 17, 2, 13, 17, 0, 18, 13, 13, 4, 13, 18, 13, 13, 2, 13, 17, 13, 12, 13, 0, 13, 2, 2, 2, 18, 13, 2, 13, 13, 18, 13, 13, 18, 13, 13, 13, 29, 13, 23, 13, 23, 13, 28, 13, 4, 13, 13, 13, 0, 13, 2, 4, 13, 13, 2, 2, 13, 13, 17, 4, 13, 2, 2, 13, 17, 13, 2, 13, 17, 0, 13, 13, 4, 13, 13, 10, 2, 13, 10, 4, 13, 10, 2, 13, 10, 4, 13, 10, 2, 13, 10, 4, 13, 10, 2, 13, 10, 13, 13, 10, 17, 13, 10, 2, 13, 10, 12, 13, 10, 4, 13 ]

[ [ 154, 2 ], [ 181, 9 ], [ 181, 18 ], [ 181, 19 ], [ 181, 20 ], [ 166, 22 ], [ 152, 25 ], [ 158, 26 ], [ 172, 29 ], [ 175, 32 ], [ 167, 37 ], [ 148, 40 ], [ 167, 45 ], [ 49, 48 ], [ 167, 53 ], [ 59, 56 ], [ 176, 57 ], [ 48, 58 ], [ 48, 61 ], [ 176, 63 ], [ 48, 65 ], [ 155, 67 ], [ 70, 69 ], [ 167, 74 ], [ 80, 77 ], [ 149, 78 ], [ 69, 79 ], [ 56, 82 ], [ 176, 83 ], [ 69, 84 ], [ 155, 86 ], [ 155, 88 ], [ 93, 92 ], [ 176, 97 ], [ 111, 99 ], [ 113, 100 ], [ 149, 102 ], [ 111, 103 ], [ 149, 105 ], [ 113, 106 ], [ 155, 107 ], [ 92, 109 ], [ 111, 111 ], [ 113, 113 ], [ 116, 115 ], [ 182, 118 ], [ 158, 119 ], [ 160, 121 ], [ 179, 124 ], [ 115, 125 ], [ 152, 128 ], [ 164, 129 ], [ 179, 132 ], [ 158, 135 ], [ 115, 137 ], [ 164, 139 ], [ 169, 142 ], [ 155, 143 ], [ 170, 146 ], [ 161, 146 ], [ 173, 146 ], [ 148, 149 ], [ 181, 152 ], [ 154, 155 ], [ 181, 158 ], [ 160, 161 ], [ 181, 164 ], [ 166, 167 ], [ 155, 169 ], [ 169, 170 ], [ 172, 173 ], [ 175, 176 ], [ 181, 182 ] ]

[ "mod = 10**9+7\nh, w, a, b = map(int, input().split())\n\nn = h+w-2\n\nans = 0\nfac = [1]*(n+1)\ninv = [1]*(n+1)\n\nfor i in range(1, n+1):\n fac[i] = i*fac[i-1] % mod\n\nfor i in range(1, n+1):\n inv[i] = pow(fac[i], mod-2, mod)\n\ndef func(x, y):\n m = fac[x+y]*inv[x]*inv[y]%mod\n return m\n\nfor x in range(b, w):\n ans += func(x, h-a-1)*func(w-1-x, a-1)\n ans %= mod\n\nprint(ans)", "mod = 10**9+7", "mod", "10**9+7", "10**9", "10", "9", "7", "h, w, a, b = map(int, input().split())", "h", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "w", "a", "b", "n = h+w-2", "n", "h+w-2", "h+w", "h", "w", "2", "ans = 0", "ans", "0", "fac = [1]*(n+1)", "fac", "[1]*(n+1)", "[1]", "1", "n+1", "n", "1", "inv = [1]*(n+1)", "inv", "[1]*(n+1)", "[1]", "1", "n+1", "n", "1", "for i in range(1, n+1):\n fac[i] = i*fac[i-1] % mod", "i", "range(1, n+1)", "range", "1", "n+1", "n", "1", "fac[i] = i*fac[i-1] % mod", "fac[i]", "fac", "i", "i*fac[i-1] % mod", "i*fac[i-1]", "i", "fac[i-1]", "fac", "i-1", "i", "1", "mod", "for i in range(1, n+1):\n inv[i] = pow(fac[i], mod-2, mod)", "i", "range(1, n+1)", "range", "1", "n+1", "n", "1", "inv[i] = pow(fac[i], mod-2, mod)", "inv[i]", "inv", "i", "pow(fac[i], mod-2, mod)", "pow", "fac[i]", "fac", "i", "mod-2", "mod", "2", "mod", "def func(x, y):\n m = fac[x+y]*inv[x]*inv[y]%mod\n return m", "func", "m = fac[x+y]*inv[x]*inv[y]%mod", "m", "fac[x+y]*inv[x]*inv[y]%mod", "fac[x+y]*inv[x]*inv[y]", "fac[x+y]*inv[x]", "fac[x+y]", "fac", "x+y", "x", "y", "inv[x]", "inv", "x", "inv[y]", "inv", "y", "mod", "return m", "m", "x", "x", "y", "y", "for x in range(b, w):\n ans += func(x, h-a-1)*func(w-1-x, a-1)\n ans %= mod", "x", "range(b, w)", "range", "b", "w", "ans += func(x, h-a-1)*func(w-1-x, a-1)", "ans", "func(x, h-a-1)*func(w-1-x, a-1)", "func(x, h-a-1)", "func", "x", "h-a-1", "h-a", "h", "a", "1", "func(w-1-x, a-1)", "func", "w-1-x", "w-1", "w", "1", "x", "a-1", "a", "1", "ans %= mod", "ans", "mod", "print(ans)", "print", "ans", "inv = [1]*(n+1)", "[1]*(n+1)", "inv", "h, w, a, b = map(int, input().split())", "map(int, input().split())", "h", "mod = 10**9+7", "10**9+7", "mod", "w, a, b = map(int, input().split())", "map(int, input().split())", "w", "ans += func(x, h-a-1)*func(w-1-x, a-1)", "func(x, h-a-1)*func(w-1-x, a-1)", "ans", "a, b = map(int, input().split())", "map(int, input().split())", "a", "n = h+w-2", "h+w-2", "n", "ans %= mod", "mod", "ans", "ans = 0", "0", "ans", "fac = [1]*(n+1)", "[1]*(n+1)", "fac", "def func(x, y):\n m = fac[x+y]*inv[x]*inv[y]%mod\n return m", "def func(x, y):\n m = fac[x+y]*inv[x]*inv[y]%mod\n return m", "func", "b = map(int, input().split())", "map(int, input().split())", "b" ]

[ 7, 15, 13, 15, 13, 15, 13, 15, 13, 15, 15, 13, 0, 13, 2, 2, 17, 17, 17, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 13, 13, 12, 13, 0, 13, 2, 2, 18, 13, 2, 13, 13, 18, 13, 13, 13, 29, 2, 2, 18, 13, 13, 4, 13, 13, 2, 13, 17, 13, 13, 23, 13, 23, 13, 0, 13, 39, 17, 28, 13, 4, 13, 2, 13, 13, 4, 18, 13, 13, 2, 2, 18, 13, 17, 2, 13, 17, 13, 0, 13, 17, 28, 13, 4, 13, 2, 13, 13, 0, 13, 2, 4, 13, 2, 2, 2, 2, 13, 13, 17, 13, 13, 2, 13, 13, 4, 13, 2, 2, 2, 2, 13, 13, 13, 17, 13, 2, 13, 17, 0, 13, 2, 13, 13, 0, 13, 13, 4, 13, 13, 10, 4, 13, 10, 12, 13, 10, 2, 13, 10, 2, 13, 10, 4, 13, 10, 39, 13, 10, 13, 13, 10, 4, 13, 10, 4, 13, 10, 17, 13, 10, 2, 13 ]

[ [ 148, 13 ], [ 166, 20 ], [ 166, 29 ], [ 166, 30 ], [ 166, 31 ], [ 36, 35 ], [ 62, 41 ], [ 64, 42 ], [ 64, 45 ], [ 149, 46 ], [ 62, 52 ], [ 35, 55 ], [ 149, 57 ], [ 149, 59 ], [ 149, 60 ], [ 62, 62 ], [ 64, 64 ], [ 157, 66 ], [ 71, 70 ], [ 143, 74 ], [ 155, 75 ], [ 158, 78 ], [ 158, 83 ], [ 70, 86 ], [ 149, 88 ], [ 169, 90 ], [ 94, 93 ], [ 155, 97 ], [ 164, 98 ], [ 151, 100 ], [ 146, 103 ], [ 143, 108 ], [ 167, 109 ], [ 164, 111 ], [ 93, 112 ], [ 164, 114 ], [ 93, 115 ], [ 146, 117 ], [ 155, 122 ], [ 164, 123 ], [ 93, 124 ], [ 167, 126 ], [ 167, 128 ], [ 172, 131 ], [ 152, 133 ], [ 149, 134 ], [ 160, 136 ], [ 149, 137 ], [ 161, 140 ], [ 173, 140 ], [ 170, 140 ], [ 166, 143 ], [ 148, 149 ], [ 151, 152 ], [ 166, 155 ], [ 157, 158 ], [ 149, 160 ], [ 160, 161 ], [ 166, 164 ], [ 166, 167 ], [ 169, 170 ], [ 172, 173 ] ]

[ "#coding: utf-8\nimport math\nimport heapq\nimport bisect\nimport numpy as np\nfrom collections import Counter, deque\nimport itertools\n#from scipy.misc import comb\n\nMOD = 10**9+7\nH,W,A,B = map(int,input().split())\n\ndef comb(a,b):\n\tp = fac[a-b]*fac[b]%MOD\n\treturn fac[a]*pow(p,MOD-2,MOD)%MOD\n\nfac=[1]\nfor i in range(H+W):\n\tfac.append(fac[-1]*(i+1)%MOD)\n\nans=0\nfor i in range(W-B):\n\tp = comb(H-A-1+B+i,B+i)*comb(W-B-i-2+A,A-1)\n\tans += p%MOD\n\tans %= MOD\n\nprint(ans)", "import math", "math", "import heapq", "heapq", "import bisect", "bisect", "import numpy as np", "numpy", "from collections import Counter, deque", "import itertools", "itertools", "MOD = 10**9+7", "MOD", "10**9+7", "10**9", "10", "9", "7", "H,W,A,B = map(int,input().split())", "H", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "W", "A", "B", "def comb(a,b):\n\tp = fac[a-b]*fac[b]%MOD\n\treturn fac[a]*pow(p,MOD-2,MOD)%MOD", "comb", "p = fac[a-b]*fac[b]%MOD", "p", "fac[a-b]*fac[b]%MOD", "fac[a-b]*fac[b]", "fac[a-b]", "fac", "a-b", "a", "b", "fac[b]", "fac", "b", "MOD", "return fac[a]*pow(p,MOD-2,MOD)%MOD", "fac[a]*pow(p,MOD-2,MOD)%MOD", "fac[a]*pow(p,MOD-2,MOD)", "fac[a]", "fac", "a", "pow(p,MOD-2,MOD)", "pow", "p", "MOD-2", "MOD", "2", "MOD", "MOD", "a", "a", "b", "b", "fac=[1]", "fac", "[1]", "1", "for i in range(H+W):\n\tfac.append(fac[-1]*(i+1)%MOD)", "i", "range(H+W)", "range", "H+W", "H", "W", "fac.append(fac[-1]*(i+1)%MOD)", "fac.append", "fac", "append", "fac[-1]*(i+1)%MOD", "fac[-1]*(i+1)", "fac[-1]", "fac", "-1", "i+1", "i", "1", "MOD", "ans=0", "ans", "0", "for i in range(W-B):\n\tp = comb(H-A-1+B+i,B+i)*comb(W-B-i-2+A,A-1)\n\tans += p%MOD\n\tans %= MOD", "i", "range(W-B)", "range", "W-B", "W", "B", "p = comb(H-A-1+B+i,B+i)*comb(W-B-i-2+A,A-1)", "p", "comb(H-A-1+B+i,B+i)*comb(W-B-i-2+A,A-1)", "comb(H-A-1+B+i,B+i)", "comb", "H-A-1+B+i", "H-A-1+B", "H-A-1", "H-A", "H", "A", "1", "B", "i", "B+i", "B", "i", "comb(W-B-i-2+A,A-1)", "comb", "W-B-i-2+A", "W-B-i-2", "W-B-i", "W-B", "W", "B", "i", "2", "A", "A-1", "A", "1", "ans += p%MOD", "ans", "p%MOD", "p", "MOD", "ans %= MOD", "ans", "MOD", "print(ans)", "print", "ans", "H,W,A,B = map(int,input().split())", "map(int,input().split())", "H", "def comb(a,b):\n\tp = fac[a-b]*fac[b]%MOD\n\treturn fac[a]*pow(p,MOD-2,MOD)%MOD", "def comb(a,b):\n\tp = fac[a-b]*fac[b]%MOD\n\treturn fac[a]*pow(p,MOD-2,MOD)%MOD", "comb", "MOD = 10**9+7", "10**9+7", "MOD", "p = comb(H-A-1+B+i,B+i)*comb(W-B-i-2+A,A-1)", "comb(H-A-1+B+i,B+i)*comb(W-B-i-2+A,A-1)", "p", "W,A,B = map(int,input().split())", "map(int,input().split())", "W", "fac=[1]", "[1]", "fac", "ans %= MOD", "MOD", "ans", "B = map(int,input().split())", "map(int,input().split())", "B", "A,B = map(int,input().split())", "map(int,input().split())", "A", "ans=0", "0", "ans", "ans += p%MOD", "p%MOD", "ans" ]

[ 7, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 13, 13, 0, 13, 2, 2, 17, 17, 17, 41, 28, 13, 4, 13, 2, 2, 13, 13, 17, 4, 17, 0, 13, 13, 28, 13, 4, 13, 17, 2, 2, 13, 13, 17, 0, 18, 13, 13, 2, 2, 18, 13, 2, 13, 17, 13, 13, 41, 28, 13, 13, 4, 4, 13, 13, 2, 13, 17, 13, 0, 13, 13, 12, 13, 0, 13, 2, 2, 18, 13, 2, 13, 13, 18, 13, 13, 18, 13, 13, 29, 2, 13, 13, 23, 13, 23, 13, 14, 2, 2, 13, 13, 13, 0, 13, 17, 28, 13, 4, 13, 2, 13, 13, 0, 13, 2, 2, 4, 13, 13, 2, 13, 17, 4, 13, 2, 2, 13, 13, 17, 2, 2, 13, 13, 17, 13, 0, 13, 4, 13, 2, 13, 17, 2, 13, 17, 28, 13, 4, 13, 13, 0, 13, 2, 2, 4, 13, 2, 2, 13, 13, 17, 13, 4, 13, 2, 13, 17, 2, 2, 13, 13, 17, 13, 4, 13, 2, 13, 13, 10, 4, 13, 10, 13, 13, 10, 4, 13, 10, 4, 13, 10, 4, 13, 10, 13, 13, 10, 17, 13, 10, 2, 13, 10, 2, 13, 10, 4, 13, 10, 2, 13, 10, 12, 13 ]

[ [ 194, 2 ], [ 194, 11 ], [ 194, 12 ], [ 194, 13 ], [ 206, 15 ], [ 24, 23 ], [ 183, 28 ], [ 192, 29 ], [ 197, 34 ], [ 38, 37 ], [ 183, 43 ], [ 192, 44 ], [ 50, 47 ], [ 198, 48 ], [ 37, 49 ], [ 198, 53 ], [ 37, 55 ], [ 37, 57 ], [ 207, 58 ], [ 62, 61 ], [ 198, 61 ], [ 61, 66 ], [ 207, 68 ], [ 207, 70 ], [ 185, 72 ], [ 78, 77 ], [ 198, 81 ], [ 96, 83 ], [ 98, 84 ], [ 186, 86 ], [ 96, 87 ], [ 186, 89 ], [ 98, 90 ], [ 77, 93 ], [ 96, 93 ], [ 207, 94 ], [ 96, 96 ], [ 98, 98 ], [ 183, 102 ], [ 195, 103 ], [ 189, 104 ], [ 200, 106 ], [ 110, 109 ], [ 183, 113 ], [ 195, 114 ], [ 212, 116 ], [ 216, 120 ], [ 109, 121 ], [ 189, 123 ], [ 216, 126 ], [ 183, 129 ], [ 109, 130 ], [ 192, 134 ], [ 189, 135 ], [ 207, 137 ], [ 209, 139 ], [ 216, 141 ], [ 183, 143 ], [ 192, 146 ], [ 150, 149 ], [ 189, 152 ], [ 203, 154 ], [ 216, 158 ], [ 183, 161 ], [ 195, 162 ], [ 149, 164 ], [ 216, 166 ], [ 195, 168 ], [ 192, 172 ], [ 149, 173 ], [ 207, 175 ], [ 204, 179 ], [ 213, 179 ], [ 201, 179 ], [ 210, 179 ], [ 207, 180 ], [ 194, 183 ], [ 185, 186 ], [ 194, 189 ], [ 194, 192 ], [ 194, 195 ], [ 197, 198 ], [ 200, 201 ], [ 203, 204 ], [ 206, 207 ], [ 209, 210 ], [ 212, 213 ] ]

[ "H, W, A, B = map(int, input().split())\np = 10 ** 9 + 7\nF = [1 for i in range(H + W + 1)]\nfor i in range(1, H + W + 1):\n F[i] = F[i - 1] * i % p\nFi = [pow(f, p - 2, p) for f in F]\ndef fac(a, b):\n a = F[a + b] * Fi[a] * Fi[b]\n return a % p\nif H - A < B:\n ans = 0\n for h in range(H - A):\n ans += fac(h, B - 1) * fac(H - h - 1, W - B - 1) % p\nelse:\n ans = fac(H - 1, W- 1)\n for w in range(B):\n ans -= fac(H - A - 1, w) * fac(A - 1, W - w - 1) % p\nprint(ans % p)", "H, W, A, B = map(int, input().split())", "H", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "W", "A", "B", "p = 10 ** 9 + 7", "p", "10 ** 9 + 7", "10 ** 9", "10", "9", "7", "1 for i in range(H + W + 1)", "for i in range(H + W + 1)", "i", "range(H + W + 1)", "range", "H + W + 1", "H + W", "H", "W", "1", "for i in range(H + W + 1)", "1", "F = [1 for i in range(H + W + 1)]", "F", "[1 for i in range(H + W + 1)]", "for i in range(1, H + W + 1):\n F[i] = F[i - 1] * i % p", "i", "range(1, H + W + 1)", "range", "1", "H + W + 1", "H + W", "H", "W", "1", "F[i] = F[i - 1] * i % p", "F[i]", "F", "i", "F[i - 1] * i % p", "F[i - 1] * i", "F[i - 1]", "F", "i - 1", "i", "1", "i", "p", "pow(f, p - 2, p) for f in F", "for f in F", "f", "F", "for f in F", "pow(f, p - 2, p)", "pow", "f", "p - 2", "p", "2", "p", "Fi = [pow(f, p - 2, p) for f in F]", "Fi", "[pow(f, p - 2, p) for f in F]", "def fac(a, b):\n a = F[a + b] * Fi[a] * Fi[b]\n return a % p", "fac", "a = F[a + b] * Fi[a] * Fi[b]", "a", "F[a + b] * Fi[a] * Fi[b]", "F[a + b] * Fi[a]", "F[a + b]", "F", "a + b", "a", "b", "Fi[a]", "Fi", "a", "Fi[b]", "Fi", "b", "return a % p", "a % p", "a", "p", "a", "a", "b", "b", "if H - A < B:\n ans = 0\n for h in range(H - A):\n ans += fac(h, B - 1) * fac(H - h - 1, W - B - 1) % p\nelse:\n ans = fac(H - 1, W- 1)\n for w in range(B):\n ans -= fac(H - A - 1, w) * fac(A - 1, W - w - 1) % p", "H - A < B", "H - A", "H", "A", "B", "ans = 0", "ans", "0", "for h in range(H - A):\n ans += fac(h, B - 1) * fac(H - h - 1, W - B - 1) % p", "h", "range(H - A)", "range", "H - A", "H", "A", "ans += fac(h, B - 1) * fac(H - h - 1, W - B - 1) % p", "ans", "fac(h, B - 1) * fac(H - h - 1, W - B - 1) % p", "fac(h, B - 1) * fac(H - h - 1, W - B - 1)", "fac(h, B - 1)", "fac", "h", "B - 1", "B", "1", "fac(H - h - 1, W - B - 1)", "fac", "H - h - 1", "H - h", "H", "h", "1", "W - B - 1", "W - B", "W", "B", "1", "p", "ans = fac(H - 1, W- 1)", "ans", "fac(H - 1, W- 1)", "fac", "H - 1", "H", "1", "W- 1", "W", "1", "for w in range(B):\n ans -= fac(H - A - 1, w) * fac(A - 1, W - w - 1) % p", "w", "range(B)", "range", "B", "ans -= fac(H - A - 1, w) * fac(A - 1, W - w - 1) % p", "ans", "fac(H - A - 1, w) * fac(A - 1, W - w - 1) % p", "fac(H - A - 1, w) * fac(A - 1, W - w - 1)", "fac(H - A - 1, w)", "fac", "H - A - 1", "H - A", "H", "A", "1", "w", "fac(A - 1, W - w - 1)", "fac", "A - 1", "A", "1", "W - w - 1", "W - w", "W", "w", "1", "p", "print(ans % p)", "print", "ans % p", "ans", "p", "H, W, A, B = map(int, input().split())", "map(int, input().split())", "H", "Fi = [pow(f, p - 2, p) for f in F]", "[pow(f, p - 2, p) for f in F]", "Fi", "B = map(int, input().split())", "map(int, input().split())", "B", "W, A, B = map(int, input().split())", "map(int, input().split())", "W", "A, B = map(int, input().split())", "map(int, input().split())", "A", "F = [1 for i in range(H + W + 1)]", "[1 for i in range(H + W + 1)]", "F", "ans = 0", "0", "ans", "ans -= fac(H - A - 1, w) * fac(A - 1, W - w - 1) % p", "fac(H - A - 1, w) * fac(A - 1, W - w - 1) % p", "ans", "p = 10 ** 9 + 7", "10 ** 9 + 7", "p", "ans = fac(H - 1, W- 1)", "fac(H - 1, W- 1)", "ans", "ans += fac(h, B - 1) * fac(H - h - 1, W - B - 1) % p", "fac(h, B - 1) * fac(H - h - 1, W - B - 1) % p", "ans", "def fac(a, b):\n a = F[a + b] * Fi[a] * Fi[b]\n return a % p", "def fac(a, b):\n a = F[a + b] * Fi[a] * Fi[b]\n return a % p", "fac" ]

[ 7, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 13, 13, 0, 13, 2, 2, 17, 17, 17, 0, 13, 2, 39, 17, 2, 2, 13, 13, 17, 0, 13, 2, 39, 17, 2, 2, 13, 13, 17, 28, 13, 4, 13, 17, 2, 2, 13, 13, 17, 0, 18, 13, 13, 2, 2, 13, 18, 13, 2, 13, 17, 13, 0, 18, 13, 2, 13, 13, 4, 13, 18, 13, 2, 13, 13, 2, 13, 17, 13, 28, 13, 18, 4, 13, 17, 2, 2, 13, 13, 17, 39, 17, 0, 18, 13, 2, 13, 17, 2, 2, 13, 18, 13, 13, 13, 0, 13, 12, 2, 2, 2, 18, 13, 13, 18, 13, 13, 18, 13, 2, 13, 13, 13, 23, 23, 0, 13, 17, 28, 13, 4, 13, 2, 13, 17, 2, 13, 17, 0, 13, 2, 2, 4, 13, 2, 2, 13, 17, 2, 2, 13, 13, 17, 2, 13, 17, 4, 13, 2, 2, 13, 13, 2, 13, 17, 2, 13, 13, 13, 0, 13, 13, 4, 13, 13, 10, 12, 13, 10, 17, 13, 10, 4, 13, 10, 2, 13, 10, 4, 13, 10, 2, 13, 10, 4, 13, 10, 4, 13, 10, 2, 13, 10, 2, 13, 10, 13, 13 ]

[ [ 199, 2 ], [ 199, 11 ], [ 199, 12 ], [ 199, 13 ], [ 187, 15 ], [ 193, 22 ], [ 197, 28 ], [ 191, 29 ], [ 202, 32 ], [ 197, 38 ], [ 191, 39 ], [ 43, 42 ], [ 197, 48 ], [ 191, 49 ], [ 55, 52 ], [ 194, 53 ], [ 42, 54 ], [ 42, 57 ], [ 194, 59 ], [ 42, 61 ], [ 188, 63 ], [ 70, 65 ], [ 203, 66 ], [ 197, 68 ], [ 191, 69 ], [ 194, 73 ], [ 197, 75 ], [ 191, 76 ], [ 188, 78 ], [ 188, 80 ], [ 83, 82 ], [ 197, 89 ], [ 191, 90 ], [ 100, 95 ], [ 203, 96 ], [ 82, 98 ], [ 82, 102 ], [ 203, 104 ], [ 82, 105 ], [ 188, 106 ], [ 178, 108 ], [ 194, 114 ], [ 203, 117 ], [ 203, 120 ], [ 188, 124 ], [ 181, 128 ], [ 132, 131 ], [ 185, 135 ], [ 191, 138 ], [ 205, 141 ], [ 179, 145 ], [ 131, 148 ], [ 197, 152 ], [ 200, 153 ], [ 131, 156 ], [ 179, 159 ], [ 191, 162 ], [ 131, 163 ], [ 200, 165 ], [ 191, 168 ], [ 131, 169 ], [ 188, 170 ], [ 208, 172 ], [ 188, 173 ], [ 209, 176 ], [ 206, 176 ], [ 182, 176 ], [ 178, 179 ], [ 181, 182 ], [ 199, 185 ], [ 187, 188 ], [ 199, 191 ], [ 193, 194 ], [ 199, 197 ], [ 199, 200 ], [ 202, 203 ], [ 205, 206 ], [ 188, 208 ], [ 208, 209 ] ]

[ "H, W, A, B = map(int, input().split())\nmod = 10**9 + 7\n\nfact = [1] * (H+W+1)\nfact_inv = [1] * (H+W+1)\nfor i in range(1, H+W+1):\n fact[i] = i * fact[i-1] % mod\nfact_inv[H+W] = pow(fact[H+W], mod-2, mod)\nfor i in range(1, H+W+1)[::-1]:\n fact_inv[i-1] = i * fact_inv[i] % mod\ncomb = lambda n, k: fact[n] * fact_inv[k] * fact_inv[n-k] % mod\n\nans = 0\nfor i in range(B+1, W+1):\n ans += comb((i-1) + (H-A-1), i-1) * comb((W-i) + (A-1), W-i) % mod\n ans %= mod\nprint(ans)", "H, W, A, B = map(int, input().split())", "H", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "W", "A", "B", "mod = 10**9 + 7", "mod", "10**9 + 7", "10**9", "10", "9", "7", "fact = [1] * (H+W+1)", "fact", "[1] * (H+W+1)", "[1]", "1", "H+W+1", "H+W", "H", "W", "1", "fact_inv = [1] * (H+W+1)", "fact_inv", "[1] * (H+W+1)", "[1]", "1", "H+W+1", "H+W", "H", "W", "1", "for i in range(1, H+W+1):\n fact[i] = i * fact[i-1] % mod", "i", "range(1, H+W+1)", "range", "1", "H+W+1", "H+W", "H", "W", "1", "fact[i] = i * fact[i-1] % mod", "fact[i]", "fact", "i", "i * fact[i-1] % mod", "i * fact[i-1]", "i", "fact[i-1]", "fact", "i-1", "i", "1", "mod", "fact_inv[H+W] = pow(fact[H+W], mod-2, mod)", "fact_inv[H+W]", "fact_inv", "H+W", "H", "W", "pow(fact[H+W], mod-2, mod)", "pow", "fact[H+W]", "fact", "H+W", "H", "W", "mod-2", "mod", "2", "mod", "for i in range(1, H+W+1)[::-1]:\n fact_inv[i-1] = i * fact_inv[i] % mod", "i", "range(1, H+W+1)[::-1]", "(1, H+W+1)", "range", "1", "H+W+1", "H+W", "H", "W", "1", "::-1", "-1", "fact_inv[i-1] = i * fact_inv[i] % mod", "fact_inv[i-1]", "fact_inv", "i-1", "i", "1", "i * fact_inv[i] % mod", "i * fact_inv[i]", "i", "fact_inv[i]", "fact_inv", "i", "mod", "comb = lambda n, k: fact[n] * fact_inv[k] * fact_inv[n-k] % mod", "comb", "lambda n, k: fact[n] * fact_inv[k] * fact_inv[n-k] % mod", "fact[n] * fact_inv[k] * fact_inv[n-k] % mod", "fact[n] * fact_inv[k] * fact_inv[n-k]", "fact[n] * fact_inv[k]", "fact[n]", "fact", "n", "fact_inv[k]", "fact_inv", "k", "fact_inv[n-k]", "fact_inv", "n-k", "n", "k", "mod", "n", "k", "ans = 0", "ans", "0", "for i in range(B+1, W+1):\n ans += comb((i-1) + (H-A-1), i-1) * comb((W-i) + (A-1), W-i) % mod\n ans %= mod", "i", "range(B+1, W+1)", "range", "B+1", "B", "1", "W+1", "W", "1", "ans += comb((i-1) + (H-A-1), i-1) * comb((W-i) + (A-1), W-i) % mod", "ans", "comb((i-1) + (H-A-1), i-1) * comb((W-i) + (A-1), W-i) % mod", "comb((i-1) + (H-A-1), i-1) * comb((W-i) + (A-1), W-i)", "comb((i-1) + (H-A-1), i-1)", "comb", "(i-1) + (H-A-1)", "i-1", "i", "1", "H-A-1", "H-A", "H", "A", "1", "i-1", "i", "1", "comb((W-i) + (A-1), W-i)", "comb", "(W-i) + (A-1)", "W-i", "W", "i", "A-1", "A", "1", "W-i", "W", "i", "mod", "ans %= mod", "ans", "mod", "print(ans)", "print", "ans", "comb = lambda n, k: fact[n] * fact_inv[k] * fact_inv[n-k] % mod", "lambda n, k: fact[n] * fact_inv[k] * fact_inv[n-k] % mod", "comb", "ans = 0", "0", "ans", "B = map(int, input().split())", "map(int, input().split())", "B", "mod = 10**9 + 7", "10**9 + 7", "mod", "W, A, B = map(int, input().split())", "map(int, input().split())", "W", "fact = [1] * (H+W+1)", "[1] * (H+W+1)", "fact", "H, W, A, B = map(int, input().split())", "map(int, input().split())", "H", "A, B = map(int, input().split())", "map(int, input().split())", "A", "fact_inv = [1] * (H+W+1)", "[1] * (H+W+1)", "fact_inv", "ans += comb((i-1) + (H-A-1), i-1) * comb((W-i) + (A-1), W-i) % mod", "comb((i-1) + (H-A-1), i-1) * comb((W-i) + (A-1), W-i) % mod", "ans", "ans %= mod", "mod", "ans" ]

[ 7, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 13, 13, 0, 13, 17, 0, 13, 39, 17, 17, 0, 13, 39, 17, 17, 0, 13, 39, 17, 17, 28, 13, 4, 13, 17, 2, 13, 13, 4, 18, 13, 13, 2, 2, 18, 13, 17, 13, 13, 4, 18, 13, 13, 2, 2, 40, 18, 13, 2, 13, 13, 2, 13, 13, 13, 4, 18, 13, 13, 2, 2, 18, 13, 17, 18, 13, 13, 13, 12, 13, 29, 2, 2, 2, 2, 2, 18, 13, 2, 2, 2, 2, 13, 13, 13, 13, 17, 18, 13, 2, 2, 2, 2, 2, 13, 13, 17, 13, 13, 17, 18, 13, 2, 13, 13, 18, 13, 2, 2, 13, 13, 17, 18, 13, 2, 2, 2, 13, 13, 17, 13, 18, 13, 2, 13, 17, 23, 13, 12, 13, 0, 13, 17, 28, 13, 4, 13, 13, 2, 13, 17, 0, 13, 4, 13, 13, 29, 13, 23, 13, 23, 13, 23, 13, 4, 13, 2, 4, 13, 13, 17, 2, 2, 13, 13, 17, 13, 10, 12, 13, 10, 4, 13, 10, 12, 13, 10, 4, 13, 10, 4, 13, 10, 39, 13, 10, 39, 13, 10, 4, 13, 10, 17, 13, 10, 39, 13 ]

[ [ 201, 2 ], [ 201, 11 ], [ 201, 12 ], [ 201, 13 ], [ 204, 15 ], [ 207, 18 ], [ 195, 23 ], [ 198, 28 ], [ 34, 33 ], [ 184, 38 ], [ 190, 39 ], [ 208, 42 ], [ 208, 47 ], [ 33, 49 ], [ 205, 50 ], [ 196, 53 ], [ 196, 59 ], [ 205, 61 ], [ 33, 62 ], [ 205, 64 ], [ 33, 65 ], [ 205, 66 ], [ 199, 69 ], [ 199, 74 ], [ 196, 77 ], [ 33, 78 ], [ 205, 79 ], [ 208, 89 ], [ 193, 94 ], [ 139, 95 ], [ 184, 96 ], [ 202, 97 ], [ 208, 100 ], [ 190, 106 ], [ 193, 107 ], [ 139, 109 ], [ 202, 110 ], [ 199, 113 ], [ 193, 115 ], [ 139, 116 ], [ 199, 118 ], [ 184, 121 ], [ 202, 122 ], [ 199, 125 ], [ 190, 129 ], [ 193, 130 ], [ 139, 132 ], [ 199, 134 ], [ 202, 136 ], [ 139, 139 ], [ 144, 143 ], [ 147, 146 ], [ 163, 149 ], [ 165, 151 ], [ 155, 154 ], [ 161, 156 ], [ 146, 157 ], [ 154, 159 ], [ 143, 159 ], [ 161, 161 ], [ 163, 163 ], [ 165, 165 ], [ 181, 170 ], [ 187, 171 ], [ 190, 175 ], [ 193, 176 ], [ 205, 178 ], [ 201, 184 ], [ 201, 190 ], [ 201, 193 ], [ 195, 196 ], [ 198, 199 ], [ 201, 202 ], [ 204, 205 ], [ 207, 208 ] ]

[ "H, W, A, B = map(int, input().split())\n\nMOD = 1000000007\n\nfac = [1, 1]\ninverse = [0, 1]\nifac = [1, 1]\n \nfor i in range(2, H+W):\n fac.append((fac[-1] * i) % MOD)\n inverse.append((-inverse[MOD % i] * (MOD // i)) % MOD)\n ifac.append((ifac[-1] * inverse[i]) % MOD)\n\ndef f(n):\n return fac[B+n+H-A-1] * fac[W-B-1-n+A-1] * ifac[B+n] * ifac[H-A-1] * ifac[W-B-1-n] * ifac[A-1]\n\ndef sigma(func, frm, to):\n result = 0\n for i in range(frm, to+1):\n result += func(i)\n return result\n \nprint(sigma(f, 0, W-B-1)%MOD)", "H, W, A, B = map(int, input().split())", "H", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "W", "A", "B", "MOD = 1000000007", "MOD", "1000000007", "fac = [1, 1]", "fac", "[1, 1]", "1", "1", "inverse = [0, 1]", "inverse", "[0, 1]", "0", "1", "ifac = [1, 1]", "ifac", "[1, 1]", "1", "1", "for i in range(2, H+W):\n fac.append((fac[-1] * i) % MOD)\n inverse.append((-inverse[MOD % i] * (MOD // i)) % MOD)\n ifac.append((ifac[-1] * inverse[i]) % MOD)", "i", "range(2, H+W)", "range", "2", "H+W", "H", "W", "fac.append((fac[-1] * i) % MOD)", "fac.append", "fac", "append", "(fac[-1] * i) % MOD", "fac[-1] * i", "fac[-1]", "fac", "-1", "i", "MOD", "inverse.append((-inverse[MOD % i] * (MOD // i)) % MOD)", "inverse.append", "inverse", "append", "(-inverse[MOD % i] * (MOD // i)) % MOD", "-inverse[MOD % i] * (MOD // i)", "-inverse[MOD % i]", "inverse[MOD % i]", "inverse", "MOD % i", "MOD", "i", "MOD // i", "MOD", "i", "MOD", "ifac.append((ifac[-1] * inverse[i]) % MOD)", "ifac.append", "ifac", "append", "(ifac[-1] * inverse[i]) % MOD", "ifac[-1] * inverse[i]", "ifac[-1]", "ifac", "-1", "inverse[i]", "inverse", "i", "MOD", "def f(n):\n return fac[B+n+H-A-1] * fac[W-B-1-n+A-1] * ifac[B+n] * ifac[H-A-1] * ifac[W-B-1-n] * ifac[A-1]", "f", "return fac[B+n+H-A-1] * fac[W-B-1-n+A-1] * ifac[B+n] * ifac[H-A-1] * ifac[W-B-1-n] * ifac[A-1]", "fac[B+n+H-A-1] * fac[W-B-1-n+A-1] * ifac[B+n] * ifac[H-A-1] * ifac[W-B-1-n] * ifac[A-1]", "fac[B+n+H-A-1] * fac[W-B-1-n+A-1] * ifac[B+n] * ifac[H-A-1] * ifac[W-B-1-n]", "fac[B+n+H-A-1] * fac[W-B-1-n+A-1] * ifac[B+n] * ifac[H-A-1]", "fac[B+n+H-A-1] * fac[W-B-1-n+A-1] * ifac[B+n]", "fac[B+n+H-A-1] * fac[W-B-1-n+A-1]", "fac[B+n+H-A-1]", "fac", "B+n+H-A-1", "B+n+H-A", "B+n+H", "B+n", "B", "n", "H", "A", "1", "fac[W-B-1-n+A-1]", "fac", "W-B-1-n+A-1", "W-B-1-n+A", "W-B-1-n", "W-B-1", "W-B", "W", "B", "1", "n", "A", "1", "ifac[B+n]", "ifac", "B+n", "B", "n", "ifac[H-A-1]", "ifac", "H-A-1", "H-A", "H", "A", "1", "ifac[W-B-1-n]", "ifac", "W-B-1-n", "W-B-1", "W-B", "W", "B", "1", "n", "ifac[A-1]", "ifac", "A-1", "A", "1", "n", "n", "def sigma(func, frm, to):\n result = 0\n for i in range(frm, to+1):\n result += func(i)\n return result\n ", "sigma", "result = 0", "result", "0", "for i in range(frm, to+1):\n result += func(i)\n ", "i", "range(frm, to+1)", "range", "frm", "to+1", "to", "1", "result += func(i)", "result", "func(i)", "func", "i", "return result", "result", "func", "func", "frm", "frm", "to", "to", "print(sigma(f, 0, W-B-1)%MOD)", "print", "sigma(f, 0, W-B-1)%MOD", "sigma(f, 0, W-B-1)", "sigma", "f", "0", "W-B-1", "W-B", "W", "B", "1", "MOD", "def sigma(func, frm, to):\n result = 0\n for i in range(frm, to+1):\n result += func(i)\n return result\n ", "def sigma(func, frm, to):\n result = 0\n for i in range(frm, to+1):\n result += func(i)\n return result\n ", "sigma", "H, W, A, B = map(int, input().split())", "map(int, input().split())", "H", "def f(n):\n return fac[B+n+H-A-1] * fac[W-B-1-n+A-1] * ifac[B+n] * ifac[H-A-1] * ifac[W-B-1-n] * ifac[A-1]", "def f(n):\n return fac[B+n+H-A-1] * fac[W-B-1-n+A-1] * ifac[B+n] * ifac[H-A-1] * ifac[W-B-1-n] * ifac[A-1]", "f", "W, A, B = map(int, input().split())", "map(int, input().split())", "W", "B = map(int, input().split())", "map(int, input().split())", "B", "inverse = [0, 1]", "[0, 1]", "inverse", "ifac = [1, 1]", "[1, 1]", "ifac", "A, B = map(int, input().split())", "map(int, input().split())", "A", "MOD = 1000000007", "1000000007", "MOD", "fac = [1, 1]", "[1, 1]", "fac" ]

[ 7, 17, 0, 13, 2, 2, 17, 2, 17, 17, 17, 0, 13, 2, 2, 17, 17, 17, 0, 13, 2, 39, 17, 13, 0, 13, 2, 39, 17, 13, 0, 13, 2, 39, 17, 13, 0, 18, 13, 17, 17, 0, 18, 13, 17, 17, 0, 18, 13, 17, 17, 0, 18, 13, 17, 17, 0, 18, 13, 17, 17, 28, 13, 4, 13, 17, 13, 0, 18, 13, 13, 2, 2, 18, 13, 2, 13, 17, 13, 13, 0, 18, 13, 13, 2, 13, 2, 2, 18, 13, 2, 13, 13, 2, 13, 13, 13, 0, 18, 13, 13, 2, 2, 18, 13, 2, 13, 17, 18, 13, 13, 13, 12, 13, 14, 2, 13, 13, 29, 17, 14, 2, 2, 13, 17, 2, 13, 17, 29, 17, 29, 2, 2, 18, 13, 13, 2, 2, 18, 13, 13, 18, 13, 2, 13, 13, 13, 13, 23, 13, 23, 13, 12, 13, 29, 4, 13, 2, 2, 13, 13, 17, 13, 23, 13, 23, 13, 0, 13, 4, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 13, 13, 0, 13, 17, 28, 13, 4, 13, 2, 13, 13, 0, 13, 2, 4, 13, 13, 13, 4, 13, 2, 13, 13, 2, 2, 13, 13, 17, 0, 13, 2, 2, 13, 13, 13, 4, 13, 13, 10, 2, 13, 10, 2, 13, 10, 4, 13, 10, 2, 13, 10, 2, 13, 10, 2, 13, 10, 4, 13, 10, 2, 13, 10, 4, 13, 10, 17, 13, 10, 12, 13, 10, 4, 13, 10, 2, 13, 10, 12, 13 ]

[ [ 232, 3 ], [ 235, 12 ], [ 241, 19 ], [ 233, 23 ], [ 220, 25 ], [ 233, 29 ], [ 223, 31 ], [ 233, 35 ], [ 40, 37 ], [ 242, 38 ], [ 45, 42 ], [ 242, 43 ], [ 50, 47 ], [ 221, 48 ], [ 55, 52 ], [ 221, 53 ], [ 60, 57 ], [ 224, 58 ], [ 63, 62 ], [ 233, 66 ], [ 71, 68 ], [ 242, 69 ], [ 62, 70 ], [ 242, 74 ], [ 62, 76 ], [ 62, 78 ], [ 236, 79 ], [ 84, 81 ], [ 224, 82 ], [ 62, 83 ], [ 236, 85 ], [ 224, 89 ], [ 236, 91 ], [ 62, 92 ], [ 236, 94 ], [ 62, 95 ], [ 236, 96 ], [ 101, 98 ], [ 221, 99 ], [ 62, 100 ], [ 221, 104 ], [ 62, 106 ], [ 81, 108 ], [ 224, 109 ], [ 62, 110 ], [ 236, 111 ], [ 149, 116 ], [ 151, 117 ], [ 149, 123 ], [ 151, 126 ], [ 242, 134 ], [ 149, 135 ], [ 221, 139 ], [ 151, 140 ], [ 221, 142 ], [ 149, 144 ], [ 151, 145 ], [ 236, 146 ], [ 236, 147 ], [ 149, 149 ], [ 151, 151 ], [ 260, 156 ], [ 164, 159 ], [ 166, 160 ], [ 166, 162 ], [ 164, 164 ], [ 166, 166 ], [ 253, 168 ], [ 253, 179 ], [ 253, 180 ], [ 253, 181 ], [ 247, 183 ], [ 187, 186 ], [ 227, 190 ], [ 245, 191 ], [ 256, 193 ], [ 251, 196 ], [ 239, 197 ], [ 186, 198 ], [ 251, 200 ], [ 254, 202 ], [ 239, 203 ], [ 227, 206 ], [ 186, 207 ], [ 229, 210 ], [ 248, 213 ], [ 230, 213 ], [ 257, 214 ], [ 236, 215 ], [ 230, 218 ], [ 248, 218 ], [ 220, 221 ], [ 223, 224 ], [ 253, 227 ], [ 229, 230 ], [ 232, 233 ], [ 235, 236 ], [ 253, 239 ], [ 241, 242 ], [ 253, 245 ], [ 247, 248 ], [ 253, 254 ], [ 256, 257 ] ]

[ "# -*- coding: utf-8 -*-\n\"\"\"\nCreated on Mon Sep 23 17:33:45 2019\nABC042D\n@author: maezawa\n\"\"\"\n\nMAX = 5*10**5+1\nMOD = 10**9+7\n\nfac = [0] * MAX\nfinv = [0]*MAX\ninv = [0]*MAX\n\n# テーブルを作る前処理\nfac[0] = 1\nfac[1] = 1\nfinv[0] = 1\nfinv[1] = 1\ninv[1] = 1\nfor i in range(2,MAX):\n fac[i] = fac[i - 1] * i % MOD\n inv[i] = MOD - inv[MOD%i] * (MOD // i) % MOD\n finv[i] = finv[i - 1] * inv[i] % MOD\n\n# 二項係数計算\ndef COM(n, k):\n if (n < k):\n return 0\n if (n < 0 or k < 0):\n return 0\n return fac[n] * (finv[k] * finv[n - k] % MOD) % MOD\n\ndef HCOM(n,k):\n return COM(n+k-1,k)\n\n\n#n, r = list(map(int, input().split()))\n#ans = COM(n, r)\n#print(ans)\n\nh, w, a, b = list(map(int, input().split()))\ncnt = 0\nfor i in range(h-a):\n p0 = HCOM(b, i) * HCOM(w-b,h-i-1)\n cnt = (cnt+p0)%MOD\nprint(cnt)", "\"\"\"\nCreated on Mon Sep 23 17:33:45 2019\nABC042D\n@author: maezawa\n\"\"\"", "MAX = 5*10**5+1", "MAX", "5*10**5+1", "5*10**5", "5", "10**5", "10", "5", "1", "MOD = 10**9+7", "MOD", "10**9+7", "10**9", "10", "9", "7", "fac = [0] * MAX", "fac", "[0] * MAX", "[0]", "0", "MAX", "finv = [0]*MAX", "finv", "[0]*MAX", "[0]", "0", "MAX", "inv = [0]*MAX", "inv", "[0]*MAX", "[0]", "0", "MAX", "fac[0] = 1", "fac[0]", "fac", "0", "1", "fac[1] = 1", "fac[1]", "fac", "1", "1", "finv[0] = 1", "finv[0]", "finv", "0", "1", "finv[1] = 1", "finv[1]", "finv", "1", "1", "inv[1] = 1", "inv[1]", "inv", "1", "1", "for i in range(2,MAX):\n fac[i] = fac[i - 1] * i % MOD\n inv[i] = MOD - inv[MOD%i] * (MOD // i) % MOD\n finv[i] = finv[i - 1] * inv[i] % MOD\n\n# 二項係数計算", "i", "range(2,MAX)", "range", "2", "MAX", "fac[i] = fac[i - 1] * i % MOD", "fac[i]", "fac", "i", "fac[i - 1] * i % MOD", "fac[i - 1] * i", "fac[i - 1]", "fac", "i - 1", "i", "1", "i", "MOD", "inv[i] = MOD - inv[MOD%i] * (MOD // i) % MOD", "inv[i]", "inv", "i", "MOD - inv[MOD%i] * (MOD // i) % MOD", "MOD", "inv[MOD%i] * (MOD // i) % MOD", "inv[MOD%i] * (MOD // i)", "inv[MOD%i]", "inv", "MOD%i", "MOD", "i", "MOD // i", "MOD", "i", "MOD", "finv[i] = finv[i - 1] * inv[i] % MOD", "finv[i]", "finv", "i", "finv[i - 1] * inv[i] % MOD", "finv[i - 1] * inv[i]", "finv[i - 1]", "finv", "i - 1", "i", "1", "inv[i]", "inv", "i", "MOD", "def COM(n, k):\n if (n < k):\n return 0\n if (n < 0 or k < 0):\n return 0\n return fac[n] * (finv[k] * finv[n - k] % MOD) % MOD", "COM", "if (n < k):\n return 0\n ", "n < k", "n", "k", "return 0", "0", "if (n < 0 or k < 0):\n return 0\n ", "n < 0 or k < 0", "n < 0", "n", "0", "k < 0", "k", "0", "return 0", "0", "return fac[n] * (finv[k] * finv[n - k] % MOD) % MOD", "fac[n] * (finv[k] * finv[n - k] % MOD) % MOD", "fac[n] * (finv[k] * finv[n - k] % MOD)", "fac[n]", "fac", "n", "finv[k] * finv[n - k] % MOD", "finv[k] * finv[n - k]", "finv[k]", "finv", "k", "finv[n - k]", "finv", "n - k", "n", "k", "MOD", "MOD", "n", "n", "k", "k", "def HCOM(n,k):\n return COM(n+k-1,k)\n\n\n#n, r = list(map(int, input().split()))\n#ans = COM(n, r)\n#print(ans)", "HCOM", "return COM(n+k-1,k)", "COM(n+k-1,k)", "COM", "n+k-1", "n+k", "n", "k", "1", "k", "n", "n", "k", "k", "h, w, a, b = list(map(int, input().split()))", "h", "list(map(int, input().split()))", "list", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "w", "a", "b", "cnt = 0", "cnt", "0", "for i in range(h-a):\n p0 = HCOM(b, i) * HCOM(w-b,h-i-1)\n cnt = (cnt+p0)%MOD", "i", "range(h-a)", "range", "h-a", "h", "a", "p0 = HCOM(b, i) * HCOM(w-b,h-i-1)", "p0", "HCOM(b, i) * HCOM(w-b,h-i-1)", "HCOM(b, i)", "HCOM", "b", "i", "HCOM(w-b,h-i-1)", "HCOM", "w-b", "w", "b", "h-i-1", "h-i", "h", "i", "1", "cnt = (cnt+p0)%MOD", "cnt", "(cnt+p0)%MOD", "cnt+p0", "cnt", "p0", "MOD", "print(cnt)", "print", "cnt", "finv = [0]*MAX", "[0]*MAX", "finv", "inv = [0]*MAX", "[0]*MAX", "inv", "h, w, a, b = list(map(int, input().split()))", "list(map(int, input().split()))", "h", "cnt = (cnt+p0)%MOD", "(cnt+p0)%MOD", "cnt", "MAX = 5*10**5+1", "5*10**5+1", "MAX", "MOD = 10**9+7", "10**9+7", "MOD", "b = list(map(int, input().split()))", "list(map(int, input().split()))", "b", "fac = [0] * MAX", "[0] * MAX", "fac", "a, b = list(map(int, input().split()))", "list(map(int, input().split()))", "a", "cnt = 0", "0", "cnt", "def HCOM(n,k):\n return COM(n+k-1,k)\n\n\n#n, r = list(map(int, input().split()))\n#ans = COM(n, r)\n#print(ans)", "def HCOM(n,k):\n return COM(n+k-1,k)\n\n\n#n, r = list(map(int, input().split()))\n#ans = COM(n, r)\n#print(ans)", "HCOM", "w, a, b = list(map(int, input().split()))", "list(map(int, input().split()))", "w", "p0 = HCOM(b, i) * HCOM(w-b,h-i-1)", "HCOM(b, i) * HCOM(w-b,h-i-1)", "p0", "def COM(n, k):\n if (n < k):\n return 0\n if (n < 0 or k < 0):\n return 0\n return fac[n] * (finv[k] * finv[n - k] % MOD) % MOD", "def COM(n, k):\n if (n < k):\n return 0\n if (n < 0 or k < 0):\n return 0\n return fac[n] * (finv[k] * finv[n - k] % MOD) % MOD", "COM" ]

[ 7, 0, 13, 2, 2, 17, 17, 17, 0, 13, 4, 13, 2, 17, 17, 12, 13, 29, 2, 2, 13, 4, 13, 13, 2, 13, 17, 13, 13, 23, 13, 23, 13, 0, 13, 2, 39, 17, 2, 13, 17, 28, 13, 4, 13, 17, 2, 13, 17, 0, 18, 13, 13, 2, 2, 13, 18, 13, 2, 13, 17, 13, 0, 13, 2, 39, 17, 2, 13, 17, 0, 18, 13, 13, 4, 13, 17, 18, 13, 13, 28, 13, 4, 13, 13, 17, 17, 0, 18, 13, 2, 13, 17, 2, 2, 18, 13, 13, 13, 13, 12, 13, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 13, 13, 0, 13, 17, 0, 13, 2, 2, 13, 13, 17, 0, 13, 13, 42, 2, 40, 13, 17, 2, 13, 13, 0, 13, 2, 2, 2, 18, 13, 2, 13, 13, 18, 13, 13, 18, 13, 13, 13, 0, 13, 2, 2, 2, 18, 13, 2, 2, 2, 2, 2, 13, 13, 17, 13, 13, 17, 18, 13, 2, 2, 13, 13, 17, 18, 13, 2, 2, 13, 13, 17, 13, 0, 13, 2, 2, 13, 2, 13, 13, 13, 0, 13, 17, 0, 13, 17, 4, 13, 13, 14, 2, 13, 17, 4, 13, 10, 2, 13, 10, 2, 13, 10, 4, 13, 10, 12, 13, 10, 12, 13, 10, 2, 13 ]

[ [ 211, 2 ], [ 217, 9 ], [ 30, 20 ], [ 32, 23 ], [ 212, 25 ], [ 212, 27 ], [ 212, 28 ], [ 30, 30 ], [ 32, 32 ], [ 226, 34 ], [ 218, 39 ], [ 43, 42 ], [ 218, 47 ], [ 53, 50 ], [ 227, 51 ], [ 42, 52 ], [ 42, 55 ], [ 227, 57 ], [ 42, 59 ], [ 212, 61 ], [ 214, 63 ], [ 218, 68 ], [ 74, 71 ], [ 215, 72 ], [ 218, 73 ], [ 224, 75 ], [ 227, 78 ], [ 218, 79 ], [ 82, 81 ], [ 218, 84 ], [ 93, 88 ], [ 215, 89 ], [ 81, 91 ], [ 215, 96 ], [ 81, 97 ], [ 81, 98 ], [ 212, 99 ], [ 104, 103 ], [ 104, 112 ], [ 104, 113 ], [ 104, 114 ], [ 117, 116 ], [ 120, 119 ], [ 103, 122 ], [ 113, 123 ], [ 127, 126 ], [ 114, 127 ], [ 119, 131 ], [ 196, 131 ], [ 126, 134 ], [ 199, 134 ], [ 112, 135 ], [ 138, 137 ], [ 227, 142 ], [ 119, 144 ], [ 196, 144 ], [ 126, 145 ], [ 199, 145 ], [ 215, 147 ], [ 119, 148 ], [ 196, 148 ], [ 215, 150 ], [ 126, 151 ], [ 199, 151 ], [ 212, 152 ], [ 155, 154 ], [ 227, 159 ], [ 103, 165 ], [ 119, 166 ], [ 196, 166 ], [ 112, 168 ], [ 126, 169 ], [ 199, 169 ], [ 215, 172 ], [ 103, 175 ], [ 119, 176 ], [ 196, 176 ], [ 215, 179 ], [ 112, 182 ], [ 126, 183 ], [ 199, 183 ], [ 212, 185 ], [ 188, 187 ], [ 116, 190 ], [ 187, 190 ], [ 137, 192 ], [ 154, 193 ], [ 212, 194 ], [ 197, 196 ], [ 200, 199 ], [ 187, 203 ], [ 116, 203 ], [ 221, 209 ], [ 211, 212 ], [ 214, 215 ], [ 217, 218 ], [ 226, 227 ] ]

[ "MOD = 10**9 + 7\nMAX = int(2e5+1)\n\n\ndef div(a, b):\n return a * pow(b, MOD-2, MOD) % MOD\n\n\nFACT = [1] * (MAX+1)\nfor i in range(1, MAX+1):\n FACT[i] = (i * FACT[i-1]) % MOD\nINV = [1] * (MAX+1)\nINV[MAX] = div(1, FACT[MAX])\nfor i in range(MAX, 0, -1):\n INV[i-1] = (INV[i] * i) % MOD\n\n\ndef main():\n H, W, A, B = map(int, input().split())\n ans = 0\n i = H-A-1\n j = B\n while i >= 0 and j < W:\n a = (FACT[i+j] * INV[i] * INV[j]) % MOD\n b = (FACT[H-i-1 + W-j-1] * INV[H-i-1] * INV[W-j-1]) % MOD\n ans = (ans + a * b) % MOD\n i -= 1\n j += 1\n print(ans)\n\n\nif __name__ == \"__main__\":\n main()", "MOD = 10**9 + 7", "MOD", "10**9 + 7", "10**9", "10", "9", "7", "MAX = int(2e5+1)", "MAX", "int(2e5+1)", "int", "2e5+1", "2e5", "1", "def div(a, b):\n return a * pow(b, MOD-2, MOD) % MOD", "div", "return a * pow(b, MOD-2, MOD) % MOD", "a * pow(b, MOD-2, MOD) % MOD", "a * pow(b, MOD-2, MOD)", "a", "pow(b, MOD-2, MOD)", "pow", "b", "MOD-2", "MOD", "2", "MOD", "MOD", "a", "a", "b", "b", "FACT = [1] * (MAX+1)", "FACT", "[1] * (MAX+1)", "[1]", "1", "MAX+1", "MAX", "1", "for i in range(1, MAX+1):\n FACT[i] = (i * FACT[i-1]) % MOD", "i", "range(1, MAX+1)", "range", "1", "MAX+1", "MAX", "1", "FACT[i] = (i * FACT[i-1]) % MOD", "FACT[i]", "FACT", "i", "(i * FACT[i-1]) % MOD", "i * FACT[i-1]", "i", "FACT[i-1]", "FACT", "i-1", "i", "1", "MOD", "INV = [1] * (MAX+1)", "INV", "[1] * (MAX+1)", "[1]", "1", "MAX+1", "MAX", "1", "INV[MAX] = div(1, FACT[MAX])", "INV[MAX]", "INV", "MAX", "div(1, FACT[MAX])", "div", "1", "FACT[MAX]", "FACT", "MAX", "for i in range(MAX, 0, -1):\n INV[i-1] = (INV[i] * i) % MOD", "i", "range(MAX, 0, -1)", "range", "MAX", "0", "-1", "INV[i-1] = (INV[i] * i) % MOD", "INV[i-1]", "INV", "i-1", "i", "1", "(INV[i] * i) % MOD", "INV[i] * i", "INV[i]", "INV", "i", "i", "MOD", "def main():\n H, W, A, B = map(int, input().split())\n ans = 0\n i = H-A-1\n j = B\n while i >= 0 and j < W:\n a = (FACT[i+j] * INV[i] * INV[j]) % MOD\n b = (FACT[H-i-1 + W-j-1] * INV[H-i-1] * INV[W-j-1]) % MOD\n ans = (ans + a * b) % MOD\n i -= 1\n j += 1\n print(ans)", "main", "H, W, A, B = map(int, input().split())", "H", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "W", "A", "B", "ans = 0", "ans", "0", "i = H-A-1", "i", "H-A-1", "H-A", "H", "A", "1", "j = B", "j", "B", "while i >= 0 and j < W:\n a = (FACT[i+j] * INV[i] * INV[j]) % MOD\n b = (FACT[H-i-1 + W-j-1] * INV[H-i-1] * INV[W-j-1]) % MOD\n ans = (ans + a * b) % MOD\n i -= 1\n j += 1\n ", "i >= 0 and j < W", "i >= 0", "i", "0", "j < W", "j", "W", "a = (FACT[i+j] * INV[i] * INV[j]) % MOD", "a", "(FACT[i+j] * INV[i] * INV[j]) % MOD", "FACT[i+j] * INV[i] * INV[j]", "FACT[i+j] * INV[i]", "FACT[i+j]", "FACT", "i+j", "i", "j", "INV[i]", "INV", "i", "INV[j]", "INV", "j", "MOD", "b = (FACT[H-i-1 + W-j-1] * INV[H-i-1] * INV[W-j-1]) % MOD", "b", "(FACT[H-i-1 + W-j-1] * INV[H-i-1] * INV[W-j-1]) % MOD", "FACT[H-i-1 + W-j-1] * INV[H-i-1] * INV[W-j-1]", "FACT[H-i-1 + W-j-1] * INV[H-i-1]", "FACT[H-i-1 + W-j-1]", "FACT", "H-i-1 + W-j-1", "H-i-1 + W-j", "H-i-1 + W", "H-i-1", "H-i", "H", "i", "1", "W", "j", "1", "INV[H-i-1]", "INV", "H-i-1", "H-i", "H", "i", "1", "INV[W-j-1]", "INV", "W-j-1", "W-j", "W", "j", "1", "MOD", "ans = (ans + a * b) % MOD", "ans", "(ans + a * b) % MOD", "ans + a * b", "ans", "a * b", "a", "b", "MOD", "i -= 1", "i", "1", "j += 1", "j", "1", "print(ans)", "print", "ans", "if __name__ == \"__main__\":\n main()", "__name__ == \"__main__\"", "__name__", "\"__main__\"", "main()", "main", "MOD = 10**9 + 7", "10**9 + 7", "MOD", "INV = [1] * (MAX+1)", "[1] * (MAX+1)", "INV", "MAX = int(2e5+1)", "int(2e5+1)", "MAX", "def main():\n H, W, A, B = map(int, input().split())\n ans = 0\n i = H-A-1\n j = B\n while i >= 0 and j < W:\n a = (FACT[i+j] * INV[i] * INV[j]) % MOD\n b = (FACT[H-i-1 + W-j-1] * INV[H-i-1] * INV[W-j-1]) % MOD\n ans = (ans + a * b) % MOD\n i -= 1\n j += 1\n print(ans)", "def main():\n H, W, A, B = map(int, input().split())\n ans = 0\n i = H-A-1\n j = B\n while i >= 0 and j < W:\n a = (FACT[i+j] * INV[i] * INV[j]) % MOD\n b = (FACT[H-i-1 + W-j-1] * INV[H-i-1] * INV[W-j-1]) % MOD\n ans = (ans + a * b) % MOD\n i -= 1\n j += 1\n print(ans)", "main", "def div(a, b):\n return a * pow(b, MOD-2, MOD) % MOD", "def div(a, b):\n return a * pow(b, MOD-2, MOD) % MOD", "div", "FACT = [1] * (MAX+1)", "[1] * (MAX+1)", "FACT" ]

[ 7, 0, 13, 17, 0, 13, 17, 0, 13, 2, 39, 17, 13, 0, 13, 2, 39, 17, 13, 0, 13, 2, 39, 17, 13, 12, 13, 0, 18, 13, 17, 17, 0, 18, 13, 17, 17, 0, 18, 13, 17, 17, 0, 18, 13, 17, 17, 0, 18, 13, 17, 17, 28, 13, 4, 13, 17, 13, 0, 18, 13, 13, 2, 2, 18, 13, 2, 13, 17, 13, 13, 0, 18, 13, 13, 2, 13, 2, 2, 18, 13, 2, 13, 13, 2, 13, 13, 13, 0, 18, 13, 13, 2, 2, 18, 13, 2, 13, 17, 18, 13, 13, 13, 12, 13, 14, 2, 13, 13, 14, 2, 2, 13, 17, 2, 13, 17, 29, 2, 2, 18, 13, 13, 2, 2, 18, 13, 13, 18, 13, 2, 13, 13, 13, 13, 23, 13, 23, 13, 12, 13, 0, 13, 17, 0, 13, 2, 2, 2, 13, 13, 13, 17, 0, 13, 13, 0, 13, 2, 2, 2, 13, 13, 13, 17, 0, 13, 2, 2, 13, 13, 17, 28, 13, 4, 13, 2, 13, 13, 0, 13, 4, 13, 13, 13, 0, 13, 4, 13, 13, 13, 0, 13, 2, 2, 13, 13, 13, 0, 13, 17, 0, 13, 17, 0, 13, 17, 0, 13, 17, 29, 2, 13, 13, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 13, 13, 4, 13, 4, 13, 4, 13, 10, 2, 13, 10, 4, 13, 10, 4, 13, 10, 2, 13, 10, 17, 13, 10, 12, 13, 10, 4, 13, 10, 2, 13, 10, 12, 13, 10, 17, 13, 10, 4, 13, 10, 12, 13 ]

[ [ 261, 2 ], [ 246, 5 ], [ 255, 8 ], [ 262, 12 ], [ 234, 14 ], [ 262, 18 ], [ 243, 20 ], [ 262, 24 ], [ 36, 28 ], [ 256, 29 ], [ 36, 33 ], [ 256, 34 ], [ 46, 38 ], [ 235, 39 ], [ 46, 43 ], [ 235, 44 ], [ 51, 48 ], [ 244, 49 ], [ 54, 53 ], [ 262, 57 ], [ 62, 59 ], [ 256, 60 ], [ 53, 61 ], [ 256, 65 ], [ 53, 67 ], [ 53, 69 ], [ 247, 70 ], [ 75, 72 ], [ 244, 73 ], [ 53, 74 ], [ 247, 76 ], [ 244, 80 ], [ 247, 82 ], [ 53, 83 ], [ 247, 85 ], [ 53, 86 ], [ 247, 87 ], [ 92, 89 ], [ 235, 90 ], [ 53, 91 ], [ 235, 95 ], [ 53, 97 ], [ 72, 99 ], [ 244, 100 ], [ 53, 101 ], [ 247, 102 ], [ 136, 107 ], [ 138, 108 ], [ 136, 112 ], [ 138, 115 ], [ 256, 121 ], [ 136, 122 ], [ 235, 126 ], [ 138, 127 ], [ 235, 129 ], [ 136, 131 ], [ 138, 132 ], [ 247, 133 ], [ 247, 134 ], [ 136, 136 ], [ 138, 138 ], [ 143, 142 ], [ 146, 145 ], [ 155, 154 ], [ 158, 157 ], [ 167, 166 ], [ 174, 173 ], [ 181, 180 ], [ 268, 182 ], [ 145, 183 ], [ 199, 183 ], [ 154, 184 ], [ 202, 184 ], [ 187, 186 ], [ 268, 188 ], [ 157, 189 ], [ 205, 189 ], [ 166, 190 ], [ 208, 190 ], [ 193, 192 ], [ 180, 195 ], [ 186, 196 ], [ 247, 197 ], [ 200, 199 ], [ 203, 202 ], [ 206, 205 ], [ 209, 208 ], [ 192, 212 ], [ 142, 212 ], [ 247, 213 ], [ 264, 215 ], [ 264, 224 ], [ 264, 225 ], [ 264, 226 ], [ 259, 228 ], [ 250, 232 ], [ 234, 235 ], [ 264, 238 ], [ 264, 241 ], [ 243, 244 ], [ 246, 247 ], [ 264, 253 ], [ 255, 256 ], [ 261, 262 ], [ 264, 265 ] ]

[ "MAX = 510000\nMOD = 1000000007\n\nfac = [0] * MAX\nfinv = [0] * MAX\ninv = [0] * MAX\n\ndef comb_init():\n fac[0] = fac[1] = 1\n finv[0] = finv[1] = 1\n inv[1] = 1\n for i in range(2, MAX):\n fac[i] = fac[i - 1] * i % MOD\n inv[i] = MOD - inv[MOD % i] * (MOD // i) % MOD\n finv[i] = finv[i - 1] * inv[i] % MOD\n \ndef comb(n, r):\n if n < r: return 0\n if n < 0 or r < 0: return 0\n return fac[n] * (finv[r] * finv[n - r] % MOD) % MOD\n\ndef solve():\n ans = 0\n an = H + B - A - 1\n ar = B\n bn = W + A - B - 2\n br = W - B - 1\n for i in range(W-B):\n a = comb(an, ar)\n b = comb(bn, br)\n ans += (a * b) % MOD\n an += 1; ar += 1\n bn -= 1; br -= 1\n return ans % MOD\n\nH, W, A, B = map(int, input().split())\n\ncomb_init()\nprint(solve())", "MAX = 510000", "MAX", "510000", "MOD = 1000000007", "MOD", "1000000007", "fac = [0] * MAX", "fac", "[0] * MAX", "[0]", "0", "MAX", "finv = [0] * MAX", "finv", "[0] * MAX", "[0]", "0", "MAX", "inv = [0] * MAX", "inv", "[0] * MAX", "[0]", "0", "MAX", "def comb_init():\n fac[0] = fac[1] = 1\n finv[0] = finv[1] = 1\n inv[1] = 1\n for i in range(2, MAX):\n fac[i] = fac[i - 1] * i % MOD\n inv[i] = MOD - inv[MOD % i] * (MOD // i) % MOD\n finv[i] = finv[i - 1] * inv[i] % MOD\n ", "comb_init", "fac[0] = fac[1] = 1", "fac[0]", "fac", "0", "1", "= fac[1] = 1", "fac[1]", "fac", "1", "1", "finv[0] = finv[1] = 1", "finv[0]", "finv", "0", "1", "= finv[1] = 1", "finv[1]", "finv", "1", "1", "inv[1] = 1", "inv[1]", "inv", "1", "1", "for i in range(2, MAX):\n fac[i] = fac[i - 1] * i % MOD\n inv[i] = MOD - inv[MOD % i] * (MOD // i) % MOD\n finv[i] = finv[i - 1] * inv[i] % MOD\n ", "i", "range(2, MAX)", "range", "2", "MAX", "fac[i] = fac[i - 1] * i % MOD", "fac[i]", "fac", "i", "fac[i - 1] * i % MOD", "fac[i - 1] * i", "fac[i - 1]", "fac", "i - 1", "i", "1", "i", "MOD", "inv[i] = MOD - inv[MOD % i] * (MOD // i) % MOD", "inv[i]", "inv", "i", "MOD - inv[MOD % i] * (MOD // i) % MOD", "MOD", "inv[MOD % i] * (MOD // i) % MOD", "inv[MOD % i] * (MOD // i)", "inv[MOD % i]", "inv", "MOD % i", "MOD", "i", "MOD // i", "MOD", "i", "MOD", "finv[i] = finv[i - 1] * inv[i] % MOD", "finv[i]", "finv", "i", "finv[i - 1] * inv[i] % MOD", "finv[i - 1] * inv[i]", "finv[i - 1]", "finv", "i - 1", "i", "1", "inv[i]", "inv", "i", "MOD", "def comb(n, r):\n if n < r: return 0\n if n < 0 or r < 0: return 0\n return fac[n] * (finv[r] * finv[n - r] % MOD) % MOD", "comb", "if n < r: return 0\n ", "n < r", "n", "r", "if n < 0 or r < 0: return 0\n ", "n < 0 or r < 0", "n < 0", "n", "0", "r < 0", "r", "0", "return fac[n] * (finv[r] * finv[n - r] % MOD) % MOD", "fac[n] * (finv[r] * finv[n - r] % MOD) % MOD", "fac[n] * (finv[r] * finv[n - r] % MOD)", "fac[n]", "fac", "n", "finv[r] * finv[n - r] % MOD", "finv[r] * finv[n - r]", "finv[r]", "finv", "r", "finv[n - r]", "finv", "n - r", "n", "r", "MOD", "MOD", "n", "n", "r", "r", "def solve():\n ans = 0\n an = H + B - A - 1\n ar = B\n bn = W + A - B - 2\n br = W - B - 1\n for i in range(W-B):\n a = comb(an, ar)\n b = comb(bn, br)\n ans += (a * b) % MOD\n an += 1; ar += 1\n bn -= 1; br -= 1\n return ans % MOD", "solve", "ans = 0", "ans", "0", "an = H + B - A - 1", "an", "H + B - A - 1", "H + B - A", "H + B", "H", "B", "A", "1", "ar = B", "ar", "B", "bn = W + A - B - 2", "bn", "W + A - B - 2", "W + A - B", "W + A", "W", "A", "B", "2", "br = W - B - 1", "br", "W - B - 1", "W - B", "W", "B", "1", "for i in range(W-B):\n a = comb(an, ar)\n b = comb(bn, br)\n ans += (a * b) % MOD\n an += 1; ar += 1\n bn -= 1; br -= 1\n ", "i", "range(W-B)", "range", "W-B", "W", "B", "a = comb(an, ar)", "a", "comb(an, ar)", "comb", "an", "ar", "b = comb(bn, br)", "b", "comb(bn, br)", "comb", "bn", "br", "ans += (a * b) % MOD", "ans", "(a * b) % MOD", "a * b", "a", "b", "MOD", "an += 1", "an", "1", "ar += 1", "ar", "1", "bn -= 1", "bn", "1", "br -= 1", "br", "1", "return ans % MOD", "ans % MOD", "ans", "MOD", "H, W, A, B = map(int, input().split())", "H", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "W", "A", "B", "comb_init()", "comb_init", "print(solve())", "print", "solve()", "solve", "finv = [0] * MAX", "[0] * MAX", "finv", "B = map(int, input().split())", "map(int, input().split())", "B", "W, A, B = map(int, input().split())", "map(int, input().split())", "W", "inv = [0] * MAX", "[0] * MAX", "inv", "MOD = 1000000007", "1000000007", "MOD", "def solve():\n ans = 0\n an = H + B - A - 1\n ar = B\n bn = W + A - B - 2\n br = W - B - 1\n for i in range(W-B):\n a = comb(an, ar)\n b = comb(bn, br)\n ans += (a * b) % MOD\n an += 1; ar += 1\n bn -= 1; br -= 1\n return ans % MOD", "def solve():\n ans = 0\n an = H + B - A - 1\n ar = B\n bn = W + A - B - 2\n br = W - B - 1\n for i in range(W-B):\n a = comb(an, ar)\n b = comb(bn, br)\n ans += (a * b) % MOD\n an += 1; ar += 1\n bn -= 1; br -= 1\n return ans % MOD", "solve", "H, W, A, B = map(int, input().split())", "map(int, input().split())", "H", "fac = [0] * MAX", "[0] * MAX", "fac", "def comb_init():\n fac[0] = fac[1] = 1\n finv[0] = finv[1] = 1\n inv[1] = 1\n for i in range(2, MAX):\n fac[i] = fac[i - 1] * i % MOD\n inv[i] = MOD - inv[MOD % i] * (MOD // i) % MOD\n finv[i] = finv[i - 1] * inv[i] % MOD\n ", "def comb_init():\n fac[0] = fac[1] = 1\n finv[0] = finv[1] = 1\n inv[1] = 1\n for i in range(2, MAX):\n fac[i] = fac[i - 1] * i % MOD\n inv[i] = MOD - inv[MOD % i] * (MOD // i) % MOD\n finv[i] = finv[i - 1] * inv[i] % MOD\n ", "comb_init", "MAX = 510000", "510000", "MAX", "A, B = map(int, input().split())", "map(int, input().split())", "A", "def comb(n, r):\n if n < r: return 0\n if n < 0 or r < 0: return 0\n return fac[n] * (finv[r] * finv[n - r] % MOD) % MOD", "def comb(n, r):\n if n < r: return 0\n if n < 0 or r < 0: return 0\n return fac[n] * (finv[r] * finv[n - r] % MOD) % MOD", "comb" ]

[ 7, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 13, 13, 6, 13, 17, 12, 13, 0, 18, 13, 13, 13, 0, 18, 13, 13, 4, 18, 13, 13, 13, 0, 18, 13, 13, 4, 18, 13, 13, 13, 18, 13, 13, 23, 13, 23, 13, 23, 13, 2, 2, 17, 17, 17, 12, 13, 29, 2, 2, 2, 2, 18, 18, 13, 13, 13, 18, 18, 13, 13, 13, 18, 13, 13, 18, 18, 13, 13, 2, 13, 13, 18, 13, 13, 23, 13, 23, 13, 23, 13, 12, 13, 0, 13, 39, 17, 0, 13, 39, 17, 28, 13, 4, 13, 17, 2, 13, 17, 4, 18, 13, 13, 2, 2, 18, 13, 2, 13, 17, 13, 18, 13, 13, 4, 18, 13, 13, 2, 2, 18, 13, 2, 13, 17, 18, 18, 13, 13, 13, 18, 13, 13, 29, 39, 13, 13, 23, 13, 23, 13, 12, 13, 0, 13, 2, 39, 17, 2, 13, 17, 0, 18, 13, 17, 17, 28, 13, 4, 13, 17, 2, 13, 17, 0, 18, 13, 13, 2, 18, 13, 13, 2, 2, 2, 18, 13, 13, 13, 18, 13, 2, 18, 13, 13, 13, 18, 13, 13, 29, 13, 23, 13, 23, 13, 0, 13, 4, 13, 17, 0, 13, 2, 2, 17, 17, 17, 0, 13, 17, 28, 13, 4, 13, 13, 13, 0, 13, 2, 4, 13, 2, 2, 2, 13, 13, 17, 13, 13, 4, 13, 2, 2, 2, 2, 13, 17, 13, 17, 13, 2, 13, 17, 0, 13, 13, 4, 13, 13, 10, 6, 13, 10, 4, 13, 10, 2, 13, 10, 4, 13, 10, 17, 13, 10, 4, 13, 10, 2, 13, 10, 4, 13, 10, 13, 13, 10, 4, 13 ]

[ [ 288, 2 ], [ 288, 11 ], [ 288, 12 ], [ 288, 13 ], [ 23, 20 ], [ 46, 21 ], [ 50, 22 ], [ 50, 23 ], [ 28, 25 ], [ 46, 26 ], [ 46, 30 ], [ 48, 32 ], [ 37, 34 ], [ 46, 35 ], [ 46, 39 ], [ 48, 41 ], [ 37, 42 ], [ 46, 43 ], [ 46, 46 ], [ 48, 48 ], [ 51, 50 ], [ 87, 65 ], [ 89, 67 ], [ 87, 70 ], [ 91, 72 ], [ 87, 74 ], [ 87, 78 ], [ 89, 81 ], [ 91, 82 ], [ 87, 84 ], [ 87, 87 ], [ 89, 89 ], [ 91, 91 ], [ 96, 95 ], [ 100, 99 ], [ 104, 103 ], [ 151, 108 ], [ 95, 112 ], [ 95, 117 ], [ 103, 119 ], [ 103, 121 ], [ 149, 123 ], [ 99, 127 ], [ 99, 132 ], [ 103, 134 ], [ 149, 138 ], [ 103, 140 ], [ 149, 142 ], [ 149, 149 ], [ 151, 151 ], [ 156, 155 ], [ 205, 160 ], [ 166, 163 ], [ 155, 164 ], [ 169, 168 ], [ 205, 173 ], [ 179, 176 ], [ 155, 177 ], [ 168, 178 ], [ 203, 181 ], [ 203, 187 ], [ 168, 189 ], [ 155, 191 ], [ 203, 194 ], [ 168, 196 ], [ 203, 198 ], [ 155, 201 ], [ 203, 203 ], [ 205, 205 ], [ 264, 207 ], [ 267, 212 ], [ 273, 219 ], [ 223, 222 ], [ 277, 225 ], [ 283, 226 ], [ 279, 228 ], [ 265, 231 ], [ 289, 235 ], [ 271, 236 ], [ 222, 238 ], [ 222, 239 ], [ 265, 241 ], [ 271, 246 ], [ 283, 248 ], [ 222, 250 ], [ 271, 252 ], [ 285, 255 ], [ 268, 256 ], [ 286, 259 ], [ 280, 259 ], [ 274, 259 ], [ 264, 265 ], [ 267, 268 ], [ 288, 271 ], [ 273, 274 ], [ 288, 277 ], [ 279, 280 ], [ 288, 283 ], [ 268, 285 ], [ 285, 286 ], [ 288, 289 ] ]

[ "H,W,A,B = map(int,input().split())\n\n\nclass Combination:\n \"\"\"\n O(n)の前計算を1回行うことで，O(1)でnCr mod mを求められる\n n_max = 10**6のとき前処理は約950ms (PyPyなら約340ms, 10**7で約1800ms)\n 使用例：\n comb = Combination(1000000)\n print(comb(5, 3)) # 10\n \"\"\"\n\n def __init__(self, n_max, mod=10 ** 9 + 7):\n self.mod = mod\n self.modinv = self.make_modinv_list(n_max)\n self.fac, self.facinv = self.make_factorial_list(n_max)\n\n def __call__(self, n, r):\n return self.fac[n] * self.facinv[r] % self.mod * self.facinv[n - r] % self.mod\n\n def make_factorial_list(self, n):\n # 階乗のリストと階乗のmod逆元のリストを返す O(n)\n # self.make_modinv_list()が先に実行されている必要がある\n fac = [1]\n facinv = [1]\n for i in range(1, n + 1):\n fac.append(fac[i - 1] * i % self.mod)\n facinv.append(facinv[i - 1] * self.modinv[i] % self.mod)\n return fac, facinv\n\n def make_modinv_list(self, n):\n # 0からnまでのmod逆元のリストを返す O(n)\n modinv = [0] * (n + 1)\n modinv[1] = 1\n for i in range(2, n + 1):\n modinv[i] = self.mod - self.mod // i * modinv[self.mod % i] % self.mod\n return modinv\n\ncomb = Combination(1000000)\nMOD = 10**9+7\nans = 0\nfor i in range(B,W):\n ans += comb(H-A-1+i,i)*comb(A-1+W-1-i,A-1)\n ans %= MOD\n #print(comb(H-A-1+i,i)*comb(A-1+W-1-i,A-1))\nprint(ans)\n\n", "H,W,A,B = map(int,input().split())", "H", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "W", "A", "B", "class Combination:\n \"\"\"\n O(n)の前計算を1回行うことで，O(1)でnCr mod mを求められる\n n_max = 10**6のとき前処理は約950ms (PyPyなら約340ms, 10**7で約1800ms)\n 使用例：\n comb = Combination(1000000)\n print(comb(5, 3)) # 10\n \"\"\"\n\n def __init__(self, n_max, mod=10 ** 9 + 7):\n self.mod = mod\n self.modinv = self.make_modinv_list(n_max)\n self.fac, self.facinv = self.make_factorial_list(n_max)\n\n def __call__(self, n, r):\n return self.fac[n] * self.facinv[r] % self.mod * self.facinv[n - r] % self.mod\n\n def make_factorial_list(self, n):\n # 階乗のリストと階乗のmod逆元のリストを返す O(n)\n # self.make_modinv_list()が先に実行されている必要がある\n fac = [1]\n facinv = [1]\n for i in range(1, n + 1):\n fac.append(fac[i - 1] * i % self.mod)\n facinv.append(facinv[i - 1] * self.modinv[i] % self.mod)\n return fac, facinv\n\n def make_modinv_list(self, n):\n # 0からnまでのmod逆元のリストを返す O(n)\n modinv = [0] * (n + 1)\n modinv[1] = 1\n for i in range(2, n + 1):\n modinv[i] = self.mod - self.mod // i * modinv[self.mod % i] % self.mod\n return modinv", "Combination", "\"\"\"\n O(n)の前計算を1回行うことで，O(1)でnCr mod mを求められる\n n_max = 10**6のとき前処理は約950ms (PyPyなら約340ms, 10**7で約1800ms)\n 使用例：\n comb = Combination(1000000)\n print(comb(5, 3)) # 10\n \"\"\"", "def __init__(self, n_max, mod=10 ** 9 + 7):\n self.mod = mod\n self.modinv = self.make_modinv_list(n_max)\n self.fac, self.facinv = self.make_factorial_list(n_max)\n\n ", "__init__", "self.mod = mod", "self.mod", "self", "mod", "mod", "self.modinv = self.make_modinv_list(n_max)", "self.modinv", "self", "modinv", "self.make_modinv_list(n_max)", "self.make_modinv_list", "self", "make_modinv_list", "n_max", "self.fac, self.facinv = self.make_factorial_list(n_max)", "self.fac", "self", "fac", "self.make_factorial_list(n_max)", "self.make_factorial_list", "self", "make_factorial_list", "n_max", "self.facinv", "self", "facinv", "self", "self", "n_max", "n_max", "mod=10 ** 9 + 7", "mod", "10 ** 9 + 7", "10 ** 9", "10", "9", "7", "def __call__(self, n, r):\n return self.fac[n] * self.facinv[r] % self.mod * self.facinv[n - r] % self.mod\n\n ", "__call__", "return self.fac[n] * self.facinv[r] % self.mod * self.facinv[n - r] % self.mod", "self.fac[n] * self.facinv[r] % self.mod * self.facinv[n - r] % self.mod", "self.fac[n] * self.facinv[r] % self.mod * self.facinv[n - r]", "self.fac[n] * self.facinv[r] % self.mod", "self.fac[n] * self.facinv[r]", "self.fac[n]", "self.fac", "self", "fac", "n", "self.facinv[r]", "self.facinv", "self", "facinv", "r", "self.mod", "self", "mod", "self.facinv[n - r]", "self.facinv", "self", "facinv", "n - r", "n", "r", "self.mod", "self", "mod", "self", "self", "n", "n", "r", "r", "def make_factorial_list(self, n):\n # 階乗のリストと階乗のmod逆元のリストを返す O(n)\n # self.make_modinv_list()が先に実行されている必要がある\n fac = [1]\n facinv = [1]\n for i in range(1, n + 1):\n fac.append(fac[i - 1] * i % self.mod)\n facinv.append(facinv[i - 1] * self.modinv[i] % self.mod)\n return fac, facinv\n\n ", "make_factorial_list", "fac = [1]", "fac", "[1]", "1", "facinv = [1]", "facinv", "[1]", "1", "for i in range(1, n + 1):\n fac.append(fac[i - 1] * i % self.mod)\n facinv.append(facinv[i - 1] * self.modinv[i] % self.mod)\n ", "i", "range(1, n + 1)", "range", "1", "n + 1", "n", "1", "fac.append(fac[i - 1] * i % self.mod)", "fac.append", "fac", "append", "fac[i - 1] * i % self.mod", "fac[i - 1] * i", "fac[i - 1]", "fac", "i - 1", "i", "1", "i", "self.mod", "self", "mod", "facinv.append(facinv[i - 1] * self.modinv[i] % self.mod)", "facinv.append", "facinv", "append", "facinv[i - 1] * self.modinv[i] % self.mod", "facinv[i - 1] * self.modinv[i]", "facinv[i - 1]", "facinv", "i - 1", "i", "1", "self.modinv[i]", "self.modinv", "self", "modinv", "i", "self.mod", "self", "mod", "return fac, facinv", "return fac, facinv", "fac", "facinv", "self", "self", "n", "n", "def make_modinv_list(self, n):\n # 0からnまでのmod逆元のリストを返す O(n)\n modinv = [0] * (n + 1)\n modinv[1] = 1\n for i in range(2, n + 1):\n modinv[i] = self.mod - self.mod // i * modinv[self.mod % i] % self.mod\n return modinv", "make_modinv_list", "modinv = [0] * (n + 1)", "modinv", "[0] * (n + 1)", "[0]", "0", "n + 1", "n", "1", "modinv[1] = 1", "modinv[1]", "modinv", "1", "1", "for i in range(2, n + 1):\n modinv[i] = self.mod - self.mod // i * modinv[self.mod % i] % self.mod\n ", "i", "range(2, n + 1)", "range", "2", "n + 1", "n", "1", "modinv[i] = self.mod - self.mod // i * modinv[self.mod % i] % self.mod", "modinv[i]", "modinv", "i", "self.mod - self.mod // i * modinv[self.mod % i] % self.mod", "self.mod", "self", "mod", "self.mod // i * modinv[self.mod % i] % self.mod", "self.mod // i * modinv[self.mod % i]", "self.mod // i", "self.mod", "self", "mod", "i", "modinv[self.mod % i]", "modinv", "self.mod % i", "self.mod", "self", "mod", "i", "self.mod", "self", "mod", "return modinv", "modinv", "self", "self", "n", "n", "comb = Combination(1000000)", "comb", "Combination(1000000)", "Combination", "1000000", "MOD = 10**9+7", "MOD", "10**9+7", "10**9", "10", "9", "7", "ans = 0", "ans", "0", "for i in range(B,W):\n ans += comb(H-A-1+i,i)*comb(A-1+W-1-i,A-1)\n ans %= MOD\n #print(comb(H-A-1+i,i)*comb(A-1+W-1-i,A-1))", "i", "range(B,W)", "range", "B", "W", "ans += comb(H-A-1+i,i)*comb(A-1+W-1-i,A-1)", "ans", "comb(H-A-1+i,i)*comb(A-1+W-1-i,A-1)", "comb(H-A-1+i,i)", "comb", "H-A-1+i", "H-A-1", "H-A", "H", "A", "1", "i", "i", "comb(A-1+W-1-i,A-1)", "comb", "A-1+W-1-i", "A-1+W-1", "A-1+W", "A-1", "A", "1", "W", "1", "i", "A-1", "A", "1", "ans %= MOD", "ans", "MOD", "print(ans)", "print", "ans", "class Combination:\n \"\"\"\n O(n)の前計算を1回行うことで，O(1)でnCr mod mを求められる\n n_max = 10**6のとき前処理は約950ms (PyPyなら約340ms, 10**7で約1800ms)\n 使用例：\n comb = Combination(1000000)\n print(comb(5, 3)) # 10\n \"\"\"\n\n def __init__(self, n_max, mod=10 ** 9 + 7):\n self.mod = mod\n self.modinv = self.make_modinv_list(n_max)\n self.fac, self.facinv = self.make_factorial_list(n_max)\n\n def __call__(self, n, r):\n return self.fac[n] * self.facinv[r] % self.mod * self.facinv[n - r] % self.mod\n\n def make_factorial_list(self, n):\n # 階乗のリストと階乗のmod逆元のリストを返す O(n)\n # self.make_modinv_list()が先に実行されている必要がある\n fac = [1]\n facinv = [1]\n for i in range(1, n + 1):\n fac.append(fac[i - 1] * i % self.mod)\n facinv.append(facinv[i - 1] * self.modinv[i] % self.mod)\n return fac, facinv\n\n def make_modinv_list(self, n):\n # 0からnまでのmod逆元のリストを返す O(n)\n modinv = [0] * (n + 1)\n modinv[1] = 1\n for i in range(2, n + 1):\n modinv[i] = self.mod - self.mod // i * modinv[self.mod % i] % self.mod\n return modinv", "class Combination:\n \"\"\"\n O(n)の前計算を1回行うことで，O(1)でnCr mod mを求められる\n n_max = 10**6のとき前処理は約950ms (PyPyなら約340ms, 10**7で約1800ms)\n 使用例：\n comb = Combination(1000000)\n print(comb(5, 3)) # 10\n \"\"\"\n\n def __init__(self, n_max, mod=10 ** 9 + 7):\n self.mod = mod\n self.modinv = self.make_modinv_list(n_max)\n self.fac, self.facinv = self.make_factorial_list(n_max)\n\n def __call__(self, n, r):\n return self.fac[n] * self.facinv[r] % self.mod * self.facinv[n - r] % self.mod\n\n def make_factorial_list(self, n):\n # 階乗のリストと階乗のmod逆元のリストを返す O(n)\n # self.make_modinv_list()が先に実行されている必要がある\n fac = [1]\n facinv = [1]\n for i in range(1, n + 1):\n fac.append(fac[i - 1] * i % self.mod)\n facinv.append(facinv[i - 1] * self.modinv[i] % self.mod)\n return fac, facinv\n\n def make_modinv_list(self, n):\n # 0からnまでのmod逆元のリストを返す O(n)\n modinv = [0] * (n + 1)\n modinv[1] = 1\n for i in range(2, n + 1):\n modinv[i] = self.mod - self.mod // i * modinv[self.mod % i] % self.mod\n return modinv", "Combination", "comb = Combination(1000000)", "Combination(1000000)", "comb", "MOD = 10**9+7", "10**9+7", "MOD", "A,B = map(int,input().split())", "map(int,input().split())", "A", "ans = 0", "0", "ans", "B = map(int,input().split())", "map(int,input().split())", "B", "ans += comb(H-A-1+i,i)*comb(A-1+W-1-i,A-1)", "comb(H-A-1+i,i)*comb(A-1+W-1-i,A-1)", "ans", "W,A,B = map(int,input().split())", "map(int,input().split())", "W", "ans %= MOD", "MOD", "ans", "H,W,A,B = map(int,input().split())", "map(int,input().split())", "H" ]

[ 7, 6, 13, 12, 13, 0, 18, 13, 13, 13, 0, 18, 13, 13, 13, 0, 18, 13, 13, 39, 17, 0, 18, 13, 13, 39, 17, 28, 13, 4, 13, 17, 2, 18, 13, 13, 17, 4, 18, 18, 13, 13, 13, 2, 2, 18, 18, 13, 13, 17, 4, 13, 13, 2, 18, 13, 13, 17, 18, 13, 13, 18, 13, 13, 4, 18, 18, 13, 13, 13, 2, 2, 18, 18, 13, 13, 17, 13, 18, 13, 13, 23, 13, 23, 13, 23, 13, 12, 13, 29, 2, 2, 2, 18, 18, 13, 13, 2, 13, 13, 18, 18, 13, 13, 13, 18, 18, 13, 13, 13, 18, 13, 13, 23, 13, 23, 13, 23, 13, 13, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 13, 13, 0, 13, 2, 2, 17, 17, 17, 0, 13, 4, 13, 2, 13, 13, 13, 0, 13, 17, 28, 13, 4, 13, 2, 13, 17, 2, 13, 17, 0, 13, 2, 2, 4, 18, 13, 13, 2, 2, 2, 13, 13, 13, 17, 2, 13, 17, 4, 18, 13, 13, 2, 2, 2, 13, 13, 13, 17, 2, 13, 17, 13, 0, 13, 13, 4, 13, 13, 10, 6, 13, 10, 4, 13, 10, 2, 13, 10, 13, 13, 10, 4, 13, 10, 4, 13, 10, 4, 13, 10, 2, 13, 10, 4, 13, 10, 17, 13 ]

[ [ 9, 6 ], [ 82, 7 ], [ 84, 8 ], [ 84, 9 ], [ 14, 11 ], [ 82, 12 ], [ 86, 13 ], [ 86, 14 ], [ 19, 16 ], [ 82, 17 ], [ 25, 22 ], [ 82, 23 ], [ 29, 28 ], [ 6, 33 ], [ 82, 34 ], [ 84, 35 ], [ 16, 39 ], [ 82, 40 ], [ 16, 46 ], [ 82, 47 ], [ 28, 52 ], [ 11, 54 ], [ 82, 55 ], [ 86, 56 ], [ 11, 58 ], [ 82, 59 ], [ 86, 60 ], [ 11, 61 ], [ 82, 62 ], [ 86, 63 ], [ 22, 66 ], [ 82, 67 ], [ 22, 73 ], [ 82, 74 ], [ 28, 77 ], [ 11, 78 ], [ 82, 79 ], [ 86, 80 ], [ 82, 82 ], [ 84, 84 ], [ 86, 86 ], [ 114, 95 ], [ 116, 98 ], [ 118, 99 ], [ 114, 102 ], [ 118, 104 ], [ 114, 107 ], [ 116, 109 ], [ 114, 111 ], [ 114, 114 ], [ 116, 116 ], [ 118, 118 ], [ 225, 121 ], [ 225, 130 ], [ 225, 131 ], [ 225, 132 ], [ 207, 134 ], [ 219, 141 ], [ 214, 145 ], [ 205, 146 ], [ 208, 147 ], [ 228, 149 ], [ 153, 152 ], [ 226, 156 ], [ 205, 159 ], [ 222, 162 ], [ 220, 167 ], [ 88, 168 ], [ 214, 172 ], [ 217, 173 ], [ 152, 174 ], [ 152, 177 ], [ 220, 181 ], [ 88, 182 ], [ 217, 186 ], [ 205, 187 ], [ 152, 188 ], [ 217, 191 ], [ 208, 193 ], [ 210, 195 ], [ 208, 196 ], [ 211, 199 ], [ 223, 199 ], [ 229, 199 ], [ 225, 205 ], [ 207, 208 ], [ 208, 210 ], [ 210, 211 ], [ 225, 214 ], [ 225, 217 ], [ 219, 220 ], [ 222, 223 ], [ 225, 226 ], [ 228, 229 ] ]

[ "class combnk_mod(object):\n # pが素数かつaとpが互いに素であるとき\n # フェルマーの小定理より以下が成り立つ.\n # 1 / a = a ** (p - 2) (mod p)\n # これを使って (1 / k!) mod p を計算する.\n def __init__(self, maxn, p):\n self.maxn = maxn\n self.p = p\n self.x = [1] # 分母にあたる数 1 / n! mod p\n self.y = [1] # 分子にあたる数. n! mod p\n for i in range(1, self.maxn + 1):\n self.x.append(self.x[-1] * pow(i, self.p - 2, self.p) % self.p)\n self.y.append(self.y[-1] * i % self.p)\n\n def combnk(self, n, k):\n return (self.x[n - k] * self.x[k] * self.y[n]) % self.p\n\nh, w, a, b = map(int, input().split())\nMOD = 10 ** 9 + 7\nc = combnk_mod(h + w, MOD)\nans = 0\nfor i in range(b + 1, w + 1):\n ans += c.combnk(h - a + i - 2, i - 1) * c.combnk(a + w - i - 1, a - 1) % MOD\n ans %= MOD\nprint(ans)", "class combnk_mod(object):\n # pが素数かつaとpが互いに素であるとき\n # フェルマーの小定理より以下が成り立つ.\n # 1 / a = a ** (p - 2) (mod p)\n # これを使って (1 / k!) mod p を計算する.\n def __init__(self, maxn, p):\n self.maxn = maxn\n self.p = p\n self.x = [1] # 分母にあたる数 1 / n! mod p\n self.y = [1] # 分子にあたる数. n! mod p\n for i in range(1, self.maxn + 1):\n self.x.append(self.x[-1] * pow(i, self.p - 2, self.p) % self.p)\n self.y.append(self.y[-1] * i % self.p)\n\n def combnk(self, n, k):\n return (self.x[n - k] * self.x[k] * self.y[n]) % self.p", "combnk_mod", "def __init__(self, maxn, p):\n self.maxn = maxn\n self.p = p\n self.x = [1] # 分母にあたる数 1 / n! mod p\n self.y = [1] # 分子にあたる数. n! mod p\n for i in range(1, self.maxn + 1):\n self.x.append(self.x[-1] * pow(i, self.p - 2, self.p) % self.p)\n self.y.append(self.y[-1] * i % self.p)\n\n ", "__init__", "self.maxn = maxn", "self.maxn", "self", "maxn", "maxn", "self.p = p", "self.p", "self", "p", "p", "self.x = [1]", "self.x", "self", "x", "[1]", "1", "self.y = [1]", "self.y", "self", "y", "[1]", "1", "for i in range(1, self.maxn + 1):\n self.x.append(self.x[-1] * pow(i, self.p - 2, self.p) % self.p)\n self.y.append(self.y[-1] * i % self.p)\n\n ", "i", "range(1, self.maxn + 1)", "range", "1", "self.maxn + 1", "self.maxn", "self", "maxn", "1", "self.x.append(self.x[-1] * pow(i, self.p - 2, self.p) % self.p)", "self.x.append", "self.x", "self", "x", "append", "self.x[-1] * pow(i, self.p - 2, self.p) % self.p", "self.x[-1] * pow(i, self.p - 2, self.p)", "self.x[-1]", "self.x", "self", "x", "-1", "pow(i, self.p - 2, self.p)", "pow", "i", "self.p - 2", "self.p", "self", "p", "2", "self.p", "self", "p", "self.p", "self", "p", "self.y.append(self.y[-1] * i % self.p)", "self.y.append", "self.y", "self", "y", "append", "self.y[-1] * i % self.p", "self.y[-1] * i", "self.y[-1]", "self.y", "self", "y", "-1", "i", "self.p", "self", "p", "self", "self", "maxn", "maxn", "p", "p", "def combnk(self, n, k):\n return (self.x[n - k] * self.x[k] * self.y[n]) % self.p", "combnk", "return (self.x[n - k] * self.x[k] * self.y[n]) % self.p", "(self.x[n - k] * self.x[k] * self.y[n]) % self.p", "self.x[n - k] * self.x[k] * self.y[n]", "self.x[n - k] * self.x[k]", "self.x[n - k]", "self.x", "self", "x", "n - k", "n", "k", "self.x[k]", "self.x", "self", "x", "k", "self.y[n]", "self.y", "self", "y", "n", "self.p", "self", "p", "self", "self", "n", "n", "k", "k", "object", "h, w, a, b = map(int, input().split())", "h", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "w", "a", "b", "MOD = 10 ** 9 + 7", "MOD", "10 ** 9 + 7", "10 ** 9", "10", "9", "7", "c = combnk_mod(h + w, MOD)", "c", "combnk_mod(h + w, MOD)", "combnk_mod", "h + w", "h", "w", "MOD", "ans = 0", "ans", "0", "for i in range(b + 1, w + 1):\n ans += c.combnk(h - a + i - 2, i - 1) * c.combnk(a + w - i - 1, a - 1) % MOD\n ans %= MOD", "i", "range(b + 1, w + 1)", "range", "b + 1", "b", "1", "w + 1", "w", "1", "ans += c.combnk(h - a + i - 2, i - 1) * c.combnk(a + w - i - 1, a - 1) % MOD", "ans", "c.combnk(h - a + i - 2, i - 1) * c.combnk(a + w - i - 1, a - 1) % MOD", "c.combnk(h - a + i - 2, i - 1) * c.combnk(a + w - i - 1, a - 1)", "c.combnk(h - a + i - 2, i - 1)", "c.combnk", "c", "combnk", "h - a + i - 2", "h - a + i", "h - a", "h", "a", "i", "2", "i - 1", "i", "1", "c.combnk(a + w - i - 1, a - 1)", "c.combnk", "c", "combnk", "a + w - i - 1", "a + w - i", "a + w", "a", "w", "i", "1", "a - 1", "a", "1", "MOD", "ans %= MOD", "ans", "MOD", "print(ans)", "print", "ans", "class combnk_mod(object):\n # pが素数かつaとpが互いに素であるとき\n # フェルマーの小定理より以下が成り立つ.\n # 1 / a = a ** (p - 2) (mod p)\n # これを使って (1 / k!) mod p を計算する.\n def __init__(self, maxn, p):\n self.maxn = maxn\n self.p = p\n self.x = [1] # 分母にあたる数 1 / n! mod p\n self.y = [1] # 分子にあたる数. n! mod p\n for i in range(1, self.maxn + 1):\n self.x.append(self.x[-1] * pow(i, self.p - 2, self.p) % self.p)\n self.y.append(self.y[-1] * i % self.p)\n\n def combnk(self, n, k):\n return (self.x[n - k] * self.x[k] * self.y[n]) % self.p", "class combnk_mod(object):\n # pが素数かつaとpが互いに素であるとき\n # フェルマーの小定理より以下が成り立つ.\n # 1 / a = a ** (p - 2) (mod p)\n # これを使って (1 / k!) mod p を計算する.\n def __init__(self, maxn, p):\n self.maxn = maxn\n self.p = p\n self.x = [1] # 分母にあたる数 1 / n! mod p\n self.y = [1] # 分子にあたる数. n! mod p\n for i in range(1, self.maxn + 1):\n self.x.append(self.x[-1] * pow(i, self.p - 2, self.p) % self.p)\n self.y.append(self.y[-1] * i % self.p)\n\n def combnk(self, n, k):\n return (self.x[n - k] * self.x[k] * self.y[n]) % self.p", "combnk_mod", "w, a, b = map(int, input().split())", "map(int, input().split())", "w", "MOD = 10 ** 9 + 7", "10 ** 9 + 7", "MOD", "ans %= MOD", "MOD", "ans", "h, w, a, b = map(int, input().split())", "map(int, input().split())", "h", "a, b = map(int, input().split())", "map(int, input().split())", "a", "c = combnk_mod(h + w, MOD)", "combnk_mod(h + w, MOD)", "c", "ans += c.combnk(h - a + i - 2, i - 1) * c.combnk(a + w - i - 1, a - 1) % MOD", "c.combnk(h - a + i - 2, i - 1) * c.combnk(a + w - i - 1, a - 1) % MOD", "ans", "b = map(int, input().split())", "map(int, input().split())", "b", "ans = 0", "0", "ans" ]

[ 7, 15, 13, 0, 13, 4, 13, 2, 17, 17, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 13, 13, 0, 13, 39, 17, 28, 13, 4, 13, 17, 2, 2, 13, 13, 17, 4, 18, 13, 13, 2, 2, 18, 13, 17, 13, 13, 0, 13, 39, 4, 13, 18, 13, 17, 2, 13, 17, 13, 28, 13, 4, 13, 4, 13, 17, 2, 2, 13, 13, 17, 4, 18, 13, 13, 2, 2, 18, 13, 17, 13, 13, 4, 18, 13, 13, 12, 13, 29, 2, 2, 18, 13, 13, 18, 13, 2, 13, 13, 18, 13, 13, 23, 13, 23, 13, 0, 13, 2, 2, 13, 13, 17, 0, 13, 17, 28, 13, 4, 13, 13, 13, 0, 13, 2, 4, 13, 2, 13, 13, 13, 4, 13, 2, 2, 2, 13, 13, 13, 17, 2, 13, 17, 0, 13, 13, 4, 13, 4, 13, 13, 10, 39, 13, 10, 2, 13, 10, 39, 13, 10, 4, 13, 10, 4, 13, 10, 4, 13, 10, 4, 13, 10, 12, 13, 10, 13, 13, 10, 2, 13, 10, 4, 13, 10, 17, 13 ]

[ [ 162, 4 ], [ 183, 11 ], [ 183, 20 ], [ 183, 21 ], [ 183, 22 ], [ 153, 24 ], [ 29, 28 ], [ 166, 34 ], [ 184, 35 ], [ 154, 39 ], [ 154, 44 ], [ 28, 46 ], [ 163, 47 ], [ 159, 49 ], [ 154, 54 ], [ 163, 57 ], [ 163, 59 ], [ 62, 61 ], [ 166, 69 ], [ 184, 70 ], [ 160, 74 ], [ 160, 79 ], [ 61, 81 ], [ 163, 82 ], [ 160, 85 ], [ 154, 93 ], [ 104, 94 ], [ 160, 96 ], [ 104, 98 ], [ 106, 99 ], [ 160, 101 ], [ 106, 102 ], [ 104, 104 ], [ 106, 106 ], [ 156, 108 ], [ 184, 111 ], [ 169, 112 ], [ 186, 115 ], [ 119, 118 ], [ 172, 121 ], [ 166, 122 ], [ 180, 124 ], [ 175, 127 ], [ 118, 129 ], [ 157, 130 ], [ 157, 131 ], [ 175, 133 ], [ 166, 137 ], [ 118, 138 ], [ 169, 139 ], [ 169, 142 ], [ 177, 145 ], [ 163, 146 ], [ 178, 151 ], [ 181, 151 ], [ 187, 151 ], [ 153, 154 ], [ 156, 157 ], [ 159, 160 ], [ 162, 163 ], [ 183, 166 ], [ 183, 169 ], [ 183, 172 ], [ 163, 177 ], [ 177, 178 ], [ 180, 181 ], [ 183, 184 ], [ 186, 187 ] ]

[ "# coding: UTF-8\nimport numpy as np\n\nMOD = int(1e+9+7)\nH, W, A, B = map(int, input().split())\n\nfact = [1]\nfor i in range(1, W+H-1):\n fact.append((fact[-1]*i) % MOD)\n\nifact = [pow(fact[-1], MOD-2, MOD)]\nfor i in reversed(range(1, W+H-1)):\n ifact.append((ifact[-1]*i) % MOD)\nifact.reverse()\n\n\ndef comb(n, r):\n return fact[n]*ifact[n-r]*ifact[r]\n\n\nr = H-A-1\ns = 0\nfor c in range(B, W):\n s += comb(c+r, r) * comb(W-c+A-2, A-1)\n s %= MOD\n\nprint(int(s))", "import numpy as np", "numpy", "MOD = int(1e+9+7)", "MOD", "int(1e+9+7)", "int", "1e+9+7", "1e+9", "7", "H, W, A, B = map(int, input().split())", "H", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "W", "A", "B", "fact = [1]", "fact", "[1]", "1", "for i in range(1, W+H-1):\n fact.append((fact[-1]*i) % MOD)", "i", "range(1, W+H-1)", "range", "1", "W+H-1", "W+H", "W", "H", "1", "fact.append((fact[-1]*i) % MOD)", "fact.append", "fact", "append", "(fact[-1]*i) % MOD", "fact[-1]*i", "fact[-1]", "fact", "-1", "i", "MOD", "ifact = [pow(fact[-1], MOD-2, MOD)]", "ifact", "[pow(fact[-1], MOD-2, MOD)]", "pow(fact[-1], MOD-2, MOD)", "pow", "fact[-1]", "fact", "-1", "MOD-2", "MOD", "2", "MOD", "for i in reversed(range(1, W+H-1)):\n ifact.append((ifact[-1]*i) % MOD)", "i", "reversed(range(1, W+H-1))", "reversed", "range(1, W+H-1)", "range", "1", "W+H-1", "W+H", "W", "H", "1", "ifact.append((ifact[-1]*i) % MOD)", "ifact.append", "ifact", "append", "(ifact[-1]*i) % MOD", "ifact[-1]*i", "ifact[-1]", "ifact", "-1", "i", "MOD", "ifact.reverse()", "ifact.reverse", "ifact", "reverse", "def comb(n, r):\n return fact[n]*ifact[n-r]*ifact[r]", "comb", "return fact[n]*ifact[n-r]*ifact[r]", "fact[n]*ifact[n-r]*ifact[r]", "fact[n]*ifact[n-r]", "fact[n]", "fact", "n", "ifact[n-r]", "ifact", "n-r", "n", "r", "ifact[r]", "ifact", "r", "n", "n", "r", "r", "r = H-A-1", "r", "H-A-1", "H-A", "H", "A", "1", "s = 0", "s", "0", "for c in range(B, W):\n s += comb(c+r, r) * comb(W-c+A-2, A-1)\n s %= MOD", "c", "range(B, W)", "range", "B", "W", "s += comb(c+r, r) * comb(W-c+A-2, A-1)", "s", "comb(c+r, r) * comb(W-c+A-2, A-1)", "comb(c+r, r)", "comb", "c+r", "c", "r", "r", "comb(W-c+A-2, A-1)", "comb", "W-c+A-2", "W-c+A", "W-c", "W", "c", "A", "2", "A-1", "A", "1", "s %= MOD", "s", "MOD", "print(int(s))", "print", "int(s)", "int", "s", "fact = [1]", "[1]", "fact", "r = H-A-1", "H-A-1", "r", "ifact = [pow(fact[-1], MOD-2, MOD)]", "[pow(fact[-1], MOD-2, MOD)]", "ifact", "MOD = int(1e+9+7)", "int(1e+9+7)", "MOD", "W, A, B = map(int, input().split())", "map(int, input().split())", "W", "A, B = map(int, input().split())", "map(int, input().split())", "A", "B = map(int, input().split())", "map(int, input().split())", "B", "def comb(n, r):\n return fact[n]*ifact[n-r]*ifact[r]", "def comb(n, r):\n return fact[n]*ifact[n-r]*ifact[r]", "comb", "s %= MOD", "MOD", "s", "s += comb(c+r, r) * comb(W-c+A-2, A-1)", "comb(c+r, r) * comb(W-c+A-2, A-1)", "s", "H, W, A, B = map(int, input().split())", "map(int, input().split())", "H", "s = 0", "0", "s" ]

[ 7, 0, 13, 2, 2, 17, 17, 17, 12, 13, 14, 2, 13, 17, 29, 17, 29, 2, 2, 2, 4, 13, 13, 2, 13, 17, 17, 2, 13, 2, 13, 17, 13, 23, 13, 23, 13, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 13, 13, 41, 28, 13, 4, 13, 2, 2, 13, 13, 17, 4, 17, 0, 13, 13, 0, 18, 13, 17, 17, 28, 13, 4, 13, 2, 2, 13, 13, 17, 0, 18, 13, 2, 13, 17, 2, 2, 18, 13, 13, 2, 13, 17, 13, 41, 28, 13, 4, 13, 2, 2, 13, 13, 17, 4, 17, 0, 13, 13, 0, 18, 13, 2, 2, 13, 13, 17, 4, 13, 18, 13, 2, 2, 13, 13, 17, 2, 13, 17, 28, 13, 4, 13, 2, 2, 13, 13, 17, 17, 17, 0, 18, 13, 2, 13, 17, 2, 2, 18, 13, 13, 13, 13, 0, 13, 17, 28, 13, 4, 13, 13, 13, 0, 13, 2, 2, 2, 2, 2, 2, 18, 13, 2, 2, 2, 13, 13, 17, 13, 18, 13, 2, 2, 13, 13, 17, 13, 18, 13, 13, 13, 2, 2, 2, 2, 18, 13, 2, 2, 2, 2, 13, 17, 13, 13, 17, 18, 13, 2, 2, 13, 17, 13, 13, 18, 13, 2, 13, 17, 13, 13, 0, 13, 13, 4, 13, 13, 10, 17, 13, 10, 12, 13, 10, 4, 13, 10, 13, 13, 10, 2, 13, 10, 2, 13, 10, 4, 13, 10, 13, 13, 10, 4, 13, 10, 4, 13, 10, 13, 13 ]

[ [ 240, 2 ], [ 36, 12 ], [ 34, 22 ], [ 36, 24 ], [ 34, 28 ], [ 36, 30 ], [ 241, 32 ], [ 34, 34 ], [ 36, 36 ], [ 255, 38 ], [ 255, 47 ], [ 255, 48 ], [ 255, 49 ], [ 53, 52 ], [ 247, 57 ], [ 235, 58 ], [ 258, 63 ], [ 69, 66 ], [ 259, 67 ], [ 72, 71 ], [ 247, 76 ], [ 235, 77 ], [ 85, 80 ], [ 259, 81 ], [ 71, 83 ], [ 259, 88 ], [ 71, 89 ], [ 71, 91 ], [ 241, 93 ], [ 97, 96 ], [ 247, 101 ], [ 235, 102 ], [ 249, 107 ], [ 117, 110 ], [ 250, 111 ], [ 247, 114 ], [ 235, 115 ], [ 232, 118 ], [ 259, 120 ], [ 247, 123 ], [ 235, 124 ], [ 241, 127 ], [ 131, 130 ], [ 247, 135 ], [ 235, 136 ], [ 146, 141 ], [ 250, 142 ], [ 130, 144 ], [ 250, 149 ], [ 130, 150 ], [ 130, 151 ], [ 241, 152 ], [ 228, 154 ], [ 158, 157 ], [ 256, 160 ], [ 235, 161 ], [ 243, 163 ], [ 259, 171 ], [ 247, 175 ], [ 253, 176 ], [ 157, 178 ], [ 250, 180 ], [ 247, 183 ], [ 253, 184 ], [ 241, 186 ], [ 250, 188 ], [ 157, 189 ], [ 241, 190 ], [ 259, 196 ], [ 235, 201 ], [ 157, 203 ], [ 253, 204 ], [ 250, 207 ], [ 235, 210 ], [ 157, 212 ], [ 241, 213 ], [ 250, 215 ], [ 253, 217 ], [ 241, 219 ], [ 241, 220 ], [ 237, 222 ], [ 241, 223 ], [ 238, 226 ], [ 244, 226 ], [ 229, 226 ], [ 228, 229 ], [ 255, 235 ], [ 241, 237 ], [ 237, 238 ], [ 240, 241 ], [ 243, 244 ], [ 255, 247 ], [ 249, 250 ], [ 255, 253 ], [ 255, 256 ], [ 258, 259 ] ]

[ "K = 10 ** 9 + 7\n\ndef pow_K(x, n):\n if n == 0:\n return 1\n else:\n return (pow_K(x, n // 2) ** 2 * x ** (n % 2)) % K\n\nH, W, A, B = map(int, input().split())\n\nfact = [0 for i in range(H+W-1)]\nfact[0] = 1\nfor i in range(H+W-2):\n fact[i + 1] = fact[i] * (i+1) % K\nfact_inv = [0 for i in range(H+W-1)]\nfact_inv[H+W-2] = pow_K(fact[H+W-2], K-2)\nfor i in range(H+W-2, 0, -1):\n fact_inv[i-1] = fact_inv[i] * i % K\n\nr = 0\nfor i in range(B, W):\n r += ((fact[H-A-1+i] * fact_inv[H-A-1] %K)*fact_inv[i] % K) * ((fact[W-1-i+A-1] * fact_inv[W-1-i] %K) * fact_inv[A-1] % K) %K\n r %= K\n\nprint(r)\n\n", "K = 10 ** 9 + 7", "K", "10 ** 9 + 7", "10 ** 9", "10", "9", "7", "def pow_K(x, n):\n if n == 0:\n return 1\n else:\n return (pow_K(x, n // 2) ** 2 * x ** (n % 2)) % K", "pow_K", "if n == 0:\n return 1\n else:\n return (pow_K(x, n // 2) ** 2 * x ** (n % 2)) % K", "n == 0", "n", "0", "return 1", "1", "return (pow_K(x, n // 2) ** 2 * x ** (n % 2)) % K", "(pow_K(x, n // 2) ** 2 * x ** (n % 2)) % K", "pow_K(x, n // 2) ** 2 * x ** (n % 2)", "pow_K(x, n // 2) ** 2", "pow_K(x, n // 2)", "pow_K", "x", "n // 2", "n", "2", "2", "x ** (n % 2)", "x", "n % 2", "n", "2", "K", "x", "x", "n", "n", "H, W, A, B = map(int, input().split())", "H", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "W", "A", "B", "0 for i in range(H+W-1)", "for i in range(H+W-1)", "i", "range(H+W-1)", "range", "H+W-1", "H+W", "H", "W", "1", "for i in range(H+W-1)", "0", "fact = [0 for i in range(H+W-1)]", "fact", "[0 for i in range(H+W-1)]", "fact[0] = 1", "fact[0]", "fact", "0", "1", "for i in range(H+W-2):\n fact[i + 1] = fact[i] * (i+1) % K", "i", "range(H+W-2)", "range", "H+W-2", "H+W", "H", "W", "2", "fact[i + 1] = fact[i] * (i+1) % K", "fact[i + 1]", "fact", "i + 1", "i", "1", "fact[i] * (i+1) % K", "fact[i] * (i+1)", "fact[i]", "fact", "i", "i+1", "i", "1", "K", "0 for i in range(H+W-1)", "for i in range(H+W-1)", "i", "range(H+W-1)", "range", "H+W-1", "H+W", "H", "W", "1", "for i in range(H+W-1)", "0", "fact_inv = [0 for i in range(H+W-1)]", "fact_inv", "[0 for i in range(H+W-1)]", "fact_inv[H+W-2] = pow_K(fact[H+W-2], K-2)", "fact_inv[H+W-2]", "fact_inv", "H+W-2", "H+W", "H", "W", "2", "pow_K(fact[H+W-2], K-2)", "pow_K", "fact[H+W-2]", "fact", "H+W-2", "H+W", "H", "W", "2", "K-2", "K", "2", "for i in range(H+W-2, 0, -1):\n fact_inv[i-1] = fact_inv[i] * i % K", "i", "range(H+W-2, 0, -1)", "range", "H+W-2", "H+W", "H", "W", "2", "0", "-1", "fact_inv[i-1] = fact_inv[i] * i % K", "fact_inv[i-1]", "fact_inv", "i-1", "i", "1", "fact_inv[i] * i % K", "fact_inv[i] * i", "fact_inv[i]", "fact_inv", "i", "i", "K", "r = 0", "r", "0", "for i in range(B, W):\n r += ((fact[H-A-1+i] * fact_inv[H-A-1] %K)*fact_inv[i] % K) * ((fact[W-1-i+A-1] * fact_inv[W-1-i] %K) * fact_inv[A-1] % K) %K\n r %= K", "i", "range(B, W)", "range", "B", "W", "r += ((fact[H-A-1+i] * fact_inv[H-A-1] %K)*fact_inv[i] % K) * ((fact[W-1-i+A-1] * fact_inv[W-1-i] %K) * fact_inv[A-1] % K) %K", "r", "((fact[H-A-1+i] * fact_inv[H-A-1] %K)*fact_inv[i] % K) * ((fact[W-1-i+A-1] * fact_inv[W-1-i] %K) * fact_inv[A-1] % K) %K", "((fact[H-A-1+i] * fact_inv[H-A-1] %K)*fact_inv[i] % K) * ((fact[W-1-i+A-1] * fact_inv[W-1-i] %K) * fact_inv[A-1] % K)", "(fact[H-A-1+i] * fact_inv[H-A-1] %K)*fact_inv[i] % K", "(fact[H-A-1+i] * fact_inv[H-A-1] %K)*fact_inv[i]", "fact[H-A-1+i] * fact_inv[H-A-1] %K", "fact[H-A-1+i] * fact_inv[H-A-1]", "fact[H-A-1+i]", "fact", "H-A-1+i", "H-A-1", "H-A", "H", "A", "1", "i", "fact_inv[H-A-1]", "fact_inv", "H-A-1", "H-A", "H", "A", "1", "K", "fact_inv[i]", "fact_inv", "i", "K", "(fact[W-1-i+A-1] * fact_inv[W-1-i] %K) * fact_inv[A-1] % K", "(fact[W-1-i+A-1] * fact_inv[W-1-i] %K) * fact_inv[A-1]", "fact[W-1-i+A-1] * fact_inv[W-1-i] %K", "fact[W-1-i+A-1] * fact_inv[W-1-i]", "fact[W-1-i+A-1]", "fact", "W-1-i+A-1", "W-1-i+A", "W-1-i", "W-1", "W", "1", "i", "A", "1", "fact_inv[W-1-i]", "fact_inv", "W-1-i", "W-1", "W", "1", "i", "K", "fact_inv[A-1]", "fact_inv", "A-1", "A", "1", "K", "K", "r %= K", "r", "K", "print(r)", "print", "r", "r = 0", "0", "r", "def pow_K(x, n):\n if n == 0:\n return 1\n else:\n return (pow_K(x, n // 2) ** 2 * x ** (n % 2)) % K", "def pow_K(x, n):\n if n == 0:\n return 1\n else:\n return (pow_K(x, n // 2) ** 2 * x ** (n % 2)) % K", "pow_K", "W, A, B = map(int, input().split())", "map(int, input().split())", "W", "r %= K", "K", "r", "K = 10 ** 9 + 7", "10 ** 9 + 7", "K", "r += ((fact[H-A-1+i] * fact_inv[H-A-1] %K)*fact_inv[i] % K) * ((fact[W-1-i+A-1] * fact_inv[W-1-i] %K) * fact_inv[A-1] % K) %K", "((fact[H-A-1+i] * fact_inv[H-A-1] %K)*fact_inv[i] % K) * ((fact[W-1-i+A-1] * fact_inv[W-1-i] %K) * fact_inv[A-1] % K) %K", "r", "H, W, A, B = map(int, input().split())", "map(int, input().split())", "H", "fact_inv = [0 for i in range(H+W-1)]", "[0 for i in range(H+W-1)]", "fact_inv", "A, B = map(int, input().split())", "map(int, input().split())", "A", "B = map(int, input().split())", "map(int, input().split())", "B", "fact = [0 for i in range(H+W-1)]", "[0 for i in range(H+W-1)]", "fact" ]

[ 7, 0, 13, 17, 12, 13, 17, 0, 13, 17, 0, 13, 13, 42, 2, 13, 17, 14, 2, 13, 17, 0, 13, 2, 2, 13, 13, 13, 0, 13, 2, 2, 13, 13, 13, 0, 13, 17, 29, 13, 23, 13, 23, 13, 23, 13, 12, 13, 17, 29, 4, 13, 0, 13, 13, 0, 13, 2, 13, 17, 0, 13, 13, 23, 13, 23, 13, 6, 13, 17, 12, 13, 17, 0, 18, 13, 13, 13, 0, 18, 13, 13, 13, 0, 18, 13, 13, 39, 17, 17, 0, 18, 13, 13, 39, 17, 17, 0, 18, 13, 13, 39, 17, 17, 28, 13, 4, 13, 17, 2, 18, 13, 13, 17, 4, 18, 18, 13, 13, 13, 2, 2, 18, 18, 13, 13, 2, 13, 17, 13, 18, 13, 13, 4, 18, 18, 13, 13, 13, 2, 18, 13, 13, 2, 2, 18, 18, 13, 13, 2, 18, 13, 13, 13, 2, 18, 13, 13, 13, 18, 13, 13, 4, 18, 18, 13, 13, 13, 2, 2, 18, 18, 13, 13, 2, 13, 17, 18, 18, 13, 13, 13, 18, 13, 13, 23, 13, 23, 13, 23, 13, 12, 13, 17, 14, 40, 2, 2, 17, 13, 13, 37, 13, 0, 13, 2, 2, 18, 18, 13, 13, 13, 18, 18, 13, 13, 2, 13, 13, 18, 13, 13, 29, 2, 2, 18, 18, 13, 13, 13, 13, 18, 13, 13, 23, 13, 23, 13, 23, 13, 12, 13, 14, 2, 2, 13, 17, 2, 13, 17, 29, 17, 29, 4, 18, 13, 13, 2, 13, 13, 13, 23, 13, 23, 13, 23, 13, 12, 13, 0, 13, 4, 13, 0, 13, 13, 0, 13, 2, 13, 13, 0, 13, 39, 2, 13, 17, 2, 13, 13, 0, 13, 17, 42, 2, 40, 18, 13, 17, 13, 2, 18, 13, 17, 17, 0, 13, 39, 2, 18, 13, 17, 17, 2, 18, 13, 17, 17, 0, 13, 39, 2, 13, 18, 13, 17, 2, 13, 18, 13, 17, 0, 13, 4, 13, 13, 31, 13, 0, 13, 4, 13, 13, 31, 13, 0, 13, 2, 2, 13, 13, 13, 0, 13, 13, 0, 13, 13, 0, 13, 39, 2, 18, 13, 17, 17, 2, 18, 13, 17, 17, 29, 13, 23, 13, 23, 13, 23, 13, 23, 13, 12, 13, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 13, 13, 4, 13, 4, 13, 13, 13, 13, 13, 14, 2, 13, 17, 4, 13, 10, 17, 13, 10, 12, 13, 10, 12, 13, 10, 12, 13, 10, 6, 13, 10, 12, 13, 10, 12, 13 ]

[ [ 411, 2 ], [ 9, 8 ], [ 12, 11 ], [ 41, 12 ], [ 43, 15 ], [ 36, 15 ], [ 43, 19 ], [ 36, 19 ], [ 23, 22 ], [ 8, 25 ], [ 22, 25 ], [ 11, 26 ], [ 29, 26 ], [ 45, 27 ], [ 30, 29 ], [ 11, 32 ], [ 29, 32 ], [ 11, 33 ], [ 29, 33 ], [ 45, 34 ], [ 37, 36 ], [ 22, 39 ], [ 8, 39 ], [ 41, 41 ], [ 43, 43 ], [ 45, 45 ], [ 421, 51 ], [ 54, 53 ], [ 53, 54 ], [ 64, 54 ], [ 57, 56 ], [ 66, 58 ], [ 62, 61 ], [ 61, 62 ], [ 66, 62 ], [ 64, 64 ], [ 66, 66 ], [ 77, 74 ], [ 186, 75 ], [ 188, 76 ], [ 188, 77 ], [ 82, 79 ], [ 186, 80 ], [ 190, 81 ], [ 190, 82 ], [ 87, 84 ], [ 186, 85 ], [ 94, 91 ], [ 186, 92 ], [ 101, 98 ], [ 186, 99 ], [ 106, 105 ], [ 79, 110 ], [ 186, 111 ], [ 190, 112 ], [ 84, 116 ], [ 186, 117 ], [ 84, 123 ], [ 186, 124 ], [ 105, 127 ], [ 105, 129 ], [ 74, 130 ], [ 186, 131 ], [ 188, 132 ], [ 91, 135 ], [ 186, 136 ], [ 74, 140 ], [ 186, 141 ], [ 188, 142 ], [ 91, 146 ], [ 186, 147 ], [ 74, 150 ], [ 186, 151 ], [ 188, 152 ], [ 105, 153 ], [ 74, 155 ], [ 186, 156 ], [ 188, 157 ], [ 105, 158 ], [ 74, 159 ], [ 186, 160 ], [ 188, 161 ], [ 98, 164 ], [ 186, 165 ], [ 98, 171 ], [ 186, 172 ], [ 105, 175 ], [ 91, 178 ], [ 186, 179 ], [ 105, 181 ], [ 74, 182 ], [ 186, 183 ], [ 188, 184 ], [ 186, 186 ], [ 188, 188 ], [ 190, 190 ], [ 239, 199 ], [ 237, 200 ], [ 205, 204 ], [ 235, 209 ], [ 239, 211 ], [ 235, 214 ], [ 237, 217 ], [ 239, 218 ], [ 235, 220 ], [ 235, 227 ], [ 237, 229 ], [ 204, 230 ], [ 235, 232 ], [ 235, 235 ], [ 237, 237 ], [ 239, 239 ], [ 264, 245 ], [ 266, 248 ], [ 262, 255 ], [ 192, 256 ], [ 264, 258 ], [ 266, 259 ], [ 264, 260 ], [ 262, 262 ], [ 264, 264 ], [ 266, 266 ], [ 271, 270 ], [ 275, 274 ], [ 412, 275 ], [ 278, 277 ], [ 374, 279 ], [ 376, 280 ], [ 283, 282 ], [ 380, 285 ], [ 374, 288 ], [ 378, 289 ], [ 292, 291 ], [ 282, 297 ], [ 359, 297 ], [ 376, 299 ], [ 282, 302 ], [ 359, 302 ], [ 307, 306 ], [ 282, 310 ], [ 359, 310 ], [ 282, 315 ], [ 359, 315 ], [ 320, 319 ], [ 376, 322 ], [ 282, 324 ], [ 359, 324 ], [ 374, 327 ], [ 282, 329 ], [ 359, 329 ], [ 333, 332 ], [ 427, 334 ], [ 270, 335 ], [ 306, 337 ], [ 340, 339 ], [ 427, 341 ], [ 270, 342 ], [ 319, 344 ], [ 347, 346 ], [ 332, 349 ], [ 339, 350 ], [ 412, 351 ], [ 354, 353 ], [ 346, 354 ], [ 357, 356 ], [ 412, 357 ], [ 360, 359 ], [ 282, 363 ], [ 359, 363 ], [ 282, 368 ], [ 359, 368 ], [ 356, 372 ], [ 353, 372 ], [ 291, 372 ], [ 374, 374 ], [ 376, 376 ], [ 378, 378 ], [ 380, 380 ], [ 385, 384 ], [ 385, 393 ], [ 385, 394 ], [ 385, 395 ], [ 418, 399 ], [ 384, 400 ], [ 393, 401 ], [ 394, 402 ], [ 395, 403 ], [ 415, 409 ], [ 411, 412 ] ]

[ "MOD = 1000000007\n\n\ndef mod_pow(a, n, mod):\n \"\"\"\n 二分累乗法による a^n (mod m)の実装\n\n :param a: 累乗の底\n :param n: 累乗の指数\n :param mod: 法\n :return: a^n (mod m)\n \"\"\"\n\n result = 1\n a_n = a\n while n > 0:\n if n & 1:\n result = result * a_n % mod\n a_n = a_n * a_n % mod\n n >>= 1\n return result\n\n\ndef mod_inverse(a, mod):\n \"\"\"\n フェルマーの小定理による a^-1 ≡ 1 (mod m)の実装\n aの逆元を計算する\n\n a^-1 ≡ 1 (mod m)\n a * a^-2 ≡ 1 (mod m)\n a^-2 ≡ a^-1 (mod m)\n\n :param a: 逆元を計算したい数\n :param mod: 法\n :return: a^-1 ≡ 1 (mod m)\n \"\"\"\n\n return mod_pow(a=a, n=mod - 2, mod=mod)\n\n\nclass ModCombination:\n \"\"\"\n nCk (mod m)を扱うクラス\n \"\"\"\n\n def __init__(self, mod, n_max):\n \"\"\"\n イニシャライザ\n 予め 1~nの階乗と階乗の逆元を計算しておく\n\n :param mod: 法\n :param n_max: nの最大値(100,000で約1秒)\n \"\"\"\n self.mod = mod\n self.n_max = n_max\n self.facts = [1, 1]\n self.inverses = [None, 1]\n self.fact_inverses = [1, 1]\n\n for i in range(2, self.n_max + 1):\n self.facts.append(self.facts[i - 1] * i % self.mod)\n # self.inverses.append(mod_inverse(i, self.mod))\n self.inverses.append(self.mod - self.inverses[self.mod % i] * (\n self.mod // i) % self.mod)\n self.fact_inverses.append(\n self.fact_inverses[i - 1] * self.inverses[i] % self.mod\n )\n\n def mod_combination(self, n, k):\n \"\"\"\n nCk (mod m)を計算する\n\n :param n: n\n :param k: k\n :return: nCk (mod m)\n \"\"\"\n if not 0 < k < n:\n raise ValueError\n\n denominator = \\\n self.fact_inverses[k] * self.fact_inverses[n - k] % self.mod\n return self.facts[n] * denominator % self.mod\n\n\ndef calc_routes(combination, dx, dy):\n if dx == 0 or dy == 0:\n return 1\n else:\n return combination.mod_combination(dx + dy, dx)\n\n\ndef check(h, w, a, b):\n combination = ModCombination(mod=MOD, n_max=h + w)\n p = (b + 1, h - a)\n all_routes = 0\n while p[0] <= w and p[1] > 0:\n d1 = (p[0] - 1, p[1] - 1)\n d2 = (w - p[0], h - p[1])\n r1 = calc_routes(combination, *d1)\n r2 = calc_routes(combination, *d2)\n routes = r1 * r2 % MOD\n all_routes += routes\n all_routes %= MOD\n p = (p[0] + 1, p[1] - 1)\n return all_routes\n\n\ndef main():\n h, w, a, b = map(int, input().split())\n print(check(h, w, a, b))\n\n\nif __name__ == '__main__':\n main()", "MOD = 1000000007", "MOD", "1000000007", "def mod_pow(a, n, mod):\n \"\"\"\n 二分累乗法による a^n (mod m)の実装\n\n :param a: 累乗の底\n :param n: 累乗の指数\n :param mod: 法\n :return: a^n (mod m)\n \"\"\"\n\n result = 1\n a_n = a\n while n > 0:\n if n & 1:\n result = result * a_n % mod\n a_n = a_n * a_n % mod\n n >>= 1\n return result", "mod_pow", "\"\"\"\n 二分累乗法による a^n (mod m)の実装\n\n :param a: 累乗の底\n :param n: 累乗の指数\n :param mod: 法\n :return: a^n (mod m)\n \"\"\"", "result = 1", "result", "1", "a_n = a", "a_n", "a", "while n > 0:\n if n & 1:\n result = result * a_n % mod\n a_n = a_n * a_n % mod\n n >>= 1\n ", "n > 0", "n", "0", "if n & 1:\n result = result * a_n % mod\n ", "n & 1", "n", "1", "result = result * a_n % mod", "result", "result * a_n % mod", "result * a_n", "result", "a_n", "mod", "a_n = a_n * a_n % mod", "a_n", "a_n * a_n % mod", "a_n * a_n", "a_n", "a_n", "mod", "n >>= 1", "n", "1", "return result", "result", "a", "a", "n", "n", "mod", "mod", "def mod_inverse(a, mod):\n \"\"\"\n フェルマーの小定理による a^-1 ≡ 1 (mod m)の実装\n aの逆元を計算する\n\n a^-1 ≡ 1 (mod m)\n a * a^-2 ≡ 1 (mod m)\n a^-2 ≡ a^-1 (mod m)\n\n :param a: 逆元を計算したい数\n :param mod: 法\n :return: a^-1 ≡ 1 (mod m)\n \"\"\"\n\n return mod_pow(a=a, n=mod - 2, mod=mod)", "mod_inverse", "\"\"\"\n フェルマーの小定理による a^-1 ≡ 1 (mod m)の実装\n aの逆元を計算する\n\n a^-1 ≡ 1 (mod m)\n a * a^-2 ≡ 1 (mod m)\n a^-2 ≡ a^-1 (mod m)\n\n :param a: 逆元を計算したい数\n :param mod: 法\n :return: a^-1 ≡ 1 (mod m)\n \"\"\"", "return mod_pow(a=a, n=mod - 2, mod=mod)", "mod_pow(a=a, n=mod - 2, mod=mod)", "mod_pow", "a=a", "a", "a", "n=mod - 2", "n", "mod - 2", "mod", "2", "mod=mod", "mod", "mod", "a", "a", "mod", "mod", "class ModCombination:\n \"\"\"\n nCk (mod m)を扱うクラス\n \"\"\"\n\n def __init__(self, mod, n_max):\n \"\"\"\n イニシャライザ\n 予め 1~nの階乗と階乗の逆元を計算しておく\n\n :param mod: 法\n :param n_max: nの最大値(100,000で約1秒)\n \"\"\"\n self.mod = mod\n self.n_max = n_max\n self.facts = [1, 1]\n self.inverses = [None, 1]\n self.fact_inverses = [1, 1]\n\n for i in range(2, self.n_max + 1):\n self.facts.append(self.facts[i - 1] * i % self.mod)\n # self.inverses.append(mod_inverse(i, self.mod))\n self.inverses.append(self.mod - self.inverses[self.mod % i] * (\n self.mod // i) % self.mod)\n self.fact_inverses.append(\n self.fact_inverses[i - 1] * self.inverses[i] % self.mod\n )\n\n def mod_combination(self, n, k):\n \"\"\"\n nCk (mod m)を計算する\n\n :param n: n\n :param k: k\n :return: nCk (mod m)\n \"\"\"\n if not 0 < k < n:\n raise ValueError\n\n denominator = \\\n self.fact_inverses[k] * self.fact_inverses[n - k] % self.mod\n return self.facts[n] * denominator % self.mod", "ModCombination", "\"\"\"\n nCk (mod m)を扱うクラス\n \"\"\"", "def __init__(self, mod, n_max):\n \"\"\"\n イニシャライザ\n 予め 1~nの階乗と階乗の逆元を計算しておく\n\n :param mod: 法\n :param n_max: nの最大値(100,000で約1秒)\n \"\"\"\n self.mod = mod\n self.n_max = n_max\n self.facts = [1, 1]\n self.inverses = [None, 1]\n self.fact_inverses = [1, 1]\n\n for i in range(2, self.n_max + 1):\n self.facts.append(self.facts[i - 1] * i % self.mod)\n # self.inverses.append(mod_inverse(i, self.mod))\n self.inverses.append(self.mod - self.inverses[self.mod % i] * (\n self.mod // i) % self.mod)\n self.fact_inverses.append(\n self.fact_inverses[i - 1] * self.inverses[i] % self.mod\n )\n\n ", "__init__", "\"\"\"\n イニシャライザ\n 予め 1~nの階乗と階乗の逆元を計算しておく\n\n :param mod: 法\n :param n_max: nの最大値(100,000で約1秒)\n \"\"\"", "self.mod = mod", "self.mod", "self", "mod", "mod", "self.n_max = n_max", "self.n_max", "self", "n_max", "n_max", "self.facts = [1, 1]", "self.facts", "self", "facts", "[1, 1]", "1", "1", "self.inverses = [None, 1]", "self.inverses", "self", "inverses", "[None, 1]", "None", "1", "self.fact_inverses = [1, 1]", "self.fact_inverses", "self", "fact_inverses", "[1, 1]", "1", "1", "for i in range(2, self.n_max + 1):\n self.facts.append(self.facts[i - 1] * i % self.mod)\n # self.inverses.append(mod_inverse(i, self.mod))\n self.inverses.append(self.mod - self.inverses[self.mod % i] * (\n self.mod // i) % self.mod)\n self.fact_inverses.append(\n self.fact_inverses[i - 1] * self.inverses[i] % self.mod\n )\n\n ", "i", "range(2, self.n_max + 1)", "range", "2", "self.n_max + 1", "self.n_max", "self", "n_max", "1", "self.facts.append(self.facts[i - 1] * i % self.mod)", "self.facts.append", "self.facts", "self", "facts", "append", "self.facts[i - 1] * i % self.mod", "self.facts[i - 1] * i", "self.facts[i - 1]", "self.facts", "self", "facts", "i - 1", "i", "1", "i", "self.mod", "self", "mod", "self.inverses.append(self.mod - self.inverses[self.mod % i] * (\n self.mod // i) % self.mod)", "self.inverses.append", "self.inverses", "self", "inverses", "append", "self.mod - self.inverses[self.mod % i] * (\n self.mod // i) % self.mod", "self.mod", "self", "mod", "self.inverses[self.mod % i] * (\n self.mod // i) % self.mod", "self.inverses[self.mod % i] * (\n self.mod // i)", "self.inverses[self.mod % i]", "self.inverses", "self", "inverses", "self.mod % i", "self.mod", "self", "mod", "i", "self.mod // i", "self.mod", "self", "mod", "i", "self.mod", "self", "mod", "self.fact_inverses.append(\n self.fact_inverses[i - 1] * self.inverses[i] % self.mod\n )", "self.fact_inverses.append", "self.fact_inverses", "self", "fact_inverses", "append", "self.fact_inverses[i - 1] * self.inverses[i] % self.mod", "self.fact_inverses[i - 1] * self.inverses[i]", "self.fact_inverses[i - 1]", "self.fact_inverses", "self", "fact_inverses", "i - 1", "i", "1", "self.inverses[i]", "self.inverses", "self", "inverses", "i", "self.mod", "self", "mod", "self", "self", "mod", "mod", "n_max", "n_max", "def mod_combination(self, n, k):\n \"\"\"\n nCk (mod m)を計算する\n\n :param n: n\n :param k: k\n :return: nCk (mod m)\n \"\"\"\n if not 0 < k < n:\n raise ValueError\n\n denominator = \\\n self.fact_inverses[k] * self.fact_inverses[n - k] % self.mod\n return self.facts[n] * denominator % self.mod", "mod_combination", "\"\"\"\n nCk (mod m)を計算する\n\n :param n: n\n :param k: k\n :return: nCk (mod m)\n \"\"\"", "if not 0 < k < n:\n raise ValueError\n\n ", "not 0 < k < n", "0 < k < n", "0 < k", "0", "k", "n", "raise ValueError", "ValueError", "denominator = \\\n self.fact_inverses[k] * self.fact_inverses[n - k] % self.mod", "denominator", "self.fact_inverses[k] * self.fact_inverses[n - k] % self.mod", "self.fact_inverses[k] * self.fact_inverses[n - k]", "self.fact_inverses[k]", "self.fact_inverses", "self", "fact_inverses", "k", "self.fact_inverses[n - k]", "self.fact_inverses", "self", "fact_inverses", "n - k", "n", "k", "self.mod", "self", "mod", "return self.facts[n] * denominator % self.mod", "self.facts[n] * denominator % self.mod", "self.facts[n] * denominator", "self.facts[n]", "self.facts", "self", "facts", "n", "denominator", "self.mod", "self", "mod", "self", "self", "n", "n", "k", "k", "def calc_routes(combination, dx, dy):\n if dx == 0 or dy == 0:\n return 1\n else:\n return combination.mod_combination(dx + dy, dx)", "calc_routes", "if dx == 0 or dy == 0:\n return 1\n else:\n return combination.mod_combination(dx + dy, dx)", "dx == 0 or dy == 0", "dx == 0", "dx", "0", "dy == 0", "dy", "0", "return 1", "1", "return combination.mod_combination(dx + dy, dx)", "combination.mod_combination(dx + dy, dx)", "combination.mod_combination", "combination", "mod_combination", "dx + dy", "dx", "dy", "dx", "combination", "combination", "dx", "dx", "dy", "dy", "def check(h, w, a, b):\n combination = ModCombination(mod=MOD, n_max=h + w)\n p = (b + 1, h - a)\n all_routes = 0\n while p[0] <= w and p[1] > 0:\n d1 = (p[0] - 1, p[1] - 1)\n d2 = (w - p[0], h - p[1])\n r1 = calc_routes(combination, *d1)\n r2 = calc_routes(combination, *d2)\n routes = r1 * r2 % MOD\n all_routes += routes\n all_routes %= MOD\n p = (p[0] + 1, p[1] - 1)\n return all_routes", "check", "combination = ModCombination(mod=MOD, n_max=h + w)", "combination", "ModCombination(mod=MOD, n_max=h + w)", "ModCombination", "mod=MOD", "mod", "MOD", "n_max=h + w", "n_max", "h + w", "h", "w", "p = (b + 1, h - a)", "p", "(b + 1, h - a)", "b + 1", "b", "1", "h - a", "h", "a", "all_routes = 0", "all_routes", "0", "while p[0] <= w and p[1] > 0:\n d1 = (p[0] - 1, p[1] - 1)\n d2 = (w - p[0], h - p[1])\n r1 = calc_routes(combination, *d1)\n r2 = calc_routes(combination, *d2)\n routes = r1 * r2 % MOD\n all_routes += routes\n all_routes %= MOD\n p = (p[0] + 1, p[1] - 1)\n ", "p[0] <= w and p[1] > 0", "p[0] <= w", "p[0]", "p", "0", "w", "p[1] > 0", "p[1]", "p", "1", "0", "d1 = (p[0] - 1, p[1] - 1)", "d1", "(p[0] - 1, p[1] - 1)", "p[0] - 1", "p[0]", "p", "0", "1", "p[1] - 1", "p[1]", "p", "1", "1", "d2 = (w - p[0], h - p[1])", "d2", "(w - p[0], h - p[1])", "w - p[0]", "w", "p[0]", "p", "0", "h - p[1]", "h", "p[1]", "p", "1", "r1 = calc_routes(combination, *d1)", "r1", "calc_routes(combination, *d1)", "calc_routes", "combination", "*d1", "d1", "r2 = calc_routes(combination, *d2)", "r2", "calc_routes(combination, *d2)", "calc_routes", "combination", "*d2", "d2", "routes = r1 * r2 % MOD", "routes", "r1 * r2 % MOD", "r1 * r2", "r1", "r2", "MOD", "all_routes += routes", "all_routes", "routes", "all_routes %= MOD", "all_routes", "MOD", "p = (p[0] + 1, p[1] - 1)", "p", "(p[0] + 1, p[1] - 1)", "p[0] + 1", "p[0]", "p", "0", "1", "p[1] - 1", "p[1]", "p", "1", "1", "return all_routes", "all_routes", "h", "h", "w", "w", "a", "a", "b", "b", "def main():\n h, w, a, b = map(int, input().split())\n print(check(h, w, a, b))", "main", "h, w, a, b = map(int, input().split())", "h", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "w", "a", "b", "print(check(h, w, a, b))", "print", "check(h, w, a, b)", "check", "h", "w", "a", "b", "if __name__ == '__main__':\n main()", "__name__ == '__main__'", "__name__", "'__main__'", "main()", "main", "MOD = 1000000007", "1000000007", "MOD", "def main():\n h, w, a, b = map(int, input().split())\n print(check(h, w, a, b))", "def main():\n h, w, a, b = map(int, input().split())\n print(check(h, w, a, b))", "main", "def check(h, w, a, b):\n combination = ModCombination(mod=MOD, n_max=h + w)\n p = (b + 1, h - a)\n all_routes = 0\n while p[0] <= w and p[1] > 0:\n d1 = (p[0] - 1, p[1] - 1)\n d2 = (w - p[0], h - p[1])\n r1 = calc_routes(combination, *d1)\n r2 = calc_routes(combination, *d2)\n routes = r1 * r2 % MOD\n all_routes += routes\n all_routes %= MOD\n p = (p[0] + 1, p[1] - 1)\n return all_routes", "def check(h, w, a, b):\n combination = ModCombination(mod=MOD, n_max=h + w)\n p = (b + 1, h - a)\n all_routes = 0\n while p[0] <= w and p[1] > 0:\n d1 = (p[0] - 1, p[1] - 1)\n d2 = (w - p[0], h - p[1])\n r1 = calc_routes(combination, *d1)\n r2 = calc_routes(combination, *d2)\n routes = r1 * r2 % MOD\n all_routes += routes\n all_routes %= MOD\n p = (p[0] + 1, p[1] - 1)\n return all_routes", "check", "def mod_pow(a, n, mod):\n \"\"\"\n 二分累乗法による a^n (mod m)の実装\n\n :param a: 累乗の底\n :param n: 累乗の指数\n :param mod: 法\n :return: a^n (mod m)\n \"\"\"\n\n result = 1\n a_n = a\n while n > 0:\n if n & 1:\n result = result * a_n % mod\n a_n = a_n * a_n % mod\n n >>= 1\n return result", "def mod_pow(a, n, mod):\n \"\"\"\n 二分累乗法による a^n (mod m)の実装\n\n :param a: 累乗の底\n :param n: 累乗の指数\n :param mod: 法\n :return: a^n (mod m)\n \"\"\"\n\n result = 1\n a_n = a\n while n > 0:\n if n & 1:\n result = result * a_n % mod\n a_n = a_n * a_n % mod\n n >>= 1\n return result", "mod_pow", "class ModCombination:\n \"\"\"\n nCk (mod m)を扱うクラス\n \"\"\"\n\n def __init__(self, mod, n_max):\n \"\"\"\n イニシャライザ\n 予め 1~nの階乗と階乗の逆元を計算しておく\n\n :param mod: 法\n :param n_max: nの最大値(100,000で約1秒)\n \"\"\"\n self.mod = mod\n self.n_max = n_max\n self.facts = [1, 1]\n self.inverses = [None, 1]\n self.fact_inverses = [1, 1]\n\n for i in range(2, self.n_max + 1):\n self.facts.append(self.facts[i - 1] * i % self.mod)\n # self.inverses.append(mod_inverse(i, self.mod))\n self.inverses.append(self.mod - self.inverses[self.mod % i] * (\n self.mod // i) % self.mod)\n self.fact_inverses.append(\n self.fact_inverses[i - 1] * self.inverses[i] % self.mod\n )\n\n def mod_combination(self, n, k):\n \"\"\"\n nCk (mod m)を計算する\n\n :param n: n\n :param k: k\n :return: nCk (mod m)\n \"\"\"\n if not 0 < k < n:\n raise ValueError\n\n denominator = \\\n self.fact_inverses[k] * self.fact_inverses[n - k] % self.mod\n return self.facts[n] * denominator % self.mod", "class ModCombination:\n \"\"\"\n nCk (mod m)を扱うクラス\n \"\"\"\n\n def __init__(self, mod, n_max):\n \"\"\"\n イニシャライザ\n 予め 1~nの階乗と階乗の逆元を計算しておく\n\n :param mod: 法\n :param n_max: nの最大値(100,000で約1秒)\n \"\"\"\n self.mod = mod\n self.n_max = n_max\n self.facts = [1, 1]\n self.inverses = [None, 1]\n self.fact_inverses = [1, 1]\n\n for i in range(2, self.n_max + 1):\n self.facts.append(self.facts[i - 1] * i % self.mod)\n # self.inverses.append(mod_inverse(i, self.mod))\n self.inverses.append(self.mod - self.inverses[self.mod % i] * (\n self.mod // i) % self.mod)\n self.fact_inverses.append(\n self.fact_inverses[i - 1] * self.inverses[i] % self.mod\n )\n\n def mod_combination(self, n, k):\n \"\"\"\n nCk (mod m)を計算する\n\n :param n: n\n :param k: k\n :return: nCk (mod m)\n \"\"\"\n if not 0 < k < n:\n raise ValueError\n\n denominator = \\\n self.fact_inverses[k] * self.fact_inverses[n - k] % self.mod\n return self.facts[n] * denominator % self.mod", "ModCombination", "def calc_routes(combination, dx, dy):\n if dx == 0 or dy == 0:\n return 1\n else:\n return combination.mod_combination(dx + dy, dx)", "def calc_routes(combination, dx, dy):\n if dx == 0 or dy == 0:\n return 1\n else:\n return combination.mod_combination(dx + dy, dx)", "calc_routes", "def mod_inverse(a, mod):\n \"\"\"\n フェルマーの小定理による a^-1 ≡ 1 (mod m)の実装\n aの逆元を計算する\n\n a^-1 ≡ 1 (mod m)\n a * a^-2 ≡ 1 (mod m)\n a^-2 ≡ a^-1 (mod m)\n\n :param a: 逆元を計算したい数\n :param mod: 法\n :return: a^-1 ≡ 1 (mod m)\n \"\"\"\n\n return mod_pow(a=a, n=mod - 2, mod=mod)", "def mod_inverse(a, mod):\n \"\"\"\n フェルマーの小定理による a^-1 ≡ 1 (mod m)の実装\n aの逆元を計算する\n\n a^-1 ≡ 1 (mod m)\n a * a^-2 ≡ 1 (mod m)\n a^-2 ≡ a^-1 (mod m)\n\n :param a: 逆元を計算したい数\n :param mod: 法\n :return: a^-1 ≡ 1 (mod m)\n \"\"\"\n\n return mod_pow(a=a, n=mod - 2, mod=mod)", "mod_inverse" ]

[ 7, 0, 13, 17, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 13, 13, 0, 13, 39, 17, 28, 13, 4, 13, 17, 2, 13, 13, 4, 18, 13, 13, 2, 2, 18, 13, 2, 13, 17, 13, 13, 12, 13, 14, 2, 13, 17, 14, 2, 13, 17, 14, 2, 2, 13, 17, 17, 23, 13, 23, 13, 0, 13, 2, 39, 17, 2, 13, 13, 0, 18, 13, 2, 2, 13, 13, 17, 4, 13, 18, 13, 2, 2, 13, 13, 17, 2, 13, 17, 28, 13, 4, 13, 2, 2, 13, 13, 17, 17, 17, 0, 18, 13, 13, 2, 2, 18, 13, 2, 13, 17, 2, 13, 17, 13, 12, 13, 29, 2, 2, 2, 18, 13, 13, 18, 13, 13, 18, 13, 2, 13, 13, 13, 23, 13, 23, 13, 0, 13, 17, 28, 13, 4, 13, 2, 13, 17, 2, 13, 17, 0, 13, 2, 2, 13, 2, 4, 13, 2, 2, 2, 2, 13, 13, 17, 13, 17, 2, 13, 17, 4, 13, 2, 2, 2, 13, 17, 13, 13, 2, 13, 13, 13, 13, 10, 4, 13, 10, 39, 13, 10, 17, 13, 10, 4, 13, 10, 4, 13, 10, 12, 13, 10, 2, 13, 10, 17, 13, 10, 4, 13, 10, 2, 13, 10, 12, 13 ]

[ [ 207, 2 ], [ 210, 5 ], [ 210, 14 ], [ 210, 15 ], [ 210, 16 ], [ 189, 18 ], [ 23, 22 ], [ 196, 27 ], [ 211, 28 ], [ 190, 31 ], [ 190, 36 ], [ 22, 38 ], [ 22, 40 ], [ 208, 41 ], [ 61, 46 ], [ 61, 50 ], [ 61, 55 ], [ 59, 59 ], [ 61, 61 ], [ 204, 63 ], [ 196, 68 ], [ 211, 69 ], [ 78, 71 ], [ 205, 72 ], [ 196, 75 ], [ 211, 76 ], [ 202, 79 ], [ 190, 81 ], [ 196, 84 ], [ 211, 85 ], [ 208, 88 ], [ 92, 91 ], [ 196, 96 ], [ 211, 97 ], [ 105, 102 ], [ 205, 103 ], [ 91, 104 ], [ 205, 108 ], [ 91, 110 ], [ 91, 113 ], [ 208, 115 ], [ 190, 123 ], [ 135, 124 ], [ 205, 126 ], [ 137, 127 ], [ 205, 129 ], [ 135, 131 ], [ 137, 132 ], [ 208, 133 ], [ 135, 135 ], [ 137, 137 ], [ 192, 139 ], [ 143, 142 ], [ 199, 146 ], [ 211, 149 ], [ 213, 152 ], [ 193, 155 ], [ 214, 155 ], [ 217, 158 ], [ 196, 163 ], [ 187, 164 ], [ 142, 166 ], [ 142, 169 ], [ 217, 172 ], [ 187, 176 ], [ 211, 178 ], [ 142, 179 ], [ 211, 181 ], [ 142, 182 ], [ 208, 183 ], [ 210, 187 ], [ 189, 190 ], [ 192, 193 ], [ 210, 196 ], [ 210, 199 ], [ 204, 205 ], [ 207, 208 ], [ 210, 211 ], [ 213, 214 ] ]

[ "mod = 1000000007\nH, W, A, B = map(int, raw_input().split())\n\nfactorial = [1]\nfor n in xrange(1, H+W):\n factorial.append(factorial[n-1]*n%mod)\n\ndef power(x, y):\n if y == 0 : return 1\n elif y == 1 : return x % mod\n elif y % 2 == 0 : return power(x, y/2)**2 % mod\n else : return power(x, y/2)**2 * x % mod\n\ninverseFactorial = [0] * (H+W)\ninverseFactorial[H+W-1] = power(factorial[H+W-1], mod-2)\nfor n in xrange(H+W-2, -1, -1):\n inverseFactorial[n] = inverseFactorial[n+1] * (n+1) % mod\n\ndef combi(n, m):\n return factorial[n] * inverseFactorial[m] * inverseFactorial[n-m] % mod\n\nsum = 0\nfor i in xrange(B+1, W+1):\n sum = (sum + combi(H-A-1+i-1, i-1) * combi(A-1+W-i, W-i)) % mod\nprint sum", "mod = 1000000007", "mod", "1000000007", "H, W, A, B = map(int, raw_input().split())", "H", "map(int, raw_input().split())", "map", "int", "raw_input().split()", "().split", "()", "raw_input", "split", "W", "A", "B", "factorial = [1]", "factorial", "[1]", "1", "for n in xrange(1, H+W):\n factorial.append(factorial[n-1]*n%mod)", "n", "xrange(1, H+W)", "xrange", "1", "H+W", "H", "W", "factorial.append(factorial[n-1]*n%mod)", "factorial.append", "factorial", "append", "factorial[n-1]*n%mod", "factorial[n-1]*n", "factorial[n-1]", "factorial", "n-1", "n", "1", "n", "mod", "def power(x, y):\n if y == 0 : return 1\n elif y == 1 : return x % mod\n elif y % 2 == 0 : return power(x, y/2)**2 % mod\n else : return power(x, y/2)**2 * x % mod", "power", "if y == 0 : return 1\n elif y == 1 : return x % mod\n elif y % 2 == 0 : return power(x, y/2)**2 % mod\n else : return power(x, y/2)**2 * x % mod", "y == 0", "y", "0", "elif y == 1 : return x % mod\n ", "y == 1", "y", "1", "elif y % 2 == 0 : return power(x, y/2)**2 % mod\n ", "y % 2 == 0", "y % 2", "y", "2", "0", "x", "x", "y", "y", "inverseFactorial = [0] * (H+W)", "inverseFactorial", "[0] * (H+W)", "[0]", "0", "H+W", "H", "W", "inverseFactorial[H+W-1] = power(factorial[H+W-1], mod-2)", "inverseFactorial[H+W-1]", "inverseFactorial", "H+W-1", "H+W", "H", "W", "1", "power(factorial[H+W-1], mod-2)", "power", "factorial[H+W-1]", "factorial", "H+W-1", "H+W", "H", "W", "1", "mod-2", "mod", "2", "for n in xrange(H+W-2, -1, -1):\n inverseFactorial[n] = inverseFactorial[n+1] * (n+1) % mod", "n", "xrange(H+W-2, -1, -1)", "xrange", "H+W-2", "H+W", "H", "W", "2", "-1", "-1", "inverseFactorial[n] = inverseFactorial[n+1] * (n+1) % mod", "inverseFactorial[n]", "inverseFactorial", "n", "inverseFactorial[n+1] * (n+1) % mod", "inverseFactorial[n+1] * (n+1)", "inverseFactorial[n+1]", "inverseFactorial", "n+1", "n", "1", "n+1", "n", "1", "mod", "def combi(n, m):\n return factorial[n] * inverseFactorial[m] * inverseFactorial[n-m] % mod", "combi", "return factorial[n] * inverseFactorial[m] * inverseFactorial[n-m] % mod", "factorial[n] * inverseFactorial[m] * inverseFactorial[n-m] % mod", "factorial[n] * inverseFactorial[m] * inverseFactorial[n-m]", "factorial[n] * inverseFactorial[m]", "factorial[n]", "factorial", "n", "inverseFactorial[m]", "inverseFactorial", "m", "inverseFactorial[n-m]", "inverseFactorial", "n-m", "n", "m", "mod", "n", "n", "m", "m", "sum = 0", "sum", "0", "for i in xrange(B+1, W+1):\n sum = (sum + combi(H-A-1+i-1, i-1) * combi(A-1+W-i, W-i)) % mod", "i", "xrange(B+1, W+1)", "xrange", "B+1", "B", "1", "W+1", "W", "1", "sum = (sum + combi(H-A-1+i-1, i-1) * combi(A-1+W-i, W-i)) % mod", "sum", "(sum + combi(H-A-1+i-1, i-1) * combi(A-1+W-i, W-i)) % mod", "sum + combi(H-A-1+i-1, i-1) * combi(A-1+W-i, W-i)", "sum", "combi(H-A-1+i-1, i-1) * combi(A-1+W-i, W-i)", "combi(H-A-1+i-1, i-1)", "combi", "H-A-1+i-1", "H-A-1+i", "H-A-1", "H-A", "H", "A", "1", "i", "1", "i-1", "i", "1", "combi(A-1+W-i, W-i)", "combi", "A-1+W-i", "A-1+W", "A-1", "A", "1", "W", "i", "W-i", "W", "i", "mod", "print", "A, B = map(int, raw_input().split())", "map(int, raw_input().split())", "A", "factorial = [1]", "[1]", "factorial", "sum = 0", "0", "sum", "H, W, A, B = map(int, raw_input().split())", "map(int, raw_input().split())", "H", "B = map(int, raw_input().split())", "map(int, raw_input().split())", "B", "def power(x, y):\n if y == 0 : return 1\n elif y == 1 : return x % mod\n elif y % 2 == 0 : return power(x, y/2)**2 % mod\n else : return power(x, y/2)**2 * x % mod", "def power(x, y):\n if y == 0 : return 1\n elif y == 1 : return x % mod\n elif y % 2 == 0 : return power(x, y/2)**2 % mod\n else : return power(x, y/2)**2 * x % mod", "power", "inverseFactorial = [0] * (H+W)", "[0] * (H+W)", "inverseFactorial", "mod = 1000000007", "1000000007", "mod", "W, A, B = map(int, raw_input().split())", "map(int, raw_input().split())", "W", "sum = (sum + combi(H-A-1+i-1, i-1) * combi(A-1+W-i, W-i)) % mod", "(sum + combi(H-A-1+i-1, i-1) * combi(A-1+W-i, W-i)) % mod", "sum", "def combi(n, m):\n return factorial[n] * inverseFactorial[m] * inverseFactorial[n-m] % mod", "def combi(n, m):\n return factorial[n] * inverseFactorial[m] * inverseFactorial[n-m] % mod", "combi" ]

[ 7, 0, 13, 2, 2, 17, 17, 17, 0, 13, 39, 17, 0, 13, 39, 17, 0, 13, 17, 28, 13, 4, 13, 17, 17, 0, 13, 13, 0, 13, 13, 4, 18, 13, 13, 13, 4, 18, 13, 13, 4, 13, 13, 2, 13, 17, 13, 12, 13, 29, 2, 2, 2, 2, 18, 13, 13, 18, 13, 13, 13, 18, 13, 2, 13, 13, 13, 23, 13, 23, 13, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 13, 13, 0, 13, 17, 0, 13, 2, 13, 17, 0, 13, 17, 0, 13, 2, 2, 2, 2, 13, 13, 17, 13, 17, 0, 13, 2, 13, 17, 28, 13, 4, 13, 2, 13, 13, 0, 13, 4, 13, 13, 13, 0, 13, 4, 13, 13, 13, 0, 13, 2, 2, 13, 2, 13, 13, 13, 0, 13, 17, 0, 13, 17, 0, 13, 17, 0, 13, 17, 4, 13, 13, 10, 39, 13, 10, 4, 13, 10, 17, 13, 10, 2, 13, 10, 2, 13, 10, 13, 13, 10, 17, 13, 10, 39, 13, 10, 4, 13, 10, 2, 13, 10, 17, 13, 10, 17, 13, 10, 17, 13, 10, 2, 13, 10, 2, 13, 10, 13, 13, 10, 4, 13, 10, 12, 13, 10, 17, 13, 10, 4, 13, 10, 4, 13, 10, 17, 13, 10, 4, 13 ]

[ [ 164, 2 ], [ 155, 9 ], [ 176, 13 ], [ 173, 17 ], [ 21, 20 ], [ 170, 26 ], [ 20, 27 ], [ 200, 29 ], [ 165, 30 ], [ 156, 33 ], [ 201, 35 ], [ 171, 35 ], [ 174, 35 ], [ 177, 38 ], [ 201, 42 ], [ 171, 42 ], [ 174, 42 ], [ 165, 44 ], [ 165, 46 ], [ 156, 55 ], [ 68, 56 ], [ 177, 58 ], [ 70, 59 ], [ 165, 60 ], [ 177, 62 ], [ 68, 64 ], [ 70, 65 ], [ 165, 66 ], [ 68, 68 ], [ 70, 70 ], [ 221, 72 ], [ 221, 81 ], [ 221, 82 ], [ 221, 83 ], [ 188, 85 ], [ 167, 88 ], [ 204, 90 ], [ 185, 93 ], [ 194, 96 ], [ 159, 101 ], [ 204, 102 ], [ 216, 104 ], [ 197, 107 ], [ 216, 109 ], [ 113, 112 ], [ 216, 116 ], [ 222, 117 ], [ 212, 119 ], [ 207, 121 ], [ 168, 122 ], [ 192, 122 ], [ 186, 123 ], [ 162, 123 ], [ 179, 125 ], [ 207, 127 ], [ 195, 128 ], [ 210, 128 ], [ 198, 129 ], [ 219, 129 ], [ 182, 131 ], [ 189, 134 ], [ 183, 134 ], [ 213, 136 ], [ 180, 137 ], [ 165, 138 ], [ 191, 140 ], [ 161, 143 ], [ 218, 146 ], [ 209, 149 ], [ 183, 153 ], [ 189, 153 ], [ 155, 156 ], [ 221, 159 ], [ 161, 162 ], [ 164, 165 ], [ 167, 168 ], [ 20, 170 ], [ 170, 171 ], [ 173, 174 ], [ 176, 177 ], [ 179, 180 ], [ 182, 183 ], [ 185, 186 ], [ 188, 189 ], [ 191, 192 ], [ 194, 195 ], [ 197, 198 ], [ 165, 200 ], [ 200, 201 ], [ 221, 204 ], [ 209, 210 ], [ 212, 213 ], [ 221, 216 ], [ 218, 219 ], [ 221, 222 ] ]

[ "P = 10**9+7\nfac = [1]\nifac = [1]\nff = 1\nfor i in range(1,200001):\n ff *= i\n ff %= P\n fac.append(ff)\n ifac.append(pow(ff, P-2, P))\ndef ncr(n, r): \n return (fac[n] * ifac[r] % P * ifac[n-r] % P);\n\nh,w,a,b = map(int,input().split())\ns = 0\nnC = b-1\nkC = 0\nnD = w-b-1+h-1\nkD = h-1\nfor i in range(h-a):\n C = ncr(nC, kC)\n D = ncr(nD, kD)\n s = (s + C * D) % P\n nC += 1\n kC += 1\n kD -= 1\n nD -= 1\nprint(s)", "P = 10**9+7", "P", "10**9+7", "10**9", "10", "9", "7", "fac = [1]", "fac", "[1]", "1", "ifac = [1]", "ifac", "[1]", "1", "ff = 1", "ff", "1", "for i in range(1,200001):\n ff *= i\n ff %= P\n fac.append(ff)\n ifac.append(pow(ff, P-2, P))", "i", "range(1,200001)", "range", "1", "200001", "ff *= i", "ff", "i", "ff %= P", "ff", "P", "fac.append(ff)", "fac.append", "fac", "append", "ff", "ifac.append(pow(ff, P-2, P))", "ifac.append", "ifac", "append", "pow(ff, P-2, P)", "pow", "ff", "P-2", "P", "2", "P", "def ncr(n, r): \n return (fac[n] * ifac[r] % P * ifac[n-r] % P);", "ncr", "return (fac[n] * ifac[r] % P * ifac[n-r] % P)", "fac[n] * ifac[r] % P * ifac[n-r] % P", "fac[n] * ifac[r] % P * ifac[n-r]", "fac[n] * ifac[r] % P", "fac[n] * ifac[r]", "fac[n]", "fac", "n", "ifac[r]", "ifac", "r", "P", "ifac[n-r]", "ifac", "n-r", "n", "r", "P", "n", "n", "r", "r", "h,w,a,b = map(int,input().split())", "h", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "w", "a", "b", "s = 0", "s", "0", "nC = b-1", "nC", "b-1", "b", "1", "kC = 0", "kC", "0", "nD = w-b-1+h-1", "nD", "w-b-1+h-1", "w-b-1+h", "w-b-1", "w-b", "w", "b", "1", "h", "1", "kD = h-1", "kD", "h-1", "h", "1", "for i in range(h-a):\n C = ncr(nC, kC)\n D = ncr(nD, kD)\n s = (s + C * D) % P\n nC += 1\n kC += 1\n kD -= 1\n nD -= 1", "i", "range(h-a)", "range", "h-a", "h", "a", "C = ncr(nC, kC)", "C", "ncr(nC, kC)", "ncr", "nC", "kC", "D = ncr(nD, kD)", "D", "ncr(nD, kD)", "ncr", "nD", "kD", "s = (s + C * D) % P", "s", "(s + C * D) % P", "s + C * D", "s", "C * D", "C", "D", "P", "nC += 1", "nC", "1", "kC += 1", "kC", "1", "kD -= 1", "kD", "1", "nD -= 1", "nD", "1", "print(s)", "print", "s", "fac = [1]", "[1]", "fac", "w,a,b = map(int,input().split())", "map(int,input().split())", "w", "kC += 1", "1", "kC", "P = 10**9+7", "10**9+7", "P", "nC = b-1", "b-1", "nC", "ff *= i", "i", "ff", "ff = 1", "1", "ff", "ifac = [1]", "[1]", "ifac", "D = ncr(nD, kD)", "ncr(nD, kD)", "D", "s = (s + C * D) % P", "(s + C * D) % P", "s", "kC = 0", "0", "kC", "s = 0", "0", "s", "nC += 1", "1", "nC", "nD = w-b-1+h-1", "w-b-1+h-1", "nD", "kD = h-1", "h-1", "kD", "ff %= P", "P", "ff", "b = map(int,input().split())", "map(int,input().split())", "b", "def ncr(n, r): \n return (fac[n] * ifac[r] % P * ifac[n-r] % P);", "def ncr(n, r): \n return (fac[n] * ifac[r] % P * ifac[n-r] % P);", "ncr", "nD -= 1", "1", "nD", "C = ncr(nC, kC)", "ncr(nC, kC)", "C", "h,w,a,b = map(int,input().split())", "map(int,input().split())", "h", "kD -= 1", "1", "kD", "a,b = map(int,input().split())", "map(int,input().split())", "a" ]

[ 7, 15, 13, 15, 13, 15, 13, 15, 13, 15, 13, 15, 15, 15, 15, 15, 15, 4, 18, 13, 13, 17, 12, 13, 29, 4, 13, 4, 13, 12, 13, 29, 4, 13, 4, 13, 13, 4, 18, 4, 13, 13, 12, 13, 29, 4, 13, 4, 13, 12, 13, 29, 4, 13, 4, 13, 13, 4, 18, 4, 13, 13, 12, 13, 29, 4, 18, 4, 13, 13, 12, 13, 29, 4, 13, 4, 13, 13, 4, 18, 4, 13, 13, 12, 13, 4, 13, 31, 13, 0, 13, 18, 13, 13, 23, 12, 13, 15, 13, 12, 13, 0, 13, 4, 18, 13, 13, 0, 13, 4, 13, 31, 13, 32, 13, 0, 13, 4, 18, 13, 13, 4, 13, 2, 13, 13, 17, 29, 13, 23, 16, 29, 13, 23, 13, 6, 13, 12, 13, 0, 13, 39, 17, 17, 0, 13, 39, 17, 17, 0, 13, 39, 17, 17, 28, 13, 4, 13, 17, 2, 13, 17, 4, 18, 13, 13, 2, 2, 18, 13, 17, 13, 13, 4, 18, 13, 13, 2, 2, 40, 18, 13, 2, 13, 13, 2, 13, 13, 13, 4, 18, 13, 13, 2, 2, 18, 13, 17, 18, 13, 17, 13, 0, 18, 13, 13, 13, 0, 18, 13, 13, 13, 0, 18, 13, 13, 13, 0, 18, 13, 13, 13, 0, 18, 13, 13, 13, 23, 13, 23, 13, 23, 13, 12, 13, 14, 2, 2, 13, 17, 2, 13, 13, 29, 17, 0, 13, 4, 13, 13, 2, 13, 13, 29, 2, 2, 2, 18, 18, 13, 13, 13, 18, 18, 13, 13, 13, 18, 18, 13, 13, 2, 13, 13, 18, 13, 13, 23, 13, 23, 13, 23, 13, 12, 13, 0, 13, 2, 2, 17, 17, 17, 0, 13, 4, 13, 2, 13, 13, 13, 0, 13, 17, 28, 13, 4, 13, 2, 13, 13, 0, 13, 4, 13, 2, 13, 2, 13, 17, 13, 0, 13, 4, 13, 2, 2, 2, 13, 13, 17, 2, 2, 13, 13, 17, 2, 2, 13, 13, 17, 0, 13, 2, 13, 13, 0, 13, 13, 29, 2, 13, 13, 23, 13, 23, 13, 23, 13, 23, 13, 0, 13, 13, 13, 12, 13, 0, 13, 4, 13, 13, 13, 13, 4, 13, 4, 13, 13, 13, 13, 13, 14, 2, 13, 17, 4, 13, 10, 12, 13, 10, 12, 13, 10, 12, 13, 10, 6, 13, 10, 12, 13, 10, 12, 13, 10, 12, 13, 10, 12, 13, 10, 12, 13, 10, 12, 13, 10, 12, 13 ]

[ [ 91, 90 ], [ 103, 102 ], [ 109, 108 ], [ 134, 110 ], [ 117, 116 ], [ 395, 122 ], [ 116, 124 ], [ 102, 125 ], [ 108, 128 ], [ 100, 132 ], [ 134, 134 ], [ 141, 140 ], [ 146, 145 ], [ 151, 150 ], [ 156, 155 ], [ 230, 160 ], [ 140, 164 ], [ 140, 169 ], [ 155, 171 ], [ 232, 172 ], [ 150, 175 ], [ 150, 181 ], [ 232, 183 ], [ 155, 184 ], [ 232, 186 ], [ 155, 187 ], [ 232, 188 ], [ 145, 191 ], [ 145, 196 ], [ 150, 199 ], [ 232, 201 ], [ 206, 203 ], [ 228, 204 ], [ 232, 206 ], [ 211, 208 ], [ 228, 209 ], [ 230, 211 ], [ 216, 213 ], [ 228, 214 ], [ 140, 215 ], [ 140, 216 ], [ 221, 218 ], [ 228, 219 ], [ 145, 220 ], [ 145, 221 ], [ 226, 223 ], [ 228, 224 ], [ 150, 225 ], [ 150, 226 ], [ 228, 228 ], [ 230, 230 ], [ 232, 232 ], [ 282, 238 ], [ 282, 241 ], [ 280, 242 ], [ 247, 246 ], [ 282, 249 ], [ 280, 251 ], [ 282, 252 ], [ 278, 259 ], [ 280, 261 ], [ 278, 264 ], [ 246, 266 ], [ 282, 266 ], [ 278, 269 ], [ 280, 272 ], [ 246, 273 ], [ 282, 273 ], [ 278, 275 ], [ 278, 278 ], [ 280, 280 ], [ 282, 282 ], [ 416, 284 ], [ 287, 286 ], [ 294, 293 ], [ 353, 297 ], [ 355, 298 ], [ 286, 299 ], [ 302, 301 ], [ 305, 304 ], [ 355, 308 ], [ 359, 309 ], [ 312, 311 ], [ 293, 313 ], [ 304, 315 ], [ 357, 317 ], [ 304, 319 ], [ 322, 321 ], [ 293, 323 ], [ 355, 327 ], [ 304, 328 ], [ 353, 332 ], [ 357, 333 ], [ 353, 337 ], [ 357, 338 ], [ 342, 341 ], [ 311, 343 ], [ 321, 344 ], [ 347, 346 ], [ 286, 347 ], [ 346, 350 ], [ 341, 350 ], [ 301, 350 ], [ 286, 351 ], [ 353, 353 ], [ 355, 355 ], [ 357, 357 ], [ 359, 359 ], [ 416, 361 ], [ 404, 362 ], [ 416, 363 ], [ 368, 367 ], [ 401, 369 ], [ 368, 370 ], [ 368, 371 ], [ 368, 372 ], [ 416, 376 ], [ 367, 377 ], [ 370, 378 ], [ 371, 379 ], [ 372, 380 ], [ 392, 386 ], [ 416, 416 ] ]

[ "\n# -*- coding: utf-8 -*-\nimport bisect\nimport heapq\nimport math\nimport random\nimport sys\nfrom pprint import pprint\nfrom collections import Counter, defaultdict, deque\nfrom decimal import ROUND_CEILING, ROUND_HALF_UP, Decimal\nfrom functools import lru_cache, reduce\nfrom itertools import combinations, combinations_with_replacement, product, permutations\nfrom operator import add, mul, sub\n\nsys.setrecursionlimit(10000)\n\n\ndef read_int():\n return int(input())\n\n\ndef read_int_n():\n return list(map(int, input().split()))\n\n\ndef read_float():\n return float(input())\n\n\ndef read_float_n():\n return list(map(float, input().split()))\n\n\ndef read_str():\n return input().strip()\n\n\ndef read_str_n():\n return list(map(str, input().split()))\n\n\ndef error_print(*args):\n print(*args, file=sys.stderr)\n\n\ndef mt(f):\n import time\n\n def wrap(*args, **kwargs):\n s = time.time()\n ret = f(*args, **kwargs)\n e = time.time()\n\n error_print(e - s, 'sec')\n return ret\n\n return wrap\n\n\nclass Combination:\n def __init__(self, n, mod):\n\n g1 = [1, 1]\n g2 = [1, 1]\n inverse = [0, 1]\n for i in range(2, n + 1):\n g1.append((g1[-1] * i) % mod)\n inverse.append((-inverse[mod % i] * (mod//i)) % mod)\n g2.append((g2[-1] * inverse[-1]) % mod)\n self.MOD = mod\n self.N = n\n self.g1 = g1\n self.g2 = g2\n self.inverse = inverse\n\n def __call__(self, n, r):\n if (r < 0 or r > n):\n return 0\n r = min(r, n-r)\n return self.g1[n] * self.g2[r] * self.g2[n-r] % self.MOD\n\n\n@mt\ndef slv(H, W, A, B):\n MOD = 10**9+7\n cmb = Combination(H+W, MOD)\n ans = 0\n for i in range(W-B):\n w1 = cmb(i+(A-1), i)\n w2 = cmb((W-i-1)+(H-A-1), (H-A-1))\n ans += w1*w2\n ans %= MOD\n\n return ans % MOD\n\n\ndef main():\n H, W, A, B = read_int_n()\n\n print(slv(H, W, A, B))\n\n\nif __name__ == '__main__':\n main()", "import bisect", "bisect", "import heapq", "heapq", "import math", "math", "import random", "random", "import sys", "sys", "from pprint import pprint", "from collections import Counter, defaultdict, deque", "from decimal import ROUND_CEILING, ROUND_HALF_UP, Decimal", "from functools import lru_cache, reduce", "from itertools import combinations, combinations_with_replacement, product, permutations", "from operator import add, mul, sub", "sys.setrecursionlimit(10000)", "sys.setrecursionlimit", "sys", "setrecursionlimit", "10000", "def read_int():\n return int(input())", "read_int", "return int(input())", "int(input())", "int", "input()", "input", "def read_int_n():\n return list(map(int, input().split()))", "read_int_n", "return list(map(int, input().split()))", "list(map(int, input().split()))", "list", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "def read_float():\n return float(input())", "read_float", "return float(input())", "float(input())", "float", "input()", "input", "def read_float_n():\n return list(map(float, input().split()))", "read_float_n", "return list(map(float, input().split()))", "list(map(float, input().split()))", "list", "map(float, input().split())", "map", "float", "input().split()", "().split", "()", "input", "split", "def read_str():\n return input().strip()", "read_str", "return input().strip()", "input().strip()", "().strip", "()", "input", "strip", "def read_str_n():\n return list(map(str, input().split()))", "read_str_n", "return list(map(str, input().split()))", "list(map(str, input().split()))", "list", "map(str, input().split())", "map", "str", "input().split()", "().split", "()", "input", "split", "def error_print(*args):\n print(*args, file=sys.stderr)", "error_print", "print(*args, file=sys.stderr)", "print", "*args", "args", "file=sys.stderr", "file", "sys.stderr", "sys", "stderr", "*args", "def mt(f):\n import time\n\n def wrap(*args, **kwargs):\n s = time.time()\n ret = f(*args, **kwargs)\n e = time.time()\n\n error_print(e - s, 'sec')\n return ret\n\n return wrap", "mt", "import time", "time", "def wrap(*args, **kwargs):\n s = time.time()\n ret = f(*args, **kwargs)\n e = time.time()\n\n error_print(e - s, 'sec')\n return ret\n\n ", "wrap", "s = time.time()", "s", "time.time()", "time.time", "time", "time", "ret = f(*args, **kwargs)", "ret", "f(*args, **kwargs)", "f", "*args", "args", "**kwargs", "kwargs", "e = time.time()", "e", "time.time()", "time.time", "time", "time", "error_print(e - s, 'sec')", "error_print", "e - s", "e", "s", "'sec'", "return ret", "ret", "*args", "**kwargs", "return wrap", "wrap", "f", "f", "class Combination:\n def __init__(self, n, mod):\n\n g1 = [1, 1]\n g2 = [1, 1]\n inverse = [0, 1]\n for i in range(2, n + 1):\n g1.append((g1[-1] * i) % mod)\n inverse.append((-inverse[mod % i] * (mod//i)) % mod)\n g2.append((g2[-1] * inverse[-1]) % mod)\n self.MOD = mod\n self.N = n\n self.g1 = g1\n self.g2 = g2\n self.inverse = inverse\n\n def __call__(self, n, r):\n if (r < 0 or r > n):\n return 0\n r = min(r, n-r)\n return self.g1[n] * self.g2[r] * self.g2[n-r] % self.MOD", "Combination", "def __init__(self, n, mod):\n\n g1 = [1, 1]\n g2 = [1, 1]\n inverse = [0, 1]\n for i in range(2, n + 1):\n g1.append((g1[-1] * i) % mod)\n inverse.append((-inverse[mod % i] * (mod//i)) % mod)\n g2.append((g2[-1] * inverse[-1]) % mod)\n self.MOD = mod\n self.N = n\n self.g1 = g1\n self.g2 = g2\n self.inverse = inverse\n\n ", "__init__", "g1 = [1, 1]", "g1", "[1, 1]", "1", "1", "g2 = [1, 1]", "g2", "[1, 1]", "1", "1", "inverse = [0, 1]", "inverse", "[0, 1]", "0", "1", "for i in range(2, n + 1):\n g1.append((g1[-1] * i) % mod)\n inverse.append((-inverse[mod % i] * (mod//i)) % mod)\n g2.append((g2[-1] * inverse[-1]) % mod)\n ", "i", "range(2, n + 1)", "range", "2", "n + 1", "n", "1", "g1.append((g1[-1] * i) % mod)", "g1.append", "g1", "append", "(g1[-1] * i) % mod", "g1[-1] * i", "g1[-1]", "g1", "-1", "i", "mod", "inverse.append((-inverse[mod % i] * (mod//i)) % mod)", "inverse.append", "inverse", "append", "(-inverse[mod % i] * (mod//i)) % mod", "-inverse[mod % i] * (mod//i)", "-inverse[mod % i]", "inverse[mod % i]", "inverse", "mod % i", "mod", "i", "mod//i", "mod", "i", "mod", "g2.append((g2[-1] * inverse[-1]) % mod)", "g2.append", "g2", "append", "(g2[-1] * inverse[-1]) % mod", "g2[-1] * inverse[-1]", "g2[-1]", "g2", "-1", "inverse[-1]", "inverse", "-1", "mod", "self.MOD = mod", "self.MOD", "self", "MOD", "mod", "self.N = n", "self.N", "self", "N", "n", "self.g1 = g1", "self.g1", "self", "g1", "g1", "self.g2 = g2", "self.g2", "self", "g2", "g2", "self.inverse = inverse", "self.inverse", "self", "inverse", "inverse", "self", "self", "n", "n", "mod", "mod", "def __call__(self, n, r):\n if (r < 0 or r > n):\n return 0\n r = min(r, n-r)\n return self.g1[n] * self.g2[r] * self.g2[n-r] % self.MOD", "__call__", "if (r < 0 or r > n):\n return 0\n ", "r < 0 or r > n", "r < 0", "r", "0", "r > n", "r", "n", "return 0", "0", "r = min(r, n-r)", "r", "min(r, n-r)", "min", "r", "n-r", "n", "r", "return self.g1[n] * self.g2[r] * self.g2[n-r] % self.MOD", "self.g1[n] * self.g2[r] * self.g2[n-r] % self.MOD", "self.g1[n] * self.g2[r] * self.g2[n-r]", "self.g1[n] * self.g2[r]", "self.g1[n]", "self.g1", "self", "g1", "n", "self.g2[r]", "self.g2", "self", "g2", "r", "self.g2[n-r]", "self.g2", "self", "g2", "n-r", "n", "r", "self.MOD", "self", "MOD", "self", "self", "n", "n", "r", "r", "def slv(H, W, A, B):\n MOD = 10**9+7\n cmb = Combination(H+W, MOD)\n ans = 0\n for i in range(W-B):\n w1 = cmb(i+(A-1), i)\n w2 = cmb((W-i-1)+(H-A-1), (H-A-1))\n ans += w1*w2\n ans %= MOD\n\n return ans % MOD", "slv", "MOD = 10**9+7", "MOD", "10**9+7", "10**9", "10", "9", "7", "cmb = Combination(H+W, MOD)", "cmb", "Combination(H+W, MOD)", "Combination", "H+W", "H", "W", "MOD", "ans = 0", "ans", "0", "for i in range(W-B):\n w1 = cmb(i+(A-1), i)\n w2 = cmb((W-i-1)+(H-A-1), (H-A-1))\n ans += w1*w2\n ans %= MOD\n\n ", "i", "range(W-B)", "range", "W-B", "W", "B", "w1 = cmb(i+(A-1), i)", "w1", "cmb(i+(A-1), i)", "cmb", "i+(A-1)", "i", "A-1", "A", "1", "i", "w2 = cmb((W-i-1)+(H-A-1), (H-A-1))", "w2", "cmb((W-i-1)+(H-A-1), (H-A-1))", "cmb", "(W-i-1)+(H-A-1)", "W-i-1", "W-i", "W", "i", "1", "H-A-1", "H-A", "H", "A", "1", "H-A-1", "H-A", "H", "A", "1", "ans += w1*w2", "ans", "w1*w2", "w1", "w2", "ans %= MOD", "ans", "MOD", "return ans % MOD", "ans % MOD", "ans", "MOD", "H", "H", "W", "W", "A", "A", "B", "B", "@mt", "slv", "mt", "slv", "def main():\n H, W, A, B = read_int_n()\n\n print(slv(H, W, A, B))", "main", "H, W, A, B = read_int_n()", "H", "read_int_n()", "read_int_n", "W", "A", "B", "print(slv(H, W, A, B))", "print", "slv(H, W, A, B)", "slv", "H", "W", "A", "B", "if __name__ == '__main__':\n main()", "__name__ == '__main__'", "__name__", "'__main__'", "main()", "main", "def read_str_n():\n return list(map(str, input().split()))", "def read_str_n():\n return list(map(str, input().split()))", "read_str_n", "def main():\n H, W, A, B = read_int_n()\n\n print(slv(H, W, A, B))", "def main():\n H, W, A, B = read_int_n()\n\n print(slv(H, W, A, B))", "main", "def error_print(*args):\n print(*args, file=sys.stderr)", "def error_print(*args):\n print(*args, file=sys.stderr)", "error_print", "class Combination:\n def __init__(self, n, mod):\n\n g1 = [1, 1]\n g2 = [1, 1]\n inverse = [0, 1]\n for i in range(2, n + 1):\n g1.append((g1[-1] * i) % mod)\n inverse.append((-inverse[mod % i] * (mod//i)) % mod)\n g2.append((g2[-1] * inverse[-1]) % mod)\n self.MOD = mod\n self.N = n\n self.g1 = g1\n self.g2 = g2\n self.inverse = inverse\n\n def __call__(self, n, r):\n if (r < 0 or r > n):\n return 0\n r = min(r, n-r)\n return self.g1[n] * self.g2[r] * self.g2[n-r] % self.MOD", "class Combination:\n def __init__(self, n, mod):\n\n g1 = [1, 1]\n g2 = [1, 1]\n inverse = [0, 1]\n for i in range(2, n + 1):\n g1.append((g1[-1] * i) % mod)\n inverse.append((-inverse[mod % i] * (mod//i)) % mod)\n g2.append((g2[-1] * inverse[-1]) % mod)\n self.MOD = mod\n self.N = n\n self.g1 = g1\n self.g2 = g2\n self.inverse = inverse\n\n def __call__(self, n, r):\n if (r < 0 or r > n):\n return 0\n r = min(r, n-r)\n return self.g1[n] * self.g2[r] * self.g2[n-r] % self.MOD", "Combination", "def read_int_n():\n return list(map(int, input().split()))", "def read_int_n():\n return list(map(int, input().split()))", "read_int_n", "def mt(f):\n import time\n\n def wrap(*args, **kwargs):\n s = time.time()\n ret = f(*args, **kwargs)\n e = time.time()\n\n error_print(e - s, 'sec')\n return ret\n\n return wrap", "def mt(f):\n import time\n\n def wrap(*args, **kwargs):\n s = time.time()\n ret = f(*args, **kwargs)\n e = time.time()\n\n error_print(e - s, 'sec')\n return ret\n\n return wrap", "mt", "def read_int():\n return int(input())", "def read_int():\n return int(input())", "read_int", "def read_float():\n return float(input())", "def read_float():\n return float(input())", "read_float", "def read_str():\n return input().strip()", "def read_str():\n return input().strip()", "read_str", "def slv(H, W, A, B):\n MOD = 10**9+7\n cmb = Combination(H+W, MOD)\n ans = 0\n for i in range(W-B):\n w1 = cmb(i+(A-1), i)\n w2 = cmb((W-i-1)+(H-A-1), (H-A-1))\n ans += w1*w2\n ans %= MOD\n\n return ans % MOD", "def slv(H, W, A, B):\n MOD = 10**9+7\n cmb = Combination(H+W, MOD)\n ans = 0\n for i in range(W-B):\n w1 = cmb(i+(A-1), i)\n w2 = cmb((W-i-1)+(H-A-1), (H-A-1))\n ans += w1*w2\n ans %= MOD\n\n return ans % MOD", "slv", "def read_float_n():\n return list(map(float, input().split()))", "def read_float_n():\n return list(map(float, input().split()))", "read_float_n" ]

[ 7, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 13, 13, 0, 13, 2, 13, 13, 0, 13, 2, 13, 13, 0, 13, 17, 12, 13, 14, 2, 13, 17, 29, 17, 14, 2, 2, 13, 17, 17, 29, 2, 2, 4, 13, 13, 2, 13, 17, 17, 13, 29, 2, 2, 2, 4, 13, 13, 2, 13, 17, 17, 13, 13, 23, 13, 23, 13, 0, 13, 39, 17, 28, 13, 4, 13, 2, 13, 13, 4, 18, 13, 13, 2, 2, 18, 13, 13, 2, 13, 17, 13, 0, 13, 2, 39, 17, 2, 2, 13, 13, 17, 0, 18, 13, 2, 13, 13, 4, 13, 18, 13, 2, 13, 13, 2, 13, 17, 28, 13, 4, 13, 4, 13, 2, 13, 13, 0, 18, 13, 13, 2, 2, 18, 13, 2, 13, 17, 2, 13, 17, 13, 12, 13, 29, 2, 2, 2, 18, 13, 2, 13, 13, 18, 13, 13, 18, 13, 13, 13, 23, 13, 23, 13, 0, 13, 17, 28, 13, 4, 13, 13, 0, 13, 2, 2, 13, 2, 4, 13, 13, 2, 13, 17, 4, 13, 2, 13, 17, 2, 2, 13, 13, 17, 13, 4, 13, 13, 10, 12, 13, 10, 17, 13, 10, 4, 13, 10, 2, 13, 10, 12, 13, 10, 2, 13, 10, 17, 13, 10, 2, 13, 10, 39, 13, 10, 4, 13, 10, 4, 13, 10, 4, 13, 10, 2, 13 ]

[ [ 233, 2 ], [ 233, 11 ], [ 233, 12 ], [ 233, 13 ], [ 209, 15 ], [ 207, 17 ], [ 234, 18 ], [ 221, 20 ], [ 231, 22 ], [ 228, 23 ], [ 203, 25 ], [ 68, 31 ], [ 68, 38 ], [ 66, 46 ], [ 68, 48 ], [ 204, 51 ], [ 66, 58 ], [ 68, 60 ], [ 66, 63 ], [ 204, 64 ], [ 66, 66 ], [ 68, 68 ], [ 224, 70 ], [ 75, 74 ], [ 207, 78 ], [ 231, 79 ], [ 225, 82 ], [ 225, 87 ], [ 74, 88 ], [ 74, 90 ], [ 204, 92 ], [ 236, 94 ], [ 207, 100 ], [ 231, 101 ], [ 109, 104 ], [ 237, 105 ], [ 207, 107 ], [ 231, 108 ], [ 201, 110 ], [ 225, 112 ], [ 207, 114 ], [ 231, 115 ], [ 204, 117 ], [ 121, 120 ], [ 207, 126 ], [ 231, 127 ], [ 132, 129 ], [ 237, 130 ], [ 120, 131 ], [ 237, 135 ], [ 120, 137 ], [ 120, 140 ], [ 204, 142 ], [ 225, 150 ], [ 162, 152 ], [ 164, 153 ], [ 237, 155 ], [ 162, 156 ], [ 237, 158 ], [ 164, 159 ], [ 204, 160 ], [ 162, 162 ], [ 164, 164 ], [ 218, 166 ], [ 170, 169 ], [ 210, 172 ], [ 215, 174 ], [ 219, 177 ], [ 216, 177 ], [ 213, 180 ], [ 169, 181 ], [ 228, 183 ], [ 213, 186 ], [ 222, 188 ], [ 207, 192 ], [ 169, 193 ], [ 204, 195 ], [ 216, 198 ], [ 219, 198 ], [ 203, 204 ], [ 233, 207 ], [ 209, 210 ], [ 215, 216 ], [ 218, 219 ], [ 221, 222 ], [ 224, 225 ], [ 233, 228 ], [ 233, 231 ], [ 233, 234 ], [ 236, 237 ] ]

[ "H, W, A, B = map(int, input().split())\nC = H - A\nD = W - B\np = 1000000007\n\ndef power(a, b): #a^b (mod p)を求める #二分累乗法を使う\n if b == 0:\n return 1\n elif b % 2 == 0:\n return power(a, b//2) ** 2 % p\n else:\n return power(a, b//2) ** 2 * a % p\n\nf = [1] #f[i] = i! % p\nfor i in range(H+W):\n f.append(f[i] * (i+1) % p)\n\nI_f = [0] * (H+W+1) #I_f[i] = (i!)^(-1) % p\nI_f[H+W] = power(f[H+W], p-2)\nfor i in reversed(range(H+W)):\n I_f[i] = I_f[i+1] * (i+1) % p\n\ndef combi(a, b): #(a+b)!/a!b! (mod p)を求める\n return f[a+b] * I_f[a] * I_f[b] % p\n\nx = 0\nfor i in range(C):\n x = (x + combi(i, B-1) * combi(D-1, H-i-1)) % p\nprint(x)", "H, W, A, B = map(int, input().split())", "H", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "W", "A", "B", "C = H - A", "C", "H - A", "H", "A", "D = W - B", "D", "W - B", "W", "B", "p = 1000000007", "p", "1000000007", "def power(a, b): #a^b (mod p)を求める #二分累乗法を使う\n if b == 0:\n return 1\n elif b % 2 == 0:\n return power(a, b//2) ** 2 % p\n else:\n return power(a, b//2) ** 2 * a % p", "power", "if b == 0:\n return 1\n elif b % 2 == 0:\n return power(a, b//2) ** 2 % p\n else:\n return power(a, b//2) ** 2 * a % p", "b == 0", "b", "0", "return 1", "1", "elif b % 2 == 0:\n return power(a, b//2) ** 2 % p\n ", "b % 2 == 0", "b % 2", "b", "2", "0", "return power(a, b//2) ** 2 % p", "power(a, b//2) ** 2 % p", "power(a, b//2) ** 2", "power(a, b//2)", "power", "a", "b//2", "b", "2", "2", "p", "return power(a, b//2) ** 2 * a % p", "power(a, b//2) ** 2 * a % p", "power(a, b//2) ** 2 * a", "power(a, b//2) ** 2", "power(a, b//2)", "power", "a", "b//2", "b", "2", "2", "a", "p", "a", "a", "b", "b", "f = [1]", "f", "[1]", "1", "for i in range(H+W):\n f.append(f[i] * (i+1) % p)", "i", "range(H+W)", "range", "H+W", "H", "W", "f.append(f[i] * (i+1) % p)", "f.append", "f", "append", "f[i] * (i+1) % p", "f[i] * (i+1)", "f[i]", "f", "i", "i+1", "i", "1", "p", "I_f = [0] * (H+W+1)", "I_f", "[0] * (H+W+1)", "[0]", "0", "H+W+1", "H+W", "H", "W", "1", "I_f[H+W] = power(f[H+W], p-2)", "I_f[H+W]", "I_f", "H+W", "H", "W", "power(f[H+W], p-2)", "power", "f[H+W]", "f", "H+W", "H", "W", "p-2", "p", "2", "for i in reversed(range(H+W)):\n I_f[i] = I_f[i+1] * (i+1) % p", "i", "reversed(range(H+W))", "reversed", "range(H+W)", "range", "H+W", "H", "W", "I_f[i] = I_f[i+1] * (i+1) % p", "I_f[i]", "I_f", "i", "I_f[i+1] * (i+1) % p", "I_f[i+1] * (i+1)", "I_f[i+1]", "I_f", "i+1", "i", "1", "i+1", "i", "1", "p", "def combi(a, b): #(a+b)!/a!b! (mod p)を求める\n return f[a+b] * I_f[a] * I_f[b] % p", "combi", "return f[a+b] * I_f[a] * I_f[b] % p", "f[a+b] * I_f[a] * I_f[b] % p", "f[a+b] * I_f[a] * I_f[b]", "f[a+b] * I_f[a]", "f[a+b]", "f", "a+b", "a", "b", "I_f[a]", "I_f", "a", "I_f[b]", "I_f", "b", "p", "a", "a", "b", "b", "x = 0", "x", "0", "for i in range(C):\n x = (x + combi(i, B-1) * combi(D-1, H-i-1)) % p", "i", "range(C)", "range", "C", "x = (x + combi(i, B-1) * combi(D-1, H-i-1)) % p", "x", "(x + combi(i, B-1) * combi(D-1, H-i-1)) % p", "x + combi(i, B-1) * combi(D-1, H-i-1)", "x", "combi(i, B-1) * combi(D-1, H-i-1)", "combi(i, B-1)", "combi", "i", "B-1", "B", "1", "combi(D-1, H-i-1)", "combi", "D-1", "D", "1", "H-i-1", "H-i", "H", "i", "1", "p", "print(x)", "print", "x", "def power(a, b): #a^b (mod p)を求める #二分累乗法を使う\n if b == 0:\n return 1\n elif b % 2 == 0:\n return power(a, b//2) ** 2 % p\n else:\n return power(a, b//2) ** 2 * a % p", "def power(a, b): #a^b (mod p)を求める #二分累乗法を使う\n if b == 0:\n return 1\n elif b % 2 == 0:\n return power(a, b//2) ** 2 % p\n else:\n return power(a, b//2) ** 2 * a % p", "power", "p = 1000000007", "1000000007", "p", "H, W, A, B = map(int, input().split())", "map(int, input().split())", "H", "C = H - A", "H - A", "C", "def combi(a, b): #(a+b)!/a!b! (mod p)を求める\n return f[a+b] * I_f[a] * I_f[b] % p", "def combi(a, b): #(a+b)!/a!b! (mod p)を求める\n return f[a+b] * I_f[a] * I_f[b] % p", "combi", "x = (x + combi(i, B-1) * combi(D-1, H-i-1)) % p", "(x + combi(i, B-1) * combi(D-1, H-i-1)) % p", "x", "x = 0", "0", "x", "D = W - B", "W - B", "D", "f = [1]", "[1]", "f", "B = map(int, input().split())", "map(int, input().split())", "B", "W, A, B = map(int, input().split())", "map(int, input().split())", "W", "A, B = map(int, input().split())", "map(int, input().split())", "A", "I_f = [0] * (H+W+1)", "[0] * (H+W+1)", "I_f" ]

[ 7, 12, 13, 0, 13, 13, 13, 17, 13, 17, 42, 2, 13, 17, 0, 13, 2, 13, 13, 0, 13, 2, 13, 13, 0, 13, 2, 13, 13, 0, 13, 13, 13, 13, 0, 13, 13, 13, 13, 29, 2, 2, 13, 13, 13, 23, 13, 23, 13, 12, 13, 14, 2, 2, 13, 17, 2, 13, 13, 37, 4, 13, 4, 18, 17, 13, 13, 13, 14, 2, 2, 13, 17, 2, 13, 13, 29, 17, 29, 2, 2, 4, 13, 2, 13, 17, 2, 13, 17, 13, 4, 13, 2, 13, 17, 13, 13, 13, 23, 13, 23, 13, 23, 13, 12, 13, 0, 13, 2, 2, 17, 17, 17, 0, 13, 17, 13, 17, 0, 13, 2, 13, 13, 13, 2, 13, 17, 0, 13, 2, 13, 17, 28, 13, 4, 13, 13, 2, 2, 2, 13, 17, 2, 13, 17, 17, 0, 13, 2, 2, 2, 13, 2, 13, 17, 4, 13, 2, 2, 13, 17, 13, 13, 13, 0, 13, 13, 13, 2, 13, 13, 0, 13, 2, 13, 17, 28, 13, 4, 13, 13, 2, 2, 2, 13, 17, 2, 13, 17, 17, 0, 13, 2, 2, 2, 13, 2, 13, 17, 4, 13, 2, 2, 13, 17, 13, 13, 13, 0, 13, 17, 28, 13, 4, 13, 13, 13, 0, 13, 2, 13, 13, 13, 2, 13, 17, 0, 13, 2, 2, 2, 13, 17, 2, 13, 17, 17, 0, 13, 2, 13, 17, 0, 13, 2, 2, 2, 13, 2, 13, 17, 4, 13, 2, 2, 13, 17, 13, 13, 13, 0, 13, 13, 13, 2, 13, 13, 0, 13, 2, 2, 13, 17, 2, 13, 17, 0, 13, 2, 13, 17, 0, 13, 2, 2, 2, 13, 2, 2, 13, 17, 13, 4, 13, 2, 13, 17, 13, 13, 0, 13, 2, 2, 13, 2, 13, 13, 13, 29, 13, 23, 13, 23, 13, 23, 13, 23, 13, 14, 2, 13, 17, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 13, 13, 0, 13, 4, 13, 13, 13, 13, 13, 4, 13, 13, 10, 12, 13, 10, 4, 13, 10, 4, 13, 10, 4, 13, 10, 12, 13, 10, 12, 13, 10, 4, 13, 10, 4, 13 ]

[ [ 5, 4 ], [ 48, 5 ], [ 7, 6 ], [ 9, 8 ], [ 4, 12 ], [ 32, 12 ], [ 16, 15 ], [ 46, 17 ], [ 30, 17 ], [ 20, 17 ], [ 4, 18 ], [ 32, 18 ], [ 21, 20 ], [ 15, 22 ], [ 4, 23 ], [ 32, 23 ], [ 26, 25 ], [ 15, 27 ], [ 8, 28 ], [ 37, 28 ], [ 31, 30 ], [ 4, 31 ], [ 32, 31 ], [ 33, 32 ], [ 30, 33 ], [ 20, 33 ], [ 46, 33 ], [ 36, 35 ], [ 8, 36 ], [ 37, 36 ], [ 38, 37 ], [ 35, 38 ], [ 25, 38 ], [ 6, 38 ], [ 35, 42 ], [ 25, 42 ], [ 6, 42 ], [ 48, 43 ], [ 48, 44 ], [ 46, 46 ], [ 48, 48 ], [ 101, 54 ], [ 99, 57 ], [ 101, 58 ], [ 99, 66 ], [ 101, 67 ], [ 101, 71 ], [ 101, 74 ], [ 99, 75 ], [ 99, 84 ], [ 101, 87 ], [ 103, 89 ], [ 99, 93 ], [ 101, 95 ], [ 103, 96 ], [ 103, 97 ], [ 99, 99 ], [ 101, 101 ], [ 103, 103 ], [ 108, 107 ], [ 115, 114 ], [ 117, 116 ], [ 120, 119 ], [ 311, 121 ], [ 315, 122 ], [ 124, 123 ], [ 317, 125 ], [ 129, 128 ], [ 119, 130 ], [ 134, 133 ], [ 128, 136 ], [ 119, 140 ], [ 123, 143 ], [ 148, 147 ], [ 114, 151 ], [ 147, 151 ], [ 133, 153 ], [ 360, 156 ], [ 133, 159 ], [ 128, 161 ], [ 107, 162 ], [ 107, 163 ], [ 166, 165 ], [ 315, 166 ], [ 168, 167 ], [ 313, 169 ], [ 317, 170 ], [ 173, 172 ], [ 165, 174 ], [ 178, 177 ], [ 172, 180 ], [ 128, 180 ], [ 165, 184 ], [ 167, 187 ], [ 192, 191 ], [ 116, 195 ], [ 191, 195 ], [ 177, 197 ], [ 360, 200 ], [ 177, 203 ], [ 172, 205 ], [ 128, 205 ], [ 107, 206 ], [ 107, 207 ], [ 210, 209 ], [ 213, 212 ], [ 317, 215 ], [ 313, 216 ], [ 219, 218 ], [ 311, 220 ], [ 315, 221 ], [ 223, 222 ], [ 212, 224 ], [ 228, 227 ], [ 218, 231 ], [ 119, 231 ], [ 222, 234 ], [ 123, 234 ], [ 239, 238 ], [ 218, 240 ], [ 119, 240 ], [ 244, 243 ], [ 147, 247 ], [ 114, 247 ], [ 243, 247 ], [ 227, 249 ], [ 268, 249 ], [ 360, 252 ], [ 227, 255 ], [ 268, 255 ], [ 238, 257 ], [ 172, 257 ], [ 128, 257 ], [ 277, 257 ], [ 107, 258 ], [ 107, 259 ], [ 262, 261 ], [ 315, 262 ], [ 264, 263 ], [ 313, 265 ], [ 212, 266 ], [ 269, 268 ], [ 261, 271 ], [ 165, 271 ], [ 263, 274 ], [ 167, 274 ], [ 278, 277 ], [ 261, 279 ], [ 165, 279 ], [ 283, 282 ], [ 191, 286 ], [ 116, 286 ], [ 282, 286 ], [ 268, 289 ], [ 227, 289 ], [ 277, 291 ], [ 238, 291 ], [ 172, 291 ], [ 128, 291 ], [ 360, 293 ], [ 268, 295 ], [ 227, 295 ], [ 107, 297 ], [ 107, 298 ], [ 301, 300 ], [ 209, 303 ], [ 300, 303 ], [ 243, 305 ], [ 147, 305 ], [ 114, 305 ], [ 282, 306 ], [ 191, 306 ], [ 116, 306 ], [ 107, 307 ], [ 300, 309 ], [ 209, 309 ], [ 311, 311 ], [ 313, 313 ], [ 315, 315 ], [ 317, 317 ], [ 368, 323 ], [ 368, 332 ], [ 368, 333 ], [ 368, 334 ], [ 350, 336 ], [ 348, 338 ], [ 369, 339 ], [ 354, 340 ], [ 366, 341 ], [ 357, 342 ], [ 351, 345 ], [ 350, 351 ], [ 368, 354 ], [ 368, 357 ], [ 368, 366 ], [ 368, 369 ] ]

[ "def mod_inv(n: int, mod: int)->int:\n b, u, v = mod, 1, 0\n while b > 0:\n t = n // b\n\n n -= t * b\n u -= t * v\n\n n, b = b, n\n u, v = v, u\n\n return (u+mod) % mod\n\n\ndef comb(r: int, c: int, mod: int) -> int:\n if c < 0 or r < c:\n raise Exception('invalid r={}, c={}'.format(r, c))\n if c == 0 or c == r:\n return 1\n return (comb(r-1, c-1, mod) + comb(r-1, c, mod)) % mod\n\n\n# n+1Cr = (n+1)*n!/((n+1-r)!r!) = ((n+1)/(n+1-r)) * (n!/((n-r)!r!))\ndef iroha_and_grid(H: int, W: int, A: int, B: int) -> int:\n MOD = 10 ** 9 + 7\n\n c1, c2 = 1, 1\n\n uH, uW = H - A, B - 1\n r = uH - 1\n for n in range(r, (uH - 1) + (uW - 1) + 1):\n c1 = (c1 * (n + 1) * mod_inv(n + 1 - r, MOD)) % MOD\n\n lH, lW = A, W - B\n r = lH - 1\n for n in range(r, (lH - 1) + (lW - 1) + 1):\n c2 = (c2 * (n + 1) * mod_inv(n + 1 - r, MOD)) % MOD\n\n ret = 0\n for w in range(B, W):\n # 上の領域の高さと幅\n uH, uW = H - A, w - 1\n n = (uH - 1) + (uW - 1) + 1\n r = uH - 1\n c1 = (c1 * (n + 1) * mod_inv(n + 1 - r, MOD)) % MOD\n\n # 下の領域の高さと幅\n lH, lW = A, W - w\n n = (lH - 1) + (lW - 1)\n r = lH - 1\n c2 = (c2 * (n + 1 - r) * mod_inv(n + 1, MOD)) % MOD\n\n ret = (ret + c1 * c2) % MOD\n\n return ret\n\n\nif __name__ == \"__main__\":\n H, W, A, B = map(int, input().split())\n ans = iroha_and_grid(H, W, A, B)\n print(ans)", "def mod_inv(n: int, mod: int)->int:\n b, u, v = mod, 1, 0\n while b > 0:\n t = n // b\n\n n -= t * b\n u -= t * v\n\n n, b = b, n\n u, v = v, u\n\n return (u+mod) % mod", "mod_inv", "b, u, v = mod, 1, 0", "b", "mod", "u", "1", "v", "0", "while b > 0:\n t = n // b\n\n n -= t * b\n u -= t * v\n\n n, b = b, n\n u, v = v, u\n\n ", "b > 0", "b", "0", "t = n // b", "t", "n // b", "n", "b", "n -= t * b", "n", "t * b", "t", "b", "u -= t * v", "u", "t * v", "t", "v", "n, b = b, n", "n", "b", "b", "n", "u, v = v, u", "u", "v", "v", "u", "return (u+mod) % mod", "(u+mod) % mod", "u+mod", "u", "mod", "mod", "n: int", "n", "mod: int", "mod", "def comb(r: int, c: int, mod: int) -> int:\n if c < 0 or r < c:\n raise Exception('invalid r={}, c={}'.format(r, c))\n if c == 0 or c == r:\n return 1\n return (comb(r-1, c-1, mod) + comb(r-1, c, mod)) % mod\n\n\n# n+1Cr = (n+1)*n!/((n+1-r)!r!) = ((n+1)/(n+1-r)) * (n!/((n-r)!r!))", "comb", "if c < 0 or r < c:\n raise Exception('invalid r={}, c={}'.format(r, c))\n ", "c < 0 or r < c", "c < 0", "c", "0", "r < c", "r", "c", "raise Exception('invalid r={}, c={}'.format(r, c))", "Exception('invalid r={}, c={}'.format(r, c))", "Exception", "'invalid r={}, c={}'.format(r, c)", "'invalid r={}, c={}'.format", "'invalid r={}, c={}'", "format", "r", "c", "if c == 0 or c == r:\n return 1\n ", "c == 0 or c == r", "c == 0", "c", "0", "c == r", "c", "r", "return 1", "1", "return (comb(r-1, c-1, mod) + comb(r-1, c, mod)) % mod", "(comb(r-1, c-1, mod) + comb(r-1, c, mod)) % mod", "comb(r-1, c-1, mod) + comb(r-1, c, mod)", "comb(r-1, c-1, mod)", "comb", "r-1", "r", "1", "c-1", "c", "1", "mod", "comb(r-1, c, mod)", "comb", "r-1", "r", "1", "c", "mod", "mod", "r: int", "r", "c: int", "c", "mod: int", "mod", "def iroha_and_grid(H: int, W: int, A: int, B: int) -> int:\n MOD = 10 ** 9 + 7\n\n c1, c2 = 1, 1\n\n uH, uW = H - A, B - 1\n r = uH - 1\n for n in range(r, (uH - 1) + (uW - 1) + 1):\n c1 = (c1 * (n + 1) * mod_inv(n + 1 - r, MOD)) % MOD\n\n lH, lW = A, W - B\n r = lH - 1\n for n in range(r, (lH - 1) + (lW - 1) + 1):\n c2 = (c2 * (n + 1) * mod_inv(n + 1 - r, MOD)) % MOD\n\n ret = 0\n for w in range(B, W):\n # 上の領域の高さと幅\n uH, uW = H - A, w - 1\n n = (uH - 1) + (uW - 1) + 1\n r = uH - 1\n c1 = (c1 * (n + 1) * mod_inv(n + 1 - r, MOD)) % MOD\n\n # 下の領域の高さと幅\n lH, lW = A, W - w\n n = (lH - 1) + (lW - 1)\n r = lH - 1\n c2 = (c2 * (n + 1 - r) * mod_inv(n + 1, MOD)) % MOD\n\n ret = (ret + c1 * c2) % MOD\n\n return ret", "iroha_and_grid", "MOD = 10 ** 9 + 7", "MOD", "10 ** 9 + 7", "10 ** 9", "10", "9", "7", "c1, c2 = 1, 1", "c1", "1", "c2", "1", "uH, uW = H - A, B - 1", "uH", "H - A", "H", "A", "uW", "B - 1", "B", "1", "r = uH - 1", "r", "uH - 1", "uH", "1", "for n in range(r, (uH - 1) + (uW - 1) + 1):\n c1 = (c1 * (n + 1) * mod_inv(n + 1 - r, MOD)) % MOD\n\n ", "n", "range(r, (uH - 1) + (uW - 1) + 1)", "range", "r", "(uH - 1) + (uW - 1) + 1", "(uH - 1) + (uW - 1)", "uH - 1", "uH", "1", "uW - 1", "uW", "1", "1", "c1 = (c1 * (n + 1) * mod_inv(n + 1 - r, MOD)) % MOD", "c1", "(c1 * (n + 1) * mod_inv(n + 1 - r, MOD)) % MOD", "c1 * (n + 1) * mod_inv(n + 1 - r, MOD)", "c1 * (n + 1)", "c1", "n + 1", "n", "1", "mod_inv(n + 1 - r, MOD)", "mod_inv", "n + 1 - r", "n + 1", "n", "1", "r", "MOD", "MOD", "lH, lW = A, W - B", "lH", "A", "lW", "W - B", "W", "B", "r = lH - 1", "r", "lH - 1", "lH", "1", "for n in range(r, (lH - 1) + (lW - 1) + 1):\n c2 = (c2 * (n + 1) * mod_inv(n + 1 - r, MOD)) % MOD\n\n ", "n", "range(r, (lH - 1) + (lW - 1) + 1)", "range", "r", "(lH - 1) + (lW - 1) + 1", "(lH - 1) + (lW - 1)", "lH - 1", "lH", "1", "lW - 1", "lW", "1", "1", "c2 = (c2 * (n + 1) * mod_inv(n + 1 - r, MOD)) % MOD", "c2", "(c2 * (n + 1) * mod_inv(n + 1 - r, MOD)) % MOD", "c2 * (n + 1) * mod_inv(n + 1 - r, MOD)", "c2 * (n + 1)", "c2", "n + 1", "n", "1", "mod_inv(n + 1 - r, MOD)", "mod_inv", "n + 1 - r", "n + 1", "n", "1", "r", "MOD", "MOD", "ret = 0", "ret", "0", "for w in range(B, W):\n # 上の領域の高さと幅\n uH, uW = H - A, w - 1\n n = (uH - 1) + (uW - 1) + 1\n r = uH - 1\n c1 = (c1 * (n + 1) * mod_inv(n + 1 - r, MOD)) % MOD\n\n # 下の領域の高さと幅\n lH, lW = A, W - w\n n = (lH - 1) + (lW - 1)\n r = lH - 1\n c2 = (c2 * (n + 1 - r) * mod_inv(n + 1, MOD)) % MOD\n\n ret = (ret + c1 * c2) % MOD\n\n ", "w", "range(B, W)", "range", "B", "W", "uH, uW = H - A, w - 1", "uH", "H - A", "H", "A", "uW", "w - 1", "w", "1", "n = (uH - 1) + (uW - 1) + 1", "n", "(uH - 1) + (uW - 1) + 1", "(uH - 1) + (uW - 1)", "uH - 1", "uH", "1", "uW - 1", "uW", "1", "1", "r = uH - 1", "r", "uH - 1", "uH", "1", "c1 = (c1 * (n + 1) * mod_inv(n + 1 - r, MOD)) % MOD", "c1", "(c1 * (n + 1) * mod_inv(n + 1 - r, MOD)) % MOD", "c1 * (n + 1) * mod_inv(n + 1 - r, MOD)", "c1 * (n + 1)", "c1", "n + 1", "n", "1", "mod_inv(n + 1 - r, MOD)", "mod_inv", "n + 1 - r", "n + 1", "n", "1", "r", "MOD", "MOD", "lH, lW = A, W - w", "lH", "A", "lW", "W - w", "W", "w", "n = (lH - 1) + (lW - 1)", "n", "(lH - 1) + (lW - 1)", "lH - 1", "lH", "1", "lW - 1", "lW", "1", "r = lH - 1", "r", "lH - 1", "lH", "1", "c2 = (c2 * (n + 1 - r) * mod_inv(n + 1, MOD)) % MOD", "c2", "(c2 * (n + 1 - r) * mod_inv(n + 1, MOD)) % MOD", "c2 * (n + 1 - r) * mod_inv(n + 1, MOD)", "c2 * (n + 1 - r)", "c2", "n + 1 - r", "n + 1", "n", "1", "r", "mod_inv(n + 1, MOD)", "mod_inv", "n + 1", "n", "1", "MOD", "MOD", "ret = (ret + c1 * c2) % MOD", "ret", "(ret + c1 * c2) % MOD", "ret + c1 * c2", "ret", "c1 * c2", "c1", "c2", "MOD", "return ret", "ret", "H: int", "H", "W: int", "W", "A: int", "A", "B: int", "B", "if __name__ == \"__main__\":\n H, W, A, B = map(int, input().split())\n ans = iroha_and_grid(H, W, A, B)\n print(ans)", "__name__ == \"__main__\"", "__name__", "\"__main__\"", "H, W, A, B = map(int, input().split())", "H", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "W", "A", "B", "ans = iroha_and_grid(H, W, A, B)", "ans", "iroha_and_grid(H, W, A, B)", "iroha_and_grid", "H", "W", "A", "B", "print(ans)", "print", "ans", "def iroha_and_grid(H: int, W: int, A: int, B: int) -> int:\n MOD = 10 ** 9 + 7\n\n c1, c2 = 1, 1\n\n uH, uW = H - A, B - 1\n r = uH - 1\n for n in range(r, (uH - 1) + (uW - 1) + 1):\n c1 = (c1 * (n + 1) * mod_inv(n + 1 - r, MOD)) % MOD\n\n lH, lW = A, W - B\n r = lH - 1\n for n in range(r, (lH - 1) + (lW - 1) + 1):\n c2 = (c2 * (n + 1) * mod_inv(n + 1 - r, MOD)) % MOD\n\n ret = 0\n for w in range(B, W):\n # 上の領域の高さと幅\n uH, uW = H - A, w - 1\n n = (uH - 1) + (uW - 1) + 1\n r = uH - 1\n c1 = (c1 * (n + 1) * mod_inv(n + 1 - r, MOD)) % MOD\n\n # 下の領域の高さと幅\n lH, lW = A, W - w\n n = (lH - 1) + (lW - 1)\n r = lH - 1\n c2 = (c2 * (n + 1 - r) * mod_inv(n + 1, MOD)) % MOD\n\n ret = (ret + c1 * c2) % MOD\n\n return ret", "def iroha_and_grid(H: int, W: int, A: int, B: int) -> int:\n MOD = 10 ** 9 + 7\n\n c1, c2 = 1, 1\n\n uH, uW = H - A, B - 1\n r = uH - 1\n for n in range(r, (uH - 1) + (uW - 1) + 1):\n c1 = (c1 * (n + 1) * mod_inv(n + 1 - r, MOD)) % MOD\n\n lH, lW = A, W - B\n r = lH - 1\n for n in range(r, (lH - 1) + (lW - 1) + 1):\n c2 = (c2 * (n + 1) * mod_inv(n + 1 - r, MOD)) % MOD\n\n ret = 0\n for w in range(B, W):\n # 上の領域の高さと幅\n uH, uW = H - A, w - 1\n n = (uH - 1) + (uW - 1) + 1\n r = uH - 1\n c1 = (c1 * (n + 1) * mod_inv(n + 1 - r, MOD)) % MOD\n\n # 下の領域の高さと幅\n lH, lW = A, W - w\n n = (lH - 1) + (lW - 1)\n r = lH - 1\n c2 = (c2 * (n + 1 - r) * mod_inv(n + 1, MOD)) % MOD\n\n ret = (ret + c1 * c2) % MOD\n\n return ret", "iroha_and_grid", "ans = iroha_and_grid(H, W, A, B)", "iroha_and_grid(H, W, A, B)", "ans", "W, A, B = map(int, input().split())", "map(int, input().split())", "W", "B = map(int, input().split())", "map(int, input().split())", "B", "def mod_inv(n: int, mod: int)->int:\n b, u, v = mod, 1, 0\n while b > 0:\n t = n // b\n\n n -= t * b\n u -= t * v\n\n n, b = b, n\n u, v = v, u\n\n return (u+mod) % mod", "def mod_inv(n: int, mod: int)->int:\n b, u, v = mod, 1, 0\n while b > 0:\n t = n // b\n\n n -= t * b\n u -= t * v\n\n n, b = b, n\n u, v = v, u\n\n return (u+mod) % mod", "mod_inv", "def comb(r: int, c: int, mod: int) -> int:\n if c < 0 or r < c:\n raise Exception('invalid r={}, c={}'.format(r, c))\n if c == 0 or c == r:\n return 1\n return (comb(r-1, c-1, mod) + comb(r-1, c, mod)) % mod\n\n\n# n+1Cr = (n+1)*n!/((n+1-r)!r!) = ((n+1)/(n+1-r)) * (n!/((n-r)!r!))", "def comb(r: int, c: int, mod: int) -> int:\n if c < 0 or r < c:\n raise Exception('invalid r={}, c={}'.format(r, c))\n if c == 0 or c == r:\n return 1\n return (comb(r-1, c-1, mod) + comb(r-1, c, mod)) % mod\n\n\n# n+1Cr = (n+1)*n!/((n+1-r)!r!) = ((n+1)/(n+1-r)) * (n!/((n-r)!r!))", "comb", "A, B = map(int, input().split())", "map(int, input().split())", "A", "H, W, A, B = map(int, input().split())", "map(int, input().split())", "H" ]

[ 7, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 13, 13, 0, 13, 17, 0, 13, 2, 2, 17, 17, 17, 0, 13, 2, 13, 17, 28, 13, 4, 13, 2, 2, 13, 13, 17, 14, 4, 18, 13, 13, 2, 13, 17, 0, 13, 2, 2, 13, 18, 18, 13, 2, 13, 17, 17, 13, 0, 13, 17, 0, 13, 4, 13, 13, 13, 13, 0, 18, 13, 13, 39, 13, 13, 12, 13, 29, 2, 2, 18, 18, 13, 13, 17, 18, 18, 13, 13, 17, 18, 18, 13, 2, 13, 13, 17, 23, 13, 23, 13, 0, 13, 17, 28, 13, 4, 13, 13, 13, 0, 13, 2, 4, 13, 2, 2, 2, 13, 13, 13, 17, 13, 4, 13, 2, 2, 2, 2, 13, 17, 13, 13, 17, 2, 2, 13, 17, 13, 0, 13, 13, 4, 13, 2, 13, 13, 10, 4, 13, 10, 13, 13, 10, 17, 13, 10, 4, 13, 10, 4, 13, 10, 4, 13, 10, 17, 13, 10, 17, 13, 10, 2, 13, 10, 2, 13, 10, 4, 13, 10, 12, 13, 10, 2, 13, 10, 2, 13 ]

[ [ 164, 2 ], [ 164, 11 ], [ 164, 12 ], [ 164, 13 ], [ 170, 15 ], [ 188, 18 ], [ 173, 25 ], [ 189, 27 ], [ 31, 30 ], [ 150, 35 ], [ 165, 36 ], [ 171, 41 ], [ 30, 44 ], [ 185, 47 ], [ 30, 50 ], [ 171, 53 ], [ 30, 55 ], [ 189, 58 ], [ 155, 60 ], [ 179, 63 ], [ 156, 66 ], [ 186, 66 ], [ 174, 67 ], [ 189, 68 ], [ 73, 70 ], [ 171, 71 ], [ 30, 72 ], [ 171, 83 ], [ 99, 84 ], [ 171, 88 ], [ 101, 89 ], [ 171, 93 ], [ 99, 95 ], [ 101, 96 ], [ 99, 99 ], [ 101, 101 ], [ 167, 103 ], [ 107, 106 ], [ 162, 109 ], [ 165, 110 ], [ 176, 112 ], [ 183, 115 ], [ 106, 119 ], [ 150, 120 ], [ 159, 121 ], [ 106, 123 ], [ 183, 125 ], [ 165, 130 ], [ 106, 132 ], [ 159, 133 ], [ 165, 137 ], [ 106, 139 ], [ 152, 141 ], [ 189, 142 ], [ 153, 146 ], [ 177, 146 ], [ 168, 146 ], [ 189, 147 ], [ 164, 150 ], [ 189, 152 ], [ 152, 153 ], [ 155, 156 ], [ 164, 159 ], [ 164, 162 ], [ 164, 165 ], [ 167, 168 ], [ 170, 171 ], [ 173, 174 ], [ 176, 177 ], [ 179, 180 ], [ 185, 186 ], [ 188, 189 ] ]

[ "H, W, A, B = map(int, input().split())\nh = {}\np = 10**9+7\nq = p - 2\nfor x in range(H+W-1):\n if h.get(x-1):\n a = (x * h[x-1][0]) % p\n else:\n a = 1\n b = pow(a,q,p)\n h[x] = (a,b)\n\ndef C(n, r):\n return h[n][0] * h[r][1] * h[n-r][1]\n\nans = 0\nfor i in range(B, W):\n ans += C(i+H - A - 1, i) * C(W - 1 - i + A - 1, W - 1 - i)\n ans %= p\nprint(ans % p)", "H, W, A, B = map(int, input().split())", "H", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "W", "A", "B", "h = {}", "h", "{}", "p = 10**9+7", "p", "10**9+7", "10**9", "10", "9", "7", "q = p - 2", "q", "p - 2", "p", "2", "for x in range(H+W-1):\n if h.get(x-1):\n a = (x * h[x-1][0]) % p\n else:\n a = 1\n b = pow(a,q,p)\n h[x] = (a,b)", "x", "range(H+W-1)", "range", "H+W-1", "H+W", "H", "W", "1", "if h.get(x-1):\n a = (x * h[x-1][0]) % p\n else:\n a = 1\n ", "h.get(x-1)", "h.get", "h", "get", "x-1", "x", "1", "a = (x * h[x-1][0]) % p", "a", "(x * h[x-1][0]) % p", "x * h[x-1][0]", "x", "h[x-1][0]", "[x-1]", "h", "x-1", "x", "1", "0", "p", "a = 1", "a", "1", "b = pow(a,q,p)", "b", "pow(a,q,p)", "pow", "a", "q", "p", "h[x] = (a,b)", "h[x]", "h", "x", "(a,b)", "a", "b", "def C(n, r):\n return h[n][0] * h[r][1] * h[n-r][1]", "C", "return h[n][0] * h[r][1] * h[n-r][1]", "h[n][0] * h[r][1] * h[n-r][1]", "h[n][0] * h[r][1]", "h[n][0]", "[n]", "h", "n", "0", "h[r][1]", "[r]", "h", "r", "1", "h[n-r][1]", "[n-r]", "h", "n-r", "n", "r", "1", "n", "n", "r", "r", "ans = 0", "ans", "0", "for i in range(B, W):\n ans += C(i+H - A - 1, i) * C(W - 1 - i + A - 1, W - 1 - i)\n ans %= p", "i", "range(B, W)", "range", "B", "W", "ans += C(i+H - A - 1, i) * C(W - 1 - i + A - 1, W - 1 - i)", "ans", "C(i+H - A - 1, i) * C(W - 1 - i + A - 1, W - 1 - i)", "C(i+H - A - 1, i)", "C", "i+H - A - 1", "i+H - A", "i+H", "i", "H", "A", "1", "i", "C(W - 1 - i + A - 1, W - 1 - i)", "C", "W - 1 - i + A - 1", "W - 1 - i + A", "W - 1 - i", "W - 1", "W", "1", "i", "A", "1", "W - 1 - i", "W - 1", "W", "1", "i", "ans %= p", "ans", "p", "print(ans % p)", "print", "ans % p", "ans", "p", "H, W, A, B = map(int, input().split())", "map(int, input().split())", "H", "ans %= p", "p", "ans", "a = 1", "1", "a", "A, B = map(int, input().split())", "map(int, input().split())", "A", "B = map(int, input().split())", "map(int, input().split())", "B", "W, A, B = map(int, input().split())", "map(int, input().split())", "W", "ans = 0", "0", "ans", "h = {}", "{}", "h", "q = p - 2", "p - 2", "q", "ans += C(i+H - A - 1, i) * C(W - 1 - i + A - 1, W - 1 - i)", "C(i+H - A - 1, i) * C(W - 1 - i + A - 1, W - 1 - i)", "ans", "b = pow(a,q,p)", "pow(a,q,p)", "b", "def C(n, r):\n return h[n][0] * h[r][1] * h[n-r][1]", "def C(n, r):\n return h[n][0] * h[r][1] * h[n-r][1]", "C", "a = (x * h[x-1][0]) % p", "(x * h[x-1][0]) % p", "a", "p = 10**9+7", "10**9+7", "p" ]

[ 7, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 13, 13, 0, 13, 2, 2, 17, 17, 17, 0, 13, 2, 39, 17, 2, 13, 13, 0, 18, 13, 17, 17, 0, 18, 13, 17, 17, 28, 13, 4, 13, 17, 2, 13, 13, 0, 18, 13, 13, 2, 2, 18, 13, 2, 13, 17, 13, 13, 0, 13, 2, 39, 17, 2, 13, 13, 0, 18, 13, 2, 2, 13, 13, 17, 4, 13, 18, 13, 2, 2, 13, 13, 17, 2, 13, 17, 13, 28, 13, 4, 13, 2, 2, 13, 13, 17, 17, 17, 0, 18, 13, 13, 2, 2, 18, 13, 2, 13, 17, 2, 13, 17, 13, 12, 13, 0, 13, 4, 13, 13, 2, 13, 13, 0, 13, 18, 13, 13, 0, 13, 2, 2, 18, 13, 13, 18, 13, 2, 13, 13, 13, 29, 2, 2, 13, 13, 13, 23, 13, 23, 13, 0, 13, 2, 13, 13, 0, 13, 2, 13, 17, 0, 13, 17, 42, 2, 2, 13, 17, 40, 13, 13, 0, 13, 2, 2, 13, 2, 4, 13, 2, 2, 13, 13, 17, 2, 13, 17, 4, 13, 2, 2, 2, 13, 13, 13, 13, 2, 13, 13, 13, 0, 13, 17, 0, 13, 17, 4, 13, 13, 10, 4, 13, 10, 2, 13, 10, 4, 13, 10, 17, 13, 10, 2, 13, 10, 17, 13, 10, 2, 13, 10, 4, 13, 10, 2, 13, 10, 17, 13, 10, 12, 13, 10, 2, 13, 10, 4, 13, 10, 2, 13 ]

[ [ 249, 2 ], [ 249, 11 ], [ 249, 12 ], [ 249, 13 ], [ 237, 15 ], [ 216, 22 ], [ 250, 27 ], [ 220, 28 ], [ 33, 30 ], [ 217, 31 ], [ 38, 35 ], [ 217, 36 ], [ 41, 40 ], [ 250, 45 ], [ 220, 46 ], [ 51, 48 ], [ 217, 49 ], [ 40, 50 ], [ 217, 54 ], [ 40, 56 ], [ 40, 58 ], [ 238, 59 ], [ 231, 61 ], [ 250, 66 ], [ 220, 67 ], [ 76, 69 ], [ 232, 70 ], [ 250, 73 ], [ 220, 74 ], [ 217, 79 ], [ 250, 82 ], [ 220, 83 ], [ 238, 86 ], [ 238, 88 ], [ 91, 90 ], [ 250, 95 ], [ 220, 96 ], [ 104, 101 ], [ 232, 102 ], [ 90, 103 ], [ 232, 107 ], [ 90, 109 ], [ 90, 112 ], [ 238, 114 ], [ 119, 118 ], [ 152, 121 ], [ 150, 123 ], [ 152, 124 ], [ 127, 126 ], [ 217, 128 ], [ 150, 129 ], [ 132, 131 ], [ 232, 135 ], [ 118, 136 ], [ 152, 136 ], [ 232, 138 ], [ 150, 140 ], [ 118, 141 ], [ 152, 141 ], [ 238, 142 ], [ 126, 146 ], [ 131, 147 ], [ 238, 148 ], [ 150, 150 ], [ 152, 152 ], [ 246, 154 ], [ 250, 156 ], [ 214, 157 ], [ 252, 159 ], [ 235, 161 ], [ 240, 164 ], [ 247, 169 ], [ 229, 169 ], [ 253, 172 ], [ 223, 172 ], [ 220, 173 ], [ 225, 175 ], [ 241, 178 ], [ 226, 178 ], [ 244, 181 ], [ 247, 184 ], [ 229, 184 ], [ 253, 185 ], [ 223, 185 ], [ 247, 188 ], [ 229, 188 ], [ 244, 191 ], [ 250, 195 ], [ 247, 196 ], [ 229, 196 ], [ 220, 197 ], [ 253, 198 ], [ 223, 198 ], [ 250, 200 ], [ 247, 201 ], [ 229, 201 ], [ 238, 202 ], [ 228, 204 ], [ 222, 207 ], [ 226, 211 ], [ 241, 211 ], [ 249, 214 ], [ 216, 217 ], [ 249, 220 ], [ 222, 223 ], [ 225, 226 ], [ 228, 229 ], [ 231, 232 ], [ 249, 235 ], [ 237, 238 ], [ 240, 241 ], [ 246, 247 ], [ 249, 250 ], [ 252, 253 ] ]

[ "# -*- coding: utf-8 -*-\n\nH,W,A,B = map(int, input().split())\nmod = (10 ** 9 + 7)\n\n# 予め組み合わせ計算に必要な階乗と逆元のテーブルを作っておく\nfactorial = [1] * (H+W)\nfactorial[0] = 1\nfactorial[1] = 1\nfor i in range(2,H+W):\n factorial[i] = factorial[i-1] * i % mod\n\ninverse = [1] * (H+W)\n# フェルマーの小定理から(x! ** mod-2 % mod == x! ** -1 % mod)\n# powに第三引数入れると冪乗のmod付計算を高速にやってくれる\ninverse[H+W-1] = pow(factorial[H+W-1], mod-2, mod)\nfor i in range(H+W-2, 0, -1):\n # 最後から戻っていくこのループならH+W回powするより処理が速い\n inverse[i] = inverse[i+1] * (i+1) % mod\n\n# 組み合わせの数だけ返してくれる関数(自作)\ndef nCr(n, r):\n # 10C7 = 10C3\n r = min(r, n-r)\n # 分子の計算\n numerator = factorial[n]\n # 分母の計算\n denominator = inverse[r] * inverse[n-r] % mod\n return numerator * denominator % mod\n\nh = H - A\nw = B + 1\nans = 0\n# マスを右上に1つずつずらして、必ず通る場所でパターンを足し合わせていく\nwhile h > 0 and w <= W:\n ans = (ans + nCr(h+w-2, h-1) * nCr(H-h+W-w, H-h)) % mod\n h -= 1\n w += 1\n\nprint(ans)", "H,W,A,B = map(int, input().split())", "H", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "W", "A", "B", "mod = (10 ** 9 + 7)", "mod", "10 ** 9 + 7", "10 ** 9", "10", "9", "7", "factorial = [1] * (H+W)", "factorial", "[1] * (H+W)", "[1]", "1", "H+W", "H", "W", "factorial[0] = 1", "factorial[0]", "factorial", "0", "1", "factorial[1] = 1", "factorial[1]", "factorial", "1", "1", "for i in range(2,H+W):\n factorial[i] = factorial[i-1] * i % mod", "i", "range(2,H+W)", "range", "2", "H+W", "H", "W", "factorial[i] = factorial[i-1] * i % mod", "factorial[i]", "factorial", "i", "factorial[i-1] * i % mod", "factorial[i-1] * i", "factorial[i-1]", "factorial", "i-1", "i", "1", "i", "mod", "inverse = [1] * (H+W)", "inverse", "[1] * (H+W)", "[1]", "1", "H+W", "H", "W", "inverse[H+W-1] = pow(factorial[H+W-1], mod-2, mod)", "inverse[H+W-1]", "inverse", "H+W-1", "H+W", "H", "W", "1", "pow(factorial[H+W-1], mod-2, mod)", "pow", "factorial[H+W-1]", "factorial", "H+W-1", "H+W", "H", "W", "1", "mod-2", "mod", "2", "mod", "for i in range(H+W-2, 0, -1):\n # 最後から戻っていくこのループならH+W回powするより処理が速い\n inverse[i] = inverse[i+1] * (i+1) % mod\n\n# 組み合わせの数だけ返してくれる関数(自作)", "i", "range(H+W-2, 0, -1)", "range", "H+W-2", "H+W", "H", "W", "2", "0", "-1", "inverse[i] = inverse[i+1] * (i+1) % mod", "inverse[i]", "inverse", "i", "inverse[i+1] * (i+1) % mod", "inverse[i+1] * (i+1)", "inverse[i+1]", "inverse", "i+1", "i", "1", "i+1", "i", "1", "mod", "def nCr(n, r):\n # 10C7 = 10C3\n r = min(r, n-r)\n # 分子の計算\n numerator = factorial[n]\n # 分母の計算\n denominator = inverse[r] * inverse[n-r] % mod\n return numerator * denominator % mod", "nCr", "r = min(r, n-r)", "r", "min(r, n-r)", "min", "r", "n-r", "n", "r", "numerator = factorial[n]", "numerator", "factorial[n]", "factorial", "n", "denominator = inverse[r] * inverse[n-r] % mod", "denominator", "inverse[r] * inverse[n-r] % mod", "inverse[r] * inverse[n-r]", "inverse[r]", "inverse", "r", "inverse[n-r]", "inverse", "n-r", "n", "r", "mod", "return numerator * denominator % mod", "numerator * denominator % mod", "numerator * denominator", "numerator", "denominator", "mod", "n", "n", "r", "r", "h = H - A", "h", "H - A", "H", "A", "w = B + 1", "w", "B + 1", "B", "1", "ans = 0", "ans", "0", "while h > 0 and w <= W:\n ans = (ans + nCr(h+w-2, h-1) * nCr(H-h+W-w, H-h)) % mod\n h -= 1\n w += 1", "h > 0 and w <= W", "h > 0", "h", "0", "w <= W", "w", "W", "ans = (ans + nCr(h+w-2, h-1) * nCr(H-h+W-w, H-h)) % mod", "ans", "(ans + nCr(h+w-2, h-1) * nCr(H-h+W-w, H-h)) % mod", "ans + nCr(h+w-2, h-1) * nCr(H-h+W-w, H-h)", "ans", "nCr(h+w-2, h-1) * nCr(H-h+W-w, H-h)", "nCr(h+w-2, h-1)", "nCr", "h+w-2", "h+w", "h", "w", "2", "h-1", "h", "1", "nCr(H-h+W-w, H-h)", "nCr", "H-h+W-w", "H-h+W", "H-h", "H", "h", "W", "w", "H-h", "H", "h", "mod", "h -= 1", "h", "1", "w += 1", "w", "1", "print(ans)", "print", "ans", "A,B = map(int, input().split())", "map(int, input().split())", "A", "factorial = [1] * (H+W)", "[1] * (H+W)", "factorial", "W,A,B = map(int, input().split())", "map(int, input().split())", "W", "w += 1", "1", "w", "ans = (ans + nCr(h+w-2, h-1) * nCr(H-h+W-w, H-h)) % mod", "(ans + nCr(h+w-2, h-1) * nCr(H-h+W-w, H-h)) % mod", "ans", "h -= 1", "1", "h", "inverse = [1] * (H+W)", "[1] * (H+W)", "inverse", "B = map(int, input().split())", "map(int, input().split())", "B", "mod = (10 ** 9 + 7)", "10 ** 9 + 7", "mod", "ans = 0", "0", "ans", "def nCr(n, r):\n # 10C7 = 10C3\n r = min(r, n-r)\n # 分子の計算\n numerator = factorial[n]\n # 分母の計算\n denominator = inverse[r] * inverse[n-r] % mod\n return numerator * denominator % mod", "def nCr(n, r):\n # 10C7 = 10C3\n r = min(r, n-r)\n # 分子の計算\n numerator = factorial[n]\n # 分母の計算\n denominator = inverse[r] * inverse[n-r] % mod\n return numerator * denominator % mod", "nCr", "h = H - A", "H - A", "h", "H,W,A,B = map(int, input().split())", "map(int, input().split())", "H", "w = B + 1", "B + 1", "w" ]

[ 7, 15, 13, 0, 13, 18, 18, 13, 13, 13, 12, 13, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 13, 13, 0, 13, 2, 4, 13, 17, 17, 0, 13, 2, 39, 17, 2, 4, 13, 2, 2, 13, 13, 13, 2, 2, 13, 13, 13, 17, 28, 13, 4, 13, 17, 4, 13, 13, 0, 18, 13, 13, 2, 18, 13, 2, 13, 17, 13, 0, 18, 13, 13, 13, 0, 13, 2, 39, 17, 2, 13, 13, 0, 13, 2, 39, 17, 2, 13, 13, 0, 13, 2, 2, 13, 13, 17, 28, 13, 4, 13, 2, 13, 13, 0, 13, 2, 2, 2, 13, 17, 13, 17, 0, 18, 13, 13, 2, 2, 18, 13, 2, 13, 13, 4, 13, 18, 13, 13, 2, 13, 17, 13, 4, 13, 18, 13, 13, 2, 13, 17, 13, 0, 18, 13, 13, 13, 0, 13, 2, 13, 17, 28, 13, 4, 13, 2, 13, 13, 0, 13, 2, 2, 2, 13, 13, 13, 17, 0, 18, 13, 13, 2, 2, 18, 13, 2, 13, 13, 4, 13, 18, 13, 13, 2, 13, 17, 13, 4, 13, 18, 13, 13, 2, 13, 17, 13, 0, 18, 13, 13, 13, 0, 13, 17, 28, 13, 4, 13, 2, 13, 13, 0, 13, 2, 18, 13, 13, 18, 13, 13, 0, 13, 13, 4, 13, 13, 14, 2, 13, 17, 4, 13, 10, 18, 13, 10, 12, 13 ]

[ [ 235, 4 ], [ 14, 13 ], [ 236, 20 ], [ 14, 22 ], [ 14, 23 ], [ 14, 24 ], [ 27, 26 ], [ 34, 33 ], [ 13, 42 ], [ 23, 43 ], [ 22, 44 ], [ 23, 47 ], [ 22, 48 ], [ 24, 49 ], [ 53, 52 ], [ 33, 58 ], [ 63, 60 ], [ 33, 61 ], [ 52, 62 ], [ 33, 65 ], [ 52, 67 ], [ 52, 69 ], [ 74, 71 ], [ 33, 72 ], [ 52, 73 ], [ 26, 74 ], [ 77, 76 ], [ 22, 81 ], [ 24, 82 ], [ 85, 84 ], [ 22, 89 ], [ 24, 90 ], [ 93, 92 ], [ 13, 95 ], [ 23, 96 ], [ 100, 99 ], [ 22, 103 ], [ 24, 104 ], [ 107, 106 ], [ 24, 110 ], [ 99, 112 ], [ 118, 115 ], [ 76, 116 ], [ 99, 117 ], [ 33, 121 ], [ 92, 123 ], [ 106, 124 ], [ 33, 128 ], [ 92, 129 ], [ 26, 131 ], [ 26, 133 ], [ 33, 137 ], [ 106, 138 ], [ 26, 140 ], [ 26, 142 ], [ 147, 144 ], [ 76, 145 ], [ 99, 146 ], [ 26, 147 ], [ 150, 149 ], [ 23, 151 ], [ 155, 154 ], [ 22, 158 ], [ 24, 159 ], [ 162, 161 ], [ 22, 165 ], [ 24, 166 ], [ 154, 167 ], [ 173, 170 ], [ 84, 171 ], [ 154, 172 ], [ 33, 176 ], [ 149, 178 ], [ 92, 178 ], [ 161, 179 ], [ 106, 179 ], [ 33, 183 ], [ 149, 184 ], [ 92, 184 ], [ 26, 186 ], [ 26, 188 ], [ 33, 192 ], [ 161, 193 ], [ 106, 193 ], [ 26, 195 ], [ 26, 197 ], [ 202, 199 ], [ 84, 200 ], [ 154, 201 ], [ 26, 202 ], [ 205, 204 ], [ 208, 207 ], [ 22, 211 ], [ 24, 212 ], [ 215, 214 ], [ 144, 216 ], [ 115, 216 ], [ 76, 217 ], [ 207, 218 ], [ 199, 219 ], [ 170, 219 ], [ 84, 220 ], [ 207, 221 ], [ 224, 223 ], [ 26, 224 ], [ 223, 227 ], [ 214, 227 ], [ 204, 227 ], [ 239, 233 ], [ 235, 236 ] ]

[ "import sys\ninput = sys.stdin.readline\n\ndef main():\n H, W, A, B = map(int, input().split())\n\n MOD = int(1e9) + 7\n\n kai = [1] * (max(H-A+W, A+W-B) + 1)\n for i in range(1, len(kai)):\n kai[i] = kai[i-1] * i\n kai[i] %= MOD\n \n up = [0] * (W-B)\n down = [0] * (W-B)\n\n t1 = H-A-1\n for i in range(W-B):\n t2 = B + 1 + i-1\n # print(t1, t2)\n up[i] = kai[t1 + t2] * pow(kai[t1], MOD-2, MOD) * pow(kai[t2], MOD-2, MOD)\n up[i] %= MOD\n t1 = A-1\n for i in range(W-B):\n t2 = W-B-i-1\n # print(t1, t2)\n down[i] = kai[t1 + t2] * pow(kai[t1], MOD-2, MOD) * pow(kai[t2], MOD-2, MOD)\n down[i] %= MOD\n \n ans = 0\n for i in range(W-B):\n ans += (up[i] * down[i])\n ans %= MOD\n print(ans)\n\n\nif __name__ == \"__main__\":\n main()", "import sys", "sys", "input = sys.stdin.readline", "input", "sys.stdin.readline", "sys.stdin", "sys", "stdin", "readline", "def main():\n H, W, A, B = map(int, input().split())\n\n MOD = int(1e9) + 7\n\n kai = [1] * (max(H-A+W, A+W-B) + 1)\n for i in range(1, len(kai)):\n kai[i] = kai[i-1] * i\n kai[i] %= MOD\n \n up = [0] * (W-B)\n down = [0] * (W-B)\n\n t1 = H-A-1\n for i in range(W-B):\n t2 = B + 1 + i-1\n # print(t1, t2)\n up[i] = kai[t1 + t2] * pow(kai[t1], MOD-2, MOD) * pow(kai[t2], MOD-2, MOD)\n up[i] %= MOD\n t1 = A-1\n for i in range(W-B):\n t2 = W-B-i-1\n # print(t1, t2)\n down[i] = kai[t1 + t2] * pow(kai[t1], MOD-2, MOD) * pow(kai[t2], MOD-2, MOD)\n down[i] %= MOD\n \n ans = 0\n for i in range(W-B):\n ans += (up[i] * down[i])\n ans %= MOD\n print(ans)", "main", "H, W, A, B = map(int, input().split())", "H", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "W", "A", "B", "MOD = int(1e9) + 7", "MOD", "int(1e9) + 7", "int(1e9)", "int", "1e9", "7", "kai = [1] * (max(H-A+W, A+W-B) + 1)", "kai", "[1] * (max(H-A+W, A+W-B) + 1)", "[1]", "1", "max(H-A+W, A+W-B) + 1", "max(H-A+W, A+W-B)", "max", "H-A+W", "H-A", "H", "A", "W", "A+W-B", "A+W", "A", "W", "B", "1", "for i in range(1, len(kai)):\n kai[i] = kai[i-1] * i\n kai[i] %= MOD\n \n ", "i", "range(1, len(kai))", "range", "1", "len(kai)", "len", "kai", "kai[i] = kai[i-1] * i", "kai[i]", "kai", "i", "kai[i-1] * i", "kai[i-1]", "kai", "i-1", "i", "1", "i", "kai[i] %= MOD", "kai[i]", "kai", "i", "MOD", "up = [0] * (W-B)", "up", "[0] * (W-B)", "[0]", "0", "W-B", "W", "B", "down = [0] * (W-B)", "down", "[0] * (W-B)", "[0]", "0", "W-B", "W", "B", "t1 = H-A-1", "t1", "H-A-1", "H-A", "H", "A", "1", "for i in range(W-B):\n t2 = B + 1 + i-1\n # print(t1, t2)\n up[i] = kai[t1 + t2] * pow(kai[t1], MOD-2, MOD) * pow(kai[t2], MOD-2, MOD)\n up[i] %= MOD\n ", "i", "range(W-B)", "range", "W-B", "W", "B", "t2 = B + 1 + i-1", "t2", "B + 1 + i-1", "B + 1 + i", "B + 1", "B", "1", "i", "1", "up[i] = kai[t1 + t2] * pow(kai[t1], MOD-2, MOD) * pow(kai[t2], MOD-2, MOD)", "up[i]", "up", "i", "kai[t1 + t2] * pow(kai[t1], MOD-2, MOD) * pow(kai[t2], MOD-2, MOD)", "kai[t1 + t2] * pow(kai[t1], MOD-2, MOD)", "kai[t1 + t2]", "kai", "t1 + t2", "t1", "t2", "pow(kai[t1], MOD-2, MOD)", "pow", "kai[t1]", "kai", "t1", "MOD-2", "MOD", "2", "MOD", "pow(kai[t2], MOD-2, MOD)", "pow", "kai[t2]", "kai", "t2", "MOD-2", "MOD", "2", "MOD", "up[i] %= MOD", "up[i]", "up", "i", "MOD", "t1 = A-1", "t1", "A-1", "A", "1", "for i in range(W-B):\n t2 = W-B-i-1\n # print(t1, t2)\n down[i] = kai[t1 + t2] * pow(kai[t1], MOD-2, MOD) * pow(kai[t2], MOD-2, MOD)\n down[i] %= MOD\n \n ", "i", "range(W-B)", "range", "W-B", "W", "B", "t2 = W-B-i-1", "t2", "W-B-i-1", "W-B-i", "W-B", "W", "B", "i", "1", "down[i] = kai[t1 + t2] * pow(kai[t1], MOD-2, MOD) * pow(kai[t2], MOD-2, MOD)", "down[i]", "down", "i", "kai[t1 + t2] * pow(kai[t1], MOD-2, MOD) * pow(kai[t2], MOD-2, MOD)", "kai[t1 + t2] * pow(kai[t1], MOD-2, MOD)", "kai[t1 + t2]", "kai", "t1 + t2", "t1", "t2", "pow(kai[t1], MOD-2, MOD)", "pow", "kai[t1]", "kai", "t1", "MOD-2", "MOD", "2", "MOD", "pow(kai[t2], MOD-2, MOD)", "pow", "kai[t2]", "kai", "t2", "MOD-2", "MOD", "2", "MOD", "down[i] %= MOD", "down[i]", "down", "i", "MOD", "ans = 0", "ans", "0", "for i in range(W-B):\n ans += (up[i] * down[i])\n ans %= MOD\n ", "i", "range(W-B)", "range", "W-B", "W", "B", "ans += (up[i] * down[i])", "ans", "up[i] * down[i]", "up[i]", "up", "i", "down[i]", "down", "i", "ans %= MOD", "ans", "MOD", "print(ans)", "print", "ans", "if __name__ == \"__main__\":\n main()", "__name__ == \"__main__\"", "__name__", "\"__main__\"", "main()", "main", "input = sys.stdin.readline", "sys.stdin.readline", "input", "def main():\n H, W, A, B = map(int, input().split())\n\n MOD = int(1e9) + 7\n\n kai = [1] * (max(H-A+W, A+W-B) + 1)\n for i in range(1, len(kai)):\n kai[i] = kai[i-1] * i\n kai[i] %= MOD\n \n up = [0] * (W-B)\n down = [0] * (W-B)\n\n t1 = H-A-1\n for i in range(W-B):\n t2 = B + 1 + i-1\n # print(t1, t2)\n up[i] = kai[t1 + t2] * pow(kai[t1], MOD-2, MOD) * pow(kai[t2], MOD-2, MOD)\n up[i] %= MOD\n t1 = A-1\n for i in range(W-B):\n t2 = W-B-i-1\n # print(t1, t2)\n down[i] = kai[t1 + t2] * pow(kai[t1], MOD-2, MOD) * pow(kai[t2], MOD-2, MOD)\n down[i] %= MOD\n \n ans = 0\n for i in range(W-B):\n ans += (up[i] * down[i])\n ans %= MOD\n print(ans)", "def main():\n H, W, A, B = map(int, input().split())\n\n MOD = int(1e9) + 7\n\n kai = [1] * (max(H-A+W, A+W-B) + 1)\n for i in range(1, len(kai)):\n kai[i] = kai[i-1] * i\n kai[i] %= MOD\n \n up = [0] * (W-B)\n down = [0] * (W-B)\n\n t1 = H-A-1\n for i in range(W-B):\n t2 = B + 1 + i-1\n # print(t1, t2)\n up[i] = kai[t1 + t2] * pow(kai[t1], MOD-2, MOD) * pow(kai[t2], MOD-2, MOD)\n up[i] %= MOD\n t1 = A-1\n for i in range(W-B):\n t2 = W-B-i-1\n # print(t1, t2)\n down[i] = kai[t1 + t2] * pow(kai[t1], MOD-2, MOD) * pow(kai[t2], MOD-2, MOD)\n down[i] %= MOD\n \n ans = 0\n for i in range(W-B):\n ans += (up[i] * down[i])\n ans %= MOD\n print(ans)", "main" ]

[ 7, 0, 13, 2, 2, 17, 17, 17, 0, 13, 2, 39, 17, 17, 28, 13, 4, 13, 2, 4, 13, 13, 17, 0, 18, 13, 2, 13, 17, 2, 2, 18, 13, 13, 2, 13, 17, 13, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 13, 13, 0, 13, 17, 0, 13, 13, 13, 2, 2, 13, 13, 17, 42, 2, 2, 13, 13, 40, 13, 17, 0, 13, 2, 2, 13, 13, 17, 0, 13, 2, 2, 13, 13, 17, 0, 13, 2, 2, 2, 2, 18, 13, 2, 13, 13, 4, 13, 2, 18, 13, 13, 18, 13, 13, 2, 13, 17, 13, 18, 13, 2, 13, 13, 4, 13, 2, 18, 13, 13, 18, 13, 13, 2, 13, 17, 13, 13, 0, 13, 17, 0, 13, 17, 4, 13, 2, 13, 13, 10, 2, 13, 10, 2, 13, 10, 4, 13, 10, 2, 13, 10, 2, 13, 10, 17, 13, 10, 2, 13, 10, 4, 13, 10, 2, 13, 10, 4, 13, 10, 17, 13, 10, 17, 13, 10, 13, 13, 10, 4, 13 ]

[ [ 158, 2 ], [ 152, 9 ], [ 16, 15 ], [ 153, 21 ], [ 29, 24 ], [ 153, 25 ], [ 15, 27 ], [ 153, 32 ], [ 15, 33 ], [ 15, 35 ], [ 159, 37 ], [ 179, 39 ], [ 179, 48 ], [ 179, 49 ], [ 179, 50 ], [ 170, 52 ], [ 176, 55 ], [ 180, 56 ], [ 140, 57 ], [ 162, 60 ], [ 147, 61 ], [ 177, 66 ], [ 156, 66 ], [ 168, 67 ], [ 141, 69 ], [ 174, 69 ], [ 143, 72 ], [ 168, 75 ], [ 177, 76 ], [ 156, 76 ], [ 149, 79 ], [ 162, 82 ], [ 141, 83 ], [ 174, 83 ], [ 164, 86 ], [ 153, 92 ], [ 177, 94 ], [ 156, 94 ], [ 141, 95 ], [ 174, 95 ], [ 153, 100 ], [ 177, 101 ], [ 156, 101 ], [ 153, 103 ], [ 141, 104 ], [ 174, 104 ], [ 159, 106 ], [ 159, 108 ], [ 153, 110 ], [ 144, 112 ], [ 150, 113 ], [ 153, 118 ], [ 144, 119 ], [ 153, 121 ], [ 150, 122 ], [ 159, 124 ], [ 159, 126 ], [ 159, 127 ], [ 155, 129 ], [ 173, 132 ], [ 165, 137 ], [ 171, 137 ], [ 159, 138 ], [ 140, 141 ], [ 143, 144 ], [ 179, 147 ], [ 149, 150 ], [ 152, 153 ], [ 155, 156 ], [ 158, 159 ], [ 179, 162 ], [ 164, 165 ], [ 179, 168 ], [ 170, 171 ], [ 173, 174 ], [ 180, 176 ], [ 176, 177 ], [ 179, 180 ] ]

[ "MOD = 10 ** 9 + 7\nfac = [1] * 200005\nfor i in range(len(fac) - 1):\n fac[i + 1] = fac[i] * (i + 1) % MOD\nh, w, a, b = map(int, input().split())\nans = 0\nx, y = b, h - a - 1\nwhile x < w and y >= 0:\n p = w - x - 1\n q = h - y - 1\n ans += (fac[x + y] * pow(fac[x] * fac[y], MOD - 2, MOD) *\n fac[p + q] * pow(fac[p] * fac[q], MOD - 2, MOD)) % MOD\n x += 1\n y -= 1\nprint(ans % MOD)", "MOD = 10 ** 9 + 7", "MOD", "10 ** 9 + 7", "10 ** 9", "10", "9", "7", "fac = [1] * 200005", "fac", "[1] * 200005", "[1]", "1", "200005", "for i in range(len(fac) - 1):\n fac[i + 1] = fac[i] * (i + 1) % MOD", "i", "range(len(fac) - 1)", "range", "len(fac) - 1", "len(fac)", "len", "fac", "1", "fac[i + 1] = fac[i] * (i + 1) % MOD", "fac[i + 1]", "fac", "i + 1", "i", "1", "fac[i] * (i + 1) % MOD", "fac[i] * (i + 1)", "fac[i]", "fac", "i", "i + 1", "i", "1", "MOD", "h, w, a, b = map(int, input().split())", "h", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "w", "a", "b", "ans = 0", "ans", "0", "x, y = b, h - a - 1", "x", "b", "y", "h - a - 1", "h - a", "h", "a", "1", "while x < w and y >= 0:\n p = w - x - 1\n q = h - y - 1\n ans += (fac[x + y] * pow(fac[x] * fac[y], MOD - 2, MOD) *\n fac[p + q] * pow(fac[p] * fac[q], MOD - 2, MOD)) % MOD\n x += 1\n y -= 1", "x < w and y >= 0", "x < w", "x", "w", "y >= 0", "y", "0", "p = w - x - 1", "p", "w - x - 1", "w - x", "w", "x", "1", "q = h - y - 1", "q", "h - y - 1", "h - y", "h", "y", "1", "ans += (fac[x + y] * pow(fac[x] * fac[y], MOD - 2, MOD) *\n fac[p + q] * pow(fac[p] * fac[q], MOD - 2, MOD)) % MOD", "ans", "(fac[x + y] * pow(fac[x] * fac[y], MOD - 2, MOD) *\n fac[p + q] * pow(fac[p] * fac[q], MOD - 2, MOD)) % MOD", "fac[x + y] * pow(fac[x] * fac[y], MOD - 2, MOD) *\n fac[p + q] * pow(fac[p] * fac[q], MOD - 2, MOD)", "fac[x + y] * pow(fac[x] * fac[y], MOD - 2, MOD) *\n fac[p + q]", "fac[x + y] * pow(fac[x] * fac[y], MOD - 2, MOD)", "fac[x + y]", "fac", "x + y", "x", "y", "pow(fac[x] * fac[y], MOD - 2, MOD)", "pow", "fac[x] * fac[y]", "fac[x]", "fac", "x", "fac[y]", "fac", "y", "MOD - 2", "MOD", "2", "MOD", "fac[p + q]", "fac", "p + q", "p", "q", "pow(fac[p] * fac[q], MOD - 2, MOD)", "pow", "fac[p] * fac[q]", "fac[p]", "fac", "p", "fac[q]", "fac", "q", "MOD - 2", "MOD", "2", "MOD", "MOD", "x += 1", "x", "1", "y -= 1", "y", "1", "print(ans % MOD)", "print", "ans % MOD", "ans", "MOD", "y = b, h - a - 1", "h - a - 1", "y", "p = w - x - 1", "w - x - 1", "p", "a, b = map(int, input().split())", "map(int, input().split())", "a", "q = h - y - 1", "h - y - 1", "q", "fac = [1] * 200005", "[1] * 200005", "fac", "x += 1", "1", "x", "MOD = 10 ** 9 + 7", "10 ** 9 + 7", "MOD", "h, w, a, b = map(int, input().split())", "map(int, input().split())", "h", "ans += (fac[x + y] * pow(fac[x] * fac[y], MOD - 2, MOD) *\n fac[p + q] * pow(fac[p] * fac[q], MOD - 2, MOD)) % MOD", "(fac[x + y] * pow(fac[x] * fac[y], MOD - 2, MOD) *\n fac[p + q] * pow(fac[p] * fac[q], MOD - 2, MOD)) % MOD", "ans", "w, a, b = map(int, input().split())", "map(int, input().split())", "w", "ans = 0", "0", "ans", "y -= 1", "1", "y", "x, y = b, h - a - 1", "b", "x", "b = map(int, input().split())", "map(int, input().split())", "b" ]

[ 7, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 13, 13, 0, 13, 2, 4, 13, 17, 17, 17, 12, 13, 14, 2, 2, 13, 17, 2, 13, 13, 29, 17, 0, 13, 4, 13, 13, 2, 13, 13, 29, 2, 2, 2, 18, 13, 13, 18, 13, 13, 18, 13, 2, 13, 13, 13, 23, 13, 23, 13, 23, 13, 0, 13, 39, 17, 17, 0, 13, 39, 17, 17, 0, 13, 39, 17, 17, 28, 13, 4, 13, 17, 2, 17, 17, 4, 18, 13, 13, 2, 2, 18, 13, 17, 13, 13, 4, 18, 13, 13, 2, 2, 40, 18, 13, 2, 13, 13, 2, 13, 13, 13, 4, 18, 13, 13, 2, 2, 18, 13, 17, 18, 13, 17, 13, 0, 13, 17, 28, 13, 4, 13, 17, 2, 2, 13, 13, 17, 0, 13, 4, 13, 2, 2, 2, 13, 17, 13, 17, 2, 13, 17, 13, 0, 13, 4, 13, 2, 2, 2, 2, 13, 13, 13, 13, 17, 2, 13, 13, 13, 0, 13, 13, 0, 13, 13, 4, 13, 13, 10, 13, 13, 10, 4, 13, 10, 2, 13, 10, 17, 13, 10, 39, 13, 10, 39, 13, 10, 12, 13, 10, 4, 13, 10, 39, 13, 10, 4, 13, 10, 4, 13, 10, 4, 13, 10, 13, 13, 10, 4, 13 ]

[ [ 221, 2 ], [ 221, 11 ], [ 221, 12 ], [ 221, 13 ], [ 188, 15 ], [ 61, 27 ], [ 61, 30 ], [ 59, 31 ], [ 36, 35 ], [ 61, 38 ], [ 59, 40 ], [ 61, 41 ], [ 59, 48 ], [ 35, 51 ], [ 61, 51 ], [ 59, 55 ], [ 35, 56 ], [ 61, 56 ], [ 63, 57 ], [ 59, 59 ], [ 61, 61 ], [ 63, 63 ], [ 197, 65 ], [ 206, 70 ], [ 194, 75 ], [ 81, 80 ], [ 198, 89 ], [ 198, 94 ], [ 80, 96 ], [ 189, 97 ], [ 195, 100 ], [ 195, 106 ], [ 189, 108 ], [ 80, 109 ], [ 189, 111 ], [ 80, 112 ], [ 189, 113 ], [ 207, 116 ], [ 207, 121 ], [ 195, 124 ], [ 189, 126 ], [ 191, 128 ], [ 132, 131 ], [ 213, 137 ], [ 222, 138 ], [ 215, 141 ], [ 201, 143 ], [ 131, 147 ], [ 210, 149 ], [ 131, 152 ], [ 189, 154 ], [ 185, 156 ], [ 201, 158 ], [ 213, 163 ], [ 131, 164 ], [ 204, 165 ], [ 210, 166 ], [ 213, 169 ], [ 131, 170 ], [ 189, 171 ], [ 218, 173 ], [ 186, 174 ], [ 216, 174 ], [ 182, 176 ], [ 189, 177 ], [ 183, 180 ], [ 219, 180 ], [ 192, 180 ], [ 189, 182 ], [ 182, 183 ], [ 185, 186 ], [ 188, 189 ], [ 191, 192 ], [ 194, 195 ], [ 197, 198 ], [ 221, 204 ], [ 206, 207 ], [ 221, 210 ], [ 221, 213 ], [ 215, 216 ], [ 186, 218 ], [ 216, 218 ], [ 218, 219 ], [ 221, 222 ] ]

[ "h,w,a,b=map(int,input().split())\nmod=pow(10,9)+7\n\n# コンビネーション、さらに高速。あらかじめO(N)の計算をすることでのちの計算が早くなる\ndef cmb(n, r, mod):\n if ( r<0 or r>n ):\n return 0\n r = min(r, n-r)\n return g1[n] * g2[r] * g2[n-r] % mod\ng1 = [1, 1] \ng2 = [1, 1] \ninverse = [0, 1]\nfor i in range( 2, 200000 + 1 ):\n g1.append( ( g1[-1] * i ) % mod )\n inverse.append( ( -inverse[mod % i] * (mod//i) ) % mod )\n g2.append( (g2[-1] * inverse[-1]) % mod )\nans=0\nfor k in range(1,h-a+1):\n tmp=cmb(k-1+b-1,k-1,mod)\n tmp*=cmb(h-k+w-b-1,h-k,mod)\n ans+=tmp\n ans%=mod\nprint(ans)", "h,w,a,b=map(int,input().split())", "h", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "w", "a", "b", "mod=pow(10,9)+7", "mod", "pow(10,9)+7", "pow(10,9)", "pow", "10", "9", "7", "def cmb(n, r, mod):\n if ( r<0 or r>n ):\n return 0\n r = min(r, n-r)\n return g1[n] * g2[r] * g2[n-r] % mod", "cmb", "if ( r<0 or r>n ):\n return 0\n ", "r<0 or r>n", "r<0", "r", "0", "r>n", "r", "n", "return 0", "0", "r = min(r, n-r)", "r", "min(r, n-r)", "min", "r", "n-r", "n", "r", "return g1[n] * g2[r] * g2[n-r] % mod", "g1[n] * g2[r] * g2[n-r] % mod", "g1[n] * g2[r] * g2[n-r]", "g1[n] * g2[r]", "g1[n]", "g1", "n", "g2[r]", "g2", "r", "g2[n-r]", "g2", "n-r", "n", "r", "mod", "n", "n", "r", "r", "mod", "mod", "g1 = [1, 1]", "g1", "[1, 1]", "1", "1", "g2 = [1, 1]", "g2", "[1, 1]", "1", "1", "inverse = [0, 1]", "inverse", "[0, 1]", "0", "1", "for i in range( 2, 200000 + 1 ):\n g1.append( ( g1[-1] * i ) % mod )\n inverse.append( ( -inverse[mod % i] * (mod//i) ) % mod )\n g2.append( (g2[-1] * inverse[-1]) % mod )", "i", "range( 2, 200000 + 1 )", "range", "2", "200000 + 1", "200000", "1", "g1.append( ( g1[-1] * i ) % mod )", "g1.append", "g1", "append", "( g1[-1] * i ) % mod", "g1[-1] * i", "g1[-1]", "g1", "-1", "i", "mod", "inverse.append( ( -inverse[mod % i] * (mod//i) ) % mod )", "inverse.append", "inverse", "append", "( -inverse[mod % i] * (mod//i) ) % mod", "-inverse[mod % i] * (mod//i)", "-inverse[mod % i]", "inverse[mod % i]", "inverse", "mod % i", "mod", "i", "mod//i", "mod", "i", "mod", "g2.append( (g2[-1] * inverse[-1]) % mod )", "g2.append", "g2", "append", "(g2[-1] * inverse[-1]) % mod", "g2[-1] * inverse[-1]", "g2[-1]", "g2", "-1", "inverse[-1]", "inverse", "-1", "mod", "ans=0", "ans", "0", "for k in range(1,h-a+1):\n tmp=cmb(k-1+b-1,k-1,mod)\n tmp*=cmb(h-k+w-b-1,h-k,mod)\n ans+=tmp\n ans%=mod", "k", "range(1,h-a+1)", "range", "1", "h-a+1", "h-a", "h", "a", "1", "tmp=cmb(k-1+b-1,k-1,mod)", "tmp", "cmb(k-1+b-1,k-1,mod)", "cmb", "k-1+b-1", "k-1+b", "k-1", "k", "1", "b", "1", "k-1", "k", "1", "mod", "tmp*=cmb(h-k+w-b-1,h-k,mod)", "tmp", "cmb(h-k+w-b-1,h-k,mod)", "cmb", "h-k+w-b-1", "h-k+w-b", "h-k+w", "h-k", "h", "k", "w", "b", "1", "h-k", "h", "k", "mod", "ans+=tmp", "ans", "tmp", "ans%=mod", "ans", "mod", "print(ans)", "print", "ans", "ans%=mod", "mod", "ans", "tmp*=cmb(h-k+w-b-1,h-k,mod)", "cmb(h-k+w-b-1,h-k,mod)", "tmp", "mod=pow(10,9)+7", "pow(10,9)+7", "mod", "ans=0", "0", "ans", "inverse = [0, 1]", "[0, 1]", "inverse", "g1 = [1, 1]", "[1, 1]", "g1", "def cmb(n, r, mod):\n if ( r<0 or r>n ):\n return 0\n r = min(r, n-r)\n return g1[n] * g2[r] * g2[n-r] % mod", "def cmb(n, r, mod):\n if ( r<0 or r>n ):\n return 0\n r = min(r, n-r)\n return g1[n] * g2[r] * g2[n-r] % mod", "cmb", "w,a,b=map(int,input().split())", "map(int,input().split())", "w", "g2 = [1, 1]", "[1, 1]", "g2", "b=map(int,input().split())", "map(int,input().split())", "b", "h,w,a,b=map(int,input().split())", "map(int,input().split())", "h", "tmp=cmb(k-1+b-1,k-1,mod)", "cmb(k-1+b-1,k-1,mod)", "tmp", "ans+=tmp", "tmp", "ans", "a,b=map(int,input().split())", "map(int,input().split())", "a" ]

[ 7, 0, 13, 4, 13, 13, 4, 18, 4, 18, 4, 13, 17, 13, 13, 13, 13, 13, 0, 13, 2, 2, 17, 17, 17, 12, 13, 14, 2, 13, 2, 13, 13, 0, 13, 2, 13, 13, 0, 13, 17, 0, 13, 17, 28, 13, 4, 13, 13, 0, 13, 2, 2, 13, 2, 13, 13, 13, 0, 13, 2, 2, 13, 2, 13, 17, 13, 0, 13, 2, 2, 13, 4, 13, 13, 2, 13, 17, 13, 13, 29, 13, 23, 13, 23, 13, 23, 13, 0, 13, 4, 13, 2, 2, 13, 13, 17, 2, 13, 17, 13, 0, 13, 4, 13, 2, 2, 13, 13, 17, 2, 13, 17, 13, 0, 13, 13, 28, 13, 4, 13, 2, 13, 17, 0, 13, 2, 2, 13, 13, 13, 0, 13, 2, 13, 17, 0, 13, 2, 2, 13, 13, 17, 0, 13, 2, 2, 2, 13, 13, 17, 13, 0, 13, 2, 2, 2, 13, 13, 13, 13, 0, 13, 2, 2, 13, 4, 13, 13, 17, 13, 13, 0, 13, 2, 2, 13, 4, 13, 13, 17, 13, 13, 0, 13, 2, 2, 13, 13, 13, 4, 13, 13, 10, 2, 13, 10, 2, 13, 10, 13, 13, 10, 4, 13, 10, 4, 13, 10, 2, 13, 10, 2, 13, 10, 2, 13, 10, 2, 13, 10, 12, 13, 10, 2, 13, 10, 4, 13, 10, 4, 13, 10, 4, 13, 10, 4, 13, 10, 2, 13, 10, 2, 13 ]

[ [ 236, 2 ], [ 236, 15 ], [ 236, 16 ], [ 236, 17 ], [ 212, 19 ], [ 85, 29 ], [ 83, 31 ], [ 85, 32 ], [ 35, 34 ], [ 83, 36 ], [ 85, 37 ], [ 40, 39 ], [ 43, 42 ], [ 46, 45 ], [ 34, 48 ], [ 85, 48 ], [ 51, 50 ], [ 39, 53 ], [ 50, 53 ], [ 83, 55 ], [ 45, 56 ], [ 87, 57 ], [ 60, 59 ], [ 42, 62 ], [ 59, 62 ], [ 45, 64 ], [ 87, 66 ], [ 69, 68 ], [ 50, 71 ], [ 39, 71 ], [ 59, 74 ], [ 42, 74 ], [ 87, 76 ], [ 87, 78 ], [ 87, 79 ], [ 68, 81 ], [ 83, 83 ], [ 85, 85 ], [ 87, 87 ], [ 233, 89 ], [ 222, 91 ], [ 204, 94 ], [ 237, 95 ], [ 237, 98 ], [ 213, 100 ], [ 206, 102 ], [ 222, 104 ], [ 231, 107 ], [ 237, 108 ], [ 237, 111 ], [ 213, 113 ], [ 200, 115 ], [ 207, 116 ], [ 119, 118 ], [ 228, 122 ], [ 239, 125 ], [ 204, 128 ], [ 231, 129 ], [ 118, 130 ], [ 209, 132 ], [ 118, 134 ], [ 224, 137 ], [ 237, 140 ], [ 118, 141 ], [ 194, 144 ], [ 237, 148 ], [ 231, 149 ], [ 118, 151 ], [ 197, 153 ], [ 207, 157 ], [ 219, 157 ], [ 216, 157 ], [ 198, 157 ], [ 240, 158 ], [ 225, 159 ], [ 213, 160 ], [ 215, 162 ], [ 198, 165 ], [ 207, 165 ], [ 219, 165 ], [ 216, 165 ], [ 210, 168 ], [ 213, 170 ], [ 213, 171 ], [ 218, 173 ], [ 216, 176 ], [ 198, 176 ], [ 207, 176 ], [ 219, 176 ], [ 195, 179 ], [ 213, 181 ], [ 213, 182 ], [ 242, 184 ], [ 201, 187 ], [ 234, 187 ], [ 243, 187 ], [ 219, 188 ], [ 216, 188 ], [ 198, 188 ], [ 207, 188 ], [ 213, 189 ], [ 243, 192 ], [ 201, 192 ], [ 234, 192 ], [ 194, 195 ], [ 197, 198 ], [ 207, 200 ], [ 200, 201 ], [ 236, 204 ], [ 206, 207 ], [ 209, 210 ], [ 212, 213 ], [ 215, 216 ], [ 218, 219 ], [ 224, 225 ], [ 236, 228 ], [ 236, 231 ], [ 233, 234 ], [ 236, 237 ], [ 239, 240 ], [ 242, 243 ] ]

[ "H, W, A, B = map(int, open(0).read().split())\nMOD = 10**9+7\n\ndef modcomb(m, n, mod):\n if n > m - n:\n n = m - n\n p = 1\n q = 1\n for i in range(n):\n p = p * (m - i) % mod\n q = q * (i + 1) % mod\n result = p * pow(q, mod - 2, mod) % mod\n return result\n\ntotal = modcomb(H + W - 2, W - 1, MOD)\n\ntmp = modcomb(A + W - 2, W - 1, MOD)\ntotal -= tmp\n\nfor i in range(B - 1):\n a = H - A + i\n b = i + 1\n c = W - i - 1\n d = W + A - 2 - i\n# print(a,b,c,d)\n tmp = tmp * a * c % MOD\n tmp = tmp * pow(b, -1, MOD) % MOD\n tmp = tmp * pow(d, -1, MOD) % MOD\n# print(tmp)\n total = (total - tmp) % MOD\n\nprint(total)", "H, W, A, B = map(int, open(0).read().split())", "H", "map(int, open(0).read().split())", "map", "int", "open(0).read().split()", "(0).read().split", "(0).read()", "(0).read", "(0)", "open", "0", "read", "split", "W", "A", "B", "MOD = 10**9+7", "MOD", "10**9+7", "10**9", "10", "9", "7", "def modcomb(m, n, mod):\n if n > m - n:\n n = m - n\n p = 1\n q = 1\n for i in range(n):\n p = p * (m - i) % mod\n q = q * (i + 1) % mod\n result = p * pow(q, mod - 2, mod) % mod\n return result", "modcomb", "if n > m - n:\n n = m - n\n ", "n > m - n", "n", "m - n", "m", "n", "n = m - n", "n", "m - n", "m", "n", "p = 1", "p", "1", "q = 1", "q", "1", "for i in range(n):\n p = p * (m - i) % mod\n q = q * (i + 1) % mod\n ", "i", "range(n)", "range", "n", "p = p * (m - i) % mod", "p", "p * (m - i) % mod", "p * (m - i)", "p", "m - i", "m", "i", "mod", "q = q * (i + 1) % mod", "q", "q * (i + 1) % mod", "q * (i + 1)", "q", "i + 1", "i", "1", "mod", "result = p * pow(q, mod - 2, mod) % mod", "result", "p * pow(q, mod - 2, mod) % mod", "p * pow(q, mod - 2, mod)", "p", "pow(q, mod - 2, mod)", "pow", "q", "mod - 2", "mod", "2", "mod", "mod", "return result", "result", "m", "m", "n", "n", "mod", "mod", "total = modcomb(H + W - 2, W - 1, MOD)", "total", "modcomb(H + W - 2, W - 1, MOD)", "modcomb", "H + W - 2", "H + W", "H", "W", "2", "W - 1", "W", "1", "MOD", "tmp = modcomb(A + W - 2, W - 1, MOD)", "tmp", "modcomb(A + W - 2, W - 1, MOD)", "modcomb", "A + W - 2", "A + W", "A", "W", "2", "W - 1", "W", "1", "MOD", "total -= tmp", "total", "tmp", "for i in range(B - 1):\n a = H - A + i\n b = i + 1\n c = W - i - 1\n d = W + A - 2 - i\n# print(a,b,c,d)\n tmp = tmp * a * c % MOD\n tmp = tmp * pow(b, -1, MOD) % MOD\n tmp = tmp * pow(d, -1, MOD) % MOD\n# print(tmp)\n total = (total - tmp) % MOD", "i", "range(B - 1)", "range", "B - 1", "B", "1", "a = H - A + i", "a", "H - A + i", "H - A", "H", "A", "i", "b = i + 1", "b", "i + 1", "i", "1", "c = W - i - 1", "c", "W - i - 1", "W - i", "W", "i", "1", "d = W + A - 2 - i", "d", "W + A - 2 - i", "W + A - 2", "W + A", "W", "A", "2", "i", "tmp = tmp * a * c % MOD", "tmp", "tmp * a * c % MOD", "tmp * a * c", "tmp * a", "tmp", "a", "c", "MOD", "tmp = tmp * pow(b, -1, MOD) % MOD", "tmp", "tmp * pow(b, -1, MOD) % MOD", "tmp * pow(b, -1, MOD)", "tmp", "pow(b, -1, MOD)", "pow", "b", "-1", "MOD", "MOD", "tmp = tmp * pow(d, -1, MOD) % MOD", "tmp", "tmp * pow(d, -1, MOD) % MOD", "tmp * pow(d, -1, MOD)", "tmp", "pow(d, -1, MOD)", "pow", "d", "-1", "MOD", "MOD", "total = (total - tmp) % MOD", "total", "(total - tmp) % MOD", "total - tmp", "total", "tmp", "MOD", "print(total)", "print", "total", "d = W + A - 2 - i", "W + A - 2 - i", "d", "tmp = tmp * a * c % MOD", "tmp * a * c % MOD", "tmp", "total -= tmp", "tmp", "total", "H, W, A, B = map(int, open(0).read().split())", "map(int, open(0).read().split())", "H", "tmp = modcomb(A + W - 2, W - 1, MOD)", "modcomb(A + W - 2, W - 1, MOD)", "tmp", "b = i + 1", "i + 1", "b", "MOD = 10**9+7", "10**9+7", "MOD", "tmp = tmp * pow(b, -1, MOD) % MOD", "tmp * pow(b, -1, MOD) % MOD", "tmp", "tmp = tmp * pow(d, -1, MOD) % MOD", "tmp * pow(d, -1, MOD) % MOD", "tmp", "def modcomb(m, n, mod):\n if n > m - n:\n n = m - n\n p = 1\n q = 1\n for i in range(n):\n p = p * (m - i) % mod\n q = q * (i + 1) % mod\n result = p * pow(q, mod - 2, mod) % mod\n return result", "def modcomb(m, n, mod):\n if n > m - n:\n n = m - n\n p = 1\n q = 1\n for i in range(n):\n p = p * (m - i) % mod\n q = q * (i + 1) % mod\n result = p * pow(q, mod - 2, mod) % mod\n return result", "modcomb", "c = W - i - 1", "W - i - 1", "c", "B = map(int, open(0).read().split())", "map(int, open(0).read().split())", "B", "A, B = map(int, open(0).read().split())", "map(int, open(0).read().split())", "A", "total = modcomb(H + W - 2, W - 1, MOD)", "modcomb(H + W - 2, W - 1, MOD)", "total", "W, A, B = map(int, open(0).read().split())", "map(int, open(0).read().split())", "W", "a = H - A + i", "H - A + i", "a", "total = (total - tmp) % MOD", "(total - tmp) % MOD", "total" ]

[ 7, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 13, 13, 0, 13, 2, 13, 13, 0, 13, 2, 2, 17, 17, 17, 0, 13, 2, 39, 17, 2, 13, 17, 0, 13, 2, 39, 17, 2, 13, 17, 0, 13, 17, 28, 13, 4, 13, 17, 2, 13, 17, 0, 13, 13, 0, 13, 13, 0, 18, 13, 13, 13, 0, 13, 4, 13, 18, 13, 2, 13, 17, 2, 13, 17, 13, 28, 13, 4, 13, 2, 13, 17, 17, 17, 0, 18, 13, 13, 13, 0, 13, 13, 0, 13, 13, 12, 13, 29, 2, 2, 2, 18, 13, 13, 18, 13, 2, 13, 13, 18, 13, 13, 13, 23, 13, 23, 13, 0, 13, 39, 17, 28, 13, 4, 13, 2, 13, 13, 4, 18, 13, 13, 4, 13, 2, 13, 13, 13, 0, 13, 17, 28, 13, 4, 13, 2, 13, 13, 0, 13, 2, 2, 2, 18, 13, 2, 13, 17, 18, 13, 13, 4, 13, 2, 2, 2, 2, 13, 13, 13, 13, 17, 2, 2, 13, 13, 17, 13, 0, 13, 13, 4, 13, 13, 10, 17, 13, 10, 17, 13, 10, 12, 13, 10, 4, 13, 10, 13, 13, 10, 2, 13, 10, 2, 13, 10, 13, 13, 10, 4, 13, 10, 39, 13, 10, 2, 13, 10, 2, 13, 10, 13, 13, 10, 4, 13, 10, 2, 13, 10, 4, 13, 10, 13, 13, 10, 13, 13, 10, 4, 13 ]

[ [ 241, 2 ], [ 241, 11 ], [ 241, 12 ], [ 241, 13 ], [ 220, 15 ], [ 233, 17 ], [ 242, 18 ], [ 205, 20 ], [ 229, 27 ], [ 221, 32 ], [ 202, 35 ], [ 221, 40 ], [ 190, 43 ], [ 47, 46 ], [ 221, 51 ], [ 235, 54 ], [ 46, 55 ], [ 223, 57 ], [ 206, 58 ], [ 63, 60 ], [ 230, 61 ], [ 46, 62 ], [ 224, 63 ], [ 236, 63 ], [ 191, 63 ], [ 211, 65 ], [ 230, 69 ], [ 221, 71 ], [ 206, 74 ], [ 206, 76 ], [ 79, 78 ], [ 221, 82 ], [ 90, 87 ], [ 203, 88 ], [ 78, 89 ], [ 212, 90 ], [ 224, 90 ], [ 236, 90 ], [ 191, 90 ], [ 239, 90 ], [ 200, 90 ], [ 199, 92 ], [ 78, 93 ], [ 238, 95 ], [ 206, 96 ], [ 230, 104 ], [ 116, 105 ], [ 203, 107 ], [ 116, 109 ], [ 118, 110 ], [ 203, 112 ], [ 118, 113 ], [ 206, 114 ], [ 116, 116 ], [ 118, 118 ], [ 214, 120 ], [ 125, 124 ], [ 233, 128 ], [ 227, 129 ], [ 215, 132 ], [ 194, 135 ], [ 197, 137 ], [ 124, 138 ], [ 124, 139 ], [ 187, 141 ], [ 145, 144 ], [ 233, 148 ], [ 227, 149 ], [ 217, 151 ], [ 215, 156 ], [ 144, 158 ], [ 215, 161 ], [ 144, 162 ], [ 194, 164 ], [ 242, 169 ], [ 197, 170 ], [ 233, 171 ], [ 144, 172 ], [ 242, 176 ], [ 197, 177 ], [ 206, 179 ], [ 208, 181 ], [ 206, 182 ], [ 209, 185 ], [ 218, 185 ], [ 188, 185 ], [ 187, 188 ], [ 190, 191 ], [ 241, 197 ], [ 78, 199 ], [ 199, 200 ], [ 202, 203 ], [ 205, 206 ], [ 206, 208 ], [ 208, 209 ], [ 211, 212 ], [ 214, 215 ], [ 217, 218 ], [ 220, 221 ], [ 206, 223 ], [ 223, 224 ], [ 241, 227 ], [ 229, 230 ], [ 241, 233 ], [ 46, 235 ], [ 235, 236 ], [ 206, 238 ], [ 238, 239 ], [ 241, 242 ] ]

[ "h,w,a,b=map(int,input().split())\nN=h+w\nmod=10**9+7\nfac=[1]*(N+2)\ninv=[1]*(N+2)\nt=1\nfor i in range(1,N+2):\n t*=i\n t%=mod\n fac[i]=t\nt=pow(fac[N+1],mod-2,mod)\nfor i in range(N+1,0,-1):\n inv[i]=t\n t*=i\n t%=mod\ndef comb(n,r):\n return fac[n]*inv[n-r]*inv[r]%mod\nc=[0]\nfor i in range(h-a):\n c.append(comb(b+i,i))\nans=0\nfor i in range(h-a):\n ans+=(c[i+1]-c[i])*comb(w-b+h-i-2,w-b-1)%mod\n ans%=mod\nprint(ans)", "h,w,a,b=map(int,input().split())", "h", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "w", "a", "b", "N=h+w", "N", "h+w", "h", "w", "mod=10**9+7", "mod", "10**9+7", "10**9", "10", "9", "7", "fac=[1]*(N+2)", "fac", "[1]*(N+2)", "[1]", "1", "N+2", "N", "2", "inv=[1]*(N+2)", "inv", "[1]*(N+2)", "[1]", "1", "N+2", "N", "2", "t=1", "t", "1", "for i in range(1,N+2):\n t*=i\n t%=mod\n fac[i]=t", "i", "range(1,N+2)", "range", "1", "N+2", "N", "2", "t*=i", "t", "i", "t%=mod", "t", "mod", "fac[i]=t", "fac[i]", "fac", "i", "t", "t=pow(fac[N+1],mod-2,mod)", "t", "pow(fac[N+1],mod-2,mod)", "pow", "fac[N+1]", "fac", "N+1", "N", "1", "mod-2", "mod", "2", "mod", "for i in range(N+1,0,-1):\n inv[i]=t\n t*=i\n t%=mod", "i", "range(N+1,0,-1)", "range", "N+1", "N", "1", "0", "-1", "inv[i]=t", "inv[i]", "inv", "i", "t", "t*=i", "t", "i", "t%=mod", "t", "mod", "def comb(n,r):\n return fac[n]*inv[n-r]*inv[r]%mod", "comb", "return fac[n]*inv[n-r]*inv[r]%mod", "fac[n]*inv[n-r]*inv[r]%mod", "fac[n]*inv[n-r]*inv[r]", "fac[n]*inv[n-r]", "fac[n]", "fac", "n", "inv[n-r]", "inv", "n-r", "n", "r", "inv[r]", "inv", "r", "mod", "n", "n", "r", "r", "c=[0]", "c", "[0]", "0", "for i in range(h-a):\n c.append(comb(b+i,i))", "i", "range(h-a)", "range", "h-a", "h", "a", "c.append(comb(b+i,i))", "c.append", "c", "append", "comb(b+i,i)", "comb", "b+i", "b", "i", "i", "ans=0", "ans", "0", "for i in range(h-a):\n ans+=(c[i+1]-c[i])*comb(w-b+h-i-2,w-b-1)%mod\n ans%=mod", "i", "range(h-a)", "range", "h-a", "h", "a", "ans+=(c[i+1]-c[i])*comb(w-b+h-i-2,w-b-1)%mod", "ans", "(c[i+1]-c[i])*comb(w-b+h-i-2,w-b-1)%mod", "(c[i+1]-c[i])*comb(w-b+h-i-2,w-b-1)", "c[i+1]-c[i]", "c[i+1]", "c", "i+1", "i", "1", "c[i]", "c", "i", "comb(w-b+h-i-2,w-b-1)", "comb", "w-b+h-i-2", "w-b+h-i", "w-b+h", "w-b", "w", "b", "h", "i", "2", "w-b-1", "w-b", "w", "b", "1", "mod", "ans%=mod", "ans", "mod", "print(ans)", "print", "ans", "ans=0", "0", "ans", "t=1", "1", "t", "def comb(n,r):\n return fac[n]*inv[n-r]*inv[r]%mod", "def comb(n,r):\n return fac[n]*inv[n-r]*inv[r]%mod", "comb", "b=map(int,input().split())", "map(int,input().split())", "b", "t*=i", "i", "t", "inv=[1]*(N+2)", "[1]*(N+2)", "inv", "mod=10**9+7", "10**9+7", "mod", "ans%=mod", "mod", "ans", "t=pow(fac[N+1],mod-2,mod)", "pow(fac[N+1],mod-2,mod)", "t", "c=[0]", "[0]", "c", "ans+=(c[i+1]-c[i])*comb(w-b+h-i-2,w-b-1)%mod", "(c[i+1]-c[i])*comb(w-b+h-i-2,w-b-1)%mod", "ans", "N=h+w", "h+w", "N", "t%=mod", "mod", "t", "a,b=map(int,input().split())", "map(int,input().split())", "a", "fac=[1]*(N+2)", "[1]*(N+2)", "fac", "h,w,a,b=map(int,input().split())", "map(int,input().split())", "h", "t*=i", "i", "t", "t%=mod", "mod", "t", "w,a,b=map(int,input().split())", "map(int,input().split())", "w" ]

[ 7, 15, 13, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 13, 13, 0, 13, 2, 2, 17, 17, 17, 12, 13, 14, 2, 13, 17, 29, 17, 14, 2, 13, 17, 29, 2, 13, 13, 14, 2, 2, 13, 17, 17, 29, 2, 2, 4, 13, 13, 2, 13, 17, 17, 13, 29, 2, 2, 2, 4, 13, 13, 2, 13, 17, 17, 13, 13, 23, 13, 23, 13, 0, 13, 39, 17, 28, 13, 4, 13, 17, 2, 13, 13, 0, 13, 2, 2, 18, 13, 2, 13, 17, 13, 13, 4, 18, 13, 13, 13, 0, 13, 2, 39, 17, 2, 13, 13, 0, 18, 13, 2, 2, 13, 13, 17, 4, 13, 18, 13, 2, 2, 13, 13, 17, 2, 13, 17, 28, 13, 4, 13, 2, 2, 13, 13, 17, 17, 17, 0, 18, 13, 13, 2, 2, 18, 13, 2, 13, 17, 2, 13, 17, 13, 12, 13, 29, 2, 2, 2, 18, 13, 13, 18, 13, 13, 18, 13, 2, 13, 13, 13, 23, 13, 23, 13, 0, 13, 17, 28, 13, 4, 13, 2, 13, 13, 0, 13, 4, 13, 2, 2, 2, 2, 13, 13, 13, 13, 17, 2, 2, 13, 13, 17, 0, 13, 4, 13, 2, 2, 13, 13, 17, 13, 0, 13, 2, 13, 2, 13, 13, 4, 13, 2, 13, 13, 10, 4, 13, 10, 39, 13, 10, 4, 13, 10, 2, 13, 10, 12, 13, 10, 4, 13, 10, 2, 13, 10, 4, 13, 10, 4, 13, 10, 2, 13, 10, 17, 13, 10, 4, 13, 10, 2, 13, 10, 12, 13 ]

[ [ 252, 4 ], [ 252, 13 ], [ 252, 14 ], [ 252, 15 ], [ 264, 17 ], [ 72, 27 ], [ 72, 33 ], [ 70, 37 ], [ 265, 38 ], [ 72, 42 ], [ 70, 50 ], [ 72, 52 ], [ 265, 55 ], [ 70, 62 ], [ 72, 64 ], [ 70, 67 ], [ 265, 68 ], [ 70, 70 ], [ 72, 72 ], [ 231, 74 ], [ 79, 78 ], [ 250, 83 ], [ 235, 84 ], [ 255, 86 ], [ 232, 90 ], [ 78, 92 ], [ 78, 94 ], [ 265, 95 ], [ 232, 98 ], [ 256, 100 ], [ 237, 102 ], [ 250, 107 ], [ 235, 108 ], [ 117, 110 ], [ 238, 111 ], [ 250, 114 ], [ 235, 115 ], [ 241, 118 ], [ 232, 120 ], [ 250, 123 ], [ 235, 124 ], [ 265, 127 ], [ 131, 130 ], [ 250, 135 ], [ 235, 136 ], [ 144, 141 ], [ 238, 142 ], [ 130, 143 ], [ 238, 147 ], [ 130, 149 ], [ 130, 152 ], [ 265, 154 ], [ 232, 162 ], [ 174, 163 ], [ 238, 165 ], [ 176, 166 ], [ 238, 168 ], [ 174, 170 ], [ 176, 171 ], [ 265, 172 ], [ 174, 174 ], [ 176, 176 ], [ 258, 178 ], [ 182, 181 ], [ 235, 185 ], [ 244, 186 ], [ 261, 188 ], [ 268, 190 ], [ 250, 195 ], [ 235, 196 ], [ 253, 197 ], [ 181, 198 ], [ 250, 202 ], [ 253, 203 ], [ 228, 206 ], [ 268, 208 ], [ 253, 211 ], [ 181, 212 ], [ 181, 214 ], [ 246, 216 ], [ 259, 218 ], [ 247, 218 ], [ 262, 220 ], [ 229, 221 ], [ 247, 225 ], [ 259, 225 ], [ 265, 226 ], [ 228, 229 ], [ 231, 232 ], [ 252, 235 ], [ 237, 238 ], [ 252, 244 ], [ 246, 247 ], [ 252, 250 ], [ 252, 253 ], [ 255, 256 ], [ 258, 259 ], [ 261, 262 ], [ 264, 265 ] ]

[ "import math\nH, W, A, B = map(int,input().split())\ne = 10**9 + 7\ndef power(a,b):\n if b == 0:\n return 1\n elif b == 1:\n return a % e\n elif b%2 == 0:\n return power(a,b//2)**2 % e\n else:\n return power(a,b//2)**2*a % e\n \nM = [1]\nfor i in range(1,H+W):\n a = M[i-1]*i%e\n M.append(a)\nN= [0]*(H+W)\nN[H+W-1] = power(M[H+W-1], e-2)\nfor i in range(H+W-2, -1, -1):\n N[i] = N[i+1] * (i+1) % e\n\ndef c(a,b):\n return M[a]*N[b]*N[a-b]%e\n\nT = 0\nfor i in range(W-B):\n P = c(H+W-A-i-2,H-A-1)\n Q = c(A+i-1,i)\n T = (T + P*Q)\nprint(T%e)", "import math", "math", "H, W, A, B = map(int,input().split())", "H", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "W", "A", "B", "e = 10**9 + 7", "e", "10**9 + 7", "10**9", "10", "9", "7", "def power(a,b):\n if b == 0:\n return 1\n elif b == 1:\n return a % e\n elif b%2 == 0:\n return power(a,b//2)**2 % e\n else:\n return power(a,b//2)**2*a % e\n ", "power", "if b == 0:\n return 1\n elif b == 1:\n return a % e\n elif b%2 == 0:\n return power(a,b//2)**2 % e\n else:\n return power(a,b//2)**2*a % e\n ", "b == 0", "b", "0", "return 1", "1", "elif b == 1:\n return a % e\n ", "b == 1", "b", "1", "return a % e", "a % e", "a", "e", "elif b%2 == 0:\n return power(a,b//2)**2 % e\n ", "b%2 == 0", "b%2", "b", "2", "0", "return power(a,b//2)**2 % e", "power(a,b//2)**2 % e", "power(a,b//2)**2", "power(a,b//2)", "power", "a", "b//2", "b", "2", "2", "e", "return power(a,b//2)**2*a % e", "power(a,b//2)**2*a % e", "power(a,b//2)**2*a", "power(a,b//2)**2", "power(a,b//2)", "power", "a", "b//2", "b", "2", "2", "a", "e", "a", "a", "b", "b", "M = [1]", "M", "[1]", "1", "for i in range(1,H+W):\n a = M[i-1]*i%e\n M.append(a)", "i", "range(1,H+W)", "range", "1", "H+W", "H", "W", "a = M[i-1]*i%e", "a", "M[i-1]*i%e", "M[i-1]*i", "M[i-1]", "M", "i-1", "i", "1", "i", "e", "M.append(a)", "M.append", "M", "append", "a", "N= [0]*(H+W)", "N", "[0]*(H+W)", "[0]", "0", "H+W", "H", "W", "N[H+W-1] = power(M[H+W-1], e-2)", "N[H+W-1]", "N", "H+W-1", "H+W", "H", "W", "1", "power(M[H+W-1], e-2)", "power", "M[H+W-1]", "M", "H+W-1", "H+W", "H", "W", "1", "e-2", "e", "2", "for i in range(H+W-2, -1, -1):\n N[i] = N[i+1] * (i+1) % e", "i", "range(H+W-2, -1, -1)", "range", "H+W-2", "H+W", "H", "W", "2", "-1", "-1", "N[i] = N[i+1] * (i+1) % e", "N[i]", "N", "i", "N[i+1] * (i+1) % e", "N[i+1] * (i+1)", "N[i+1]", "N", "i+1", "i", "1", "i+1", "i", "1", "e", "def c(a,b):\n return M[a]*N[b]*N[a-b]%e", "c", "return M[a]*N[b]*N[a-b]%e", "M[a]*N[b]*N[a-b]%e", "M[a]*N[b]*N[a-b]", "M[a]*N[b]", "M[a]", "M", "a", "N[b]", "N", "b", "N[a-b]", "N", "a-b", "a", "b", "e", "a", "a", "b", "b", "T = 0", "T", "0", "for i in range(W-B):\n P = c(H+W-A-i-2,H-A-1)\n Q = c(A+i-1,i)\n T = (T + P*Q)", "i", "range(W-B)", "range", "W-B", "W", "B", "P = c(H+W-A-i-2,H-A-1)", "P", "c(H+W-A-i-2,H-A-1)", "c", "H+W-A-i-2", "H+W-A-i", "H+W-A", "H+W", "H", "W", "A", "i", "2", "H-A-1", "H-A", "H", "A", "1", "Q = c(A+i-1,i)", "Q", "c(A+i-1,i)", "c", "A+i-1", "A+i", "A", "i", "1", "i", "T = (T + P*Q)", "T", "T + P*Q", "T", "P*Q", "P", "Q", "print(T%e)", "print", "T%e", "T", "e", "Q = c(A+i-1,i)", "c(A+i-1,i)", "Q", "M = [1]", "[1]", "M", "W, A, B = map(int,input().split())", "map(int,input().split())", "W", "N= [0]*(H+W)", "[0]*(H+W)", "N", "def power(a,b):\n if b == 0:\n return 1\n elif b == 1:\n return a % e\n elif b%2 == 0:\n return power(a,b//2)**2 % e\n else:\n return power(a,b//2)**2*a % e\n ", "def power(a,b):\n if b == 0:\n return 1\n elif b == 1:\n return a % e\n elif b%2 == 0:\n return power(a,b//2)**2 % e\n else:\n return power(a,b//2)**2*a % e\n ", "power", "B = map(int,input().split())", "map(int,input().split())", "B", "T = (T + P*Q)", "T + P*Q", "T", "H, W, A, B = map(int,input().split())", "map(int,input().split())", "H", "A, B = map(int,input().split())", "map(int,input().split())", "A", "a = M[i-1]*i%e", "M[i-1]*i%e", "a", "T = 0", "0", "T", "P = c(H+W-A-i-2,H-A-1)", "c(H+W-A-i-2,H-A-1)", "P", "e = 10**9 + 7", "10**9 + 7", "e", "def c(a,b):\n return M[a]*N[b]*N[a-b]%e", "def c(a,b):\n return M[a]*N[b]*N[a-b]%e", "c" ]

[ 7, 0, 13, 2, 2, 17, 17, 17, 0, 13, 12, 4, 13, 13, 2, 13, 17, 13, 23, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 13, 13, 0, 13, 17, 0, 13, 17, 28, 13, 4, 13, 2, 13, 17, 28, 13, 4, 13, 17, 2, 13, 13, 4, 13, 2, 13, 13, 10, 2, 13, 10, 4, 13, 10, 17, 13, 10, 4, 13, 10, 17, 13, 10, 4, 13, 10, 4, 13, 10, 12, 13 ]

[ [ 59, 2 ], [ 80, 9 ], [ 60, 15 ], [ 60, 17 ], [ 77, 20 ], [ 77, 29 ], [ 77, 30 ], [ 77, 31 ], [ 71, 33 ], [ 71, 36 ], [ 40, 39 ], [ 69, 43 ], [ 47, 46 ], [ 69, 51 ], [ 63, 52 ], [ 66, 56 ], [ 60, 57 ], [ 59, 60 ], [ 77, 63 ], [ 71, 66 ], [ 77, 69 ], [ 71, 72 ], [ 77, 75 ], [ 77, 78 ], [ 80, 81 ] ]

[ "M=10**9+7;F=lambda X:pow(X,M-2,M);H,W,A,B=map(int,input().split());Z=C=1\nfor I in range(H-1):Z=C=C*(W+H-B-2-I)*F(I+1)%M\nfor I in range(1,H-A):C=C*(B-1+I)*(H-I)*F(I*(W+H-B-1-I))%M;Z+=C\nprint(Z%M)", "M=10**9+7", "M", "10**9+7", "10**9", "10", "9", "7", "F=lambda X:pow(X,M-2,M)", "F", "lambda X:pow(X,M-2,M)", "pow(X,M-2,M)", "pow", "X", "M-2", "M", "2", "M", "X", "H,W,A,B=map(int,input().split())", "H", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "W", "A", "B", "Z=C=1", "Z", "1", "=C=1", "C", "1", "for I in range(H-1):Z=C=C*(W+H-B-2-I)*F(I+1)%M", "I", "range(H-1)", "range", "H-1", "H", "1", "for I in range(1,H-A):C=C*(B-1+I)*(H-I)*F(I*(W+H-B-1-I))%M;Z+=C", "I", "range(1,H-A)", "range", "1", "H-A", "H", "A", "print(Z%M)", "print", "Z%M", "Z", "M", "M=10**9+7", "10**9+7", "M", "A,B=map(int,input().split())", "map(int,input().split())", "A", "Z=C=1", "1", "Z", "H,W,A,B=map(int,input().split())", "map(int,input().split())", "H", "C=1", "1", "C", "W,A,B=map(int,input().split())", "map(int,input().split())", "W", "B=map(int,input().split())", "map(int,input().split())", "B", "F=lambda X:pow(X,M-2,M)", "lambda X:pow(X,M-2,M)", "F" ]

[ 7, 0, 13, 4, 13, 4, 13, 0, 13, 4, 13, 4, 13, 4, 13, 13, 4, 18, 4, 13, 13, 4, 13, 4, 13, 13, 10, 4, 13, 10, 4, 13 ]

[ [ 27, 2 ], [ 30, 8 ], [ 27, 28 ], [ 30, 31 ] ]

[ "N = int(input())\nL = sorted(list(map(int,input().split())))\nprint(sum(i for i in L[::2]))", "N = int(input())", "N", "int(input())", "int", "input()", "input", "L = sorted(list(map(int,input().split())))", "L", "sorted(list(map(int,input().split())))", "sorted", "list(map(int,input().split()))", "list", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "print(sum(i for i in L[::2]))", "print", "sum(i for i in L[::2])", "sum", "i", "N = int(input())", "int(input())", "N", "L = sorted(list(map(int,input().split())))", "sorted(list(map(int,input().split())))", "L" ]

[ 7, 15, 13, 12, 13, 29, 4, 18, 4, 18, 18, 13, 13, 13, 13, 0, 13, 4, 13, 4, 13, 0, 13, 4, 13, 4, 13, 4, 13, 13, 4, 18, 4, 13, 13, 0, 13, 17, 28, 13, 4, 13, 17, 2, 17, 13, 17, 0, 13, 18, 13, 13, 4, 13, 13, 10, 4, 13, 10, 17, 13, 10, 4, 13, 10, 18, 13, 10, 12, 13 ]

[ [ 56, 16 ], [ 69, 20 ], [ 62, 22 ], [ 69, 33 ], [ 59, 36 ], [ 40, 39 ], [ 57, 45 ], [ 65, 48 ], [ 63, 50 ], [ 39, 51 ], [ 66, 54 ], [ 60, 54 ], [ 56, 57 ], [ 59, 60 ], [ 62, 63 ], [ 65, 66 ] ]

[ "import sys\ndef input():\n return sys.stdin.readline().rstrip()\n\nN=int(input())\nL=sorted(list(map(int,input().split())))\n\nans=0\nfor i in range(0,2*N,2):\n ans+=L[i]\n\nprint(ans)", "import sys", "sys", "def input():\n return sys.stdin.readline().rstrip()", "input", "return sys.stdin.readline().rstrip()", "sys.stdin.readline().rstrip()", "sys.stdin.readline().rstrip", "sys.stdin.readline()", "sys.stdin.readline", "sys.stdin", "sys", "stdin", "readline", "rstrip", "N=int(input())", "N", "int(input())", "int", "input()", "input", "L=sorted(list(map(int,input().split())))", "L", "sorted(list(map(int,input().split())))", "sorted", "list(map(int,input().split()))", "list", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "ans=0", "ans", "0", "for i in range(0,2*N,2):\n ans+=L[i]", "i", "range(0,2*N,2)", "range", "0", "2*N", "2", "N", "2", "ans+=L[i]", "ans", "L[i]", "L", "i", "print(ans)", "print", "ans", "N=int(input())", "int(input())", "N", "ans=0", "0", "ans", "L=sorted(list(map(int,input().split())))", "sorted(list(map(int,input().split())))", "L", "ans+=L[i]", "L[i]", "ans", "def input():\n return sys.stdin.readline().rstrip()", "def input():\n return sys.stdin.readline().rstrip()", "input" ]

[ 7, 15, 13, 0, 13, 4, 13, 4, 13, 41, 28, 13, 4, 18, 4, 13, 13, 4, 4, 13, 13, 0, 13, 4, 13, 13, 0, 13, 4, 18, 13, 13, 13, 4, 13, 4, 18, 13, 13, 18, 13, 4, 18, 13, 13, 17, 2, 17, 13, 17, 10, 4, 13, 10, 4, 13, 10, 4, 13 ]

[ [ 51, 4 ], [ 12, 11 ], [ 11, 20 ], [ 54, 22 ], [ 57, 27 ], [ 55, 32 ], [ 58, 40 ], [ 55, 40 ], [ 52, 48 ], [ 51, 52 ], [ 54, 55 ], [ 57, 58 ] ]

[ "import numpy as np\nn = int(input())\nl = sorted([int(i) for i in input().split()])\nl = np.array(l)\nprint(np.sum(l[np.arange(0,2*n,2)]))", "import numpy as np", "numpy", "n = int(input())", "n", "int(input())", "int", "input()", "input", "int(i) for i in input().split()", "for i in input().split()", "i", "input().split()", "().split", "()", "input", "split", "for i in input().split()", "int(i)", "int", "i", "l = sorted([int(i) for i in input().split()])", "l", "sorted([int(i) for i in input().split()])", "sorted", "[int(i) for i in input().split()]", "l = np.array(l)", "l", "np.array(l)", "np.array", "np", "array", "l", "print(np.sum(l[np.arange(0,2*n,2)]))", "print", "np.sum(l[np.arange(0,2*n,2)])", "np.sum", "np", "sum", "l[np.arange(0,2*n,2)]", "l", "np.arange(0,2*n,2)", "np.arange", "np", "arange", "0", "2*n", "2", "n", "2", "n = int(input())", "int(input())", "n", "l = sorted([int(i) for i in input().split()])", "sorted([int(i) for i in input().split()])", "l", "l = np.array(l)", "np.array(l)", "l" ]

[ 7, 0, 13, 4, 13, 0, 13, 4, 13, 4, 13, 4, 13, 13, 4, 18, 4, 13, 13, 0, 13, 17, 28, 13, 4, 13, 17, 4, 13, 13, 17, 0, 13, 18, 13, 13, 4, 13, 13, 10, 17, 13, 10, 18, 13, 10, 4, 13, 10, 4, 13 ]

[ [ 49, 2 ], [ 46, 6 ], [ 40, 20 ], [ 24, 23 ], [ 47, 29 ], [ 43, 32 ], [ 47, 34 ], [ 23, 35 ], [ 44, 38 ], [ 41, 38 ], [ 40, 41 ], [ 43, 44 ], [ 46, 47 ], [ 49, 50 ] ]

[ "n = input()\na = sorted(list(map(int, input().split())))\nans = 0\nfor i in range(0, len(a), 2):\n ans += a[i]\nprint(ans)", "n = input()", "n", "input()", "input", "a = sorted(list(map(int, input().split())))", "a", "sorted(list(map(int, input().split())))", "sorted", "list(map(int, input().split()))", "list", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "ans = 0", "ans", "0", "for i in range(0, len(a), 2):\n ans += a[i]", "i", "range(0, len(a), 2)", "range", "0", "len(a)", "len", "a", "2", "ans += a[i]", "ans", "a[i]", "a", "i", "print(ans)", "print", "ans", "ans = 0", "0", "ans", "ans += a[i]", "a[i]", "ans", "a = sorted(list(map(int, input().split())))", "sorted(list(map(int, input().split())))", "a", "n = input()", "input()", "n" ]

[ 7, 0, 13, 4, 13, 4, 13, 0, 13, 4, 13, 4, 13, 13, 4, 18, 4, 13, 13, 4, 18, 13, 13, 0, 13, 17, 0, 13, 17, 28, 13, 4, 13, 17, 2, 17, 13, 17, 0, 13, 18, 13, 13, 4, 13, 13, 10, 4, 13, 10, 18, 13, 10, 4, 13, 10, 17, 13 ]

[ [ 53, 2 ], [ 47, 8 ], [ 48, 21 ], [ 25, 24 ], [ 56, 27 ], [ 31, 30 ], [ 54, 36 ], [ 50, 39 ], [ 48, 41 ], [ 30, 42 ], [ 51, 45 ], [ 57, 45 ], [ 47, 48 ], [ 50, 51 ], [ 53, 54 ], [ 56, 57 ] ]

[ "N=int(input())\nL=list(map(int,input().split()))\nL.sort(reverse=True)\nans=0\nfor i in range(1,2*N,2):\n ans+=L[i]\nprint(ans)\n", "N=int(input())", "N", "int(input())", "int", "input()", "input", "L=list(map(int,input().split()))", "L", "list(map(int,input().split()))", "list", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "L.sort(reverse=True)", "L.sort", "L", "sort", "reverse=True", "reverse", "True", "ans=0", "ans", "0", "for i in range(1,2*N,2):\n ans+=L[i]", "i", "range(1,2*N,2)", "range", "1", "2*N", "2", "N", "2", "ans+=L[i]", "ans", "L[i]", "L", "i", "print(ans)", "print", "ans", "L=list(map(int,input().split()))", "list(map(int,input().split()))", "L", "ans+=L[i]", "L[i]", "ans", "N=int(input())", "int(input())", "N", "ans=0", "0", "ans" ]

[ 7, 0, 13, 4, 13, 4, 13, 0, 13, 4, 13, 4, 13, 13, 4, 18, 4, 13, 13, 4, 18, 13, 13, 0, 13, 17, 28, 13, 4, 13, 2, 17, 13, 14, 2, 2, 13, 17, 17, 0, 13, 18, 13, 13, 4, 13, 13, 10, 4, 13, 10, 17, 13, 10, 4, 13, 10, 18, 13 ]

[ [ 48, 2 ], [ 54, 8 ], [ 55, 21 ], [ 51, 24 ], [ 28, 27 ], [ 49, 32 ], [ 27, 36 ], [ 57, 40 ], [ 55, 42 ], [ 27, 43 ], [ 58, 46 ], [ 52, 46 ], [ 48, 49 ], [ 51, 52 ], [ 54, 55 ], [ 57, 58 ] ]

[ "n=int(input())\na=list(map(int,input().split()))\na.sort()\nans = 0\nfor i in range(2*n):\n if i%2==0:\n ans += a[i]\nprint(ans)", "n=int(input())", "n", "int(input())", "int", "input()", "input", "a=list(map(int,input().split()))", "a", "list(map(int,input().split()))", "list", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "a.sort()", "a.sort", "a", "sort", "ans = 0", "ans", "0", "for i in range(2*n):\n if i%2==0:\n ans += a[i]", "i", "range(2*n)", "range", "2*n", "2", "n", "if i%2==0:\n ans += a[i]", "i%2==0", "i%2", "i", "2", "0", "ans += a[i]", "ans", "a[i]", "a", "i", "print(ans)", "print", "ans", "n=int(input())", "int(input())", "n", "ans = 0", "0", "ans", "a=list(map(int,input().split()))", "list(map(int,input().split()))", "a", "ans += a[i]", "a[i]", "ans" ]

[ 7, 15, 13, 13, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 12, 13, 12, 13, 12, 13, 12, 13, 41, 28, 13, 4, 13, 13, 4, 4, 13, 12, 13, 23, 13, 4, 18, 13, 13, 2, 17, 17, 0, 13, 4, 13, 17, 0, 13, 2, 2, 17, 17, 17, 15, 0, 13, 4, 13, 0, 13, 4, 13, 4, 18, 13, 13, 4, 13, 4, 13, 18, 13, 39, 17, 10, 4, 13, 10, 12, 13, 10, 12, 13, 10, 4, 13, 10, 12, 13, 10, 2, 13, 10, 12, 13, 10, 4, 13, 10, 12, 13 ]

[ [ 26, 25 ], [ 84, 31 ], [ 35, 35 ], [ 86, 44 ], [ 92, 49 ], [ 98, 57 ], [ 81, 59 ], [ 77, 61 ], [ 102, 63 ], [ 78, 66 ], [ 78, 73 ], [ 77, 78 ], [ 86, 87 ], [ 92, 93 ], [ 98, 99 ] ]

[ "import sys, re\nfrom collections import deque, defaultdict, Counter\nfrom math import ceil, sqrt, hypot, factorial, pi, sin, cos, tan, asin, acos, atan, radians, degrees#, log2, log\nfrom itertools import accumulate, permutations, combinations, combinations_with_replacement, product, groupby\nfrom operator import itemgetter, mul\nfrom copy import deepcopy\nfrom string import ascii_lowercase, ascii_uppercase, digits\nfrom bisect import bisect, bisect_left, insort, insort_left\nfrom fractions import gcd\nfrom heapq import heappush, heappop\nfrom functools import reduce\nfrom decimal import Decimal\ndef input(): return sys.stdin.readline().strip()\ndef INT(): return int(input())\ndef MAP(): return map(int, input().split())\ndef LIST(): return list(map(int, input().split()))\ndef ZIP(n): return zip(*(MAP() for _ in range(n)))\nsys.setrecursionlimit(10 ** 9)\nINF = float('inf')\nmod = 10**9 + 7\nfrom decimal import *\n\nN = INT()\nL = LIST()\n\nL.sort()\n\nprint(sum(L[::2]))", "import sys, re", "sys", "re", "from collections import deque, defaultdict, Counter", "from math import ceil, sqrt, hypot, factorial, pi, sin, cos, tan, asin, acos, atan, radians, degrees", "from itertools import accumulate, permutations, combinations, combinations_with_replacement, product, groupby", "from operator import itemgetter, mul", "from copy import deepcopy", "from string import ascii_lowercase, ascii_uppercase, digits", "from bisect import bisect, bisect_left, insort, insort_left", "from fractions import gcd", "from heapq import heappush, heappop", "from functools import reduce", "from decimal import Decimal", "def input(): return sys.stdin.readline().strip()", "input", "def INT(): return int(input())", "INT", "def MAP(): return map(int, input().split())", "MAP", "def LIST(): return list(map(int, input().split()))", "LIST", "MAP() for _ in range(n)", "for _ in range(n)", "_", "range(n)", "range", "n", "for _ in range(n)", "MAP()", "MAP", "def ZIP(n): return zip(*(MAP() for _ in range(n)))", "ZIP", "n", "n", "sys.setrecursionlimit(10 ** 9)", "sys.setrecursionlimit", "sys", "setrecursionlimit", "10 ** 9", "10", "9", "INF = float('inf')", "INF", "float('inf')", "float", "'inf'", "mod = 10**9 + 7", "mod", "10**9 + 7", "10**9", "10", "9", "7", "from decimal import *", "N = INT()", "N", "INT()", "INT", "L = LIST()", "L", "LIST()", "LIST", "L.sort()", "L.sort", "L", "sort", "print(sum(L[::2]))", "print", "sum(L[::2])", "sum", "L[::2]", "L", "::2", "2", "L = LIST()", "LIST()", "L", "def INT(): return int(input())", "def INT(): return int(input())", "INT", "def MAP(): return map(int, input().split())", "def MAP(): return map(int, input().split())", "MAP", "INF = float('inf')", "float('inf')", "INF", "def input(): return sys.stdin.readline().strip()", "def input(): return sys.stdin.readline().strip()", "input", "mod = 10**9 + 7", "10**9 + 7", "mod", "def ZIP(n): return zip(*(MAP() for _ in range(n)))", "def ZIP(n): return zip(*(MAP() for _ in range(n)))", "ZIP", "N = INT()", "INT()", "N", "def LIST(): return list(map(int, input().split()))", "def LIST(): return list(map(int, input().split()))", "LIST" ]

[ 7, 0, 13, 4, 13, 4, 13, 0, 13, 4, 13, 4, 13, 13, 4, 18, 4, 13, 13, 0, 13, 4, 13, 13, 0, 13, 17, 0, 13, 17, 28, 13, 4, 13, 17, 4, 13, 13, 17, 0, 13, 4, 13, 18, 13, 13, 18, 13, 2, 13, 17, 4, 13, 13, 10, 4, 13, 10, 4, 13, 10, 17, 13, 10, 4, 13, 10, 4, 13 ]

[ [ 67, 2 ], [ 55, 8 ], [ 64, 20 ], [ 56, 23 ], [ 26, 25 ], [ 61, 28 ], [ 32, 31 ], [ 65, 37 ], [ 56, 37 ], [ 58, 40 ], [ 65, 44 ], [ 56, 44 ], [ 31, 45 ], [ 65, 47 ], [ 56, 47 ], [ 31, 49 ], [ 59, 53 ], [ 62, 53 ], [ 55, 56 ], [ 58, 59 ], [ 61, 62 ], [ 64, 65 ], [ 67, 68 ] ]

[ "a = int(input())\nb = list(map(int, input().split()))\nb = sorted(b, reverse=True)\nc = 0\nfor i in range(1, len(b), 2):\n c += min(b[i], b[i-1])\nprint(c)", "a = int(input())", "a", "int(input())", "int", "input()", "input", "b = list(map(int, input().split()))", "b", "list(map(int, input().split()))", "list", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "b = sorted(b, reverse=True)", "b", "sorted(b, reverse=True)", "sorted", "b", "reverse=True", "reverse", "True", "c = 0", "c", "0", "for i in range(1, len(b), 2):\n c += min(b[i], b[i-1])", "i", "range(1, len(b), 2)", "range", "1", "len(b)", "len", "b", "2", "c += min(b[i], b[i-1])", "c", "min(b[i], b[i-1])", "min", "b[i]", "b", "i", "b[i-1]", "b", "i-1", "i", "1", "print(c)", "print", "c", "b = list(map(int, input().split()))", "list(map(int, input().split()))", "b", "c += min(b[i], b[i-1])", "min(b[i], b[i-1])", "c", "c = 0", "0", "c", "b = sorted(b, reverse=True)", "sorted(b, reverse=True)", "b", "a = int(input())", "int(input())", "a" ]

[ 7, 15, 13, 0, 13, 18, 18, 13, 13, 13, 0, 13, 4, 13, 4, 13, 0, 13, 4, 13, 4, 13, 13, 4, 18, 4, 13, 13, 4, 18, 13, 13, 0, 13, 17, 28, 13, 4, 13, 17, 2, 17, 13, 17, 0, 13, 4, 13, 18, 13, 13, 18, 13, 2, 13, 17, 4, 13, 13, 10, 4, 13, 10, 4, 13, 10, 18, 13, 10, 17, 13, 10, 4, 13 ]

[ [ 66, 4 ], [ 63, 11 ], [ 67, 15 ], [ 60, 17 ], [ 67, 26 ], [ 61, 30 ], [ 69, 33 ], [ 37, 36 ], [ 64, 42 ], [ 72, 45 ], [ 61, 49 ], [ 36, 50 ], [ 61, 52 ], [ 36, 54 ], [ 73, 58 ], [ 70, 58 ], [ 60, 61 ], [ 63, 64 ], [ 66, 67 ], [ 69, 70 ], [ 72, 73 ] ]

[ "import sys\ninput=sys.stdin.readline\n\nN = int(input())\nL = list(map(int, input().split()))\n\nL.sort()\nans = 0\nfor i in range(0, 2*N, 2):\n ans += min(L[i],L[i+1])\nprint(ans)", "import sys", "sys", "input=sys.stdin.readline", "input", "sys.stdin.readline", "sys.stdin", "sys", "stdin", "readline", "N = int(input())", "N", "int(input())", "int", "input()", "input", "L = list(map(int, input().split()))", "L", "list(map(int, input().split()))", "list", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "L.sort()", "L.sort", "L", "sort", "ans = 0", "ans", "0", "for i in range(0, 2*N, 2):\n ans += min(L[i],L[i+1])", "i", "range(0, 2*N, 2)", "range", "0", "2*N", "2", "N", "2", "ans += min(L[i],L[i+1])", "ans", "min(L[i],L[i+1])", "min", "L[i]", "L", "i", "L[i+1]", "L", "i+1", "i", "1", "print(ans)", "print", "ans", "L = list(map(int, input().split()))", "list(map(int, input().split()))", "L", "N = int(input())", "int(input())", "N", "input=sys.stdin.readline", "sys.stdin.readline", "input", "ans = 0", "0", "ans", "ans += min(L[i],L[i+1])", "min(L[i],L[i+1])", "ans" ]

[ 7, 0, 13, 4, 13, 4, 13, 0, 13, 4, 13, 4, 13, 13, 4, 18, 4, 13, 13, 0, 13, 4, 13, 13, 0, 13, 17, 13, 39, 28, 13, 4, 13, 17, 2, 17, 13, 17, 0, 13, 4, 13, 18, 13, 13, 18, 13, 2, 13, 17, 4, 13, 13, 10, 4, 13, 10, 39, 13, 10, 4, 13, 10, 4, 13, 10, 4, 13, 10, 17, 13 ]

[ [ 63, 2 ], [ 66, 8 ], [ 60, 20 ], [ 67, 23 ], [ 69, 25 ], [ 57, 27 ], [ 31, 30 ], [ 64, 36 ], [ 54, 39 ], [ 61, 43 ], [ 67, 43 ], [ 30, 44 ], [ 61, 46 ], [ 67, 46 ], [ 30, 48 ], [ 55, 52 ], [ 70, 52 ], [ 54, 55 ], [ 57, 58 ], [ 60, 61 ], [ 63, 64 ], [ 66, 67 ], [ 69, 70 ] ]

[ "n = int(input())\ns = list(map(int, input().split()))\ns = sorted(s)\nc, f = 0, []\nfor i in range(0, 2*n, 2):\n c+=min(s[i], s[i+1])\n # print(min(s[i], s[i+1]))\nprint(c)", "n = int(input())", "n", "int(input())", "int", "input()", "input", "s = list(map(int, input().split()))", "s", "list(map(int, input().split()))", "list", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "s = sorted(s)", "s", "sorted(s)", "sorted", "s", "c, f = 0, []", "c", "0", "f", "[]", "for i in range(0, 2*n, 2):\n c+=min(s[i], s[i+1])\n # print(min(s[i], s[i+1]))", "i", "range(0, 2*n, 2)", "range", "0", "2*n", "2", "n", "2", "c+=min(s[i], s[i+1])", "c", "min(s[i], s[i+1])", "min", "s[i]", "s", "i", "s[i+1]", "s", "i+1", "i", "1", "print(c)", "print", "c", "c+=min(s[i], s[i+1])", "min(s[i], s[i+1])", "c", "f = 0, []", "[]", "f", "s = sorted(s)", "sorted(s)", "s", "n = int(input())", "int(input())", "n", "s = list(map(int, input().split()))", "list(map(int, input().split()))", "s", "c, f = 0, []", "0", "c" ]

[ 7, 0, 13, 4, 13, 4, 13, 0, 13, 4, 13, 4, 13, 13, 4, 18, 4, 13, 13, 4, 18, 13, 13, 0, 13, 17, 28, 13, 18, 13, 39, 17, 0, 13, 13, 4, 13, 13, 10, 17, 13, 10, 4, 13, 10, 4, 13, 10, 13, 13 ]

[ [ 42, 2 ], [ 45, 8 ], [ 46, 21 ], [ 39, 24 ], [ 28, 27 ], [ 46, 29 ], [ 48, 33 ], [ 27, 34 ], [ 49, 37 ], [ 40, 37 ], [ 39, 40 ], [ 42, 43 ], [ 45, 46 ], [ 27, 48 ], [ 48, 49 ] ]

[ "N = int(input())\nL = list(map(int, input().split()))\n\nL.sort()\n\nans = 0\nfor x in L[::2]:\n ans += x\n\nprint(ans)", "N = int(input())", "N", "int(input())", "int", "input()", "input", "L = list(map(int, input().split()))", "L", "list(map(int, input().split()))", "list", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "L.sort()", "L.sort", "L", "sort", "ans = 0", "ans", "0", "for x in L[::2]:\n ans += x", "x", "L[::2]", "L", "::2", "2", "ans += x", "ans", "x", "print(ans)", "print", "ans", "ans = 0", "0", "ans", "N = int(input())", "int(input())", "N", "L = list(map(int, input().split()))", "list(map(int, input().split()))", "L", "ans += x", "x", "ans" ]

[ 7, 0, 13, 4, 13, 4, 13, 41, 28, 13, 4, 18, 4, 13, 13, 4, 4, 13, 13, 0, 13, 13, 12, 13, 0, 13, 4, 13, 13, 41, 28, 13, 13, 4, 13, 13, 2, 2, 13, 17, 17, 4, 13, 0, 13, 13, 29, 4, 13, 13, 23, 13, 23, 13, 4, 13, 4, 13, 13, 13, 10, 4, 13, 10, 13, 13, 10, 12, 13 ]

[ [ 61, 2 ], [ 10, 9 ], [ 9, 18 ], [ 64, 20 ], [ 26, 25 ], [ 53, 28 ], [ 25, 35 ], [ 53, 35 ], [ 45, 44 ], [ 44, 49 ], [ 25, 49 ], [ 53, 49 ], [ 51, 51 ], [ 53, 53 ], [ 68, 57 ], [ 62, 58 ], [ 65, 59 ], [ 61, 62 ], [ 64, 65 ] ]

[ "n = int(input())\nli = [int(x) for x in input().split()]\n\ndef skews(n,li):\n \n li = sorted(li)\n li = [l for i,l in enumerate(li) if i%2==0] \n return sum(li)\n\n\nprint(skews(n,li))", "n = int(input())", "n", "int(input())", "int", "input()", "input", "int(x) for x in input().split()", "for x in input().split()", "x", "input().split()", "().split", "()", "input", "split", "for x in input().split()", "int(x)", "int", "x", "li = [int(x) for x in input().split()]", "li", "[int(x) for x in input().split()]", "def skews(n,li):\n \n li = sorted(li)\n li = [l for i,l in enumerate(li) if i%2==0] \n return sum(li)", "skews", "li = sorted(li)", "li", "sorted(li)", "sorted", "li", "l for i,l in enumerate(li) if i%2==0", "for i,l in enumerate(li) if i%2==0", "i", "l", "enumerate(li)", "enumerate", "li", "i%2==0", "i%2", "i", "2", "0", "if i%2==0", "l", "li = [l for i,l in enumerate(li) if i%2==0]", "li", "[l for i,l in enumerate(li) if i%2==0]", "return sum(li)", "sum(li)", "sum", "li", "n", "n", "li", "li", "print(skews(n,li))", "print", "skews(n,li)", "skews", "n", "li", "n = int(input())", "int(input())", "n", "li = [int(x) for x in input().split()]", "[int(x) for x in input().split()]", "li", "def skews(n,li):\n \n li = sorted(li)\n li = [l for i,l in enumerate(li) if i%2==0] \n return sum(li)", "def skews(n,li):\n \n li = sorted(li)\n li = [l for i,l in enumerate(li) if i%2==0] \n return sum(li)", "skews" ]

[ 7, 0, 13, 4, 13, 4, 13, 4, 13, 18, 4, 13, 4, 13, 4, 13, 13, 4, 18, 4, 13, 13, 39, 17, 10, 4, 13 ]

[ [ 25, 2 ], [ 25, 26 ] ]

[ "N=input();print(sum(sorted(list(map(int,input().split())))[::2]))", "N=input()", "N", "input()", "input", "print(sum(sorted(list(map(int,input().split())))[::2]))", "print", "sum(sorted(list(map(int,input().split())))[::2])", "sum", "sorted(list(map(int,input().split())))[::2]", "(list(map(int,input().split())))", "sorted", "list(map(int,input().split()))", "list", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "::2", "2", "N=input()", "input()", "N" ]

[ 7, 0, 13, 4, 13, 4, 13, 0, 13, 17, 0, 13, 4, 13, 4, 13, 13, 4, 18, 4, 13, 13, 4, 18, 13, 13, 0, 13, 17, 28, 13, 4, 13, 17, 2, 13, 17, 17, 0, 13, 4, 13, 18, 13, 13, 18, 13, 2, 13, 17, 4, 13, 13, 10, 4, 13, 10, 4, 13, 10, 17, 13, 10, 4, 13, 10, 17, 13 ]

[ [ 54, 2 ], [ 66, 8 ], [ 57, 11 ], [ 58, 24 ], [ 60, 27 ], [ 31, 30 ], [ 67, 35 ], [ 55, 35 ], [ 63, 39 ], [ 58, 43 ], [ 30, 44 ], [ 58, 46 ], [ 30, 48 ], [ 64, 52 ], [ 61, 52 ], [ 54, 55 ], [ 57, 58 ], [ 60, 61 ], [ 63, 64 ], [ 66, 67 ] ]

[ "num = int(input())\nnum *= 2\nSkewers = list(map(int, input().split()))\n \nSkewers.sort()\nval = 0\nfor i in range(0, num-1, 2):\n val += min(Skewers[i], Skewers[i + 1])\n \n \nprint(val)", "num = int(input())", "num", "int(input())", "int", "input()", "input", "num *= 2", "num", "2", "Skewers = list(map(int, input().split()))", "Skewers", "list(map(int, input().split()))", "list", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "Skewers.sort()", "Skewers.sort", "Skewers", "sort", "val = 0", "val", "0", "for i in range(0, num-1, 2):\n val += min(Skewers[i], Skewers[i + 1])\n \n ", "i", "range(0, num-1, 2)", "range", "0", "num-1", "num", "1", "2", "val += min(Skewers[i], Skewers[i + 1])", "val", "min(Skewers[i], Skewers[i + 1])", "min", "Skewers[i]", "Skewers", "i", "Skewers[i + 1]", "Skewers", "i + 1", "i", "1", "print(val)", "print", "val", "num = int(input())", "int(input())", "num", "Skewers = list(map(int, input().split()))", "list(map(int, input().split()))", "Skewers", "val = 0", "0", "val", "val += min(Skewers[i], Skewers[i + 1])", "min(Skewers[i], Skewers[i + 1])", "val", "num *= 2", "2", "num" ]

[ 7, 15, 13, 15, 13, 15, 13, 15, 13, 15, 13, 15, 13, 15, 13, 15, 13, 15, 13, 15, 15, 15, 15, 15, 15, 15, 13, 14, 4, 18, 13, 13, 17, 0, 18, 13, 13, 4, 13, 17, 17, 4, 18, 13, 13, 17, 0, 13, 4, 13, 17, 0, 13, 2, 17, 17, 0, 13, 2, 2, 17, 17, 17, 0, 13, 4, 13, 4, 18, 18, 13, 13, 13, 0, 13, 4, 13, 4, 13, 13, 4, 18, 4, 18, 18, 13, 13, 13, 13, 4, 18, 13, 13, 0, 13, 4, 13, 18, 13, 39, 17, 4, 13, 13, 10, 4, 13, 10, 2, 13, 10, 4, 13, 10, 4, 13, 10, 2, 13, 10, 4, 13 ]

[ [ 37, 34 ], [ 120, 47 ], [ 117, 52 ], [ 108, 57 ], [ 114, 64 ], [ 34, 69 ], [ 111, 74 ], [ 34, 84 ], [ 112, 91 ], [ 105, 94 ], [ 112, 98 ], [ 106, 103 ], [ 105, 106 ], [ 108, 109 ], [ 111, 112 ], [ 114, 115 ], [ 117, 118 ], [ 120, 121 ] ]

[ "import bisect\nimport heapq\nimport itertools\nimport math\nimport operator\nimport os\nimport re\nimport string\nimport sys\nfrom collections import Counter, deque, defaultdict\nfrom copy import deepcopy\nfrom decimal import Decimal\nfrom fractions import gcd\nfrom functools import lru_cache, reduce\nfrom operator import itemgetter, mul, add, xor\n\nimport numpy as np\n\nif os.getenv(\"LOCAL\"):\n sys.stdin = open(\"_in.txt\", \"r\")\n\nsys.setrecursionlimit(2147483647)\nINF = float(\"inf\")\nIINF = 10 ** 18\nMOD = 10 ** 9 + 7\n\n\n\nN = int(sys.stdin.readline())\nL = list(map(int, sys.stdin.readline().split()))\n\nL .sort()\n\na = sum(L[::2])\nprint(a)", "import bisect", "bisect", "import heapq", "heapq", "import itertools", "itertools", "import math", "math", "import operator", "operator", "import os", "os", "import re", "re", "import string", "string", "import sys", "sys", "from collections import Counter, deque, defaultdict", "from copy import deepcopy", "from decimal import Decimal", "from fractions import gcd", "from functools import lru_cache, reduce", "from operator import itemgetter, mul, add, xor", "import numpy as np", "numpy", "if os.getenv(\"LOCAL\"):\n sys.stdin = open(\"_in.txt\", \"r\")", "os.getenv(\"LOCAL\")", "os.getenv", "os", "getenv", "\"LOCAL\"", "sys.stdin = open(\"_in.txt\", \"r\")", "sys.stdin", "sys", "stdin", "open(\"_in.txt\", \"r\")", "open", "\"_in.txt\"", "\"r\"", "sys.setrecursionlimit(2147483647)", "sys.setrecursionlimit", "sys", "setrecursionlimit", "2147483647", "INF = float(\"inf\")", "INF", "float(\"inf\")", "float", "\"inf\"", "IINF = 10 ** 18", "IINF", "10 ** 18", "10", "18", "MOD = 10 ** 9 + 7", "MOD", "10 ** 9 + 7", "10 ** 9", "10", "9", "7", "N = int(sys.stdin.readline())", "N", "int(sys.stdin.readline())", "int", "sys.stdin.readline()", "sys.stdin.readline", "sys.stdin", "sys", "stdin", "readline", "L = list(map(int, sys.stdin.readline().split()))", "L", "list(map(int, sys.stdin.readline().split()))", "list", "map(int, sys.stdin.readline().split())", "map", "int", "sys.stdin.readline().split()", "sys.stdin.readline().split", "sys.stdin.readline()", "sys.stdin.readline", "sys.stdin", "sys", "stdin", "readline", "split", "L .sort()", "L .sort", "L", "sort", "a = sum(L[::2])", "a", "sum(L[::2])", "sum", "L[::2]", "L", "::2", "2", "print(a)", "print", "a", "a = sum(L[::2])", "sum(L[::2])", "a", "MOD = 10 ** 9 + 7", "10 ** 9 + 7", "MOD", "L = list(map(int, sys.stdin.readline().split()))", "list(map(int, sys.stdin.readline().split()))", "L", "N = int(sys.stdin.readline())", "int(sys.stdin.readline())", "N", "IINF = 10 ** 18", "10 ** 18", "IINF", "INF = float(\"inf\")", "float(\"inf\")", "INF" ]

[ 7, 0, 13, 4, 13, 4, 13, 0, 13, 4, 13, 4, 13, 4, 13, 13, 4, 18, 4, 13, 13, 0, 13, 17, 28, 13, 4, 13, 2, 17, 13, 14, 2, 2, 13, 17, 17, 0, 13, 18, 13, 13, 4, 13, 13, 10, 17, 13, 10, 4, 13, 10, 4, 13, 10, 18, 13 ]

[ [ 49, 2 ], [ 52, 8 ], [ 46, 22 ], [ 26, 25 ], [ 50, 30 ], [ 25, 34 ], [ 55, 38 ], [ 53, 40 ], [ 25, 41 ], [ 56, 44 ], [ 47, 44 ], [ 46, 47 ], [ 49, 50 ], [ 52, 53 ], [ 55, 56 ] ]

[ "n = int(input())\na = sorted(list(map(int, input().split())))\ns = 0\nfor i in range(2 * n):\n if i % 2 == 0:\n s += a[i]\nprint(s)", "n = int(input())", "n", "int(input())", "int", "input()", "input", "a = sorted(list(map(int, input().split())))", "a", "sorted(list(map(int, input().split())))", "sorted", "list(map(int, input().split()))", "list", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "s = 0", "s", "0", "for i in range(2 * n):\n if i % 2 == 0:\n s += a[i]", "i", "range(2 * n)", "range", "2 * n", "2", "n", "if i % 2 == 0:\n s += a[i]", "i % 2 == 0", "i % 2", "i", "2", "0", "s += a[i]", "s", "a[i]", "a", "i", "print(s)", "print", "s", "s = 0", "0", "s", "n = int(input())", "int(input())", "n", "a = sorted(list(map(int, input().split())))", "sorted(list(map(int, input().split())))", "a", "s += a[i]", "a[i]", "s" ]

[ 7, 0, 13, 4, 13, 4, 13, 0, 13, 4, 13, 4, 13, 13, 4, 18, 4, 13, 13, 0, 13, 4, 13, 18, 13, 39, 17, 4, 13, 13, 10, 4, 13, 10, 4, 13, 10, 4, 13 ]

[ [ 31, 2 ], [ 37, 8 ], [ 34, 20 ], [ 38, 24 ], [ 35, 29 ], [ 31, 32 ], [ 34, 35 ], [ 37, 38 ] ]

[ "N = int(input())\nL = sorted(map(int, input().split()))\n\nans = sum(L[::2])\n\nprint(ans)", "N = int(input())", "N", "int(input())", "int", "input()", "input", "L = sorted(map(int, input().split()))", "L", "sorted(map(int, input().split()))", "sorted", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "ans = sum(L[::2])", "ans", "sum(L[::2])", "sum", "L[::2]", "L", "::2", "2", "print(ans)", "print", "ans", "N = int(input())", "int(input())", "N", "ans = sum(L[::2])", "sum(L[::2])", "ans", "L = sorted(map(int, input().split()))", "sorted(map(int, input().split()))", "L" ]

[ 7, 12, 13, 0, 13, 4, 13, 4, 13, 0, 13, 4, 13, 4, 13, 13, 4, 18, 4, 13, 13, 4, 13, 4, 13, 18, 13, 39, 17, 14, 2, 13, 17, 4, 13, 10, 12, 13 ]

[ [ 5, 4 ], [ 11, 10 ], [ 10, 26 ], [ 37, 34 ] ]

[ "# coding: utf-8\ndef main():\n n = int(input())\n l = sorted(map(int, input().split()))\n print(sum(l[::2]))\n\n\nif __name__ == '__main__':\n main()", "def main():\n n = int(input())\n l = sorted(map(int, input().split()))\n print(sum(l[::2]))", "main", "n = int(input())", "n", "int(input())", "int", "input()", "input", "l = sorted(map(int, input().split()))", "l", "sorted(map(int, input().split()))", "sorted", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "print(sum(l[::2]))", "print", "sum(l[::2])", "sum", "l[::2]", "l", "::2", "2", "if __name__ == '__main__':\n main()", "__name__ == '__main__'", "__name__", "'__main__'", "main()", "main", "def main():\n n = int(input())\n l = sorted(map(int, input().split()))\n print(sum(l[::2]))", "def main():\n n = int(input())\n l = sorted(map(int, input().split()))\n print(sum(l[::2]))", "main" ]

[ 7, 12, 13, 0, 13, 4, 13, 4, 13, 0, 13, 4, 13, 4, 13, 13, 4, 18, 4, 13, 13, 4, 18, 13, 13, 0, 13, 4, 13, 18, 13, 39, 17, 4, 13, 13, 14, 2, 13, 17, 4, 13, 10, 12, 13 ]

[ [ 5, 4 ], [ 11, 10 ], [ 10, 23 ], [ 27, 26 ], [ 10, 30 ], [ 26, 35 ], [ 44, 41 ] ]

[ "\ndef main():\n num = int(input())\n data = list(map(int, input().split()))\n data.sort()\n ans = sum(data[::2])\n print(ans)\n\n\n\nif __name__ == '__main__':\n main()", "def main():\n num = int(input())\n data = list(map(int, input().split()))\n data.sort()\n ans = sum(data[::2])\n print(ans)", "main", "num = int(input())", "num", "int(input())", "int", "input()", "input", "data = list(map(int, input().split()))", "data", "list(map(int, input().split()))", "list", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "data.sort()", "data.sort", "data", "sort", "ans = sum(data[::2])", "ans", "sum(data[::2])", "sum", "data[::2]", "data", "::2", "2", "print(ans)", "print", "ans", "if __name__ == '__main__':\n main()", "__name__ == '__main__'", "__name__", "'__main__'", "main()", "main", "def main():\n num = int(input())\n data = list(map(int, input().split()))\n data.sort()\n ans = sum(data[::2])\n print(ans)", "def main():\n num = int(input())\n data = list(map(int, input().split()))\n data.sort()\n ans = sum(data[::2])\n print(ans)", "main" ]

[ 7, 15, 13, 0, 13, 4, 13, 4, 13, 0, 13, 4, 18, 4, 13, 13, 41, 28, 13, 13, 4, 4, 13, 13, 0, 13, 13, 4, 18, 13, 13, 13, 0, 13, 17, 28, 13, 4, 13, 13, 0, 13, 4, 18, 13, 13, 13, 0, 13, 4, 18, 13, 13, 13, 0, 13, 13, 4, 13, 13, 10, 4, 13, 10, 4, 13, 10, 4, 13, 10, 17, 13, 10, 4, 13, 10, 13, 13, 10, 13, 13 ]

[ [ 67, 4 ], [ 61, 10 ], [ 19, 18 ], [ 62, 18 ], [ 18, 23 ], [ 79, 25 ], [ 80, 31 ], [ 62, 31 ], [ 70, 33 ], [ 37, 36 ], [ 68, 39 ], [ 64, 41 ], [ 80, 46 ], [ 62, 46 ], [ 73, 48 ], [ 80, 53 ], [ 62, 53 ], [ 76, 55 ], [ 65, 56 ], [ 77, 59 ], [ 71, 59 ], [ 61, 62 ], [ 64, 65 ], [ 67, 68 ], [ 70, 71 ], [ 73, 74 ], [ 65, 76 ], [ 76, 77 ], [ 79, 80 ] ]

[ "import heapq\n\nN = int(input())\nL = input().split()\nL = [int(a) for a in L]\n\nheapq.heapify(L)\n\nsum = 0\n\nfor i in range(N):\n k1 = heapq.heappop(L)\n k2 = heapq.heappop(L)\n sum += k1\n\nprint(sum)", "import heapq", "heapq", "N = int(input())", "N", "int(input())", "int", "input()", "input", "L = input().split()", "L", "input().split()", "().split", "()", "input", "split", "int(a) for a in L", "for a in L", "a", "L", "for a in L", "int(a)", "int", "a", "L = [int(a) for a in L]", "L", "[int(a) for a in L]", "heapq.heapify(L)", "heapq.heapify", "heapq", "heapify", "L", "sum = 0", "sum", "0", "for i in range(N):\n k1 = heapq.heappop(L)\n k2 = heapq.heappop(L)\n sum += k1", "i", "range(N)", "range", "N", "k1 = heapq.heappop(L)", "k1", "heapq.heappop(L)", "heapq.heappop", "heapq", "heappop", "L", "k2 = heapq.heappop(L)", "k2", "heapq.heappop(L)", "heapq.heappop", "heapq", "heappop", "L", "sum += k1", "sum", "k1", "print(sum)", "print", "sum", "L = input().split()", "input().split()", "L", "k1 = heapq.heappop(L)", "heapq.heappop(L)", "k1", "N = int(input())", "int(input())", "N", "sum = 0", "0", "sum", "k2 = heapq.heappop(L)", "heapq.heappop(L)", "k2", "sum += k1", "k1", "sum", "L = [int(a) for a in L]", "[int(a) for a in L]", "L" ]

[ 7, 0, 13, 4, 13, 4, 13, 41, 28, 13, 4, 18, 4, 13, 13, 4, 4, 13, 13, 0, 13, 13, 4, 18, 13, 13, 0, 13, 17, 28, 13, 4, 13, 17, 2, 17, 13, 17, 0, 13, 4, 13, 18, 13, 13, 18, 13, 2, 13, 17, 4, 13, 13, 10, 4, 13, 10, 17, 13, 10, 4, 13, 10, 13, 13 ]

[ [ 60, 2 ], [ 10, 9 ], [ 9, 18 ], [ 63, 20 ], [ 64, 24 ], [ 57, 27 ], [ 31, 30 ], [ 61, 36 ], [ 54, 39 ], [ 64, 43 ], [ 30, 44 ], [ 64, 46 ], [ 30, 48 ], [ 55, 52 ], [ 58, 52 ], [ 54, 55 ], [ 57, 58 ], [ 60, 61 ], [ 63, 64 ] ]

[ "n = int(input())\nli = [int(x) for x in input().split()]\nli.sort()\nans = 0\nfor i in range(0,2*n,2):\n ans += min(li[i],li[i+1])\nprint(ans)", "n = int(input())", "n", "int(input())", "int", "input()", "input", "int(x) for x in input().split()", "for x in input().split()", "x", "input().split()", "().split", "()", "input", "split", "for x in input().split()", "int(x)", "int", "x", "li = [int(x) for x in input().split()]", "li", "[int(x) for x in input().split()]", "li.sort()", "li.sort", "li", "sort", "ans = 0", "ans", "0", "for i in range(0,2*n,2):\n ans += min(li[i],li[i+1])", "i", "range(0,2*n,2)", "range", "0", "2*n", "2", "n", "2", "ans += min(li[i],li[i+1])", "ans", "min(li[i],li[i+1])", "min", "li[i]", "li", "i", "li[i+1]", "li", "i+1", "i", "1", "print(ans)", "print", "ans", "ans += min(li[i],li[i+1])", "min(li[i],li[i+1])", "ans", "ans = 0", "0", "ans", "n = int(input())", "int(input())", "n", "li = [int(x) for x in input().split()]", "[int(x) for x in input().split()]", "li" ]

[ 7, 0, 13, 4, 13, 4, 13, 0, 13, 4, 13, 4, 13, 13, 4, 18, 4, 13, 13, 4, 18, 13, 13, 0, 13, 17, 28, 13, 4, 13, 2, 4, 13, 13, 17, 17, 17, 0, 13, 4, 13, 18, 13, 13, 18, 13, 2, 13, 17, 4, 13, 13, 10, 4, 13, 10, 4, 13, 10, 4, 13, 10, 17, 13 ]

[ [ 59, 2 ], [ 53, 8 ], [ 54, 21 ], [ 62, 24 ], [ 28, 27 ], [ 54, 33 ], [ 56, 38 ], [ 54, 42 ], [ 27, 43 ], [ 54, 45 ], [ 27, 47 ], [ 57, 51 ], [ 63, 51 ], [ 53, 54 ], [ 56, 57 ], [ 59, 60 ], [ 62, 63 ] ]

[ "a = int(input())\nb = list(map(int, input().split()))\nb.sort()\nc = 0\nfor i in range(len(b)-1, 0, -2):\n c += min(b[i], b[i-1])\nprint(c)", "a = int(input())", "a", "int(input())", "int", "input()", "input", "b = list(map(int, input().split()))", "b", "list(map(int, input().split()))", "list", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "b.sort()", "b.sort", "b", "sort", "c = 0", "c", "0", "for i in range(len(b)-1, 0, -2):\n c += min(b[i], b[i-1])", "i", "range(len(b)-1, 0, -2)", "range", "len(b)-1", "len(b)", "len", "b", "1", "0", "-2", "c += min(b[i], b[i-1])", "c", "min(b[i], b[i-1])", "min", "b[i]", "b", "i", "b[i-1]", "b", "i-1", "i", "1", "print(c)", "print", "c", "b = list(map(int, input().split()))", "list(map(int, input().split()))", "b", "c += min(b[i], b[i-1])", "min(b[i], b[i-1])", "c", "a = int(input())", "int(input())", "a", "c = 0", "0", "c" ]

[ 7, 0, 13, 4, 13, 4, 13, 0, 13, 4, 13, 4, 13, 13, 4, 18, 4, 13, 13, 0, 13, 4, 13, 13, 0, 13, 17, 28, 13, 4, 13, 4, 13, 13, 14, 2, 2, 13, 17, 17, 4, 13, 13, 10, 4, 13, 10, 4, 13, 10, 17, 13, 10, 4, 13 ]

[ [ 44, 2 ], [ 53, 8 ], [ 47, 20 ], [ 54, 23 ], [ 50, 25 ], [ 29, 28 ], [ 48, 33 ], [ 54, 33 ], [ 28, 37 ], [ 51, 42 ], [ 44, 45 ], [ 47, 48 ], [ 50, 51 ], [ 53, 54 ] ]

[ "n=int(input())\nl=list(map(int,input().split()))\nl=sorted(l)\ns=0\nfor i in range(len(l)):\n if i%2==0:s+=l[i]\nprint(s)", "n=int(input())", "n", "int(input())", "int", "input()", "input", "l=list(map(int,input().split()))", "l", "list(map(int,input().split()))", "list", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "l=sorted(l)", "l", "sorted(l)", "sorted", "l", "s=0", "s", "0", "for i in range(len(l)):\n if i%2==0:s+=l[i]", "i", "range(len(l))", "range", "len(l)", "len", "l", "if i%2==0:s+=l[", "i%2==0", "i%2", "i", "2", "0", "print(s)", "print", "s", "n=int(input())", "int(input())", "n", "l=sorted(l)", "sorted(l)", "l", "s=0", "0", "s", "l=list(map(int,input().split()))", "list(map(int,input().split()))", "l" ]

[ 7, 0, 13, 4, 13, 4, 13, 0, 13, 4, 13, 4, 13, 13, 4, 18, 4, 13, 13, 4, 18, 13, 13, 4, 13, 4, 13, 18, 13, 39, 17, 17, 10, 4, 13, 10, 4, 13 ]

[ [ 36, 2 ], [ 33, 8 ], [ 34, 21 ], [ 34, 28 ], [ 33, 34 ], [ 36, 37 ] ]

[ "N = int(input())\nL = list(map(int, input().split()))\n\nL.sort()\nprint(sum(L[0::2]))", "N = int(input())", "N", "int(input())", "int", "input()", "input", "L = list(map(int, input().split()))", "L", "list(map(int, input().split()))", "list", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "L.sort()", "L.sort", "L", "sort", "print(sum(L[0::2]))", "print", "sum(L[0::2])", "sum", "L[0::2]", "L", "0::2", "0", "2", "L = list(map(int, input().split()))", "list(map(int, input().split()))", "L", "N = int(input())", "int(input())", "N" ]

[ 7, 0, 13, 4, 13, 4, 13, 0, 13, 4, 13, 4, 13, 4, 13, 13, 4, 18, 4, 13, 13, 0, 13, 18, 13, 39, 17, 4, 13, 4, 13, 13, 10, 4, 13, 10, 18, 13, 10, 4, 13 ]

[ [ 39, 2 ], [ 33, 8 ], [ 36, 22 ], [ 34, 24 ], [ 37, 31 ], [ 33, 34 ], [ 36, 37 ], [ 39, 40 ] ]

[ "n=int(input())\nl=sorted(list(map(int, input().split())))\nll=l[::2]\nprint(sum(ll))", "n=int(input())", "n", "int(input())", "int", "input()", "input", "l=sorted(list(map(int, input().split())))", "l", "sorted(list(map(int, input().split())))", "sorted", "list(map(int, input().split()))", "list", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "ll=l[::2]", "ll", "l[::2]", "l", "::2", "2", "print(sum(ll))", "print", "sum(ll)", "sum", "ll", "l=sorted(list(map(int, input().split())))", "sorted(list(map(int, input().split())))", "l", "ll=l[::2]", "l[::2]", "ll", "n=int(input())", "int(input())", "n" ]

[ 7, 0, 13, 4, 13, 4, 13, 0, 13, 4, 13, 4, 13, 4, 13, 13, 4, 18, 4, 13, 13, 0, 13, 17, 0, 13, 17, 28, 13, 4, 13, 13, 0, 13, 18, 13, 13, 0, 13, 17, 4, 13, 13, 10, 4, 13, 10, 17, 13, 10, 4, 13, 10, 17, 13, 10, 17, 13, 10, 18, 13 ]

[ [ 50, 2 ], [ 44, 8 ], [ 56, 22 ], [ 47, 25 ], [ 29, 28 ], [ 51, 31 ], [ 59, 33 ], [ 45, 35 ], [ 57, 36 ], [ 54, 36 ], [ 53, 38 ], [ 60, 42 ], [ 48, 42 ], [ 44, 45 ], [ 47, 48 ], [ 50, 51 ], [ 53, 54 ], [ 56, 57 ], [ 59, 60 ] ]

[ "n = int(input())\nli = sorted(list(map(int,input().split())))\n\nk=0\ncount =0\nfor i in range(n):\n count += li[k]\n k += 2\n\nprint(count)", "n = int(input())", "n", "int(input())", "int", "input()", "input", "li = sorted(list(map(int,input().split())))", "li", "sorted(list(map(int,input().split())))", "sorted", "list(map(int,input().split()))", "list", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "k=0", "k", "0", "count =0", "count", "0", "for i in range(n):\n count += li[k]\n k += 2", "i", "range(n)", "range", "n", "count += li[k]", "count", "li[k]", "li", "k", "k += 2", "k", "2", "print(count)", "print", "count", "li = sorted(list(map(int,input().split())))", "sorted(list(map(int,input().split())))", "li", "count =0", "0", "count", "n = int(input())", "int(input())", "n", "k += 2", "2", "k", "k=0", "0", "k", "count += li[k]", "li[k]", "count" ]

[ 7, 0, 13, 4, 13, 4, 13, 41, 28, 13, 4, 18, 4, 13, 13, 4, 4, 13, 13, 0, 13, 13, 0, 13, 4, 13, 13, 0, 13, 17, 28, 13, 4, 13, 13, 0, 13, 18, 13, 2, 13, 17, 4, 13, 13, 10, 4, 13, 10, 13, 13, 10, 4, 13, 10, 18, 13, 10, 17, 13 ]

[ [ 46, 2 ], [ 10, 9 ], [ 9, 18 ], [ 49, 20 ], [ 52, 23 ], [ 50, 26 ], [ 58, 28 ], [ 32, 31 ], [ 47, 34 ], [ 55, 36 ], [ 53, 38 ], [ 50, 38 ], [ 31, 40 ], [ 56, 44 ], [ 59, 44 ], [ 46, 47 ], [ 49, 50 ], [ 52, 53 ], [ 55, 56 ], [ 58, 59 ] ]

[ "n=int(input())\nli=[int(i) for i in input().split()]\n\nli=sorted(li)\nans=0\nfor i in range(n):\n\tans+=li[i*2]\nprint(ans)", "n=int(input())", "n", "int(input())", "int", "input()", "input", "int(i) for i in input().split()", "for i in input().split()", "i", "input().split()", "().split", "()", "input", "split", "for i in input().split()", "int(i)", "int", "i", "li=[int(i) for i in input().split()]", "li", "[int(i) for i in input().split()]", "li=sorted(li)", "li", "sorted(li)", "sorted", "li", "ans=0", "ans", "0", "for i in range(n):\n\tans+=li[i*2]", "i", "range(n)", "range", "n", "ans+=li[i*2]", "ans", "li[i*2]", "li", "i*2", "i", "2", "print(ans)", "print", "ans", "n=int(input())", "int(input())", "n", "li=[int(i) for i in input().split()]", "[int(i) for i in input().split()]", "li", "li=sorted(li)", "sorted(li)", "li", "ans+=li[i*2]", "li[i*2]", "ans", "ans=0", "0", "ans" ]

[ 7, 0, 13, 4, 13, 4, 13, 0, 13, 4, 13, 4, 13, 13, 4, 18, 4, 13, 13, 4, 18, 13, 13, 0, 13, 17, 28, 13, 4, 13, 2, 13, 17, 14, 2, 2, 13, 17, 17, 0, 13, 18, 13, 13, 4, 13, 13, 10, 4, 13, 10, 18, 13, 10, 17, 13, 10, 4, 13 ]

[ [ 57, 2 ], [ 48, 8 ], [ 49, 21 ], [ 54, 24 ], [ 28, 27 ], [ 58, 31 ], [ 27, 36 ], [ 51, 40 ], [ 49, 42 ], [ 27, 43 ], [ 52, 46 ], [ 55, 46 ], [ 48, 49 ], [ 51, 52 ], [ 54, 55 ], [ 57, 58 ] ]

[ "N = int(input())\nL = list(map(int, input().split()))\nL.sort()\nans = 0\nfor i in range(N*2):\n if i % 2 == 0:\n ans += L[i]\nprint(ans)", "N = int(input())", "N", "int(input())", "int", "input()", "input", "L = list(map(int, input().split()))", "L", "list(map(int, input().split()))", "list", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "L.sort()", "L.sort", "L", "sort", "ans = 0", "ans", "0", "for i in range(N*2):\n if i % 2 == 0:\n ans += L[i]", "i", "range(N*2)", "range", "N*2", "N", "2", "if i % 2 == 0:\n ans += L[i]", "i % 2 == 0", "i % 2", "i", "2", "0", "ans += L[i]", "ans", "L[i]", "L", "i", "print(ans)", "print", "ans", "L = list(map(int, input().split()))", "list(map(int, input().split()))", "L", "ans += L[i]", "L[i]", "ans", "ans = 0", "0", "ans", "N = int(input())", "int(input())", "N" ]

[ 7, 0, 13, 4, 13, 4, 13, 0, 13, 4, 13, 4, 13, 4, 13, 13, 4, 18, 4, 13, 13, 0, 13, 17, 28, 13, 4, 13, 17, 2, 17, 13, 17, 0, 13, 4, 13, 18, 13, 13, 18, 13, 2, 13, 17, 4, 13, 13, 10, 4, 13, 10, 4, 13, 10, 4, 13, 10, 17, 13 ]

[ [ 52, 2 ], [ 49, 8 ], [ 58, 22 ], [ 26, 25 ], [ 53, 31 ], [ 55, 34 ], [ 50, 38 ], [ 25, 39 ], [ 50, 41 ], [ 25, 43 ], [ 56, 47 ], [ 59, 47 ], [ 49, 50 ], [ 52, 53 ], [ 55, 56 ], [ 58, 59 ] ]

[ "N = int(input())\nL = list(sorted(map(int, input().split())))\n\nans = 0\nfor i in range(0, 2 * N, 2):\n ans += min(L[i], L[i + 1])\nprint(ans)", "N = int(input())", "N", "int(input())", "int", "input()", "input", "L = list(sorted(map(int, input().split())))", "L", "list(sorted(map(int, input().split())))", "list", "sorted(map(int, input().split()))", "sorted", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "ans = 0", "ans", "0", "for i in range(0, 2 * N, 2):\n ans += min(L[i], L[i + 1])", "i", "range(0, 2 * N, 2)", "range", "0", "2 * N", "2", "N", "2", "ans += min(L[i], L[i + 1])", "ans", "min(L[i], L[i + 1])", "min", "L[i]", "L", "i", "L[i + 1]", "L", "i + 1", "i", "1", "print(ans)", "print", "ans", "L = list(sorted(map(int, input().split())))", "list(sorted(map(int, input().split())))", "L", "N = int(input())", "int(input())", "N", "ans += min(L[i], L[i + 1])", "min(L[i], L[i + 1])", "ans", "ans = 0", "0", "ans" ]

[ 7, 0, 13, 2, 4, 13, 4, 13, 17, 0, 13, 4, 13, 4, 13, 13, 4, 18, 4, 13, 13, 0, 13, 4, 13, 13, 0, 13, 17, 28, 13, 4, 13, 17, 13, 17, 0, 13, 18, 13, 13, 4, 13, 13, 10, 17, 13, 10, 18, 13, 10, 4, 13, 10, 2, 13, 10, 4, 13 ]

[ [ 54, 2 ], [ 51, 10 ], [ 57, 22 ], [ 52, 25 ], [ 45, 27 ], [ 31, 30 ], [ 55, 34 ], [ 48, 37 ], [ 58, 39 ], [ 52, 39 ], [ 30, 40 ], [ 49, 43 ], [ 46, 43 ], [ 45, 46 ], [ 48, 49 ], [ 51, 52 ], [ 54, 55 ], [ 57, 58 ] ]

[ "n = int(input())*2\narr = list(map(int, input().split()))\narr = sorted(arr)\nsum = 0\nfor i in range(0,n,2):\n sum += arr[i]\nprint(sum)", "n = int(input())*2", "n", "int(input())*2", "int(input())", "int", "input()", "input", "2", "arr = list(map(int, input().split()))", "arr", "list(map(int, input().split()))", "list", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "arr = sorted(arr)", "arr", "sorted(arr)", "sorted", "arr", "sum = 0", "sum", "0", "for i in range(0,n,2):\n sum += arr[i]", "i", "range(0,n,2)", "range", "0", "n", "2", "sum += arr[i]", "sum", "arr[i]", "arr", "i", "print(sum)", "print", "sum", "sum = 0", "0", "sum", "sum += arr[i]", "arr[i]", "sum", "arr = list(map(int, input().split()))", "list(map(int, input().split()))", "arr", "n = int(input())*2", "int(input())*2", "n", "arr = sorted(arr)", "sorted(arr)", "arr" ]

[ 7, 0, 13, 4, 13, 4, 13, 0, 13, 4, 13, 4, 13, 13, 4, 18, 4, 13, 13, 4, 18, 13, 13, 0, 13, 39, 28, 13, 13, 4, 18, 13, 13, 18, 13, 13, 4, 13, 4, 13, 13, 10, 4, 13, 10, 4, 13, 10, 39, 13 ]

[ [ 42, 2 ], [ 45, 8 ], [ 46, 21 ], [ 48, 24 ], [ 28, 27 ], [ 49, 31 ], [ 46, 34 ], [ 27, 35 ], [ 49, 40 ], [ 42, 43 ], [ 45, 46 ], [ 48, 49 ] ]

[ "n = int(input())\nL = list(map(int, input().split()))\nL.sort()\narray_L = []\nfor m in [i * 2 for i in range(n)]:\n array_L.append(L[m])\nprint(sum(array_L))\n ", "n = int(input())", "n", "int(input())", "int", "input()", "input", "L = list(map(int, input().split()))", "L", "list(map(int, input().split()))", "list", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "L.sort()", "L.sort", "L", "sort", "array_L = []", "array_L", "[]", "for m in [i * 2 for i in range(n)]:\n array_L.append(L[m])", "m", "[i * 2 for i in range(n)]", "array_L.append(L[m])", "array_L.append", "array_L", "append", "L[m]", "L", "m", "print(sum(array_L))", "print", "sum(array_L)", "sum", "array_L", "n = int(input())", "int(input())", "n", "L = list(map(int, input().split()))", "list(map(int, input().split()))", "L", "array_L = []", "[]", "array_L" ]

[ 7, 0, 13, 4, 13, 4, 13, 0, 13, 4, 13, 4, 13, 13, 4, 18, 4, 13, 13, 4, 18, 13, 13, 0, 13, 17, 0, 13, 17, 42, 2, 13, 4, 13, 13, 0, 13, 18, 13, 13, 0, 13, 17, 4, 13, 13, 10, 4, 13, 10, 4, 13, 10, 17, 13, 10, 17, 13, 10, 17, 13, 10, 18, 13 ]

[ [ 50, 2 ], [ 47, 8 ], [ 48, 21 ], [ 53, 24 ], [ 59, 27 ], [ 60, 31 ], [ 57, 31 ], [ 48, 34 ], [ 62, 36 ], [ 48, 38 ], [ 60, 39 ], [ 57, 39 ], [ 56, 41 ], [ 63, 45 ], [ 54, 45 ], [ 47, 48 ], [ 50, 51 ], [ 53, 54 ], [ 56, 57 ], [ 59, 60 ], [ 62, 63 ] ]

[ "n = int(input())\nl = list(map(int, input().split() ))\nl.sort()\ncount = 0\ni = 0\nwhile i<len(l):\n\tcount+=l[i]\n\ti+=2\nprint(count)", "n = int(input())", "n", "int(input())", "int", "input()", "input", "l = list(map(int, input().split() ))", "l", "list(map(int, input().split() ))", "list", "map(int, input().split() )", "map", "int", "input().split()", "().split", "()", "input", "split", "l.sort()", "l.sort", "l", "sort", "count = 0", "count", "0", "i = 0", "i", "0", "while i<len(l):\n\tcount+=l[i]\n\ti+=2", "i<len(l)", "i", "len(l)", "len", "l", "count+=l[i]", "count", "l[i]", "l", "i", "i+=2", "i", "2", "print(count)", "print", "count", "l = list(map(int, input().split() ))", "list(map(int, input().split() ))", "l", "n = int(input())", "int(input())", "n", "count = 0", "0", "count", "i+=2", "2", "i", "i = 0", "0", "i", "count+=l[i]", "l[i]", "count" ]

[ 7, 0, 13, 4, 13, 4, 13, 41, 28, 13, 4, 18, 4, 13, 13, 4, 4, 13, 13, 0, 13, 13, 4, 18, 13, 13, 0, 13, 17, 28, 13, 4, 13, 17, 2, 17, 13, 17, 0, 13, 18, 13, 13, 4, 13, 13, 10, 18, 13, 10, 17, 13, 10, 4, 13, 10, 13, 13 ]

[ [ 53, 2 ], [ 10, 9 ], [ 9, 18 ], [ 56, 20 ], [ 57, 24 ], [ 50, 27 ], [ 31, 30 ], [ 54, 36 ], [ 47, 39 ], [ 57, 41 ], [ 30, 42 ], [ 48, 45 ], [ 51, 45 ], [ 47, 48 ], [ 50, 51 ], [ 53, 54 ], [ 56, 57 ] ]

[ "N = int(input())\nL = [int(i) for i in input().split()]\nL.sort()\n\nans = 0\nfor i in range(0, 2 * N, 2):\n ans += L[i]\n\nprint(ans)", "N = int(input())", "N", "int(input())", "int", "input()", "input", "int(i) for i in input().split()", "for i in input().split()", "i", "input().split()", "().split", "()", "input", "split", "for i in input().split()", "int(i)", "int", "i", "L = [int(i) for i in input().split()]", "L", "[int(i) for i in input().split()]", "L.sort()", "L.sort", "L", "sort", "ans = 0", "ans", "0", "for i in range(0, 2 * N, 2):\n ans += L[i]", "i", "range(0, 2 * N, 2)", "range", "0", "2 * N", "2", "N", "2", "ans += L[i]", "ans", "L[i]", "L", "i", "print(ans)", "print", "ans", "ans += L[i]", "L[i]", "ans", "ans = 0", "0", "ans", "N = int(input())", "int(input())", "N", "L = [int(i) for i in input().split()]", "[int(i) for i in input().split()]", "L" ]

[ 7, 0, 13, 4, 13, 4, 13, 0, 13, 4, 13, 4, 13, 13, 4, 18, 4, 13, 13, 0, 13, 4, 13, 13, 0, 13, 4, 13, 18, 13, 39, 17, 17, 4, 13, 13, 10, 4, 13, 10, 4, 13, 10, 4, 13, 10, 4, 13 ]

[ [ 46, 2 ], [ 43, 8 ], [ 37, 20 ], [ 44, 23 ], [ 40, 25 ], [ 38, 29 ], [ 41, 35 ], [ 37, 38 ], [ 40, 41 ], [ 43, 44 ], [ 46, 47 ] ]

[ "N = int(input())\nL = list(map(int, input().split()))\n \nL_s = sorted(L)\nA = sum(L_s[0::2])\n \nprint(A)", "N = int(input())", "N", "int(input())", "int", "input()", "input", "L = list(map(int, input().split()))", "L", "list(map(int, input().split()))", "list", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "L_s = sorted(L)", "L_s", "sorted(L)", "sorted", "L", "A = sum(L_s[0::2])", "A", "sum(L_s[0::2])", "sum", "L_s[0::2]", "L_s", "0::2", "0", "2", "print(A)", "print", "A", "L_s = sorted(L)", "sorted(L)", "L_s", "A = sum(L_s[0::2])", "sum(L_s[0::2])", "A", "L = list(map(int, input().split()))", "list(map(int, input().split()))", "L", "N = int(input())", "int(input())", "N" ]

[ 7, 0, 13, 4, 13, 4, 13, 0, 13, 4, 13, 4, 13, 13, 4, 18, 4, 13, 13, 4, 18, 13, 13, 0, 13, 17, 0, 13, 4, 13, 18, 13, 39, 17, 17, 4, 13, 13, 10, 4, 13, 10, 4, 13, 10, 4, 13 ]

[ [ 45, 2 ], [ 39, 8 ], [ 40, 21 ], [ 25, 24 ], [ 42, 27 ], [ 40, 31 ], [ 43, 37 ], [ 39, 40 ], [ 42, 43 ], [ 45, 46 ] ]

[ "#AGC001A\nN = int(input())\nLs = list(map(int, input().split()))\n\nLs.sort(reverse=True)\nres = sum(Ls[1::2])\n\nprint(res)", "N = int(input())", "N", "int(input())", "int", "input()", "input", "Ls = list(map(int, input().split()))", "Ls", "list(map(int, input().split()))", "list", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "Ls.sort(reverse=True)", "Ls.sort", "Ls", "sort", "reverse=True", "reverse", "True", "res = sum(Ls[1::2])", "res", "sum(Ls[1::2])", "sum", "Ls[1::2]", "Ls", "1::2", "1", "2", "print(res)", "print", "res", "Ls = list(map(int, input().split()))", "list(map(int, input().split()))", "Ls", "res = sum(Ls[1::2])", "sum(Ls[1::2])", "res", "N = int(input())", "int(input())", "N" ]

[ 7, 0, 13, 4, 13, 4, 13, 0, 13, 4, 13, 4, 13, 13, 4, 18, 4, 13, 13, 4, 18, 13, 13, 41, 28, 13, 4, 13, 2, 17, 13, 2, 2, 13, 17, 17, 4, 18, 13, 13, 4, 13, 4, 13, 13, 10, 4, 13, 10, 4, 13 ]

[ [ 46, 2 ], [ 49, 8 ], [ 50, 21 ], [ 26, 25 ], [ 47, 30 ], [ 25, 33 ], [ 50, 38 ], [ 25, 39 ], [ 46, 47 ], [ 49, 50 ] ]

[ "n = int(input())\nl = list(map(int, input().split()))\nl.sort()\nprint(sum([l[i] for i in range(2*n) if i % 2 == 0]))", "n = int(input())", "n", "int(input())", "int", "input()", "input", "l = list(map(int, input().split()))", "l", "list(map(int, input().split()))", "list", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "l.sort()", "l.sort", "l", "sort", "l[i] for i in range(2*n) if i % 2 == 0", "for i in range(2*n) if i % 2 == 0", "i", "range(2*n)", "range", "2*n", "2", "n", "i % 2 == 0", "i % 2", "i", "2", "0", "if i % 2 == 0", "l[i]", "l", "i", "print(sum([l[i] for i in range(2*n) if i % 2 == 0]))", "print", "sum([l[i] for i in range(2*n) if i % 2 == 0])", "sum", "[l[i] for i in range(2*n) if i % 2 == 0]", "n = int(input())", "int(input())", "n", "l = list(map(int, input().split()))", "list(map(int, input().split()))", "l" ]