node_ids
sequencelengths 4
1.4k
| edge_index
sequencelengths 1
2.22k
| text
sequencelengths 4
1.4k
| source
stringlengths 14
427k
|
|---|---|---|---|
[
7,
15,
13,
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,
12,
13,
0,
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,
29,
2,
13,
13,
23,
13,
23,
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,
4,
13,
2,
13,
13,
10,
2,
13,
10,
4,
13,
10,
4,
13,
10,
17,
13,
10,
13,
13,
10,
4,
13,
10,
12,
13,
10,
2,
13,
10,
4,
13
] | [
[
161,
4
],
[
161,
13
],
[
161,
14
],
[
161,
15
],
[
137,
17
],
[
26,
25
],
[
141,
30
],
[
153,
31
],
[
149,
36
],
[
40,
39
],
[
141,
45
],
[
153,
46
],
[
52,
49
],
[
150,
50
],
[
39,
51
],
[
150,
55
],
[
39,
57
],
[
39,
59
],
[
138,
60
],
[
65,
64
],
[
150,
68
],
[
95,
70
],
[
97,
71
],
[
150,
75
],
[
95,
76
],
[
138,
78
],
[
138,
80
],
[
150,
84
],
[
97,
85
],
[
138,
87
],
[
138,
89
],
[
64,
92
],
[
95,
92
],
[
138,
93
],
[
95,
95
],
[
97,
97
],
[
146,
99
],
[
103,
102
],
[
141,
106
],
[
144,
107
],
[
158,
109
],
[
156,
113
],
[
102,
114
],
[
162,
116
],
[
156,
119
],
[
141,
122
],
[
102,
123
],
[
153,
127
],
[
162,
128
],
[
138,
130
],
[
159,
134
],
[
147,
134
],
[
138,
135
],
[
137,
138
],
[
161,
141
],
[
161,
144
],
[
146,
147
],
[
149,
150
],
[
161,
153
],
[
158,
159
],
[
161,
162
]
] | [
"import math\nH, 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\ndef fac(a, b):\n a = F[a + b] * pow(F[a], p - 2, p) * pow(F[b], p - 2, p)\n return a % p\nans = 0\nfor h in range(H - A):\n ans += fac(h, B - 1) * fac(H - h - 1, W - B - 1) % p\nprint(ans % p)",
"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",
"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",
"def fac(a, b):\n a = F[a + b] * pow(F[a], p - 2, p) * pow(F[b], p - 2, p)\n return a % p",
"fac",
"a = F[a + b] * pow(F[a], p - 2, p) * pow(F[b], p - 2, p)",
"a",
"F[a + b] * pow(F[a], p - 2, p) * pow(F[b], p - 2, p)",
"F[a + b] * pow(F[a], p - 2, p)",
"F[a + b]",
"F",
"a + b",
"a",
"b",
"pow(F[a], p - 2, p)",
"pow",
"F[a]",
"F",
"a",
"p - 2",
"p",
"2",
"p",
"pow(F[b], p - 2, p)",
"pow",
"F[b]",
"F",
"b",
"p - 2",
"p",
"2",
"p",
"return a % p",
"a % p",
"a",
"p",
"a",
"a",
"b",
"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",
"print(ans % p)",
"print",
"ans % p",
"ans",
"p",
"p = 10 ** 9 + 7",
"10 ** 9 + 7",
"p",
"H, W, A, B = map(int, input().split())",
"map(int, input().split())",
"H",
"A, B = map(int, input().split())",
"map(int, input().split())",
"A",
"ans = 0",
"0",
"ans",
"F = [1 for i in range(H + W + 1)]",
"[1 for i in range(H + W + 1)]",
"F",
"W, A, B = map(int, input().split())",
"map(int, input().split())",
"W",
"def fac(a, b):\n a = F[a + b] * pow(F[a], p - 2, p) * pow(F[b], p - 2, p)\n return a % p",
"def fac(a, b):\n a = F[a + b] * pow(F[a], p - 2, p) * pow(F[b], p - 2, p)\n return a % p",
"fac",
"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",
"B = map(int, input().split())",
"map(int, input().split())",
"B"
] | import math
H, W, A, B = map(int, input().split())
p = 10 ** 9 + 7
F = [1 for i in range(H + W + 1)]
for i in range(1, H + W + 1):
F[i] = F[i - 1] * i % p
def fac(a, b):
a = F[a + b] * pow(F[a], p - 2, p) * pow(F[b], p - 2, p)
return a % p
ans = 0
for h in range(H - A):
ans += fac(h, B - 1) * fac(H - h - 1, W - B - 1) % p
print(ans % p) |
[
7,
15,
13,
12,
13,
41,
28,
13,
4,
13,
13,
4,
2,
39,
13,
13,
12,
13,
23,
13,
23,
13,
23,
13,
41,
28,
13,
4,
13,
13,
4,
13,
12,
13,
23,
13,
23,
13,
23,
13,
23,
13,
41,
28,
13,
4,
13,
13,
4,
13,
12,
13,
23,
13,
23,
13,
23,
13,
23,
13,
23,
13,
12,
13,
23,
13,
23,
13,
17,
12,
13,
12,
13,
41,
28,
13,
4,
13,
13,
4,
4,
13,
12,
13,
23,
13,
17,
12,
13,
12,
13,
12,
13,
12,
13,
4,
18,
13,
13,
2,
17,
17,
0,
13,
2,
17,
17,
0,
13,
2,
2,
17,
17,
17,
6,
13,
17,
12,
13,
17,
0,
13,
17,
0,
18,
13,
13,
13,
0,
18,
13,
13,
13,
0,
13,
2,
39,
17,
13,
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,
13,
2,
39,
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,
13,
2,
2,
18,
13,
2,
13,
17,
2,
13,
17,
13,
0,
18,
13,
13,
13,
0,
18,
13,
13,
13,
23,
13,
23,
13,
23,
13,
12,
13,
17,
14,
2,
13,
13,
0,
13,
4,
13,
13,
2,
13,
13,
0,
13,
18,
18,
13,
13,
13,
0,
13,
2,
2,
18,
18,
13,
13,
13,
18,
18,
13,
13,
2,
13,
13,
18,
13,
13,
29,
2,
2,
13,
13,
18,
13,
13,
23,
13,
23,
13,
23,
13,
0,
13,
4,
13,
13,
13,
13,
0,
13,
2,
13,
13,
0,
13,
2,
13,
13,
0,
13,
4,
13,
2,
13,
13,
13,
0,
13,
17,
28,
13,
4,
13,
17,
2,
13,
17,
0,
13,
4,
18,
13,
13,
2,
2,
2,
13,
13,
13,
17,
2,
13,
17,
0,
13,
4,
18,
13,
13,
2,
2,
2,
13,
13,
13,
17,
2,
13,
17,
0,
13,
2,
13,
13,
0,
13,
13,
4,
13,
13,
10,
12,
13,
10,
4,
13,
10,
4,
13,
10,
12,
13,
10,
2,
13,
10,
17,
13,
10,
12,
13,
10,
2,
13,
10,
4,
13,
10,
13,
13,
10,
12,
13,
10,
4,
13,
10,
12,
13,
10,
12,
13,
10,
2,
13,
10,
4,
13,
10,
12,
13,
10,
4,
13,
10,
12,
13,
10,
12,
13,
10,
12,
13,
10,
6,
13,
10,
4,
13,
10,
2,
13,
10,
12,
13,
10,
2,
13,
10,
12,
13
] | [
[
8,
7
],
[
19,
19
],
[
21,
21
],
[
23,
23
],
[
27,
26
],
[
35,
35
],
[
37,
37
],
[
39,
39
],
[
41,
41
],
[
45,
44
],
[
53,
53
],
[
55,
55
],
[
57,
57
],
[
59,
59
],
[
61,
61
],
[
65,
65
],
[
68,
67
],
[
76,
75
],
[
439,
81
],
[
86,
85
],
[
408,
103
],
[
387,
108
],
[
122,
121
],
[
127,
124
],
[
226,
125
],
[
121,
126
],
[
228,
126
],
[
121,
127
],
[
228,
127
],
[
132,
129
],
[
226,
130
],
[
230,
131
],
[
230,
132
],
[
135,
134
],
[
121,
138
],
[
228,
138
],
[
148,
140
],
[
134,
141
],
[
148,
145
],
[
134,
146
],
[
151,
150
],
[
121,
154
],
[
228,
154
],
[
159,
156
],
[
134,
157
],
[
150,
158
],
[
134,
162
],
[
150,
164
],
[
150,
166
],
[
230,
167
],
[
170,
169
],
[
121,
173
],
[
228,
173
],
[
180,
175
],
[
169,
176
],
[
121,
178
],
[
228,
178
],
[
134,
183
],
[
121,
185
],
[
228,
185
],
[
230,
188
],
[
230,
190
],
[
193,
192
],
[
121,
196
],
[
228,
196
],
[
204,
201
],
[
169,
202
],
[
192,
203
],
[
169,
207
],
[
192,
209
],
[
192,
212
],
[
230,
214
],
[
219,
216
],
[
226,
217
],
[
134,
219
],
[
224,
221
],
[
226,
222
],
[
169,
224
],
[
226,
226
],
[
228,
228
],
[
230,
230
],
[
283,
236
],
[
285,
237
],
[
240,
239
],
[
285,
242
],
[
283,
244
],
[
285,
245
],
[
248,
247
],
[
281,
250
],
[
283,
252
],
[
255,
254
],
[
281,
259
],
[
239,
261
],
[
285,
261
],
[
281,
264
],
[
283,
267
],
[
239,
268
],
[
285,
268
],
[
281,
270
],
[
388,
271
],
[
247,
275
],
[
254,
276
],
[
281,
278
],
[
388,
279
],
[
281,
281
],
[
283,
283
],
[
285,
285
],
[
417,
287
],
[
421,
289
],
[
417,
290
],
[
417,
291
],
[
417,
292
],
[
441,
294
],
[
418,
296
],
[
400,
297
],
[
435,
299
],
[
391,
301
],
[
373,
302
],
[
369,
304
],
[
418,
308
],
[
391,
309
],
[
388,
310
],
[
381,
312
],
[
316,
315
],
[
436,
320
],
[
411,
323
],
[
370,
326
],
[
232,
327
],
[
442,
331
],
[
373,
332
],
[
315,
333
],
[
442,
336
],
[
432,
339
],
[
370,
342
],
[
232,
343
],
[
400,
347
],
[
436,
348
],
[
315,
349
],
[
400,
352
],
[
378,
355
],
[
412,
357
],
[
433,
358
],
[
393,
360
],
[
388,
361
],
[
394,
364
],
[
379,
364
],
[
382,
364
],
[
369,
370
],
[
417,
373
],
[
378,
379
],
[
381,
382
],
[
387,
388
],
[
417,
391
],
[
388,
393
],
[
393,
394
],
[
417,
400
],
[
408,
409
],
[
411,
412
],
[
417,
418
],
[
432,
433
],
[
435,
436
],
[
441,
442
]
] | [
"# -*- coding: utf-8 -*-\n\nimport sys\n\ndef input(): return sys.stdin.readline().strip()\ndef list2d(a, b, c): return [[c] * b for i in range(a)]\ndef list3d(a, b, c, d): return [[[d] * c for j in range(b)] for i in range(a)]\ndef list4d(a, b, c, d, e): return [[[[e] * d for j in range(c)] for j in range(b)] for i in range(a)]\ndef ceil(x, y=1): return int(-(-x // y))\ndef INT(): return int(input())\ndef MAP(): return map(int, input().split())\ndef LIST(N=None): return list(MAP()) if N is None else [INT() for i in range(N)]\ndef Yes(): print('Yes')\ndef No(): print('No')\ndef YES(): print('YES')\ndef NO(): print('NO')\nsys.setrecursionlimit(10 ** 9)\nINF = 10 ** 18\nMOD = 10 ** 9 + 7\n\nclass ModTools:\n \"\"\" 階乗たくさん使う時用のテーブル準備 \"\"\"\n\n def __init__(self, MAX, MOD):\n \"\"\" MAX：階乗に使う数値の最大以上まで作る \"\"\"\n \n MAX += 1\n self.MAX = MAX\n self.MOD = MOD\n # 階乗テーブル\n factorial = [1] * MAX\n factorial[0] = factorial[1] = 1\n for i in range(2, MAX):\n factorial[i] = factorial[i-1] * i % MOD\n # 階乗の逆元テーブル\n inverse = [1] * MAX\n # powに第三引数入れると冪乗のmod付計算を高速にやってくれる\n inverse[MAX-1] = pow(factorial[MAX-1], MOD-2, MOD)\n for i in range(MAX-2, 0, -1):\n # 最後から戻っていくこのループならMAX回powするより処理が速い\n inverse[i] = inverse[i+1] * (i+1) % MOD\n self.fact = factorial\n self.inv = inverse\n \n def nCr(self, n, r):\n \"\"\" 組み合わせの数 (必要な階乗と逆元のテーブルを事前に作っておく) \"\"\"\n\n if n < r: return 0\n # 10C7 = 10C3\n r = min(r, n-r)\n # 分子の計算\n numerator = self.fact[n]\n # 分母の計算\n denominator = self.inv[r] * self.inv[n-r] % self.MOD\n return numerator * denominator % self.MOD\n\nH, W, Y2, X1 = MAP()\n\nY1 = H - Y2\nX2 = W - X1\nmt = ModTools(H+W, MOD)\nans = 0\nfor x in range(1, X2+1):\n # 上の方の通り数\n cnt1 = mt.nCr(Y1+X1+x-2, Y1-1)\n # 下の方の通り数\n cnt2 = mt.nCr(Y2+X2-x-1, Y2-1)\n ans += cnt1 * cnt2\n ans %= MOD\nprint(ans)",
"import sys",
"sys",
"def input(): return sys.stdin.readline().strip()",
"input",
"[c] * b for i in range(a)",
"for i in range(a)",
"i",
"range(a)",
"range",
"a",
"for i in range(a)",
"[c] * b",
"[c]",
"c",
"b",
"def list2d(a, b, c): return [[c] * b for i in range(a)]",
"list2d",
"a",
"a",
"b",
"b",
"c",
"c",
"[[d] * c for j in range(b)] for i in range(a)",
"for i in range(a)",
"i",
"range(a)",
"range",
"a",
"for i in range(a)",
"[[d] * c for j in range(b)]",
"def list3d(a, b, c, d): return [[[d] * c for j in range(b)] for i in range(a)]",
"list3d",
"a",
"a",
"b",
"b",
"c",
"c",
"d",
"d",
"[[[e] * d for j in range(c)] for j in range(b)] for i in range(a)",
"for i in range(a)",
"i",
"range(a)",
"range",
"a",
"for i in range(a)",
"[[[e] * d for j in range(c)] for j in range(b)]",
"def list4d(a, b, c, d, e): return [[[[e] * d for j in range(c)] for j in range(b)] for i in range(a)]",
"list4d",
"a",
"a",
"b",
"b",
"c",
"c",
"d",
"d",
"e",
"e",
"def ceil(x, y=1): return int(-(-x // y))",
"ceil",
"x",
"x",
"y=1",
"y",
"1",
"def INT(): return int(input())",
"INT",
"def MAP(): return map(int, input().split())",
"MAP",
"INT() for i in range(N)",
"for i in range(N)",
"i",
"range(N)",
"range",
"N",
"for i in range(N)",
"INT()",
"INT",
"def LIST(N=None): return list(MAP()) if N is None else [INT() for i in range(N)]",
"LIST",
"N=None",
"N",
"None",
"def Yes(): print('Yes')",
"Yes",
"def No(): print('No')",
"No",
"def YES(): print('YES')",
"YES",
"def NO(): print('NO')",
"NO",
"sys.setrecursionlimit(10 ** 9)",
"sys.setrecursionlimit",
"sys",
"setrecursionlimit",
"10 ** 9",
"10",
"9",
"INF = 10 ** 18",
"INF",
"10 ** 18",
"10",
"18",
"MOD = 10 ** 9 + 7",
"MOD",
"10 ** 9 + 7",
"10 ** 9",
"10",
"9",
"7",
"class ModTools:\n \"\"\" 階乗たくさん使う時用のテーブル準備 \"\"\"\n\n def __init__(self, MAX, MOD):\n \"\"\" MAX：階乗に使う数値の最大以上まで作る \"\"\"\n \n MAX += 1\n self.MAX = MAX\n self.MOD = MOD\n # 階乗テーブル\n factorial = [1] * MAX\n factorial[0] = factorial[1] = 1\n for i in range(2, MAX):\n factorial[i] = factorial[i-1] * i % MOD\n # 階乗の逆元テーブル\n inverse = [1] * MAX\n # powに第三引数入れると冪乗のmod付計算を高速にやってくれる\n inverse[MAX-1] = pow(factorial[MAX-1], MOD-2, MOD)\n for i in range(MAX-2, 0, -1):\n # 最後から戻っていくこのループならMAX回powするより処理が速い\n inverse[i] = inverse[i+1] * (i+1) % MOD\n self.fact = factorial\n self.inv = inverse\n \n def nCr(self, n, r):\n \"\"\" 組み合わせの数 (必要な階乗と逆元のテーブルを事前に作っておく) \"\"\"\n\n if n < r: return 0\n # 10C7 = 10C3\n r = min(r, n-r)\n # 分子の計算\n numerator = self.fact[n]\n # 分母の計算\n denominator = self.inv[r] * self.inv[n-r] % self.MOD\n return numerator * denominator % self.MOD",
"ModTools",
"\"\"\" 階乗たくさん使う時用のテーブル準備 \"\"\"",
"def __init__(self, MAX, MOD):\n \"\"\" MAX：階乗に使う数値の最大以上まで作る \"\"\"\n \n MAX += 1\n self.MAX = MAX\n self.MOD = MOD\n # 階乗テーブル\n factorial = [1] * MAX\n factorial[0] = factorial[1] = 1\n for i in range(2, MAX):\n factorial[i] = factorial[i-1] * i % MOD\n # 階乗の逆元テーブル\n inverse = [1] * MAX\n # powに第三引数入れると冪乗のmod付計算を高速にやってくれる\n inverse[MAX-1] = pow(factorial[MAX-1], MOD-2, MOD)\n for i in range(MAX-2, 0, -1):\n # 最後から戻っていくこのループならMAX回powするより処理が速い\n inverse[i] = inverse[i+1] * (i+1) % MOD\n self.fact = factorial\n self.inv = inverse\n \n ",
"__init__",
"\"\"\" MAX：階乗に使う数値の最大以上まで作る \"\"\"",
"MAX += 1",
"MAX",
"1",
"self.MAX = MAX",
"self.MAX",
"self",
"MAX",
"MAX",
"self.MOD = MOD",
"self.MOD",
"self",
"MOD",
"MOD",
"factorial = [1] * MAX",
"factorial",
"[1] * MAX",
"[1]",
"1",
"MAX",
"factorial[0] = factorial[1] = 1",
"factorial[0]",
"factorial",
"0",
"1",
"= factorial[1] = 1",
"factorial[1]",
"factorial",
"1",
"1",
"for i in range(2, MAX):\n factorial[i] = factorial[i-1] * i % MOD\n # 階乗の逆元テーブル\n ",
"i",
"range(2, MAX)",
"range",
"2",
"MAX",
"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] * MAX",
"inverse",
"[1] * MAX",
"[1]",
"1",
"MAX",
"inverse[MAX-1] = pow(factorial[MAX-1], MOD-2, MOD)",
"inverse[MAX-1]",
"inverse",
"MAX-1",
"MAX",
"1",
"pow(factorial[MAX-1], MOD-2, MOD)",
"pow",
"factorial[MAX-1]",
"factorial",
"MAX-1",
"MAX",
"1",
"MOD-2",
"MOD",
"2",
"MOD",
"for i in range(MAX-2, 0, -1):\n # 最後から戻っていくこのループならMAX回powするより処理が速い\n inverse[i] = inverse[i+1] * (i+1) % MOD\n ",
"i",
"range(MAX-2, 0, -1)",
"range",
"MAX-2",
"MAX",
"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",
"self.fact = factorial",
"self.fact",
"self",
"fact",
"factorial",
"self.inv = inverse",
"self.inv",
"self",
"inv",
"inverse",
"self",
"self",
"MAX",
"MAX",
"MOD",
"MOD",
"def nCr(self, n, r):\n \"\"\" 組み合わせの数 (必要な階乗と逆元のテーブルを事前に作っておく) \"\"\"\n\n if n < r: return 0\n # 10C7 = 10C3\n r = min(r, n-r)\n # 分子の計算\n numerator = self.fact[n]\n # 分母の計算\n denominator = self.inv[r] * self.inv[n-r] % self.MOD\n return numerator * denominator % self.MOD",
"nCr",
"\"\"\" 組み合わせの数 (必要な階乗と逆元のテーブルを事前に作っておく) \"\"\"",
"if n < r: return 0\n # 10C7 = 10C3\n ",
"n < r",
"n",
"r",
"r = min(r, n-r)",
"r",
"min(r, n-r)",
"min",
"r",
"n-r",
"n",
"r",
"numerator = self.fact[n]",
"numerator",
"self.fact[n]",
"self.fact",
"self",
"fact",
"n",
"denominator = self.inv[r] * self.inv[n-r] % self.MOD",
"denominator",
"self.inv[r] * self.inv[n-r] % self.MOD",
"self.inv[r] * self.inv[n-r]",
"self.inv[r]",
"self.inv",
"self",
"inv",
"r",
"self.inv[n-r]",
"self.inv",
"self",
"inv",
"n-r",
"n",
"r",
"self.MOD",
"self",
"MOD",
"return numerator * denominator % self.MOD",
"numerator * denominator % self.MOD",
"numerator * denominator",
"numerator",
"denominator",
"self.MOD",
"self",
"MOD",
"self",
"self",
"n",
"n",
"r",
"r",
"H, W, Y2, X1 = MAP()",
"H",
"MAP()",
"MAP",
"W",
"Y2",
"X1",
"Y1 = H - Y2",
"Y1",
"H - Y2",
"H",
"Y2",
"X2 = W - X1",
"X2",
"W - X1",
"W",
"X1",
"mt = ModTools(H+W, MOD)",
"mt",
"ModTools(H+W, MOD)",
"ModTools",
"H+W",
"H",
"W",
"MOD",
"ans = 0",
"ans",
"0",
"for x in range(1, X2+1):\n # 上の方の通り数\n cnt1 = mt.nCr(Y1+X1+x-2, Y1-1)\n # 下の方の通り数\n cnt2 = mt.nCr(Y2+X2-x-1, Y2-1)\n ans += cnt1 * cnt2\n ans %= MOD",
"x",
"range(1, X2+1)",
"range",
"1",
"X2+1",
"X2",
"1",
"cnt1 = mt.nCr(Y1+X1+x-2, Y1-1)",
"cnt1",
"mt.nCr(Y1+X1+x-2, Y1-1)",
"mt.nCr",
"mt",
"nCr",
"Y1+X1+x-2",
"Y1+X1+x",
"Y1+X1",
"Y1",
"X1",
"x",
"2",
"Y1-1",
"Y1",
"1",
"cnt2 = mt.nCr(Y2+X2-x-1, Y2-1)",
"cnt2",
"mt.nCr(Y2+X2-x-1, Y2-1)",
"mt.nCr",
"mt",
"nCr",
"Y2+X2-x-1",
"Y2+X2-x",
"Y2+X2",
"Y2",
"X2",
"x",
"1",
"Y2-1",
"Y2",
"1",
"ans += cnt1 * cnt2",
"ans",
"cnt1 * cnt2",
"cnt1",
"cnt2",
"ans %= MOD",
"ans",
"MOD",
"print(ans)",
"print",
"ans",
"def NO(): print('NO')",
"def NO(): print('NO')",
"NO",
"mt = ModTools(H+W, MOD)",
"ModTools(H+W, MOD)",
"mt",
"X1 = MAP()",
"MAP()",
"X1",
"def ceil(x, y=1): return int(-(-x // y))",
"def ceil(x, y=1): return int(-(-x // y))",
"ceil",
"ans += cnt1 * cnt2",
"cnt1 * cnt2",
"ans",
"ans = 0",
"0",
"ans",
"def LIST(N=None): return list(MAP()) if N is None else [INT() for i in range(N)]",
"def LIST(N=None): return list(MAP()) if N is None else [INT() for i in range(N)]",
"LIST",
"MOD = 10 ** 9 + 7",
"10 ** 9 + 7",
"MOD",
"W, Y2, X1 = MAP()",
"MAP()",
"W",
"ans %= MOD",
"MOD",
"ans",
"def input(): return sys.stdin.readline().strip()",
"def input(): return sys.stdin.readline().strip()",
"input",
"Y2, X1 = MAP()",
"MAP()",
"Y2",
"def list4d(a, b, c, d, e): return [[[[e] * d for j in range(c)] for j in range(b)] for i in range(a)]",
"def list4d(a, b, c, d, e): return [[[[e] * d for j in range(c)] for j in range(b)] for i in range(a)]",
"list4d",
"def list3d(a, b, c, d): return [[[d] * c for j in range(b)] for i in range(a)]",
"def list3d(a, b, c, d): return [[[d] * c for j in range(b)] for i in range(a)]",
"list3d",
"INF = 10 ** 18",
"10 ** 18",
"INF",
"cnt1 = mt.nCr(Y1+X1+x-2, Y1-1)",
"mt.nCr(Y1+X1+x-2, Y1-1)",
"cnt1",
"def No(): print('No')",
"def No(): print('No')",
"No",
"H, W, Y2, X1 = MAP()",
"MAP()",
"H",
"def MAP(): return map(int, input().split())",
"def MAP(): return map(int, input().split())",
"MAP",
"def list2d(a, b, c): return [[c] * b for i in range(a)]",
"def list2d(a, b, c): return [[c] * b for i in range(a)]",
"list2d",
"def YES(): print('YES')",
"def YES(): print('YES')",
"YES",
"class ModTools:\n \"\"\" 階乗たくさん使う時用のテーブル準備 \"\"\"\n\n def __init__(self, MAX, MOD):\n \"\"\" MAX：階乗に使う数値の最大以上まで作る \"\"\"\n \n MAX += 1\n self.MAX = MAX\n self.MOD = MOD\n # 階乗テーブル\n factorial = [1] * MAX\n factorial[0] = factorial[1] = 1\n for i in range(2, MAX):\n factorial[i] = factorial[i-1] * i % MOD\n # 階乗の逆元テーブル\n inverse = [1] * MAX\n # powに第三引数入れると冪乗のmod付計算を高速にやってくれる\n inverse[MAX-1] = pow(factorial[MAX-1], MOD-2, MOD)\n for i in range(MAX-2, 0, -1):\n # 最後から戻っていくこのループならMAX回powするより処理が速い\n inverse[i] = inverse[i+1] * (i+1) % MOD\n self.fact = factorial\n self.inv = inverse\n \n def nCr(self, n, r):\n \"\"\" 組み合わせの数 (必要な階乗と逆元のテーブルを事前に作っておく) \"\"\"\n\n if n < r: return 0\n # 10C7 = 10C3\n r = min(r, n-r)\n # 分子の計算\n numerator = self.fact[n]\n # 分母の計算\n denominator = self.inv[r] * self.inv[n-r] % self.MOD\n return numerator * denominator % self.MOD",
"class ModTools:\n \"\"\" 階乗たくさん使う時用のテーブル準備 \"\"\"\n\n def __init__(self, MAX, MOD):\n \"\"\" MAX：階乗に使う数値の最大以上まで作る \"\"\"\n \n MAX += 1\n self.MAX = MAX\n self.MOD = MOD\n # 階乗テーブル\n factorial = [1] * MAX\n factorial[0] = factorial[1] = 1\n for i in range(2, MAX):\n factorial[i] = factorial[i-1] * i % MOD\n # 階乗の逆元テーブル\n inverse = [1] * MAX\n # powに第三引数入れると冪乗のmod付計算を高速にやってくれる\n inverse[MAX-1] = pow(factorial[MAX-1], MOD-2, MOD)\n for i in range(MAX-2, 0, -1):\n # 最後から戻っていくこのループならMAX回powするより処理が速い\n inverse[i] = inverse[i+1] * (i+1) % MOD\n self.fact = factorial\n self.inv = inverse\n \n def nCr(self, n, r):\n \"\"\" 組み合わせの数 (必要な階乗と逆元のテーブルを事前に作っておく) \"\"\"\n\n if n < r: return 0\n # 10C7 = 10C3\n r = min(r, n-r)\n # 分子の計算\n numerator = self.fact[n]\n # 分母の計算\n denominator = self.inv[r] * self.inv[n-r] % self.MOD\n return numerator * denominator % self.MOD",
"ModTools",
"cnt2 = mt.nCr(Y2+X2-x-1, Y2-1)",
"mt.nCr(Y2+X2-x-1, Y2-1)",
"cnt2",
"X2 = W - X1",
"W - X1",
"X2",
"def INT(): return int(input())",
"def INT(): return int(input())",
"INT",
"Y1 = H - Y2",
"H - Y2",
"Y1",
"def Yes(): print('Yes')",
"def Yes(): print('Yes')",
"Yes"
] | # -*- coding: utf-8 -*-
import sys
def input(): return sys.stdin.readline().strip()
def list2d(a, b, c): return [[c] * b for i in range(a)]
def list3d(a, b, c, d): return [[[d] * c for j in range(b)] for i in range(a)]
def list4d(a, b, c, d, e): return [[[[e] * d for j in range(c)] for j in range(b)] for i in range(a)]
def ceil(x, y=1): return int(-(-x // y))
def INT(): return int(input())
def MAP(): return map(int, input().split())
def LIST(N=None): return list(MAP()) if N is None else [INT() for i in range(N)]
def Yes(): print('Yes')
def No(): print('No')
def YES(): print('YES')
def NO(): print('NO')
sys.setrecursionlimit(10 ** 9)
INF = 10 ** 18
MOD = 10 ** 9 + 7
class ModTools:
""" 階乗たくさん使う時用のテーブル準備 """
def __init__(self, MAX, MOD):
""" MAX：階乗に使う数値の最大以上まで作る """
MAX += 1
self.MAX = MAX
self.MOD = MOD
# 階乗テーブル
factorial = [1] * MAX
factorial[0] = factorial[1] = 1
for i in range(2, MAX):
factorial[i] = factorial[i-1] * i % MOD
# 階乗の逆元テーブル
inverse = [1] * MAX
# powに第三引数入れると冪乗のmod付計算を高速にやってくれる
inverse[MAX-1] = pow(factorial[MAX-1], MOD-2, MOD)
for i in range(MAX-2, 0, -1):
# 最後から戻っていくこのループならMAX回powするより処理が速い
inverse[i] = inverse[i+1] * (i+1) % MOD
self.fact = factorial
self.inv = inverse
def nCr(self, n, r):
""" 組み合わせの数 (必要な階乗と逆元のテーブルを事前に作っておく) """
if n < r: return 0
# 10C7 = 10C3
r = min(r, n-r)
# 分子の計算
numerator = self.fact[n]
# 分母の計算
denominator = self.inv[r] * self.inv[n-r] % self.MOD
return numerator * denominator % self.MOD
H, W, Y2, X1 = MAP()
Y1 = H - Y2
X2 = W - X1
mt = ModTools(H+W, MOD)
ans = 0
for x in range(1, X2+1):
# 上の方の通り数
cnt1 = mt.nCr(Y1+X1+x-2, Y1-1)
# 下の方の通り数
cnt2 = mt.nCr(Y2+X2-x-1, Y2-1)
ans += cnt1 * cnt2
ans %= MOD
print(ans)
|
[
7,
6,
13,
12,
13,
0,
18,
13,
13,
2,
39,
17,
2,
13,
17,
0,
18,
13,
13,
2,
39,
17,
2,
13,
17,
0,
18,
18,
13,
13,
17,
17,
0,
18,
18,
13,
13,
17,
17,
0,
18,
13,
13,
13,
0,
13,
2,
18,
13,
13,
17,
28,
13,
4,
13,
13,
0,
18,
18,
13,
13,
2,
13,
17,
2,
2,
18,
18,
13,
13,
13,
2,
13,
17,
18,
13,
13,
0,
18,
18,
13,
13,
2,
13,
17,
2,
2,
18,
18,
13,
13,
13,
4,
13,
2,
13,
17,
13,
18,
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,
17,
29,
17,
14,
2,
2,
13,
13,
2,
13,
17,
29,
17,
0,
13,
2,
2,
18,
18,
13,
13,
2,
13,
13,
18,
18,
13,
13,
13,
18,
13,
13,
29,
2,
2,
13,
18,
18,
13,
13,
13,
18,
13,
13,
23,
13,
23,
13,
23,
13,
12,
13,
14,
2,
2,
13,
17,
2,
13,
17,
29,
17,
14,
2,
2,
13,
13,
2,
13,
17,
29,
17,
29,
2,
2,
18,
18,
13,
13,
13,
18,
18,
13,
13,
2,
13,
13,
18,
13,
13,
23,
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,
2,
13,
13,
17,
0,
13,
17,
0,
13,
2,
13,
13,
13,
2,
13,
13,
28,
13,
4,
13,
2,
13,
17,
2,
13,
17,
0,
13,
2,
2,
13,
13,
17,
0,
13,
2,
2,
13,
2,
4,
18,
13,
13,
2,
2,
13,
13,
17,
2,
13,
17,
4,
18,
13,
13,
2,
2,
13,
13,
17,
2,
13,
17,
13,
4,
13,
13,
10,
2,
13,
10,
2,
13,
10,
4,
13,
10,
2,
13,
10,
4,
13,
10,
6,
13,
10,
4,
13,
10,
2,
13,
10,
17,
13,
10,
2,
13,
10,
4,
13,
10,
4,
13
] | [
[
9,
6
],
[
105,
7
],
[
107,
13
],
[
19,
16
],
[
105,
17
],
[
107,
23
],
[
31,
26
],
[
6,
27
],
[
105,
28
],
[
38,
33
],
[
16,
34
],
[
105,
35
],
[
43,
40
],
[
105,
41
],
[
109,
42
],
[
109,
43
],
[
46,
45
],
[
40,
47
],
[
105,
48
],
[
109,
49
],
[
53,
52
],
[
107,
55
],
[
64,
57
],
[
6,
58
],
[
105,
59
],
[
52,
62
],
[
6,
67
],
[
105,
68
],
[
52,
70
],
[
52,
72
],
[
40,
74
],
[
105,
75
],
[
109,
76
],
[
85,
78
],
[
16,
79
],
[
105,
80
],
[
52,
83
],
[
16,
88
],
[
105,
89
],
[
52,
91
],
[
52,
95
],
[
45,
97
],
[
40,
98
],
[
105,
99
],
[
109,
100
],
[
40,
101
],
[
105,
102
],
[
109,
103
],
[
105,
105
],
[
107,
107
],
[
110,
109
],
[
171,
120
],
[
173,
123
],
[
171,
130
],
[
173,
131
],
[
171,
133
],
[
139,
138
],
[
169,
143
],
[
171,
146
],
[
173,
147
],
[
169,
150
],
[
173,
152
],
[
169,
154
],
[
138,
159
],
[
169,
162
],
[
171,
164
],
[
169,
166
],
[
169,
169
],
[
171,
171
],
[
173,
173
],
[
217,
179
],
[
219,
182
],
[
217,
189
],
[
219,
190
],
[
217,
192
],
[
215,
201
],
[
217,
203
],
[
215,
206
],
[
217,
209
],
[
219,
210
],
[
215,
212
],
[
215,
215
],
[
217,
217
],
[
219,
219
],
[
346,
221
],
[
346,
230
],
[
346,
231
],
[
346,
232
],
[
313,
234
],
[
343,
241
],
[
347,
246
],
[
320,
247
],
[
337,
250
],
[
334,
253
],
[
347,
255
],
[
332,
256
],
[
316,
257
],
[
320,
259
],
[
326,
260
],
[
263,
262
],
[
326,
266
],
[
320,
269
],
[
322,
272
],
[
320,
275
],
[
262,
276
],
[
340,
279
],
[
338,
282
],
[
341,
282
],
[
344,
286
],
[
116,
287
],
[
262,
290
],
[
335,
291
],
[
335,
294
],
[
344,
298
],
[
116,
299
],
[
332,
302
],
[
323,
303
],
[
317,
303
],
[
332,
306
],
[
314,
308
],
[
341,
311
],
[
338,
311
],
[
313,
314
],
[
316,
317
],
[
346,
320
],
[
322,
323
],
[
346,
326
],
[
346,
332
],
[
334,
335
],
[
337,
338
],
[
340,
341
],
[
343,
344
],
[
346,
347
]
] | [
"class Factorial:\n def __init__(self, n, mod=10**9+7):\n self.fac = [0] * (n+1)\n self.ifac = [0] * (n+1)\n self.fac[0] = 1\n self.ifac[0] = 1\n self.mod = mod\n modmod = self.mod - 2\n for i in range(n):\n self.fac[i+1] = self.fac[i] * (i+1) % self.mod\n self.ifac[i+1] = self.ifac[i] * pow(i+1, modmod, self.mod) % self.mod\n\n def comb(self, n, r):\n if n == 0 and r == 0:\n return 1\n if n < r or n < 0:\n return 0\n tmp = self.ifac[n-r] * self.ifac[r] % self.mod\n return tmp * self.fac[n] % self.mod\n\n def perm(self, n, r):\n if n == 0 and r == 0:\n return 1\n if n < r or n < 0:\n return 0\n return (self.fac[n] * self.ifac[n-r]) % self.mod\n\nh,w,a,b = map(int, input().split())\nmod = 10**9+7\nfact = Factorial(h+w+1)\nans = 0\nc,d = h-a, w-b\nfor i in range(b+1, w+1):\n d = w-i+1\n# print(i,i+c-2, c-1, fact.comb(i+c-2, c-1), fact.comb(a+d-2, a-1))\n ans = (ans + fact.comb(i+c-2, c-1) * fact.comb(a+d-2, a-1)) % mod\n\nprint(ans)",
"class Factorial:\n def __init__(self, n, mod=10**9+7):\n self.fac = [0] * (n+1)\n self.ifac = [0] * (n+1)\n self.fac[0] = 1\n self.ifac[0] = 1\n self.mod = mod\n modmod = self.mod - 2\n for i in range(n):\n self.fac[i+1] = self.fac[i] * (i+1) % self.mod\n self.ifac[i+1] = self.ifac[i] * pow(i+1, modmod, self.mod) % self.mod\n\n def comb(self, n, r):\n if n == 0 and r == 0:\n return 1\n if n < r or n < 0:\n return 0\n tmp = self.ifac[n-r] * self.ifac[r] % self.mod\n return tmp * self.fac[n] % self.mod\n\n def perm(self, n, r):\n if n == 0 and r == 0:\n return 1\n if n < r or n < 0:\n return 0\n return (self.fac[n] * self.ifac[n-r]) % self.mod",
"Factorial",
"def __init__(self, n, mod=10**9+7):\n self.fac = [0] * (n+1)\n self.ifac = [0] * (n+1)\n self.fac[0] = 1\n self.ifac[0] = 1\n self.mod = mod\n modmod = self.mod - 2\n for i in range(n):\n self.fac[i+1] = self.fac[i] * (i+1) % self.mod\n self.ifac[i+1] = self.ifac[i] * pow(i+1, modmod, self.mod) % self.mod\n\n ",
"__init__",
"self.fac = [0] * (n+1)",
"self.fac",
"self",
"fac",
"[0] * (n+1)",
"[0]",
"0",
"n+1",
"n",
"1",
"self.ifac = [0] * (n+1)",
"self.ifac",
"self",
"ifac",
"[0] * (n+1)",
"[0]",
"0",
"n+1",
"n",
"1",
"self.fac[0] = 1",
"self.fac[0]",
"self.fac",
"self",
"fac",
"0",
"1",
"self.ifac[0] = 1",
"self.ifac[0]",
"self.ifac",
"self",
"ifac",
"0",
"1",
"self.mod = mod",
"self.mod",
"self",
"mod",
"mod",
"modmod = self.mod - 2",
"modmod",
"self.mod - 2",
"self.mod",
"self",
"mod",
"2",
"for i in range(n):\n self.fac[i+1] = self.fac[i] * (i+1) % self.mod\n self.ifac[i+1] = self.ifac[i] * pow(i+1, modmod, self.mod) % self.mod\n\n ",
"i",
"range(n)",
"range",
"n",
"self.fac[i+1] = self.fac[i] * (i+1) % self.mod",
"self.fac[i+1]",
"self.fac",
"self",
"fac",
"i+1",
"i",
"1",
"self.fac[i] * (i+1) % self.mod",
"self.fac[i] * (i+1)",
"self.fac[i]",
"self.fac",
"self",
"fac",
"i",
"i+1",
"i",
"1",
"self.mod",
"self",
"mod",
"self.ifac[i+1] = self.ifac[i] * pow(i+1, modmod, self.mod) % self.mod",
"self.ifac[i+1]",
"self.ifac",
"self",
"ifac",
"i+1",
"i",
"1",
"self.ifac[i] * pow(i+1, modmod, self.mod) % self.mod",
"self.ifac[i] * pow(i+1, modmod, self.mod)",
"self.ifac[i]",
"self.ifac",
"self",
"ifac",
"i",
"pow(i+1, modmod, self.mod)",
"pow",
"i+1",
"i",
"1",
"modmod",
"self.mod",
"self",
"mod",
"self.mod",
"self",
"mod",
"self",
"self",
"n",
"n",
"mod=10**9+7",
"mod",
"10**9+7",
"10**9",
"10",
"9",
"7",
"def comb(self, n, r):\n if n == 0 and r == 0:\n return 1\n if n < r or n < 0:\n return 0\n tmp = self.ifac[n-r] * self.ifac[r] % self.mod\n return tmp * self.fac[n] % self.mod\n\n ",
"comb",
"if n == 0 and r == 0:\n return 1\n ",
"n == 0 and r == 0",
"n == 0",
"n",
"0",
"r == 0",
"r",
"0",
"return 1",
"1",
"if n < r or n < 0:\n return 0\n ",
"n < r or n < 0",
"n < r",
"n",
"r",
"n < 0",
"n",
"0",
"return 0",
"0",
"tmp = self.ifac[n-r] * self.ifac[r] % self.mod",
"tmp",
"self.ifac[n-r] * self.ifac[r] % self.mod",
"self.ifac[n-r] * self.ifac[r]",
"self.ifac[n-r]",
"self.ifac",
"self",
"ifac",
"n-r",
"n",
"r",
"self.ifac[r]",
"self.ifac",
"self",
"ifac",
"r",
"self.mod",
"self",
"mod",
"return tmp * self.fac[n] % self.mod",
"tmp * self.fac[n] % self.mod",
"tmp * self.fac[n]",
"tmp",
"self.fac[n]",
"self.fac",
"self",
"fac",
"n",
"self.mod",
"self",
"mod",
"self",
"self",
"n",
"n",
"r",
"r",
"def perm(self, n, r):\n if n == 0 and r == 0:\n return 1\n if n < r or n < 0:\n return 0\n return (self.fac[n] * self.ifac[n-r]) % self.mod",
"perm",
"if n == 0 and r == 0:\n return 1\n ",
"n == 0 and r == 0",
"n == 0",
"n",
"0",
"r == 0",
"r",
"0",
"return 1",
"1",
"if n < r or n < 0:\n return 0\n ",
"n < r or n < 0",
"n < r",
"n",
"r",
"n < 0",
"n",
"0",
"return 0",
"0",
"return (self.fac[n] * self.ifac[n-r]) % self.mod",
"(self.fac[n] * self.ifac[n-r]) % self.mod",
"self.fac[n] * self.ifac[n-r]",
"self.fac[n]",
"self.fac",
"self",
"fac",
"n",
"self.ifac[n-r]",
"self.ifac",
"self",
"ifac",
"n-r",
"n",
"r",
"self.mod",
"self",
"mod",
"self",
"self",
"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",
"mod = 10**9+7",
"mod",
"10**9+7",
"10**9",
"10",
"9",
"7",
"fact = Factorial(h+w+1)",
"fact",
"Factorial(h+w+1)",
"Factorial",
"h+w+1",
"h+w",
"h",
"w",
"1",
"ans = 0",
"ans",
"0",
"c,d = h-a, w-b",
"c",
"h-a",
"h",
"a",
"d",
"w-b",
"w",
"b",
"for i in range(b+1, w+1):\n d = w-i+1\n# print(i,i+c-2, c-1, fact.comb(i+c-2, c-1), fact.comb(a+d-2, a-1))\n ans = (ans + fact.comb(i+c-2, c-1) * fact.comb(a+d-2, a-1)) % mod",
"i",
"range(b+1, w+1)",
"range",
"b+1",
"b",
"1",
"w+1",
"w",
"1",
"d = w-i+1",
"d",
"w-i+1",
"w-i",
"w",
"i",
"1",
"ans = (ans + fact.comb(i+c-2, c-1) * fact.comb(a+d-2, a-1)) % mod",
"ans",
"(ans + fact.comb(i+c-2, c-1) * fact.comb(a+d-2, a-1)) % mod",
"ans + fact.comb(i+c-2, c-1) * fact.comb(a+d-2, a-1)",
"ans",
"fact.comb(i+c-2, c-1) * fact.comb(a+d-2, a-1)",
"fact.comb(i+c-2, c-1)",
"fact.comb",
"fact",
"comb",
"i+c-2",
"i+c",
"i",
"c",
"2",
"c-1",
"c",
"1",
"fact.comb(a+d-2, a-1)",
"fact.comb",
"fact",
"comb",
"a+d-2",
"a+d",
"a",
"d",
"2",
"a-1",
"a",
"1",
"mod",
"print(ans)",
"print",
"ans",
"mod = 10**9+7",
"10**9+7",
"mod",
"d = h-a, w-b",
"w-b",
"d",
"w,a,b = map(int, input().split())",
"map(int, input().split())",
"w",
"d = w-i+1",
"w-i+1",
"d",
"b = map(int, input().split())",
"map(int, input().split())",
"b",
"class Factorial:\n def __init__(self, n, mod=10**9+7):\n self.fac = [0] * (n+1)\n self.ifac = [0] * (n+1)\n self.fac[0] = 1\n self.ifac[0] = 1\n self.mod = mod\n modmod = self.mod - 2\n for i in range(n):\n self.fac[i+1] = self.fac[i] * (i+1) % self.mod\n self.ifac[i+1] = self.ifac[i] * pow(i+1, modmod, self.mod) % self.mod\n\n def comb(self, n, r):\n if n == 0 and r == 0:\n return 1\n if n < r or n < 0:\n return 0\n tmp = self.ifac[n-r] * self.ifac[r] % self.mod\n return tmp * self.fac[n] % self.mod\n\n def perm(self, n, r):\n if n == 0 and r == 0:\n return 1\n if n < r or n < 0:\n return 0\n return (self.fac[n] * self.ifac[n-r]) % self.mod",
"class Factorial:\n def __init__(self, n, mod=10**9+7):\n self.fac = [0] * (n+1)\n self.ifac = [0] * (n+1)\n self.fac[0] = 1\n self.ifac[0] = 1\n self.mod = mod\n modmod = self.mod - 2\n for i in range(n):\n self.fac[i+1] = self.fac[i] * (i+1) % self.mod\n self.ifac[i+1] = self.ifac[i] * pow(i+1, modmod, self.mod) % self.mod\n\n def comb(self, n, r):\n if n == 0 and r == 0:\n return 1\n if n < r or n < 0:\n return 0\n tmp = self.ifac[n-r] * self.ifac[r] % self.mod\n return tmp * self.fac[n] % self.mod\n\n def perm(self, n, r):\n if n == 0 and r == 0:\n return 1\n if n < r or n < 0:\n return 0\n return (self.fac[n] * self.ifac[n-r]) % self.mod",
"Factorial",
"a,b = map(int, input().split())",
"map(int, input().split())",
"a",
"c,d = h-a, w-b",
"h-a",
"c",
"ans = 0",
"0",
"ans",
"ans = (ans + fact.comb(i+c-2, c-1) * fact.comb(a+d-2, a-1)) % mod",
"(ans + fact.comb(i+c-2, c-1) * fact.comb(a+d-2, a-1)) % mod",
"ans",
"fact = Factorial(h+w+1)",
"Factorial(h+w+1)",
"fact",
"h,w,a,b = map(int, input().split())",
"map(int, input().split())",
"h"
] | class Factorial:
def __init__(self, n, mod=10**9+7):
self.fac = [0] * (n+1)
self.ifac = [0] * (n+1)
self.fac[0] = 1
self.ifac[0] = 1
self.mod = mod
modmod = self.mod - 2
for i in range(n):
self.fac[i+1] = self.fac[i] * (i+1) % self.mod
self.ifac[i+1] = self.ifac[i] * pow(i+1, modmod, self.mod) % self.mod
def comb(self, n, r):
if n == 0 and r == 0:
return 1
if n < r or n < 0:
return 0
tmp = self.ifac[n-r] * self.ifac[r] % self.mod
return tmp * self.fac[n] % self.mod
def perm(self, n, r):
if n == 0 and r == 0:
return 1
if n < r or n < 0:
return 0
return (self.fac[n] * self.ifac[n-r]) % self.mod
h,w,a,b = map(int, input().split())
mod = 10**9+7
fact = Factorial(h+w+1)
ans = 0
c,d = h-a, w-b
for i in range(b+1, w+1):
d = w-i+1
# print(i,i+c-2, c-1, fact.comb(i+c-2, c-1), fact.comb(a+d-2, a-1))
ans = (ans + fact.comb(i+c-2, c-1) * fact.comb(a+d-2, a-1)) % mod
print(ans)
|
[
7,
0,
13,
4,
13,
13,
4,
18,
4,
13,
13,
13,
13,
13,
0,
13,
2,
39,
17,
17,
0,
13,
2,
39,
17,
17,
0,
18,
13,
17,
17,
0,
13,
17,
28,
13,
4,
13,
17,
17,
0,
18,
13,
13,
2,
2,
18,
13,
2,
13,
17,
13,
17,
0,
18,
13,
17,
4,
13,
18,
13,
17,
17,
17,
28,
13,
4,
13,
17,
17,
17,
0,
18,
13,
13,
2,
2,
18,
13,
2,
13,
17,
2,
13,
17,
17,
0,
18,
13,
17,
17,
28,
13,
4,
13,
2,
13,
13,
14,
2,
13,
17,
14,
2,
13,
17,
0,
13,
17,
0,
13,
2,
2,
2,
18,
13,
2,
2,
2,
2,
13,
13,
13,
17,
13,
18,
13,
2,
2,
13,
17,
13,
18,
13,
2,
2,
13,
17,
13,
17,
0,
13,
2,
2,
2,
2,
18,
13,
2,
2,
13,
17,
13,
18,
13,
2,
13,
17,
18,
13,
13,
17,
2,
2,
2,
18,
13,
2,
2,
2,
2,
13,
13,
13,
17,
13,
18,
13,
2,
2,
13,
13,
17,
18,
13,
2,
2,
13,
17,
13,
17,
0,
13,
2,
2,
13,
13,
17,
4,
13,
13,
10,
2,
13,
10,
2,
13,
10,
2,
13,
10,
4,
13,
10,
2,
13,
10,
17,
13,
10,
17,
13,
10,
4,
13,
10,
2,
13,
10,
4,
13,
10,
4,
13
] | [
[
232,
2
],
[
232,
11
],
[
232,
12
],
[
232,
13
],
[
208,
15
],
[
214,
21
],
[
30,
27
],
[
209,
28
],
[
220,
32
],
[
36,
35
],
[
44,
41
],
[
209,
42
],
[
35,
43
],
[
209,
47
],
[
35,
49
],
[
35,
51
],
[
57,
54
],
[
215,
55
],
[
209,
60
],
[
66,
65
],
[
75,
72
],
[
215,
73
],
[
65,
74
],
[
215,
78
],
[
65,
80
],
[
65,
83
],
[
90,
87
],
[
215,
88
],
[
93,
92
],
[
212,
96
],
[
230,
97
],
[
92,
100
],
[
212,
104
],
[
217,
107
],
[
202,
110
],
[
209,
115
],
[
224,
120
],
[
233,
121
],
[
212,
122
],
[
92,
124
],
[
215,
126
],
[
224,
129
],
[
233,
131
],
[
215,
133
],
[
212,
136
],
[
92,
138
],
[
205,
141
],
[
209,
147
],
[
233,
150
],
[
92,
152
],
[
215,
154
],
[
233,
156
],
[
72,
158
],
[
215,
159
],
[
92,
160
],
[
209,
166
],
[
224,
171
],
[
233,
172
],
[
212,
173
],
[
92,
175
],
[
215,
177
],
[
224,
180
],
[
233,
181
],
[
215,
184
],
[
212,
187
],
[
92,
189
],
[
226,
192
],
[
221,
195
],
[
227,
195
],
[
206,
196
],
[
203,
196
],
[
218,
196
],
[
227,
200
],
[
221,
200
],
[
202,
203
],
[
205,
206
],
[
208,
209
],
[
232,
212
],
[
214,
215
],
[
217,
218
],
[
220,
221
],
[
232,
224
],
[
226,
227
],
[
232,
230
],
[
232,
233
]
] | [
"h,w,a,b=map(int,input().split())\nfac=[0]*200001#iの階乗mod(1000000007)\ninv=[0]*200001#iの逆元mod(1000000007)\nfac[0]=1\nans=0\nfor i in range(1,200001):\n fac[i]=fac[i-1]*i%1000000007\ninv[200000]=pow(fac[200000],1000000005,1000000007)\nfor i in range(199999,0,-1):\n inv[i]=(inv[i+1]*(i+1))%1000000007\n inv[0]=1\nfor i in range(h-a):\n if i==0:\n if h==1:\n x=1\n else:\n x=(fac[w-b+h-2\n -i]*inv[w-1-b]*inv[h-1-i])%1000000007\n else:\n x=((fac[b-1+i]*inv[b-1]*inv[i])%1000000007)*((fac[w-b+h-2-i]*inv[w-b-1]*inv[h-1-i])%1000000007)\n ans=(ans+x)%1000000007\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",
"fac=[0]*200001",
"fac",
"[0]*200001",
"[0]",
"0",
"200001",
"inv=[0]*200001",
"inv",
"[0]*200001",
"[0]",
"0",
"200001",
"fac[0]=1",
"fac[0]",
"fac",
"0",
"1",
"ans=0",
"ans",
"0",
"for i in range(1,200001):\n fac[i]=fac[i-1]*i%1000000007",
"i",
"range(1,200001)",
"range",
"1",
"200001",
"fac[i]=fac[i-1]*i%1000000007",
"fac[i]",
"fac",
"i",
"fac[i-1]*i%1000000007",
"fac[i-1]*i",
"fac[i-1]",
"fac",
"i-1",
"i",
"1",
"i",
"1000000007",
"inv[200000]=pow(fac[200000],1000000005,1000000007)",
"inv[200000]",
"inv",
"200000",
"pow(fac[200000],1000000005,1000000007)",
"pow",
"fac[200000]",
"fac",
"200000",
"1000000005",
"1000000007",
"for i in range(199999,0,-1):\n inv[i]=(inv[i+1]*(i+1))%1000000007\n inv[0]=1",
"i",
"range(199999,0,-1)",
"range",
"199999",
"0",
"-1",
"inv[i]=(inv[i+1]*(i+1))%1000000007",
"inv[i]",
"inv",
"i",
"(inv[i+1]*(i+1))%1000000007",
"inv[i+1]*(i+1)",
"inv[i+1]",
"inv",
"i+1",
"i",
"1",
"i+1",
"i",
"1",
"1000000007",
"inv[0]=1",
"inv[0]",
"inv",
"0",
"1",
"for i in range(h-a):\n if i==0:\n if h==1:\n x=1\n else:\n x=(fac[w-b+h-2\n -i]*inv[w-1-b]*inv[h-1-i])%1000000007\n else:\n x=((fac[b-1+i]*inv[b-1]*inv[i])%1000000007)*((fac[w-b+h-2-i]*inv[w-b-1]*inv[h-1-i])%1000000007)\n ans=(ans+x)%1000000007",
"i",
"range(h-a)",
"range",
"h-a",
"h",
"a",
"if i==0:\n if h==1:\n x=1\n else:\n x=(fac[w-b+h-2\n -i]*inv[w-1-b]*inv[h-1-i])%1000000007\n else:\n x=((fac[b-1+i]*inv[b-1]*inv[i])%1000000007)*((fac[w-b+h-2-i]*inv[w-b-1]*inv[h-1-i])%1000000007)\n ",
"i==0",
"i",
"0",
"if h==1:\n x=1\n else:\n x=(fac[w-b+h-2\n -i]*inv[w-1-b]*inv[h-1-i])%1000000007\n ",
"h==1",
"h",
"1",
"x=1",
"x",
"1",
"x=(fac[w-b+h-2\n -i]*inv[w-1-b]*inv[h-1-i])%1000000007",
"x",
"(fac[w-b+h-2\n -i]*inv[w-1-b]*inv[h-1-i])%1000000007",
"fac[w-b+h-2\n -i]*inv[w-1-b]*inv[h-1-i]",
"fac[w-b+h-2\n -i]*inv[w-1-b]",
"fac[w-b+h-2\n -i]",
"fac",
"w-b+h-2\n -i",
"w-b+h-2",
"w-b+h",
"w-b",
"w",
"b",
"h",
"2",
"i",
"inv[w-1-b]",
"inv",
"w-1-b",
"w-1",
"w",
"1",
"b",
"inv[h-1-i]",
"inv",
"h-1-i",
"h-1",
"h",
"1",
"i",
"1000000007",
"x=((fac[b-1+i]*inv[b-1]*inv[i])%1000000007)*((fac[w-b+h-2-i]*inv[w-b-1]*inv[h-1-i])%1000000007)",
"x",
"((fac[b-1+i]*inv[b-1]*inv[i])%1000000007)*((fac[w-b+h-2-i]*inv[w-b-1]*inv[h-1-i])%1000000007)",
"(fac[b-1+i]*inv[b-1]*inv[i])%1000000007",
"fac[b-1+i]*inv[b-1]*inv[i]",
"fac[b-1+i]*inv[b-1]",
"fac[b-1+i]",
"fac",
"b-1+i",
"b-1",
"b",
"1",
"i",
"inv[b-1]",
"inv",
"b-1",
"b",
"1",
"inv[i]",
"inv",
"i",
"1000000007",
"(fac[w-b+h-2-i]*inv[w-b-1]*inv[h-1-i])%1000000007",
"fac[w-b+h-2-i]*inv[w-b-1]*inv[h-1-i]",
"fac[w-b+h-2-i]*inv[w-b-1]",
"fac[w-b+h-2-i]",
"fac",
"w-b+h-2-i",
"w-b+h-2",
"w-b+h",
"w-b",
"w",
"b",
"h",
"2",
"i",
"inv[w-b-1]",
"inv",
"w-b-1",
"w-b",
"w",
"b",
"1",
"inv[h-1-i]",
"inv",
"h-1-i",
"h-1",
"h",
"1",
"i",
"1000000007",
"ans=(ans+x)%1000000007",
"ans",
"(ans+x)%1000000007",
"ans+x",
"ans",
"x",
"1000000007",
"print(ans)",
"print",
"ans",
"x=(fac[w-b+h-2\n -i]*inv[w-1-b]*inv[h-1-i])%1000000007",
"(fac[w-b+h-2\n -i]*inv[w-1-b]*inv[h-1-i])%1000000007",
"x",
"x=((fac[b-1+i]*inv[b-1]*inv[i])%1000000007)*((fac[w-b+h-2-i]*inv[w-b-1]*inv[h-1-i])%1000000007)",
"((fac[b-1+i]*inv[b-1]*inv[i])%1000000007)*((fac[w-b+h-2-i]*inv[w-b-1]*inv[h-1-i])%1000000007)",
"x",
"fac=[0]*200001",
"[0]*200001",
"fac",
"h,w,a,b=map(int,input().split())",
"map(int,input().split())",
"h",
"inv=[0]*200001",
"[0]*200001",
"inv",
"x=1",
"1",
"x",
"ans=0",
"0",
"ans",
"w,a,b=map(int,input().split())",
"map(int,input().split())",
"w",
"ans=(ans+x)%1000000007",
"(ans+x)%1000000007",
"ans",
"a,b=map(int,input().split())",
"map(int,input().split())",
"a",
"b=map(int,input().split())",
"map(int,input().split())",
"b"
] | h,w,a,b=map(int,input().split())
fac=[0]*200001#iの階乗mod(1000000007)
inv=[0]*200001#iの逆元mod(1000000007)
fac[0]=1
ans=0
for i in range(1,200001):
fac[i]=fac[i-1]*i%1000000007
inv[200000]=pow(fac[200000],1000000005,1000000007)
for i in range(199999,0,-1):
inv[i]=(inv[i+1]*(i+1))%1000000007
inv[0]=1
for i in range(h-a):
if i==0:
if h==1:
x=1
else:
x=(fac[w-b+h-2
-i]*inv[w-1-b]*inv[h-1-i])%1000000007
else:
x=((fac[b-1+i]*inv[b-1]*inv[i])%1000000007)*((fac[w-b+h-2-i]*inv[w-b-1]*inv[h-1-i])%1000000007)
ans=(ans+x)%1000000007
print(ans)
|
[
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,
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,
4,
18,
13,
13,
4,
13,
18,
13,
17,
2,
13,
17,
13,
12,
13,
14,
2,
2,
13,
13,
2,
13,
17,
29,
17,
14,
2,
13,
17,
29,
17,
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,
13,
13,
0,
13,
2,
2,
4,
13,
2,
2,
2,
13,
13,
17,
13,
13,
4,
13,
2,
2,
2,
2,
13,
17,
13,
13,
17,
2,
13,
17,
13,
0,
13,
13,
4,
13,
2,
13,
13,
10,
4,
13,
10,
39,
13,
10,
12,
13,
10,
2,
13,
10,
13,
13,
10,
39,
13,
10,
4,
13,
10,
2,
13,
10,
17,
13,
10,
4,
13,
10,
4,
13
] | [
[
178,
2
],
[
178,
11
],
[
178,
12
],
[
178,
13
],
[
169,
15
],
[
163,
22
],
[
151,
26
],
[
31,
30
],
[
167,
36
],
[
149,
37
],
[
164,
41
],
[
164,
46
],
[
30,
48
],
[
170,
49
],
[
152,
52
],
[
164,
57
],
[
170,
60
],
[
170,
62
],
[
98,
68
],
[
100,
69
],
[
100,
71
],
[
100,
77
],
[
164,
86
],
[
98,
87
],
[
152,
89
],
[
100,
90
],
[
152,
92
],
[
98,
94
],
[
100,
95
],
[
170,
96
],
[
98,
98
],
[
100,
100
],
[
172,
102
],
[
106,
105
],
[
176,
108
],
[
149,
109
],
[
157,
111
],
[
155,
115
],
[
167,
119
],
[
179,
120
],
[
105,
122
],
[
105,
123
],
[
155,
125
],
[
179,
130
],
[
149,
132
],
[
105,
133
],
[
179,
136
],
[
170,
138
],
[
160,
140
],
[
170,
141
],
[
161,
145
],
[
158,
145
],
[
173,
145
],
[
170,
146
],
[
178,
149
],
[
151,
152
],
[
157,
158
],
[
170,
160
],
[
160,
161
],
[
163,
164
],
[
178,
167
],
[
169,
170
],
[
172,
173
],
[
178,
176
],
[
178,
179
]
] | [
"H, W, A, B = map(int, input().split())\nMOD = 10 ** 9 + 7\n\n# 階乗 & 逆元計算\nfactorial = [1]\ninverse = [1]\nfor i in range(1, H + W + 2):\n factorial.append(factorial[-1] * i % MOD)\n inverse.append(pow(factorial[-1], MOD - 2, MOD))\n\n\n# 組み合わせ計算\ndef nCr(n, r):\n if n < r or r < 0:\n return 0\n elif r == 0:\n return 1\n return factorial[n] * inverse[r] * inverse[n - r] % MOD\n\n\nans = 0\nfor w in range(B, W):\n ans += nCr(H - A - 1 + w, w) * nCr(A - 1 + W - w - 1, 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",
"factorial = [1]",
"factorial",
"[1]",
"1",
"inverse = [1]",
"inverse",
"[1]",
"1",
"for i in range(1, H + W + 2):\n factorial.append(factorial[-1] * i % MOD)\n inverse.append(pow(factorial[-1], MOD - 2, MOD))\n\n\n# 組み合わせ計算",
"i",
"range(1, H + W + 2)",
"range",
"1",
"H + W + 2",
"H + W",
"H",
"W",
"2",
"factorial.append(factorial[-1] * i % MOD)",
"factorial.append",
"factorial",
"append",
"factorial[-1] * i % MOD",
"factorial[-1] * i",
"factorial[-1]",
"factorial",
"-1",
"i",
"MOD",
"inverse.append(pow(factorial[-1], MOD - 2, MOD))",
"inverse.append",
"inverse",
"append",
"pow(factorial[-1], MOD - 2, MOD)",
"pow",
"factorial[-1]",
"factorial",
"-1",
"MOD - 2",
"MOD",
"2",
"MOD",
"def nCr(n, r):\n if n < r or r < 0:\n return 0\n elif r == 0:\n return 1\n return factorial[n] * inverse[r] * inverse[n - r] % MOD",
"nCr",
"if n < r or r < 0:\n return 0\n elif r == 0:\n return 1\n ",
"n < r or r < 0",
"n < r",
"n",
"r",
"r < 0",
"r",
"0",
"return 0",
"0",
"elif r == 0:\n return 1\n ",
"r == 0",
"r",
"0",
"return 1",
"1",
"return factorial[n] * inverse[r] * inverse[n - r] % MOD",
"factorial[n] * inverse[r] * inverse[n - r] % MOD",
"factorial[n] * inverse[r] * inverse[n - r]",
"factorial[n] * inverse[r]",
"factorial[n]",
"factorial",
"n",
"inverse[r]",
"inverse",
"r",
"inverse[n - r]",
"inverse",
"n - r",
"n",
"r",
"MOD",
"n",
"n",
"r",
"r",
"ans = 0",
"ans",
"0",
"for w in range(B, W):\n ans += nCr(H - A - 1 + w, w) * nCr(A - 1 + W - w - 1, A - 1) % MOD\n ans %= MOD",
"w",
"range(B, W)",
"range",
"B",
"W",
"ans += nCr(H - A - 1 + w, w) * nCr(A - 1 + W - w - 1, A - 1) % MOD",
"ans",
"nCr(H - A - 1 + w, w) * nCr(A - 1 + W - w - 1, A - 1) % MOD",
"nCr(H - A - 1 + w, w) * nCr(A - 1 + W - w - 1, A - 1)",
"nCr(H - A - 1 + w, w)",
"nCr",
"H - A - 1 + w",
"H - A - 1",
"H - A",
"H",
"A",
"1",
"w",
"w",
"nCr(A - 1 + W - w - 1, A - 1)",
"nCr",
"A - 1 + W - w - 1",
"A - 1 + W - w",
"A - 1 + W",
"A - 1",
"A",
"1",
"W",
"w",
"1",
"A - 1",
"A",
"1",
"MOD",
"ans %= MOD",
"ans",
"MOD",
"print(ans % MOD)",
"print",
"ans % MOD",
"ans",
"MOD",
"W, A, B = map(int, input().split())",
"map(int, input().split())",
"W",
"inverse = [1]",
"[1]",
"inverse",
"def nCr(n, r):\n if n < r or r < 0:\n return 0\n elif r == 0:\n return 1\n return factorial[n] * inverse[r] * inverse[n - r] % MOD",
"def nCr(n, r):\n if n < r or r < 0:\n return 0\n elif r == 0:\n return 1\n return factorial[n] * inverse[r] * inverse[n - r] % MOD",
"nCr",
"ans += nCr(H - A - 1 + w, w) * nCr(A - 1 + W - w - 1, A - 1) % MOD",
"nCr(H - A - 1 + w, w) * nCr(A - 1 + W - w - 1, A - 1) % MOD",
"ans",
"ans %= MOD",
"MOD",
"ans",
"factorial = [1]",
"[1]",
"factorial",
"H, W, A, B = map(int, input().split())",
"map(int, input().split())",
"H",
"MOD = 10 ** 9 + 7",
"10 ** 9 + 7",
"MOD",
"ans = 0",
"0",
"ans",
"B = map(int, input().split())",
"map(int, input().split())",
"B",
"A, B = map(int, input().split())",
"map(int, input().split())",
"A"
] | H, W, A, B = map(int, input().split())
MOD = 10 ** 9 + 7
# 階乗 & 逆元計算
factorial = [1]
inverse = [1]
for i in range(1, H + W + 2):
factorial.append(factorial[-1] * i % MOD)
inverse.append(pow(factorial[-1], MOD - 2, MOD))
# 組み合わせ計算
def nCr(n, r):
if n < r or r < 0:
return 0
elif r == 0:
return 1
return factorial[n] * inverse[r] * inverse[n - r] % MOD
ans = 0
for w in range(B, W):
ans += nCr(H - A - 1 + w, w) * nCr(A - 1 + W - w - 1, A - 1) % MOD
ans %= MOD
print(ans % MOD)
|
[
7,
0,
13,
4,
13,
13,
4,
18,
4,
13,
13,
13,
13,
13,
0,
13,
4,
13,
2,
17,
17,
0,
13,
2,
13,
17,
0,
13,
2,
13,
13,
13,
2,
13,
13,
0,
13,
39,
42,
40,
13,
17,
0,
13,
2,
39,
2,
13,
17,
18,
13,
39,
0,
13,
17,
0,
13,
17,
0,
13,
39,
17,
0,
13,
39,
28,
13,
4,
13,
2,
13,
13,
4,
18,
13,
13,
2,
2,
2,
13,
17,
18,
13,
13,
13,
28,
13,
4,
13,
13,
0,
13,
17,
28,
13,
4,
13,
4,
13,
13,
14,
2,
18,
13,
13,
17,
0,
13,
18,
13,
13,
0,
13,
13,
14,
40,
13,
2,
4,
13,
13,
17,
0,
13,
13,
0,
13,
13,
4,
18,
13,
13,
13,
0,
13,
17,
0,
13,
17,
28,
13,
4,
13,
4,
13,
13,
14,
2,
18,
13,
13,
17,
0,
13,
18,
13,
2,
13,
17,
0,
13,
13,
0,
13,
18,
13,
2,
2,
13,
13,
17,
0,
13,
13,
14,
40,
13,
2,
4,
13,
13,
17,
0,
13,
13,
0,
13,
13,
0,
13,
13,
0,
13,
13,
28,
13,
4,
13,
13,
0,
13,
2,
2,
2,
2,
18,
13,
2,
2,
13,
13,
17,
18,
13,
2,
2,
2,
13,
13,
13,
17,
18,
13,
13,
18,
13,
2,
2,
13,
13,
17,
13,
0,
13,
13,
4,
13,
2,
2,
2,
13,
13,
13,
13,
10,
17,
13,
10,
17,
13,
10,
18,
13,
10,
39,
13,
10,
4,
13,
10,
4,
13,
10,
4,
13,
10,
17,
13,
10,
39,
13,
10,
2,
13,
10,
13,
13,
10,
17,
13,
10,
13,
13,
10,
2,
13,
10,
18,
13,
10,
13,
13,
10,
2,
13,
10,
13,
13,
10,
13,
13,
10,
13,
13,
10,
39,
13,
10,
17,
13,
10,
18,
13,
10,
2,
13,
10,
2,
13,
10,
13,
13,
10,
13,
13,
10,
4,
13,
10,
13,
13,
10,
4,
13,
10,
13,
13
] | [
[
326,
2
],
[
326,
11
],
[
326,
12
],
[
326,
13
],
[
332,
15
],
[
272,
22
],
[
333,
24
],
[
284,
27
],
[
261,
29
],
[
258,
30
],
[
317,
31
],
[
327,
33
],
[
264,
34
],
[
269,
36
],
[
273,
40
],
[
267,
40
],
[
293,
43
],
[
273,
47
],
[
267,
47
],
[
270,
50
],
[
294,
50
],
[
266,
53
],
[
308,
56
],
[
254,
59
],
[
305,
63
],
[
67,
66
],
[
261,
70
],
[
327,
71
],
[
255,
74
],
[
66,
79
],
[
255,
82
],
[
66,
83
],
[
333,
84
],
[
87,
86
],
[
261,
89
],
[
278,
91
],
[
95,
94
],
[
294,
99
],
[
270,
99
],
[
294,
103
],
[
270,
103
],
[
94,
104
],
[
287,
107
],
[
255,
109
],
[
86,
110
],
[
329,
112
],
[
333,
113
],
[
94,
116
],
[
294,
120
],
[
270,
120
],
[
302,
123
],
[
303,
124
],
[
330,
124
],
[
288,
124
],
[
279,
124
],
[
336,
124
],
[
335,
126
],
[
333,
127
],
[
306,
130
],
[
336,
132
],
[
303,
132
],
[
330,
132
],
[
288,
132
],
[
279,
132
],
[
248,
134
],
[
245,
137
],
[
141,
140
],
[
294,
145
],
[
270,
145
],
[
294,
149
],
[
270,
149
],
[
140,
150
],
[
311,
153
],
[
255,
155
],
[
264,
157
],
[
281,
160
],
[
333,
161
],
[
251,
163
],
[
255,
165
],
[
327,
168
],
[
264,
169
],
[
320,
172
],
[
333,
173
],
[
140,
176
],
[
294,
180
],
[
270,
180
],
[
275,
183
],
[
276,
184
],
[
282,
184
],
[
312,
184
],
[
249,
184
],
[
297,
184
],
[
296,
186
],
[
333,
187
],
[
299,
189
],
[
300,
190
],
[
321,
190
],
[
252,
190
],
[
246,
190
],
[
291,
190
],
[
290,
192
],
[
333,
193
],
[
196,
195
],
[
285,
198
],
[
314,
200
],
[
255,
206
],
[
195,
209
],
[
264,
210
],
[
255,
213
],
[
261,
217
],
[
318,
218
],
[
195,
219
],
[
306,
222
],
[
195,
223
],
[
306,
225
],
[
261,
228
],
[
195,
229
],
[
333,
231
],
[
323,
233
],
[
333,
234
],
[
324,
240
],
[
315,
240
],
[
309,
240
],
[
297,
241
],
[
276,
241
],
[
282,
241
],
[
312,
241
],
[
249,
241
],
[
291,
242
],
[
300,
242
],
[
321,
242
],
[
252,
242
],
[
246,
242
],
[
333,
243
],
[
245,
246
],
[
248,
249
],
[
251,
252
],
[
254,
255
],
[
326,
258
],
[
326,
261
],
[
326,
264
],
[
266,
267
],
[
269,
270
],
[
272,
273
],
[
276,
275
],
[
282,
275
],
[
312,
275
],
[
249,
275
],
[
297,
275
],
[
275,
276
],
[
278,
279
],
[
333,
281
],
[
281,
282
],
[
284,
285
],
[
287,
288
],
[
333,
290
],
[
290,
291
],
[
293,
294
],
[
333,
296
],
[
296,
297
],
[
300,
299
],
[
321,
299
],
[
252,
299
],
[
246,
299
],
[
291,
299
],
[
299,
300
],
[
303,
302
],
[
330,
302
],
[
288,
302
],
[
279,
302
],
[
336,
302
],
[
302,
303
],
[
305,
306
],
[
308,
309
],
[
311,
312
],
[
314,
315
],
[
317,
318
],
[
333,
320
],
[
320,
321
],
[
333,
323
],
[
323,
324
],
[
326,
327
],
[
333,
329
],
[
329,
330
],
[
332,
333
],
[
333,
335
],
[
335,
336
]
] | [
"H, W, A, B = map(int, input().split())\nmod = int(1e+9 + 7)\np = mod - 2\nX, Y = H-A, W-B\nL = []\nwhile p != 0:\n L = [p%2] + L[:]\n p //= 2\nS = 0\nfL = [1]\ninvfL = []\nfor i in range(H+W):\n fL.append(((i+1)*fL[i])%mod)\nfor i in range(H):\n invi = 1\n for j in range(len(L)):\n if L[j] == 1:\n invi *= fL[i]\n invi %= mod\n if j != len(L)-1:\n invi *= invi\n invi %= mod\n invfL.append(invi)\ninvB = 1\ninvW = 1\nfor i in range(len(L)):\n if L[i] == 1:\n invB *= fL[B-1]\n invB %= mod\n invW *= fL[W-B-1]\n invW %= mod\n if i != len(L)-1:\n invB *= invB\n invB %= mod\n invW *= invW\n invW %= mod\nfor i in range(X):\n S += (fL[i+B-1]*fL[H+Y-i-2]*invfL[i]*invfL[H-i-1])%mod\n S %= mod\nprint((S*invB*invW)%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 = int(1e+9 + 7)",
"mod",
"int(1e+9 + 7)",
"int",
"1e+9 + 7",
"1e+9",
"7",
"p = mod - 2",
"p",
"mod - 2",
"mod",
"2",
"X, Y = H-A, W-B",
"X",
"H-A",
"H",
"A",
"Y",
"W-B",
"W",
"B",
"L = []",
"L",
"[]",
"while p != 0:\n L = [p%2] + L[:]\n p //= 2",
"p != 0",
"p",
"0",
"L = [p%2] + L[:]",
"L",
"[p%2] + L[:]",
"[p%2]",
"p%2",
"p",
"2",
"L[:]",
"L",
":",
"p //= 2",
"p",
"2",
"S = 0",
"S",
"0",
"fL = [1]",
"fL",
"[1]",
"1",
"invfL = []",
"invfL",
"[]",
"for i in range(H+W):\n fL.append(((i+1)*fL[i])%mod)",
"i",
"range(H+W)",
"range",
"H+W",
"H",
"W",
"fL.append(((i+1)*fL[i])%mod)",
"fL.append",
"fL",
"append",
"((i+1)*fL[i])%mod",
"(i+1)*fL[i]",
"i+1",
"i",
"1",
"fL[i]",
"fL",
"i",
"mod",
"for i in range(H):\n invi = 1\n for j in range(len(L)):\n if L[j] == 1:\n invi *= fL[i]\n invi %= mod\n if j != len(L)-1:\n invi *= invi\n invi %= mod\n invfL.append(invi)",
"i",
"range(H)",
"range",
"H",
"invi = 1",
"invi",
"1",
"for j in range(len(L)):\n if L[j] == 1:\n invi *= fL[i]\n invi %= mod\n if j != len(L)-1:\n invi *= invi\n invi %= mod\n ",
"j",
"range(len(L))",
"range",
"len(L)",
"len",
"L",
"if L[j] == 1:\n invi *= fL[i]\n invi %= mod\n ",
"L[j] == 1",
"L[j]",
"L",
"j",
"1",
"invi *= fL[i]",
"invi",
"fL[i]",
"fL",
"i",
"invi %= mod",
"invi",
"mod",
"if j != len(L)-1:\n invi *= invi\n invi %= mod\n ",
"j != len(L)-1",
"j",
"len(L)-1",
"len(L)",
"len",
"L",
"1",
"invi *= invi",
"invi",
"invi",
"invi %= mod",
"invi",
"mod",
"invfL.append(invi)",
"invfL.append",
"invfL",
"append",
"invi",
"invB = 1",
"invB",
"1",
"invW = 1",
"invW",
"1",
"for i in range(len(L)):\n if L[i] == 1:\n invB *= fL[B-1]\n invB %= mod\n invW *= fL[W-B-1]\n invW %= mod\n if i != len(L)-1:\n invB *= invB\n invB %= mod\n invW *= invW\n invW %= mod",
"i",
"range(len(L))",
"range",
"len(L)",
"len",
"L",
"if L[i] == 1:\n invB *= fL[B-1]\n invB %= mod\n invW *= fL[W-B-1]\n invW %= mod\n ",
"L[i] == 1",
"L[i]",
"L",
"i",
"1",
"invB *= fL[B-1]",
"invB",
"fL[B-1]",
"fL",
"B-1",
"B",
"1",
"invB %= mod",
"invB",
"mod",
"invW *= fL[W-B-1]",
"invW",
"fL[W-B-1]",
"fL",
"W-B-1",
"W-B",
"W",
"B",
"1",
"invW %= mod",
"invW",
"mod",
"if i != len(L)-1:\n invB *= invB\n invB %= mod\n invW *= invW\n invW %= mod",
"i != len(L)-1",
"i",
"len(L)-1",
"len(L)",
"len",
"L",
"1",
"invB *= invB",
"invB",
"invB",
"invB %= mod",
"invB",
"mod",
"invW *= invW",
"invW",
"invW",
"invW %= mod",
"invW",
"mod",
"for i in range(X):\n S += (fL[i+B-1]*fL[H+Y-i-2]*invfL[i]*invfL[H-i-1])%mod\n S %= mod",
"i",
"range(X)",
"range",
"X",
"S += (fL[i+B-1]*fL[H+Y-i-2]*invfL[i]*invfL[H-i-1])%mod",
"S",
"(fL[i+B-1]*fL[H+Y-i-2]*invfL[i]*invfL[H-i-1])%mod",
"fL[i+B-1]*fL[H+Y-i-2]*invfL[i]*invfL[H-i-1]",
"fL[i+B-1]*fL[H+Y-i-2]*invfL[i]",
"fL[i+B-1]*fL[H+Y-i-2]",
"fL[i+B-1]",
"fL",
"i+B-1",
"i+B",
"i",
"B",
"1",
"fL[H+Y-i-2]",
"fL",
"H+Y-i-2",
"H+Y-i",
"H+Y",
"H",
"Y",
"i",
"2",
"invfL[i]",
"invfL",
"i",
"invfL[H-i-1]",
"invfL",
"H-i-1",
"H-i",
"H",
"i",
"1",
"mod",
"S %= mod",
"S",
"mod",
"print((S*invB*invW)%mod)",
"print",
"(S*invB*invW)%mod",
"S*invB*invW",
"S*invB",
"S",
"invB",
"invW",
"mod",
"invW = 1",
"1",
"invW",
"invB = 1",
"1",
"invB",
"invW *= fL[W-B-1]",
"fL[W-B-1]",
"invW",
"fL = [1]",
"[1]",
"fL",
"A, B = map(int, input().split())",
"map(int, input().split())",
"A",
"H, W, A, B = map(int, input().split())",
"map(int, input().split())",
"H",
"B = map(int, input().split())",
"map(int, input().split())",
"B",
"p //= 2",
"2",
"p",
"L = []",
"[]",
"L",
"p = mod - 2",
"mod - 2",
"p",
"invB *= invB",
"invB",
"invB",
"invi = 1",
"1",
"invi",
"invB %= mod",
"mod",
"invB",
"X, Y = H-A, W-B",
"H-A",
"X",
"invi *= fL[i]",
"fL[i]",
"invi",
"invW %= mod",
"mod",
"invW",
"L = [p%2] + L[:]",
"[p%2] + L[:]",
"L",
"invB %= mod",
"mod",
"invB",
"invW *= invW",
"invW",
"invW",
"invi *= invi",
"invi",
"invi",
"invfL = []",
"[]",
"invfL",
"S = 0",
"0",
"S",
"invB *= fL[B-1]",
"fL[B-1]",
"invB",
"S += (fL[i+B-1]*fL[H+Y-i-2]*invfL[i]*invfL[H-i-1])%mod",
"(fL[i+B-1]*fL[H+Y-i-2]*invfL[i]*invfL[H-i-1])%mod",
"S",
"Y = H-A, W-B",
"W-B",
"Y",
"invW %= mod",
"mod",
"invW",
"S %= mod",
"mod",
"S",
"W, A, B = map(int, input().split())",
"map(int, input().split())",
"W",
"invi %= mod",
"mod",
"invi",
"mod = int(1e+9 + 7)",
"int(1e+9 + 7)",
"mod",
"invi %= mod",
"mod",
"invi"
] | H, W, A, B = map(int, input().split())
mod = int(1e+9 + 7)
p = mod - 2
X, Y = H-A, W-B
L = []
while p != 0:
L = [p%2] + L[:]
p //= 2
S = 0
fL = [1]
invfL = []
for i in range(H+W):
fL.append(((i+1)*fL[i])%mod)
for i in range(H):
invi = 1
for j in range(len(L)):
if L[j] == 1:
invi *= fL[i]
invi %= mod
if j != len(L)-1:
invi *= invi
invi %= mod
invfL.append(invi)
invB = 1
invW = 1
for i in range(len(L)):
if L[i] == 1:
invB *= fL[B-1]
invB %= mod
invW *= fL[W-B-1]
invW %= mod
if i != len(L)-1:
invB *= invB
invB %= mod
invW *= invW
invW %= mod
for i in range(X):
S += (fL[i+B-1]*fL[H+Y-i-2]*invfL[i]*invfL[H-i-1])%mod
S %= mod
print((S*invB*invW)%mod) |
[
7,
15,
13,
15,
13,
15,
15,
13,
15,
0,
13,
18,
13,
13,
4,
13,
2,
17,
17,
12,
13,
0,
13,
4,
13,
13,
4,
18,
4,
13,
13,
13,
13,
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,
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,
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,
2,
13,
13,
17,
2,
13,
17,
13,
28,
13,
4,
13,
4,
13,
13,
13,
0,
13,
2,
2,
13,
2,
2,
4,
13,
2,
2,
2,
13,
13,
13,
17,
2,
2,
13,
17,
13,
13,
4,
13,
2,
2,
2,
13,
13,
13,
17,
2,
2,
13,
17,
13,
13,
13,
13,
4,
13,
13,
29,
14,
2,
13,
17,
4,
13,
10,
18,
13,
10,
12,
13
] | [
[
224,
10
],
[
23,
22
],
[
225,
29
],
[
23,
31
],
[
23,
32
],
[
23,
33
],
[
36,
35
],
[
43,
42
],
[
50,
49
],
[
55,
54
],
[
60,
59
],
[
102,
68
],
[
102,
71
],
[
100,
72
],
[
77,
76
],
[
102,
79
],
[
100,
81
],
[
102,
82
],
[
49,
88
],
[
100,
89
],
[
54,
91
],
[
76,
92
],
[
102,
92
],
[
54,
94
],
[
100,
96
],
[
76,
97
],
[
102,
97
],
[
104,
98
],
[
100,
100
],
[
102,
102
],
[
104,
104
],
[
107,
106
],
[
42,
111
],
[
49,
115
],
[
49,
120
],
[
106,
122
],
[
35,
123
],
[
59,
126
],
[
59,
132
],
[
35,
134
],
[
106,
135
],
[
35,
137
],
[
106,
138
],
[
35,
139
],
[
54,
142
],
[
54,
147
],
[
59,
150
],
[
35,
152
],
[
155,
154
],
[
64,
156
],
[
22,
159
],
[
31,
160
],
[
22,
163
],
[
35,
165
],
[
168,
167
],
[
32,
172
],
[
33,
173
],
[
176,
175
],
[
154,
178
],
[
175,
178
],
[
64,
182
],
[
33,
186
],
[
22,
187
],
[
32,
188
],
[
33,
192
],
[
167,
194
],
[
35,
195
],
[
64,
197
],
[
32,
201
],
[
31,
202
],
[
33,
203
],
[
32,
207
],
[
167,
209
],
[
35,
210
],
[
35,
211
],
[
35,
212
],
[
175,
215
],
[
154,
215
],
[
228,
222
],
[
224,
225
]
] | [
"import math\n#import numpy as np\nimport queue\nfrom collections import deque,defaultdict\nimport heapq\nfrom sys import stdin,setrecursionlimit\n#from scipy.sparse.csgraph import dijkstra\n#from scipy.sparse import csr_matrix\nipt = stdin.readline\nsetrecursionlimit(10**7)\n\ndef main():\n h,w,a,b = map(int,ipt().split())\n mod = 10**9+7\n\n #nCrをmodで割った余りを求める。Nに最大値を入れて使用。\n N = 2*10**5\n g1 = [1, 1] # 元テーブル\n g2 = [1, 1] #逆元テーブル\n inverse = [0, 1] #逆元テーブル計算用テーブル\n 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 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\n ans = cmb(h+w-2,h-1,mod)\n for i in range(max(a,b)):\n ans = (ans-cmb(b+h-a-1,b-1-i,mod)*cmb(a+w-b-1,a-1-i,mod)%mod)%mod\n print(ans)\n\n\n\n return\n\nif __name__ == '__main__':\n main()",
"import math",
"math",
"import queue",
"queue",
"from collections import deque,defaultdict",
"import heapq",
"heapq",
"from sys import stdin,setrecursionlimit",
"ipt = stdin.readline",
"ipt",
"stdin.readline",
"stdin",
"readline",
"setrecursionlimit(10**7)",
"setrecursionlimit",
"10**7",
"10",
"7",
"def main():\n h,w,a,b = map(int,ipt().split())\n mod = 10**9+7\n\n #nCrをmodで割った余りを求める。Nに最大値を入れて使用。\n N = 2*10**5\n g1 = [1, 1] # 元テーブル\n g2 = [1, 1] #逆元テーブル\n inverse = [0, 1] #逆元テーブル計算用テーブル\n 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 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\n ans = cmb(h+w-2,h-1,mod)\n for i in range(max(a,b)):\n ans = (ans-cmb(b+h-a-1,b-1-i,mod)*cmb(a+w-b-1,a-1-i,mod)%mod)%mod\n print(ans)\n\n\n\n return",
"main",
"h,w,a,b = map(int,ipt().split())",
"h",
"map(int,ipt().split())",
"map",
"int",
"ipt().split()",
"().split",
"()",
"ipt",
"split",
"w",
"a",
"b",
"mod = 10**9+7",
"mod",
"10**9+7",
"10**9",
"10",
"9",
"7",
"N = 2*10**5",
"N",
"2*10**5",
"2",
"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",
"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 ",
"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",
"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\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",
"ans = cmb(h+w-2,h-1,mod)",
"ans",
"cmb(h+w-2,h-1,mod)",
"cmb",
"h+w-2",
"h+w",
"h",
"w",
"2",
"h-1",
"h",
"1",
"mod",
"for i in range(max(a,b)):\n ans = (ans-cmb(b+h-a-1,b-1-i,mod)*cmb(a+w-b-1,a-1-i,mod)%mod)%mod\n ",
"i",
"range(max(a,b))",
"range",
"max(a,b)",
"max",
"a",
"b",
"ans = (ans-cmb(b+h-a-1,b-1-i,mod)*cmb(a+w-b-1,a-1-i,mod)%mod)%mod",
"ans",
"(ans-cmb(b+h-a-1,b-1-i,mod)*cmb(a+w-b-1,a-1-i,mod)%mod)%mod",
"ans-cmb(b+h-a-1,b-1-i,mod)*cmb(a+w-b-1,a-1-i,mod)%mod",
"ans",
"cmb(b+h-a-1,b-1-i,mod)*cmb(a+w-b-1,a-1-i,mod)%mod",
"cmb(b+h-a-1,b-1-i,mod)*cmb(a+w-b-1,a-1-i,mod)",
"cmb(b+h-a-1,b-1-i,mod)",
"cmb",
"b+h-a-1",
"b+h-a",
"b+h",
"b",
"h",
"a",
"1",
"b-1-i",
"b-1",
"b",
"1",
"i",
"mod",
"cmb(a+w-b-1,a-1-i,mod)",
"cmb",
"a+w-b-1",
"a+w-b",
"a+w",
"a",
"w",
"b",
"1",
"a-1-i",
"a-1",
"a",
"1",
"i",
"mod",
"mod",
"mod",
"print(ans)",
"print",
"ans",
"return",
"if __name__ == '__main__':\n main()",
"__name__ == '__main__'",
"__name__",
"'__main__'",
"main()",
"main",
"ipt = stdin.readline",
"stdin.readline",
"ipt",
"def main():\n h,w,a,b = map(int,ipt().split())\n mod = 10**9+7\n\n #nCrをmodで割った余りを求める。Nに最大値を入れて使用。\n N = 2*10**5\n g1 = [1, 1] # 元テーブル\n g2 = [1, 1] #逆元テーブル\n inverse = [0, 1] #逆元テーブル計算用テーブル\n 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 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\n ans = cmb(h+w-2,h-1,mod)\n for i in range(max(a,b)):\n ans = (ans-cmb(b+h-a-1,b-1-i,mod)*cmb(a+w-b-1,a-1-i,mod)%mod)%mod\n print(ans)\n\n\n\n return",
"def main():\n h,w,a,b = map(int,ipt().split())\n mod = 10**9+7\n\n #nCrをmodで割った余りを求める。Nに最大値を入れて使用。\n N = 2*10**5\n g1 = [1, 1] # 元テーブル\n g2 = [1, 1] #逆元テーブル\n inverse = [0, 1] #逆元テーブル計算用テーブル\n 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 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\n ans = cmb(h+w-2,h-1,mod)\n for i in range(max(a,b)):\n ans = (ans-cmb(b+h-a-1,b-1-i,mod)*cmb(a+w-b-1,a-1-i,mod)%mod)%mod\n print(ans)\n\n\n\n return",
"main"
] | import math
#import numpy as np
import queue
from collections import deque,defaultdict
import heapq
from sys import stdin,setrecursionlimit
#from scipy.sparse.csgraph import dijkstra
#from scipy.sparse import csr_matrix
ipt = stdin.readline
setrecursionlimit(10**7)
def main():
h,w,a,b = map(int,ipt().split())
mod = 10**9+7
#nCrをmodで割った余りを求める。Nに最大値を入れて使用。
N = 2*10**5
g1 = [1, 1] # 元テーブル
g2 = [1, 1] #逆元テーブル
inverse = [0, 1] #逆元テーブル計算用テーブル
def cmb(n,r,mod):
if r<0 or r>n :
return 0
r = min(r,n-r)
return g1[n]*g2[r]*g2[n-r]%mod
for i in range(2,N+1):
g1.append((g1[-1]*i)%mod)
inverse.append((-inverse[mod % i]*(mod//i))%mod)
g2.append((g2[-1]*inverse[-1])%mod)
ans = cmb(h+w-2,h-1,mod)
for i in range(max(a,b)):
ans = (ans-cmb(b+h-a-1,b-1-i,mod)*cmb(a+w-b-1,a-1-i,mod)%mod)%mod
print(ans)
return
if __name__ == '__main__':
main()
|
[
7,
15,
13,
0,
13,
2,
4,
13,
17,
17,
17,
4,
18,
13,
13,
4,
13,
17,
17,
12,
13,
14,
2,
13,
17,
14,
2,
13,
17,
14,
2,
2,
13,
17,
17,
23,
13,
23,
13,
12,
13,
29,
2,
2,
2,
13,
13,
2,
13,
13,
13,
23,
13,
23,
13,
12,
13,
29,
4,
13,
13,
4,
13,
13,
2,
13,
17,
23,
13,
23,
13,
12,
13,
29,
4,
13,
13,
4,
13,
13,
23,
13,
23,
13,
12,
13,
0,
13,
13,
13,
17,
13,
17,
42,
13,
0,
13,
2,
13,
13,
0,
13,
2,
13,
2,
13,
13,
13,
2,
13,
2,
13,
13,
0,
13,
13,
13,
13,
13,
13,
13,
13,
0,
13,
13,
29,
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,
13,
13,
18,
13,
13,
18,
13,
2,
13,
13,
13,
23,
13,
23,
13,
0,
13,
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,
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,
13,
4,
13,
4,
13,
2,
2,
13,
13,
17,
13,
4,
13,
2,
2,
2,
2,
2,
13,
17,
13,
13,
17,
13,
2,
2,
13,
17,
13,
13,
4,
13,
13,
10,
39,
13,
10,
12,
13,
10,
12,
13,
10,
4,
13,
10,
12,
13,
10,
39,
13,
10,
12,
13,
10,
39,
13,
10,
4,
13,
10,
2,
13,
10,
12,
13,
10,
4,
13,
10,
12,
13,
10,
17,
13,
10,
2,
13,
10,
2,
13,
10,
4,
13
] | [
[
343,
4
],
[
38,
23
],
[
38,
27
],
[
38,
32
],
[
36,
36
],
[
38,
38
],
[
52,
45
],
[
344,
46
],
[
54,
48
],
[
344,
49
],
[
344,
50
],
[
52,
52
],
[
54,
54
],
[
305,
59
],
[
68,
60
],
[
311,
62
],
[
70,
63
],
[
344,
65
],
[
68,
68
],
[
70,
70
],
[
305,
75
],
[
81,
76
],
[
83,
79
],
[
81,
81
],
[
83,
83
],
[
88,
87
],
[
344,
88
],
[
90,
89
],
[
92,
91
],
[
97,
96
],
[
128,
98
],
[
114,
98
],
[
101,
98
],
[
87,
99
],
[
116,
99
],
[
102,
101
],
[
128,
103
],
[
114,
103
],
[
101,
103
],
[
96,
105
],
[
87,
106
],
[
116,
106
],
[
108,
107
],
[
89,
109
],
[
118,
109
],
[
107,
109
],
[
96,
111
],
[
91,
112
],
[
120,
112
],
[
115,
114
],
[
87,
115
],
[
116,
115
],
[
117,
116
],
[
114,
117
],
[
101,
117
],
[
128,
117
],
[
119,
118
],
[
91,
119
],
[
120,
119
],
[
121,
120
],
[
118,
121
],
[
107,
121
],
[
89,
121
],
[
124,
123
],
[
344,
124
],
[
123,
126
],
[
118,
126
],
[
107,
126
],
[
89,
126
],
[
128,
128
],
[
168,
134
],
[
168,
137
],
[
166,
138
],
[
143,
142
],
[
168,
145
],
[
166,
147
],
[
168,
148
],
[
166,
155
],
[
142,
158
],
[
168,
158
],
[
166,
162
],
[
142,
163
],
[
168,
163
],
[
344,
164
],
[
166,
166
],
[
168,
168
],
[
340,
170
],
[
319,
175
],
[
313,
180
],
[
298,
185
],
[
191,
190
],
[
341,
195
],
[
320,
199
],
[
320,
204
],
[
190,
206
],
[
344,
207
],
[
299,
210
],
[
299,
216
],
[
344,
218
],
[
190,
219
],
[
344,
221
],
[
190,
222
],
[
344,
223
],
[
314,
226
],
[
314,
231
],
[
299,
234
],
[
344,
236
],
[
346,
238
],
[
346,
247
],
[
346,
248
],
[
346,
249
],
[
337,
251
],
[
255,
254
],
[
308,
258
],
[
332,
259
],
[
325,
261
],
[
338,
264
],
[
326,
264
],
[
305,
266
],
[
302,
268
],
[
254,
271
],
[
323,
272
],
[
254,
274
],
[
302,
276
],
[
308,
282
],
[
254,
284
],
[
347,
285
],
[
323,
287
],
[
308,
290
],
[
254,
292
],
[
344,
293
],
[
326,
296
],
[
338,
296
],
[
298,
299
],
[
346,
308
],
[
313,
314
],
[
319,
320
],
[
346,
323
],
[
325,
326
],
[
346,
332
],
[
337,
338
],
[
340,
341
],
[
343,
344
],
[
346,
347
]
] | [
"import sys\nmod = pow(10, 9) + 7\nsys.setrecursionlimit(pow(10, 8))\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-1)//2)**2 * x % mod\n \ndef mul(a, b):\n return ((a % mod) * (b % mod)) % mod\n\ndef div(a, b):\n return mul(a, power(b, mod-2))\ndef div2(a, b):\n return mul(a, modinv(b))\n\ndef modinv(a):\n b, u, v = mod, 1, 0\n while b:\n t = a//b\n a, u = a-t*b, u-t*v\n a, b, u, v = b, a, v, u\n u %= mod\n return u\n\ndef cmb(n, r):\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\nNNN = (10**6)\ng1 = [1, 1]\ng2 = [1, 1]\ninverse = [0, 1]\n\nfor i in range( 2, NNN + 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 )\nH, W, A, B = map(int, input().split())\n\nr = 0\nfor i in range(H-A):\n# (0, 0) -> (i, B-1)\n# (i, B) -> (H-1, W-1)\n r = (r + mul(cmb(i+B-1, i), cmb(H-1-i+W-1-B, H-1-i)))%mod\nprint(r)\n",
"import sys",
"sys",
"mod = pow(10, 9) + 7",
"mod",
"pow(10, 9) + 7",
"pow(10, 9)",
"pow",
"10",
"9",
"7",
"sys.setrecursionlimit(pow(10, 8))",
"sys.setrecursionlimit",
"sys",
"setrecursionlimit",
"pow(10, 8)",
"pow",
"10",
"8",
"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-1)//2)**2 * x % mod\n ",
"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-1)//2)**2 * x % mod\n ",
"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",
"def mul(a, b):\n return ((a % mod) * (b % mod)) % mod",
"mul",
"return ((a % mod) * (b % mod)) % mod",
"((a % mod) * (b % mod)) % mod",
"(a % mod) * (b % mod)",
"a % mod",
"a",
"mod",
"b % mod",
"b",
"mod",
"mod",
"a",
"a",
"b",
"b",
"def div(a, b):\n return mul(a, power(b, mod-2))",
"div",
"return mul(a, power(b, mod-2))",
"mul(a, power(b, mod-2))",
"mul",
"a",
"power(b, mod-2)",
"power",
"b",
"mod-2",
"mod",
"2",
"a",
"a",
"b",
"b",
"def div2(a, b):\n return mul(a, modinv(b))",
"div2",
"return mul(a, modinv(b))",
"mul(a, modinv(b))",
"mul",
"a",
"modinv(b)",
"modinv",
"b",
"a",
"a",
"b",
"b",
"def modinv(a):\n b, u, v = mod, 1, 0\n while b:\n t = a//b\n a, u = a-t*b, u-t*v\n a, b, u, v = b, a, v, u\n u %= mod\n return u",
"modinv",
"b, u, v = mod, 1, 0",
"b",
"mod",
"u",
"1",
"v",
"0",
"while b:\n t = a//b\n a, u = a-t*b, u-t*v\n a, b, u, v = b, a, v, u\n ",
"b",
"t = a//b",
"t",
"a//b",
"a",
"b",
"a, u = a-t*b, u-t*v",
"a",
"a-t*b",
"a",
"t*b",
"t",
"b",
"u",
"u-t*v",
"u",
"t*v",
"t",
"v",
"a, b, u, v = b, a, v, u",
"a",
"b",
"b",
"a",
"u",
"v",
"v",
"u",
"u %= mod",
"u",
"mod",
"return u",
"u",
"a",
"a",
"def cmb(n, r):\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",
"NNN = (10**6)",
"NNN",
"10**6",
"10",
"6",
"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, NNN + 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, NNN + 1 )",
"range",
"2",
"NNN + 1",
"NNN",
"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",
"r = 0",
"r",
"0",
"for i in range(H-A):\n# (0, 0) -> (i, B-1)\n# (i, B) -> (H-1, W-1)\n r = (r + mul(cmb(i+B-1, i), cmb(H-1-i+W-1-B, H-1-i)))%mod",
"i",
"range(H-A)",
"range",
"H-A",
"H",
"A",
"r = (r + mul(cmb(i+B-1, i), cmb(H-1-i+W-1-B, H-1-i)))%mod",
"r",
"(r + mul(cmb(i+B-1, i), cmb(H-1-i+W-1-B, H-1-i)))%mod",
"r + mul(cmb(i+B-1, i), cmb(H-1-i+W-1-B, H-1-i))",
"r",
"mul(cmb(i+B-1, i), cmb(H-1-i+W-1-B, H-1-i))",
"mul",
"cmb(i+B-1, i)",
"cmb",
"i+B-1",
"i+B",
"i",
"B",
"1",
"i",
"cmb(H-1-i+W-1-B, H-1-i)",
"cmb",
"H-1-i+W-1-B",
"H-1-i+W-1",
"H-1-i+W",
"H-1-i",
"H-1",
"H",
"1",
"i",
"W",
"1",
"B",
"H-1-i",
"H-1",
"H",
"1",
"i",
"mod",
"print(r)",
"print",
"r",
"inverse = [0, 1]",
"[0, 1]",
"inverse",
"def cmb(n, r):\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):\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",
"def mul(a, b):\n return ((a % mod) * (b % mod)) % mod",
"def mul(a, b):\n return ((a % mod) * (b % mod)) % mod",
"mul",
"H, W, A, B = map(int, input().split())",
"map(int, input().split())",
"H",
"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-1)//2)**2 * x % mod\n ",
"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-1)//2)**2 * x % mod\n ",
"power",
"g2 = [1, 1]",
"[1, 1]",
"g2",
"def div(a, b):\n return mul(a, power(b, mod-2))",
"def div(a, b):\n return mul(a, power(b, mod-2))",
"div",
"g1 = [1, 1]",
"[1, 1]",
"g1",
"B = map(int, input().split())",
"map(int, input().split())",
"B",
"r = (r + mul(cmb(i+B-1, i), cmb(H-1-i+W-1-B, H-1-i)))%mod",
"(r + mul(cmb(i+B-1, i), cmb(H-1-i+W-1-B, H-1-i)))%mod",
"r",
"def div2(a, b):\n return mul(a, modinv(b))",
"def div2(a, b):\n return mul(a, modinv(b))",
"div2",
"A, B = map(int, input().split())",
"map(int, input().split())",
"A",
"def modinv(a):\n b, u, v = mod, 1, 0\n while b:\n t = a//b\n a, u = a-t*b, u-t*v\n a, b, u, v = b, a, v, u\n u %= mod\n return u",
"def modinv(a):\n b, u, v = mod, 1, 0\n while b:\n t = a//b\n a, u = a-t*b, u-t*v\n a, b, u, v = b, a, v, u\n u %= mod\n return u",
"modinv",
"r = 0",
"0",
"r",
"NNN = (10**6)",
"10**6",
"NNN",
"mod = pow(10, 9) + 7",
"pow(10, 9) + 7",
"mod",
"W, A, B = map(int, input().split())",
"map(int, input().split())",
"W"
] | import sys
mod = pow(10, 9) + 7
sys.setrecursionlimit(pow(10, 8))
def power(x, y):
if y == 0: return 1
elif y == 1 : return x % mod
elif y % 2 == 0 : return power(x, y//2)**2 % mod
else: return power(x, (y-1)//2)**2 * x % mod
def mul(a, b):
return ((a % mod) * (b % mod)) % mod
def div(a, b):
return mul(a, power(b, mod-2))
def div2(a, b):
return mul(a, modinv(b))
def modinv(a):
b, u, v = mod, 1, 0
while b:
t = a//b
a, u = a-t*b, u-t*v
a, b, u, v = b, a, v, u
u %= mod
return u
def cmb(n, r):
if ( r<0 or r>n ):
return 0
r = min(r, n-r)
return g1[n] * g2[r] * g2[n-r] % mod
NNN = (10**6)
g1 = [1, 1]
g2 = [1, 1]
inverse = [0, 1]
for i in range( 2, NNN + 1 ):
g1.append( ( g1[-1] * i ) % mod )
inverse.append( ( -inverse[mod % i] * (mod//i) ) % mod )
g2.append( (g2[-1] * inverse[-1]) % mod )
H, W, A, B = map(int, input().split())
r = 0
for i in range(H-A):
# (0, 0) -> (i, B-1)
# (i, B) -> (H-1, W-1)
r = (r + mul(cmb(i+B-1, i), cmb(H-1-i+W-1-B, H-1-i)))%mod
print(r)
|
[
7,
0,
13,
2,
2,
17,
17,
17,
0,
13,
4,
13,
13,
4,
18,
4,
13,
13,
13,
13,
13,
0,
13,
2,
39,
17,
2,
2,
13,
13,
17,
13,
2,
39,
17,
2,
2,
13,
13,
17,
12,
13,
29,
4,
13,
13,
2,
13,
17,
13,
23,
13,
0,
18,
13,
17,
17,
18,
13,
17,
17,
18,
13,
17,
17,
18,
13,
17,
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,
13,
4,
13,
18,
13,
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,
2,
13,
17,
2,
13,
17,
0,
13,
2,
2,
4,
13,
2,
2,
13,
13,
17,
2,
13,
17,
4,
13,
2,
13,
17,
2,
13,
13,
13,
4,
13,
2,
13,
13,
10,
2,
13,
10,
12,
13,
10,
2,
13,
10,
17,
13,
10,
2,
13,
10,
4,
13,
10,
4,
13,
10,
12,
13,
10,
2,
13,
10,
4,
13,
10,
4,
13
] | [
[
165,
2
],
[
195,
9
],
[
195,
18
],
[
195,
19
],
[
195,
20
],
[
189,
22
],
[
193,
28
],
[
196,
29
],
[
177,
31
],
[
193,
37
],
[
196,
38
],
[
51,
45
],
[
166,
47
],
[
166,
49
],
[
51,
51
],
[
56,
53
],
[
190,
54
],
[
60,
57
],
[
190,
58
],
[
64,
61
],
[
178,
62
],
[
68,
65
],
[
178,
66
],
[
71,
70
],
[
193,
76
],
[
196,
77
],
[
83,
80
],
[
190,
81
],
[
70,
82
],
[
70,
85
],
[
190,
87
],
[
70,
89
],
[
166,
91
],
[
96,
93
],
[
178,
94
],
[
70,
95
],
[
169,
97
],
[
80,
98
],
[
190,
99
],
[
70,
100
],
[
190,
108
],
[
120,
110
],
[
122,
111
],
[
178,
113
],
[
120,
114
],
[
178,
116
],
[
122,
117
],
[
166,
118
],
[
120,
120
],
[
122,
122
],
[
174,
124
],
[
128,
127
],
[
181,
131
],
[
196,
134
],
[
171,
137
],
[
187,
141
],
[
193,
144
],
[
184,
145
],
[
127,
148
],
[
187,
151
],
[
184,
153
],
[
196,
156
],
[
127,
157
],
[
166,
158
],
[
172,
162
],
[
175,
162
],
[
166,
163
],
[
165,
166
],
[
171,
172
],
[
174,
175
],
[
177,
178
],
[
195,
181
],
[
195,
184
],
[
189,
190
],
[
195,
193
],
[
195,
196
]
] | [
"mod=10**9+7\nh,w,a,b=map(int,input().split())\nF,I=[0]*(h+w+2),[0]*(h+w+2)\ndef inv(n):\n return pow(n,mod-2,mod)\nF[0],F[1],I[0],I[1]=1,1,1,1\nfor i in range(2,h+w+2):\n F[i]=i*F[i-1]%mod\n I[i]=inv(F[i])\ndef c(a,b):\n return F[a+b]*I[a]*I[b]%mod\nans=0\nfor i in range(b+1,w+1):\n ans+=(c(h-a-1,i-1)*c(a-1,w-i))%mod\nprint(ans%mod)",
"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",
"F,I=[0]*(h+w+2),[0]*(h+w+2)",
"F",
"[0]*(h+w+2)",
"[0]",
"0",
"h+w+2",
"h+w",
"h",
"w",
"2",
"I",
"[0]*(h+w+2)",
"[0]",
"0",
"h+w+2",
"h+w",
"h",
"w",
"2",
"def inv(n):\n return pow(n,mod-2,mod)",
"inv",
"return pow(n,mod-2,mod)",
"pow(n,mod-2,mod)",
"pow",
"n",
"mod-2",
"mod",
"2",
"mod",
"n",
"n",
"F[0],F[1],I[0],I[1]=1,1,1,1",
"F[0]",
"F",
"0",
"1",
"F[1]",
"F",
"1",
"1",
"I[0]",
"I",
"0",
"1",
"I[1]",
"I",
"1",
"1",
"for i in range(2,h+w+2):\n F[i]=i*F[i-1]%mod\n I[i]=inv(F[i])",
"i",
"range(2,h+w+2)",
"range",
"2",
"h+w+2",
"h+w",
"h",
"w",
"2",
"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",
"I[i]=inv(F[i])",
"I[i]",
"I",
"i",
"inv(F[i])",
"inv",
"F[i]",
"F",
"i",
"def c(a,b):\n return F[a+b]*I[a]*I[b]%mod",
"c",
"return F[a+b]*I[a]*I[b]%mod",
"F[a+b]*I[a]*I[b]%mod",
"F[a+b]*I[a]*I[b]",
"F[a+b]*I[a]",
"F[a+b]",
"F",
"a+b",
"a",
"b",
"I[a]",
"I",
"a",
"I[b]",
"I",
"b",
"mod",
"a",
"a",
"b",
"b",
"ans=0",
"ans",
"0",
"for i in range(b+1,w+1):\n ans+=(c(h-a-1,i-1)*c(a-1,w-i))%mod",
"i",
"range(b+1,w+1)",
"range",
"b+1",
"b",
"1",
"w+1",
"w",
"1",
"ans+=(c(h-a-1,i-1)*c(a-1,w-i))%mod",
"ans",
"(c(h-a-1,i-1)*c(a-1,w-i))%mod",
"c(h-a-1,i-1)*c(a-1,w-i)",
"c(h-a-1,i-1)",
"c",
"h-a-1",
"h-a",
"h",
"a",
"1",
"i-1",
"i",
"1",
"c(a-1,w-i)",
"c",
"a-1",
"a",
"1",
"w-i",
"w",
"i",
"mod",
"print(ans%mod)",
"print",
"ans%mod",
"ans",
"mod",
"mod=10**9+7",
"10**9+7",
"mod",
"def inv(n):\n return pow(n,mod-2,mod)",
"def inv(n):\n return pow(n,mod-2,mod)",
"inv",
"ans+=(c(h-a-1,i-1)*c(a-1,w-i))%mod",
"(c(h-a-1,i-1)*c(a-1,w-i))%mod",
"ans",
"ans=0",
"0",
"ans",
"I=[0]*(h+w+2),[0]*(h+w+2)",
"[0]*(h+w+2)",
"I",
"b=map(int,input().split())",
"map(int,input().split())",
"b",
"a,b=map(int,input().split())",
"map(int,input().split())",
"a",
"def c(a,b):\n return F[a+b]*I[a]*I[b]%mod",
"def c(a,b):\n return F[a+b]*I[a]*I[b]%mod",
"c",
"F,I=[0]*(h+w+2),[0]*(h+w+2)",
"[0]*(h+w+2)",
"F",
"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
h,w,a,b=map(int,input().split())
F,I=[0]*(h+w+2),[0]*(h+w+2)
def inv(n):
return pow(n,mod-2,mod)
F[0],F[1],I[0],I[1]=1,1,1,1
for i in range(2,h+w+2):
F[i]=i*F[i-1]%mod
I[i]=inv(F[i])
def c(a,b):
return F[a+b]*I[a]*I[b]%mod
ans=0
for i in range(b+1,w+1):
ans+=(c(h-a-1,i-1)*c(a-1,w-i))%mod
print(ans%mod) |
[
7,
15,
15,
15,
0,
13,
4,
13,
13,
4,
18,
4,
13,
13,
13,
13,
13,
0,
13,
17,
0,
13,
2,
2,
17,
17,
17,
4,
13,
0,
13,
17,
12,
13,
29,
2,
2,
2,
18,
13,
2,
13,
13,
18,
13,
13,
18,
13,
13,
13,
23,
13,
23,
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,
14,
40,
2,
13,
13,
2,
13,
13,
28,
13,
4,
13,
17,
2,
13,
13,
0,
13,
2,
2,
4,
13,
13,
2,
13,
17,
4,
13,
2,
2,
13,
17,
13,
2,
2,
13,
17,
13,
13,
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,
2,
13,
10,
2,
13,
10,
2,
13,
10,
4,
13,
10,
13,
13,
10,
4,
13,
10,
17,
13,
10,
4,
13,
10,
4,
13,
10,
12,
13,
10,
2,
13
] | [
[
196,
5
],
[
196,
14
],
[
196,
15
],
[
196,
16
],
[
190,
18
],
[
175,
21
],
[
31,
30
],
[
51,
41
],
[
53,
42
],
[
51,
45
],
[
53,
48
],
[
176,
49
],
[
51,
51
],
[
53,
53
],
[
202,
55
],
[
194,
60
],
[
197,
61
],
[
64,
63
],
[
194,
68
],
[
197,
69
],
[
74,
71
],
[
203,
72
],
[
63,
73
],
[
203,
77
],
[
63,
79
],
[
63,
81
],
[
176,
82
],
[
86,
85
],
[
203,
85
],
[
85,
90
],
[
176,
92
],
[
176,
94
],
[
184,
96
],
[
194,
101
],
[
188,
102
],
[
197,
104
],
[
182,
105
],
[
108,
107
],
[
194,
112
],
[
188,
113
],
[
172,
115
],
[
200,
119
],
[
107,
120
],
[
182,
122
],
[
200,
125
],
[
194,
128
],
[
107,
130
],
[
197,
133
],
[
182,
135
],
[
176,
136
],
[
139,
138
],
[
182,
141
],
[
197,
142
],
[
178,
144
],
[
200,
148
],
[
138,
149
],
[
194,
152
],
[
188,
154
],
[
200,
156
],
[
197,
159
],
[
138,
161
],
[
188,
163
],
[
176,
165
],
[
179,
169
],
[
173,
169
],
[
191,
169
],
[
176,
170
],
[
172,
173
],
[
175,
176
],
[
178,
179
],
[
196,
182
],
[
184,
185
],
[
196,
188
],
[
190,
191
],
[
196,
194
],
[
196,
197
],
[
202,
203
]
] | [
"from operator import mul\nfrom functools import reduce\nfrom functools import lru_cache\n\n\nH,W,A,B = map(int,input().split())\nans = 0\nmod = 10**9+7\n\nlru_cache(maxsize=None)\ndef cmb(c, r):\n return fc[c + r] * ic[c] * ic[r] % mod\n \nfc = [1] * (H + W)\nfor i in range(2, H+W):\n fc[i] = fc[i - 1] * i % mod\nic = [pow(x, mod-2, mod) for x in fc]\n \nif H-A <= W-B:\n for i in range(0,H-A):\n ans += cmb(i, B-1) * cmb(H - 1 - i,W - 1 -B ) % mod\nelse:\n for i in range(B, W):\n ans += cmb(i, H - 1 - A) * cmb(W - 1 - i, A - 1) % mod\n \nprint(ans%(mod))",
"from operator import mul",
"from functools import reduce",
"from functools import lru_cache",
"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",
"mod = 10**9+7",
"mod",
"10**9+7",
"10**9",
"10",
"9",
"7",
"lru_cache(maxsize=None)",
"lru_cache",
"maxsize=None",
"maxsize",
"None",
"def cmb(c, r):\n return fc[c + r] * ic[c] * ic[r] % mod\n ",
"cmb",
"return fc[c + r] * ic[c] * ic[r] % mod",
"fc[c + r] * ic[c] * ic[r] % mod",
"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",
"mod",
"c",
"c",
"r",
"r",
"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 % mod",
"i",
"range(2, H+W)",
"range",
"2",
"H+W",
"H",
"W",
"fc[i] = fc[i - 1] * i % mod",
"fc[i]",
"fc",
"i",
"fc[i - 1] * i % mod",
"fc[i - 1] * i",
"fc[i - 1]",
"fc",
"i - 1",
"i",
"1",
"i",
"mod",
"pow(x, mod-2, mod) for x in fc",
"for x in fc",
"x",
"fc",
"for x in fc",
"pow(x, mod-2, mod)",
"pow",
"x",
"mod-2",
"mod",
"2",
"mod",
"ic = [pow(x, mod-2, mod) for x in fc]",
"ic",
"[pow(x, mod-2, mod) for x in fc]",
"if H-A <= W-B:\n for i in range(0,H-A):\n ans += cmb(i, B-1) * cmb(H - 1 - i,W - 1 -B ) % mod\nelse:\n for i in range(B, W):\n ans += cmb(i, H - 1 - A) * cmb(W - 1 - i, A - 1) % mod\n ",
"H-A <= W-B",
"H-A",
"H",
"A",
"W-B",
"W",
"B",
"for i in range(0,H-A):\n ans += cmb(i, B-1) * cmb(H - 1 - i,W - 1 -B ) % mod",
"i",
"range(0,H-A)",
"range",
"0",
"H-A",
"H",
"A",
"ans += cmb(i, B-1) * cmb(H - 1 - i,W - 1 -B ) % mod",
"ans",
"cmb(i, B-1) * cmb(H - 1 - i,W - 1 -B ) % mod",
"cmb(i, B-1) * cmb(H - 1 - i,W - 1 -B )",
"cmb(i, B-1)",
"cmb",
"i",
"B-1",
"B",
"1",
"cmb(H - 1 - i,W - 1 -B )",
"cmb",
"H - 1 - i",
"H - 1",
"H",
"1",
"i",
"W - 1 -B",
"W - 1",
"W",
"1",
"B",
"mod",
"for i in range(B, W):\n ans += cmb(i, H - 1 - A) * cmb(W - 1 - i, A - 1) % mod\n ",
"i",
"range(B, W)",
"range",
"B",
"W",
"ans += cmb(i, H - 1 - A) * cmb(W - 1 - i, A - 1) % mod",
"ans",
"cmb(i, H - 1 - A) * cmb(W - 1 - i, A - 1) % mod",
"cmb(i, H - 1 - A) * cmb(W - 1 - i, A - 1)",
"cmb(i, H - 1 - A)",
"cmb",
"i",
"H - 1 - A",
"H - 1",
"H",
"1",
"A",
"cmb(W - 1 - i, A - 1)",
"cmb",
"W - 1 - i",
"W - 1",
"W",
"1",
"i",
"A - 1",
"A",
"1",
"mod",
"print(ans%(mod))",
"print",
"ans%(mod)",
"ans",
"mod",
"ans += cmb(i, B-1) * cmb(H - 1 - i,W - 1 -B ) % mod",
"cmb(i, B-1) * cmb(H - 1 - i,W - 1 -B ) % mod",
"ans",
"mod = 10**9+7",
"10**9+7",
"mod",
"ans += cmb(i, H - 1 - A) * cmb(W - 1 - i, A - 1) % mod",
"cmb(i, H - 1 - A) * cmb(W - 1 - i, A - 1) % mod",
"ans",
"B = map(int,input().split())",
"map(int,input().split())",
"B",
"ic = [pow(x, mod-2, mod) for x in fc]",
"[pow(x, mod-2, mod) for x in fc]",
"ic",
"A,B = map(int,input().split())",
"map(int,input().split())",
"A",
"ans = 0",
"0",
"ans",
"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",
"def cmb(c, r):\n return fc[c + r] * ic[c] * ic[r] % mod\n ",
"def cmb(c, r):\n return fc[c + r] * ic[c] * ic[r] % mod\n ",
"cmb",
"fc = [1] * (H + W)",
"[1] * (H + W)",
"fc"
] | from operator import mul
from functools import reduce
from functools import lru_cache
H,W,A,B = map(int,input().split())
ans = 0
mod = 10**9+7
lru_cache(maxsize=None)
def cmb(c, r):
return fc[c + r] * ic[c] * ic[r] % mod
fc = [1] * (H + W)
for i in range(2, H+W):
fc[i] = fc[i - 1] * i % mod
ic = [pow(x, mod-2, mod) for x in fc]
if H-A <= W-B:
for i in range(0,H-A):
ans += cmb(i, B-1) * cmb(H - 1 - i,W - 1 -B ) % mod
else:
for i in range(B, W):
ans += cmb(i, H - 1 - A) * cmb(W - 1 - i, A - 1) % mod
print(ans%(mod)) |
[
7,
15,
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,
0,
13,
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,
12,
13,
29,
2,
2,
2,
2,
18,
13,
13,
4,
13,
18,
13,
13,
2,
13,
17,
13,
13,
4,
13,
18,
13,
2,
13,
13,
2,
13,
17,
13,
13,
23,
13,
23,
13,
23,
13,
28,
13,
4,
13,
2,
13,
13,
0,
13,
4,
13,
13,
13,
17,
0,
13,
4,
13,
13,
13,
17,
0,
13,
2,
2,
13,
2,
13,
13,
17,
0,
13,
17,
0,
13,
17,
0,
13,
17,
0,
13,
17,
4,
13,
13,
10,
17,
13,
10,
17,
13,
10,
17,
13,
10,
12,
13,
10,
13,
13,
10,
2,
13,
10,
17,
13,
10,
17,
13,
10,
4,
13,
10,
4,
13,
10,
2,
13,
10,
17,
13,
10,
4,
13,
10,
13,
13,
10,
4,
13,
10,
2,
13,
10,
4,
13,
10,
17,
13,
10,
17,
13,
10,
39,
13,
10,
4,
13,
10,
2,
13
] | [
[
213,
3
],
[
213,
12
],
[
213,
13
],
[
213,
14
],
[
159,
16
],
[
198,
19
],
[
178,
21
],
[
186,
24
],
[
216,
27
],
[
181,
32
],
[
178,
33
],
[
214,
35
],
[
168,
38
],
[
214,
40
],
[
171,
43
],
[
210,
46
],
[
174,
50
],
[
54,
53
],
[
192,
59
],
[
53,
60
],
[
165,
62
],
[
172,
63
],
[
211,
66
],
[
166,
68
],
[
193,
68
],
[
175,
68
],
[
211,
77
],
[
102,
78
],
[
211,
82
],
[
104,
83
],
[
106,
85
],
[
106,
87
],
[
106,
88
],
[
211,
92
],
[
102,
94
],
[
104,
95
],
[
106,
97
],
[
106,
99
],
[
106,
100
],
[
102,
102
],
[
104,
104
],
[
106,
106
],
[
109,
108
],
[
214,
112
],
[
190,
113
],
[
201,
115
],
[
163,
117
],
[
199,
118
],
[
208,
118
],
[
187,
119
],
[
154,
119
],
[
195,
122
],
[
163,
124
],
[
217,
125
],
[
157,
125
],
[
169,
126
],
[
205,
126
],
[
183,
129
],
[
160,
132
],
[
184,
132
],
[
202,
134
],
[
196,
135
],
[
207,
138
],
[
153,
141
],
[
204,
144
],
[
156,
147
],
[
184,
151
],
[
160,
151
],
[
153,
154
],
[
156,
157
],
[
159,
160
],
[
172,
165
],
[
165,
166
],
[
168,
169
],
[
171,
172
],
[
174,
175
],
[
213,
178
],
[
213,
181
],
[
183,
184
],
[
186,
187
],
[
213,
190
],
[
53,
192
],
[
192,
193
],
[
195,
196
],
[
198,
199
],
[
201,
202
],
[
204,
205
],
[
207,
208
],
[
210,
211
],
[
213,
214
],
[
216,
217
]
] | [
"from math import comb\nh,w,a,b = map(int,input().split())\ns = 0\nnC = b-1\nkC = 0\nnD = w-b-1+h-1\nkD = h-1\np = 1000000007\nfac = [1]\nff = 1\nfor i in range(1,200001):\n ff *= i\n ff %= p\n fac.append(ff)\ndef ncr(n, r, p): \n return (fac[n] * pow(fac[r], p-2, p) % p * pow(fac[n-r], p-2, p) % p);\n\nfor i in range(h-a):\n C = ncr(nC, kC, 1000000007)\n D = ncr(nD, kD, 1000000007)\n s = (s + C * D) % 1000000007\n nC += 1\n kC += 1\n kD -= 1\n nD -= 1\nprint(s)",
"from math import comb",
"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",
"p = 1000000007",
"p",
"1000000007",
"fac = [1]",
"fac",
"[1]",
"1",
"ff = 1",
"ff",
"1",
"for i in range(1,200001):\n ff *= i\n ff %= p\n fac.append(ff)",
"i",
"range(1,200001)",
"range",
"1",
"200001",
"ff *= i",
"ff",
"i",
"ff %= p",
"ff",
"p",
"fac.append(ff)",
"fac.append",
"fac",
"append",
"ff",
"def ncr(n, r, p): \n return (fac[n] * pow(fac[r], p-2, p) % p * pow(fac[n-r], p-2, p) % p);",
"ncr",
"return (fac[n] * pow(fac[r], p-2, p) % p * pow(fac[n-r], p-2, p) % p)",
"fac[n] * pow(fac[r], p-2, p) % p * pow(fac[n-r], p-2, p) % p",
"fac[n] * pow(fac[r], p-2, p) % p * pow(fac[n-r], p-2, p)",
"fac[n] * pow(fac[r], p-2, p) % p",
"fac[n] * pow(fac[r], p-2, p)",
"fac[n]",
"fac",
"n",
"pow(fac[r], p-2, p)",
"pow",
"fac[r]",
"fac",
"r",
"p-2",
"p",
"2",
"p",
"p",
"pow(fac[n-r], p-2, p)",
"pow",
"fac[n-r]",
"fac",
"n-r",
"n",
"r",
"p-2",
"p",
"2",
"p",
"p",
"n",
"n",
"r",
"r",
"p",
"p",
"for i in range(h-a):\n C = ncr(nC, kC, 1000000007)\n D = ncr(nD, kD, 1000000007)\n s = (s + C * D) % 1000000007\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, 1000000007)",
"C",
"ncr(nC, kC, 1000000007)",
"ncr",
"nC",
"kC",
"1000000007",
"D = ncr(nD, kD, 1000000007)",
"D",
"ncr(nD, kD, 1000000007)",
"ncr",
"nD",
"kD",
"1000000007",
"s = (s + C * D) % 1000000007",
"s",
"(s + C * D) % 1000000007",
"s + C * D",
"s",
"C * D",
"C",
"D",
"1000000007",
"nC += 1",
"nC",
"1",
"kC += 1",
"kC",
"1",
"kD -= 1",
"kD",
"1",
"nD -= 1",
"nD",
"1",
"print(s)",
"print",
"s",
"kC += 1",
"1",
"kC",
"nD -= 1",
"1",
"nD",
"s = 0",
"0",
"s",
"def ncr(n, r, p): \n return (fac[n] * pow(fac[r], p-2, p) % p * pow(fac[n-r], p-2, p) % p);",
"def ncr(n, r, p): \n return (fac[n] * pow(fac[r], p-2, p) % p * pow(fac[n-r], p-2, p) % p);",
"ncr",
"ff %= p",
"p",
"ff",
"kD = h-1",
"h-1",
"kD",
"p = 1000000007",
"1000000007",
"p",
"ff = 1",
"1",
"ff",
"b = map(int,input().split())",
"map(int,input().split())",
"b",
"w,a,b = map(int,input().split())",
"map(int,input().split())",
"w",
"s = (s + C * D) % 1000000007",
"(s + C * D) % 1000000007",
"s",
"kC = 0",
"0",
"kC",
"a,b = map(int,input().split())",
"map(int,input().split())",
"a",
"ff *= i",
"i",
"ff",
"D = ncr(nD, kD, 1000000007)",
"ncr(nD, kD, 1000000007)",
"D",
"nC = b-1",
"b-1",
"nC",
"C = ncr(nC, kC, 1000000007)",
"ncr(nC, kC, 1000000007)",
"C",
"kD -= 1",
"1",
"kD",
"nC += 1",
"1",
"nC",
"fac = [1]",
"[1]",
"fac",
"h,w,a,b = map(int,input().split())",
"map(int,input().split())",
"h",
"nD = w-b-1+h-1",
"w-b-1+h-1",
"nD"
] | from math import comb
h,w,a,b = map(int,input().split())
s = 0
nC = b-1
kC = 0
nD = w-b-1+h-1
kD = h-1
p = 1000000007
fac = [1]
ff = 1
for i in range(1,200001):
ff *= i
ff %= p
fac.append(ff)
def ncr(n, r, p):
return (fac[n] * pow(fac[r], p-2, p) % p * pow(fac[n-r], p-2, p) % p);
for i in range(h-a):
C = ncr(nC, kC, 1000000007)
D = ncr(nD, kD, 1000000007)
s = (s + C * D) % 1000000007
nC += 1
kC += 1
kD -= 1
nD -= 1
print(s)
|
[
7,
12,
13,
29,
4,
13,
4,
18,
4,
13,
13,
12,
13,
29,
4,
13,
4,
13,
13,
4,
18,
4,
18,
4,
13,
13,
13,
17,
0,
13,
39,
17,
0,
13,
2,
2,
17,
17,
17,
0,
13,
39,
17,
12,
13,
14,
2,
13,
17,
29,
17,
0,
13,
4,
13,
13,
2,
13,
17,
0,
13,
2,
2,
13,
13,
13,
14,
2,
2,
13,
17,
17,
29,
13,
29,
2,
2,
13,
13,
13,
23,
13,
23,
13,
12,
13,
0,
13,
17,
42,
13,
14,
2,
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,
12,
13,
14,
2,
2,
13,
17,
2,
13,
13,
29,
17,
29,
2,
2,
2,
2,
18,
13,
13,
18,
13,
2,
13,
13,
13,
18,
13,
13,
13,
23,
13,
23,
13,
12,
13,
17,
0,
13,
4,
13,
13,
13,
13,
28,
13,
4,
13,
17,
2,
13,
13,
0,
13,
2,
2,
18,
13,
17,
13,
13,
4,
18,
13,
13,
13,
0,
13,
4,
13,
13,
2,
13,
17,
4,
18,
13,
13,
13,
0,
13,
17,
28,
13,
4,
13,
13,
13,
0,
13,
13,
0,
13,
2,
2,
13,
13,
17,
0,
13,
2,
2,
13,
13,
17,
0,
13,
2,
13,
17,
0,
13,
2,
2,
13,
2,
2,
4,
13,
2,
13,
13,
13,
4,
13,
2,
13,
13,
13,
13,
13,
29,
13,
14,
2,
13,
17,
4,
13,
4,
13,
10,
39,
13,
10,
12,
13,
10,
12,
13,
10,
39,
13,
10,
2,
13,
10,
12,
13,
10,
12,
13,
10,
12,
13,
10,
12,
13
] | [
[
271,
29
],
[
274,
33
],
[
262,
40
],
[
83,
47
],
[
53,
52
],
[
81,
55
],
[
83,
57
],
[
61,
60
],
[
52,
63
],
[
52,
64
],
[
275,
65
],
[
83,
69
],
[
60,
73
],
[
60,
77
],
[
81,
78
],
[
275,
79
],
[
81,
81
],
[
83,
83
],
[
88,
87
],
[
119,
94
],
[
112,
94
],
[
99,
98
],
[
87,
101
],
[
98,
101
],
[
117,
102
],
[
105,
102
],
[
275,
103
],
[
106,
105
],
[
117,
108
],
[
105,
108
],
[
117,
109
],
[
105,
109
],
[
275,
110
],
[
113,
112
],
[
98,
115
],
[
87,
115
],
[
117,
117
],
[
119,
119
],
[
153,
125
],
[
153,
128
],
[
151,
129
],
[
272,
138
],
[
151,
139
],
[
263,
141
],
[
151,
143
],
[
153,
144
],
[
275,
145
],
[
263,
147
],
[
153,
148
],
[
275,
149
],
[
151,
151
],
[
153,
153
],
[
159,
158
],
[
269,
160
],
[
159,
161
],
[
159,
162
],
[
159,
163
],
[
166,
165
],
[
158,
170
],
[
161,
171
],
[
174,
173
],
[
272,
177
],
[
165,
179
],
[
275,
180
],
[
272,
183
],
[
173,
185
],
[
188,
187
],
[
284,
189
],
[
173,
190
],
[
275,
192
],
[
263,
196
],
[
187,
198
],
[
201,
200
],
[
204,
203
],
[
163,
206
],
[
161,
207
],
[
210,
209
],
[
203,
210
],
[
213,
212
],
[
158,
215
],
[
162,
216
],
[
220,
219
],
[
161,
222
],
[
203,
223
],
[
227,
226
],
[
162,
228
],
[
232,
231
],
[
200,
234
],
[
231,
234
],
[
266,
238
],
[
212,
240
],
[
209,
241
],
[
212,
242
],
[
266,
244
],
[
226,
246
],
[
219,
247
],
[
226,
248
],
[
275,
249
],
[
275,
250
],
[
231,
252
],
[
200,
252
],
[
287,
260
],
[
262,
263
],
[
271,
272
],
[
274,
275
]
] | [
"\n\ndef read_int():\n return int(input().strip())\n\n\ndef read_ints():\n return list(map(int, input().strip().split(' ')))\n\n\nfactorial = [1]\nmodulo = 10**9+7\ninverse_factorial = [0]\n\n\ndef pow1(a, p):\n if p == 0:\n return 1\n half = pow1(a, p//2)\n total = (half*half)%modulo\n if p%2 == 0:\n return total\n return (total*a)%modulo\n\n\ndef modpow(a, p):\n ans = 1\n while p:\n if p&1 == 1:\n ans = (ans*a)%modulo\n a = (a*a)%modulo\n p >>= 1\n return ans\n\n\ndef nCr(n, r):\n if r == 0 or r == n:\n return 1\n return (((factorial[n]*inverse_factorial[n-r])%modulo)*inverse_factorial[r])%modulo\n\n\ndef solve():\n \"\"\"\n 2 3 1 1\n ...\n x.. A\n\n B\n\n C(2, 1)*C(3, 2)\n\n m 0 n 1 C(m, n) 1\n m 1 n 2 C(m, n) 2\n m 0 n 2 C(m, n) 4\n m 1 n 3 C(m, n) 12\n \"\"\"\n H, W, A, B = read_ints()\n for i in range(1, H+W):\n f = (factorial[-1]*i)%modulo\n factorial.append(f)\n inv_f = modpow(f, modulo-2)\n inverse_factorial.append(inv_f)\n T = 0\n for d in range(B, W):\n # d = 0, 1\n y0 = d\n x0 = H-A-1\n y1 = W-d-1\n x1 = A-1\n T = (T+(nCr(x0+y0, x0)*nCr(x1+y1, x1))%modulo)%modulo\n return T\n\n\nif __name__ == '__main__':\n print(solve())",
"def read_int():\n return int(input().strip())",
"read_int",
"return int(input().strip())",
"int(input().strip())",
"int",
"input().strip()",
"().strip",
"()",
"input",
"strip",
"def read_ints():\n return list(map(int, input().strip().split(' ')))",
"read_ints",
"return list(map(int, input().strip().split(' ')))",
"list(map(int, input().strip().split(' ')))",
"list",
"map(int, input().strip().split(' '))",
"map",
"int",
"input().strip().split(' ')",
"().strip().split",
"().strip()",
"().strip",
"()",
"input",
"strip",
"split",
"' '",
"factorial = [1]",
"factorial",
"[1]",
"1",
"modulo = 10**9+7",
"modulo",
"10**9+7",
"10**9",
"10",
"9",
"7",
"inverse_factorial = [0]",
"inverse_factorial",
"[0]",
"0",
"def pow1(a, p):\n if p == 0:\n return 1\n half = pow1(a, p//2)\n total = (half*half)%modulo\n if p%2 == 0:\n return total\n return (total*a)%modulo",
"pow1",
"if p == 0:\n return 1\n ",
"p == 0",
"p",
"0",
"return 1",
"1",
"half = pow1(a, p//2)",
"half",
"pow1(a, p//2)",
"pow1",
"a",
"p//2",
"p",
"2",
"total = (half*half)%modulo",
"total",
"(half*half)%modulo",
"half*half",
"half",
"half",
"modulo",
"if p%2 == 0:\n return total\n ",
"p%2 == 0",
"p%2",
"p",
"2",
"0",
"return total",
"total",
"return (total*a)%modulo",
"(total*a)%modulo",
"total*a",
"total",
"a",
"modulo",
"a",
"a",
"p",
"p",
"def modpow(a, p):\n ans = 1\n while p:\n if p&1 == 1:\n ans = (ans*a)%modulo\n a = (a*a)%modulo\n p >>= 1\n return ans",
"modpow",
"ans = 1",
"ans",
"1",
"while p:\n if p&1 == 1:\n ans = (ans*a)%modulo\n a = (a*a)%modulo\n p >>= 1\n ",
"p",
"if p&1 == 1:\n ans = (ans*a)%modulo\n ",
"p&1 == 1",
"p&1",
"p",
"1",
"1",
"ans = (ans*a)%modulo",
"ans",
"(ans*a)%modulo",
"ans*a",
"ans",
"a",
"modulo",
"a = (a*a)%modulo",
"a",
"(a*a)%modulo",
"a*a",
"a",
"a",
"modulo",
"p >>= 1",
"p",
"1",
"return ans",
"ans",
"a",
"a",
"p",
"p",
"def nCr(n, r):\n if r == 0 or r == n:\n return 1\n return (((factorial[n]*inverse_factorial[n-r])%modulo)*inverse_factorial[r])%modulo",
"nCr",
"if r == 0 or r == n:\n return 1\n ",
"r == 0 or r == n",
"r == 0",
"r",
"0",
"r == n",
"r",
"n",
"return 1",
"1",
"return (((factorial[n]*inverse_factorial[n-r])%modulo)*inverse_factorial[r])%modulo",
"(((factorial[n]*inverse_factorial[n-r])%modulo)*inverse_factorial[r])%modulo",
"((factorial[n]*inverse_factorial[n-r])%modulo)*inverse_factorial[r]",
"(factorial[n]*inverse_factorial[n-r])%modulo",
"factorial[n]*inverse_factorial[n-r]",
"factorial[n]",
"factorial",
"n",
"inverse_factorial[n-r]",
"inverse_factorial",
"n-r",
"n",
"r",
"modulo",
"inverse_factorial[r]",
"inverse_factorial",
"r",
"modulo",
"n",
"n",
"r",
"r",
"def solve():\n \"\"\"\n 2 3 1 1\n ...\n x.. A\n\n B\n\n C(2, 1)*C(3, 2)\n\n m 0 n 1 C(m, n) 1\n m 1 n 2 C(m, n) 2\n m 0 n 2 C(m, n) 4\n m 1 n 3 C(m, n) 12\n \"\"\"\n H, W, A, B = read_ints()\n for i in range(1, H+W):\n f = (factorial[-1]*i)%modulo\n factorial.append(f)\n inv_f = modpow(f, modulo-2)\n inverse_factorial.append(inv_f)\n T = 0\n for d in range(B, W):\n # d = 0, 1\n y0 = d\n x0 = H-A-1\n y1 = W-d-1\n x1 = A-1\n T = (T+(nCr(x0+y0, x0)*nCr(x1+y1, x1))%modulo)%modulo\n return T",
"solve",
"\"\"\"\n 2 3 1 1\n ...\n x.. A\n\n B\n\n C(2, 1)*C(3, 2)\n\n m 0 n 1 C(m, n) 1\n m 1 n 2 C(m, n) 2\n m 0 n 2 C(m, n) 4\n m 1 n 3 C(m, n) 12\n \"\"\"",
"H, W, A, B = read_ints()",
"H",
"read_ints()",
"read_ints",
"W",
"A",
"B",
"for i in range(1, H+W):\n f = (factorial[-1]*i)%modulo\n factorial.append(f)\n inv_f = modpow(f, modulo-2)\n inverse_factorial.append(inv_f)\n ",
"i",
"range(1, H+W)",
"range",
"1",
"H+W",
"H",
"W",
"f = (factorial[-1]*i)%modulo",
"f",
"(factorial[-1]*i)%modulo",
"factorial[-1]*i",
"factorial[-1]",
"factorial",
"-1",
"i",
"modulo",
"factorial.append(f)",
"factorial.append",
"factorial",
"append",
"f",
"inv_f = modpow(f, modulo-2)",
"inv_f",
"modpow(f, modulo-2)",
"modpow",
"f",
"modulo-2",
"modulo",
"2",
"inverse_factorial.append(inv_f)",
"inverse_factorial.append",
"inverse_factorial",
"append",
"inv_f",
"T = 0",
"T",
"0",
"for d in range(B, W):\n # d = 0, 1\n y0 = d\n x0 = H-A-1\n y1 = W-d-1\n x1 = A-1\n T = (T+(nCr(x0+y0, x0)*nCr(x1+y1, x1))%modulo)%modulo\n ",
"d",
"range(B, W)",
"range",
"B",
"W",
"y0 = d",
"y0",
"d",
"x0 = H-A-1",
"x0",
"H-A-1",
"H-A",
"H",
"A",
"1",
"y1 = W-d-1",
"y1",
"W-d-1",
"W-d",
"W",
"d",
"1",
"x1 = A-1",
"x1",
"A-1",
"A",
"1",
"T = (T+(nCr(x0+y0, x0)*nCr(x1+y1, x1))%modulo)%modulo",
"T",
"(T+(nCr(x0+y0, x0)*nCr(x1+y1, x1))%modulo)%modulo",
"T+(nCr(x0+y0, x0)*nCr(x1+y1, x1))%modulo",
"T",
"(nCr(x0+y0, x0)*nCr(x1+y1, x1))%modulo",
"nCr(x0+y0, x0)*nCr(x1+y1, x1)",
"nCr(x0+y0, x0)",
"nCr",
"x0+y0",
"x0",
"y0",
"x0",
"nCr(x1+y1, x1)",
"nCr",
"x1+y1",
"x1",
"y1",
"x1",
"modulo",
"modulo",
"return T",
"T",
"if __name__ == '__main__':\n print(solve())",
"__name__ == '__main__'",
"__name__",
"'__main__'",
"print(solve())",
"print",
"solve()",
"solve",
"inverse_factorial = [0]",
"[0]",
"inverse_factorial",
"def nCr(n, r):\n if r == 0 or r == n:\n return 1\n return (((factorial[n]*inverse_factorial[n-r])%modulo)*inverse_factorial[r])%modulo",
"def nCr(n, r):\n if r == 0 or r == n:\n return 1\n return (((factorial[n]*inverse_factorial[n-r])%modulo)*inverse_factorial[r])%modulo",
"nCr",
"def read_ints():\n return list(map(int, input().strip().split(' ')))",
"def read_ints():\n return list(map(int, input().strip().split(' ')))",
"read_ints",
"factorial = [1]",
"[1]",
"factorial",
"modulo = 10**9+7",
"10**9+7",
"modulo",
"def read_int():\n return int(input().strip())",
"def read_int():\n return int(input().strip())",
"read_int",
"def pow1(a, p):\n if p == 0:\n return 1\n half = pow1(a, p//2)\n total = (half*half)%modulo\n if p%2 == 0:\n return total\n return (total*a)%modulo",
"def pow1(a, p):\n if p == 0:\n return 1\n half = pow1(a, p//2)\n total = (half*half)%modulo\n if p%2 == 0:\n return total\n return (total*a)%modulo",
"pow1",
"def modpow(a, p):\n ans = 1\n while p:\n if p&1 == 1:\n ans = (ans*a)%modulo\n a = (a*a)%modulo\n p >>= 1\n return ans",
"def modpow(a, p):\n ans = 1\n while p:\n if p&1 == 1:\n ans = (ans*a)%modulo\n a = (a*a)%modulo\n p >>= 1\n return ans",
"modpow",
"def solve():\n \"\"\"\n 2 3 1 1\n ...\n x.. A\n\n B\n\n C(2, 1)*C(3, 2)\n\n m 0 n 1 C(m, n) 1\n m 1 n 2 C(m, n) 2\n m 0 n 2 C(m, n) 4\n m 1 n 3 C(m, n) 12\n \"\"\"\n H, W, A, B = read_ints()\n for i in range(1, H+W):\n f = (factorial[-1]*i)%modulo\n factorial.append(f)\n inv_f = modpow(f, modulo-2)\n inverse_factorial.append(inv_f)\n T = 0\n for d in range(B, W):\n # d = 0, 1\n y0 = d\n x0 = H-A-1\n y1 = W-d-1\n x1 = A-1\n T = (T+(nCr(x0+y0, x0)*nCr(x1+y1, x1))%modulo)%modulo\n return T",
"def solve():\n \"\"\"\n 2 3 1 1\n ...\n x.. A\n\n B\n\n C(2, 1)*C(3, 2)\n\n m 0 n 1 C(m, n) 1\n m 1 n 2 C(m, n) 2\n m 0 n 2 C(m, n) 4\n m 1 n 3 C(m, n) 12\n \"\"\"\n H, W, A, B = read_ints()\n for i in range(1, H+W):\n f = (factorial[-1]*i)%modulo\n factorial.append(f)\n inv_f = modpow(f, modulo-2)\n inverse_factorial.append(inv_f)\n T = 0\n for d in range(B, W):\n # d = 0, 1\n y0 = d\n x0 = H-A-1\n y1 = W-d-1\n x1 = A-1\n T = (T+(nCr(x0+y0, x0)*nCr(x1+y1, x1))%modulo)%modulo\n return T",
"solve"
] |
def read_int():
return int(input().strip())
def read_ints():
return list(map(int, input().strip().split(' ')))
factorial = [1]
modulo = 10**9+7
inverse_factorial = [0]
def pow1(a, p):
if p == 0:
return 1
half = pow1(a, p//2)
total = (half*half)%modulo
if p%2 == 0:
return total
return (total*a)%modulo
def modpow(a, p):
ans = 1
while p:
if p&1 == 1:
ans = (ans*a)%modulo
a = (a*a)%modulo
p >>= 1
return ans
def nCr(n, r):
if r == 0 or r == n:
return 1
return (((factorial[n]*inverse_factorial[n-r])%modulo)*inverse_factorial[r])%modulo
def solve():
"""
2 3 1 1
...
x.. A
B
C(2, 1)*C(3, 2)
m 0 n 1 C(m, n) 1
m 1 n 2 C(m, n) 2
m 0 n 2 C(m, n) 4
m 1 n 3 C(m, n) 12
"""
H, W, A, B = read_ints()
for i in range(1, H+W):
f = (factorial[-1]*i)%modulo
factorial.append(f)
inv_f = modpow(f, modulo-2)
inverse_factorial.append(inv_f)
T = 0
for d in range(B, W):
# d = 0, 1
y0 = d
x0 = H-A-1
y1 = W-d-1
x1 = A-1
T = (T+(nCr(x0+y0, x0)*nCr(x1+y1, x1))%modulo)%modulo
return T
if __name__ == '__main__':
print(solve())
|
[
7,
15,
13,
0,
13,
4,
13,
13,
4,
18,
4,
18,
4,
18,
18,
13,
13,
13,
13,
13,
13,
13,
13,
0,
13,
2,
2,
17,
17,
17,
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,
17,
28,
13,
4,
13,
13,
0,
13,
2,
2,
18,
13,
2,
2,
2,
13,
13,
17,
13,
4,
13,
18,
13,
13,
2,
13,
17,
13,
4,
13,
18,
13,
2,
2,
13,
13,
17,
2,
13,
17,
13,
0,
13,
13,
0,
13,
2,
2,
18,
13,
2,
2,
2,
13,
13,
17,
13,
4,
13,
18,
13,
2,
13,
17,
2,
13,
17,
13,
4,
13,
18,
13,
2,
2,
13,
17,
13,
2,
13,
17,
13,
0,
13,
13,
0,
13,
13,
0,
13,
13,
0,
13,
2,
2,
18,
13,
2,
2,
13,
13,
17,
4,
13,
18,
13,
2,
13,
17,
2,
13,
17,
13,
4,
13,
18,
13,
2,
13,
17,
2,
13,
17,
13,
0,
13,
13,
4,
13,
2,
2,
13,
13,
13,
10,
13,
13,
10,
4,
13,
10,
4,
13,
10,
2,
13,
10,
39,
13,
10,
2,
13,
10,
4,
13,
10,
17,
13,
10,
13,
13,
10,
4,
13,
10,
13,
13,
10,
2,
13,
10,
13,
13,
10,
2,
13,
10,
13,
13
] | [
[
218,
4
],
[
218,
20
],
[
218,
21
],
[
218,
22
],
[
224,
24
],
[
203,
31
],
[
36,
35
],
[
195,
41
],
[
198,
42
],
[
204,
46
],
[
204,
51
],
[
35,
53
],
[
225,
54
],
[
212,
56
],
[
60,
59
],
[
219,
62
],
[
200,
64
],
[
204,
68
],
[
195,
72
],
[
210,
73
],
[
59,
75
],
[
204,
79
],
[
59,
80
],
[
225,
82
],
[
225,
84
],
[
204,
88
],
[
195,
91
],
[
210,
92
],
[
225,
95
],
[
225,
97
],
[
191,
99
],
[
225,
100
],
[
206,
102
],
[
204,
106
],
[
198,
110
],
[
210,
111
],
[
59,
113
],
[
204,
117
],
[
210,
119
],
[
225,
122
],
[
225,
124
],
[
204,
128
],
[
198,
131
],
[
59,
133
],
[
225,
135
],
[
225,
137
],
[
233,
139
],
[
225,
140
],
[
221,
142
],
[
234,
143
],
[
207,
143
],
[
192,
143
],
[
201,
143
],
[
227,
145
],
[
225,
146
],
[
230,
148
],
[
204,
152
],
[
195,
155
],
[
198,
156
],
[
204,
161
],
[
195,
163
],
[
225,
166
],
[
225,
168
],
[
204,
172
],
[
198,
174
],
[
225,
177
],
[
225,
179
],
[
215,
181
],
[
225,
182
],
[
216,
187
],
[
231,
187
],
[
228,
188
],
[
222,
188
],
[
213,
188
],
[
225,
189
],
[
225,
191
],
[
191,
192
],
[
218,
195
],
[
218,
198
],
[
200,
201
],
[
203,
204
],
[
206,
207
],
[
218,
210
],
[
212,
213
],
[
225,
215
],
[
215,
216
],
[
218,
219
],
[
234,
221
],
[
207,
221
],
[
192,
221
],
[
201,
221
],
[
221,
222
],
[
224,
225
],
[
225,
227
],
[
227,
228
],
[
230,
231
],
[
225,
233
],
[
233,
234
]
] | [
"import sys\nH,W,A,B = map(int,sys.stdin.readline().rstrip().split())\nmod = 10**9+7\n\nkaijou = [1]\nfor i in range(1,H+W-1):\n kaijou.append((kaijou[-1]*i) % mod)\n\na = 0\nfor i in range(B):\n b = kaijou[(H-A-1)+i]*pow(kaijou[i],mod-2,mod)*pow(kaijou[H-A-1],mod-2,mod)\n b %= mod\n b *= kaijou[(W+A-2)-i]*pow(kaijou[A-1],mod-2,mod)*pow(kaijou[W-1-i],mod-2,mod)\n b %= mod\n a += b\n a %= mod\n\nc = kaijou[H+W-2]*pow(kaijou[H-1],mod-2,mod)*pow(kaijou[W-1],mod-2,mod)\nc %= mod\n\nprint((c-a) % mod)",
"import sys",
"sys",
"H,W,A,B = map(int,sys.stdin.readline().rstrip().split())",
"H",
"map(int,sys.stdin.readline().rstrip().split())",
"map",
"int",
"sys.stdin.readline().rstrip().split()",
"sys.stdin.readline().rstrip().split",
"sys.stdin.readline().rstrip()",
"sys.stdin.readline().rstrip",
"sys.stdin.readline()",
"sys.stdin.readline",
"sys.stdin",
"sys",
"stdin",
"readline",
"rstrip",
"split",
"W",
"A",
"B",
"mod = 10**9+7",
"mod",
"10**9+7",
"10**9",
"10",
"9",
"7",
"kaijou = [1]",
"kaijou",
"[1]",
"1",
"for i in range(1,H+W-1):\n kaijou.append((kaijou[-1]*i) % mod)",
"i",
"range(1,H+W-1)",
"range",
"1",
"H+W-1",
"H+W",
"H",
"W",
"1",
"kaijou.append((kaijou[-1]*i) % mod)",
"kaijou.append",
"kaijou",
"append",
"(kaijou[-1]*i) % mod",
"kaijou[-1]*i",
"kaijou[-1]",
"kaijou",
"-1",
"i",
"mod",
"a = 0",
"a",
"0",
"for i in range(B):\n b = kaijou[(H-A-1)+i]*pow(kaijou[i],mod-2,mod)*pow(kaijou[H-A-1],mod-2,mod)\n b %= mod\n b *= kaijou[(W+A-2)-i]*pow(kaijou[A-1],mod-2,mod)*pow(kaijou[W-1-i],mod-2,mod)\n b %= mod\n a += b\n a %= mod",
"i",
"range(B)",
"range",
"B",
"b = kaijou[(H-A-1)+i]*pow(kaijou[i],mod-2,mod)*pow(kaijou[H-A-1],mod-2,mod)",
"b",
"kaijou[(H-A-1)+i]*pow(kaijou[i],mod-2,mod)*pow(kaijou[H-A-1],mod-2,mod)",
"kaijou[(H-A-1)+i]*pow(kaijou[i],mod-2,mod)",
"kaijou[(H-A-1)+i]",
"kaijou",
"(H-A-1)+i",
"H-A-1",
"H-A",
"H",
"A",
"1",
"i",
"pow(kaijou[i],mod-2,mod)",
"pow",
"kaijou[i]",
"kaijou",
"i",
"mod-2",
"mod",
"2",
"mod",
"pow(kaijou[H-A-1],mod-2,mod)",
"pow",
"kaijou[H-A-1]",
"kaijou",
"H-A-1",
"H-A",
"H",
"A",
"1",
"mod-2",
"mod",
"2",
"mod",
"b %= mod",
"b",
"mod",
"b *= kaijou[(W+A-2)-i]*pow(kaijou[A-1],mod-2,mod)*pow(kaijou[W-1-i],mod-2,mod)",
"b",
"kaijou[(W+A-2)-i]*pow(kaijou[A-1],mod-2,mod)*pow(kaijou[W-1-i],mod-2,mod)",
"kaijou[(W+A-2)-i]*pow(kaijou[A-1],mod-2,mod)",
"kaijou[(W+A-2)-i]",
"kaijou",
"(W+A-2)-i",
"W+A-2",
"W+A",
"W",
"A",
"2",
"i",
"pow(kaijou[A-1],mod-2,mod)",
"pow",
"kaijou[A-1]",
"kaijou",
"A-1",
"A",
"1",
"mod-2",
"mod",
"2",
"mod",
"pow(kaijou[W-1-i],mod-2,mod)",
"pow",
"kaijou[W-1-i]",
"kaijou",
"W-1-i",
"W-1",
"W",
"1",
"i",
"mod-2",
"mod",
"2",
"mod",
"b %= mod",
"b",
"mod",
"a += b",
"a",
"b",
"a %= mod",
"a",
"mod",
"c = kaijou[H+W-2]*pow(kaijou[H-1],mod-2,mod)*pow(kaijou[W-1],mod-2,mod)",
"c",
"kaijou[H+W-2]*pow(kaijou[H-1],mod-2,mod)*pow(kaijou[W-1],mod-2,mod)",
"kaijou[H+W-2]*pow(kaijou[H-1],mod-2,mod)",
"kaijou[H+W-2]",
"kaijou",
"H+W-2",
"H+W",
"H",
"W",
"2",
"pow(kaijou[H-1],mod-2,mod)",
"pow",
"kaijou[H-1]",
"kaijou",
"H-1",
"H",
"1",
"mod-2",
"mod",
"2",
"mod",
"pow(kaijou[W-1],mod-2,mod)",
"pow",
"kaijou[W-1]",
"kaijou",
"W-1",
"W",
"1",
"mod-2",
"mod",
"2",
"mod",
"c %= mod",
"c",
"mod",
"print((c-a) % mod)",
"print",
"(c-a) % mod",
"c-a",
"c",
"a",
"mod",
"b %= mod",
"mod",
"b",
"H,W,A,B = map(int,sys.stdin.readline().rstrip().split())",
"map(int,sys.stdin.readline().rstrip().split())",
"H",
"W,A,B = map(int,sys.stdin.readline().rstrip().split())",
"map(int,sys.stdin.readline().rstrip().split())",
"W",
"b = kaijou[(H-A-1)+i]*pow(kaijou[i],mod-2,mod)*pow(kaijou[H-A-1],mod-2,mod)",
"kaijou[(H-A-1)+i]*pow(kaijou[i],mod-2,mod)*pow(kaijou[H-A-1],mod-2,mod)",
"b",
"kaijou = [1]",
"[1]",
"kaijou",
"b *= kaijou[(W+A-2)-i]*pow(kaijou[A-1],mod-2,mod)*pow(kaijou[W-1-i],mod-2,mod)",
"kaijou[(W+A-2)-i]*pow(kaijou[A-1],mod-2,mod)*pow(kaijou[W-1-i],mod-2,mod)",
"b",
"A,B = map(int,sys.stdin.readline().rstrip().split())",
"map(int,sys.stdin.readline().rstrip().split())",
"A",
"a = 0",
"0",
"a",
"c %= mod",
"mod",
"c",
"B = map(int,sys.stdin.readline().rstrip().split())",
"map(int,sys.stdin.readline().rstrip().split())",
"B",
"a += b",
"b",
"a",
"mod = 10**9+7",
"10**9+7",
"mod",
"a %= mod",
"mod",
"a",
"c = kaijou[H+W-2]*pow(kaijou[H-1],mod-2,mod)*pow(kaijou[W-1],mod-2,mod)",
"kaijou[H+W-2]*pow(kaijou[H-1],mod-2,mod)*pow(kaijou[W-1],mod-2,mod)",
"c",
"b %= mod",
"mod",
"b"
] | import sys
H,W,A,B = map(int,sys.stdin.readline().rstrip().split())
mod = 10**9+7
kaijou = [1]
for i in range(1,H+W-1):
kaijou.append((kaijou[-1]*i) % mod)
a = 0
for i in range(B):
b = kaijou[(H-A-1)+i]*pow(kaijou[i],mod-2,mod)*pow(kaijou[H-A-1],mod-2,mod)
b %= mod
b *= kaijou[(W+A-2)-i]*pow(kaijou[A-1],mod-2,mod)*pow(kaijou[W-1-i],mod-2,mod)
b %= mod
a += b
a %= mod
c = kaijou[H+W-2]*pow(kaijou[H-1],mod-2,mod)*pow(kaijou[W-1],mod-2,mod)
c %= mod
print((c-a) % mod) |
[
7,
0,
13,
2,
2,
17,
17,
17,
0,
13,
4,
13,
13,
4,
18,
4,
13,
13,
13,
13,
13,
12,
13,
14,
2,
13,
13,
14,
2,
2,
13,
17,
2,
13,
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,
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,
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,
2,
13,
13,
0,
13,
2,
4,
13,
2,
2,
13,
13,
17,
2,
13,
17,
4,
13,
2,
2,
2,
2,
13,
13,
13,
13,
17,
2,
2,
13,
13,
17,
0,
13,
13,
4,
13,
2,
13,
13,
10,
12,
13,
10,
2,
13,
10,
4,
13,
10,
4,
13,
10,
4,
13,
10,
2,
13,
10,
13,
13,
10,
2,
13,
10,
4,
13,
10,
2,
13,
10,
17,
13
] | [
[
164,
2
],
[
185,
9
],
[
185,
18
],
[
185,
19
],
[
185,
20
],
[
54,
25
],
[
56,
26
],
[
54,
30
],
[
56,
33
],
[
54,
42
],
[
56,
45
],
[
165,
46
],
[
54,
50
],
[
56,
51
],
[
165,
52
],
[
54,
54
],
[
56,
56
],
[
176,
58
],
[
186,
64
],
[
171,
65
],
[
182,
68
],
[
186,
74
],
[
171,
75
],
[
79,
78
],
[
186,
84
],
[
171,
85
],
[
91,
88
],
[
177,
89
],
[
78,
90
],
[
177,
94
],
[
78,
96
],
[
78,
98
],
[
165,
99
],
[
104,
101
],
[
183,
102
],
[
78,
103
],
[
88,
106
],
[
177,
107
],
[
78,
108
],
[
165,
110
],
[
165,
112
],
[
191,
114
],
[
118,
117
],
[
186,
121
],
[
174,
122
],
[
188,
124
],
[
162,
127
],
[
168,
130
],
[
117,
131
],
[
168,
134
],
[
162,
137
],
[
186,
142
],
[
171,
143
],
[
168,
144
],
[
117,
145
],
[
171,
149
],
[
168,
150
],
[
179,
153
],
[
165,
154
],
[
180,
158
],
[
189,
158
],
[
192,
158
],
[
165,
159
],
[
164,
165
],
[
185,
168
],
[
185,
171
],
[
185,
174
],
[
176,
177
],
[
165,
179
],
[
179,
180
],
[
182,
183
],
[
185,
186
],
[
188,
189
],
[
191,
192
]
] | [
"mod = 10 ** 9 + 7\nh, w, a, b = map(int, input().split())\ndef comb(n, r):\n if n < r:return 0\n if n < 0 or r < 0:return 0\n return fa[n] * fi[r] % mod * fi[n - r] % mod\nfa = [1] * (h + w + 1)\nfi = [1] * (h + w + 1)\nfor i in range(1, h + w + 1):\n fa[i] = fa[i - 1] * i % mod\n fi[i] = pow(fa[i], mod - 2, mod)\nans = 0\nfor i in range(h - a):\n ans += comb(b + i - 1, b - 1) * comb(h + w - b - i - 2, w - b - 1)\n ans %= mod\nprint(ans % mod)",
"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(n, r):\n if n < r:return 0\n if n < 0 or r < 0:return 0\n return fa[n] * fi[r] % mod * fi[n - r] % 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 fa[n] * fi[r] % mod * fi[n - r] % mod",
"fa[n] * fi[r] % mod * fi[n - r] % mod",
"fa[n] * fi[r] % mod * fi[n - r]",
"fa[n] * fi[r] % mod",
"fa[n] * fi[r]",
"fa[n]",
"fa",
"n",
"fi[r]",
"fi",
"r",
"mod",
"fi[n - r]",
"fi",
"n - r",
"n",
"r",
"mod",
"n",
"n",
"r",
"r",
"fa = [1] * (h + w + 1)",
"fa",
"[1] * (h + w + 1)",
"[1]",
"1",
"h + w + 1",
"h + w",
"h",
"w",
"1",
"fi = [1] * (h + w + 1)",
"fi",
"[1] * (h + w + 1)",
"[1]",
"1",
"h + w + 1",
"h + w",
"h",
"w",
"1",
"for i in range(1, h + w + 1):\n fa[i] = fa[i - 1] * i % mod\n fi[i] = pow(fa[i], mod - 2, mod)",
"i",
"range(1, h + w + 1)",
"range",
"1",
"h + w + 1",
"h + w",
"h",
"w",
"1",
"fa[i] = fa[i - 1] * i % mod",
"fa[i]",
"fa",
"i",
"fa[i - 1] * i % mod",
"fa[i - 1] * i",
"fa[i - 1]",
"fa",
"i - 1",
"i",
"1",
"i",
"mod",
"fi[i] = pow(fa[i], mod - 2, mod)",
"fi[i]",
"fi",
"i",
"pow(fa[i], mod - 2, mod)",
"pow",
"fa[i]",
"fa",
"i",
"mod - 2",
"mod",
"2",
"mod",
"ans = 0",
"ans",
"0",
"for i in range(h - a):\n ans += comb(b + i - 1, b - 1) * comb(h + w - b - i - 2, w - b - 1)\n ans %= mod",
"i",
"range(h - a)",
"range",
"h - a",
"h",
"a",
"ans += comb(b + i - 1, b - 1) * comb(h + w - b - i - 2, w - b - 1)",
"ans",
"comb(b + i - 1, b - 1) * comb(h + w - b - i - 2, w - b - 1)",
"comb(b + i - 1, b - 1)",
"comb",
"b + i - 1",
"b + i",
"b",
"i",
"1",
"b - 1",
"b",
"1",
"comb(h + w - b - i - 2, w - b - 1)",
"comb",
"h + w - b - i - 2",
"h + w - b - i",
"h + w - b",
"h + w",
"h",
"w",
"b",
"i",
"2",
"w - b - 1",
"w - b",
"w",
"b",
"1",
"ans %= mod",
"ans",
"mod",
"print(ans % mod)",
"print",
"ans % mod",
"ans",
"mod",
"def comb(n, r):\n if n < r:return 0\n if n < 0 or r < 0:return 0\n return fa[n] * fi[r] % mod * fi[n - r] % mod",
"def comb(n, r):\n if n < r:return 0\n if n < 0 or r < 0:return 0\n return fa[n] * fi[r] % mod * fi[n - r] % mod",
"comb",
"mod = 10 ** 9 + 7",
"10 ** 9 + 7",
"mod",
"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",
"fa = [1] * (h + w + 1)",
"[1] * (h + w + 1)",
"fa",
"ans %= mod",
"mod",
"ans",
"fi = [1] * (h + w + 1)",
"[1] * (h + w + 1)",
"fi",
"h, w, a, b = map(int, input().split())",
"map(int, input().split())",
"h",
"ans += comb(b + i - 1, b - 1) * comb(h + w - b - i - 2, w - b - 1)",
"comb(b + i - 1, b - 1) * comb(h + w - b - i - 2, w - b - 1)",
"ans",
"ans = 0",
"0",
"ans"
] | mod = 10 ** 9 + 7
h, w, a, b = map(int, input().split())
def comb(n, r):
if n < r:return 0
if n < 0 or r < 0:return 0
return fa[n] * fi[r] % mod * fi[n - r] % mod
fa = [1] * (h + w + 1)
fi = [1] * (h + w + 1)
for i in range(1, h + w + 1):
fa[i] = fa[i - 1] * i % mod
fi[i] = pow(fa[i], mod - 2, mod)
ans = 0
for i in range(h - a):
ans += comb(b + i - 1, b - 1) * comb(h + w - b - i - 2, w - b - 1)
ans %= mod
print(ans % mod) |
[
7,
0,
13,
4,
13,
13,
4,
18,
4,
13,
13,
13,
13,
13,
0,
13,
2,
2,
17,
17,
17,
12,
13,
0,
13,
39,
17,
0,
13,
17,
28,
13,
4,
13,
13,
0,
13,
2,
2,
13,
2,
13,
17,
13,
4,
18,
13,
13,
13,
29,
13,
23,
13,
12,
13,
0,
13,
39,
17,
28,
13,
4,
13,
13,
4,
18,
13,
13,
4,
13,
18,
13,
2,
13,
17,
2,
13,
17,
13,
29,
13,
23,
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,
23,
13,
23,
13,
0,
13,
2,
13,
13,
0,
13,
2,
13,
13,
0,
13,
17,
0,
13,
4,
13,
2,
13,
13,
0,
13,
4,
13,
2,
13,
13,
13,
42,
2,
2,
13,
17,
2,
13,
17,
0,
13,
17,
0,
13,
17,
0,
13,
2,
2,
4,
13,
2,
2,
2,
13,
13,
13,
17,
13,
13,
13,
4,
13,
2,
2,
2,
13,
13,
13,
17,
13,
13,
13,
13,
4,
13,
2,
13,
13,
10,
2,
13,
10,
4,
13,
10,
2,
13,
10,
12,
13,
10,
4,
13,
10,
4,
13,
10,
12,
13,
10,
17,
13,
10,
12,
13,
10,
2,
13,
10,
4,
13,
10,
2,
13,
10,
4,
13,
10,
17,
13,
10,
17,
13,
10,
4,
13
] | [
[
233,
2
],
[
233,
11
],
[
233,
12
],
[
233,
13
],
[
194,
15
],
[
25,
24
],
[
29,
28
],
[
32,
31
],
[
52,
34
],
[
37,
36
],
[
28,
39
],
[
36,
39
],
[
31,
41
],
[
195,
43
],
[
24,
46
],
[
36,
48
],
[
28,
48
],
[
24,
50
],
[
52,
52
],
[
57,
56
],
[
61,
60
],
[
82,
63
],
[
56,
66
],
[
84,
71
],
[
60,
73
],
[
195,
76
],
[
195,
78
],
[
56,
80
],
[
82,
82
],
[
84,
84
],
[
108,
92
],
[
104,
93
],
[
110,
95
],
[
106,
96
],
[
110,
98
],
[
104,
100
],
[
106,
101
],
[
195,
102
],
[
104,
104
],
[
106,
106
],
[
108,
108
],
[
110,
110
],
[
215,
112
],
[
225,
114
],
[
234,
115
],
[
188,
117
],
[
201,
119
],
[
192,
120
],
[
227,
122
],
[
218,
125
],
[
198,
127
],
[
225,
129
],
[
201,
130
],
[
203,
132
],
[
213,
134
],
[
225,
136
],
[
201,
137
],
[
219,
138
],
[
216,
142
],
[
210,
142
],
[
189,
145
],
[
231,
145
],
[
209,
148
],
[
230,
151
],
[
221,
154
],
[
207,
158
],
[
225,
162
],
[
234,
163
],
[
192,
164
],
[
210,
166
],
[
216,
166
],
[
219,
167
],
[
204,
168
],
[
207,
170
],
[
201,
174
],
[
234,
175
],
[
192,
176
],
[
231,
178
],
[
189,
178
],
[
219,
179
],
[
204,
180
],
[
195,
181
],
[
222,
185
],
[
228,
185
],
[
195,
186
],
[
188,
189
],
[
233,
192
],
[
194,
195
],
[
233,
201
],
[
203,
204
],
[
209,
210
],
[
215,
216
],
[
218,
219
],
[
221,
222
],
[
233,
225
],
[
227,
228
],
[
230,
231
],
[
233,
234
]
] | [
"H, W, A, B = map(int, input().split())\n\nMOD = 10 ** 9 + 7\n\n\ndef get_fact_list(n: int) -> list:\n result_list = [1]\n tmp = 1\n for i in range(n):\n tmp = (tmp * (i + 1)) % MOD\n result_list.append(tmp)\n\n return result_list\n\n\ndef get_inv_list(n: int, fact_lit: list) -> list:\n result_list = [1]\n\n for i in range(n):\n result_list.append(pow(fact_lit[i + 1], MOD - 2, MOD))\n\n return result_list\n\n\ndef comb(n: int, m: int, fact_list: list, inv_list: list) -> int:\n return (fact_list[n] * inv_list[m] * inv_list[n - m]) % MOD\n\n\nh = H - A\nw = W - B\nways = 0\nfact = get_fact_list(H + W)\ninv = get_inv_list(H + W, fact)\n\nwhile h > 0 and w > 0:\n h -= 1\n w -= 1\n ways += (comb(H - A + B - 1, h, fact, inv) * comb(W + A - B - 1, w, fact, inv)) % MOD\n\nprint(ways % 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",
"def get_fact_list(n: int) -> list:\n result_list = [1]\n tmp = 1\n for i in range(n):\n tmp = (tmp * (i + 1)) % MOD\n result_list.append(tmp)\n\n return result_list",
"get_fact_list",
"result_list = [1]",
"result_list",
"[1]",
"1",
"tmp = 1",
"tmp",
"1",
"for i in range(n):\n tmp = (tmp * (i + 1)) % MOD\n result_list.append(tmp)\n\n ",
"i",
"range(n)",
"range",
"n",
"tmp = (tmp * (i + 1)) % MOD",
"tmp",
"(tmp * (i + 1)) % MOD",
"tmp * (i + 1)",
"tmp",
"i + 1",
"i",
"1",
"MOD",
"result_list.append(tmp)",
"result_list.append",
"result_list",
"append",
"tmp",
"return result_list",
"result_list",
"n: int",
"n",
"def get_inv_list(n: int, fact_lit: list) -> list:\n result_list = [1]\n\n for i in range(n):\n result_list.append(pow(fact_lit[i + 1], MOD - 2, MOD))\n\n return result_list",
"get_inv_list",
"result_list = [1]",
"result_list",
"[1]",
"1",
"for i in range(n):\n result_list.append(pow(fact_lit[i + 1], MOD - 2, MOD))\n\n ",
"i",
"range(n)",
"range",
"n",
"result_list.append(pow(fact_lit[i + 1], MOD - 2, MOD))",
"result_list.append",
"result_list",
"append",
"pow(fact_lit[i + 1], MOD - 2, MOD)",
"pow",
"fact_lit[i + 1]",
"fact_lit",
"i + 1",
"i",
"1",
"MOD - 2",
"MOD",
"2",
"MOD",
"return result_list",
"result_list",
"n: int",
"n",
"fact_lit: list",
"fact_lit",
"def comb(n: int, m: int, fact_list: list, inv_list: list) -> int:\n return (fact_list[n] * inv_list[m] * inv_list[n - m]) % MOD",
"comb",
"return (fact_list[n] * inv_list[m] * inv_list[n - m]) % MOD",
"(fact_list[n] * inv_list[m] * inv_list[n - m]) % MOD",
"fact_list[n] * inv_list[m] * inv_list[n - m]",
"fact_list[n] * inv_list[m]",
"fact_list[n]",
"fact_list",
"n",
"inv_list[m]",
"inv_list",
"m",
"inv_list[n - m]",
"inv_list",
"n - m",
"n",
"m",
"MOD",
"n: int",
"n",
"m: int",
"m",
"fact_list: list",
"fact_list",
"inv_list: list",
"inv_list",
"h = H - A",
"h",
"H - A",
"H",
"A",
"w = W - B",
"w",
"W - B",
"W",
"B",
"ways = 0",
"ways",
"0",
"fact = get_fact_list(H + W)",
"fact",
"get_fact_list(H + W)",
"get_fact_list",
"H + W",
"H",
"W",
"inv = get_inv_list(H + W, fact)",
"inv",
"get_inv_list(H + W, fact)",
"get_inv_list",
"H + W",
"H",
"W",
"fact",
"while h > 0 and w > 0:\n h -= 1\n w -= 1\n ways += (comb(H - A + B - 1, h, fact, inv) * comb(W + A - B - 1, w, fact, inv)) % MOD",
"h > 0 and w > 0",
"h > 0",
"h",
"0",
"w > 0",
"w",
"0",
"h -= 1",
"h",
"1",
"w -= 1",
"w",
"1",
"ways += (comb(H - A + B - 1, h, fact, inv) * comb(W + A - B - 1, w, fact, inv)) % MOD",
"ways",
"(comb(H - A + B - 1, h, fact, inv) * comb(W + A - B - 1, w, fact, inv)) % MOD",
"comb(H - A + B - 1, h, fact, inv) * comb(W + A - B - 1, w, fact, inv)",
"comb(H - A + B - 1, h, fact, inv)",
"comb",
"H - A + B - 1",
"H - A + B",
"H - A",
"H",
"A",
"B",
"1",
"h",
"fact",
"inv",
"comb(W + A - B - 1, w, fact, inv)",
"comb",
"W + A - B - 1",
"W + A - B",
"W + A",
"W",
"A",
"B",
"1",
"w",
"fact",
"inv",
"MOD",
"print(ways % MOD)",
"print",
"ways % MOD",
"ways",
"MOD",
"w = W - B",
"W - B",
"w",
"B = map(int, input().split())",
"map(int, input().split())",
"B",
"MOD = 10 ** 9 + 7",
"10 ** 9 + 7",
"MOD",
"def get_fact_list(n: int) -> list:\n result_list = [1]\n tmp = 1\n for i in range(n):\n tmp = (tmp * (i + 1)) % MOD\n result_list.append(tmp)\n\n return result_list",
"def get_fact_list(n: int) -> list:\n result_list = [1]\n tmp = 1\n for i in range(n):\n tmp = (tmp * (i + 1)) % MOD\n result_list.append(tmp)\n\n return result_list",
"get_fact_list",
"W, A, B = map(int, input().split())",
"map(int, input().split())",
"W",
"inv = get_inv_list(H + W, fact)",
"get_inv_list(H + W, fact)",
"inv",
"def comb(n: int, m: int, fact_list: list, inv_list: list) -> int:\n return (fact_list[n] * inv_list[m] * inv_list[n - m]) % MOD",
"def comb(n: int, m: int, fact_list: list, inv_list: list) -> int:\n return (fact_list[n] * inv_list[m] * inv_list[n - m]) % MOD",
"comb",
"h -= 1",
"1",
"h",
"def get_inv_list(n: int, fact_lit: list) -> list:\n result_list = [1]\n\n for i in range(n):\n result_list.append(pow(fact_lit[i + 1], MOD - 2, MOD))\n\n return result_list",
"def get_inv_list(n: int, fact_lit: list) -> list:\n result_list = [1]\n\n for i in range(n):\n result_list.append(pow(fact_lit[i + 1], MOD - 2, MOD))\n\n return result_list",
"get_inv_list",
"h = H - A",
"H - A",
"h",
"fact = get_fact_list(H + W)",
"get_fact_list(H + W)",
"fact",
"ways += (comb(H - A + B - 1, h, fact, inv) * comb(W + A - B - 1, w, fact, inv)) % MOD",
"(comb(H - A + B - 1, h, fact, inv) * comb(W + A - B - 1, w, fact, inv)) % MOD",
"ways",
"H, W, A, B = map(int, input().split())",
"map(int, input().split())",
"H",
"ways = 0",
"0",
"ways",
"w -= 1",
"1",
"w",
"A, B = map(int, input().split())",
"map(int, input().split())",
"A"
] | H, W, A, B = map(int, input().split())
MOD = 10 ** 9 + 7
def get_fact_list(n: int) -> list:
result_list = [1]
tmp = 1
for i in range(n):
tmp = (tmp * (i + 1)) % MOD
result_list.append(tmp)
return result_list
def get_inv_list(n: int, fact_lit: list) -> list:
result_list = [1]
for i in range(n):
result_list.append(pow(fact_lit[i + 1], MOD - 2, MOD))
return result_list
def comb(n: int, m: int, fact_list: list, inv_list: list) -> int:
return (fact_list[n] * inv_list[m] * inv_list[n - m]) % MOD
h = H - A
w = W - B
ways = 0
fact = get_fact_list(H + W)
inv = get_inv_list(H + W, fact)
while h > 0 and w > 0:
h -= 1
w -= 1
ways += (comb(H - A + B - 1, h, fact, inv) * comb(W + A - B - 1, w, fact, inv)) % MOD
print(ways % MOD) |
[
7,
12,
13,
29,
2,
2,
13,
13,
13,
23,
13,
23,
13,
23,
13,
12,
13,
29,
2,
2,
13,
4,
13,
13,
2,
13,
17,
13,
23,
13,
23,
13,
23,
13,
12,
13,
29,
4,
13,
13,
2,
13,
17,
23,
13,
23,
13,
12,
13,
0,
13,
17,
0,
13,
39,
17,
28,
13,
4,
13,
17,
2,
13,
17,
0,
13,
13,
0,
13,
13,
4,
18,
13,
13,
13,
0,
13,
4,
13,
13,
2,
13,
17,
13,
0,
13,
2,
39,
17,
2,
13,
17,
0,
18,
13,
13,
13,
28,
13,
4,
13,
13,
17,
17,
0,
13,
13,
0,
13,
13,
0,
18,
13,
2,
13,
17,
13,
29,
39,
13,
13,
23,
13,
23,
13,
12,
13,
29,
2,
2,
2,
18,
13,
13,
18,
13,
2,
13,
13,
18,
13,
13,
13,
23,
13,
23,
13,
23,
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,
17,
0,
13,
4,
13,
2,
13,
13,
13,
13,
28,
13,
4,
13,
2,
13,
13,
0,
13,
4,
13,
2,
2,
13,
13,
17,
13,
13,
13,
13,
0,
13,
4,
13,
2,
2,
2,
2,
13,
13,
13,
13,
17,
2,
2,
13,
13,
17,
13,
13,
13,
0,
13,
13,
0,
13,
13,
4,
13,
13,
10,
17,
13,
10,
4,
13,
10,
4,
13,
10,
13,
13,
10,
4,
13,
10,
4,
13,
10,
12,
13,
10,
12,
13,
10,
4,
13,
10,
12,
13,
10,
12,
13,
10,
2,
13,
10,
4,
13,
10,
12,
13,
10,
4,
13,
10,
4,
13,
10,
13,
13
] | [
[
10,
6
],
[
12,
7
],
[
14,
8
],
[
10,
10
],
[
12,
12
],
[
14,
14
],
[
29,
20
],
[
31,
23
],
[
33,
25
],
[
33,
27
],
[
29,
29
],
[
31,
31
],
[
33,
33
],
[
44,
39
],
[
46,
41
],
[
44,
44
],
[
46,
46
],
[
51,
50
],
[
54,
53
],
[
58,
57
],
[
122,
62
],
[
66,
65
],
[
57,
66
],
[
69,
68
],
[
124,
69
],
[
53,
72
],
[
68,
74
],
[
65,
74
],
[
50,
74
],
[
77,
76
],
[
68,
79
],
[
65,
79
],
[
50,
79
],
[
124,
81
],
[
124,
83
],
[
86,
85
],
[
122,
90
],
[
96,
93
],
[
85,
94
],
[
122,
95
],
[
76,
96
],
[
99,
98
],
[
122,
101
],
[
106,
105
],
[
98,
106
],
[
109,
108
],
[
124,
109
],
[
116,
111
],
[
85,
112
],
[
98,
114
],
[
108,
116
],
[
105,
116
],
[
76,
116
],
[
122,
122
],
[
124,
124
],
[
150,
132
],
[
144,
133
],
[
152,
135
],
[
144,
137
],
[
146,
138
],
[
152,
140
],
[
146,
141
],
[
148,
142
],
[
144,
144
],
[
146,
146
],
[
148,
148
],
[
150,
150
],
[
152,
152
],
[
281,
154
],
[
281,
163
],
[
281,
164
],
[
281,
165
],
[
269,
167
],
[
236,
174
],
[
272,
177
],
[
258,
179
],
[
282,
181
],
[
252,
182
],
[
270,
183
],
[
272,
184
],
[
187,
186
],
[
282,
190
],
[
243,
191
],
[
239,
193
],
[
264,
195
],
[
186,
198
],
[
279,
199
],
[
186,
201
],
[
270,
202
],
[
273,
203
],
[
261,
204
],
[
248,
206
],
[
264,
208
],
[
282,
213
],
[
252,
214
],
[
186,
215
],
[
279,
216
],
[
252,
220
],
[
279,
221
],
[
270,
223
],
[
273,
224
],
[
261,
225
],
[
284,
227
],
[
249,
228
],
[
240,
228
],
[
245,
230
],
[
270,
231
],
[
246,
234
],
[
285,
234
],
[
237,
234
],
[
236,
237
],
[
239,
240
],
[
281,
243
],
[
270,
245
],
[
245,
246
],
[
248,
249
],
[
281,
252
],
[
272,
261
],
[
269,
270
],
[
272,
273
],
[
281,
279
],
[
281,
282
],
[
249,
284
],
[
240,
284
],
[
284,
285
]
] | [
"\n#modの掛け算\n \ndef modmal(a,b,mod): #a*bをmodを法にして求める\n \n return a * b % mod\n \n \n#modの割り算\n \ndef moddiv(a,b,mod): #a/bをmodを法にして求める\n \n return (a * pow(b,mod-2)) % mod\n \n \n#逆元\n \ndef inverse(a,mod): #aのmodを法にした逆元を返す\n return pow(a,mod-2)\n \n \n \n#modのn!と、n!の逆元を格納したリストを返す(拾いもの)\n#factorialsには[1, 1!%mod , 2!%mod , 6!%mod… , n!%mod] が入っている\n#invsには↑の逆元が入っている\n \ndef modfac(n, MOD):\n \n f = 1\n factorials = [1]\n for m in range(1, n + 1):\n f *= m\n f %= MOD\n factorials.append(f)\n inv = pow(f, MOD - 2, MOD)\n invs = [1] * (n + 1)\n invs[n] = inv\n for m in range(n, 1, -1):\n inv *= m\n inv %= MOD\n invs[m - 1] = inv\n return factorials, invs\n \n \ndef modnCr(n,r,mod,fac,inv): #上で求めたfacとinvsを引数に入れるべし\n \n return fac[n] * inv[n-r] * inv[r] % mod\n\n\nH,W,A,B = map(int,input().split())\n\nmod = 10 ** 9 + 7\nans = 0\n\nfac,inv = modfac(H+W,mod)\n\nfor i in range(H-A):\n\n now = modnCr(i + B-1, i,mod,fac,inv)\n now *= modnCr(H+W-i-B-2,W-B-1,mod,fac,inv)\n\n ans += now\n ans %= mod\n\nprint (ans)",
"def modmal(a,b,mod): #a*bをmodを法にして求める\n \n return a * b % mod\n \n \n#modの割り算\n ",
"modmal",
"return a * b % mod",
"a * b % mod",
"a * b",
"a",
"b",
"mod",
"a",
"a",
"b",
"b",
"mod",
"mod",
"def moddiv(a,b,mod): #a/bをmodを法にして求める\n \n return (a * pow(b,mod-2)) % mod\n \n \n#逆元\n ",
"moddiv",
"return (a * pow(b,mod-2)) % mod",
"(a * pow(b,mod-2)) % mod",
"a * pow(b,mod-2)",
"a",
"pow(b,mod-2)",
"pow",
"b",
"mod-2",
"mod",
"2",
"mod",
"a",
"a",
"b",
"b",
"mod",
"mod",
"def inverse(a,mod): #aのmodを法にした逆元を返す\n return pow(a,mod-2)\n \n \n \n#modのn!と、n!の逆元を格納したリストを返す(拾いもの)\n#factorialsには[1, 1!%mod , 2!%mod , 6!%mod… , n!%mod] が入っている\n#invsには↑の逆元が入っている\n ",
"inverse",
"return pow(a,mod-2)",
"pow(a,mod-2)",
"pow",
"a",
"mod-2",
"mod",
"2",
"a",
"a",
"mod",
"mod",
"def modfac(n, MOD):\n \n f = 1\n factorials = [1]\n for m in range(1, n + 1):\n f *= m\n f %= MOD\n factorials.append(f)\n inv = pow(f, MOD - 2, MOD)\n invs = [1] * (n + 1)\n invs[n] = inv\n for m in range(n, 1, -1):\n inv *= m\n inv %= MOD\n invs[m - 1] = inv\n return factorials, invs\n \n ",
"modfac",
"f = 1",
"f",
"1",
"factorials = [1]",
"factorials",
"[1]",
"1",
"for m in range(1, n + 1):\n f *= m\n f %= MOD\n factorials.append(f)\n ",
"m",
"range(1, n + 1)",
"range",
"1",
"n + 1",
"n",
"1",
"f *= m",
"f",
"m",
"f %= MOD",
"f",
"MOD",
"factorials.append(f)",
"factorials.append",
"factorials",
"append",
"f",
"inv = pow(f, MOD - 2, MOD)",
"inv",
"pow(f, MOD - 2, MOD)",
"pow",
"f",
"MOD - 2",
"MOD",
"2",
"MOD",
"invs = [1] * (n + 1)",
"invs",
"[1] * (n + 1)",
"[1]",
"1",
"n + 1",
"n",
"1",
"invs[n] = inv",
"invs[n]",
"invs",
"n",
"inv",
"for m in range(n, 1, -1):\n inv *= m\n inv %= MOD\n invs[m - 1] = inv\n ",
"m",
"range(n, 1, -1)",
"range",
"n",
"1",
"-1",
"inv *= m",
"inv",
"m",
"inv %= MOD",
"inv",
"MOD",
"invs[m - 1] = inv",
"invs[m - 1]",
"invs",
"m - 1",
"m",
"1",
"inv",
"return factorials, invs",
"return factorials, invs",
"factorials",
"invs",
"n",
"n",
"MOD",
"MOD",
"def modnCr(n,r,mod,fac,inv): #上で求めたfacとinvsを引数に入れるべし\n \n return fac[n] * inv[n-r] * inv[r] % mod",
"modnCr",
"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",
"mod",
"mod",
"fac",
"fac",
"inv",
"inv",
"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",
"ans = 0",
"ans",
"0",
"fac,inv = modfac(H+W,mod)",
"fac",
"modfac(H+W,mod)",
"modfac",
"H+W",
"H",
"W",
"mod",
"inv",
"for i in range(H-A):\n\n now = modnCr(i + B-1, i,mod,fac,inv)\n now *= modnCr(H+W-i-B-2,W-B-1,mod,fac,inv)\n\n ans += now\n ans %= mod",
"i",
"range(H-A)",
"range",
"H-A",
"H",
"A",
"now = modnCr(i + B-1, i,mod,fac,inv)",
"now",
"modnCr(i + B-1, i,mod,fac,inv)",
"modnCr",
"i + B-1",
"i + B",
"i",
"B",
"1",
"i",
"mod",
"fac",
"inv",
"now *= modnCr(H+W-i-B-2,W-B-1,mod,fac,inv)",
"now",
"modnCr(H+W-i-B-2,W-B-1,mod,fac,inv)",
"modnCr",
"H+W-i-B-2",
"H+W-i-B",
"H+W-i",
"H+W",
"H",
"W",
"i",
"B",
"2",
"W-B-1",
"W-B",
"W",
"B",
"1",
"mod",
"fac",
"inv",
"ans += now",
"ans",
"now",
"ans %= mod",
"ans",
"mod",
"print (ans)",
"print",
"ans",
"ans = 0",
"0",
"ans",
"now = modnCr(i + B-1, i,mod,fac,inv)",
"modnCr(i + B-1, i,mod,fac,inv)",
"now",
"A,B = map(int,input().split())",
"map(int,input().split())",
"A",
"ans %= mod",
"mod",
"ans",
"now *= modnCr(H+W-i-B-2,W-B-1,mod,fac,inv)",
"modnCr(H+W-i-B-2,W-B-1,mod,fac,inv)",
"now",
"W,A,B = map(int,input().split())",
"map(int,input().split())",
"W",
"def modmal(a,b,mod): #a*bをmodを法にして求める\n \n return a * b % mod\n \n \n#modの割り算\n ",
"def modmal(a,b,mod): #a*bをmodを法にして求める\n \n return a * b % mod\n \n \n#modの割り算\n ",
"modmal",
"def modfac(n, MOD):\n \n f = 1\n factorials = [1]\n for m in range(1, n + 1):\n f *= m\n f %= MOD\n factorials.append(f)\n inv = pow(f, MOD - 2, MOD)\n invs = [1] * (n + 1)\n invs[n] = inv\n for m in range(n, 1, -1):\n inv *= m\n inv %= MOD\n invs[m - 1] = inv\n return factorials, invs\n \n ",
"def modfac(n, MOD):\n \n f = 1\n factorials = [1]\n for m in range(1, n + 1):\n f *= m\n f %= MOD\n factorials.append(f)\n inv = pow(f, MOD - 2, MOD)\n invs = [1] * (n + 1)\n invs[n] = inv\n for m in range(n, 1, -1):\n inv *= m\n inv %= MOD\n invs[m - 1] = inv\n return factorials, invs\n \n ",
"modfac",
"inv = modfac(H+W,mod)",
"modfac(H+W,mod)",
"inv",
"def modnCr(n,r,mod,fac,inv): #上で求めたfacとinvsを引数に入れるべし\n \n return fac[n] * inv[n-r] * inv[r] % mod",
"def modnCr(n,r,mod,fac,inv): #上で求めたfacとinvsを引数に入れるべし\n \n return fac[n] * inv[n-r] * inv[r] % mod",
"modnCr",
"def moddiv(a,b,mod): #a/bをmodを法にして求める\n \n return (a * pow(b,mod-2)) % mod\n \n \n#逆元\n ",
"def moddiv(a,b,mod): #a/bをmodを法にして求める\n \n return (a * pow(b,mod-2)) % mod\n \n \n#逆元\n ",
"moddiv",
"mod = 10 ** 9 + 7",
"10 ** 9 + 7",
"mod",
"fac,inv = modfac(H+W,mod)",
"modfac(H+W,mod)",
"fac",
"def inverse(a,mod): #aのmodを法にした逆元を返す\n return pow(a,mod-2)\n \n \n \n#modのn!と、n!の逆元を格納したリストを返す(拾いもの)\n#factorialsには[1, 1!%mod , 2!%mod , 6!%mod… , n!%mod] が入っている\n#invsには↑の逆元が入っている\n ",
"def inverse(a,mod): #aのmodを法にした逆元を返す\n return pow(a,mod-2)\n \n \n \n#modのn!と、n!の逆元を格納したリストを返す(拾いもの)\n#factorialsには[1, 1!%mod , 2!%mod , 6!%mod… , n!%mod] が入っている\n#invsには↑の逆元が入っている\n ",
"inverse",
"B = map(int,input().split())",
"map(int,input().split())",
"B",
"H,W,A,B = map(int,input().split())",
"map(int,input().split())",
"H",
"ans += now",
"now",
"ans"
] |
#modの掛け算
def modmal(a,b,mod): #a*bをmodを法にして求める
return a * b % mod
#modの割り算
def moddiv(a,b,mod): #a/bをmodを法にして求める
return (a * pow(b,mod-2)) % mod
#逆元
def inverse(a,mod): #aのmodを法にした逆元を返す
return pow(a,mod-2)
#modのn!と、n!の逆元を格納したリストを返す(拾いもの)
#factorialsには[1, 1!%mod , 2!%mod , 6!%mod… , n!%mod] が入っている
#invsには↑の逆元が入っている
def modfac(n, MOD):
f = 1
factorials = [1]
for m in range(1, n + 1):
f *= m
f %= MOD
factorials.append(f)
inv = pow(f, MOD - 2, MOD)
invs = [1] * (n + 1)
invs[n] = inv
for m in range(n, 1, -1):
inv *= m
inv %= MOD
invs[m - 1] = inv
return factorials, invs
def modnCr(n,r,mod,fac,inv): #上で求めたfacとinvsを引数に入れるべし
return fac[n] * inv[n-r] * inv[r] % mod
H,W,A,B = map(int,input().split())
mod = 10 ** 9 + 7
ans = 0
fac,inv = modfac(H+W,mod)
for i in range(H-A):
now = modnCr(i + B-1, i,mod,fac,inv)
now *= modnCr(H+W-i-B-2,W-B-1,mod,fac,inv)
ans += now
ans %= mod
print (ans)
|
[
7,
12,
13,
14,
2,
13,
17,
29,
39,
17,
17,
13,
0,
13,
4,
13,
13,
2,
13,
13,
13,
13,
0,
13,
2,
2,
13,
13,
13,
29,
39,
13,
13,
13,
23,
13,
23,
13,
12,
13,
0,
13,
4,
13,
13,
13,
13,
13,
29,
2,
13,
13,
23,
13,
23,
13,
12,
13,
41,
28,
13,
4,
13,
2,
13,
13,
4,
17,
0,
13,
13,
0,
13,
17,
28,
13,
4,
13,
2,
13,
13,
0,
18,
13,
13,
13,
0,
13,
2,
13,
13,
0,
13,
18,
13,
2,
13,
17,
0,
13,
13,
29,
13,
23,
13,
23,
13,
23,
13,
23,
13,
23,
13,
23,
13,
12,
13,
41,
28,
13,
4,
13,
2,
13,
13,
4,
17,
0,
13,
13,
0,
13,
17,
28,
13,
4,
13,
17,
2,
13,
17,
0,
13,
2,
2,
2,
13,
13,
13,
17,
0,
13,
18,
13,
13,
0,
13,
13,
28,
13,
4,
13,
2,
2,
13,
13,
17,
17,
17,
0,
18,
13,
13,
13,
0,
13,
2,
2,
2,
2,
13,
13,
13,
13,
17,
0,
13,
18,
13,
2,
13,
13,
0,
13,
13,
29,
13,
23,
13,
23,
13,
23,
13,
23,
13,
23,
13,
23,
13,
12,
13,
0,
13,
2,
2,
17,
17,
17,
0,
13,
4,
13,
4,
13,
13,
4,
18,
4,
13,
13,
17,
13,
13,
13,
41,
28,
13,
4,
13,
17,
2,
13,
17,
4,
4,
13,
13,
13,
0,
13,
2,
39,
17,
13,
0,
13,
4,
13,
13,
13,
13,
13,
13,
13,
0,
13,
4,
13,
13,
13,
13,
13,
13,
13,
0,
13,
17,
28,
13,
13,
4,
13,
13,
13,
0,
13,
2,
13,
13,
0,
13,
13,
4,
13,
13,
14,
2,
13,
17,
4,
13,
10,
12,
13,
10,
12,
13,
10,
12,
13,
10,
12,
13,
10,
12,
13
] | [
[
37,
5
],
[
14,
13
],
[
37,
16
],
[
35,
18
],
[
37,
19
],
[
14,
20
],
[
14,
21
],
[
24,
23
],
[
35,
26
],
[
37,
27
],
[
20,
28
],
[
35,
35
],
[
37,
37
],
[
42,
41
],
[
315,
43
],
[
53,
44
],
[
55,
45
],
[
42,
46
],
[
42,
47
],
[
41,
50
],
[
55,
51
],
[
53,
53
],
[
55,
55
],
[
61,
60
],
[
104,
64
],
[
108,
65
],
[
70,
69
],
[
73,
72
],
[
76,
75
],
[
104,
79
],
[
108,
80
],
[
85,
82
],
[
69,
83
],
[
75,
84
],
[
72,
85
],
[
99,
85
],
[
92,
85
],
[
87,
85
],
[
88,
87
],
[
75,
89
],
[
110,
90
],
[
93,
92
],
[
114,
94
],
[
75,
96
],
[
100,
99
],
[
112,
100
],
[
69,
102
],
[
104,
104
],
[
106,
106
],
[
108,
108
],
[
110,
110
],
[
112,
112
],
[
114,
114
],
[
120,
119
],
[
198,
123
],
[
202,
124
],
[
129,
128
],
[
132,
131
],
[
135,
134
],
[
202,
139
],
[
143,
142
],
[
134,
146
],
[
200,
147
],
[
204,
148
],
[
152,
151
],
[
208,
153
],
[
134,
154
],
[
157,
156
],
[
206,
157
],
[
160,
159
],
[
198,
164
],
[
202,
165
],
[
173,
170
],
[
128,
171
],
[
159,
172
],
[
156,
173
],
[
151,
173
],
[
142,
173
],
[
131,
173
],
[
193,
173
],
[
186,
173
],
[
175,
173
],
[
176,
175
],
[
198,
180
],
[
159,
181
],
[
200,
182
],
[
204,
183
],
[
187,
186
],
[
208,
188
],
[
198,
190
],
[
159,
191
],
[
194,
193
],
[
206,
194
],
[
128,
196
],
[
198,
198
],
[
200,
200
],
[
202,
202
],
[
204,
204
],
[
206,
206
],
[
208,
208
],
[
213,
212
],
[
220,
219
],
[
220,
231
],
[
220,
232
],
[
220,
233
],
[
237,
236
],
[
219,
241
],
[
309,
245
],
[
236,
246
],
[
212,
247
],
[
250,
249
],
[
256,
255
],
[
312,
257
],
[
219,
258
],
[
231,
259
],
[
232,
260
],
[
233,
261
],
[
212,
262
],
[
249,
263
],
[
266,
265
],
[
303,
267
],
[
219,
268
],
[
231,
269
],
[
232,
270
],
[
233,
271
],
[
212,
272
],
[
249,
273
],
[
276,
275
],
[
255,
282
],
[
265,
283
],
[
286,
285
],
[
291,
290
],
[
212,
291
],
[
290,
294
],
[
285,
294
],
[
275,
294
],
[
306,
300
]
] | [
"def ext_euclid(a, b):\n # return (x, y, gcd(a, b)) such that a * x + b * y = gcd(a, b)\n if b == 0:\n return 1, 0, a\n y, x, v = ext_euclid(b, a % b)\n y -= (a // b) * x\n return x, y, v\n\n\ndef mod_inv(a, mod):\n x, _, _ = ext_euclid(a, mod)\n return x % mod\n\n\ndef comb_list_1(H, W, A, B, mod, modinv_list):\n # (h+B-1)_C_(B-1) (h in {0, ..., H-A-1})\n ret = [0 for _ in range(H - A)]\n c = 1\n for h in range(H - A):\n ret[h] = c\n c *= h + B\n c *= modinv_list[h + 1]\n c %= mod\n return ret\n\n\ndef comb_list_2(H, W, A, B, mod, modinv_list):\n # (-h+H+W-B-2)_C_(W-B-1) (h in {0, ..., H-A-1})\n ret = [0 for _ in range(H - A)]\n # initial value -> (A+W-B-1)_C_(W-B-1) (h = H-A-1)\n c = 1\n for a in range(1, A + 1):\n c *= (a + W - B - 1)\n c *= modinv_list[a]\n c %= mod\n # fill elements of result list from the back\n for h in range(H - A - 1, -1, -1):\n ret[h] = c\n c *= H - h + W - B - 1\n c *= modinv_list[H - h]\n c %= mod\n return ret\n\n\ndef main():\n MOD = 10 ** 9 + 7\n H, W, A, B = list(map(int, input().split(' ')))\n modinv_list = [None] + [mod_inv(h, MOD) for h in range(1, H + 1)] # modinv doesn't exist on h = 0\n combs_1 = comb_list_1(H, W, A, B, MOD, modinv_list)\n combs_2 = comb_list_2(H, W, A, B, MOD, modinv_list)\n ans = 0\n for c1, c2 in zip(combs_1, combs_2):\n ans += c1 * c2\n ans %= MOD\n print(ans)\n\n\nif __name__ == '__main__':\n main()",
"def ext_euclid(a, b):\n # return (x, y, gcd(a, b)) such that a * x + b * y = gcd(a, b)\n if b == 0:\n return 1, 0, a\n y, x, v = ext_euclid(b, a % b)\n y -= (a // b) * x\n return x, y, v",
"ext_euclid",
"if b == 0:\n return 1, 0, a\n ",
"b == 0",
"b",
"0",
"return 1, 0, a",
"return 1, 0, a",
"1",
"0",
"a",
"y, x, v = ext_euclid(b, a % b)",
"y",
"ext_euclid(b, a % b)",
"ext_euclid",
"b",
"a % b",
"a",
"b",
"x",
"v",
"y -= (a // b) * x",
"y",
"(a // b) * x",
"a // b",
"a",
"b",
"x",
"return x, y, v",
"return x, y, v",
"x",
"y",
"v",
"a",
"a",
"b",
"b",
"def mod_inv(a, mod):\n x, _, _ = ext_euclid(a, mod)\n return x % mod",
"mod_inv",
"x, _, _ = ext_euclid(a, mod)",
"x",
"ext_euclid(a, mod)",
"ext_euclid",
"a",
"mod",
"_",
"_",
"return x % mod",
"x % mod",
"x",
"mod",
"a",
"a",
"mod",
"mod",
"def comb_list_1(H, W, A, B, mod, modinv_list):\n # (h+B-1)_C_(B-1) (h in {0, ..., H-A-1})\n ret = [0 for _ in range(H - A)]\n c = 1\n for h in range(H - A):\n ret[h] = c\n c *= h + B\n c *= modinv_list[h + 1]\n c %= mod\n return ret",
"comb_list_1",
"0 for _ in range(H - A)",
"for _ in range(H - A)",
"_",
"range(H - A)",
"range",
"H - A",
"H",
"A",
"for _ in range(H - A)",
"0",
"ret = [0 for _ in range(H - A)]",
"ret",
"[0 for _ in range(H - A)]",
"c = 1",
"c",
"1",
"for h in range(H - A):\n ret[h] = c\n c *= h + B\n c *= modinv_list[h + 1]\n c %= mod\n ",
"h",
"range(H - A)",
"range",
"H - A",
"H",
"A",
"ret[h] = c",
"ret[h]",
"ret",
"h",
"c",
"c *= h + B",
"c",
"h + B",
"h",
"B",
"c *= modinv_list[h + 1]",
"c",
"modinv_list[h + 1]",
"modinv_list",
"h + 1",
"h",
"1",
"c %= mod",
"c",
"mod",
"return ret",
"ret",
"H",
"H",
"W",
"W",
"A",
"A",
"B",
"B",
"mod",
"mod",
"modinv_list",
"modinv_list",
"def comb_list_2(H, W, A, B, mod, modinv_list):\n # (-h+H+W-B-2)_C_(W-B-1) (h in {0, ..., H-A-1})\n ret = [0 for _ in range(H - A)]\n # initial value -> (A+W-B-1)_C_(W-B-1) (h = H-A-1)\n c = 1\n for a in range(1, A + 1):\n c *= (a + W - B - 1)\n c *= modinv_list[a]\n c %= mod\n # fill elements of result list from the back\n for h in range(H - A - 1, -1, -1):\n ret[h] = c\n c *= H - h + W - B - 1\n c *= modinv_list[H - h]\n c %= mod\n return ret",
"comb_list_2",
"0 for _ in range(H - A)",
"for _ in range(H - A)",
"_",
"range(H - A)",
"range",
"H - A",
"H",
"A",
"for _ in range(H - A)",
"0",
"ret = [0 for _ in range(H - A)]",
"ret",
"[0 for _ in range(H - A)]",
"c = 1",
"c",
"1",
"for a in range(1, A + 1):\n c *= (a + W - B - 1)\n c *= modinv_list[a]\n c %= mod\n # fill elements of result list from the back\n ",
"a",
"range(1, A + 1)",
"range",
"1",
"A + 1",
"A",
"1",
"c *= (a + W - B - 1)",
"c",
"a + W - B - 1",
"a + W - B",
"a + W",
"a",
"W",
"B",
"1",
"c *= modinv_list[a]",
"c",
"modinv_list[a]",
"modinv_list",
"a",
"c %= mod",
"c",
"mod",
"for h in range(H - A - 1, -1, -1):\n ret[h] = c\n c *= H - h + W - B - 1\n c *= modinv_list[H - h]\n c %= mod\n ",
"h",
"range(H - A - 1, -1, -1)",
"range",
"H - A - 1",
"H - A",
"H",
"A",
"1",
"-1",
"-1",
"ret[h] = c",
"ret[h]",
"ret",
"h",
"c",
"c *= H - h + W - B - 1",
"c",
"H - h + W - B - 1",
"H - h + W - B",
"H - h + W",
"H - h",
"H",
"h",
"W",
"B",
"1",
"c *= modinv_list[H - h]",
"c",
"modinv_list[H - h]",
"modinv_list",
"H - h",
"H",
"h",
"c %= mod",
"c",
"mod",
"return ret",
"ret",
"H",
"H",
"W",
"W",
"A",
"A",
"B",
"B",
"mod",
"mod",
"modinv_list",
"modinv_list",
"def main():\n MOD = 10 ** 9 + 7\n H, W, A, B = list(map(int, input().split(' ')))\n modinv_list = [None] + [mod_inv(h, MOD) for h in range(1, H + 1)] # modinv doesn't exist on h = 0\n combs_1 = comb_list_1(H, W, A, B, MOD, modinv_list)\n combs_2 = comb_list_2(H, W, A, B, MOD, modinv_list)\n ans = 0\n for c1, c2 in zip(combs_1, combs_2):\n ans += c1 * c2\n ans %= MOD\n print(ans)",
"main",
"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",
"mod_inv(h, MOD) for h in range(1, H + 1)",
"for h in range(1, H + 1)",
"h",
"range(1, H + 1)",
"range",
"1",
"H + 1",
"H",
"1",
"for h in range(1, H + 1)",
"mod_inv(h, MOD)",
"mod_inv",
"h",
"MOD",
"modinv_list = [None] + [mod_inv(h, MOD) for h in range(1, H + 1)]",
"modinv_list",
"[None] + [mod_inv(h, MOD) for h in range(1, H + 1)]",
"[None]",
"None",
"[mod_inv(h, MOD) for h in range(1, H + 1)]",
"combs_1 = comb_list_1(H, W, A, B, MOD, modinv_list)",
"combs_1",
"comb_list_1(H, W, A, B, MOD, modinv_list)",
"comb_list_1",
"H",
"W",
"A",
"B",
"MOD",
"modinv_list",
"combs_2 = comb_list_2(H, W, A, B, MOD, modinv_list)",
"combs_2",
"comb_list_2(H, W, A, B, MOD, modinv_list)",
"comb_list_2",
"H",
"W",
"A",
"B",
"MOD",
"modinv_list",
"ans = 0",
"ans",
"0",
"for c1, c2 in zip(combs_1, combs_2):\n ans += c1 * c2\n ans %= MOD\n ",
"c1",
"c2",
"zip(combs_1, combs_2)",
"zip",
"combs_1",
"combs_2",
"ans += c1 * c2",
"ans",
"c1 * c2",
"c1",
"c2",
"ans %= MOD",
"ans",
"MOD",
"print(ans)",
"print",
"ans",
"if __name__ == '__main__':\n main()",
"__name__ == '__main__'",
"__name__",
"'__main__'",
"main()",
"main",
"def comb_list_2(H, W, A, B, mod, modinv_list):\n # (-h+H+W-B-2)_C_(W-B-1) (h in {0, ..., H-A-1})\n ret = [0 for _ in range(H - A)]\n # initial value -> (A+W-B-1)_C_(W-B-1) (h = H-A-1)\n c = 1\n for a in range(1, A + 1):\n c *= (a + W - B - 1)\n c *= modinv_list[a]\n c %= mod\n # fill elements of result list from the back\n for h in range(H - A - 1, -1, -1):\n ret[h] = c\n c *= H - h + W - B - 1\n c *= modinv_list[H - h]\n c %= mod\n return ret",
"def comb_list_2(H, W, A, B, mod, modinv_list):\n # (-h+H+W-B-2)_C_(W-B-1) (h in {0, ..., H-A-1})\n ret = [0 for _ in range(H - A)]\n # initial value -> (A+W-B-1)_C_(W-B-1) (h = H-A-1)\n c = 1\n for a in range(1, A + 1):\n c *= (a + W - B - 1)\n c *= modinv_list[a]\n c %= mod\n # fill elements of result list from the back\n for h in range(H - A - 1, -1, -1):\n ret[h] = c\n c *= H - h + W - B - 1\n c *= modinv_list[H - h]\n c %= mod\n return ret",
"comb_list_2",
"def main():\n MOD = 10 ** 9 + 7\n H, W, A, B = list(map(int, input().split(' ')))\n modinv_list = [None] + [mod_inv(h, MOD) for h in range(1, H + 1)] # modinv doesn't exist on h = 0\n combs_1 = comb_list_1(H, W, A, B, MOD, modinv_list)\n combs_2 = comb_list_2(H, W, A, B, MOD, modinv_list)\n ans = 0\n for c1, c2 in zip(combs_1, combs_2):\n ans += c1 * c2\n ans %= MOD\n print(ans)",
"def main():\n MOD = 10 ** 9 + 7\n H, W, A, B = list(map(int, input().split(' ')))\n modinv_list = [None] + [mod_inv(h, MOD) for h in range(1, H + 1)] # modinv doesn't exist on h = 0\n combs_1 = comb_list_1(H, W, A, B, MOD, modinv_list)\n combs_2 = comb_list_2(H, W, A, B, MOD, modinv_list)\n ans = 0\n for c1, c2 in zip(combs_1, combs_2):\n ans += c1 * c2\n ans %= MOD\n print(ans)",
"main",
"def mod_inv(a, mod):\n x, _, _ = ext_euclid(a, mod)\n return x % mod",
"def mod_inv(a, mod):\n x, _, _ = ext_euclid(a, mod)\n return x % mod",
"mod_inv",
"def comb_list_1(H, W, A, B, mod, modinv_list):\n # (h+B-1)_C_(B-1) (h in {0, ..., H-A-1})\n ret = [0 for _ in range(H - A)]\n c = 1\n for h in range(H - A):\n ret[h] = c\n c *= h + B\n c *= modinv_list[h + 1]\n c %= mod\n return ret",
"def comb_list_1(H, W, A, B, mod, modinv_list):\n # (h+B-1)_C_(B-1) (h in {0, ..., H-A-1})\n ret = [0 for _ in range(H - A)]\n c = 1\n for h in range(H - A):\n ret[h] = c\n c *= h + B\n c *= modinv_list[h + 1]\n c %= mod\n return ret",
"comb_list_1",
"def ext_euclid(a, b):\n # return (x, y, gcd(a, b)) such that a * x + b * y = gcd(a, b)\n if b == 0:\n return 1, 0, a\n y, x, v = ext_euclid(b, a % b)\n y -= (a // b) * x\n return x, y, v",
"def ext_euclid(a, b):\n # return (x, y, gcd(a, b)) such that a * x + b * y = gcd(a, b)\n if b == 0:\n return 1, 0, a\n y, x, v = ext_euclid(b, a % b)\n y -= (a // b) * x\n return x, y, v",
"ext_euclid"
] | def ext_euclid(a, b):
# return (x, y, gcd(a, b)) such that a * x + b * y = gcd(a, b)
if b == 0:
return 1, 0, a
y, x, v = ext_euclid(b, a % b)
y -= (a // b) * x
return x, y, v
def mod_inv(a, mod):
x, _, _ = ext_euclid(a, mod)
return x % mod
def comb_list_1(H, W, A, B, mod, modinv_list):
# (h+B-1)_C_(B-1) (h in {0, ..., H-A-1})
ret = [0 for _ in range(H - A)]
c = 1
for h in range(H - A):
ret[h] = c
c *= h + B
c *= modinv_list[h + 1]
c %= mod
return ret
def comb_list_2(H, W, A, B, mod, modinv_list):
# (-h+H+W-B-2)_C_(W-B-1) (h in {0, ..., H-A-1})
ret = [0 for _ in range(H - A)]
# initial value -> (A+W-B-1)_C_(W-B-1) (h = H-A-1)
c = 1
for a in range(1, A + 1):
c *= (a + W - B - 1)
c *= modinv_list[a]
c %= mod
# fill elements of result list from the back
for h in range(H - A - 1, -1, -1):
ret[h] = c
c *= H - h + W - B - 1
c *= modinv_list[H - h]
c %= mod
return ret
def main():
MOD = 10 ** 9 + 7
H, W, A, B = list(map(int, input().split(' ')))
modinv_list = [None] + [mod_inv(h, MOD) for h in range(1, H + 1)] # modinv doesn't exist on h = 0
combs_1 = comb_list_1(H, W, A, B, MOD, modinv_list)
combs_2 = comb_list_2(H, W, A, B, MOD, modinv_list)
ans = 0
for c1, c2 in zip(combs_1, combs_2):
ans += c1 * c2
ans %= MOD
print(ans)
if __name__ == '__main__':
main() |
[
7,
15,
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,
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,
2,
2,
13,
13,
17,
17,
17,
4,
18,
13,
13,
2,
2,
18,
13,
17,
13,
13,
0,
13,
4,
13,
4,
13,
13,
12,
13,
29,
2,
2,
18,
13,
13,
18,
13,
13,
18,
13,
2,
13,
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,
4,
13,
2,
2,
2,
2,
13,
17,
13,
13,
17,
2,
13,
17,
13,
0,
13,
13,
4,
13,
13,
10,
2,
13,
10,
13,
13,
10,
2,
13,
10,
39,
13,
10,
12,
13,
10,
39,
13,
10,
4,
13,
10,
4,
13,
10,
4,
13,
10,
4,
13,
10,
17,
13,
10,
4,
13
] | [
[
186,
3
],
[
186,
12
],
[
186,
13
],
[
186,
14
],
[
159,
16
],
[
168,
23
],
[
28,
27
],
[
187,
33
],
[
181,
34
],
[
169,
38
],
[
169,
43
],
[
27,
45
],
[
160,
46
],
[
162,
48
],
[
169,
53
],
[
160,
56
],
[
160,
58
],
[
61,
60
],
[
187,
65
],
[
181,
66
],
[
163,
72
],
[
163,
77
],
[
60,
79
],
[
160,
80
],
[
171,
82
],
[
163,
87
],
[
169,
94
],
[
105,
95
],
[
172,
97
],
[
107,
98
],
[
172,
100
],
[
105,
102
],
[
107,
103
],
[
105,
105
],
[
107,
107
],
[
183,
109
],
[
113,
112
],
[
175,
115
],
[
181,
116
],
[
153,
118
],
[
166,
122
],
[
187,
126
],
[
178,
127
],
[
112,
129
],
[
112,
130
],
[
166,
132
],
[
178,
137
],
[
181,
139
],
[
112,
140
],
[
178,
143
],
[
160,
145
],
[
156,
147
],
[
160,
148
],
[
157,
151
],
[
154,
151
],
[
184,
151
],
[
153,
154
],
[
160,
156
],
[
156,
157
],
[
159,
160
],
[
162,
163
],
[
168,
169
],
[
171,
172
],
[
186,
175
],
[
186,
178
],
[
186,
181
],
[
183,
184
],
[
186,
187
]
] | [
"from math import factorial\n\nh, w, a, b = map(int, input().split())\nMOD = 10**9+7\n\nfact = [1]\n\n# 累積乗を作る\nfor i in range(1, h+w-1):\n fact.append(fact[-1] * i % MOD)\n\n# 累積乗の逆元\ninv_fact = [pow(fact[-1], MOD-2, MOD)] # x^(-1) = x^(10^9+5) % (10^9+7), フェルマーの小定理\nfor i in range(h+w-2, 0, -1): # xが最大の場合を求め、後ろ向きに計算していく\n inv_fact.append(inv_fact[-1] * i % MOD)\ninv = list(reversed(inv_fact)) # 逆順に取得\n\n#print(fact, inv_fact, inv)\ndef comb(x, y):\n return (fact[x] * inv[y] * inv[x-y])\n\nans = 0\nfor x in range(b, w):\n ans += ((comb((h-a-1 + x), x)) * (comb((a-1 + w-x-1), a-1)) % MOD)\n ans %= MOD\n\nprint(ans)",
"from math import factorial",
"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]",
"fact",
"[1]",
"1",
"for i in range(1, h+w-1):\n fact.append(fact[-1] * i % MOD)\n\n# 累積乗の逆元",
"i",
"range(1, h+w-1)",
"range",
"1",
"h+w-1",
"h+w",
"h",
"w",
"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_fact = [pow(fact[-1], MOD-2, MOD)]",
"inv_fact",
"[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 range(h+w-2, 0, -1): # xが最大の場合を求め、後ろ向きに計算していく\n inv_fact.append(inv_fact[-1] * i % MOD)",
"i",
"range(h+w-2, 0, -1)",
"range",
"h+w-2",
"h+w",
"h",
"w",
"2",
"0",
"-1",
"inv_fact.append(inv_fact[-1] * i % MOD)",
"inv_fact.append",
"inv_fact",
"append",
"inv_fact[-1] * i % MOD",
"inv_fact[-1] * i",
"inv_fact[-1]",
"inv_fact",
"-1",
"i",
"MOD",
"inv = list(reversed(inv_fact))",
"inv",
"list(reversed(inv_fact))",
"list",
"reversed(inv_fact)",
"reversed",
"inv_fact",
"def comb(x, y):\n return (fact[x] * inv[y] * inv[x-y])",
"comb",
"return (fact[x] * inv[y] * inv[x-y])",
"fact[x] * inv[y] * inv[x-y]",
"fact[x] * inv[y]",
"fact[x]",
"fact",
"x",
"inv[y]",
"inv",
"y",
"inv[x-y]",
"inv",
"x-y",
"x",
"y",
"x",
"x",
"y",
"y",
"ans = 0",
"ans",
"0",
"for x in range(b, w):\n ans += ((comb((h-a-1 + x), x)) * (comb((a-1 + w-x-1), a-1)) % MOD)\n ans %= MOD",
"x",
"range(b, w)",
"range",
"b",
"w",
"ans += ((comb((h-a-1 + x), x)) * (comb((a-1 + w-x-1), a-1)) % MOD)",
"ans",
"(comb((h-a-1 + x), x)) * (comb((a-1 + w-x-1), a-1)) % MOD",
"(comb((h-a-1 + x), x)) * (comb((a-1 + w-x-1), a-1))",
"comb((h-a-1 + x), x)",
"comb",
"h-a-1 + x",
"h-a-1",
"h-a",
"h",
"a",
"1",
"x",
"x",
"comb((a-1 + w-x-1), a-1)",
"comb",
"a-1 + w-x-1",
"a-1 + w-x",
"a-1 + w",
"a-1",
"a",
"1",
"w",
"x",
"1",
"a-1",
"a",
"1",
"MOD",
"ans %= MOD",
"ans",
"MOD",
"print(ans)",
"print",
"ans",
"ans += ((comb((h-a-1 + x), x)) * (comb((a-1 + w-x-1), a-1)) % MOD)",
"(comb((h-a-1 + x), x)) * (comb((a-1 + w-x-1), a-1)) % MOD",
"ans",
"ans %= MOD",
"MOD",
"ans",
"MOD = 10**9+7",
"10**9+7",
"MOD",
"inv_fact = [pow(fact[-1], MOD-2, MOD)]",
"[pow(fact[-1], MOD-2, MOD)]",
"inv_fact",
"def comb(x, y):\n return (fact[x] * inv[y] * inv[x-y])",
"def comb(x, y):\n return (fact[x] * inv[y] * inv[x-y])",
"comb",
"fact = [1]",
"[1]",
"fact",
"inv = list(reversed(inv_fact))",
"list(reversed(inv_fact))",
"inv",
"b = map(int, input().split())",
"map(int, input().split())",
"b",
"a, b = map(int, input().split())",
"map(int, input().split())",
"a",
"w, a, b = map(int, input().split())",
"map(int, input().split())",
"w",
"ans = 0",
"0",
"ans",
"h, w, a, b = map(int, input().split())",
"map(int, input().split())",
"h"
] | from math import factorial
h, w, a, b = map(int, input().split())
MOD = 10**9+7
fact = [1]
# 累積乗を作る
for i in range(1, h+w-1):
fact.append(fact[-1] * i % MOD)
# 累積乗の逆元
inv_fact = [pow(fact[-1], MOD-2, MOD)] # x^(-1) = x^(10^9+5) % (10^9+7), フェルマーの小定理
for i in range(h+w-2, 0, -1): # xが最大の場合を求め、後ろ向きに計算していく
inv_fact.append(inv_fact[-1] * i % MOD)
inv = list(reversed(inv_fact)) # 逆順に取得
#print(fact, inv_fact, inv)
def comb(x, y):
return (fact[x] * inv[y] * inv[x-y])
ans = 0
for x in range(b, w):
ans += ((comb((h-a-1 + x), x)) * (comb((a-1 + w-x-1), a-1)) % MOD)
ans %= MOD
print(ans)
|
[
7,
0,
13,
2,
2,
17,
17,
17,
0,
13,
4,
13,
13,
4,
18,
4,
13,
13,
13,
13,
13,
12,
13,
29,
4,
13,
13,
2,
13,
17,
13,
23,
13,
12,
13,
29,
2,
2,
18,
13,
13,
18,
13,
13,
18,
13,
2,
13,
13,
23,
13,
23,
13,
0,
13,
21,
22,
17,
17,
0,
13,
21,
22,
17,
17,
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,
0,
13,
17,
14,
40,
2,
13,
13,
2,
13,
13,
28,
13,
4,
13,
13,
13,
0,
13,
2,
4,
13,
2,
2,
2,
13,
13,
13,
17,
13,
4,
13,
2,
2,
2,
13,
13,
13,
17,
2,
2,
13,
17,
13,
0,
13,
13,
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,
2,
2,
13,
13,
17,
13,
0,
13,
13,
4,
13,
13,
10,
4,
13,
10,
17,
13,
10,
12,
13,
10,
2,
13,
10,
2,
13,
10,
4,
13,
10,
4,
13,
10,
17,
13,
10,
2,
13,
10,
13,
13,
10,
21,
13,
10,
13,
13,
10,
2,
13,
10,
4,
13,
10,
12,
13,
10,
21,
13
] | [
[
225,
2
],
[
228,
9
],
[
228,
18
],
[
228,
19
],
[
228,
20
],
[
32,
26
],
[
226,
28
],
[
226,
30
],
[
32,
32
],
[
50,
40
],
[
52,
43
],
[
50,
47
],
[
52,
48
],
[
50,
50
],
[
52,
52
],
[
219,
54
],
[
234,
60
],
[
192,
66
],
[
70,
69
],
[
190,
75
],
[
208,
76
],
[
198,
79
],
[
193,
82
],
[
199,
82
],
[
69,
83
],
[
226,
84
],
[
89,
86
],
[
220,
87
],
[
69,
88
],
[
199,
89
],
[
193,
89
],
[
94,
91
],
[
235,
92
],
[
69,
93
],
[
232,
95
],
[
199,
96
],
[
193,
96
],
[
210,
98
],
[
190,
103
],
[
229,
104
],
[
208,
106
],
[
205,
107
],
[
110,
109
],
[
205,
112
],
[
208,
113
],
[
201,
115
],
[
196,
118
],
[
190,
122
],
[
229,
123
],
[
205,
124
],
[
109,
126
],
[
196,
128
],
[
208,
132
],
[
229,
133
],
[
205,
134
],
[
208,
138
],
[
109,
140
],
[
222,
142
],
[
226,
143
],
[
146,
145
],
[
190,
149
],
[
229,
150
],
[
213,
152
],
[
196,
155
],
[
190,
159
],
[
229,
160
],
[
205,
161
],
[
205,
164
],
[
145,
165
],
[
196,
167
],
[
208,
171
],
[
229,
172
],
[
205,
173
],
[
208,
178
],
[
205,
179
],
[
145,
181
],
[
216,
183
],
[
226,
184
],
[
217,
187
],
[
214,
187
],
[
223,
187
],
[
202,
187
],
[
211,
187
],
[
228,
190
],
[
192,
193
],
[
198,
199
],
[
201,
202
],
[
228,
205
],
[
228,
208
],
[
210,
211
],
[
213,
214
],
[
226,
216
],
[
216,
217
],
[
219,
220
],
[
226,
222
],
[
222,
223
],
[
225,
226
],
[
228,
229
],
[
234,
235
]
] | [
"MOD=10**9+7\nH,W,A,B=map(int,input().split())\n\ndef invmod(a):\n return pow(a,MOD-2,MOD)\ndef comb_mod(n,r):\n return fact_dic[n]*fact_inv_dic[r]*fact_inv_dic[n-r]\n\nfact_dic={0:1}\nfact_inv_dic={0:1}\nfact_mod=1\nfor i in range(1,H+W-1):\n fact_mod=(fact_mod*i)%MOD\n fact_dic[i]=fact_mod\n fact_inv_dic[i]=invmod(fact_mod)\n \nanswer=0\nif H-A>=W-B:\n for i in range(B,W):\n answer+=comb_mod(H-A+B-1,i)*comb_mod(W+A-B-1,W-1-i)\n answer%=MOD\nelse:\n for j in range(H-A):\n answer+=comb_mod(H-A+B-1,B+j)*comb_mod(W+A-B-1,W-B-1-j)\n answer%=MOD\n \nprint(answer)",
"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 invmod(a):\n return pow(a,MOD-2,MOD)",
"invmod",
"return pow(a,MOD-2,MOD)",
"pow(a,MOD-2,MOD)",
"pow",
"a",
"MOD-2",
"MOD",
"2",
"MOD",
"a",
"a",
"def comb_mod(n,r):\n return fact_dic[n]*fact_inv_dic[r]*fact_inv_dic[n-r]",
"comb_mod",
"return fact_dic[n]*fact_inv_dic[r]*fact_inv_dic[n-r]",
"fact_dic[n]*fact_inv_dic[r]*fact_inv_dic[n-r]",
"fact_dic[n]*fact_inv_dic[r]",
"fact_dic[n]",
"fact_dic",
"n",
"fact_inv_dic[r]",
"fact_inv_dic",
"r",
"fact_inv_dic[n-r]",
"fact_inv_dic",
"n-r",
"n",
"r",
"n",
"n",
"r",
"r",
"fact_dic={0:1}",
"fact_dic",
"{0:1}",
"0",
"0",
"1",
"fact_inv_dic={0:1}",
"fact_inv_dic",
"{0:1}",
"0",
"0",
"1",
"fact_mod=1",
"fact_mod",
"1",
"for i in range(1,H+W-1):\n fact_mod=(fact_mod*i)%MOD\n fact_dic[i]=fact_mod\n fact_inv_dic[i]=invmod(fact_mod)\n ",
"i",
"range(1,H+W-1)",
"range",
"1",
"H+W-1",
"H+W",
"H",
"W",
"1",
"fact_mod=(fact_mod*i)%MOD",
"fact_mod",
"(fact_mod*i)%MOD",
"fact_mod*i",
"fact_mod",
"i",
"MOD",
"fact_dic[i]=fact_mod",
"fact_dic[i]",
"fact_dic",
"i",
"fact_mod",
"fact_inv_dic[i]=invmod(fact_mod)",
"fact_inv_dic[i]",
"fact_inv_dic",
"i",
"invmod(fact_mod)",
"invmod",
"fact_mod",
"answer=0",
"answer",
"0",
"if H-A>=W-B:\n for i in range(B,W):\n answer+=comb_mod(H-A+B-1,i)*comb_mod(W+A-B-1,W-1-i)\n answer%=MOD\nelse:\n for j in range(H-A):\n answer+=comb_mod(H-A+B-1,B+j)*comb_mod(W+A-B-1,W-B-1-j)\n answer%=MOD\n ",
"H-A>=W-B",
"H-A",
"H",
"A",
"W-B",
"W",
"B",
"for i in range(B,W):\n answer+=comb_mod(H-A+B-1,i)*comb_mod(W+A-B-1,W-1-i)\n answer%=MOD",
"i",
"range(B,W)",
"range",
"B",
"W",
"answer+=comb_mod(H-A+B-1,i)*comb_mod(W+A-B-1,W-1-i)",
"answer",
"comb_mod(H-A+B-1,i)*comb_mod(W+A-B-1,W-1-i)",
"comb_mod(H-A+B-1,i)",
"comb_mod",
"H-A+B-1",
"H-A+B",
"H-A",
"H",
"A",
"B",
"1",
"i",
"comb_mod(W+A-B-1,W-1-i)",
"comb_mod",
"W+A-B-1",
"W+A-B",
"W+A",
"W",
"A",
"B",
"1",
"W-1-i",
"W-1",
"W",
"1",
"i",
"answer%=MOD",
"answer",
"MOD",
"for j in range(H-A):\n answer+=comb_mod(H-A+B-1,B+j)*comb_mod(W+A-B-1,W-B-1-j)\n answer%=MOD\n ",
"j",
"range(H-A)",
"range",
"H-A",
"H",
"A",
"answer+=comb_mod(H-A+B-1,B+j)*comb_mod(W+A-B-1,W-B-1-j)",
"answer",
"comb_mod(H-A+B-1,B+j)*comb_mod(W+A-B-1,W-B-1-j)",
"comb_mod(H-A+B-1,B+j)",
"comb_mod",
"H-A+B-1",
"H-A+B",
"H-A",
"H",
"A",
"B",
"1",
"B+j",
"B",
"j",
"comb_mod(W+A-B-1,W-B-1-j)",
"comb_mod",
"W+A-B-1",
"W+A-B",
"W+A",
"W",
"A",
"B",
"1",
"W-B-1-j",
"W-B-1",
"W-B",
"W",
"B",
"1",
"j",
"answer%=MOD",
"answer",
"MOD",
"print(answer)",
"print",
"answer",
"H,W,A,B=map(int,input().split())",
"map(int,input().split())",
"H",
"fact_mod=1",
"1",
"fact_mod",
"def comb_mod(n,r):\n return fact_dic[n]*fact_inv_dic[r]*fact_inv_dic[n-r]",
"def comb_mod(n,r):\n return fact_dic[n]*fact_inv_dic[r]*fact_inv_dic[n-r]",
"comb_mod",
"fact_mod=(fact_mod*i)%MOD",
"(fact_mod*i)%MOD",
"fact_mod",
"answer+=comb_mod(H-A+B-1,i)*comb_mod(W+A-B-1,W-1-i)",
"comb_mod(H-A+B-1,i)*comb_mod(W+A-B-1,W-1-i)",
"answer",
"B=map(int,input().split())",
"map(int,input().split())",
"B",
"W,A,B=map(int,input().split())",
"map(int,input().split())",
"W",
"answer=0",
"0",
"answer",
"answer+=comb_mod(H-A+B-1,B+j)*comb_mod(W+A-B-1,W-B-1-j)",
"comb_mod(H-A+B-1,B+j)*comb_mod(W+A-B-1,W-B-1-j)",
"answer",
"answer%=MOD",
"MOD",
"answer",
"fact_dic={0:1}",
"{0:1}",
"fact_dic",
"answer%=MOD",
"MOD",
"answer",
"MOD=10**9+7",
"10**9+7",
"MOD",
"A,B=map(int,input().split())",
"map(int,input().split())",
"A",
"def invmod(a):\n return pow(a,MOD-2,MOD)",
"def invmod(a):\n return pow(a,MOD-2,MOD)",
"invmod",
"fact_inv_dic={0:1}",
"{0:1}",
"fact_inv_dic"
] | MOD=10**9+7
H,W,A,B=map(int,input().split())
def invmod(a):
return pow(a,MOD-2,MOD)
def comb_mod(n,r):
return fact_dic[n]*fact_inv_dic[r]*fact_inv_dic[n-r]
fact_dic={0:1}
fact_inv_dic={0:1}
fact_mod=1
for i in range(1,H+W-1):
fact_mod=(fact_mod*i)%MOD
fact_dic[i]=fact_mod
fact_inv_dic[i]=invmod(fact_mod)
answer=0
if H-A>=W-B:
for i in range(B,W):
answer+=comb_mod(H-A+B-1,i)*comb_mod(W+A-B-1,W-1-i)
answer%=MOD
else:
for j in range(H-A):
answer+=comb_mod(H-A+B-1,B+j)*comb_mod(W+A-B-1,W-B-1-j)
answer%=MOD
print(answer) |
[
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,
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,
2,
2,
13,
13,
17,
2,
13,
17,
13,
28,
13,
4,
13,
2,
2,
13,
13,
17,
2,
13,
17,
0,
13,
2,
4,
13,
2,
2,
13,
13,
17,
2,
13,
17,
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,
39,
13,
10,
2,
13,
10,
2,
13,
10,
39,
13,
10,
2,
13,
10,
4,
13,
10,
12,
13,
10,
39,
13,
10,
4,
13,
10,
4,
13,
10,
4,
13,
10,
13,
13,
10,
4,
13
] | [
[
224,
2
],
[
224,
11
],
[
224,
12
],
[
224,
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
],
[
206,
57
],
[
200,
64
],
[
215,
69
],
[
203,
74
],
[
194,
79
],
[
85,
84
],
[
201,
89
],
[
216,
93
],
[
216,
98
],
[
84,
100
],
[
207,
101
],
[
195,
104
],
[
195,
110
],
[
207,
112
],
[
84,
113
],
[
207,
115
],
[
84,
116
],
[
207,
117
],
[
204,
120
],
[
204,
125
],
[
195,
128
],
[
207,
130
],
[
230,
132
],
[
213,
134
],
[
222,
137
],
[
219,
138
],
[
222,
141
],
[
207,
143
],
[
146,
145
],
[
222,
150
],
[
225,
151
],
[
222,
154
],
[
197,
157
],
[
213,
160
],
[
145,
163
],
[
210,
164
],
[
145,
167
],
[
207,
169
],
[
213,
171
],
[
222,
176
],
[
145,
177
],
[
219,
178
],
[
210,
179
],
[
219,
183
],
[
210,
184
],
[
207,
186
],
[
227,
188
],
[
207,
189
],
[
228,
192
],
[
198,
192
],
[
231,
192
],
[
194,
195
],
[
197,
198
],
[
200,
201
],
[
203,
204
],
[
206,
207
],
[
224,
210
],
[
215,
216
],
[
224,
219
],
[
224,
222
],
[
224,
225
],
[
207,
227
],
[
227,
228
],
[
230,
231
]
] | [
"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\n\nmod = 10**9+7 #出力の制限\nN = 10**6\ng1 = [1, 1] # 元テーブル\ng2 = [1, 1] #逆元テーブル\ninverse = [0, 1] #逆元テーブル計算用テーブル\n\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 )\nans=cmb(h+w-2,h-1,mod)\nfor i in range(h-a+1,h+1):\n ans-=cmb(i+b-2,i-1,mod)*cmb(h-i+w-b-1,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",
"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",
"N",
"10**6",
"10",
"6",
"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",
"ans=cmb(h+w-2,h-1,mod)",
"ans",
"cmb(h+w-2,h-1,mod)",
"cmb",
"h+w-2",
"h+w",
"h",
"w",
"2",
"h-1",
"h",
"1",
"mod",
"for i in range(h-a+1,h+1):\n ans-=cmb(i+b-2,i-1,mod)*cmb(h-i+w-b-1,w-b-1,mod)\n ans%=mod",
"i",
"range(h-a+1,h+1)",
"range",
"h-a+1",
"h-a",
"h",
"a",
"1",
"h+1",
"h",
"1",
"ans-=cmb(i+b-2,i-1,mod)*cmb(h-i+w-b-1,w-b-1,mod)",
"ans",
"cmb(i+b-2,i-1,mod)*cmb(h-i+w-b-1,w-b-1,mod)",
"cmb(i+b-2,i-1,mod)",
"cmb",
"i+b-2",
"i+b",
"i",
"b",
"2",
"i-1",
"i",
"1",
"mod",
"cmb(h-i+w-b-1,w-b-1,mod)",
"cmb",
"h-i+w-b-1",
"h-i+w-b",
"h-i+w",
"h-i",
"h",
"i",
"w",
"b",
"1",
"w-b-1",
"w-b",
"w",
"b",
"1",
"mod",
"ans%=mod",
"ans",
"mod",
"print(ans)",
"print",
"ans",
"inverse = [0, 1]",
"[0, 1]",
"inverse",
"ans-=cmb(i+b-2,i-1,mod)*cmb(h-i+w-b-1,w-b-1,mod)",
"cmb(i+b-2,i-1,mod)*cmb(h-i+w-b-1,w-b-1,mod)",
"ans",
"N = 10**6",
"10**6",
"N",
"g2 = [1, 1]",
"[1, 1]",
"g2",
"mod = 10**9+7",
"10**9+7",
"mod",
"b=map(int,input().split())",
"map(int,input().split())",
"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",
"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",
"g1 = [1, 1]",
"[1, 1]",
"g1",
"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",
"a,b=map(int,input().split())",
"map(int,input().split())",
"a",
"ans%=mod",
"mod",
"ans",
"ans=cmb(h+w-2,h-1,mod)",
"cmb(h+w-2,h-1,mod)",
"ans"
] | h,w,a,b=map(int,input().split())
#コンビネーション逆元
def cmb(n, r, mod):
if ( r<0 or r>n ):
return 0
r = min(r, n-r)
return g1[n] * g2[r] * g2[n-r] % mod
mod = 10**9+7 #出力の制限
N = 10**6
g1 = [1, 1] # 元テーブル
g2 = [1, 1] #逆元テーブル
inverse = [0, 1] #逆元テーブル計算用テーブル
for i in range( 2, N + 1 ):
g1.append( ( g1[-1] * i ) % mod )
inverse.append( ( -inverse[mod % i] * (mod//i) ) % mod )
g2.append( (g2[-1] * inverse[-1]) % mod )
ans=cmb(h+w-2,h-1,mod)
for i in range(h-a+1,h+1):
ans-=cmb(i+b-2,i-1,mod)*cmb(h-i+w-b-1,w-b-1,mod)
ans%=mod
print(ans) |
[
7,
15,
15,
15,
15,
13,
15,
13,
15,
13,
41,
28,
13,
4,
18,
4,
18,
18,
18,
13,
13,
13,
13,
13,
4,
4,
13,
13,
12,
13,
12,
13,
41,
28,
13,
4,
18,
4,
18,
18,
13,
13,
13,
13,
4,
4,
13,
13,
12,
13,
12,
13,
0,
13,
4,
13,
4,
18,
18,
13,
13,
13,
14,
2,
18,
13,
17,
17,
29,
18,
13,
39,
17,
29,
13,
12,
13,
41,
28,
13,
4,
13,
13,
4,
4,
13,
29,
13,
23,
13,
12,
13,
41,
28,
13,
4,
13,
13,
4,
4,
13,
29,
13,
23,
13,
12,
13,
41,
28,
13,
4,
13,
13,
4,
4,
13,
29,
13,
23,
13,
12,
13,
41,
28,
13,
4,
13,
13,
4,
4,
13,
29,
13,
23,
13,
4,
18,
13,
13,
17,
0,
13,
17,
12,
13,
0,
13,
39,
17,
0,
13,
17,
28,
13,
4,
13,
17,
2,
13,
17,
4,
18,
13,
13,
2,
2,
18,
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,
18,
4,
13,
13,
39,
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,
4,
13,
13,
13,
13,
0,
13,
17,
0,
13,
2,
13,
13,
0,
13,
2,
13,
17,
42,
2,
40,
13,
13,
13,
0,
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,
0,
13,
17,
0,
13,
17,
4,
13,
2,
13,
13,
29,
14,
2,
13,
17,
4,
13,
10,
12,
13,
10,
17,
13,
10,
12,
13,
10,
12,
13,
10,
12,
13,
10,
12,
13,
10,
12,
13,
10,
12,
13,
10,
12,
13,
10,
12,
13
] | [
[
13,
12
],
[
12,
27
],
[
35,
34
],
[
34,
47
],
[
54,
53
],
[
53,
65
],
[
53,
70
],
[
53,
74
],
[
80,
79
],
[
89,
82
],
[
331,
85
],
[
89,
89
],
[
95,
94
],
[
104,
97
],
[
325,
100
],
[
104,
104
],
[
110,
109
],
[
119,
112
],
[
319,
115
],
[
119,
119
],
[
125,
124
],
[
134,
127
],
[
316,
130
],
[
134,
134
],
[
312,
141
],
[
147,
146
],
[
151,
150
],
[
154,
153
],
[
150,
158
],
[
146,
162
],
[
146,
167
],
[
153,
169
],
[
313,
170
],
[
173,
172
],
[
150,
177
],
[
183,
180
],
[
172,
181
],
[
150,
182
],
[
146,
186
],
[
150,
187
],
[
313,
189
],
[
313,
191
],
[
194,
193
],
[
150,
197
],
[
204,
201
],
[
172,
202
],
[
193,
203
],
[
172,
207
],
[
193,
209
],
[
193,
212
],
[
313,
214
],
[
146,
222
],
[
234,
223
],
[
172,
225
],
[
236,
226
],
[
172,
228
],
[
234,
230
],
[
236,
231
],
[
313,
232
],
[
234,
234
],
[
236,
236
],
[
239,
238
],
[
325,
240
],
[
239,
241
],
[
239,
242
],
[
239,
243
],
[
246,
245
],
[
249,
248
],
[
238,
250
],
[
242,
251
],
[
254,
253
],
[
243,
255
],
[
253,
260
],
[
294,
260
],
[
241,
261
],
[
248,
262
],
[
291,
262
],
[
265,
264
],
[
216,
268
],
[
253,
271
],
[
294,
271
],
[
248,
272
],
[
291,
272
],
[
253,
275
],
[
294,
275
],
[
216,
278
],
[
238,
282
],
[
248,
283
],
[
291,
283
],
[
241,
284
],
[
253,
285
],
[
294,
285
],
[
241,
287
],
[
253,
288
],
[
294,
288
],
[
313,
289
],
[
292,
291
],
[
295,
294
],
[
264,
299
],
[
245,
299
],
[
313,
300
],
[
328,
307
],
[
312,
313
]
] | [
"#!usr/bin/env python3\nfrom collections import defaultdict, deque\nfrom heapq import heappush, heappop\nfrom itertools import permutations, accumulate\nimport sys\nimport math\nimport bisect\ndef LI(): return [int(x) for x in sys.stdin.buffer.readline().split()]\ndef I(): return int(sys.stdin.buffer.readline())\ndef LS():return [list(x) for x in sys.stdin.readline().split()]\ndef S():\n res = list(sys.stdin.readline())\n if res[-1] == \"\\n\":\n return res[:-1]\n return res\ndef IR(n):\n return [I() for i in range(n)]\ndef LIR(n):\n return [LI() for i in range(n)]\ndef SR(n):\n return [S() for i in range(n)]\ndef LSR(n):\n return [LS() for i in range(n)]\n\nsys.setrecursionlimit(1000000)\nmod = 1000000007\n\ndef solve():\n f = [1]\n N = 1000000\n for i in range(1,N+1):\n f.append(f[-1]*i%mod)\n inv = [None]*(N+1)\n inv[N] = pow(f[N],mod-2,mod)\n for i in range(N)[::-1]:\n inv[i] = inv[i+1]*(i+1)%mod\n def comb(a,b):\n return f[a]*inv[b]*inv[a-b]%mod\n h,w,a,b = LI()\n ans = 0\n y = h-a\n x = b+1\n while x <= w and y:\n ans += comb(x+y-2,x-1)*comb(h-y+w-x,w-x)%mod\n y -= 1\n x += 1\n print(ans%mod)\n return\n\n#Solve\nif __name__ == \"__main__\":\n solve()",
"from collections import defaultdict, deque",
"from heapq import heappush, heappop",
"from itertools import permutations, accumulate",
"import sys",
"sys",
"import math",
"math",
"import bisect",
"bisect",
"int(x) for x in sys.stdin.buffer.readline().split()",
"for x in sys.stdin.buffer.readline().split()",
"x",
"sys.stdin.buffer.readline().split()",
"sys.stdin.buffer.readline().split",
"sys.stdin.buffer.readline()",
"sys.stdin.buffer.readline",
"sys.stdin.buffer",
"sys.stdin",
"sys",
"stdin",
"buffer",
"readline",
"split",
"for x in sys.stdin.buffer.readline().split()",
"int(x)",
"int",
"x",
"def LI(): return [int(x) for x in sys.stdin.buffer.readline().split()]",
"LI",
"def I(): return int(sys.stdin.buffer.readline())",
"I",
"list(x) for x in sys.stdin.readline().split()",
"for x in sys.stdin.readline().split()",
"x",
"sys.stdin.readline().split()",
"sys.stdin.readline().split",
"sys.stdin.readline()",
"sys.stdin.readline",
"sys.stdin",
"sys",
"stdin",
"readline",
"split",
"for x in sys.stdin.readline().split()",
"list(x)",
"list",
"x",
"def LS():return [list(x) for x in sys.stdin.readline().split()]",
"LS",
"def S():\n res = list(sys.stdin.readline())\n if res[-1] == \"\\n\":\n return res[:-1]\n return res",
"S",
"res = list(sys.stdin.readline())",
"res",
"list(sys.stdin.readline())",
"list",
"sys.stdin.readline()",
"sys.stdin.readline",
"sys.stdin",
"sys",
"stdin",
"readline",
"if res[-1] == \"\\n\":\n return res[:-1]\n ",
"res[-1] == \"\\n\"",
"res[-1]",
"res",
"-1",
"\"\\n\"",
"return res[:-1]",
"res[:-1]",
"res",
":-1",
"-1",
"return res",
"res",
"def IR(n):\n return [I() for i in range(n)]",
"IR",
"I() for i in range(n)",
"for i in range(n)",
"i",
"range(n)",
"range",
"n",
"for i in range(n)",
"I()",
"I",
"return [I() for i in range(n)]",
"[I() for i in range(n)]",
"n",
"n",
"def LIR(n):\n return [LI() for i in range(n)]",
"LIR",
"LI() for i in range(n)",
"for i in range(n)",
"i",
"range(n)",
"range",
"n",
"for i in range(n)",
"LI()",
"LI",
"return [LI() for i in range(n)]",
"[LI() for i in range(n)]",
"n",
"n",
"def SR(n):\n return [S() for i in range(n)]",
"SR",
"S() for i in range(n)",
"for i in range(n)",
"i",
"range(n)",
"range",
"n",
"for i in range(n)",
"S()",
"S",
"return [S() for i in range(n)]",
"[S() for i in range(n)]",
"n",
"n",
"def LSR(n):\n return [LS() for i in range(n)]",
"LSR",
"LS() for i in range(n)",
"for i in range(n)",
"i",
"range(n)",
"range",
"n",
"for i in range(n)",
"LS()",
"LS",
"return [LS() for i in range(n)]",
"[LS() for i in range(n)]",
"n",
"n",
"sys.setrecursionlimit(1000000)",
"sys.setrecursionlimit",
"sys",
"setrecursionlimit",
"1000000",
"mod = 1000000007",
"mod",
"1000000007",
"def solve():\n f = [1]\n N = 1000000\n for i in range(1,N+1):\n f.append(f[-1]*i%mod)\n inv = [None]*(N+1)\n inv[N] = pow(f[N],mod-2,mod)\n for i in range(N)[::-1]:\n inv[i] = inv[i+1]*(i+1)%mod\n def comb(a,b):\n return f[a]*inv[b]*inv[a-b]%mod\n h,w,a,b = LI()\n ans = 0\n y = h-a\n x = b+1\n while x <= w and y:\n ans += comb(x+y-2,x-1)*comb(h-y+w-x,w-x)%mod\n y -= 1\n x += 1\n print(ans%mod)\n return\n\n#Solve",
"solve",
"f = [1]",
"f",
"[1]",
"1",
"N = 1000000",
"N",
"1000000",
"for i in range(1,N+1):\n f.append(f[-1]*i%mod)\n ",
"i",
"range(1,N+1)",
"range",
"1",
"N+1",
"N",
"1",
"f.append(f[-1]*i%mod)",
"f.append",
"f",
"append",
"f[-1]*i%mod",
"f[-1]*i",
"f[-1]",
"f",
"-1",
"i",
"mod",
"inv = [None]*(N+1)",
"inv",
"[None]*(N+1)",
"[None]",
"None",
"N+1",
"N",
"1",
"inv[N] = pow(f[N],mod-2,mod)",
"inv[N]",
"inv",
"N",
"pow(f[N],mod-2,mod)",
"pow",
"f[N]",
"f",
"N",
"mod-2",
"mod",
"2",
"mod",
"for i in range(N)[::-1]:\n inv[i] = inv[i+1]*(i+1)%mod\n ",
"i",
"range(N)[::-1]",
"(N)",
"range",
"N",
"::-1",
"-1",
"inv[i] = inv[i+1]*(i+1)%mod",
"inv[i]",
"inv",
"i",
"inv[i+1]*(i+1)%mod",
"inv[i+1]*(i+1)",
"inv[i+1]",
"inv",
"i+1",
"i",
"1",
"i+1",
"i",
"1",
"mod",
"def comb(a,b):\n return f[a]*inv[b]*inv[a-b]%mod\n ",
"comb",
"return f[a]*inv[b]*inv[a-b]%mod",
"f[a]*inv[b]*inv[a-b]%mod",
"f[a]*inv[b]*inv[a-b]",
"f[a]*inv[b]",
"f[a]",
"f",
"a",
"inv[b]",
"inv",
"b",
"inv[a-b]",
"inv",
"a-b",
"a",
"b",
"mod",
"a",
"a",
"b",
"b",
"h,w,a,b = LI()",
"h",
"LI()",
"LI",
"w",
"a",
"b",
"ans = 0",
"ans",
"0",
"y = h-a",
"y",
"h-a",
"h",
"a",
"x = b+1",
"x",
"b+1",
"b",
"1",
"while x <= w and y:\n ans += comb(x+y-2,x-1)*comb(h-y+w-x,w-x)%mod\n y -= 1\n x += 1\n ",
"x <= w and y",
"x <= w",
"x",
"w",
"y",
"ans += comb(x+y-2,x-1)*comb(h-y+w-x,w-x)%mod",
"ans",
"comb(x+y-2,x-1)*comb(h-y+w-x,w-x)%mod",
"comb(x+y-2,x-1)*comb(h-y+w-x,w-x)",
"comb(x+y-2,x-1)",
"comb",
"x+y-2",
"x+y",
"x",
"y",
"2",
"x-1",
"x",
"1",
"comb(h-y+w-x,w-x)",
"comb",
"h-y+w-x",
"h-y+w",
"h-y",
"h",
"y",
"w",
"x",
"w-x",
"w",
"x",
"mod",
"y -= 1",
"y",
"1",
"x += 1",
"x",
"1",
"print(ans%mod)",
"print",
"ans%mod",
"ans",
"mod",
"return",
"if __name__ == \"__main__\":\n solve()",
"__name__ == \"__main__\"",
"__name__",
"\"__main__\"",
"solve()",
"solve",
"def IR(n):\n return [I() for i in range(n)]",
"def IR(n):\n return [I() for i in range(n)]",
"IR",
"mod = 1000000007",
"1000000007",
"mod",
"def LS():return [list(x) for x in sys.stdin.readline().split()]",
"def LS():return [list(x) for x in sys.stdin.readline().split()]",
"LS",
"def S():\n res = list(sys.stdin.readline())\n if res[-1] == \"\\n\":\n return res[:-1]\n return res",
"def S():\n res = list(sys.stdin.readline())\n if res[-1] == \"\\n\":\n return res[:-1]\n return res",
"S",
"def SR(n):\n return [S() for i in range(n)]",
"def SR(n):\n return [S() for i in range(n)]",
"SR",
"def LI(): return [int(x) for x in sys.stdin.buffer.readline().split()]",
"def LI(): return [int(x) for x in sys.stdin.buffer.readline().split()]",
"LI",
"def solve():\n f = [1]\n N = 1000000\n for i in range(1,N+1):\n f.append(f[-1]*i%mod)\n inv = [None]*(N+1)\n inv[N] = pow(f[N],mod-2,mod)\n for i in range(N)[::-1]:\n inv[i] = inv[i+1]*(i+1)%mod\n def comb(a,b):\n return f[a]*inv[b]*inv[a-b]%mod\n h,w,a,b = LI()\n ans = 0\n y = h-a\n x = b+1\n while x <= w and y:\n ans += comb(x+y-2,x-1)*comb(h-y+w-x,w-x)%mod\n y -= 1\n x += 1\n print(ans%mod)\n return\n\n#Solve",
"def solve():\n f = [1]\n N = 1000000\n for i in range(1,N+1):\n f.append(f[-1]*i%mod)\n inv = [None]*(N+1)\n inv[N] = pow(f[N],mod-2,mod)\n for i in range(N)[::-1]:\n inv[i] = inv[i+1]*(i+1)%mod\n def comb(a,b):\n return f[a]*inv[b]*inv[a-b]%mod\n h,w,a,b = LI()\n ans = 0\n y = h-a\n x = b+1\n while x <= w and y:\n ans += comb(x+y-2,x-1)*comb(h-y+w-x,w-x)%mod\n y -= 1\n x += 1\n print(ans%mod)\n return\n\n#Solve",
"solve",
"def I(): return int(sys.stdin.buffer.readline())",
"def I(): return int(sys.stdin.buffer.readline())",
"I",
"def LSR(n):\n return [LS() for i in range(n)]",
"def LSR(n):\n return [LS() for i in range(n)]",
"LSR",
"def LIR(n):\n return [LI() for i in range(n)]",
"def LIR(n):\n return [LI() for i in range(n)]",
"LIR"
] | #!usr/bin/env python3
from collections import defaultdict, deque
from heapq import heappush, heappop
from itertools import permutations, accumulate
import sys
import math
import bisect
def LI(): return [int(x) for x in sys.stdin.buffer.readline().split()]
def I(): return int(sys.stdin.buffer.readline())
def LS():return [list(x) for x in sys.stdin.readline().split()]
def S():
res = list(sys.stdin.readline())
if res[-1] == "\n":
return res[:-1]
return res
def IR(n):
return [I() for i in range(n)]
def LIR(n):
return [LI() for i in range(n)]
def SR(n):
return [S() for i in range(n)]
def LSR(n):
return [LS() for i in range(n)]
sys.setrecursionlimit(1000000)
mod = 1000000007
def solve():
f = [1]
N = 1000000
for i in range(1,N+1):
f.append(f[-1]*i%mod)
inv = [None]*(N+1)
inv[N] = pow(f[N],mod-2,mod)
for i in range(N)[::-1]:
inv[i] = inv[i+1]*(i+1)%mod
def comb(a,b):
return f[a]*inv[b]*inv[a-b]%mod
h,w,a,b = LI()
ans = 0
y = h-a
x = b+1
while x <= w and y:
ans += comb(x+y-2,x-1)*comb(h-y+w-x,w-x)%mod
y -= 1
x += 1
print(ans%mod)
return
#Solve
if __name__ == "__main__":
solve()
|
[
7,
12,
13,
14,
2,
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,
0,
13,
2,
2,
17,
17,
17,
0,
13,
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,
41,
28,
13,
4,
18,
4,
13,
13,
4,
4,
13,
13,
0,
13,
13,
13,
13,
13,
0,
13,
17,
28,
13,
4,
13,
13,
13,
0,
13,
2,
4,
13,
2,
2,
2,
13,
13,
17,
13,
13,
13,
4,
13,
2,
2,
2,
13,
13,
17,
13,
2,
2,
13,
17,
13,
13,
4,
13,
2,
13,
13,
10,
2,
13,
10,
13,
13,
10,
2,
13,
10,
13,
13,
10,
39,
13,
10,
17,
13,
10,
2,
13,
10,
39,
13,
10,
13,
13,
10,
12,
13,
10,
39,
13,
10,
13,
13
] | [
[
32,
6
],
[
30,
9
],
[
32,
10
],
[
30,
19
],
[
32,
22
],
[
30,
26
],
[
32,
27
],
[
34,
28
],
[
30,
30
],
[
32,
32
],
[
34,
34
],
[
172,
36
],
[
178,
43
],
[
202,
48
],
[
193,
53
],
[
184,
58
],
[
64,
63
],
[
179,
68
],
[
203,
72
],
[
203,
77
],
[
63,
79
],
[
173,
80
],
[
185,
83
],
[
185,
89
],
[
173,
91
],
[
63,
92
],
[
173,
94
],
[
63,
95
],
[
173,
96
],
[
194,
99
],
[
194,
104
],
[
185,
107
],
[
173,
109
],
[
113,
112
],
[
112,
121
],
[
205,
123
],
[
205,
125
],
[
205,
126
],
[
205,
127
],
[
187,
129
],
[
133,
132
],
[
197,
135
],
[
182,
136
],
[
190,
138
],
[
200,
141
],
[
176,
145
],
[
206,
146
],
[
132,
148
],
[
132,
149
],
[
173,
150
],
[
200,
152
],
[
206,
156
],
[
182,
157
],
[
132,
159
],
[
182,
162
],
[
132,
164
],
[
173,
165
],
[
191,
169
],
[
188,
169
],
[
173,
170
],
[
172,
173
],
[
205,
176
],
[
178,
179
],
[
205,
182
],
[
184,
185
],
[
187,
188
],
[
190,
191
],
[
193,
194
],
[
205,
197
],
[
202,
203
],
[
205,
206
]
] | [
"def combmod(n, r, p):\n if r < 0 or n < r:\n return 0\n return fact[n] * finv[r] * finv[n-r] % p\n\n\np = 10**9+7\nN = 10**6\nfact = [1, 1]\nfinv = [1, 1]\ninv = [0, 1]\n\nfor i in range(2, N+1):\n fact.append((fact[-1] * i) % p)\n inv.append((-inv[p % i] * (p // i)) % p)\n finv.append((finv[-1] * inv[-1]) % p)\n\nh, w, a, b = (int(x) for x in input().split())\nans = 0\nfor j in range(b, w):\n ans += combmod(h-a-1 + j, j, p) * combmod(a+w-2 - j, w-1 - j, p)\nprint(ans % p)",
"def combmod(n, r, p):\n if r < 0 or n < r:\n return 0\n return fact[n] * finv[r] * finv[n-r] % p",
"combmod",
"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",
"return fact[n] * finv[r] * finv[n-r] % p",
"fact[n] * finv[r] * finv[n-r] % p",
"fact[n] * finv[r] * finv[n-r]",
"fact[n] * finv[r]",
"fact[n]",
"fact",
"n",
"finv[r]",
"finv",
"r",
"finv[n-r]",
"finv",
"n-r",
"n",
"r",
"p",
"n",
"n",
"r",
"r",
"p",
"p",
"p = 10**9+7",
"p",
"10**9+7",
"10**9",
"10",
"9",
"7",
"N = 10**6",
"N",
"10**6",
"10",
"6",
"fact = [1, 1]",
"fact",
"[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, N+1):\n fact.append((fact[-1] * i) % p)\n inv.append((-inv[p % i] * (p // i)) % p)\n finv.append((finv[-1] * inv[-1]) % p)",
"i",
"range(2, N+1)",
"range",
"2",
"N+1",
"N",
"1",
"fact.append((fact[-1] * i) % p)",
"fact.append",
"fact",
"append",
"(fact[-1] * i) % p",
"fact[-1] * i",
"fact[-1]",
"fact",
"-1",
"i",
"p",
"inv.append((-inv[p % i] * (p // i)) % p)",
"inv.append",
"inv",
"append",
"(-inv[p % i] * (p // i)) % p",
"-inv[p % i] * (p // i)",
"-inv[p % i]",
"inv[p % i]",
"inv",
"p % i",
"p",
"i",
"p // i",
"p",
"i",
"p",
"finv.append((finv[-1] * inv[-1]) % p)",
"finv.append",
"finv",
"append",
"(finv[-1] * inv[-1]) % p",
"finv[-1] * inv[-1]",
"finv[-1]",
"finv",
"-1",
"inv[-1]",
"inv",
"-1",
"p",
"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",
"h, w, a, b = (int(x) for x in input().split())",
"h",
"(int(x) for x in input().split())",
"w",
"a",
"b",
"ans = 0",
"ans",
"0",
"for j in range(b, w):\n ans += combmod(h-a-1 + j, j, p) * combmod(a+w-2 - j, w-1 - j, p)",
"j",
"range(b, w)",
"range",
"b",
"w",
"ans += combmod(h-a-1 + j, j, p) * combmod(a+w-2 - j, w-1 - j, p)",
"ans",
"combmod(h-a-1 + j, j, p) * combmod(a+w-2 - j, w-1 - j, p)",
"combmod(h-a-1 + j, j, p)",
"combmod",
"h-a-1 + j",
"h-a-1",
"h-a",
"h",
"a",
"1",
"j",
"j",
"p",
"combmod(a+w-2 - j, w-1 - j, p)",
"combmod",
"a+w-2 - j",
"a+w-2",
"a+w",
"a",
"w",
"2",
"j",
"w-1 - j",
"w-1",
"w",
"1",
"j",
"p",
"print(ans % p)",
"print",
"ans % p",
"ans",
"p",
"p = 10**9+7",
"10**9+7",
"p",
"h, w, a, b = (int(x) for x in input().split())",
"(int(x) for x in input().split())",
"h",
"N = 10**6",
"10**6",
"N",
"w, a, b = (int(x) for x in input().split())",
"(int(x) for x in input().split())",
"w",
"inv = [0, 1]",
"[0, 1]",
"inv",
"ans = 0",
"0",
"ans",
"ans += combmod(h-a-1 + j, j, p) * combmod(a+w-2 - j, w-1 - j, p)",
"combmod(h-a-1 + j, j, p) * combmod(a+w-2 - j, w-1 - j, p)",
"ans",
"finv = [1, 1]",
"[1, 1]",
"finv",
"b = (int(x) for x in input().split())",
"(int(x) for x in input().split())",
"b",
"def combmod(n, r, p):\n if r < 0 or n < r:\n return 0\n return fact[n] * finv[r] * finv[n-r] % p",
"def combmod(n, r, p):\n if r < 0 or n < r:\n return 0\n return fact[n] * finv[r] * finv[n-r] % p",
"combmod",
"fact = [1, 1]",
"[1, 1]",
"fact",
"a, b = (int(x) for x in input().split())",
"(int(x) for x in input().split())",
"a"
] | def combmod(n, r, p):
if r < 0 or n < r:
return 0
return fact[n] * finv[r] * finv[n-r] % p
p = 10**9+7
N = 10**6
fact = [1, 1]
finv = [1, 1]
inv = [0, 1]
for i in range(2, N+1):
fact.append((fact[-1] * i) % p)
inv.append((-inv[p % i] * (p // i)) % p)
finv.append((finv[-1] * inv[-1]) % p)
h, w, a, b = (int(x) for x in input().split())
ans = 0
for j in range(b, w):
ans += combmod(h-a-1 + j, j, p) * combmod(a+w-2 - j, w-1 - j, p)
print(ans % p)
|
[
7,
0,
13,
2,
2,
17,
17,
17,
0,
13,
2,
17,
2,
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,
4,
13,
13,
4,
18,
4,
13,
13,
13,
13,
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,
0,
13,
4,
13,
2,
2,
2,
2,
13,
13,
13,
13,
17,
2,
13,
13,
0,
13,
13,
0,
13,
13,
4,
13,
13,
10,
4,
13,
10,
2,
13,
10,
4,
13,
10,
2,
13,
10,
17,
13,
10,
13,
13,
10,
2,
13,
10,
2,
13,
10,
4,
13,
10,
2,
13,
10,
12,
13,
10,
13,
13,
10,
4,
13,
10,
4,
13,
10,
4,
13
] | [
[
226,
2
],
[
208,
9
],
[
220,
16
],
[
209,
24
],
[
217,
26
],
[
209,
34
],
[
202,
36
],
[
209,
44
],
[
47,
46
],
[
209,
51
],
[
57,
54
],
[
221,
55
],
[
46,
56
],
[
221,
60
],
[
46,
62
],
[
46,
64
],
[
227,
65
],
[
70,
67
],
[
203,
68
],
[
46,
69
],
[
203,
74
],
[
227,
76
],
[
46,
77
],
[
227,
79
],
[
46,
80
],
[
227,
81
],
[
86,
83
],
[
218,
84
],
[
46,
85
],
[
218,
89
],
[
46,
91
],
[
67,
93
],
[
203,
94
],
[
46,
95
],
[
227,
96
],
[
130,
101
],
[
132,
102
],
[
130,
106
],
[
132,
109
],
[
221,
115
],
[
130,
116
],
[
218,
120
],
[
132,
121
],
[
218,
123
],
[
130,
125
],
[
132,
126
],
[
227,
127
],
[
227,
128
],
[
130,
130
],
[
132,
132
],
[
238,
134
],
[
238,
143
],
[
238,
144
],
[
238,
145
],
[
211,
147
],
[
151,
150
],
[
200,
156
],
[
239,
157
],
[
223,
160
],
[
230,
162
],
[
150,
166
],
[
236,
168
],
[
150,
171
],
[
241,
174
],
[
230,
176
],
[
200,
181
],
[
150,
182
],
[
206,
183
],
[
236,
184
],
[
200,
187
],
[
150,
188
],
[
214,
190
],
[
242,
191
],
[
224,
191
],
[
232,
193
],
[
227,
194
],
[
233,
197
],
[
215,
197
],
[
212,
197
],
[
238,
200
],
[
202,
203
],
[
238,
206
],
[
208,
209
],
[
211,
212
],
[
242,
214
],
[
224,
214
],
[
214,
215
],
[
217,
218
],
[
220,
221
],
[
223,
224
],
[
226,
227
],
[
227,
232
],
[
232,
233
],
[
238,
236
],
[
238,
239
],
[
241,
242
]
] | [
"# Combination\nMOD = 10**9+7\nMAX = 2*10**5\nfac = [1,1] + [0]*MAX\nfinv = [1,1] + [0]*MAX\ninv = [0,1] + [0]*MAX\nfor i in range(2,MAX+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 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\nH, W, A, B = map(int, input().split())\nans = 0\nfor i in range(1, H-A+1):\n cnt = comb(i-1+B-1, i-1)\n #print(i, cnt)\n cnt *= comb(H-i+W-B-1, H-i)\n ans += cnt\n ans %= 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 = [1,1] + [0]*MAX",
"fac",
"[1,1] + [0]*MAX",
"[1,1]",
"1",
"1",
"[0]*MAX",
"[0]",
"0",
"MAX",
"finv = [1,1] + [0]*MAX",
"finv",
"[1,1] + [0]*MAX",
"[1,1]",
"1",
"1",
"[0]*MAX",
"[0]",
"0",
"MAX",
"inv = [0,1] + [0]*MAX",
"inv",
"[0,1] + [0]*MAX",
"[0,1]",
"0",
"1",
"[0]*MAX",
"[0]",
"0",
"MAX",
"for i in range(2,MAX+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,MAX+2)",
"range",
"2",
"MAX+2",
"MAX",
"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 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",
"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(1, H-A+1):\n cnt = comb(i-1+B-1, i-1)\n #print(i, cnt)\n cnt *= comb(H-i+W-B-1, H-i)\n ans += cnt\n ans %= MOD",
"i",
"range(1, H-A+1)",
"range",
"1",
"H-A+1",
"H-A",
"H",
"A",
"1",
"cnt = comb(i-1+B-1, i-1)",
"cnt",
"comb(i-1+B-1, i-1)",
"comb",
"i-1+B-1",
"i-1+B",
"i-1",
"i",
"1",
"B",
"1",
"i-1",
"i",
"1",
"cnt *= comb(H-i+W-B-1, H-i)",
"cnt",
"comb(H-i+W-B-1, H-i)",
"comb",
"H-i+W-B-1",
"H-i+W-B",
"H-i+W",
"H-i",
"H",
"i",
"W",
"B",
"1",
"H-i",
"H",
"i",
"ans += cnt",
"ans",
"cnt",
"ans %= MOD",
"ans",
"MOD",
"print(ans)",
"print",
"ans",
"H, W, A, B = map(int, input().split())",
"map(int, input().split())",
"H",
"inv = [0,1] + [0]*MAX",
"[0,1] + [0]*MAX",
"inv",
"W, A, B = map(int, input().split())",
"map(int, input().split())",
"W",
"MAX = 2*10**5",
"2*10**5",
"MAX",
"ans = 0",
"0",
"ans",
"ans += cnt",
"cnt",
"ans",
"finv = [1,1] + [0]*MAX",
"[1,1] + [0]*MAX",
"finv",
"fac = [1,1] + [0]*MAX",
"[1,1] + [0]*MAX",
"fac",
"cnt = comb(i-1+B-1, i-1)",
"comb(i-1+B-1, i-1)",
"cnt",
"MOD = 10**9+7",
"10**9+7",
"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",
"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",
"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",
"cnt *= comb(H-i+W-B-1, H-i)",
"comb(H-i+W-B-1, H-i)",
"cnt"
] | # Combination
MOD = 10**9+7
MAX = 2*10**5
fac = [1,1] + [0]*MAX
finv = [1,1] + [0]*MAX
inv = [0,1] + [0]*MAX
for i in range(2,MAX+2):
fac[i] = fac[i-1] * i % MOD
inv[i] = -inv[MOD%i] * (MOD // i) % MOD
finv[i] = finv[i-1] * inv[i] % MOD
def comb(n,r):
if n < r: return 0
if n < 0 or r < 0: return 0
return fac[n] * (finv[r] * finv[n-r] % MOD) % MOD
H, W, A, B = map(int, input().split())
ans = 0
for i in range(1, H-A+1):
cnt = comb(i-1+B-1, i-1)
#print(i, cnt)
cnt *= comb(H-i+W-B-1, H-i)
ans += cnt
ans %= MOD
print(ans)
|
[
7,
15,
13,
15,
13,
15,
13,
0,
13,
2,
2,
17,
17,
17,
0,
13,
39,
39,
17,
17,
39,
17,
17,
39,
17,
17,
39,
17,
17,
12,
13,
41,
28,
13,
4,
18,
4,
18,
18,
13,
13,
13,
13,
4,
4,
13,
13,
12,
13,
12,
13,
41,
28,
13,
4,
13,
13,
4,
4,
13,
12,
13,
23,
13,
12,
13,
42,
40,
13,
17,
0,
13,
13,
13,
2,
13,
13,
29,
13,
23,
13,
23,
13,
12,
13,
29,
2,
2,
13,
13,
4,
13,
13,
13,
23,
13,
23,
13,
12,
13,
0,
13,
2,
39,
17,
2,
13,
17,
0,
18,
13,
17,
17,
0,
18,
13,
17,
17,
0,
13,
17,
42,
40,
2,
13,
13,
13,
14,
18,
13,
13,
0,
13,
13,
42,
40,
2,
13,
13,
13,
0,
18,
13,
2,
13,
13,
17,
0,
13,
17,
0,
13,
17,
29,
13,
23,
13,
12,
13,
0,
13,
4,
13,
13,
13,
13,
0,
13,
2,
39,
17,
2,
13,
13,
0,
18,
13,
17,
17,
28,
13,
4,
13,
17,
2,
2,
13,
13,
13,
0,
18,
13,
17,
13,
0,
18,
13,
17,
13,
28,
13,
4,
13,
17,
2,
2,
2,
13,
17,
13,
13,
0,
18,
13,
17,
13,
0,
18,
13,
17,
13,
28,
13,
4,
13,
17,
2,
13,
13,
0,
18,
13,
17,
4,
13,
13,
2,
13,
17,
13,
0,
18,
13,
17,
13,
28,
13,
4,
13,
17,
2,
13,
17,
0,
18,
13,
17,
4,
13,
13,
2,
13,
17,
13,
0,
18,
13,
17,
13,
28,
13,
4,
13,
17,
2,
13,
13,
0,
18,
13,
17,
4,
13,
13,
2,
13,
17,
13,
0,
18,
13,
17,
13,
28,
13,
4,
13,
17,
13,
0,
18,
13,
17,
4,
13,
13,
2,
13,
17,
13,
0,
18,
13,
17,
13,
28,
13,
4,
13,
17,
2,
13,
13,
0,
18,
13,
13,
18,
13,
2,
13,
17,
0,
18,
13,
13,
2,
2,
2,
2,
13,
13,
13,
17,
13,
0,
18,
13,
13,
13,
0,
18,
13,
13,
2,
2,
13,
13,
13,
0,
18,
13,
13,
13,
0,
18,
13,
13,
4,
13,
2,
13,
13,
2,
13,
17,
13,
0,
18,
13,
13,
13,
0,
18,
13,
13,
4,
13,
2,
2,
2,
2,
13,
17,
13,
13,
13,
2,
13,
17,
13,
0,
18,
13,
13,
13,
29,
2,
4,
13,
13,
13,
14,
2,
13,
17,
4,
13,
4,
13,
10,
2,
13,
10,
12,
13,
10,
12,
13,
10,
12,
13,
10,
12,
13,
10,
12,
13,
10,
12,
13,
10,
12,
13,
10,
12,
13,
10,
39,
13
] | [
[
421,
8
],
[
448,
15
],
[
34,
33
],
[
33,
46
],
[
54,
53
],
[
437,
59
],
[
63,
63
],
[
82,
68
],
[
73,
68
],
[
72,
71
],
[
82,
72
],
[
73,
72
],
[
74,
73
],
[
71,
75
],
[
80,
75
],
[
82,
76
],
[
73,
76
],
[
71,
78
],
[
80,
78
],
[
80,
80
],
[
82,
82
],
[
95,
88
],
[
97,
89
],
[
440,
91
],
[
95,
92
],
[
97,
93
],
[
95,
95
],
[
97,
97
],
[
102,
101
],
[
156,
106
],
[
112,
109
],
[
101,
110
],
[
117,
114
],
[
101,
115
],
[
120,
119
],
[
119,
124
],
[
151,
124
],
[
119,
125
],
[
151,
125
],
[
156,
126
],
[
101,
129
],
[
119,
130
],
[
151,
130
],
[
133,
132
],
[
119,
133
],
[
151,
133
],
[
119,
137
],
[
151,
137
],
[
132,
138
],
[
148,
138
],
[
156,
139
],
[
146,
141
],
[
119,
144
],
[
151,
144
],
[
132,
145
],
[
148,
145
],
[
149,
148
],
[
152,
151
],
[
101,
154
],
[
156,
156
],
[
161,
160
],
[
431,
162
],
[
161,
163
],
[
161,
164
],
[
161,
165
],
[
168,
167
],
[
163,
172
],
[
165,
173
],
[
178,
175
],
[
167,
176
],
[
181,
180
],
[
165,
186
],
[
160,
187
],
[
164,
188
],
[
193,
190
],
[
167,
191
],
[
180,
193
],
[
198,
195
],
[
167,
196
],
[
422,
198
],
[
201,
200
],
[
164,
207
],
[
163,
209
],
[
165,
210
],
[
215,
212
],
[
167,
213
],
[
200,
215
],
[
220,
217
],
[
167,
218
],
[
422,
220
],
[
223,
222
],
[
160,
227
],
[
164,
228
],
[
233,
230
],
[
167,
231
],
[
222,
235
],
[
422,
237
],
[
422,
239
],
[
244,
241
],
[
167,
242
],
[
422,
244
],
[
247,
246
],
[
165,
251
],
[
257,
254
],
[
167,
255
],
[
246,
259
],
[
422,
261
],
[
422,
263
],
[
268,
265
],
[
167,
266
],
[
422,
268
],
[
271,
270
],
[
163,
275
],
[
165,
276
],
[
281,
278
],
[
167,
279
],
[
270,
283
],
[
422,
285
],
[
422,
287
],
[
292,
289
],
[
167,
290
],
[
422,
292
],
[
295,
294
],
[
164,
298
],
[
303,
300
],
[
167,
301
],
[
294,
305
],
[
422,
307
],
[
422,
309
],
[
314,
311
],
[
167,
312
],
[
422,
314
],
[
317,
316
],
[
163,
321
],
[
165,
322
],
[
327,
324
],
[
167,
325
],
[
316,
326
],
[
167,
328
],
[
316,
330
],
[
336,
333
],
[
167,
334
],
[
316,
335
],
[
165,
340
],
[
160,
341
],
[
164,
342
],
[
316,
344
],
[
349,
346
],
[
167,
347
],
[
316,
348
],
[
422,
349
],
[
354,
351
],
[
167,
352
],
[
316,
353
],
[
163,
356
],
[
165,
357
],
[
316,
358
],
[
363,
360
],
[
167,
361
],
[
316,
362
],
[
422,
363
],
[
368,
365
],
[
167,
366
],
[
316,
367
],
[
165,
371
],
[
316,
372
],
[
422,
374
],
[
422,
376
],
[
381,
378
],
[
167,
379
],
[
316,
380
],
[
422,
381
],
[
386,
383
],
[
167,
384
],
[
316,
385
],
[
164,
392
],
[
163,
394
],
[
165,
395
],
[
316,
396
],
[
422,
398
],
[
422,
400
],
[
405,
402
],
[
167,
403
],
[
316,
404
],
[
422,
405
],
[
167,
410
],
[
422,
411
],
[
446,
419
],
[
421,
422
],
[
448,
449
]
] | [
"import sys\nimport heapq\nimport bisect\n\nmod = 10**9+7\ndd = ((-1,0),(1,0),(0,-1),(0,1))\n\ndef I(): return(int(sys.stdin.readline()))\ndef LI(): return([int(x) for x in sys.stdin.readline().split()])\ndef S(): return(sys.stdin.readline()[:-1])\ndef IR(n): return([I() for _ in range(n)])\n\ndef GCD(a,b):\n while b!=0:\n a,b = b,a%b\n return a\n\ndef LCM(a,b):\n return a * b // GCD(a,b)\n\ndef Eratosthenes(N):\n r = [True]*(N+1)\n r[0] = False\n r[1] = False\n i = 2\n while i*i<=N:\n if r[i]: \n j = i\n while i*j<=N:\n prime[i*j]=False\n j+=1\n i+=1\n return(r)\n\ndef main():\n H,W,A,B = LI()\n\n ans = [0]*(W-B)\n\n ans[0] = 1\n\n for i in range(1,B+H-A):\n ans[0] *= i\n ans[0] %= mod\n for i in range(1,A-1+W-B):\n ans[0] *= i\n ans[0] %= mod\n for i in range(1,H-A):\n ans[0] *= pow(i,mod-2,mod)\n ans[0] %= mod\n for i in range(1,B+1):\n ans[0] *= pow(i,mod-2,mod)\n ans[0] %= mod\n for i in range(1,W-B):\n ans[0] *= pow(i,mod-2,mod)\n ans[0] %= mod\n for i in range(1,A):\n ans[0] *= pow(i,mod-2,mod)\n ans[0] %= mod\n\n for i in range(1,W-B):\n ans[i] = ans[i-1]\n ans[i] *= (B+H-A-1+i)\n ans[i] %= mod\n ans[i] *= (W-B-i)\n ans[i] %= mod\n ans[i] *= pow(B+i,mod-2,mod)\n ans[i] %= mod\n ans[i] *= pow(A-1+W-B-i,mod-2,mod)\n ans[i] %= mod\n\n return(sum(ans)%mod)\n\n\nif __name__ == \"__main__\":\n print(main())",
"import sys",
"sys",
"import heapq",
"heapq",
"import bisect",
"bisect",
"mod = 10**9+7",
"mod",
"10**9+7",
"10**9",
"10",
"9",
"7",
"dd = ((-1,0),(1,0),(0,-1),(0,1))",
"dd",
"((-1,0),(1,0),(0,-1),(0,1))",
"(-1,0)",
"-1",
"0",
"(1,0)",
"1",
"0",
"(0,-1)",
"0",
"-1",
"(0,1)",
"0",
"1",
"def I(): return(int(sys.stdin.readline()))",
"I",
"int(x) for x in sys.stdin.readline().split()",
"for x in sys.stdin.readline().split()",
"x",
"sys.stdin.readline().split()",
"sys.stdin.readline().split",
"sys.stdin.readline()",
"sys.stdin.readline",
"sys.stdin",
"sys",
"stdin",
"readline",
"split",
"for x in sys.stdin.readline().split()",
"int(x)",
"int",
"x",
"def LI(): return([int(x) for x in sys.stdin.readline().split()])",
"LI",
"def S(): return(sys.stdin.readline()[:-1])",
"S",
"I() for _ in range(n)",
"for _ in range(n)",
"_",
"range(n)",
"range",
"n",
"for _ in range(n)",
"I()",
"I",
"def IR(n): return([I() for _ in range(n)])",
"IR",
"n",
"n",
"def GCD(a,b):\n while b!=0:\n a,b = b,a%b\n return a",
"GCD",
"while b!=0:\n a,b = b,a%b\n ",
"b!=0",
"b",
"0",
"a,b = b,a%b",
"a",
"b",
"b",
"a%b",
"a",
"b",
"return a",
"a",
"a",
"a",
"b",
"b",
"def LCM(a,b):\n return a * b // GCD(a,b)",
"LCM",
"return a * b // GCD(a,b)",
"a * b // GCD(a,b)",
"a * b",
"a",
"b",
"GCD(a,b)",
"GCD",
"a",
"b",
"a",
"a",
"b",
"b",
"def Eratosthenes(N):\n r = [True]*(N+1)\n r[0] = False\n r[1] = False\n i = 2\n while i*i<=N:\n if r[i]: \n j = i\n while i*j<=N:\n prime[i*j]=False\n j+=1\n i+=1\n return(r)",
"Eratosthenes",
"r = [True]*(N+1)",
"r",
"[True]*(N+1)",
"[True]",
"True",
"N+1",
"N",
"1",
"r[0] = False",
"r[0]",
"r",
"0",
"False",
"r[1] = False",
"r[1]",
"r",
"1",
"False",
"i = 2",
"i",
"2",
"while i*i<=N:\n if r[i]: \n j = i\n while i*j<=N:\n prime[i*j]=False\n j+=1\n i+=1\n ",
"i*i<=N",
"i*i",
"i",
"i",
"N",
"if r[i]: \n j = i\n while i*j<=N:\n prime[i*j]=False\n j+=1\n ",
"r[i]",
"r",
"i",
"j = i",
"j",
"i",
"while i*j<=N:\n prime[i*j]=False\n j+=1\n ",
"i*j<=N",
"i*j",
"i",
"j",
"N",
"prime[i*j]=False",
"prime[i*j]",
"prime",
"i*j",
"i",
"j",
"False",
"j+=1",
"j",
"1",
"i+=1",
"i",
"1",
"return(r)",
"r",
"N",
"N",
"def main():\n H,W,A,B = LI()\n\n ans = [0]*(W-B)\n\n ans[0] = 1\n\n for i in range(1,B+H-A):\n ans[0] *= i\n ans[0] %= mod\n for i in range(1,A-1+W-B):\n ans[0] *= i\n ans[0] %= mod\n for i in range(1,H-A):\n ans[0] *= pow(i,mod-2,mod)\n ans[0] %= mod\n for i in range(1,B+1):\n ans[0] *= pow(i,mod-2,mod)\n ans[0] %= mod\n for i in range(1,W-B):\n ans[0] *= pow(i,mod-2,mod)\n ans[0] %= mod\n for i in range(1,A):\n ans[0] *= pow(i,mod-2,mod)\n ans[0] %= mod\n\n for i in range(1,W-B):\n ans[i] = ans[i-1]\n ans[i] *= (B+H-A-1+i)\n ans[i] %= mod\n ans[i] *= (W-B-i)\n ans[i] %= mod\n ans[i] *= pow(B+i,mod-2,mod)\n ans[i] %= mod\n ans[i] *= pow(A-1+W-B-i,mod-2,mod)\n ans[i] %= mod\n\n return(sum(ans)%mod)",
"main",
"H,W,A,B = LI()",
"H",
"LI()",
"LI",
"W",
"A",
"B",
"ans = [0]*(W-B)",
"ans",
"[0]*(W-B)",
"[0]",
"0",
"W-B",
"W",
"B",
"ans[0] = 1",
"ans[0]",
"ans",
"0",
"1",
"for i in range(1,B+H-A):\n ans[0] *= i\n ans[0] %= mod\n ",
"i",
"range(1,B+H-A)",
"range",
"1",
"B+H-A",
"B+H",
"B",
"H",
"A",
"ans[0] *= i",
"ans[0]",
"ans",
"0",
"i",
"ans[0] %= mod",
"ans[0]",
"ans",
"0",
"mod",
"for i in range(1,A-1+W-B):\n ans[0] *= i\n ans[0] %= mod\n ",
"i",
"range(1,A-1+W-B)",
"range",
"1",
"A-1+W-B",
"A-1+W",
"A-1",
"A",
"1",
"W",
"B",
"ans[0] *= i",
"ans[0]",
"ans",
"0",
"i",
"ans[0] %= mod",
"ans[0]",
"ans",
"0",
"mod",
"for i in range(1,H-A):\n ans[0] *= pow(i,mod-2,mod)\n ans[0] %= mod\n ",
"i",
"range(1,H-A)",
"range",
"1",
"H-A",
"H",
"A",
"ans[0] *= pow(i,mod-2,mod)",
"ans[0]",
"ans",
"0",
"pow(i,mod-2,mod)",
"pow",
"i",
"mod-2",
"mod",
"2",
"mod",
"ans[0] %= mod",
"ans[0]",
"ans",
"0",
"mod",
"for i in range(1,B+1):\n ans[0] *= pow(i,mod-2,mod)\n ans[0] %= mod\n ",
"i",
"range(1,B+1)",
"range",
"1",
"B+1",
"B",
"1",
"ans[0] *= pow(i,mod-2,mod)",
"ans[0]",
"ans",
"0",
"pow(i,mod-2,mod)",
"pow",
"i",
"mod-2",
"mod",
"2",
"mod",
"ans[0] %= mod",
"ans[0]",
"ans",
"0",
"mod",
"for i in range(1,W-B):\n ans[0] *= pow(i,mod-2,mod)\n ans[0] %= mod\n ",
"i",
"range(1,W-B)",
"range",
"1",
"W-B",
"W",
"B",
"ans[0] *= pow(i,mod-2,mod)",
"ans[0]",
"ans",
"0",
"pow(i,mod-2,mod)",
"pow",
"i",
"mod-2",
"mod",
"2",
"mod",
"ans[0] %= mod",
"ans[0]",
"ans",
"0",
"mod",
"for i in range(1,A):\n ans[0] *= pow(i,mod-2,mod)\n ans[0] %= mod\n\n ",
"i",
"range(1,A)",
"range",
"1",
"A",
"ans[0] *= pow(i,mod-2,mod)",
"ans[0]",
"ans",
"0",
"pow(i,mod-2,mod)",
"pow",
"i",
"mod-2",
"mod",
"2",
"mod",
"ans[0] %= mod",
"ans[0]",
"ans",
"0",
"mod",
"for i in range(1,W-B):\n ans[i] = ans[i-1]\n ans[i] *= (B+H-A-1+i)\n ans[i] %= mod\n ans[i] *= (W-B-i)\n ans[i] %= mod\n ans[i] *= pow(B+i,mod-2,mod)\n ans[i] %= mod\n ans[i] *= pow(A-1+W-B-i,mod-2,mod)\n ans[i] %= mod\n\n ",
"i",
"range(1,W-B)",
"range",
"1",
"W-B",
"W",
"B",
"ans[i] = ans[i-1]",
"ans[i]",
"ans",
"i",
"ans[i-1]",
"ans",
"i-1",
"i",
"1",
"ans[i] *= (B+H-A-1+i)",
"ans[i]",
"ans",
"i",
"B+H-A-1+i",
"B+H-A-1",
"B+H-A",
"B+H",
"B",
"H",
"A",
"1",
"i",
"ans[i] %= mod",
"ans[i]",
"ans",
"i",
"mod",
"ans[i] *= (W-B-i)",
"ans[i]",
"ans",
"i",
"W-B-i",
"W-B",
"W",
"B",
"i",
"ans[i] %= mod",
"ans[i]",
"ans",
"i",
"mod",
"ans[i] *= pow(B+i,mod-2,mod)",
"ans[i]",
"ans",
"i",
"pow(B+i,mod-2,mod)",
"pow",
"B+i",
"B",
"i",
"mod-2",
"mod",
"2",
"mod",
"ans[i] %= mod",
"ans[i]",
"ans",
"i",
"mod",
"ans[i] *= pow(A-1+W-B-i,mod-2,mod)",
"ans[i]",
"ans",
"i",
"pow(A-1+W-B-i,mod-2,mod)",
"pow",
"A-1+W-B-i",
"A-1+W-B",
"A-1+W",
"A-1",
"A",
"1",
"W",
"B",
"i",
"mod-2",
"mod",
"2",
"mod",
"ans[i] %= mod",
"ans[i]",
"ans",
"i",
"mod",
"return(sum(ans)%mod)",
"sum(ans)%mod",
"sum(ans)",
"sum",
"ans",
"mod",
"if __name__ == \"__main__\":\n print(main())",
"__name__ == \"__main__\"",
"__name__",
"\"__main__\"",
"print(main())",
"print",
"main()",
"main",
"mod = 10**9+7",
"10**9+7",
"mod",
"def IR(n): return([I() for _ in range(n)])",
"def IR(n): return([I() for _ in range(n)])",
"IR",
"def S(): return(sys.stdin.readline()[:-1])",
"def S(): return(sys.stdin.readline()[:-1])",
"S",
"def LI(): return([int(x) for x in sys.stdin.readline().split()])",
"def LI(): return([int(x) for x in sys.stdin.readline().split()])",
"LI",
"def LCM(a,b):\n return a * b // GCD(a,b)",
"def LCM(a,b):\n return a * b // GCD(a,b)",
"LCM",
"def I(): return(int(sys.stdin.readline()))",
"def I(): return(int(sys.stdin.readline()))",
"I",
"def GCD(a,b):\n while b!=0:\n a,b = b,a%b\n return a",
"def GCD(a,b):\n while b!=0:\n a,b = b,a%b\n return a",
"GCD",
"def Eratosthenes(N):\n r = [True]*(N+1)\n r[0] = False\n r[1] = False\n i = 2\n while i*i<=N:\n if r[i]: \n j = i\n while i*j<=N:\n prime[i*j]=False\n j+=1\n i+=1\n return(r)",
"def Eratosthenes(N):\n r = [True]*(N+1)\n r[0] = False\n r[1] = False\n i = 2\n while i*i<=N:\n if r[i]: \n j = i\n while i*j<=N:\n prime[i*j]=False\n j+=1\n i+=1\n return(r)",
"Eratosthenes",
"def main():\n H,W,A,B = LI()\n\n ans = [0]*(W-B)\n\n ans[0] = 1\n\n for i in range(1,B+H-A):\n ans[0] *= i\n ans[0] %= mod\n for i in range(1,A-1+W-B):\n ans[0] *= i\n ans[0] %= mod\n for i in range(1,H-A):\n ans[0] *= pow(i,mod-2,mod)\n ans[0] %= mod\n for i in range(1,B+1):\n ans[0] *= pow(i,mod-2,mod)\n ans[0] %= mod\n for i in range(1,W-B):\n ans[0] *= pow(i,mod-2,mod)\n ans[0] %= mod\n for i in range(1,A):\n ans[0] *= pow(i,mod-2,mod)\n ans[0] %= mod\n\n for i in range(1,W-B):\n ans[i] = ans[i-1]\n ans[i] *= (B+H-A-1+i)\n ans[i] %= mod\n ans[i] *= (W-B-i)\n ans[i] %= mod\n ans[i] *= pow(B+i,mod-2,mod)\n ans[i] %= mod\n ans[i] *= pow(A-1+W-B-i,mod-2,mod)\n ans[i] %= mod\n\n return(sum(ans)%mod)",
"def main():\n H,W,A,B = LI()\n\n ans = [0]*(W-B)\n\n ans[0] = 1\n\n for i in range(1,B+H-A):\n ans[0] *= i\n ans[0] %= mod\n for i in range(1,A-1+W-B):\n ans[0] *= i\n ans[0] %= mod\n for i in range(1,H-A):\n ans[0] *= pow(i,mod-2,mod)\n ans[0] %= mod\n for i in range(1,B+1):\n ans[0] *= pow(i,mod-2,mod)\n ans[0] %= mod\n for i in range(1,W-B):\n ans[0] *= pow(i,mod-2,mod)\n ans[0] %= mod\n for i in range(1,A):\n ans[0] *= pow(i,mod-2,mod)\n ans[0] %= mod\n\n for i in range(1,W-B):\n ans[i] = ans[i-1]\n ans[i] *= (B+H-A-1+i)\n ans[i] %= mod\n ans[i] *= (W-B-i)\n ans[i] %= mod\n ans[i] *= pow(B+i,mod-2,mod)\n ans[i] %= mod\n ans[i] *= pow(A-1+W-B-i,mod-2,mod)\n ans[i] %= mod\n\n return(sum(ans)%mod)",
"main",
"dd = ((-1,0),(1,0),(0,-1),(0,1))",
"((-1,0),(1,0),(0,-1),(0,1))",
"dd"
] | import sys
import heapq
import bisect
mod = 10**9+7
dd = ((-1,0),(1,0),(0,-1),(0,1))
def I(): return(int(sys.stdin.readline()))
def LI(): return([int(x) for x in sys.stdin.readline().split()])
def S(): return(sys.stdin.readline()[:-1])
def IR(n): return([I() for _ in range(n)])
def GCD(a,b):
while b!=0:
a,b = b,a%b
return a
def LCM(a,b):
return a * b // GCD(a,b)
def Eratosthenes(N):
r = [True]*(N+1)
r[0] = False
r[1] = False
i = 2
while i*i<=N:
if r[i]:
j = i
while i*j<=N:
prime[i*j]=False
j+=1
i+=1
return(r)
def main():
H,W,A,B = LI()
ans = [0]*(W-B)
ans[0] = 1
for i in range(1,B+H-A):
ans[0] *= i
ans[0] %= mod
for i in range(1,A-1+W-B):
ans[0] *= i
ans[0] %= mod
for i in range(1,H-A):
ans[0] *= pow(i,mod-2,mod)
ans[0] %= mod
for i in range(1,B+1):
ans[0] *= pow(i,mod-2,mod)
ans[0] %= mod
for i in range(1,W-B):
ans[0] *= pow(i,mod-2,mod)
ans[0] %= mod
for i in range(1,A):
ans[0] *= pow(i,mod-2,mod)
ans[0] %= mod
for i in range(1,W-B):
ans[i] = ans[i-1]
ans[i] *= (B+H-A-1+i)
ans[i] %= mod
ans[i] *= (W-B-i)
ans[i] %= mod
ans[i] *= pow(B+i,mod-2,mod)
ans[i] %= mod
ans[i] *= pow(A-1+W-B-i,mod-2,mod)
ans[i] %= mod
return(sum(ans)%mod)
if __name__ == "__main__":
print(main())
|
[
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,
39,
17,
28,
13,
4,
13,
17,
2,
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,
13,
17,
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,
17,
28,
13,
4,
13,
2,
13,
13,
0,
13,
2,
4,
13,
2,
2,
13,
13,
17,
13,
4,
13,
2,
2,
2,
13,
13,
17,
2,
2,
13,
13,
17,
2,
2,
13,
13,
17,
0,
13,
13,
4,
13,
13,
10,
4,
13,
10,
39,
13,
10,
4,
13,
10,
13,
13,
10,
2,
13,
10,
2,
13,
10,
17,
13,
10,
4,
13,
10,
4,
13,
10,
39,
13,
10,
12,
13,
10,
2,
13
] | [
[
173,
2
],
[
173,
11
],
[
173,
12
],
[
173,
13
],
[
164,
15
],
[
150,
17
],
[
171,
18
],
[
182,
20
],
[
152,
27
],
[
32,
31
],
[
165,
36
],
[
153,
40
],
[
153,
45
],
[
31,
47
],
[
183,
48
],
[
176,
50
],
[
153,
55
],
[
183,
58
],
[
183,
60
],
[
63,
62
],
[
165,
65
],
[
177,
70
],
[
177,
75
],
[
62,
77
],
[
183,
78
],
[
177,
81
],
[
153,
89
],
[
100,
90
],
[
177,
92
],
[
100,
94
],
[
102,
95
],
[
177,
97
],
[
102,
98
],
[
100,
100
],
[
102,
102
],
[
167,
104
],
[
108,
107
],
[
150,
111
],
[
174,
112
],
[
161,
114
],
[
180,
117
],
[
156,
120
],
[
107,
121
],
[
107,
123
],
[
180,
125
],
[
171,
129
],
[
156,
130
],
[
150,
134
],
[
107,
135
],
[
150,
139
],
[
107,
140
],
[
158,
143
],
[
183,
144
],
[
159,
147
],
[
162,
147
],
[
168,
147
],
[
173,
150
],
[
152,
153
],
[
173,
156
],
[
183,
158
],
[
158,
159
],
[
161,
162
],
[
164,
165
],
[
167,
168
],
[
173,
171
],
[
173,
174
],
[
176,
177
],
[
182,
183
]
] | [
"H,W,A,B=map(int,input().split())\nN=H+W\nmod=10**9+7\nfactl=[1]\nfor i in range(1,N+1):\n factl.append(factl[-1]*i%mod)\ninvl=[pow(factl[-1],mod-2,mod)]\nfor i in range(N,0,-1):\n invl.append(invl[-1]*i%mod)\ninvl.reverse()\ndef Comb(a,b):\n return factl[a]*invl[a-b]*invl[b]\nans=0\nfor i in range(H-A):\n ans+=Comb(B+i-1,i)*Comb((W-B-1)+(H-i-1), H-i-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",
"N",
"H+W",
"H",
"W",
"mod=10**9+7",
"mod",
"10**9+7",
"10**9",
"10",
"9",
"7",
"factl=[1]",
"factl",
"[1]",
"1",
"for i in range(1,N+1):\n factl.append(factl[-1]*i%mod)",
"i",
"range(1,N+1)",
"range",
"1",
"N+1",
"N",
"1",
"factl.append(factl[-1]*i%mod)",
"factl.append",
"factl",
"append",
"factl[-1]*i%mod",
"factl[-1]*i",
"factl[-1]",
"factl",
"-1",
"i",
"mod",
"invl=[pow(factl[-1],mod-2,mod)]",
"invl",
"[pow(factl[-1],mod-2,mod)]",
"pow(factl[-1],mod-2,mod)",
"pow",
"factl[-1]",
"factl",
"-1",
"mod-2",
"mod",
"2",
"mod",
"for i in range(N,0,-1):\n invl.append(invl[-1]*i%mod)",
"i",
"range(N,0,-1)",
"range",
"N",
"0",
"-1",
"invl.append(invl[-1]*i%mod)",
"invl.append",
"invl",
"append",
"invl[-1]*i%mod",
"invl[-1]*i",
"invl[-1]",
"invl",
"-1",
"i",
"mod",
"invl.reverse()",
"invl.reverse",
"invl",
"reverse",
"def Comb(a,b):\n return factl[a]*invl[a-b]*invl[b]",
"Comb",
"return factl[a]*invl[a-b]*invl[b]",
"factl[a]*invl[a-b]*invl[b]",
"factl[a]*invl[a-b]",
"factl[a]",
"factl",
"a",
"invl[a-b]",
"invl",
"a-b",
"a",
"b",
"invl[b]",
"invl",
"b",
"a",
"a",
"b",
"b",
"ans=0",
"ans",
"0",
"for i in range(H-A):\n ans+=Comb(B+i-1,i)*Comb((W-B-1)+(H-i-1), H-i-1)\n ans%=mod",
"i",
"range(H-A)",
"range",
"H-A",
"H",
"A",
"ans+=Comb(B+i-1,i)*Comb((W-B-1)+(H-i-1), H-i-1)",
"ans",
"Comb(B+i-1,i)*Comb((W-B-1)+(H-i-1), H-i-1)",
"Comb(B+i-1,i)",
"Comb",
"B+i-1",
"B+i",
"B",
"i",
"1",
"i",
"Comb((W-B-1)+(H-i-1), H-i-1)",
"Comb",
"(W-B-1)+(H-i-1)",
"W-B-1",
"W-B",
"W",
"B",
"1",
"H-i-1",
"H-i",
"H",
"i",
"1",
"H-i-1",
"H-i",
"H",
"i",
"1",
"ans%=mod",
"ans",
"mod",
"print(ans)",
"print",
"ans",
"H,W,A,B=map(int,input().split())",
"map(int,input().split())",
"H",
"factl=[1]",
"[1]",
"factl",
"B=map(int,input().split())",
"map(int,input().split())",
"B",
"ans%=mod",
"mod",
"ans",
"ans+=Comb(B+i-1,i)*Comb((W-B-1)+(H-i-1), H-i-1)",
"Comb(B+i-1,i)*Comb((W-B-1)+(H-i-1), H-i-1)",
"ans",
"N=H+W",
"H+W",
"N",
"ans=0",
"0",
"ans",
"W,A,B=map(int,input().split())",
"map(int,input().split())",
"W",
"A,B=map(int,input().split())",
"map(int,input().split())",
"A",
"invl=[pow(factl[-1],mod-2,mod)]",
"[pow(factl[-1],mod-2,mod)]",
"invl",
"def Comb(a,b):\n return factl[a]*invl[a-b]*invl[b]",
"def Comb(a,b):\n return factl[a]*invl[a-b]*invl[b]",
"Comb",
"mod=10**9+7",
"10**9+7",
"mod"
] | H,W,A,B=map(int,input().split())
N=H+W
mod=10**9+7
factl=[1]
for i in range(1,N+1):
factl.append(factl[-1]*i%mod)
invl=[pow(factl[-1],mod-2,mod)]
for i in range(N,0,-1):
invl.append(invl[-1]*i%mod)
invl.reverse()
def Comb(a,b):
return factl[a]*invl[a-b]*invl[b]
ans=0
for i in range(H-A):
ans+=Comb(B+i-1,i)*Comb((W-B-1)+(H-i-1), H-i-1)
ans%=mod
print(ans) |
[
7,
12,
13,
29,
2,
2,
18,
13,
13,
18,
13,
2,
13,
13,
18,
13,
13,
23,
13,
23,
13,
12,
13,
41,
0,
13,
4,
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,
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,
13,
2,
39,
17,
2,
2,
13,
13,
17,
0,
18,
13,
17,
4,
13,
18,
13,
17,
2,
13,
17,
13,
0,
13,
18,
13,
17,
28,
13,
4,
13,
2,
2,
13,
13,
17,
17,
17,
0,
13,
2,
2,
13,
2,
13,
17,
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,
12,
13,
10,
12,
13
] | [
[
18,
8
],
[
18,
12
],
[
20,
13
],
[
20,
16
],
[
18,
18
],
[
20,
20
],
[
26,
25
],
[
26,
36
],
[
26,
37
],
[
26,
38
],
[
41,
40
],
[
48,
47
],
[
25,
53
],
[
36,
54
],
[
57,
56
],
[
60,
59
],
[
25,
65
],
[
36,
66
],
[
70,
69
],
[
56,
72
],
[
69,
72
],
[
59,
73
],
[
40,
74
],
[
79,
76
],
[
47,
77
],
[
59,
78
],
[
69,
79
],
[
56,
79
],
[
82,
81
],
[
25,
87
],
[
36,
88
],
[
94,
91
],
[
81,
92
],
[
47,
97
],
[
40,
100
],
[
40,
102
],
[
105,
104
],
[
81,
106
],
[
110,
109
],
[
25,
114
],
[
36,
115
],
[
121,
120
],
[
104,
123
],
[
69,
123
],
[
56,
123
],
[
120,
123
],
[
109,
125
],
[
40,
127
],
[
132,
129
],
[
81,
130
],
[
109,
131
],
[
120,
132
],
[
104,
132
],
[
69,
132
],
[
56,
132
],
[
135,
134
],
[
138,
137
],
[
38,
140
],
[
36,
141
],
[
144,
143
],
[
185,
146
],
[
137,
150
],
[
25,
151
],
[
37,
152
],
[
137,
154
],
[
185,
156
],
[
36,
161
],
[
137,
162
],
[
37,
164
],
[
37,
167
],
[
143,
172
],
[
134,
172
],
[
40,
173
],
[
182,
179
]
] | [
"# ABC042D - いろはちゃんとマス目 / Iroha and a Grid (ARC058D)\ndef comb(n: int, r: int) -> int:\n return fact[n] * inv[n - r] * inv[r]\n\n\ndef main():\n global fact, inv\n H, W, A, B = tuple(map(int, input().split()))\n MOD = 10 ** 9 + 7\n # table of factorials\n fact, x = [1] * (H + W + 1), 1\n for i in range(1, H + W + 1):\n x = (x * i) % MOD\n fact[i] = x\n # table of inverse factorials\n inv = [1] * (H + W + 1)\n inv[-1] = pow(fact[-1], MOD - 2, MOD)\n x = inv[-1]\n for i in range(H + W - 1, 0, -1):\n x = (x * (i + 1)) % MOD\n inv[i] = x\n\n ans = 0\n for i in range(B, W):\n ans += comb(i + H - A - 1, i) * comb(W - i - 1 + A - 1, A - 1)\n print(ans % MOD)\n\n\nif __name__ == \"__main__\":\n main()",
"def comb(n: int, r: int) -> int:\n return fact[n] * inv[n - r] * inv[r]",
"comb",
"return fact[n] * inv[n - r] * inv[r]",
"fact[n] * inv[n - r] * inv[r]",
"fact[n] * inv[n - r]",
"fact[n]",
"fact",
"n",
"inv[n - r]",
"inv",
"n - r",
"n",
"r",
"inv[r]",
"inv",
"r",
"n: int",
"n",
"r: int",
"r",
"def main():\n global fact, inv\n H, W, A, B = tuple(map(int, input().split()))\n MOD = 10 ** 9 + 7\n # table of factorials\n fact, x = [1] * (H + W + 1), 1\n for i in range(1, H + W + 1):\n x = (x * i) % MOD\n fact[i] = x\n # table of inverse factorials\n inv = [1] * (H + W + 1)\n inv[-1] = pow(fact[-1], MOD - 2, MOD)\n x = inv[-1]\n for i in range(H + W - 1, 0, -1):\n x = (x * (i + 1)) % MOD\n inv[i] = x\n\n ans = 0\n for i in range(B, W):\n ans += comb(i + H - A - 1, i) * comb(W - i - 1 + A - 1, A - 1)\n print(ans % MOD)",
"main",
"global fact, inv",
"H, W, A, B = tuple(map(int, input().split()))",
"H",
"tuple(map(int, input().split()))",
"tuple",
"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, x = [1] * (H + W + 1), 1",
"fact",
"[1] * (H + W + 1)",
"[1]",
"1",
"H + W + 1",
"H + W",
"H",
"W",
"1",
"x",
"1",
"for i in range(1, H + W + 1):\n x = (x * i) % MOD\n fact[i] = x\n # table of inverse factorials\n ",
"i",
"range(1, H + W + 1)",
"range",
"1",
"H + W + 1",
"H + W",
"H",
"W",
"1",
"x = (x * i) % MOD",
"x",
"(x * i) % MOD",
"x * i",
"x",
"i",
"MOD",
"fact[i] = x",
"fact[i]",
"fact",
"i",
"x",
"inv = [1] * (H + W + 1)",
"inv",
"[1] * (H + W + 1)",
"[1]",
"1",
"H + W + 1",
"H + W",
"H",
"W",
"1",
"inv[-1] = pow(fact[-1], MOD - 2, MOD)",
"inv[-1]",
"inv",
"-1",
"pow(fact[-1], MOD - 2, MOD)",
"pow",
"fact[-1]",
"fact",
"-1",
"MOD - 2",
"MOD",
"2",
"MOD",
"x = inv[-1]",
"x",
"inv[-1]",
"inv",
"-1",
"for i in range(H + W - 1, 0, -1):\n x = (x * (i + 1)) % MOD\n inv[i] = x\n\n ",
"i",
"range(H + W - 1, 0, -1)",
"range",
"H + W - 1",
"H + W",
"H",
"W",
"1",
"0",
"-1",
"x = (x * (i + 1)) % MOD",
"x",
"(x * (i + 1)) % MOD",
"x * (i + 1)",
"x",
"i + 1",
"i",
"1",
"MOD",
"inv[i] = x",
"inv[i]",
"inv",
"i",
"x",
"ans = 0",
"ans",
"0",
"for i in range(B, W):\n ans += comb(i + H - A - 1, i) * comb(W - i - 1 + A - 1, A - 1)\n ",
"i",
"range(B, W)",
"range",
"B",
"W",
"ans += comb(i + H - A - 1, i) * comb(W - i - 1 + A - 1, A - 1)",
"ans",
"comb(i + H - A - 1, i) * comb(W - i - 1 + A - 1, A - 1)",
"comb(i + H - A - 1, i)",
"comb",
"i + H - A - 1",
"i + H - A",
"i + H",
"i",
"H",
"A",
"1",
"i",
"comb(W - i - 1 + A - 1, A - 1)",
"comb",
"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",
"def main():\n global fact, inv\n H, W, A, B = tuple(map(int, input().split()))\n MOD = 10 ** 9 + 7\n # table of factorials\n fact, x = [1] * (H + W + 1), 1\n for i in range(1, H + W + 1):\n x = (x * i) % MOD\n fact[i] = x\n # table of inverse factorials\n inv = [1] * (H + W + 1)\n inv[-1] = pow(fact[-1], MOD - 2, MOD)\n x = inv[-1]\n for i in range(H + W - 1, 0, -1):\n x = (x * (i + 1)) % MOD\n inv[i] = x\n\n ans = 0\n for i in range(B, W):\n ans += comb(i + H - A - 1, i) * comb(W - i - 1 + A - 1, A - 1)\n print(ans % MOD)",
"def main():\n global fact, inv\n H, W, A, B = tuple(map(int, input().split()))\n MOD = 10 ** 9 + 7\n # table of factorials\n fact, x = [1] * (H + W + 1), 1\n for i in range(1, H + W + 1):\n x = (x * i) % MOD\n fact[i] = x\n # table of inverse factorials\n inv = [1] * (H + W + 1)\n inv[-1] = pow(fact[-1], MOD - 2, MOD)\n x = inv[-1]\n for i in range(H + W - 1, 0, -1):\n x = (x * (i + 1)) % MOD\n inv[i] = x\n\n ans = 0\n for i in range(B, W):\n ans += comb(i + H - A - 1, i) * comb(W - i - 1 + A - 1, A - 1)\n print(ans % MOD)",
"main",
"def comb(n: int, r: int) -> int:\n return fact[n] * inv[n - r] * inv[r]",
"def comb(n: int, r: int) -> int:\n return fact[n] * inv[n - r] * inv[r]",
"comb"
] | # ABC042D - いろはちゃんとマス目 / Iroha and a Grid (ARC058D)
def comb(n: int, r: int) -> int:
return fact[n] * inv[n - r] * inv[r]
def main():
global fact, inv
H, W, A, B = tuple(map(int, input().split()))
MOD = 10 ** 9 + 7
# table of factorials
fact, x = [1] * (H + W + 1), 1
for i in range(1, H + W + 1):
x = (x * i) % MOD
fact[i] = x
# table of inverse factorials
inv = [1] * (H + W + 1)
inv[-1] = pow(fact[-1], MOD - 2, MOD)
x = inv[-1]
for i in range(H + W - 1, 0, -1):
x = (x * (i + 1)) % MOD
inv[i] = x
ans = 0
for i in range(B, W):
ans += comb(i + H - A - 1, i) * comb(W - i - 1 + A - 1, A - 1)
print(ans % MOD)
if __name__ == "__main__":
main() |
[
7,
15,
15,
13,
4,
18,
13,
13,
2,
17,
17,
15,
15,
15,
12,
13,
12,
13,
12,
13,
12,
13,
41,
28,
13,
4,
13,
13,
4,
4,
13,
12,
13,
23,
13,
0,
13,
12,
2,
4,
13,
13,
17,
23,
12,
13,
12,
13,
0,
13,
12,
4,
13,
31,
13,
0,
13,
17,
23,
0,
13,
39,
39,
17,
17,
39,
17,
17,
39,
17,
17,
39,
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,
12,
13,
29,
4,
13,
40,
18,
13,
13,
23,
13,
12,
13,
14,
4,
13,
13,
13,
29,
4,
13,
2,
18,
13,
13,
13,
23,
13,
23,
13,
12,
13,
14,
4,
13,
13,
13,
29,
4,
13,
2,
18,
13,
13,
13,
23,
13,
23,
13,
12,
13,
29,
4,
13,
2,
13,
18,
13,
13,
23,
13,
23,
13,
12,
13,
14,
4,
13,
13,
13,
29,
4,
13,
2,
18,
13,
13,
13,
23,
13,
23,
13,
0,
13,
13,
0,
13,
13,
12,
13,
14,
4,
13,
13,
13,
29,
4,
13,
2,
18,
13,
13,
4,
13,
13,
2,
13,
17,
13,
23,
13,
23,
13,
12,
13,
29,
4,
13,
2,
13,
4,
13,
18,
13,
13,
2,
13,
17,
13,
23,
13,
23,
13,
12,
13,
29,
4,
13,
4,
13,
18,
13,
13,
13,
13,
23,
13,
23,
13,
23,
13,
17,
0,
13,
2,
2,
17,
17,
17,
12,
13,
14,
2,
13,
13,
29,
2,
2,
18,
13,
13,
18,
13,
13,
18,
13,
2,
13,
13,
23,
13,
23,
13,
0,
13,
17,
0,
13,
39,
4,
13,
17,
28,
13,
4,
13,
17,
2,
13,
17,
0,
13,
2,
39,
4,
13,
17,
2,
13,
17,
0,
18,
13,
13,
18,
13,
13,
28,
13,
4,
13,
2,
13,
17,
17,
17,
12,
13,
0,
13,
4,
13,
13,
13,
13,
0,
13,
39,
28,
13,
4,
13,
2,
13,
13,
4,
18,
13,
13,
4,
13,
2,
13,
13,
13,
0,
13,
4,
13,
17,
0,
13,
17,
28,
13,
13,
4,
13,
13,
0,
13,
2,
2,
13,
13,
4,
13,
2,
2,
2,
2,
2,
13,
17,
13,
13,
17,
13,
2,
2,
13,
17,
13,
0,
13,
13,
4,
13,
13,
4,
13,
10,
12,
13,
10,
12,
13,
10,
12,
13,
10,
12,
13,
10,
12,
13,
10,
12,
13,
10,
17,
13,
10,
39,
13,
10,
6,
13,
10,
12,
13,
10,
12,
13,
10,
12,
13,
10,
39,
13,
10,
2,
13,
10,
12,
13,
10,
12,
13,
10,
2,
13
] | [
[
25,
24
],
[
435,
30
],
[
34,
34
],
[
413,
36
],
[
407,
49
],
[
57,
56
],
[
437,
60
],
[
82,
79
],
[
86,
80
],
[
88,
83
],
[
86,
86
],
[
88,
88
],
[
98,
95
],
[
98,
98
],
[
109,
106
],
[
109,
109
],
[
128,
115
],
[
126,
122
],
[
128,
124
],
[
126,
126
],
[
128,
128
],
[
147,
134
],
[
145,
141
],
[
147,
143
],
[
145,
145
],
[
147,
147
],
[
161,
154
],
[
159,
156
],
[
159,
159
],
[
161,
161
],
[
180,
167
],
[
178,
174
],
[
180,
176
],
[
178,
178
],
[
180,
180
],
[
183,
182
],
[
111,
183
],
[
186,
185
],
[
163,
186
],
[
211,
192
],
[
209,
199
],
[
211,
203
],
[
209,
209
],
[
211,
211
],
[
231,
218
],
[
229,
222
],
[
229,
229
],
[
231,
231
],
[
245,
240
],
[
247,
242
],
[
245,
245
],
[
247,
247
],
[
250,
249
],
[
449,
252
],
[
279,
262
],
[
281,
263
],
[
279,
269
],
[
281,
272
],
[
279,
276
],
[
281,
277
],
[
279,
279
],
[
281,
281
],
[
419,
283
],
[
422,
286
],
[
293,
292
],
[
420,
297
],
[
440,
300
],
[
420,
307
],
[
313,
310
],
[
441,
311
],
[
420,
312
],
[
423,
314
],
[
420,
315
],
[
318,
317
],
[
420,
321
],
[
329,
328
],
[
402,
330
],
[
329,
331
],
[
329,
332
],
[
329,
333
],
[
336,
335
],
[
339,
338
],
[
328,
342
],
[
332,
343
],
[
335,
346
],
[
411,
349
],
[
333,
351
],
[
338,
352
],
[
338,
353
],
[
356,
355
],
[
361,
360
],
[
335,
367
],
[
370,
369
],
[
360,
373
],
[
393,
373
],
[
411,
375
],
[
328,
381
],
[
331,
384
],
[
333,
386
],
[
331,
389
],
[
333,
391
],
[
394,
393
],
[
369,
397
],
[
355,
397
],
[
444,
399
],
[
407,
408
],
[
413,
414
],
[
419,
420
],
[
422,
423
],
[
437,
438
],
[
440,
441
],
[
449,
450
]
] | [
"from itertools import permutations\nimport sys\n\nsys.setrecursionlimit(10 ** 6)\nfrom bisect import *\nfrom collections import *\nfrom heapq import *\n\ndef II(): return int(sys.stdin.readline())\ndef MI(): return map(int, sys.stdin.readline().split())\ndef LI(): return list(map(int, sys.stdin.readline().split()))\ndef SI(): return sys.stdin.readline()[:-1]\ndef LLI(rows_number): return [LI() for _ in range(rows_number)]\nint1 = lambda x: int(x) - 1\ndef MI1(): return map(int1, sys.stdin.readline().split())\ndef LI1(): return list(map(int1, sys.stdin.readline().split()))\np2D = lambda x: print(*x, sep=\"\\n\")\ndij = [(1, 0), (0, 1), (-1, 0), (0, -1)]\n\n# grobalにmdを設定すること\nclass mint:\n def __init__(self, x):\n self.__x = x % md\n\n def __str__(self):\n return str(self.__x)\n\n def __neg__(self):\n return mint(-self.__x)\n\n def __add__(self, other):\n if isinstance(other, mint): other = other.__x\n return mint(self.__x + other)\n\n def __sub__(self, other):\n if isinstance(other, mint): other = other.__x\n return mint(self.__x - other)\n\n def __rsub__(self, other):\n return mint(other - self.__x)\n\n def __mul__(self, other):\n if isinstance(other, mint): other = other.__x\n return mint(self.__x * other)\n\n __radd__ = __add__\n __rmul__ = __mul__\n\n def __truediv__(self, other):\n if isinstance(other, mint): other = other.__x\n return mint(self.__x * pow(other, md - 2, md))\n\n def __rtruediv__(self, other):\n return mint(other * pow(self.__x, md - 2, md))\n\n def __pow__(self, power, modulo=None):\n return mint(pow(self.__x, power, md))\n\nmd = 10**9+7\n\ndef nCr(com_n, com_r):\n if com_n < com_r: return 0\n return fac[com_n] * ifac[com_r] * ifac[com_n - com_r]\n\nn_max = 200005\nfac = [mint(1)]\nfor i in range(1, n_max + 1): fac.append(fac[-1] * i)\nifac = [mint(1)] * (n_max + 1)\nifac[n_max] /= fac[n_max]\nfor i in range(n_max - 1, 1, -1): ifac[i] = ifac[i + 1] * (i + 1)\n\ndef main():\n h,w,a,b=MI()\n cc=[]\n for i in range(h-a):\n cc.append(nCr(b+i,i))\n #print(*cc)\n ans=mint(0)\n pc=0\n for i,c in enumerate(cc):\n ans+=(c-pc)*nCr(h-1-i+w-1-b,w-1-b)\n pc=c\n print(ans)\n\nmain()",
"from itertools import permutations",
"import sys",
"sys",
"sys.setrecursionlimit(10 ** 6)",
"sys.setrecursionlimit",
"sys",
"setrecursionlimit",
"10 ** 6",
"10",
"6",
"from bisect import *",
"from collections import *",
"from heapq import *",
"def II(): return int(sys.stdin.readline())",
"II",
"def MI(): return map(int, sys.stdin.readline().split())",
"MI",
"def LI(): return list(map(int, sys.stdin.readline().split()))",
"LI",
"def SI(): return sys.stdin.readline()[:-1]",
"SI",
"LI() for _ in range(rows_number)",
"for _ in range(rows_number)",
"_",
"range(rows_number)",
"range",
"rows_number",
"for _ in range(rows_number)",
"LI()",
"LI",
"def LLI(rows_number): return [LI() for _ in range(rows_number)]",
"LLI",
"rows_number",
"rows_number",
"int1 = lambda x: int(x) - 1",
"int1",
"lambda x: int(x) - 1",
"int(x) - 1",
"int(x)",
"int",
"x",
"1",
"x",
"def MI1(): return map(int1, sys.stdin.readline().split())",
"MI1",
"def LI1(): return list(map(int1, sys.stdin.readline().split()))",
"LI1",
"p2D = lambda x: print(*x, sep=\"\\n\")",
"p2D",
"lambda x: print(*x, sep=\"\\n\")",
"print(*x, sep=\"\\n\")",
"print",
"*x",
"x",
"sep=\"\\n\"",
"sep",
"\"\\n\"",
"x",
"dij = [(1, 0), (0, 1), (-1, 0), (0, -1)]",
"dij",
"[(1, 0), (0, 1), (-1, 0), (0, -1)]",
"(1, 0)",
"1",
"0",
"(0, 1)",
"0",
"1",
"(-1, 0)",
"-1",
"0",
"(0, -1)",
"0",
"-1",
"class mint:\n def __init__(self, x):\n self.__x = x % md\n\n def __str__(self):\n return str(self.__x)\n\n def __neg__(self):\n return mint(-self.__x)\n\n def __add__(self, other):\n if isinstance(other, mint): other = other.__x\n return mint(self.__x + other)\n\n def __sub__(self, other):\n if isinstance(other, mint): other = other.__x\n return mint(self.__x - other)\n\n def __rsub__(self, other):\n return mint(other - self.__x)\n\n def __mul__(self, other):\n if isinstance(other, mint): other = other.__x\n return mint(self.__x * other)\n\n __radd__ = __add__\n __rmul__ = __mul__\n\n def __truediv__(self, other):\n if isinstance(other, mint): other = other.__x\n return mint(self.__x * pow(other, md - 2, md))\n\n def __rtruediv__(self, other):\n return mint(other * pow(self.__x, md - 2, md))\n\n def __pow__(self, power, modulo=None):\n return mint(pow(self.__x, power, md))",
"mint",
"def __init__(self, x):\n self.__x = x % md\n\n ",
"__init__",
"self.__x = x % md",
"self.__x",
"self",
"__x",
"x % md",
"x",
"md",
"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",
"def __neg__(self):\n return mint(-self.__x)\n\n ",
"__neg__",
"return mint(-self.__x)",
"mint(-self.__x)",
"mint",
"-self.__x",
"self.__x",
"self",
"__x",
"self",
"self",
"def __add__(self, other):\n if isinstance(other, mint): other = other.__x\n return mint(self.__x + other)\n\n ",
"__add__",
"if isinstance(other, mint): other = other.__x\n ",
"isinstance(other, mint)",
"isinstance",
"other",
"mint",
"return mint(self.__x + other)",
"mint(self.__x + other)",
"mint",
"self.__x + other",
"self.__x",
"self",
"__x",
"other",
"self",
"self",
"other",
"other",
"def __sub__(self, other):\n if isinstance(other, mint): other = other.__x\n return mint(self.__x - other)\n\n ",
"__sub__",
"if isinstance(other, mint): other = other.__x\n ",
"isinstance(other, mint)",
"isinstance",
"other",
"mint",
"return mint(self.__x - other)",
"mint(self.__x - other)",
"mint",
"self.__x - other",
"self.__x",
"self",
"__x",
"other",
"self",
"self",
"other",
"other",
"def __rsub__(self, other):\n return mint(other - self.__x)\n\n ",
"__rsub__",
"return mint(other - self.__x)",
"mint(other - self.__x)",
"mint",
"other - self.__x",
"other",
"self.__x",
"self",
"__x",
"self",
"self",
"other",
"other",
"def __mul__(self, other):\n if isinstance(other, mint): other = other.__x\n return mint(self.__x * other)\n\n ",
"__mul__",
"if isinstance(other, mint): other = other.__x\n ",
"isinstance(other, mint)",
"isinstance",
"other",
"mint",
"return mint(self.__x * other)",
"mint(self.__x * other)",
"mint",
"self.__x * other",
"self.__x",
"self",
"__x",
"other",
"self",
"self",
"other",
"other",
"__radd__ = __add__",
"__radd__",
"__add__",
"__rmul__ = __mul__",
"__rmul__",
"__mul__",
"def __truediv__(self, other):\n if isinstance(other, mint): other = other.__x\n return mint(self.__x * pow(other, md - 2, md))\n\n ",
"__truediv__",
"if isinstance(other, mint): other = other.__x\n ",
"isinstance(other, mint)",
"isinstance",
"other",
"mint",
"return mint(self.__x * pow(other, md - 2, md))",
"mint(self.__x * pow(other, md - 2, md))",
"mint",
"self.__x * pow(other, md - 2, md)",
"self.__x",
"self",
"__x",
"pow(other, md - 2, md)",
"pow",
"other",
"md - 2",
"md",
"2",
"md",
"self",
"self",
"other",
"other",
"def __rtruediv__(self, other):\n return mint(other * pow(self.__x, md - 2, md))\n\n ",
"__rtruediv__",
"return mint(other * pow(self.__x, md - 2, md))",
"mint(other * pow(self.__x, md - 2, md))",
"mint",
"other * pow(self.__x, md - 2, md)",
"other",
"pow(self.__x, md - 2, md)",
"pow",
"self.__x",
"self",
"__x",
"md - 2",
"md",
"2",
"md",
"self",
"self",
"other",
"other",
"def __pow__(self, power, modulo=None):\n return mint(pow(self.__x, power, md))",
"__pow__",
"return mint(pow(self.__x, power, md))",
"mint(pow(self.__x, power, md))",
"mint",
"pow(self.__x, power, md)",
"pow",
"self.__x",
"self",
"__x",
"power",
"md",
"self",
"self",
"power",
"power",
"modulo=None",
"modulo",
"None",
"md = 10**9+7",
"md",
"10**9+7",
"10**9",
"10",
"9",
"7",
"def nCr(com_n, com_r):\n if com_n < com_r: return 0\n return fac[com_n] * ifac[com_r] * ifac[com_n - com_r]",
"nCr",
"if com_n < com_r: return 0\n ",
"com_n < com_r",
"com_n",
"com_r",
"return fac[com_n] * ifac[com_r] * ifac[com_n - com_r]",
"fac[com_n] * ifac[com_r] * ifac[com_n - com_r]",
"fac[com_n] * ifac[com_r]",
"fac[com_n]",
"fac",
"com_n",
"ifac[com_r]",
"ifac",
"com_r",
"ifac[com_n - com_r]",
"ifac",
"com_n - com_r",
"com_n",
"com_r",
"com_n",
"com_n",
"com_r",
"com_r",
"n_max = 200005",
"n_max",
"200005",
"fac = [mint(1)]",
"fac",
"[mint(1)]",
"mint(1)",
"mint",
"1",
"for i in range(1, n_max + 1): fac.append(fac[-1] * i)",
"i",
"range(1, n_max + 1)",
"range",
"1",
"n_max + 1",
"n_max",
"1",
"ifac = [mint(1)] * (n_max + 1)",
"ifac",
"[mint(1)] * (n_max + 1)",
"[mint(1)]",
"mint(1)",
"mint",
"1",
"n_max + 1",
"n_max",
"1",
"ifac[n_max] /= fac[n_max]",
"ifac[n_max]",
"ifac",
"n_max",
"fac[n_max]",
"fac",
"n_max",
"for i in range(n_max - 1, 1, -1): ifac[i] = ifac[i + 1] * (i + 1)",
"i",
"range(n_max - 1, 1, -1)",
"range",
"n_max - 1",
"n_max",
"1",
"1",
"-1",
"def main():\n h,w,a,b=MI()\n cc=[]\n for i in range(h-a):\n cc.append(nCr(b+i,i))\n #print(*cc)\n ans=mint(0)\n pc=0\n for i,c in enumerate(cc):\n ans+=(c-pc)*nCr(h-1-i+w-1-b,w-1-b)\n pc=c\n print(ans)",
"main",
"h,w,a,b=MI()",
"h",
"MI()",
"MI",
"w",
"a",
"b",
"cc=[]",
"cc",
"[]",
"for i in range(h-a):\n cc.append(nCr(b+i,i))\n #print(*cc)\n ",
"i",
"range(h-a)",
"range",
"h-a",
"h",
"a",
"cc.append(nCr(b+i,i))",
"cc.append",
"cc",
"append",
"nCr(b+i,i)",
"nCr",
"b+i",
"b",
"i",
"i",
"ans=mint(0)",
"ans",
"mint(0)",
"mint",
"0",
"pc=0",
"pc",
"0",
"for i,c in enumerate(cc):\n ans+=(c-pc)*nCr(h-1-i+w-1-b,w-1-b)\n pc=c\n ",
"i",
"c",
"enumerate(cc)",
"enumerate",
"cc",
"ans+=(c-pc)*nCr(h-1-i+w-1-b,w-1-b)",
"ans",
"(c-pc)*nCr(h-1-i+w-1-b,w-1-b)",
"c-pc",
"c",
"pc",
"nCr(h-1-i+w-1-b,w-1-b)",
"nCr",
"h-1-i+w-1-b",
"h-1-i+w-1",
"h-1-i+w",
"h-1-i",
"h-1",
"h",
"1",
"i",
"w",
"1",
"b",
"w-1-b",
"w-1",
"w",
"1",
"b",
"pc=c",
"pc",
"c",
"print(ans)",
"print",
"ans",
"main()",
"main",
"def MI(): return map(int, sys.stdin.readline().split())",
"def MI(): return map(int, sys.stdin.readline().split())",
"MI",
"def LI1(): return list(map(int1, sys.stdin.readline().split()))",
"def LI1(): return list(map(int1, sys.stdin.readline().split()))",
"LI1",
"p2D = lambda x: print(*x, sep=\"\\n\")",
"lambda x: print(*x, sep=\"\\n\")",
"p2D",
"def nCr(com_n, com_r):\n if com_n < com_r: return 0\n return fac[com_n] * ifac[com_r] * ifac[com_n - com_r]",
"def nCr(com_n, com_r):\n if com_n < com_r: return 0\n return fac[com_n] * ifac[com_r] * ifac[com_n - com_r]",
"nCr",
"int1 = lambda x: int(x) - 1",
"lambda x: int(x) - 1",
"int1",
"def II(): return int(sys.stdin.readline())",
"def II(): return int(sys.stdin.readline())",
"II",
"n_max = 200005",
"200005",
"n_max",
"fac = [mint(1)]",
"[mint(1)]",
"fac",
"class mint:\n def __init__(self, x):\n self.__x = x % md\n\n def __str__(self):\n return str(self.__x)\n\n def __neg__(self):\n return mint(-self.__x)\n\n def __add__(self, other):\n if isinstance(other, mint): other = other.__x\n return mint(self.__x + other)\n\n def __sub__(self, other):\n if isinstance(other, mint): other = other.__x\n return mint(self.__x - other)\n\n def __rsub__(self, other):\n return mint(other - self.__x)\n\n def __mul__(self, other):\n if isinstance(other, mint): other = other.__x\n return mint(self.__x * other)\n\n __radd__ = __add__\n __rmul__ = __mul__\n\n def __truediv__(self, other):\n if isinstance(other, mint): other = other.__x\n return mint(self.__x * pow(other, md - 2, md))\n\n def __rtruediv__(self, other):\n return mint(other * pow(self.__x, md - 2, md))\n\n def __pow__(self, power, modulo=None):\n return mint(pow(self.__x, power, md))",
"class mint:\n def __init__(self, x):\n self.__x = x % md\n\n def __str__(self):\n return str(self.__x)\n\n def __neg__(self):\n return mint(-self.__x)\n\n def __add__(self, other):\n if isinstance(other, mint): other = other.__x\n return mint(self.__x + other)\n\n def __sub__(self, other):\n if isinstance(other, mint): other = other.__x\n return mint(self.__x - other)\n\n def __rsub__(self, other):\n return mint(other - self.__x)\n\n def __mul__(self, other):\n if isinstance(other, mint): other = other.__x\n return mint(self.__x * other)\n\n __radd__ = __add__\n __rmul__ = __mul__\n\n def __truediv__(self, other):\n if isinstance(other, mint): other = other.__x\n return mint(self.__x * pow(other, md - 2, md))\n\n def __rtruediv__(self, other):\n return mint(other * pow(self.__x, md - 2, md))\n\n def __pow__(self, power, modulo=None):\n return mint(pow(self.__x, power, md))",
"mint",
"def LLI(rows_number): return [LI() for _ in range(rows_number)]",
"def LLI(rows_number): return [LI() for _ in range(rows_number)]",
"LLI",
"def SI(): return sys.stdin.readline()[:-1]",
"def SI(): return sys.stdin.readline()[:-1]",
"SI",
"def LI(): return list(map(int, sys.stdin.readline().split()))",
"def LI(): return list(map(int, sys.stdin.readline().split()))",
"LI",
"dij = [(1, 0), (0, 1), (-1, 0), (0, -1)]",
"[(1, 0), (0, 1), (-1, 0), (0, -1)]",
"dij",
"ifac = [mint(1)] * (n_max + 1)",
"[mint(1)] * (n_max + 1)",
"ifac",
"def main():\n h,w,a,b=MI()\n cc=[]\n for i in range(h-a):\n cc.append(nCr(b+i,i))\n #print(*cc)\n ans=mint(0)\n pc=0\n for i,c in enumerate(cc):\n ans+=(c-pc)*nCr(h-1-i+w-1-b,w-1-b)\n pc=c\n print(ans)",
"def main():\n h,w,a,b=MI()\n cc=[]\n for i in range(h-a):\n cc.append(nCr(b+i,i))\n #print(*cc)\n ans=mint(0)\n pc=0\n for i,c in enumerate(cc):\n ans+=(c-pc)*nCr(h-1-i+w-1-b,w-1-b)\n pc=c\n print(ans)",
"main",
"def MI1(): return map(int1, sys.stdin.readline().split())",
"def MI1(): return map(int1, sys.stdin.readline().split())",
"MI1",
"md = 10**9+7",
"10**9+7",
"md"
] | from itertools import permutations
import sys
sys.setrecursionlimit(10 ** 6)
from bisect import *
from collections import *
from heapq import *
def II(): return int(sys.stdin.readline())
def MI(): return map(int, sys.stdin.readline().split())
def LI(): return list(map(int, sys.stdin.readline().split()))
def SI(): return sys.stdin.readline()[:-1]
def LLI(rows_number): return [LI() for _ in range(rows_number)]
int1 = lambda x: int(x) - 1
def MI1(): return map(int1, sys.stdin.readline().split())
def LI1(): return list(map(int1, sys.stdin.readline().split()))
p2D = lambda x: print(*x, sep="\n")
dij = [(1, 0), (0, 1), (-1, 0), (0, -1)]
# grobalにmdを設定すること
class mint:
def __init__(self, x):
self.__x = x % md
def __str__(self):
return str(self.__x)
def __neg__(self):
return mint(-self.__x)
def __add__(self, other):
if isinstance(other, mint): other = other.__x
return mint(self.__x + other)
def __sub__(self, other):
if isinstance(other, mint): other = other.__x
return mint(self.__x - other)
def __rsub__(self, other):
return mint(other - self.__x)
def __mul__(self, other):
if isinstance(other, mint): other = other.__x
return mint(self.__x * other)
__radd__ = __add__
__rmul__ = __mul__
def __truediv__(self, other):
if isinstance(other, mint): other = other.__x
return mint(self.__x * pow(other, md - 2, md))
def __rtruediv__(self, other):
return mint(other * pow(self.__x, md - 2, md))
def __pow__(self, power, modulo=None):
return mint(pow(self.__x, power, md))
md = 10**9+7
def nCr(com_n, com_r):
if com_n < com_r: return 0
return fac[com_n] * ifac[com_r] * ifac[com_n - com_r]
n_max = 200005
fac = [mint(1)]
for i in range(1, n_max + 1): fac.append(fac[-1] * i)
ifac = [mint(1)] * (n_max + 1)
ifac[n_max] /= fac[n_max]
for i in range(n_max - 1, 1, -1): ifac[i] = ifac[i + 1] * (i + 1)
def main():
h,w,a,b=MI()
cc=[]
for i in range(h-a):
cc.append(nCr(b+i,i))
#print(*cc)
ans=mint(0)
pc=0
for i,c in enumerate(cc):
ans+=(c-pc)*nCr(h-1-i+w-1-b,w-1-b)
pc=c
print(ans)
main()
|
[
7,
15,
13,
41,
28,
13,
4,
18,
4,
18,
18,
13,
13,
13,
13,
4,
4,
13,
13,
0,
13,
13,
13,
13,
13,
0,
13,
4,
13,
0,
13,
2,
2,
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,
13,
0,
13,
2,
2,
17,
17,
17,
0,
13,
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,
17,
0,
13,
17,
28,
13,
4,
13,
2,
13,
13,
0,
18,
13,
13,
4,
13,
2,
13,
13,
13,
0,
13,
2,
2,
18,
13,
13,
13,
4,
13,
2,
2,
2,
2,
2,
13,
13,
17,
13,
13,
17,
2,
2,
13,
13,
17,
0,
13,
18,
13,
13,
0,
13,
13,
4,
13,
13,
10,
2,
13,
10,
39,
13,
10,
18,
13,
10,
2,
13,
10,
4,
13,
10,
13,
13,
10,
13,
13,
10,
13,
13,
10,
2,
13,
10,
39,
13,
10,
13,
13,
10,
17,
13,
10,
2,
13,
10,
17,
13,
10,
13,
13,
10,
12,
13,
10,
39,
13
] | [
[
6,
5
],
[
5,
18
],
[
257,
20
],
[
257,
22
],
[
257,
23
],
[
257,
24
],
[
227,
26
],
[
215,
30
],
[
75,
41
],
[
75,
44
],
[
73,
45
],
[
50,
49
],
[
75,
52
],
[
73,
54
],
[
75,
55
],
[
73,
62
],
[
49,
65
],
[
75,
65
],
[
73,
69
],
[
49,
70
],
[
75,
70
],
[
77,
71
],
[
73,
73
],
[
75,
75
],
[
78,
77
],
[
224,
80
],
[
239,
87
],
[
218,
92
],
[
242,
97
],
[
263,
102
],
[
108,
107
],
[
240,
112
],
[
219,
116
],
[
219,
121
],
[
107,
123
],
[
225,
124
],
[
264,
127
],
[
264,
133
],
[
225,
135
],
[
107,
136
],
[
225,
138
],
[
107,
139
],
[
225,
140
],
[
243,
143
],
[
243,
148
],
[
264,
151
],
[
225,
153
],
[
254,
155
],
[
248,
158
],
[
162,
161
],
[
234,
165
],
[
246,
166
],
[
171,
168
],
[
228,
169
],
[
161,
170
],
[
261,
172
],
[
161,
174
],
[
258,
175
],
[
161,
176
],
[
251,
178
],
[
168,
181
],
[
228,
182
],
[
161,
183
],
[
249,
184
],
[
222,
184
],
[
261,
186
],
[
234,
192
],
[
161,
193
],
[
237,
195
],
[
258,
196
],
[
234,
200
],
[
161,
201
],
[
221,
204
],
[
168,
205
],
[
228,
206
],
[
161,
207
],
[
230,
209
],
[
216,
210
],
[
231,
213
],
[
252,
213
],
[
255,
213
],
[
215,
216
],
[
218,
219
],
[
168,
221
],
[
221,
222
],
[
224,
225
],
[
227,
228
],
[
216,
230
],
[
230,
231
],
[
257,
234
],
[
257,
237
],
[
239,
240
],
[
242,
243
],
[
257,
246
],
[
248,
249
],
[
251,
252
],
[
254,
255
],
[
257,
258
],
[
263,
264
]
] | [
"import sys\nh, w, a, b = [int(i) for i in sys.stdin.readline().split()]\ndic = dict()\nMOD = 10**9+7\n\ndef nCr(n, r, mod=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\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\n\n\nres = 0\n_sum = 0\nfor i in range(h - a):\n dic[i] = nCr(i + b, i)\n res += (dic[i] - _sum) * nCr(h - i - 1 + w - b - 1, h - i - 1)\n _sum = dic[i]\n res %= MOD\nprint(res)",
"import sys",
"sys",
"int(i) for i in sys.stdin.readline().split()",
"for i in sys.stdin.readline().split()",
"i",
"sys.stdin.readline().split()",
"sys.stdin.readline().split",
"sys.stdin.readline()",
"sys.stdin.readline",
"sys.stdin",
"sys",
"stdin",
"readline",
"split",
"for i in sys.stdin.readline().split()",
"int(i)",
"int",
"i",
"h, w, a, b = [int(i) for i in sys.stdin.readline().split()]",
"h",
"[int(i) for i in sys.stdin.readline().split()]",
"w",
"a",
"b",
"dic = dict()",
"dic",
"dict()",
"dict",
"MOD = 10**9+7",
"MOD",
"10**9+7",
"10**9",
"10",
"9",
"7",
"def nCr(n, r, mod=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",
"nCr",
"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",
"MOD",
"mod = 10**9+7",
"mod",
"10**9+7",
"10**9",
"10",
"9",
"7",
"N = 10**6",
"N",
"10**6",
"10",
"6",
"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",
"res = 0",
"res",
"0",
"_sum = 0",
"_sum",
"0",
"for i in range(h - a):\n dic[i] = nCr(i + b, i)\n res += (dic[i] - _sum) * nCr(h - i - 1 + w - b - 1, h - i - 1)\n _sum = dic[i]\n res %= MOD",
"i",
"range(h - a)",
"range",
"h - a",
"h",
"a",
"dic[i] = nCr(i + b, i)",
"dic[i]",
"dic",
"i",
"nCr(i + b, i)",
"nCr",
"i + b",
"i",
"b",
"i",
"res += (dic[i] - _sum) * nCr(h - i - 1 + w - b - 1, h - i - 1)",
"res",
"(dic[i] - _sum) * nCr(h - i - 1 + w - b - 1, h - i - 1)",
"dic[i] - _sum",
"dic[i]",
"dic",
"i",
"_sum",
"nCr(h - i - 1 + w - b - 1, h - i - 1)",
"nCr",
"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",
"h - i - 1",
"h - i",
"h",
"i",
"1",
"_sum = dic[i]",
"_sum",
"dic[i]",
"dic",
"i",
"res %= MOD",
"res",
"MOD",
"print(res)",
"print",
"res",
"MOD = 10**9+7",
"10**9+7",
"MOD",
"g1 = [1, 1]",
"[1, 1]",
"g1",
"_sum = dic[i]",
"dic[i]",
"_sum",
"mod = 10**9+7",
"10**9+7",
"mod",
"dic = dict()",
"dict()",
"dic",
"res %= MOD",
"MOD",
"res",
"h, w, a, b = [int(i) for i in sys.stdin.readline().split()]",
"[int(i) for i in sys.stdin.readline().split()]",
"h",
"w, a, b = [int(i) for i in sys.stdin.readline().split()]",
"[int(i) for i in sys.stdin.readline().split()]",
"w",
"N = 10**6",
"10**6",
"N",
"g2 = [1, 1]",
"[1, 1]",
"g2",
"a, b = [int(i) for i in sys.stdin.readline().split()]",
"[int(i) for i in sys.stdin.readline().split()]",
"a",
"_sum = 0",
"0",
"_sum",
"res += (dic[i] - _sum) * nCr(h - i - 1 + w - b - 1, h - i - 1)",
"(dic[i] - _sum) * nCr(h - i - 1 + w - b - 1, h - i - 1)",
"res",
"res = 0",
"0",
"res",
"b = [int(i) for i in sys.stdin.readline().split()]",
"[int(i) for i in sys.stdin.readline().split()]",
"b",
"def nCr(n, r, mod=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 nCr(n, r, mod=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",
"nCr",
"inverse = [0, 1]",
"[0, 1]",
"inverse"
] | import sys
h, w, a, b = [int(i) for i in sys.stdin.readline().split()]
dic = dict()
MOD = 10**9+7
def nCr(n, r, mod=MOD):
if ( r<0 or r>n ):
return 0
r = min(r, n-r)
return g1[n] * g2[r] * g2[n-r] % mod
mod = 10**9+7 #出力の制限
N = 10**6
g1 = [1, 1] # 元テーブル
g2 = [1, 1] #逆元テーブル
inverse = [0, 1] #逆元テーブル計算用テーブル
for i in range( 2, N + 1 ):
g1.append( ( g1[-1] * i ) % mod )
inverse.append( ( -inverse[mod % i] * (mod//i) ) % mod )
g2.append( (g2[-1] * inverse[-1]) % mod )
res = 0
_sum = 0
for i in range(h - a):
dic[i] = nCr(i + b, i)
res += (dic[i] - _sum) * nCr(h - i - 1 + w - b - 1, h - i - 1)
_sum = dic[i]
res %= MOD
print(res) |
[
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,
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,
2,
2,
13,
13,
17,
13,
4,
13,
2,
13,
17,
2,
2,
13,
13,
17,
13,
4,
13,
2,
13,
13,
10,
2,
13,
10,
2,
13,
10,
4,
13,
10,
2,
13,
10,
17,
13,
10,
4,
13,
10,
4,
13,
10,
2,
13,
10,
2,
13,
10,
4,
13,
10,
12,
13
] | [
[
182,
2
],
[
182,
11
],
[
182,
12
],
[
182,
13
],
[
155,
15
],
[
164,
22
],
[
183,
25
],
[
171,
26
],
[
179,
29
],
[
165,
33
],
[
176,
34
],
[
165,
38
],
[
41,
40
],
[
165,
44
],
[
49,
46
],
[
180,
47
],
[
40,
48
],
[
40,
51
],
[
180,
53
],
[
40,
55
],
[
156,
57
],
[
64,
59
],
[
177,
60
],
[
165,
62
],
[
180,
67
],
[
165,
69
],
[
156,
72
],
[
156,
74
],
[
77,
76
],
[
165,
80
],
[
90,
85
],
[
177,
86
],
[
76,
88
],
[
177,
93
],
[
76,
94
],
[
76,
95
],
[
156,
96
],
[
185,
98
],
[
180,
104
],
[
177,
109
],
[
177,
112
],
[
156,
114
],
[
167,
118
],
[
122,
121
],
[
174,
124
],
[
171,
125
],
[
158,
127
],
[
186,
131
],
[
183,
134
],
[
162,
135
],
[
121,
137
],
[
186,
139
],
[
162,
141
],
[
171,
145
],
[
121,
146
],
[
156,
148
],
[
159,
152
],
[
168,
152
],
[
156,
153
],
[
155,
156
],
[
158,
159
],
[
182,
162
],
[
164,
165
],
[
167,
168
],
[
182,
171
],
[
182,
174
],
[
176,
177
],
[
179,
180
],
[
182,
183
],
[
185,
186
]
] | [
"h,w,a,b=map(int,input().split())\nmod=10**9+7\n\nn=h+w+1\nfc,inv=[1]*n,[1]*n\nfor i in range(1,n):\n fc[i]=i*fc[i-1]%mod\ninv[n-1]=pow(fc[n-1],mod-2,mod)\nfor i in range(n-1,0,-1):\n inv[i-1]=inv[i]*i%mod\nf=lambda a,b:fc[a+b]*inv[a]*inv[b]%mod\n\nv=0\nfor i in range(b,w):\n v+=f(h-a-1,i)*f(a-1,w-i-1)%mod\nprint(v%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",
"fc,inv=[1]*n,[1]*n",
"fc",
"[1]*n",
"[1]",
"1",
"n",
"inv",
"[1]*n",
"[1]",
"1",
"n",
"for i in range(1,n):\n fc[i]=i*fc[i-1]%mod",
"i",
"range(1,n)",
"range",
"1",
"n",
"fc[i]=i*fc[i-1]%mod",
"fc[i]",
"fc",
"i",
"i*fc[i-1]%mod",
"i*fc[i-1]",
"i",
"fc[i-1]",
"fc",
"i-1",
"i",
"1",
"mod",
"inv[n-1]=pow(fc[n-1],mod-2,mod)",
"inv[n-1]",
"inv",
"n-1",
"n",
"1",
"pow(fc[n-1],mod-2,mod)",
"pow",
"fc[n-1]",
"fc",
"n-1",
"n",
"1",
"mod-2",
"mod",
"2",
"mod",
"for i in range(n-1,0,-1):\n inv[i-1]=inv[i]*i%mod",
"i",
"range(n-1,0,-1)",
"range",
"n-1",
"n",
"1",
"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",
"f=lambda a,b:fc[a+b]*inv[a]*inv[b]%mod",
"f",
"lambda a,b:fc[a+b]*inv[a]*inv[b]%mod",
"fc[a+b]*inv[a]*inv[b]%mod",
"fc[a+b]*inv[a]*inv[b]",
"fc[a+b]*inv[a]",
"fc[a+b]",
"fc",
"a+b",
"a",
"b",
"inv[a]",
"inv",
"a",
"inv[b]",
"inv",
"b",
"mod",
"a",
"b",
"v=0",
"v",
"0",
"for i in range(b,w):\n v+=f(h-a-1,i)*f(a-1,w-i-1)%mod",
"i",
"range(b,w)",
"range",
"b",
"w",
"v+=f(h-a-1,i)*f(a-1,w-i-1)%mod",
"v",
"f(h-a-1,i)*f(a-1,w-i-1)%mod",
"f(h-a-1,i)*f(a-1,w-i-1)",
"f(h-a-1,i)",
"f",
"h-a-1",
"h-a",
"h",
"a",
"1",
"i",
"f(a-1,w-i-1)",
"f",
"a-1",
"a",
"1",
"w-i-1",
"w-i",
"w",
"i",
"1",
"mod",
"print(v%mod)",
"print",
"v%mod",
"v",
"mod",
"mod=10**9+7",
"10**9+7",
"mod",
"v+=f(h-a-1,i)*f(a-1,w-i-1)%mod",
"f(h-a-1,i)*f(a-1,w-i-1)%mod",
"v",
"a,b=map(int,input().split())",
"map(int,input().split())",
"a",
"n=h+w+1",
"h+w+1",
"n",
"v=0",
"0",
"v",
"w,a,b=map(int,input().split())",
"map(int,input().split())",
"w",
"b=map(int,input().split())",
"map(int,input().split())",
"b",
"inv=[1]*n,[1]*n",
"[1]*n",
"inv",
"fc,inv=[1]*n,[1]*n",
"[1]*n",
"fc",
"h,w,a,b=map(int,input().split())",
"map(int,input().split())",
"h",
"f=lambda a,b:fc[a+b]*inv[a]*inv[b]%mod",
"lambda a,b:fc[a+b]*inv[a]*inv[b]%mod",
"f"
] | h,w,a,b=map(int,input().split())
mod=10**9+7
n=h+w+1
fc,inv=[1]*n,[1]*n
for i in range(1,n):
fc[i]=i*fc[i-1]%mod
inv[n-1]=pow(fc[n-1],mod-2,mod)
for i in range(n-1,0,-1):
inv[i-1]=inv[i]*i%mod
f=lambda a,b:fc[a+b]*inv[a]*inv[b]%mod
v=0
for i in range(b,w):
v+=f(h-a-1,i)*f(a-1,w-i-1)%mod
print(v%mod)
|
[
7,
0,
13,
2,
2,
17,
17,
17,
0,
13,
17,
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,
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,
0,
13,
4,
13,
13,
4,
18,
4,
13,
13,
13,
13,
13,
0,
13,
17,
28,
13,
4,
13,
2,
13,
17,
2,
13,
17,
0,
13,
2,
2,
4,
13,
2,
2,
2,
13,
13,
13,
17,
2,
13,
17,
4,
13,
2,
2,
2,
13,
13,
13,
17,
2,
13,
17,
13,
0,
13,
2,
2,
13,
13,
13,
4,
13,
13,
10,
17,
13,
10,
4,
13,
10,
2,
13,
10,
2,
13,
10,
4,
13,
10,
2,
13,
10,
4,
13,
10,
2,
13,
10,
12,
13,
10,
17,
13,
10,
4,
13
] | [
[
166,
2
],
[
172,
9
],
[
160,
12
],
[
173,
17
],
[
23,
20
],
[
161,
21
],
[
26,
25
],
[
173,
30
],
[
36,
33
],
[
161,
34
],
[
25,
35
],
[
161,
39
],
[
25,
41
],
[
25,
43
],
[
167,
44
],
[
161,
52
],
[
76,
53
],
[
161,
57
],
[
78,
58
],
[
167,
60
],
[
167,
62
],
[
161,
66
],
[
76,
68
],
[
78,
69
],
[
167,
71
],
[
167,
73
],
[
167,
74
],
[
76,
76
],
[
78,
78
],
[
175,
80
],
[
175,
89
],
[
175,
90
],
[
175,
91
],
[
145,
93
],
[
97,
96
],
[
176,
100
],
[
149,
103
],
[
151,
106
],
[
170,
110
],
[
158,
114
],
[
164,
115
],
[
96,
116
],
[
96,
119
],
[
170,
122
],
[
164,
126
],
[
149,
127
],
[
96,
128
],
[
164,
131
],
[
167,
133
],
[
154,
135
],
[
146,
138
],
[
155,
138
],
[
152,
139
],
[
167,
140
],
[
155,
143
],
[
146,
143
],
[
145,
146
],
[
175,
149
],
[
151,
152
],
[
154,
155
],
[
175,
158
],
[
160,
161
],
[
175,
164
],
[
166,
167
],
[
172,
173
],
[
175,
176
]
] | [
"mod = 10**9 + 7\nN = 200000\nfact = [None] * (N+1)\nfact[0] = 1\nfor i in range(1, N+1):\n fact[i] = fact[i-1] * i % mod\n\ndef comb(n, k):\n return fact[n] * pow(fact[k], mod-2, mod) * pow(fact[n-k], mod-2, mod) % mod\n\nH, W, A, B = map(int, input().split())\nans = 0\nfor b in range(B+1, W+1):\n tmp = comb(H-A+b-2, b-1) * comb(A+W-b-1, A-1) % mod\n ans = (ans + tmp) % mod\nprint(ans)",
"mod = 10**9 + 7",
"mod",
"10**9 + 7",
"10**9",
"10",
"9",
"7",
"N = 200000",
"N",
"200000",
"fact = [None] * (N+1)",
"fact",
"[None] * (N+1)",
"[None]",
"None",
"N+1",
"N",
"1",
"fact[0] = 1",
"fact[0]",
"fact",
"0",
"1",
"for i in range(1, N+1):\n fact[i] = fact[i-1] * i % mod",
"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",
"def comb(n, k):\n return fact[n] * pow(fact[k], mod-2, mod) * pow(fact[n-k], mod-2, mod) % mod",
"comb",
"return fact[n] * pow(fact[k], mod-2, mod) * pow(fact[n-k], mod-2, mod) % mod",
"fact[n] * pow(fact[k], mod-2, mod) * pow(fact[n-k], mod-2, mod) % mod",
"fact[n] * pow(fact[k], mod-2, mod) * pow(fact[n-k], mod-2, mod)",
"fact[n] * pow(fact[k], mod-2, mod)",
"fact[n]",
"fact",
"n",
"pow(fact[k], mod-2, mod)",
"pow",
"fact[k]",
"fact",
"k",
"mod-2",
"mod",
"2",
"mod",
"pow(fact[n-k], mod-2, mod)",
"pow",
"fact[n-k]",
"fact",
"n-k",
"n",
"k",
"mod-2",
"mod",
"2",
"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",
"ans = 0",
"ans",
"0",
"for b in range(B+1, W+1):\n tmp = comb(H-A+b-2, b-1) * comb(A+W-b-1, A-1) % mod\n ans = (ans + tmp) % mod",
"b",
"range(B+1, W+1)",
"range",
"B+1",
"B",
"1",
"W+1",
"W",
"1",
"tmp = comb(H-A+b-2, b-1) * comb(A+W-b-1, A-1) % mod",
"tmp",
"comb(H-A+b-2, b-1) * comb(A+W-b-1, A-1) % mod",
"comb(H-A+b-2, b-1) * comb(A+W-b-1, A-1)",
"comb(H-A+b-2, b-1)",
"comb",
"H-A+b-2",
"H-A+b",
"H-A",
"H",
"A",
"b",
"2",
"b-1",
"b",
"1",
"comb(A+W-b-1, A-1)",
"comb",
"A+W-b-1",
"A+W-b",
"A+W",
"A",
"W",
"b",
"1",
"A-1",
"A",
"1",
"mod",
"ans = (ans + tmp) % mod",
"ans",
"(ans + tmp) % mod",
"ans + tmp",
"ans",
"tmp",
"mod",
"print(ans)",
"print",
"ans",
"ans = 0",
"0",
"ans",
"W, A, B = map(int, input().split())",
"map(int, input().split())",
"W",
"tmp = comb(H-A+b-2, b-1) * comb(A+W-b-1, A-1) % mod",
"comb(H-A+b-2, b-1) * comb(A+W-b-1, A-1) % mod",
"tmp",
"ans = (ans + tmp) % mod",
"(ans + tmp) % mod",
"ans",
"H, W, A, B = map(int, input().split())",
"map(int, input().split())",
"H",
"fact = [None] * (N+1)",
"[None] * (N+1)",
"fact",
"A, B = map(int, input().split())",
"map(int, input().split())",
"A",
"mod = 10**9 + 7",
"10**9 + 7",
"mod",
"def comb(n, k):\n return fact[n] * pow(fact[k], mod-2, mod) * pow(fact[n-k], mod-2, mod) % mod",
"def comb(n, k):\n return fact[n] * pow(fact[k], mod-2, mod) * pow(fact[n-k], mod-2, mod) % mod",
"comb",
"N = 200000",
"200000",
"N",
"B = map(int, input().split())",
"map(int, input().split())",
"B"
] | mod = 10**9 + 7
N = 200000
fact = [None] * (N+1)
fact[0] = 1
for i in range(1, N+1):
fact[i] = fact[i-1] * i % mod
def comb(n, k):
return fact[n] * pow(fact[k], mod-2, mod) * pow(fact[n-k], mod-2, mod) % mod
H, W, A, B = map(int, input().split())
ans = 0
for b in range(B+1, W+1):
tmp = comb(H-A+b-2, b-1) * comb(A+W-b-1, A-1) % mod
ans = (ans + tmp) % mod
print(ans)
|
[
7,
12,
13,
0,
13,
17,
28,
13,
4,
13,
13,
0,
13,
13,
0,
13,
13,
0,
13,
17,
29,
13,
23,
13,
23,
13,
23,
13,
12,
13,
0,
13,
17,
28,
13,
4,
13,
17,
2,
13,
17,
0,
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,
2,
4,
13,
17,
17,
17,
0,
13,
2,
2,
2,
13,
13,
13,
17,
0,
13,
2,
2,
2,
13,
13,
13,
17,
0,
13,
2,
2,
4,
13,
13,
2,
2,
13,
13,
17,
13,
4,
13,
13,
2,
13,
17,
13,
13,
0,
13,
13,
28,
13,
4,
13,
2,
2,
13,
13,
17,
0,
13,
17,
0,
13,
2,
2,
2,
2,
13,
13,
2,
13,
2,
13,
17,
4,
13,
2,
2,
13,
2,
2,
13,
13,
17,
13,
2,
13,
17,
13,
13,
0,
13,
17,
0,
13,
13,
0,
13,
13,
0,
13,
2,
2,
2,
13,
4,
13,
4,
13,
2,
13,
17,
13,
2,
13,
17,
13,
4,
13,
4,
13,
2,
2,
13,
13,
17,
13,
2,
13,
17,
13,
13,
4,
13,
13,
10,
12,
13,
10,
13,
13,
10,
12,
13,
10,
2,
13,
10,
4,
13,
10,
13,
13,
10,
17,
13,
10,
13,
13,
10,
2,
13,
10,
4,
13,
10,
2,
13,
10,
2,
13,
10,
2,
13,
10,
4,
13,
10,
4,
13,
10,
17,
13,
10,
2,
13
] | [
[
5,
4
],
[
8,
7
],
[
25,
10
],
[
13,
12
],
[
23,
13
],
[
18,
13
],
[
16,
15
],
[
27,
16
],
[
19,
18
],
[
15,
21
],
[
12,
21
],
[
4,
21
],
[
23,
23
],
[
25,
25
],
[
27,
27
],
[
32,
31
],
[
35,
34
],
[
50,
39
],
[
43,
42
],
[
34,
43
],
[
46,
45
],
[
52,
46
],
[
45,
48
],
[
42,
48
],
[
31,
48
],
[
50,
50
],
[
52,
52
],
[
245,
54
],
[
245,
63
],
[
245,
64
],
[
245,
65
],
[
233,
67
],
[
227,
75
],
[
231,
79
],
[
243,
80
],
[
246,
81
],
[
251,
84
],
[
216,
88
],
[
246,
89
],
[
243,
90
],
[
236,
93
],
[
204,
97
],
[
228,
98
],
[
231,
101
],
[
243,
102
],
[
234,
104
],
[
204,
106
],
[
252,
107
],
[
243,
109
],
[
234,
111
],
[
234,
112
],
[
218,
114
],
[
237,
115
],
[
118,
117
],
[
216,
122
],
[
246,
123
],
[
248,
126
],
[
239,
129
],
[
237,
134
],
[
240,
134
],
[
249,
135
],
[
228,
135
],
[
252,
137
],
[
222,
137
],
[
243,
139
],
[
249,
145
],
[
228,
145
],
[
231,
148
],
[
243,
149
],
[
252,
151
],
[
222,
151
],
[
234,
153
],
[
234,
155
],
[
234,
156
],
[
221,
158
],
[
224,
161
],
[
240,
162
],
[
237,
162
],
[
206,
164
],
[
234,
165
],
[
212,
167
],
[
207,
171
],
[
225,
171
],
[
219,
171
],
[
210,
175
],
[
243,
177
],
[
234,
179
],
[
234,
181
],
[
234,
183
],
[
210,
187
],
[
231,
190
],
[
243,
191
],
[
234,
193
],
[
234,
195
],
[
234,
197
],
[
234,
198
],
[
213,
201
],
[
207,
201
],
[
225,
201
],
[
219,
201
],
[
234,
206
],
[
206,
207
],
[
212,
213
],
[
245,
216
],
[
237,
218
],
[
218,
219
],
[
221,
222
],
[
240,
224
],
[
237,
224
],
[
224,
225
],
[
227,
228
],
[
245,
231
],
[
233,
234
],
[
236,
237
],
[
239,
240
],
[
245,
243
],
[
245,
246
],
[
248,
249
],
[
251,
252
]
] | [
"def permutation(n, k, mod):\n s = 1\n for _ in range(k):\n s *= n\n s %= mod\n n -= 1\n return s\n\ndef factorial(n, mod):\n s = 1\n for i in range(1, n + 1):\n s *= i\n s %= mod\n return s\n\nh, w, a, b = map(int, input().split())\nmod = pow(10, 9) + 7\nx = h - a + b - 1\ny = w - b + a - 2\np = permutation(x, h - a - 1, mod) * permutation(y, a - 1, mod) % mod\nans = p\nfor _ in range(w - b - 1):\n x += 1\n p = p * x * (y - (a - 1)) * pow((x - (h - a - 1)) * y, mod - 2, mod) % mod\n y -= 1\n ans += p\n ans %= mod\nans = ans * pow(factorial(a - 1, mod), mod - 2, mod) * pow(factorial(h - a - 1, mod), mod - 2, mod) % mod\nprint(ans)",
"def permutation(n, k, mod):\n s = 1\n for _ in range(k):\n s *= n\n s %= mod\n n -= 1\n return s",
"permutation",
"s = 1",
"s",
"1",
"for _ in range(k):\n s *= n\n s %= mod\n n -= 1\n ",
"_",
"range(k)",
"range",
"k",
"s *= n",
"s",
"n",
"s %= mod",
"s",
"mod",
"n -= 1",
"n",
"1",
"return s",
"s",
"n",
"n",
"k",
"k",
"mod",
"mod",
"def factorial(n, mod):\n s = 1\n for i in range(1, n + 1):\n s *= i\n s %= mod\n return s",
"factorial",
"s = 1",
"s",
"1",
"for i in range(1, n + 1):\n s *= i\n s %= mod\n ",
"i",
"range(1, n + 1)",
"range",
"1",
"n + 1",
"n",
"1",
"s *= i",
"s",
"i",
"s %= mod",
"s",
"mod",
"return s",
"s",
"n",
"n",
"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",
"mod = pow(10, 9) + 7",
"mod",
"pow(10, 9) + 7",
"pow(10, 9)",
"pow",
"10",
"9",
"7",
"x = h - a + b - 1",
"x",
"h - a + b - 1",
"h - a + b",
"h - a",
"h",
"a",
"b",
"1",
"y = w - b + a - 2",
"y",
"w - b + a - 2",
"w - b + a",
"w - b",
"w",
"b",
"a",
"2",
"p = permutation(x, h - a - 1, mod) * permutation(y, a - 1, mod) % mod",
"p",
"permutation(x, h - a - 1, mod) * permutation(y, a - 1, mod) % mod",
"permutation(x, h - a - 1, mod) * permutation(y, a - 1, mod)",
"permutation(x, h - a - 1, mod)",
"permutation",
"x",
"h - a - 1",
"h - a",
"h",
"a",
"1",
"mod",
"permutation(y, a - 1, mod)",
"permutation",
"y",
"a - 1",
"a",
"1",
"mod",
"mod",
"ans = p",
"ans",
"p",
"for _ in range(w - b - 1):\n x += 1\n p = p * x * (y - (a - 1)) * pow((x - (h - a - 1)) * y, mod - 2, mod) % mod\n y -= 1\n ans += p\n ans %= mod",
"_",
"range(w - b - 1)",
"range",
"w - b - 1",
"w - b",
"w",
"b",
"1",
"x += 1",
"x",
"1",
"p = p * x * (y - (a - 1)) * pow((x - (h - a - 1)) * y, mod - 2, mod) % mod",
"p",
"p * x * (y - (a - 1)) * pow((x - (h - a - 1)) * y, mod - 2, mod) % mod",
"p * x * (y - (a - 1)) * pow((x - (h - a - 1)) * y, mod - 2, mod)",
"p * x * (y - (a - 1))",
"p * x",
"p",
"x",
"y - (a - 1)",
"y",
"a - 1",
"a",
"1",
"pow((x - (h - a - 1)) * y, mod - 2, mod)",
"pow",
"(x - (h - a - 1)) * y",
"x - (h - a - 1)",
"x",
"h - a - 1",
"h - a",
"h",
"a",
"1",
"y",
"mod - 2",
"mod",
"2",
"mod",
"mod",
"y -= 1",
"y",
"1",
"ans += p",
"ans",
"p",
"ans %= mod",
"ans",
"mod",
"ans = ans * pow(factorial(a - 1, mod), mod - 2, mod) * pow(factorial(h - a - 1, mod), mod - 2, mod) % mod",
"ans",
"ans * pow(factorial(a - 1, mod), mod - 2, mod) * pow(factorial(h - a - 1, mod), mod - 2, mod) % mod",
"ans * pow(factorial(a - 1, mod), mod - 2, mod) * pow(factorial(h - a - 1, mod), mod - 2, mod)",
"ans * pow(factorial(a - 1, mod), mod - 2, mod)",
"ans",
"pow(factorial(a - 1, mod), mod - 2, mod)",
"pow",
"factorial(a - 1, mod)",
"factorial",
"a - 1",
"a",
"1",
"mod",
"mod - 2",
"mod",
"2",
"mod",
"pow(factorial(h - a - 1, mod), mod - 2, mod)",
"pow",
"factorial(h - a - 1, mod)",
"factorial",
"h - a - 1",
"h - a",
"h",
"a",
"1",
"mod",
"mod - 2",
"mod",
"2",
"mod",
"mod",
"print(ans)",
"print",
"ans",
"def permutation(n, k, mod):\n s = 1\n for _ in range(k):\n s *= n\n s %= mod\n n -= 1\n return s",
"def permutation(n, k, mod):\n s = 1\n for _ in range(k):\n s *= n\n s %= mod\n n -= 1\n return s",
"permutation",
"ans %= mod",
"mod",
"ans",
"def factorial(n, mod):\n s = 1\n for i in range(1, n + 1):\n s *= i\n s %= mod\n return s",
"def factorial(n, mod):\n s = 1\n for i in range(1, n + 1):\n s *= i\n s %= mod\n return s",
"factorial",
"ans = ans * pow(factorial(a - 1, mod), mod - 2, mod) * pow(factorial(h - a - 1, mod), mod - 2, mod) % mod",
"ans * pow(factorial(a - 1, mod), mod - 2, mod) * pow(factorial(h - a - 1, mod), mod - 2, mod) % mod",
"ans",
"w, a, b = map(int, input().split())",
"map(int, input().split())",
"w",
"ans = p",
"p",
"ans",
"y -= 1",
"1",
"y",
"ans += p",
"p",
"ans",
"x = h - a + b - 1",
"h - a + b - 1",
"x",
"h, w, a, b = map(int, input().split())",
"map(int, input().split())",
"h",
"mod = pow(10, 9) + 7",
"pow(10, 9) + 7",
"mod",
"p = permutation(x, h - a - 1, mod) * permutation(y, a - 1, mod) % mod",
"permutation(x, h - a - 1, mod) * permutation(y, a - 1, mod) % mod",
"p",
"p = p * x * (y - (a - 1)) * pow((x - (h - a - 1)) * y, mod - 2, mod) % mod",
"p * x * (y - (a - 1)) * pow((x - (h - a - 1)) * y, mod - 2, mod) % mod",
"p",
"a, b = map(int, input().split())",
"map(int, input().split())",
"a",
"b = map(int, input().split())",
"map(int, input().split())",
"b",
"x += 1",
"1",
"x",
"y = w - b + a - 2",
"w - b + a - 2",
"y"
] | def permutation(n, k, mod):
s = 1
for _ in range(k):
s *= n
s %= mod
n -= 1
return s
def factorial(n, mod):
s = 1
for i in range(1, n + 1):
s *= i
s %= mod
return s
h, w, a, b = map(int, input().split())
mod = pow(10, 9) + 7
x = h - a + b - 1
y = w - b + a - 2
p = permutation(x, h - a - 1, mod) * permutation(y, a - 1, mod) % mod
ans = p
for _ in range(w - b - 1):
x += 1
p = p * x * (y - (a - 1)) * pow((x - (h - a - 1)) * y, mod - 2, mod) % mod
y -= 1
ans += p
ans %= mod
ans = ans * pow(factorial(a - 1, mod), mod - 2, mod) * pow(factorial(h - a - 1, mod), mod - 2, mod) % mod
print(ans) |
[
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,
4,
13,
2,
2,
13,
13,
17,
2,
13,
17,
13,
4,
13,
2,
2,
2,
2,
13,
13,
13,
13,
17,
2,
2,
13,
13,
17,
13,
4,
13,
2,
13,
13,
10,
12,
13,
10,
4,
13,
10,
39,
13,
10,
39,
13,
10,
4,
13,
10,
2,
13,
10,
4,
13,
10,
17,
13,
10,
4,
13,
10,
2,
13,
10,
39,
13,
10,
2,
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
],
[
207,
44
],
[
195,
51
],
[
186,
58
],
[
210,
63
],
[
189,
68
],
[
74,
73
],
[
196,
78
],
[
187,
82
],
[
187,
87
],
[
73,
89
],
[
208,
90
],
[
190,
93
],
[
190,
99
],
[
208,
101
],
[
73,
102
],
[
208,
104
],
[
73,
105
],
[
208,
106
],
[
211,
109
],
[
211,
114
],
[
190,
117
],
[
208,
119
],
[
204,
121
],
[
204,
130
],
[
204,
131
],
[
204,
132
],
[
201,
134
],
[
138,
137
],
[
193,
141
],
[
184,
142
],
[
213,
144
],
[
181,
147
],
[
199,
150
],
[
137,
151
],
[
199,
154
],
[
208,
156
],
[
181,
158
],
[
193,
163
],
[
137,
164
],
[
205,
165
],
[
199,
166
],
[
205,
170
],
[
199,
171
],
[
208,
173
],
[
214,
177
],
[
202,
177
],
[
208,
178
],
[
204,
184
],
[
186,
187
],
[
189,
190
],
[
204,
193
],
[
195,
196
],
[
204,
199
],
[
201,
202
],
[
204,
205
],
[
207,
208
],
[
210,
211
],
[
213,
214
]
] | [
"#縦H A\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 = (10**5)*2\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 )\nH,W,A,B=map(int,input().split())\nans=0\nfor i in range(H-A):\n ans+=cmb(B+i-1,B-1,mod) * cmb(H-i+W-B-2,W-B-1,mod)\nprint(ans%mod)\n# 1 1 1\n# $ 1 2",
"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**5)*2",
"N",
"(10**5)*2",
"10**5",
"10",
"5",
"2",
"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 i in range(H-A):\n ans+=cmb(B+i-1,B-1,mod) * cmb(H-i+W-B-2,W-B-1,mod)",
"i",
"range(H-A)",
"range",
"H-A",
"H",
"A",
"ans+=cmb(B+i-1,B-1,mod) * cmb(H-i+W-B-2,W-B-1,mod)",
"ans",
"cmb(B+i-1,B-1,mod) * cmb(H-i+W-B-2,W-B-1,mod)",
"cmb(B+i-1,B-1,mod)",
"cmb",
"B+i-1",
"B+i",
"B",
"i",
"1",
"B-1",
"B",
"1",
"mod",
"cmb(H-i+W-B-2,W-B-1,mod)",
"cmb",
"H-i+W-B-2",
"H-i+W-B",
"H-i+W",
"H-i",
"H",
"i",
"W",
"B",
"2",
"W-B-1",
"W-B",
"W",
"B",
"1",
"mod",
"print(ans%mod)",
"print",
"ans%mod",
"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",
"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",
"g1 = [1, 1]",
"[1, 1]",
"g1",
"inverse = [0, 1]",
"[0, 1]",
"inverse",
"H,W,A,B=map(int,input().split())",
"map(int,input().split())",
"H",
"N = (10**5)*2",
"(10**5)*2",
"N",
"B=map(int,input().split())",
"map(int,input().split())",
"B",
"ans=0",
"0",
"ans",
"W,A,B=map(int,input().split())",
"map(int,input().split())",
"W",
"mod = 10**9+7",
"10**9+7",
"mod",
"g2 = [1, 1]",
"[1, 1]",
"g2",
"ans+=cmb(B+i-1,B-1,mod) * cmb(H-i+W-B-2,W-B-1,mod)",
"cmb(B+i-1,B-1,mod) * cmb(H-i+W-B-2,W-B-1,mod)",
"ans"
] | #縦H A
def cmb(n, r, mod):
if ( r<0 or r>n ):
return 0
r = min(r, n-r)
return g1[n] * g2[r] * g2[n-r] % mod
mod = 10**9+7 #出力の制限
N = (10**5)*2
g1 = [1, 1] # 元テーブル
g2 = [1, 1] #逆元テーブル
inverse = [0, 1] #逆元テーブル計算用テーブル
for i in range( 2, N + 1 ):
g1.append( ( g1[-1] * i ) % mod )
inverse.append( ( -inverse[mod % i] * (mod//i) ) % mod )
g2.append( (g2[-1] * inverse[-1]) % mod )
H,W,A,B=map(int,input().split())
ans=0
for i in range(H-A):
ans+=cmb(B+i-1,B-1,mod) * cmb(H-i+W-B-2,W-B-1,mod)
print(ans%mod)
# 1 1 1
# $ 1 2 |
[
7,
12,
13,
42,
13,
0,
13,
13,
13,
2,
13,
13,
29,
13,
23,
13,
23,
13,
12,
13,
0,
39,
13,
13,
39,
17,
17,
0,
39,
13,
13,
39,
17,
17,
42,
40,
13,
17,
0,
13,
2,
13,
13,
0,
39,
13,
13,
39,
13,
2,
13,
13,
0,
39,
13,
13,
39,
2,
13,
2,
13,
13,
13,
0,
39,
13,
13,
39,
2,
13,
2,
13,
13,
13,
29,
39,
13,
13,
13,
23,
13,
23,
13,
12,
13,
0,
39,
13,
13,
13,
4,
13,
13,
13,
29,
2,
13,
13,
23,
13,
23,
13,
0,
13,
2,
2,
17,
17,
17,
0,
13,
2,
2,
17,
17,
17,
0,
13,
2,
39,
17,
2,
13,
17,
12,
13,
0,
13,
17,
0,
18,
13,
17,
17,
28,
13,
4,
13,
17,
2,
13,
17,
0,
13,
2,
2,
2,
13,
13,
13,
13,
0,
18,
13,
13,
13,
23,
13,
23,
13,
4,
13,
13,
13,
0,
13,
2,
39,
17,
2,
13,
17,
12,
13,
28,
13,
4,
13,
2,
13,
17,
0,
13,
18,
13,
13,
0,
39,
13,
13,
13,
4,
13,
13,
13,
0,
18,
13,
13,
2,
13,
13,
23,
13,
23,
13,
4,
13,
13,
13,
12,
13,
0,
13,
18,
13,
13,
0,
13,
18,
13,
13,
0,
13,
18,
13,
2,
13,
13,
29,
2,
2,
2,
2,
13,
13,
13,
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,
13,
13,
0,
13,
2,
4,
13,
2,
2,
2,
13,
13,
17,
13,
13,
13,
4,
13,
2,
2,
2,
2,
13,
17,
13,
13,
17,
2,
13,
17,
13,
0,
13,
13,
4,
13,
13,
10,
12,
13,
10,
17,
13,
10,
2,
13,
10,
12,
13,
10,
12,
13,
10,
2,
13,
10,
4,
13,
10,
12,
13,
10,
4,
13,
10,
12,
13,
10,
4,
13,
10,
13,
13,
10,
2,
13,
10,
12,
13,
10,
4,
13,
10,
2,
13,
10,
2,
13
] | [
[
7,
6
],
[
17,
7
],
[
8,
7
],
[
9,
8
],
[
6,
10
],
[
15,
10
],
[
17,
11
],
[
8,
11
],
[
6,
13
],
[
15,
13
],
[
15,
15
],
[
17,
17
],
[
24,
21
],
[
31,
28
],
[
82,
36
],
[
40,
39
],
[
80,
41
],
[
82,
42
],
[
47,
44
],
[
80,
50
],
[
82,
51
],
[
56,
53
],
[
39,
60
],
[
67,
64
],
[
39,
71
],
[
80,
80
],
[
82,
82
],
[
90,
86
],
[
325,
91
],
[
99,
92
],
[
101,
93
],
[
101,
97
],
[
99,
99
],
[
101,
101
],
[
309,
103
],
[
348,
110
],
[
318,
117
],
[
349,
122
],
[
128,
127
],
[
133,
130
],
[
319,
131
],
[
136,
135
],
[
157,
140
],
[
144,
143
],
[
127,
147
],
[
143,
147
],
[
159,
148
],
[
135,
149
],
[
159,
150
],
[
155,
152
],
[
319,
153
],
[
135,
154
],
[
143,
155
],
[
127,
155
],
[
157,
157
],
[
159,
159
],
[
313,
161
],
[
349,
162
],
[
310,
163
],
[
339,
165
],
[
349,
170
],
[
176,
175
],
[
203,
179
],
[
183,
182
],
[
319,
184
],
[
175,
185
],
[
191,
187
],
[
325,
192
],
[
182,
193
],
[
205,
194
],
[
199,
196
],
[
340,
197
],
[
304,
197
],
[
175,
198
],
[
205,
201
],
[
203,
203
],
[
205,
205
],
[
331,
207
],
[
349,
208
],
[
310,
209
],
[
214,
213
],
[
319,
215
],
[
240,
216
],
[
219,
218
],
[
340,
220
],
[
304,
220
],
[
242,
221
],
[
224,
223
],
[
340,
225
],
[
304,
225
],
[
240,
227
],
[
242,
228
],
[
213,
234
],
[
218,
235
],
[
244,
236
],
[
223,
237
],
[
244,
238
],
[
240,
240
],
[
242,
242
],
[
244,
244
],
[
345,
246
],
[
345,
255
],
[
345,
256
],
[
345,
257
],
[
306,
259
],
[
263,
262
],
[
328,
265
],
[
346,
266
],
[
351,
268
],
[
316,
271
],
[
334,
275
],
[
322,
276
],
[
262,
278
],
[
262,
279
],
[
310,
280
],
[
316,
282
],
[
322,
287
],
[
346,
289
],
[
262,
290
],
[
322,
293
],
[
310,
295
],
[
336,
297
],
[
310,
298
],
[
337,
301
],
[
352,
301
],
[
307,
301
],
[
306,
307
],
[
309,
310
],
[
318,
319
],
[
345,
322
],
[
345,
328
],
[
345,
334
],
[
310,
336
],
[
336,
337
],
[
339,
340
],
[
345,
346
],
[
348,
349
],
[
351,
352
]
] | [
"def gcd(a, b):\n\twhile b:\n\t\ta, b = b, a % b\n\treturn a\n\ndef egcd(a, b):\n (x, lastx) = (0, 1)\n (y, lasty) = (1, 0)\n while b != 0:\n q = a // b\n (a, b) = (b, a % b)\n (x, lastx) = (lastx - q * x, x)\n (y, lasty) = (lasty - q * y, y)\n return (lastx, lasty, a)\n\n# ax ≡ 1 (mod m)\ndef modinv(a, m):\n (inv, q, gcd_val) = egcd(a, m)\n return inv % m\nN = 10**9+7\nR = 10**5*2\nmodfact = [0]*(R+1)\ndef modfact_memo(n,N):\n r = 1\n modfact[0] = 1\n for i in range(1,n+1):\n r = r % N * i % N\n modfact[i] = r\nmodfact_memo(R,N)\n\n# ax ≡ 1 (mod m)\nmodinv=[0]*(R+1)\ndef modinv_memo(a,m):\n for i in range(a+1):\n j = modfact[i]\n (inv, q, gcd_val) = egcd(j, m)\n modinv[i] = inv % m\nmodinv_memo(R,N)\n\ndef modconb(n,r,N):\n p = modfact[n]\n q1 = modinv[r]\n q2 = modinv[n-r]\n return p*q1%N*q2%N\n\nH,W,A,B = map(int,input().split())\nans = 0\nfor r in range(B,W):\n ans += modconb(H-A-1+r,r,N)*modconb(A-1+W-r-1,A-1,N)\n ans %= N\n\nprint(ans)",
"def gcd(a, b):\n\twhile b:\n\t\ta, b = b, a % b\n\treturn a",
"gcd",
"while b:\n\t\ta, b = b, a % b\n\t",
"b",
"a, b = b, a % b",
"a",
"b",
"b",
"a % b",
"a",
"b",
"return a",
"a",
"a",
"a",
"b",
"b",
"def egcd(a, b):\n (x, lastx) = (0, 1)\n (y, lasty) = (1, 0)\n while b != 0:\n q = a // b\n (a, b) = (b, a % b)\n (x, lastx) = (lastx - q * x, x)\n (y, lasty) = (lasty - q * y, y)\n return (lastx, lasty, a)\n\n# ax ≡ 1 (mod m)",
"egcd",
"(x, lastx) = (0, 1)",
"(x, lastx)",
"x",
"lastx",
"(0, 1)",
"0",
"1",
"(y, lasty) = (1, 0)",
"(y, lasty)",
"y",
"lasty",
"(1, 0)",
"1",
"0",
"while b != 0:\n q = a // b\n (a, b) = (b, a % b)\n (x, lastx) = (lastx - q * x, x)\n (y, lasty) = (lasty - q * y, y)\n ",
"b != 0",
"b",
"0",
"q = a // b",
"q",
"a // b",
"a",
"b",
"(a, b) = (b, a % b)",
"(a, b)",
"a",
"b",
"(b, a % b)",
"b",
"a % b",
"a",
"b",
"(x, lastx) = (lastx - q * x, x)",
"(x, lastx)",
"x",
"lastx",
"(lastx - q * x, x)",
"lastx - q * x",
"lastx",
"q * x",
"q",
"x",
"x",
"(y, lasty) = (lasty - q * y, y)",
"(y, lasty)",
"y",
"lasty",
"(lasty - q * y, y)",
"lasty - q * y",
"lasty",
"q * y",
"q",
"y",
"y",
"return (lastx, lasty, a)",
"(lastx, lasty, a)",
"lastx",
"lasty",
"a",
"a",
"a",
"b",
"b",
"def modinv(a, m):\n (inv, q, gcd_val) = egcd(a, m)\n return inv % m",
"modinv",
"(inv, q, gcd_val) = egcd(a, m)",
"(inv, q, gcd_val)",
"inv",
"q",
"gcd_val",
"egcd(a, m)",
"egcd",
"a",
"m",
"return inv % m",
"inv % m",
"inv",
"m",
"a",
"a",
"m",
"m",
"N = 10**9+7",
"N",
"10**9+7",
"10**9",
"10",
"9",
"7",
"R = 10**5*2",
"R",
"10**5*2",
"10**5",
"10",
"5",
"2",
"modfact = [0]*(R+1)",
"modfact",
"[0]*(R+1)",
"[0]",
"0",
"R+1",
"R",
"1",
"def modfact_memo(n,N):\n r = 1\n modfact[0] = 1\n for i in range(1,n+1):\n r = r % N * i % N\n modfact[i] = r",
"modfact_memo",
"r = 1",
"r",
"1",
"modfact[0] = 1",
"modfact[0]",
"modfact",
"0",
"1",
"for i in range(1,n+1):\n r = r % N * i % N\n modfact[i] = r",
"i",
"range(1,n+1)",
"range",
"1",
"n+1",
"n",
"1",
"r = r % N * i % N",
"r",
"r % N * i % N",
"r % N * i",
"r % N",
"r",
"N",
"i",
"N",
"modfact[i] = r",
"modfact[i]",
"modfact",
"i",
"r",
"n",
"n",
"N",
"N",
"modfact_memo(R,N)",
"modfact_memo",
"R",
"N",
"modinv=[0]*(R+1)",
"modinv",
"[0]*(R+1)",
"[0]",
"0",
"R+1",
"R",
"1",
"def modinv_memo(a,m):\n for i in range(a+1):\n j = modfact[i]\n (inv, q, gcd_val) = egcd(j, m)\n modinv[i] = inv % m",
"modinv_memo",
"for i in range(a+1):\n j = modfact[i]\n (inv, q, gcd_val) = egcd(j, m)\n modinv[i] = inv % m",
"i",
"range(a+1)",
"range",
"a+1",
"a",
"1",
"j = modfact[i]",
"j",
"modfact[i]",
"modfact",
"i",
"(inv, q, gcd_val) = egcd(j, m)",
"(inv, q, gcd_val)",
"inv",
"q",
"gcd_val",
"egcd(j, m)",
"egcd",
"j",
"m",
"modinv[i] = inv % m",
"modinv[i]",
"modinv",
"i",
"inv % m",
"inv",
"m",
"a",
"a",
"m",
"m",
"modinv_memo(R,N)",
"modinv_memo",
"R",
"N",
"def modconb(n,r,N):\n p = modfact[n]\n q1 = modinv[r]\n q2 = modinv[n-r]\n return p*q1%N*q2%N",
"modconb",
"p = modfact[n]",
"p",
"modfact[n]",
"modfact",
"n",
"q1 = modinv[r]",
"q1",
"modinv[r]",
"modinv",
"r",
"q2 = modinv[n-r]",
"q2",
"modinv[n-r]",
"modinv",
"n-r",
"n",
"r",
"return p*q1%N*q2%N",
"p*q1%N*q2%N",
"p*q1%N*q2",
"p*q1%N",
"p*q1",
"p",
"q1",
"N",
"q2",
"N",
"n",
"n",
"r",
"r",
"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",
"ans = 0",
"ans",
"0",
"for r in range(B,W):\n ans += modconb(H-A-1+r,r,N)*modconb(A-1+W-r-1,A-1,N)\n ans %= N",
"r",
"range(B,W)",
"range",
"B",
"W",
"ans += modconb(H-A-1+r,r,N)*modconb(A-1+W-r-1,A-1,N)",
"ans",
"modconb(H-A-1+r,r,N)*modconb(A-1+W-r-1,A-1,N)",
"modconb(H-A-1+r,r,N)",
"modconb",
"H-A-1+r",
"H-A-1",
"H-A",
"H",
"A",
"1",
"r",
"r",
"N",
"modconb(A-1+W-r-1,A-1,N)",
"modconb",
"A-1+W-r-1",
"A-1+W-r",
"A-1+W",
"A-1",
"A",
"1",
"W",
"r",
"1",
"A-1",
"A",
"1",
"N",
"ans %= N",
"ans",
"N",
"print(ans)",
"print",
"ans",
"def modinv(a, m):\n (inv, q, gcd_val) = egcd(a, m)\n return inv % m",
"def modinv(a, m):\n (inv, q, gcd_val) = egcd(a, m)\n return inv % m",
"modinv",
"ans = 0",
"0",
"ans",
"N = 10**9+7",
"10**9+7",
"N",
"def modfact_memo(n,N):\n r = 1\n modfact[0] = 1\n for i in range(1,n+1):\n r = r % N * i % N\n modfact[i] = r",
"def modfact_memo(n,N):\n r = 1\n modfact[0] = 1\n for i in range(1,n+1):\n r = r % N * i % N\n modfact[i] = r",
"modfact_memo",
"def modconb(n,r,N):\n p = modfact[n]\n q1 = modinv[r]\n q2 = modinv[n-r]\n return p*q1%N*q2%N",
"def modconb(n,r,N):\n p = modfact[n]\n q1 = modinv[r]\n q2 = modinv[n-r]\n return p*q1%N*q2%N",
"modconb",
"modfact = [0]*(R+1)",
"[0]*(R+1)",
"modfact",
"A,B = map(int,input().split())",
"map(int,input().split())",
"A",
"def egcd(a, b):\n (x, lastx) = (0, 1)\n (y, lasty) = (1, 0)\n while b != 0:\n q = a // b\n (a, b) = (b, a % b)\n (x, lastx) = (lastx - q * x, x)\n (y, lasty) = (lasty - q * y, y)\n return (lastx, lasty, a)\n\n# ax ≡ 1 (mod m)",
"def egcd(a, b):\n (x, lastx) = (0, 1)\n (y, lasty) = (1, 0)\n while b != 0:\n q = a // b\n (a, b) = (b, a % b)\n (x, lastx) = (lastx - q * x, x)\n (y, lasty) = (lasty - q * y, y)\n return (lastx, lasty, a)\n\n# ax ≡ 1 (mod m)",
"egcd",
"B = map(int,input().split())",
"map(int,input().split())",
"B",
"def modinv_memo(a,m):\n for i in range(a+1):\n j = modfact[i]\n (inv, q, gcd_val) = egcd(j, m)\n modinv[i] = inv % m",
"def modinv_memo(a,m):\n for i in range(a+1):\n j = modfact[i]\n (inv, q, gcd_val) = egcd(j, m)\n modinv[i] = inv % m",
"modinv_memo",
"H,W,A,B = map(int,input().split())",
"map(int,input().split())",
"H",
"ans %= N",
"N",
"ans",
"modinv=[0]*(R+1)",
"[0]*(R+1)",
"modinv",
"def gcd(a, b):\n\twhile b:\n\t\ta, b = b, a % b\n\treturn a",
"def gcd(a, b):\n\twhile b:\n\t\ta, b = b, a % b\n\treturn a",
"gcd",
"W,A,B = map(int,input().split())",
"map(int,input().split())",
"W",
"R = 10**5*2",
"10**5*2",
"R",
"ans += modconb(H-A-1+r,r,N)*modconb(A-1+W-r-1,A-1,N)",
"modconb(H-A-1+r,r,N)*modconb(A-1+W-r-1,A-1,N)",
"ans"
] | def gcd(a, b):
while b:
a, b = b, a % b
return a
def egcd(a, b):
(x, lastx) = (0, 1)
(y, lasty) = (1, 0)
while b != 0:
q = a // b
(a, b) = (b, a % b)
(x, lastx) = (lastx - q * x, x)
(y, lasty) = (lasty - q * y, y)
return (lastx, lasty, a)
# ax ≡ 1 (mod m)
def modinv(a, m):
(inv, q, gcd_val) = egcd(a, m)
return inv % m
N = 10**9+7
R = 10**5*2
modfact = [0]*(R+1)
def modfact_memo(n,N):
r = 1
modfact[0] = 1
for i in range(1,n+1):
r = r % N * i % N
modfact[i] = r
modfact_memo(R,N)
# ax ≡ 1 (mod m)
modinv=[0]*(R+1)
def modinv_memo(a,m):
for i in range(a+1):
j = modfact[i]
(inv, q, gcd_val) = egcd(j, m)
modinv[i] = inv % m
modinv_memo(R,N)
def modconb(n,r,N):
p = modfact[n]
q1 = modinv[r]
q2 = modinv[n-r]
return p*q1%N*q2%N
H,W,A,B = map(int,input().split())
ans = 0
for r in range(B,W):
ans += modconb(H-A-1+r,r,N)*modconb(A-1+W-r-1,A-1,N)
ans %= N
print(ans) |
[
7,
0,
13,
4,
13,
13,
4,
18,
4,
13,
13,
13,
13,
13,
0,
13,
2,
2,
17,
2,
17,
17,
17,
0,
13,
2,
2,
17,
17,
17,
0,
13,
2,
39,
17,
2,
13,
17,
0,
18,
13,
17,
17,
0,
18,
13,
17,
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,
4,
13,
17,
2,
13,
17,
0,
18,
13,
2,
13,
17,
2,
2,
18,
13,
13,
13,
13,
12,
13,
29,
2,
2,
18,
13,
2,
13,
13,
18,
13,
13,
18,
13,
13,
23,
13,
23,
13,
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,
13,
17,
2,
13,
17,
13,
0,
13,
13,
4,
13,
13,
10,
4,
13,
10,
2,
13,
10,
12,
13,
10,
2,
13,
10,
4,
13,
10,
4,
13,
10,
2,
13,
10,
13,
13,
10,
4,
13,
10,
2,
13,
10,
17,
13,
10,
2,
13
] | [
[
196,
2
],
[
196,
11
],
[
196,
12
],
[
196,
13
],
[
181,
15
],
[
175,
24
],
[
190,
31
],
[
182,
36
],
[
42,
39
],
[
191,
40
],
[
47,
44
],
[
191,
45
],
[
50,
49
],
[
182,
54
],
[
60,
57
],
[
191,
58
],
[
49,
59
],
[
191,
63
],
[
49,
65
],
[
49,
67
],
[
176,
68
],
[
205,
70
],
[
182,
75
],
[
81,
78
],
[
206,
79
],
[
182,
80
],
[
191,
84
],
[
182,
85
],
[
176,
87
],
[
176,
89
],
[
92,
91
],
[
182,
98
],
[
106,
101
],
[
206,
102
],
[
91,
104
],
[
206,
109
],
[
91,
110
],
[
91,
111
],
[
176,
112
],
[
191,
119
],
[
130,
121
],
[
132,
122
],
[
206,
124
],
[
130,
125
],
[
206,
127
],
[
132,
128
],
[
130,
130
],
[
132,
132
],
[
202,
134
],
[
138,
137
],
[
197,
140
],
[
173,
141
],
[
199,
143
],
[
179,
147
],
[
137,
148
],
[
185,
151
],
[
188,
152
],
[
179,
155
],
[
173,
158
],
[
137,
159
],
[
188,
162
],
[
176,
164
],
[
193,
166
],
[
176,
167
],
[
194,
170
],
[
200,
170
],
[
203,
170
],
[
196,
173
],
[
175,
176
],
[
181,
182
],
[
196,
185
],
[
196,
188
],
[
190,
191
],
[
176,
193
],
[
193,
194
],
[
196,
197
],
[
199,
200
],
[
202,
203
],
[
205,
206
]
] | [
"H, W, A, B = map(int, input().split())\n\nMAX = 2 * 10 ** 5 + 1\nMOD = 10 ** 9 + 7\n\n# Factorial\nfac = [0] * (MAX + 1)\nfac[0] = 1\nfac[1] = 1\nfor i in range(2, MAX + 1):\n fac[i] = fac[i - 1] * i % MOD\n \n# Inverse factorial\nfinv = [0] * (MAX + 1)\nfinv[MAX] = pow(fac[MAX], MOD - 2, MOD)\nfor i in reversed(range(1, MAX + 1)):\n finv[i - 1] = finv[i] * i % MOD\n\n\ndef comb(a, b):\n return fac[a + b] * finv[a] * finv[b]\n\n\nans = 0\nfor i in range(B, W):\n ans += comb(i, H - A - 1) * comb(W - i - 1, A - 1) % 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",
"MAX = 2 * 10 ** 5 + 1",
"MAX",
"2 * 10 ** 5 + 1",
"2 * 10 ** 5",
"2",
"10 ** 5",
"10",
"5",
"1",
"MOD = 10 ** 9 + 7",
"MOD",
"10 ** 9 + 7",
"10 ** 9",
"10",
"9",
"7",
"fac = [0] * (MAX + 1)",
"fac",
"[0] * (MAX + 1)",
"[0]",
"0",
"MAX + 1",
"MAX",
"1",
"fac[0] = 1",
"fac[0]",
"fac",
"0",
"1",
"fac[1] = 1",
"fac[1]",
"fac",
"1",
"1",
"for i in range(2, MAX + 1):\n fac[i] = fac[i - 1] * i % MOD\n \n# Inverse factorial",
"i",
"range(2, MAX + 1)",
"range",
"2",
"MAX + 1",
"MAX",
"1",
"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",
"finv = [0] * (MAX + 1)",
"finv",
"[0] * (MAX + 1)",
"[0]",
"0",
"MAX + 1",
"MAX",
"1",
"finv[MAX] = pow(fac[MAX], MOD - 2, MOD)",
"finv[MAX]",
"finv",
"MAX",
"pow(fac[MAX], MOD - 2, MOD)",
"pow",
"fac[MAX]",
"fac",
"MAX",
"MOD - 2",
"MOD",
"2",
"MOD",
"for i in reversed(range(1, MAX + 1)):\n finv[i - 1] = finv[i] * i % MOD",
"i",
"reversed(range(1, MAX + 1))",
"reversed",
"range(1, MAX + 1)",
"range",
"1",
"MAX + 1",
"MAX",
"1",
"finv[i - 1] = finv[i] * i % MOD",
"finv[i - 1]",
"finv",
"i - 1",
"i",
"1",
"finv[i] * i % MOD",
"finv[i] * i",
"finv[i]",
"finv",
"i",
"i",
"MOD",
"def comb(a, b):\n return fac[a + b] * finv[a] * finv[b]",
"comb",
"return fac[a + b] * finv[a] * finv[b]",
"fac[a + b] * finv[a] * finv[b]",
"fac[a + b] * finv[a]",
"fac[a + b]",
"fac",
"a + b",
"a",
"b",
"finv[a]",
"finv",
"a",
"finv[b]",
"finv",
"b",
"a",
"a",
"b",
"b",
"ans = 0",
"ans",
"0",
"for i in range(B, W):\n ans += comb(i, H - A - 1) * comb(W - i - 1, A - 1) % MOD\n ans %= MOD",
"i",
"range(B, W)",
"range",
"B",
"W",
"ans += comb(i, H - A - 1) * comb(W - i - 1, A - 1) % MOD",
"ans",
"comb(i, H - A - 1) * comb(W - i - 1, A - 1) % MOD",
"comb(i, H - A - 1) * comb(W - i - 1, A - 1)",
"comb(i, H - A - 1)",
"comb",
"i",
"H - A - 1",
"H - A",
"H",
"A",
"1",
"comb(W - i - 1, A - 1)",
"comb",
"W - i - 1",
"W - i",
"W",
"i",
"1",
"A - 1",
"A",
"1",
"MOD",
"ans %= MOD",
"ans",
"MOD",
"print(ans)",
"print",
"ans",
"W, A, B = map(int, input().split())",
"map(int, input().split())",
"W",
"MOD = 10 ** 9 + 7",
"10 ** 9 + 7",
"MOD",
"def comb(a, b):\n return fac[a + b] * finv[a] * finv[b]",
"def comb(a, b):\n return fac[a + b] * finv[a] * finv[b]",
"comb",
"MAX = 2 * 10 ** 5 + 1",
"2 * 10 ** 5 + 1",
"MAX",
"H, W, A, B = map(int, input().split())",
"map(int, input().split())",
"H",
"A, B = map(int, input().split())",
"map(int, input().split())",
"A",
"fac = [0] * (MAX + 1)",
"[0] * (MAX + 1)",
"fac",
"ans %= MOD",
"MOD",
"ans",
"B = map(int, input().split())",
"map(int, input().split())",
"B",
"ans += comb(i, H - A - 1) * comb(W - i - 1, A - 1) % MOD",
"comb(i, H - A - 1) * comb(W - i - 1, A - 1) % MOD",
"ans",
"ans = 0",
"0",
"ans",
"finv = [0] * (MAX + 1)",
"[0] * (MAX + 1)",
"finv"
] | H, W, A, B = map(int, input().split())
MAX = 2 * 10 ** 5 + 1
MOD = 10 ** 9 + 7
# Factorial
fac = [0] * (MAX + 1)
fac[0] = 1
fac[1] = 1
for i in range(2, MAX + 1):
fac[i] = fac[i - 1] * i % MOD
# Inverse factorial
finv = [0] * (MAX + 1)
finv[MAX] = pow(fac[MAX], MOD - 2, MOD)
for i in reversed(range(1, MAX + 1)):
finv[i - 1] = finv[i] * i % MOD
def comb(a, b):
return fac[a + b] * finv[a] * finv[b]
ans = 0
for i in range(B, W):
ans += comb(i, H - A - 1) * comb(W - i - 1, A - 1) % MOD
ans %= MOD
print(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,
13,
13,
0,
13,
2,
39,
17,
2,
13,
17,
28,
13,
4,
13,
17,
2,
13,
17,
0,
18,
13,
13,
4,
13,
13,
2,
13,
17,
13,
0,
13,
2,
2,
13,
13,
17,
0,
13,
2,
13,
17,
0,
13,
2,
39,
17,
2,
13,
17,
0,
18,
13,
13,
17,
28,
13,
4,
13,
2,
13,
17,
2,
13,
17,
0,
18,
13,
13,
2,
2,
2,
18,
13,
2,
13,
17,
13,
18,
13,
2,
13,
13,
13,
0,
13,
2,
2,
13,
13,
17,
0,
13,
2,
13,
17,
0,
13,
2,
39,
17,
2,
13,
17,
0,
18,
13,
13,
17,
28,
13,
4,
13,
2,
13,
17,
2,
13,
17,
0,
18,
13,
13,
2,
2,
2,
18,
13,
2,
13,
17,
13,
18,
13,
2,
13,
13,
13,
0,
13,
2,
2,
2,
13,
13,
17,
13,
0,
13,
2,
2,
13,
13,
17,
0,
13,
2,
39,
17,
2,
13,
17,
0,
18,
13,
13,
17,
28,
13,
4,
13,
2,
13,
17,
2,
13,
17,
0,
18,
13,
13,
2,
2,
2,
18,
13,
2,
13,
17,
13,
18,
13,
2,
13,
13,
13,
0,
13,
18,
13,
2,
2,
13,
13,
17,
28,
13,
4,
13,
2,
13,
13,
13,
0,
13,
2,
2,
13,
2,
18,
13,
2,
2,
13,
13,
17,
18,
13,
2,
2,
2,
2,
2,
13,
13,
17,
13,
13,
17,
13,
4,
13,
13,
10,
2,
13,
10,
2,
13,
10,
4,
13,
10,
2,
13,
10,
2,
13,
10,
2,
13,
10,
2,
13,
10,
4,
13,
10,
2,
13,
10,
2,
13,
10,
4,
13,
10,
2,
13,
10,
4,
13,
10,
2,
13,
10,
2,
13,
10,
2,
13,
10,
18,
13,
10,
2,
13
] | [
[
303,
2
],
[
303,
11
],
[
303,
12
],
[
303,
13
],
[
276,
15
],
[
309,
22
],
[
274,
24
],
[
298,
25
],
[
279,
27
],
[
310,
32
],
[
36,
35
],
[
310,
40
],
[
46,
43
],
[
280,
44
],
[
35,
45
],
[
35,
48
],
[
277,
50
],
[
277,
52
],
[
291,
54
],
[
274,
57
],
[
298,
58
],
[
318,
61
],
[
274,
63
],
[
282,
66
],
[
292,
71
],
[
77,
74
],
[
283,
75
],
[
319,
76
],
[
310,
76
],
[
80,
79
],
[
319,
83
],
[
310,
83
],
[
292,
86
],
[
92,
89
],
[
283,
90
],
[
79,
91
],
[
283,
96
],
[
79,
98
],
[
79,
100
],
[
280,
102
],
[
79,
104
],
[
319,
105
],
[
310,
105
],
[
277,
106
],
[
294,
108
],
[
274,
111
],
[
304,
112
],
[
300,
115
],
[
304,
117
],
[
306,
120
],
[
295,
125
],
[
292,
125
],
[
131,
128
],
[
307,
129
],
[
301,
130
],
[
319,
130
],
[
310,
130
],
[
134,
133
],
[
301,
137
],
[
319,
137
],
[
310,
137
],
[
295,
140
],
[
292,
140
],
[
146,
143
],
[
307,
144
],
[
133,
145
],
[
307,
150
],
[
133,
152
],
[
133,
154
],
[
280,
156
],
[
133,
158
],
[
301,
159
],
[
319,
159
],
[
310,
159
],
[
277,
160
],
[
267,
162
],
[
298,
166
],
[
304,
167
],
[
289,
169
],
[
312,
171
],
[
298,
174
],
[
304,
175
],
[
270,
178
],
[
268,
183
],
[
295,
183
],
[
292,
183
],
[
189,
186
],
[
271,
187
],
[
313,
188
],
[
301,
188
],
[
319,
188
],
[
310,
188
],
[
192,
191
],
[
313,
195
],
[
301,
195
],
[
319,
195
],
[
310,
195
],
[
268,
198
],
[
295,
198
],
[
292,
198
],
[
204,
201
],
[
271,
202
],
[
191,
203
],
[
271,
208
],
[
191,
210
],
[
191,
212
],
[
280,
214
],
[
191,
216
],
[
313,
217
],
[
301,
217
],
[
319,
217
],
[
310,
217
],
[
277,
218
],
[
315,
220
],
[
283,
222
],
[
274,
225
],
[
298,
226
],
[
230,
229
],
[
274,
233
],
[
289,
234
],
[
274,
235
],
[
285,
237
],
[
316,
240
],
[
286,
240
],
[
307,
243
],
[
229,
246
],
[
304,
247
],
[
271,
250
],
[
274,
256
],
[
229,
257
],
[
298,
259
],
[
304,
260
],
[
277,
262
],
[
286,
265
],
[
316,
265
],
[
267,
268
],
[
270,
271
],
[
303,
274
],
[
276,
277
],
[
279,
280
],
[
282,
283
],
[
285,
286
],
[
303,
289
],
[
291,
292
],
[
294,
295
],
[
303,
298
],
[
300,
301
],
[
303,
304
],
[
306,
307
],
[
309,
310
],
[
312,
313
],
[
315,
316
],
[
318,
319
]
] | [
"H,W,A,B=map(int,input().split())\n\nmod=10**9+7\n\nn=H+W\nINV=[None]*(n+1)#1/aのリストを予め作っておく.\nfor i in range(1,n+1):\n INV[i]=pow(i,mod-2,mod)\n\nk=H+W-2\nn=H-1\nCombi1=[None]*(k+1)#Combi[i]=iCnを表す.kは必要な分だけ.\nCombi1[n]=1\nfor i in range(n+1,k+1):\n Combi1[i]=Combi1[i-1]*i*INV[i-n] %mod\n\nk=H+B-2\nn=B-1\nCombi2=[None]*(k+1)#Combi[i]=iCnを表す.kは必要な分だけ.\nCombi2[n]=1\nfor i in range(n+1,k+1):\n Combi2[i]=Combi2[i-1]*i*INV[i-n] %mod\n\nk=W-B-1+A\nn=W-B-1\nCombi3=[None]*(k+1)#Combi[i]=iCnを表す.kは必要な分だけ.\nCombi3[n]=1\nfor i in range(n+1,k+1):\n Combi3[i]=Combi3[i-1]*i*INV[i-n] %mod\n\n\n\n\nANS=Combi1[H+W-2]\nfor x in range(H-A,H):\n ANS=(ANS-Combi2[x+B-1]*Combi3[(H-x-1)+W-B-1])%mod\n\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",
"n=H+W",
"n",
"H+W",
"H",
"W",
"INV=[None]*(n+1)",
"INV",
"[None]*(n+1)",
"[None]",
"None",
"n+1",
"n",
"1",
"for i in range(1,n+1):\n INV[i]=pow(i,mod-2,mod)",
"i",
"range(1,n+1)",
"range",
"1",
"n+1",
"n",
"1",
"INV[i]=pow(i,mod-2,mod)",
"INV[i]",
"INV",
"i",
"pow(i,mod-2,mod)",
"pow",
"i",
"mod-2",
"mod",
"2",
"mod",
"k=H+W-2",
"k",
"H+W-2",
"H+W",
"H",
"W",
"2",
"n=H-1",
"n",
"H-1",
"H",
"1",
"Combi1=[None]*(k+1)",
"Combi1",
"[None]*(k+1)",
"[None]",
"None",
"k+1",
"k",
"1",
"Combi1[n]=1",
"Combi1[n]",
"Combi1",
"n",
"1",
"for i in range(n+1,k+1):\n Combi1[i]=Combi1[i-1]*i*INV[i-n] %mod",
"i",
"range(n+1,k+1)",
"range",
"n+1",
"n",
"1",
"k+1",
"k",
"1",
"Combi1[i]=Combi1[i-1]*i*INV[i-n] %mod",
"Combi1[i]",
"Combi1",
"i",
"Combi1[i-1]*i*INV[i-n] %mod",
"Combi1[i-1]*i*INV[i-n]",
"Combi1[i-1]*i",
"Combi1[i-1]",
"Combi1",
"i-1",
"i",
"1",
"i",
"INV[i-n]",
"INV",
"i-n",
"i",
"n",
"mod",
"k=H+B-2",
"k",
"H+B-2",
"H+B",
"H",
"B",
"2",
"n=B-1",
"n",
"B-1",
"B",
"1",
"Combi2=[None]*(k+1)",
"Combi2",
"[None]*(k+1)",
"[None]",
"None",
"k+1",
"k",
"1",
"Combi2[n]=1",
"Combi2[n]",
"Combi2",
"n",
"1",
"for i in range(n+1,k+1):\n Combi2[i]=Combi2[i-1]*i*INV[i-n] %mod",
"i",
"range(n+1,k+1)",
"range",
"n+1",
"n",
"1",
"k+1",
"k",
"1",
"Combi2[i]=Combi2[i-1]*i*INV[i-n] %mod",
"Combi2[i]",
"Combi2",
"i",
"Combi2[i-1]*i*INV[i-n] %mod",
"Combi2[i-1]*i*INV[i-n]",
"Combi2[i-1]*i",
"Combi2[i-1]",
"Combi2",
"i-1",
"i",
"1",
"i",
"INV[i-n]",
"INV",
"i-n",
"i",
"n",
"mod",
"k=W-B-1+A",
"k",
"W-B-1+A",
"W-B-1",
"W-B",
"W",
"B",
"1",
"A",
"n=W-B-1",
"n",
"W-B-1",
"W-B",
"W",
"B",
"1",
"Combi3=[None]*(k+1)",
"Combi3",
"[None]*(k+1)",
"[None]",
"None",
"k+1",
"k",
"1",
"Combi3[n]=1",
"Combi3[n]",
"Combi3",
"n",
"1",
"for i in range(n+1,k+1):\n Combi3[i]=Combi3[i-1]*i*INV[i-n] %mod",
"i",
"range(n+1,k+1)",
"range",
"n+1",
"n",
"1",
"k+1",
"k",
"1",
"Combi3[i]=Combi3[i-1]*i*INV[i-n] %mod",
"Combi3[i]",
"Combi3",
"i",
"Combi3[i-1]*i*INV[i-n] %mod",
"Combi3[i-1]*i*INV[i-n]",
"Combi3[i-1]*i",
"Combi3[i-1]",
"Combi3",
"i-1",
"i",
"1",
"i",
"INV[i-n]",
"INV",
"i-n",
"i",
"n",
"mod",
"ANS=Combi1[H+W-2]",
"ANS",
"Combi1[H+W-2]",
"Combi1",
"H+W-2",
"H+W",
"H",
"W",
"2",
"for x in range(H-A,H):\n ANS=(ANS-Combi2[x+B-1]*Combi3[(H-x-1)+W-B-1])%mod",
"x",
"range(H-A,H)",
"range",
"H-A",
"H",
"A",
"H",
"ANS=(ANS-Combi2[x+B-1]*Combi3[(H-x-1)+W-B-1])%mod",
"ANS",
"(ANS-Combi2[x+B-1]*Combi3[(H-x-1)+W-B-1])%mod",
"ANS-Combi2[x+B-1]*Combi3[(H-x-1)+W-B-1]",
"ANS",
"Combi2[x+B-1]*Combi3[(H-x-1)+W-B-1]",
"Combi2[x+B-1]",
"Combi2",
"x+B-1",
"x+B",
"x",
"B",
"1",
"Combi3[(H-x-1)+W-B-1]",
"Combi3",
"(H-x-1)+W-B-1",
"(H-x-1)+W-B",
"(H-x-1)+W",
"H-x-1",
"H-x",
"H",
"x",
"1",
"W",
"B",
"1",
"mod",
"print(ANS)",
"print",
"ANS",
"k=W-B-1+A",
"W-B-1+A",
"k",
"Combi3=[None]*(k+1)",
"[None]*(k+1)",
"Combi3",
"H,W,A,B=map(int,input().split())",
"map(int,input().split())",
"H",
"mod=10**9+7",
"10**9+7",
"mod",
"INV=[None]*(n+1)",
"[None]*(n+1)",
"INV",
"Combi1=[None]*(k+1)",
"[None]*(k+1)",
"Combi1",
"ANS=(ANS-Combi2[x+B-1]*Combi3[(H-x-1)+W-B-1])%mod",
"(ANS-Combi2[x+B-1]*Combi3[(H-x-1)+W-B-1])%mod",
"ANS",
"A,B=map(int,input().split())",
"map(int,input().split())",
"A",
"k=H+W-2",
"H+W-2",
"k",
"k=H+B-2",
"H+B-2",
"k",
"W,A,B=map(int,input().split())",
"map(int,input().split())",
"W",
"n=B-1",
"B-1",
"n",
"B=map(int,input().split())",
"map(int,input().split())",
"B",
"Combi2=[None]*(k+1)",
"[None]*(k+1)",
"Combi2",
"n=H+W",
"H+W",
"n",
"n=W-B-1",
"W-B-1",
"n",
"ANS=Combi1[H+W-2]",
"Combi1[H+W-2]",
"ANS",
"n=H-1",
"H-1",
"n"
] | H,W,A,B=map(int,input().split())
mod=10**9+7
n=H+W
INV=[None]*(n+1)#1/aのリストを予め作っておく.
for i in range(1,n+1):
INV[i]=pow(i,mod-2,mod)
k=H+W-2
n=H-1
Combi1=[None]*(k+1)#Combi[i]=iCnを表す.kは必要な分だけ.
Combi1[n]=1
for i in range(n+1,k+1):
Combi1[i]=Combi1[i-1]*i*INV[i-n] %mod
k=H+B-2
n=B-1
Combi2=[None]*(k+1)#Combi[i]=iCnを表す.kは必要な分だけ.
Combi2[n]=1
for i in range(n+1,k+1):
Combi2[i]=Combi2[i-1]*i*INV[i-n] %mod
k=W-B-1+A
n=W-B-1
Combi3=[None]*(k+1)#Combi[i]=iCnを表す.kは必要な分だけ.
Combi3[n]=1
for i in range(n+1,k+1):
Combi3[i]=Combi3[i-1]*i*INV[i-n] %mod
ANS=Combi1[H+W-2]
for x in range(H-A,H):
ANS=(ANS-Combi2[x+B-1]*Combi3[(H-x-1)+W-B-1])%mod
print(ANS) |
[
7,
0,
13,
4,
13,
13,
4,
18,
4,
13,
13,
13,
13,
13,
12,
13,
0,
13,
39,
17,
17,
13,
0,
13,
39,
17,
17,
13,
42,
40,
18,
13,
17,
17,
0,
13,
2,
18,
13,
17,
18,
13,
17,
0,
13,
13,
0,
13,
39,
2,
18,
13,
17,
2,
13,
18,
13,
17,
2,
18,
13,
17,
2,
13,
18,
13,
17,
2,
18,
13,
17,
2,
13,
18,
13,
17,
0,
13,
13,
0,
13,
13,
29,
39,
18,
13,
17,
18,
13,
17,
23,
13,
23,
13,
12,
13,
0,
13,
18,
4,
13,
13,
13,
17,
29,
2,
2,
13,
2,
13,
13,
13,
23,
13,
23,
13,
12,
13,
0,
18,
13,
17,
17,
28,
13,
4,
13,
17,
13,
0,
13,
2,
2,
18,
13,
2,
13,
17,
2,
13,
13,
2,
2,
17,
17,
17,
0,
18,
13,
13,
2,
13,
4,
13,
13,
2,
2,
17,
17,
17,
29,
13,
23,
13,
23,
13,
23,
13,
0,
13,
2,
39,
17,
2,
13,
13,
0,
13,
2,
39,
17,
13,
0,
13,
4,
13,
2,
13,
13,
2,
13,
17,
13,
0,
13,
4,
13,
13,
2,
2,
13,
13,
17,
13,
17,
0,
13,
17,
28,
13,
4,
13,
2,
13,
13,
0,
13,
2,
18,
13,
13,
18,
13,
2,
40,
13,
17,
4,
13,
2,
13,
2,
2,
17,
17,
17,
17,
10,
4,
13,
10,
2,
13,
10,
12,
13,
10,
12,
13,
10,
2,
13,
10,
4,
13,
10,
4,
13,
10,
2,
13,
10,
4,
13,
10,
4,
13,
10,
12,
13,
10,
4,
13,
10,
17,
13
] | [
[
271,
2
],
[
271,
11
],
[
271,
12
],
[
271,
13
],
[
18,
17
],
[
24,
23
],
[
23,
31
],
[
80,
31
],
[
36,
35
],
[
17,
38
],
[
77,
38
],
[
23,
41
],
[
80,
41
],
[
45,
44
],
[
23,
45
],
[
80,
45
],
[
48,
47
],
[
17,
51
],
[
77,
51
],
[
35,
54
],
[
23,
56
],
[
80,
56
],
[
17,
60
],
[
77,
60
],
[
35,
63
],
[
23,
65
],
[
80,
65
],
[
17,
69
],
[
77,
69
],
[
35,
72
],
[
23,
74
],
[
80,
74
],
[
78,
77
],
[
44,
78
],
[
81,
80
],
[
47,
81
],
[
80,
85
],
[
23,
85
],
[
80,
88
],
[
23,
88
],
[
91,
91
],
[
93,
93
],
[
98,
97
],
[
269,
100
],
[
113,
101
],
[
115,
102
],
[
115,
107
],
[
97,
109
],
[
115,
110
],
[
115,
111
],
[
113,
113
],
[
115,
115
],
[
122,
119
],
[
167,
120
],
[
125,
124
],
[
163,
128
],
[
131,
130
],
[
167,
134
],
[
124,
136
],
[
165,
139
],
[
124,
140
],
[
150,
147
],
[
167,
148
],
[
124,
149
],
[
130,
151
],
[
245,
153
],
[
124,
154
],
[
167,
161
],
[
163,
163
],
[
165,
165
],
[
167,
167
],
[
241,
169
],
[
239,
174
],
[
257,
175
],
[
259,
177
],
[
239,
181
],
[
253,
183
],
[
248,
185
],
[
239,
187
],
[
257,
188
],
[
266,
190
],
[
242,
192
],
[
262,
194
],
[
248,
196
],
[
239,
197
],
[
272,
200
],
[
266,
201
],
[
260,
203
],
[
274,
206
],
[
210,
209
],
[
239,
213
],
[
257,
214
],
[
250,
216
],
[
254,
219
],
[
242,
219
],
[
209,
220
],
[
263,
222
],
[
260,
222
],
[
209,
225
],
[
251,
230
],
[
275,
230
],
[
271,
239
],
[
241,
242
],
[
250,
251
],
[
253,
254
],
[
271,
257
],
[
259,
260
],
[
262,
263
],
[
271,
266
],
[
271,
272
],
[
274,
275
]
] | [
"H,W,A,B=map(int,input().split())\ndef extgcd(a,b):\n r = [1,0,a]\n w = [0,1,b]\n while w[2]!=1:\n q = r[2]//w[2]\n r2 = w\n w2 = [r[0]-q*w[0],r[1]-q*w[1],r[2]-q*w[2]]\n r = r2\n w = w2\n #[x,y]\n return [w[0],w[1]]\ndef mod_inv(a,m):\n x = extgcd(a,m)[0]\n return (m+x%m)%m\ndef kumi(h,w,a):\n a[0]=1\n #print(a)\n for i in range(1,h):\n b=a[i-1]*(w+i)%(10**9+7)\n a[i]=b*mod_inv(i,10**9+7)\n #print(a)\n return a\nf=[0]*(H-A)\ns=[0]*(H)\nf=kumi(H-A,B-1,f)\ns=kumi(H,W-B-1,s)\n\"\"\"print(f)\nprint(s)\"\"\"\nans=0\nfor i in range(H-A):\n ans+=f[i]*s[-i-1]\nprint(ans%(10**9+7))\n\"\"\"ans=0\nfor i in range(H-A):\n #print(cmb(i+B-1,B-1)%(10**9+7),cmb(H-i+W-B-2,W-B-1)%(10**9+7))\n ans+=cmb(i+B-1,B-1)*cmb(H-i+W-B-2,W-B-1)%(10**9+7)\nprint(ans%(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 extgcd(a,b):\n r = [1,0,a]\n w = [0,1,b]\n while w[2]!=1:\n q = r[2]//w[2]\n r2 = w\n w2 = [r[0]-q*w[0],r[1]-q*w[1],r[2]-q*w[2]]\n r = r2\n w = w2\n #[x,y]\n return [w[0],w[1]]",
"extgcd",
"r = [1,0,a]",
"r",
"[1,0,a]",
"1",
"0",
"a",
"w = [0,1,b]",
"w",
"[0,1,b]",
"0",
"1",
"b",
"while w[2]!=1:\n q = r[2]//w[2]\n r2 = w\n w2 = [r[0]-q*w[0],r[1]-q*w[1],r[2]-q*w[2]]\n r = r2\n w = w2\n #[x,y]\n ",
"w[2]!=1",
"w[2]",
"w",
"2",
"1",
"q = r[2]//w[2]",
"q",
"r[2]//w[2]",
"r[2]",
"r",
"2",
"w[2]",
"w",
"2",
"r2 = w",
"r2",
"w",
"w2 = [r[0]-q*w[0],r[1]-q*w[1],r[2]-q*w[2]]",
"w2",
"[r[0]-q*w[0],r[1]-q*w[1],r[2]-q*w[2]]",
"r[0]-q*w[0]",
"r[0]",
"r",
"0",
"q*w[0]",
"q",
"w[0]",
"w",
"0",
"r[1]-q*w[1]",
"r[1]",
"r",
"1",
"q*w[1]",
"q",
"w[1]",
"w",
"1",
"r[2]-q*w[2]",
"r[2]",
"r",
"2",
"q*w[2]",
"q",
"w[2]",
"w",
"2",
"r = r2",
"r",
"r2",
"w = w2",
"w",
"w2",
"return [w[0],w[1]]",
"[w[0],w[1]]",
"w[0]",
"w",
"0",
"w[1]",
"w",
"1",
"a",
"a",
"b",
"b",
"def mod_inv(a,m):\n x = extgcd(a,m)[0]\n return (m+x%m)%m",
"mod_inv",
"x = extgcd(a,m)[0]",
"x",
"extgcd(a,m)[0]",
"(a,m)",
"extgcd",
"a",
"m",
"0",
"return (m+x%m)%m",
"(m+x%m)%m",
"m+x%m",
"m",
"x%m",
"x",
"m",
"m",
"a",
"a",
"m",
"m",
"def kumi(h,w,a):\n a[0]=1\n #print(a)\n for i in range(1,h):\n b=a[i-1]*(w+i)%(10**9+7)\n a[i]=b*mod_inv(i,10**9+7)\n #print(a)\n return a",
"kumi",
"a[0]=1",
"a[0]",
"a",
"0",
"1",
"for i in range(1,h):\n b=a[i-1]*(w+i)%(10**9+7)\n a[i]=b*mod_inv(i,10**9+7)\n #print(a)\n ",
"i",
"range(1,h)",
"range",
"1",
"h",
"b=a[i-1]*(w+i)%(10**9+7)",
"b",
"a[i-1]*(w+i)%(10**9+7)",
"a[i-1]*(w+i)",
"a[i-1]",
"a",
"i-1",
"i",
"1",
"w+i",
"w",
"i",
"10**9+7",
"10**9",
"10",
"9",
"7",
"a[i]=b*mod_inv(i,10**9+7)",
"a[i]",
"a",
"i",
"b*mod_inv(i,10**9+7)",
"b",
"mod_inv(i,10**9+7)",
"mod_inv",
"i",
"10**9+7",
"10**9",
"10",
"9",
"7",
"return a",
"a",
"h",
"h",
"w",
"w",
"a",
"a",
"f=[0]*(H-A)",
"f",
"[0]*(H-A)",
"[0]",
"0",
"H-A",
"H",
"A",
"s=[0]*(H)",
"s",
"[0]*(H)",
"[0]",
"0",
"H",
"f=kumi(H-A,B-1,f)",
"f",
"kumi(H-A,B-1,f)",
"kumi",
"H-A",
"H",
"A",
"B-1",
"B",
"1",
"f",
"s=kumi(H,W-B-1,s)",
"s",
"kumi(H,W-B-1,s)",
"kumi",
"H",
"W-B-1",
"W-B",
"W",
"B",
"1",
"s",
"\"\"\"print(f)\nprint(s)\"\"\"",
"ans=0",
"ans",
"0",
"for i in range(H-A):\n ans+=f[i]*s[-i-1]",
"i",
"range(H-A)",
"range",
"H-A",
"H",
"A",
"ans+=f[i]*s[-i-1]",
"ans",
"f[i]*s[-i-1]",
"f[i]",
"f",
"i",
"s[-i-1]",
"s",
"-i-1",
"-i",
"i",
"1",
"print(ans%(10**9+7))",
"print",
"ans%(10**9+7)",
"ans",
"10**9+7",
"10**9",
"10",
"9",
"7",
"\"\"\"ans=0\nfor i in range(H-A):\n #print(cmb(i+B-1,B-1)%(10**9+7),cmb(H-i+W-B-2,W-B-1)%(10**9+7))\n ans+=cmb(i+B-1,B-1)*cmb(H-i+W-B-2,W-B-1)%(10**9+7)\nprint(ans%(10**9+7))\"\"\"",
"H,W,A,B=map(int,input().split())",
"map(int,input().split())",
"H",
"f=[0]*(H-A)",
"[0]*(H-A)",
"f",
"def mod_inv(a,m):\n x = extgcd(a,m)[0]\n return (m+x%m)%m",
"def mod_inv(a,m):\n x = extgcd(a,m)[0]\n return (m+x%m)%m",
"mod_inv",
"def kumi(h,w,a):\n a[0]=1\n #print(a)\n for i in range(1,h):\n b=a[i-1]*(w+i)%(10**9+7)\n a[i]=b*mod_inv(i,10**9+7)\n #print(a)\n return a",
"def kumi(h,w,a):\n a[0]=1\n #print(a)\n for i in range(1,h):\n b=a[i-1]*(w+i)%(10**9+7)\n a[i]=b*mod_inv(i,10**9+7)\n #print(a)\n return a",
"kumi",
"ans+=f[i]*s[-i-1]",
"f[i]*s[-i-1]",
"ans",
"f=kumi(H-A,B-1,f)",
"kumi(H-A,B-1,f)",
"f",
"A,B=map(int,input().split())",
"map(int,input().split())",
"A",
"s=[0]*(H)",
"[0]*(H)",
"s",
"s=kumi(H,W-B-1,s)",
"kumi(H,W-B-1,s)",
"s",
"B=map(int,input().split())",
"map(int,input().split())",
"B",
"def extgcd(a,b):\n r = [1,0,a]\n w = [0,1,b]\n while w[2]!=1:\n q = r[2]//w[2]\n r2 = w\n w2 = [r[0]-q*w[0],r[1]-q*w[1],r[2]-q*w[2]]\n r = r2\n w = w2\n #[x,y]\n return [w[0],w[1]]",
"def extgcd(a,b):\n r = [1,0,a]\n w = [0,1,b]\n while w[2]!=1:\n q = r[2]//w[2]\n r2 = w\n w2 = [r[0]-q*w[0],r[1]-q*w[1],r[2]-q*w[2]]\n r = r2\n w = w2\n #[x,y]\n return [w[0],w[1]]",
"extgcd",
"W,A,B=map(int,input().split())",
"map(int,input().split())",
"W",
"ans=0",
"0",
"ans"
] | H,W,A,B=map(int,input().split())
def extgcd(a,b):
r = [1,0,a]
w = [0,1,b]
while w[2]!=1:
q = r[2]//w[2]
r2 = w
w2 = [r[0]-q*w[0],r[1]-q*w[1],r[2]-q*w[2]]
r = r2
w = w2
#[x,y]
return [w[0],w[1]]
def mod_inv(a,m):
x = extgcd(a,m)[0]
return (m+x%m)%m
def kumi(h,w,a):
a[0]=1
#print(a)
for i in range(1,h):
b=a[i-1]*(w+i)%(10**9+7)
a[i]=b*mod_inv(i,10**9+7)
#print(a)
return a
f=[0]*(H-A)
s=[0]*(H)
f=kumi(H-A,B-1,f)
s=kumi(H,W-B-1,s)
"""print(f)
print(s)"""
ans=0
for i in range(H-A):
ans+=f[i]*s[-i-1]
print(ans%(10**9+7))
"""ans=0
for i in range(H-A):
#print(cmb(i+B-1,B-1)%(10**9+7),cmb(H-i+W-B-2,W-B-1)%(10**9+7))
ans+=cmb(i+B-1,B-1)*cmb(H-i+W-B-2,W-B-1)%(10**9+7)
print(ans%(10**9+7))"""
|
[
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,
39,
17,
2,
2,
13,
13,
17,
0,
13,
2,
39,
17,
2,
2,
13,
13,
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,
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,
13,
13,
0,
13,
2,
13,
2,
2,
13,
13,
17,
0,
13,
2,
2,
2,
13,
13,
17,
2,
13,
17,
0,
13,
2,
4,
13,
13,
13,
4,
13,
13,
2,
13,
17,
0,
13,
2,
2,
13,
13,
13,
4,
13,
13,
10,
2,
13,
10,
2,
13,
10,
2,
13,
10,
4,
13,
10,
4,
13,
10,
4,
13,
10,
2,
13,
10,
2,
13,
10,
17,
13,
10,
2,
13,
10,
4,
13,
10,
12,
13,
10,
2,
13
] | [
[
180,
2
],
[
180,
11
],
[
180,
12
],
[
180,
13
],
[
174,
15
],
[
186,
18
],
[
177,
25
],
[
160,
31
],
[
163,
32
],
[
168,
35
],
[
160,
41
],
[
163,
42
],
[
46,
45
],
[
160,
50
],
[
163,
51
],
[
56,
53
],
[
178,
54
],
[
45,
55
],
[
178,
59
],
[
45,
61
],
[
45,
63
],
[
187,
64
],
[
69,
66
],
[
169,
67
],
[
45,
68
],
[
53,
71
],
[
178,
72
],
[
45,
73
],
[
187,
75
],
[
187,
77
],
[
178,
85
],
[
97,
86
],
[
169,
88
],
[
99,
89
],
[
169,
91
],
[
97,
93
],
[
99,
94
],
[
187,
95
],
[
97,
97
],
[
99,
99
],
[
102,
101
],
[
166,
104
],
[
163,
105
],
[
150,
107
],
[
101,
109
],
[
160,
112
],
[
181,
113
],
[
171,
116
],
[
163,
120
],
[
101,
121
],
[
181,
124
],
[
153,
127
],
[
184,
130
],
[
151,
131
],
[
101,
132
],
[
184,
134
],
[
172,
135
],
[
181,
137
],
[
156,
140
],
[
175,
143
],
[
157,
143
],
[
154,
144
],
[
187,
145
],
[
157,
148
],
[
175,
148
],
[
150,
151
],
[
153,
154
],
[
156,
157
],
[
180,
160
],
[
180,
163
],
[
180,
166
],
[
168,
169
],
[
171,
172
],
[
174,
175
],
[
177,
178
],
[
180,
181
],
[
186,
187
]
] | [
"h,w,a,b=map(int,input().split())\nans = 0\n\nmod = 10**9 + 7\nfac = [1] * (h+w+1)\ninv = [1] * (h+w+1)\nfor i in range(1,h+w):\n fac[i] = (fac[i-1] * i)%mod\n inv[i] = pow(fac[i], mod-2, mod)\n\ndef cmb(n,r):\n return fac[n] * inv[r] * inv[n-r] % mod\n \nfor x in range(b,w):\n c = x + (h - a - 1)\n d = (w - x - 1) + (a - 1)\n e = cmb(c, x) * cmb(d, a - 1)\n ans = (ans+e)%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",
"ans = 0",
"ans",
"0",
"mod = 10**9 + 7",
"mod",
"10**9 + 7",
"10**9",
"10",
"9",
"7",
"fac = [1] * (h+w+1)",
"fac",
"[1] * (h+w+1)",
"[1]",
"1",
"h+w+1",
"h+w",
"h",
"w",
"1",
"inv = [1] * (h+w+1)",
"inv",
"[1] * (h+w+1)",
"[1]",
"1",
"h+w+1",
"h+w",
"h",
"w",
"1",
"for i in range(1,h+w):\n fac[i] = (fac[i-1] * i)%mod\n inv[i] = pow(fac[i], mod-2, mod)",
"i",
"range(1,h+w)",
"range",
"1",
"h+w",
"h",
"w",
"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] = 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 cmb(n,r):\n return fac[n] * inv[r] * inv[n-r] % mod\n ",
"cmb",
"return fac[n] * inv[r] * inv[n-r] % mod",
"fac[n] * inv[r] * inv[n-r] % mod",
"fac[n] * inv[r] * inv[n-r]",
"fac[n] * inv[r]",
"fac[n]",
"fac",
"n",
"inv[r]",
"inv",
"r",
"inv[n-r]",
"inv",
"n-r",
"n",
"r",
"mod",
"n",
"n",
"r",
"r",
"for x in range(b,w):\n c = x + (h - a - 1)\n d = (w - x - 1) + (a - 1)\n e = cmb(c, x) * cmb(d, a - 1)\n ans = (ans+e)%mod",
"x",
"range(b,w)",
"range",
"b",
"w",
"c = x + (h - a - 1)",
"c",
"x + (h - a - 1)",
"x",
"h - a - 1",
"h - a",
"h",
"a",
"1",
"d = (w - x - 1) + (a - 1)",
"d",
"(w - x - 1) + (a - 1)",
"w - x - 1",
"w - x",
"w",
"x",
"1",
"a - 1",
"a",
"1",
"e = cmb(c, x) * cmb(d, a - 1)",
"e",
"cmb(c, x) * cmb(d, a - 1)",
"cmb(c, x)",
"cmb",
"c",
"x",
"cmb(d, a - 1)",
"cmb",
"d",
"a - 1",
"a",
"1",
"ans = (ans+e)%mod",
"ans",
"(ans+e)%mod",
"ans+e",
"ans",
"e",
"mod",
"print(ans)",
"print",
"ans",
"c = x + (h - a - 1)",
"x + (h - a - 1)",
"c",
"e = cmb(c, x) * cmb(d, a - 1)",
"cmb(c, x) * cmb(d, a - 1)",
"e",
"ans = (ans+e)%mod",
"(ans+e)%mod",
"ans",
"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",
"b=map(int,input().split())",
"map(int,input().split())",
"b",
"inv = [1] * (h+w+1)",
"[1] * (h+w+1)",
"inv",
"d = (w - x - 1) + (a - 1)",
"(w - x - 1) + (a - 1)",
"d",
"ans = 0",
"0",
"ans",
"fac = [1] * (h+w+1)",
"[1] * (h+w+1)",
"fac",
"a,b=map(int,input().split())",
"map(int,input().split())",
"a",
"def cmb(n,r):\n return fac[n] * inv[r] * inv[n-r] % mod\n ",
"def cmb(n,r):\n return fac[n] * inv[r] * inv[n-r] % mod\n ",
"cmb",
"mod = 10**9 + 7",
"10**9 + 7",
"mod"
] | h,w,a,b=map(int,input().split())
ans = 0
mod = 10**9 + 7
fac = [1] * (h+w+1)
inv = [1] * (h+w+1)
for i in range(1,h+w):
fac[i] = (fac[i-1] * i)%mod
inv[i] = pow(fac[i], mod-2, mod)
def cmb(n,r):
return fac[n] * inv[r] * inv[n-r] % mod
for x in range(b,w):
c = x + (h - a - 1)
d = (w - x - 1) + (a - 1)
e = cmb(c, x) * cmb(d, a - 1)
ans = (ans+e)%mod
print(ans) |
[
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,
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,
2,
39,
17,
2,
13,
17,
0,
13,
17,
28,
13,
4,
13,
17,
2,
13,
17,
0,
13,
4,
13,
13,
2,
13,
17,
13,
0,
13,
13,
0,
18,
13,
13,
13,
0,
13,
17,
28,
13,
4,
13,
2,
13,
13,
0,
13,
2,
2,
18,
13,
2,
2,
13,
17,
13,
18,
13,
13,
18,
13,
2,
13,
17,
0,
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,
0,
13,
2,
2,
13,
13,
13,
0,
13,
13,
0,
13,
13,
4,
13,
13,
10,
2,
13,
10,
2,
13,
10,
17,
13,
10,
4,
13,
10,
4,
13,
10,
4,
13,
10,
17,
13,
10,
2,
13,
10,
2,
13,
10,
2,
13,
10,
13,
13,
10,
2,
13,
10,
4,
13,
10,
2,
13,
10,
13,
13,
10,
13,
13,
10,
13,
13,
10,
13,
13,
10,
17,
13,
10,
4,
13
] | [
[
226,
2
],
[
226,
11
],
[
226,
12
],
[
226,
13
],
[
208,
15
],
[
206,
18
],
[
182,
19
],
[
172,
22
],
[
190,
29
],
[
209,
34
],
[
223,
37
],
[
41,
40
],
[
209,
45
],
[
214,
48
],
[
40,
49
],
[
211,
51
],
[
173,
52
],
[
57,
54
],
[
191,
55
],
[
40,
56
],
[
212,
57
],
[
215,
57
],
[
224,
57
],
[
193,
59
],
[
209,
64
],
[
175,
67
],
[
71,
70
],
[
209,
75
],
[
178,
78
],
[
70,
81
],
[
173,
83
],
[
173,
85
],
[
217,
87
],
[
173,
88
],
[
93,
90
],
[
194,
91
],
[
70,
92
],
[
218,
93
],
[
179,
93
],
[
176,
93
],
[
212,
93
],
[
215,
93
],
[
224,
93
],
[
187,
95
],
[
99,
98
],
[
206,
102
],
[
185,
103
],
[
169,
105
],
[
191,
109
],
[
227,
112
],
[
98,
114
],
[
90,
115
],
[
194,
116
],
[
98,
117
],
[
194,
119
],
[
227,
121
],
[
202,
124
],
[
191,
128
],
[
182,
133
],
[
206,
134
],
[
227,
135
],
[
98,
136
],
[
194,
139
],
[
206,
142
],
[
98,
143
],
[
194,
146
],
[
182,
149
],
[
227,
150
],
[
196,
153
],
[
170,
156
],
[
218,
156
],
[
179,
156
],
[
176,
156
],
[
212,
156
],
[
215,
156
],
[
224,
156
],
[
197,
156
],
[
203,
157
],
[
173,
158
],
[
199,
160
],
[
197,
161
],
[
170,
161
],
[
218,
161
],
[
179,
161
],
[
176,
161
],
[
212,
161
],
[
215,
161
],
[
224,
161
],
[
220,
163
],
[
173,
164
],
[
221,
167
],
[
200,
167
],
[
188,
167
],
[
169,
170
],
[
172,
173
],
[
175,
176
],
[
178,
179
],
[
226,
182
],
[
226,
185
],
[
187,
188
],
[
190,
191
],
[
193,
194
],
[
196,
197
],
[
197,
199
],
[
170,
199
],
[
218,
199
],
[
179,
199
],
[
176,
199
],
[
212,
199
],
[
215,
199
],
[
224,
199
],
[
199,
200
],
[
202,
203
],
[
226,
206
],
[
208,
209
],
[
173,
211
],
[
211,
212
],
[
40,
214
],
[
214,
215
],
[
173,
217
],
[
217,
218
],
[
173,
220
],
[
220,
221
],
[
223,
224
],
[
226,
227
]
] | [
"H,W,A,B=map(int,input().split())\nN=H+W+2\nmod=10**9+7\ntable=[1]*(N+3)\nt=1\nfor i in range(1,N+3):\n t*=i\n t%=mod\n table[i]=t\nrtable=[1]*(N+3)\nt=1\nfor i in range(1,N+3):\n t*=pow(i,mod-2,mod)\n t%=mod\n rtable[i]=t\nans=0\nfor i in range(H-A):\n t=table[B-1+i]*rtable[i]*rtable[B-1]\n s=table[W+H-B-i-2]*rtable[H-i-1]*rtable[W-B-1]\n t=(t*s)%mod\n #print(t)\n ans+=t\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+2",
"N",
"H+W+2",
"H+W",
"H",
"W",
"2",
"mod=10**9+7",
"mod",
"10**9+7",
"10**9",
"10",
"9",
"7",
"table=[1]*(N+3)",
"table",
"[1]*(N+3)",
"[1]",
"1",
"N+3",
"N",
"3",
"t=1",
"t",
"1",
"for i in range(1,N+3):\n t*=i\n t%=mod\n table[i]=t",
"i",
"range(1,N+3)",
"range",
"1",
"N+3",
"N",
"3",
"t*=i",
"t",
"i",
"t%=mod",
"t",
"mod",
"table[i]=t",
"table[i]",
"table",
"i",
"t",
"rtable=[1]*(N+3)",
"rtable",
"[1]*(N+3)",
"[1]",
"1",
"N+3",
"N",
"3",
"t=1",
"t",
"1",
"for i in range(1,N+3):\n t*=pow(i,mod-2,mod)\n t%=mod\n rtable[i]=t",
"i",
"range(1,N+3)",
"range",
"1",
"N+3",
"N",
"3",
"t*=pow(i,mod-2,mod)",
"t",
"pow(i,mod-2,mod)",
"pow",
"i",
"mod-2",
"mod",
"2",
"mod",
"t%=mod",
"t",
"mod",
"rtable[i]=t",
"rtable[i]",
"rtable",
"i",
"t",
"ans=0",
"ans",
"0",
"for i in range(H-A):\n t=table[B-1+i]*rtable[i]*rtable[B-1]\n s=table[W+H-B-i-2]*rtable[H-i-1]*rtable[W-B-1]\n t=(t*s)%mod\n #print(t)\n ans+=t\n ans%=mod",
"i",
"range(H-A)",
"range",
"H-A",
"H",
"A",
"t=table[B-1+i]*rtable[i]*rtable[B-1]",
"t",
"table[B-1+i]*rtable[i]*rtable[B-1]",
"table[B-1+i]*rtable[i]",
"table[B-1+i]",
"table",
"B-1+i",
"B-1",
"B",
"1",
"i",
"rtable[i]",
"rtable",
"i",
"rtable[B-1]",
"rtable",
"B-1",
"B",
"1",
"s=table[W+H-B-i-2]*rtable[H-i-1]*rtable[W-B-1]",
"s",
"table[W+H-B-i-2]*rtable[H-i-1]*rtable[W-B-1]",
"table[W+H-B-i-2]*rtable[H-i-1]",
"table[W+H-B-i-2]",
"table",
"W+H-B-i-2",
"W+H-B-i",
"W+H-B",
"W+H",
"W",
"H",
"B",
"i",
"2",
"rtable[H-i-1]",
"rtable",
"H-i-1",
"H-i",
"H",
"i",
"1",
"rtable[W-B-1]",
"rtable",
"W-B-1",
"W-B",
"W",
"B",
"1",
"t=(t*s)%mod",
"t",
"(t*s)%mod",
"t*s",
"t",
"s",
"mod",
"ans+=t",
"ans",
"t",
"ans%=mod",
"ans",
"mod",
"print(ans)",
"print",
"ans",
"t=table[B-1+i]*rtable[i]*rtable[B-1]",
"table[B-1+i]*rtable[i]*rtable[B-1]",
"t",
"mod=10**9+7",
"10**9+7",
"mod",
"t=1",
"1",
"t",
"t*=pow(i,mod-2,mod)",
"pow(i,mod-2,mod)",
"t",
"W,A,B=map(int,input().split())",
"map(int,input().split())",
"W",
"A,B=map(int,input().split())",
"map(int,input().split())",
"A",
"ans=0",
"0",
"ans",
"table=[1]*(N+3)",
"[1]*(N+3)",
"table",
"rtable=[1]*(N+3)",
"[1]*(N+3)",
"rtable",
"t=(t*s)%mod",
"(t*s)%mod",
"t",
"ans+=t",
"t",
"ans",
"s=table[W+H-B-i-2]*rtable[H-i-1]*rtable[W-B-1]",
"table[W+H-B-i-2]*rtable[H-i-1]*rtable[W-B-1]",
"s",
"H,W,A,B=map(int,input().split())",
"map(int,input().split())",
"H",
"N=H+W+2",
"H+W+2",
"N",
"t%=mod",
"mod",
"t",
"t*=i",
"i",
"t",
"t%=mod",
"mod",
"t",
"ans%=mod",
"mod",
"ans",
"t=1",
"1",
"t",
"B=map(int,input().split())",
"map(int,input().split())",
"B"
] | H,W,A,B=map(int,input().split())
N=H+W+2
mod=10**9+7
table=[1]*(N+3)
t=1
for i in range(1,N+3):
t*=i
t%=mod
table[i]=t
rtable=[1]*(N+3)
t=1
for i in range(1,N+3):
t*=pow(i,mod-2,mod)
t%=mod
rtable[i]=t
ans=0
for i in range(H-A):
t=table[B-1+i]*rtable[i]*rtable[B-1]
s=table[W+H-B-i-2]*rtable[H-i-1]*rtable[W-B-1]
t=(t*s)%mod
#print(t)
ans+=t
ans%=mod
print(ans) |
[
7,
0,
13,
4,
13,
13,
4,
18,
4,
13,
13,
13,
13,
13,
0,
13,
17,
12,
13,
14,
2,
13,
17,
14,
2,
13,
17,
14,
2,
2,
13,
17,
17,
23,
13,
23,
13,
0,
13,
39,
17,
28,
13,
4,
13,
17,
2,
2,
13,
13,
17,
4,
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,
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,
0,
13,
17,
28,
13,
4,
13,
2,
13,
13,
0,
13,
2,
18,
13,
2,
2,
2,
2,
13,
13,
13,
13,
17,
13,
0,
13,
2,
2,
13,
18,
13,
2,
2,
13,
13,
17,
13,
0,
13,
2,
2,
13,
18,
13,
2,
2,
13,
13,
17,
13,
0,
13,
2,
2,
13,
18,
13,
2,
2,
13,
13,
17,
13,
0,
13,
2,
2,
13,
18,
13,
13,
13,
0,
13,
2,
2,
13,
18,
13,
2,
13,
17,
13,
0,
13,
13,
4,
13,
2,
13,
13,
10,
4,
13,
10,
2,
13,
10,
2,
13,
10,
39,
13,
10,
17,
13,
10,
2,
13,
10,
4,
13,
10,
2,
13,
10,
13,
13,
10,
4,
13,
10,
2,
13,
10,
4,
13,
10,
12,
13,
10,
2,
13,
10,
17,
13,
10,
2,
13
] | [
[
244,
2
],
[
244,
11
],
[
244,
12
],
[
244,
13
],
[
223,
15
],
[
36,
21
],
[
36,
25
],
[
36,
30
],
[
34,
34
],
[
36,
36
],
[
220,
38
],
[
43,
42
],
[
239,
48
],
[
230,
49
],
[
221,
53
],
[
221,
58
],
[
42,
60
],
[
42,
62
],
[
224,
63
],
[
250,
65
],
[
239,
70
],
[
230,
71
],
[
80,
73
],
[
251,
74
],
[
239,
77
],
[
230,
78
],
[
248,
81
],
[
221,
83
],
[
239,
86
],
[
230,
87
],
[
224,
90
],
[
94,
93
],
[
239,
98
],
[
230,
99
],
[
107,
104
],
[
251,
105
],
[
93,
106
],
[
251,
110
],
[
93,
112
],
[
93,
115
],
[
224,
117
],
[
253,
119
],
[
123,
122
],
[
230,
126
],
[
245,
127
],
[
241,
129
],
[
221,
132
],
[
230,
137
],
[
122,
138
],
[
239,
139
],
[
212,
140
],
[
224,
142
],
[
226,
144
],
[
242,
147
],
[
257,
147
],
[
215,
147
],
[
233,
147
],
[
218,
147
],
[
227,
147
],
[
251,
149
],
[
230,
152
],
[
122,
153
],
[
224,
155
],
[
217,
157
],
[
227,
160
],
[
242,
160
],
[
257,
160
],
[
215,
160
],
[
233,
160
],
[
218,
160
],
[
251,
162
],
[
239,
165
],
[
212,
166
],
[
224,
168
],
[
232,
170
],
[
218,
173
],
[
227,
173
],
[
242,
173
],
[
257,
173
],
[
215,
173
],
[
233,
173
],
[
221,
175
],
[
122,
178
],
[
212,
179
],
[
224,
181
],
[
214,
183
],
[
233,
186
],
[
218,
186
],
[
227,
186
],
[
242,
186
],
[
257,
186
],
[
215,
186
],
[
104,
187
],
[
251,
188
],
[
122,
189
],
[
224,
190
],
[
256,
192
],
[
215,
195
],
[
233,
195
],
[
218,
195
],
[
227,
195
],
[
242,
195
],
[
257,
195
],
[
251,
197
],
[
212,
199
],
[
224,
201
],
[
235,
203
],
[
257,
204
],
[
215,
204
],
[
233,
204
],
[
218,
204
],
[
227,
204
],
[
242,
204
],
[
236,
208
],
[
254,
208
],
[
224,
209
],
[
244,
212
],
[
214,
215
],
[
217,
218
],
[
220,
221
],
[
223,
224
],
[
226,
227
],
[
244,
230
],
[
232,
233
],
[
257,
235
],
[
215,
235
],
[
233,
235
],
[
218,
235
],
[
227,
235
],
[
242,
235
],
[
235,
236
],
[
244,
239
],
[
241,
242
],
[
244,
245
],
[
250,
251
],
[
253,
254
],
[
256,
257
]
] | [
"h, w, a, b = map(int, input().split())\nmod = 1000000007\n\ndef modpow(x, y): \n if y == 0 : return 1\n elif y == 1 : return x % mod\n elif y % 2 == 0 : return modpow(x, y//2)**2 % mod\n else : return modpow(x, y//2)**2 * x % mod\n\nstairs = [1]\nfor i in range(1, h+w+1):\n stairs.append(stairs[i-1]*i%mod)\n\ninverse_stairs = [0]*(h+w)\ninverse_stairs[h+w-1] = modpow(stairs[h+w-1], mod-2)\nfor i in range(h+w-2, -1, -1):\n inverse_stairs[i] = inverse_stairs[i+1] * (i+1) % mod\n \nret = 0\nfor i in range(w-b):\n com = stairs[w-i+h-a-2]%mod\n com = com*inverse_stairs[w-i-1]%mod\n com = com*inverse_stairs[h-a-1]%mod\n com = com*stairs[i+a-1]%mod\n com = com*inverse_stairs[i]%mod\n com = com*inverse_stairs[a-1]%mod\n ret += com\n\nprint(ret%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(x, y): \n if y == 0 : return 1\n elif y == 1 : return x % mod\n elif y % 2 == 0 : return modpow(x, y//2)**2 % mod\n else : return modpow(x, y//2)**2 * x % mod",
"modpow",
"if y == 0 : return 1\n elif y == 1 : return x % mod\n elif y % 2 == 0 : return modpow(x, y//2)**2 % mod\n else : return modpow(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 modpow(x, y//2)**2 % mod\n ",
"y % 2 == 0",
"y % 2",
"y",
"2",
"0",
"x",
"x",
"y",
"y",
"stairs = [1]",
"stairs",
"[1]",
"1",
"for i in range(1, h+w+1):\n stairs.append(stairs[i-1]*i%mod)",
"i",
"range(1, h+w+1)",
"range",
"1",
"h+w+1",
"h+w",
"h",
"w",
"1",
"stairs.append(stairs[i-1]*i%mod)",
"stairs.append",
"stairs",
"append",
"stairs[i-1]*i%mod",
"stairs[i-1]*i",
"stairs[i-1]",
"stairs",
"i-1",
"i",
"1",
"i",
"mod",
"inverse_stairs = [0]*(h+w)",
"inverse_stairs",
"[0]*(h+w)",
"[0]",
"0",
"h+w",
"h",
"w",
"inverse_stairs[h+w-1] = modpow(stairs[h+w-1], mod-2)",
"inverse_stairs[h+w-1]",
"inverse_stairs",
"h+w-1",
"h+w",
"h",
"w",
"1",
"modpow(stairs[h+w-1], mod-2)",
"modpow",
"stairs[h+w-1]",
"stairs",
"h+w-1",
"h+w",
"h",
"w",
"1",
"mod-2",
"mod",
"2",
"for i in range(h+w-2, -1, -1):\n inverse_stairs[i] = inverse_stairs[i+1] * (i+1) % mod\n ",
"i",
"range(h+w-2, -1, -1)",
"range",
"h+w-2",
"h+w",
"h",
"w",
"2",
"-1",
"-1",
"inverse_stairs[i] = inverse_stairs[i+1] * (i+1) % mod",
"inverse_stairs[i]",
"inverse_stairs",
"i",
"inverse_stairs[i+1] * (i+1) % mod",
"inverse_stairs[i+1] * (i+1)",
"inverse_stairs[i+1]",
"inverse_stairs",
"i+1",
"i",
"1",
"i+1",
"i",
"1",
"mod",
"ret = 0",
"ret",
"0",
"for i in range(w-b):\n com = stairs[w-i+h-a-2]%mod\n com = com*inverse_stairs[w-i-1]%mod\n com = com*inverse_stairs[h-a-1]%mod\n com = com*stairs[i+a-1]%mod\n com = com*inverse_stairs[i]%mod\n com = com*inverse_stairs[a-1]%mod\n ret += com",
"i",
"range(w-b)",
"range",
"w-b",
"w",
"b",
"com = stairs[w-i+h-a-2]%mod",
"com",
"stairs[w-i+h-a-2]%mod",
"stairs[w-i+h-a-2]",
"stairs",
"w-i+h-a-2",
"w-i+h-a",
"w-i+h",
"w-i",
"w",
"i",
"h",
"a",
"2",
"mod",
"com = com*inverse_stairs[w-i-1]%mod",
"com",
"com*inverse_stairs[w-i-1]%mod",
"com*inverse_stairs[w-i-1]",
"com",
"inverse_stairs[w-i-1]",
"inverse_stairs",
"w-i-1",
"w-i",
"w",
"i",
"1",
"mod",
"com = com*inverse_stairs[h-a-1]%mod",
"com",
"com*inverse_stairs[h-a-1]%mod",
"com*inverse_stairs[h-a-1]",
"com",
"inverse_stairs[h-a-1]",
"inverse_stairs",
"h-a-1",
"h-a",
"h",
"a",
"1",
"mod",
"com = com*stairs[i+a-1]%mod",
"com",
"com*stairs[i+a-1]%mod",
"com*stairs[i+a-1]",
"com",
"stairs[i+a-1]",
"stairs",
"i+a-1",
"i+a",
"i",
"a",
"1",
"mod",
"com = com*inverse_stairs[i]%mod",
"com",
"com*inverse_stairs[i]%mod",
"com*inverse_stairs[i]",
"com",
"inverse_stairs[i]",
"inverse_stairs",
"i",
"mod",
"com = com*inverse_stairs[a-1]%mod",
"com",
"com*inverse_stairs[a-1]%mod",
"com*inverse_stairs[a-1]",
"com",
"inverse_stairs[a-1]",
"inverse_stairs",
"a-1",
"a",
"1",
"mod",
"ret += com",
"ret",
"com",
"print(ret%mod)",
"print",
"ret%mod",
"ret",
"mod",
"a, b = map(int, input().split())",
"map(int, input().split())",
"a",
"com = com*inverse_stairs[i]%mod",
"com*inverse_stairs[i]%mod",
"com",
"com = com*inverse_stairs[h-a-1]%mod",
"com*inverse_stairs[h-a-1]%mod",
"com",
"stairs = [1]",
"[1]",
"stairs",
"mod = 1000000007",
"1000000007",
"mod",
"com = com*inverse_stairs[w-i-1]%mod",
"com*inverse_stairs[w-i-1]%mod",
"com",
"w, a, b = map(int, input().split())",
"map(int, input().split())",
"w",
"com = com*stairs[i+a-1]%mod",
"com*stairs[i+a-1]%mod",
"com",
"ret += com",
"com",
"ret",
"h, w, a, b = map(int, input().split())",
"map(int, input().split())",
"h",
"com = stairs[w-i+h-a-2]%mod",
"stairs[w-i+h-a-2]%mod",
"com",
"b = map(int, input().split())",
"map(int, input().split())",
"b",
"def modpow(x, y): \n if y == 0 : return 1\n elif y == 1 : return x % mod\n elif y % 2 == 0 : return modpow(x, y//2)**2 % mod\n else : return modpow(x, y//2)**2 * x % mod",
"def modpow(x, y): \n if y == 0 : return 1\n elif y == 1 : return x % mod\n elif y % 2 == 0 : return modpow(x, y//2)**2 % mod\n else : return modpow(x, y//2)**2 * x % mod",
"modpow",
"inverse_stairs = [0]*(h+w)",
"[0]*(h+w)",
"inverse_stairs",
"ret = 0",
"0",
"ret",
"com = com*inverse_stairs[a-1]%mod",
"com*inverse_stairs[a-1]%mod",
"com"
] | h, w, a, b = map(int, input().split())
mod = 1000000007
def modpow(x, y):
if y == 0 : return 1
elif y == 1 : return x % mod
elif y % 2 == 0 : return modpow(x, y//2)**2 % mod
else : return modpow(x, y//2)**2 * x % mod
stairs = [1]
for i in range(1, h+w+1):
stairs.append(stairs[i-1]*i%mod)
inverse_stairs = [0]*(h+w)
inverse_stairs[h+w-1] = modpow(stairs[h+w-1], mod-2)
for i in range(h+w-2, -1, -1):
inverse_stairs[i] = inverse_stairs[i+1] * (i+1) % mod
ret = 0
for i in range(w-b):
com = stairs[w-i+h-a-2]%mod
com = com*inverse_stairs[w-i-1]%mod
com = com*inverse_stairs[h-a-1]%mod
com = com*stairs[i+a-1]%mod
com = com*inverse_stairs[i]%mod
com = com*inverse_stairs[a-1]%mod
ret += com
print(ret%mod) |
[
7,
0,
13,
4,
13,
13,
4,
18,
4,
13,
13,
13,
13,
13,
41,
28,
13,
2,
39,
17,
17,
4,
17,
0,
13,
13,
0,
18,
13,
17,
17,
28,
13,
4,
13,
17,
17,
0,
18,
13,
13,
2,
2,
13,
18,
13,
2,
13,
17,
2,
2,
17,
17,
17,
12,
13,
23,
13,
23,
13,
2,
2,
17,
17,
17,
12,
13,
23,
13,
23,
13,
23,
13,
2,
2,
17,
17,
17,
0,
13,
17,
28,
13,
4,
13,
2,
13,
13,
0,
13,
2,
2,
13,
2,
4,
13,
2,
2,
13,
13,
17,
2,
13,
17,
4,
13,
2,
2,
2,
2,
13,
13,
13,
13,
17,
2,
2,
13,
13,
17,
2,
2,
17,
17,
17,
4,
13,
13,
10,
4,
13,
10,
2,
13,
10,
4,
13,
10,
17,
13,
10,
12,
13,
10,
4,
13,
10,
4,
13,
10,
13,
13,
10,
12,
13
] | [
[
147,
2
],
[
147,
11
],
[
147,
12
],
[
147,
13
],
[
17,
16
],
[
150,
24
],
[
30,
27
],
[
151,
28
],
[
33,
32
],
[
41,
38
],
[
151,
39
],
[
32,
40
],
[
32,
43
],
[
151,
45
],
[
32,
47
],
[
57,
57
],
[
60,
59
],
[
68,
68
],
[
70,
70
],
[
73,
72
],
[
138,
79
],
[
83,
82
],
[
136,
86
],
[
145,
87
],
[
132,
89
],
[
139,
92
],
[
133,
92
],
[
142,
95
],
[
82,
98
],
[
130,
99
],
[
130,
102
],
[
142,
105
],
[
136,
110
],
[
148,
111
],
[
130,
112
],
[
82,
113
],
[
148,
117
],
[
130,
118
],
[
133,
127
],
[
139,
127
],
[
147,
130
],
[
132,
133
],
[
147,
136
],
[
138,
139
],
[
147,
145
],
[
147,
148
],
[
150,
151
]
] | [
"h,w,a,b=map(int,input().split())\nn_func=[None for _ in [0]*200001]\nn_func[0]=1\nfor i in range(1,200001):\n n_func[i]=(i*n_func[i-1])%(10**9+7)\ndef inv_n(n,mod=10**9+7):return pow(n,mod-2,mod)\ndef nCr(n,r,mod=10**9+7):return inv_n(n_func[n-r]*n_func[r]%mod,mod)*n_func[n]%mod\n\ncnt=0\nfor i in range(h-a):\n cnt=(cnt+nCr(i+b-1,b-1)*nCr(h+w-b-i-2,w-b-1))%(10**9+7)\nprint(cnt)",
"h,w,a,b=map(int,input().split())",
"h",
"map(int,input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"w",
"a",
"b",
"None for _ in [0]*200001",
"for _ in [0]*200001",
"_",
"[0]*200001",
"[0]",
"0",
"200001",
"for _ in [0]*200001",
"None",
"n_func=[None for _ in [0]*200001]",
"n_func",
"[None for _ in [0]*200001]",
"n_func[0]=1",
"n_func[0]",
"n_func",
"0",
"1",
"for i in range(1,200001):\n n_func[i]=(i*n_func[i-1])%(10**9+7)",
"i",
"range(1,200001)",
"range",
"1",
"200001",
"n_func[i]=(i*n_func[i-1])%(10**9+7)",
"n_func[i]",
"n_func",
"i",
"(i*n_func[i-1])%(10**9+7)",
"i*n_func[i-1]",
"i",
"n_func[i-1]",
"n_func",
"i-1",
"i",
"1",
"10**9+7",
"10**9",
"10",
"9",
"7",
"def inv_n(n,mod=10**9+7):return pow(n,mod-2,mod)",
"inv_n",
"n",
"n",
"mod=10**9+7",
"mod",
"10**9+7",
"10**9",
"10",
"9",
"7",
"def nCr(n,r,mod=10**9+7):return inv_n(n_func[n-r]*n_func[r]%mod,mod)*n_func[n]%mod",
"nCr",
"n",
"n",
"r",
"r",
"mod=10**9+7",
"mod",
"10**9+7",
"10**9",
"10",
"9",
"7",
"cnt=0",
"cnt",
"0",
"for i in range(h-a):\n cnt=(cnt+nCr(i+b-1,b-1)*nCr(h+w-b-i-2,w-b-1))%(10**9+7)",
"i",
"range(h-a)",
"range",
"h-a",
"h",
"a",
"cnt=(cnt+nCr(i+b-1,b-1)*nCr(h+w-b-i-2,w-b-1))%(10**9+7)",
"cnt",
"(cnt+nCr(i+b-1,b-1)*nCr(h+w-b-i-2,w-b-1))%(10**9+7)",
"cnt+nCr(i+b-1,b-1)*nCr(h+w-b-i-2,w-b-1)",
"cnt",
"nCr(i+b-1,b-1)*nCr(h+w-b-i-2,w-b-1)",
"nCr(i+b-1,b-1)",
"nCr",
"i+b-1",
"i+b",
"i",
"b",
"1",
"b-1",
"b",
"1",
"nCr(h+w-b-i-2,w-b-1)",
"nCr",
"h+w-b-i-2",
"h+w-b-i",
"h+w-b",
"h+w",
"h",
"w",
"b",
"i",
"2",
"w-b-1",
"w-b",
"w",
"b",
"1",
"10**9+7",
"10**9",
"10",
"9",
"7",
"print(cnt)",
"print",
"cnt",
"b=map(int,input().split())",
"map(int,input().split())",
"b",
"cnt=(cnt+nCr(i+b-1,b-1)*nCr(h+w-b-i-2,w-b-1))%(10**9+7)",
"(cnt+nCr(i+b-1,b-1)*nCr(h+w-b-i-2,w-b-1))%(10**9+7)",
"cnt",
"h,w,a,b=map(int,input().split())",
"map(int,input().split())",
"h",
"cnt=0",
"0",
"cnt",
"def nCr(n,r,mod=10**9+7):return inv_n(n_func[n-r]*n_func[r]%mod,mod)*n_func[n]%mod",
"def nCr(n,r,mod=10**9+7):return inv_n(n_func[n-r]*n_func[r]%mod,mod)*n_func[n]%mod",
"nCr",
"a,b=map(int,input().split())",
"map(int,input().split())",
"a",
"w,a,b=map(int,input().split())",
"map(int,input().split())",
"w",
"n_func=[None for _ in [0]*200001]",
"[None for _ in [0]*200001]",
"n_func",
"def inv_n(n,mod=10**9+7):return pow(n,mod-2,mod)",
"def inv_n(n,mod=10**9+7):return pow(n,mod-2,mod)",
"inv_n"
] | h,w,a,b=map(int,input().split())
n_func=[None for _ in [0]*200001]
n_func[0]=1
for i in range(1,200001):
n_func[i]=(i*n_func[i-1])%(10**9+7)
def inv_n(n,mod=10**9+7):return pow(n,mod-2,mod)
def nCr(n,r,mod=10**9+7):return inv_n(n_func[n-r]*n_func[r]%mod,mod)*n_func[n]%mod
cnt=0
for i in range(h-a):
cnt=(cnt+nCr(i+b-1,b-1)*nCr(h+w-b-i-2,w-b-1))%(10**9+7)
print(cnt) |
[
7,
0,
13,
4,
13,
13,
4,
18,
4,
13,
13,
13,
13,
13,
0,
13,
2,
2,
17,
17,
17,
0,
13,
2,
17,
2,
17,
17,
41,
28,
13,
4,
13,
2,
13,
17,
4,
17,
0,
13,
13,
28,
13,
4,
13,
17,
2,
13,
17,
0,
18,
13,
13,
2,
2,
18,
13,
2,
13,
17,
13,
13,
41,
28,
13,
4,
13,
2,
13,
17,
4,
17,
0,
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,
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,
17,
13,
10,
2,
13,
10,
4,
13,
10,
12,
13,
10,
2,
13,
10,
13,
13,
10,
4,
13,
10,
4,
13,
10,
4,
13,
10,
13,
13,
10,
4,
13,
10,
13,
13,
10,
13,
13,
10,
4,
13,
10,
13,
13,
10,
2,
13,
10,
2,
13
] | [
[
243,
2
],
[
243,
11
],
[
243,
12
],
[
243,
13
],
[
252,
15
],
[
216,
22
],
[
31,
30
],
[
217,
34
],
[
246,
39
],
[
43,
42
],
[
217,
47
],
[
53,
50
],
[
247,
51
],
[
42,
52
],
[
247,
56
],
[
42,
58
],
[
42,
60
],
[
253,
61
],
[
65,
64
],
[
217,
68
],
[
219,
73
],
[
79,
76
],
[
220,
77
],
[
217,
78
],
[
247,
82
],
[
217,
83
],
[
253,
85
],
[
253,
87
],
[
90,
89
],
[
217,
92
],
[
101,
96
],
[
220,
97
],
[
89,
99
],
[
220,
104
],
[
89,
105
],
[
89,
106
],
[
253,
107
],
[
148,
113
],
[
148,
116
],
[
146,
117
],
[
122,
121
],
[
247,
123
],
[
146,
124
],
[
127,
126
],
[
220,
128
],
[
148,
129
],
[
132,
131
],
[
253,
132
],
[
135,
134
],
[
220,
136
],
[
146,
138
],
[
148,
139
],
[
142,
141
],
[
253,
142
],
[
141,
144
],
[
134,
144
],
[
131,
144
],
[
126,
144
],
[
121,
144
],
[
146,
146
],
[
148,
148
],
[
204,
150
],
[
154,
153
],
[
244,
157
],
[
235,
158
],
[
210,
160
],
[
214,
162
],
[
229,
165
],
[
153,
167
],
[
153,
168
],
[
207,
170
],
[
244,
173
],
[
153,
175
],
[
249,
177
],
[
226,
180
],
[
229,
182
],
[
222,
184
],
[
214,
186
],
[
208,
188
],
[
250,
189
],
[
208,
190
],
[
240,
192
],
[
253,
193
],
[
237,
195
],
[
241,
196
],
[
223,
196
],
[
211,
196
],
[
231,
198
],
[
253,
199
],
[
232,
202
],
[
238,
202
],
[
205,
202
],
[
204,
205
],
[
207,
208
],
[
210,
211
],
[
216,
217
],
[
219,
220
],
[
222,
223
],
[
243,
226
],
[
243,
229
],
[
253,
231
],
[
231,
232
],
[
243,
235
],
[
241,
237
],
[
223,
237
],
[
211,
237
],
[
237,
238
],
[
253,
240
],
[
240,
241
],
[
243,
244
],
[
246,
247
],
[
249,
250
],
[
252,
253
]
] | [
"H, W, A, B = map(int, input().split())\nmod = 10**9 + 7\nU = 2 * 10**5\n\nfactorial = [1 for _ in range(U + 1)]\nfor i in range(1, U + 1):\n factorial[i] = (factorial[i - 1] * i) % mod\n\ninverse = [1 for _ in range(U + 1)]\ninverse[U] = pow(factorial[U], mod - 2, mod)\nfor i in range(U, 0, -1):\n inverse[i - 1] = (inverse[i] * i) % mod\n\n\ndef comb(n, k):\n if k < 0 or k > n:\n return 0\n x = factorial[n]\n x *= inverse[k]\n x %= mod\n x *= inverse[n - k]\n x %= mod\n return x\n \n \nans = 0\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)",
"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",
"U = 2 * 10**5",
"U",
"2 * 10**5",
"2",
"10**5",
"10",
"5",
"1 for _ in range(U + 1)",
"for _ in range(U + 1)",
"_",
"range(U + 1)",
"range",
"U + 1",
"U",
"1",
"for _ in range(U + 1)",
"1",
"factorial = [1 for _ in range(U + 1)]",
"factorial",
"[1 for _ in range(U + 1)]",
"for i in range(1, U + 1):\n factorial[i] = (factorial[i - 1] * i) % mod",
"i",
"range(1, U + 1)",
"range",
"1",
"U + 1",
"U",
"1",
"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",
"1 for _ in range(U + 1)",
"for _ in range(U + 1)",
"_",
"range(U + 1)",
"range",
"U + 1",
"U",
"1",
"for _ in range(U + 1)",
"1",
"inverse = [1 for _ in range(U + 1)]",
"inverse",
"[1 for _ in range(U + 1)]",
"inverse[U] = pow(factorial[U], mod - 2, mod)",
"inverse[U]",
"inverse",
"U",
"pow(factorial[U], mod - 2, mod)",
"pow",
"factorial[U]",
"factorial",
"U",
"mod - 2",
"mod",
"2",
"mod",
"for i in range(U, 0, -1):\n inverse[i - 1] = (inverse[i] * i) % mod",
"i",
"range(U, 0, -1)",
"range",
"U",
"0",
"-1",
"inverse[i - 1] = (inverse[i] * i) % mod",
"inverse[i - 1]",
"inverse",
"i - 1",
"i",
"1",
"(inverse[i] * i) % mod",
"inverse[i] * i",
"inverse[i]",
"inverse",
"i",
"i",
"mod",
"def comb(n, k):\n if k < 0 or k > n:\n return 0\n x = factorial[n]\n x *= inverse[k]\n x %= mod\n x *= inverse[n - k]\n x %= mod\n return x\n \n ",
"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",
"x = factorial[n]",
"x",
"factorial[n]",
"factorial",
"n",
"x *= inverse[k]",
"x",
"inverse[k]",
"inverse",
"k",
"x %= mod",
"x",
"mod",
"x *= inverse[n - k]",
"x",
"inverse[n - k]",
"inverse",
"n - k",
"n",
"k",
"x %= mod",
"x",
"mod",
"return x",
"x",
"n",
"n",
"k",
"k",
"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",
"ans = 0",
"0",
"ans",
"a = H - 1 - i",
"H - 1 - i",
"a",
"x = comb(B - 1 + i, i)",
"comb(B - 1 + i, i)",
"x",
"def comb(n, k):\n if k < 0 or k > n:\n return 0\n x = factorial[n]\n x *= inverse[k]\n x %= mod\n x *= inverse[n - k]\n x %= mod\n return x\n \n ",
"def comb(n, k):\n if k < 0 or k > n:\n return 0\n x = factorial[n]\n x *= inverse[k]\n x %= mod\n x *= inverse[n - k]\n x %= mod\n return x\n \n ",
"comb",
"U = 2 * 10**5",
"2 * 10**5",
"U",
"inverse = [1 for _ in range(U + 1)]",
"[1 for _ in range(U + 1)]",
"inverse",
"x *= comb(a + b, a)",
"comb(a + b, a)",
"x",
"W, A, B = map(int, input().split())",
"map(int, input().split())",
"W",
"B = map(int, input().split())",
"map(int, input().split())",
"B",
"ans %= mod",
"mod",
"ans",
"A, B = map(int, input().split())",
"map(int, input().split())",
"A",
"ans += x",
"x",
"ans",
"x %= mod",
"mod",
"x",
"H, W, A, B = map(int, input().split())",
"map(int, input().split())",
"H",
"factorial = [1 for _ in range(U + 1)]",
"[1 for _ in range(U + 1)]",
"factorial",
"b = W - 1 - B",
"W - 1 - B",
"b",
"mod = 10**9 + 7",
"10**9 + 7",
"mod"
] | H, W, A, B = map(int, input().split())
mod = 10**9 + 7
U = 2 * 10**5
factorial = [1 for _ in range(U + 1)]
for i in range(1, U + 1):
factorial[i] = (factorial[i - 1] * i) % mod
inverse = [1 for _ in range(U + 1)]
inverse[U] = pow(factorial[U], mod - 2, mod)
for i in range(U, 0, -1):
inverse[i - 1] = (inverse[i] * i) % mod
def comb(n, k):
if k < 0 or k > n:
return 0
x = factorial[n]
x *= inverse[k]
x %= mod
x *= inverse[n - k]
x %= mod
return x
ans = 0
for i in range(H - A):
x = comb(B - 1 + i, i)
a = H - 1 - i
b = W - 1 - B
x *= comb(a + b, a)
x %= mod
ans += x
ans %= mod
print(ans)
|
[
7,
0,
13,
4,
13,
13,
4,
18,
4,
13,
13,
13,
13,
13,
0,
13,
2,
2,
17,
17,
17,
12,
13,
0,
13,
17,
0,
13,
39,
17,
28,
13,
4,
13,
17,
2,
13,
17,
0,
13,
13,
0,
13,
13,
4,
18,
13,
13,
13,
0,
13,
4,
13,
13,
2,
13,
17,
13,
0,
13,
2,
39,
17,
2,
13,
17,
0,
18,
13,
13,
13,
28,
13,
4,
13,
13,
17,
17,
0,
13,
13,
0,
13,
13,
0,
18,
13,
2,
13,
17,
13,
29,
39,
13,
13,
23,
13,
23,
13,
0,
13,
4,
13,
2,
2,
13,
13,
17,
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,
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,
13,
17,
13,
18,
13,
2,
2,
13,
13,
17,
13,
4,
13,
2,
13,
13,
10,
4,
13,
10,
4,
13,
10,
4,
13,
10,
4,
13,
10,
2,
13,
10,
12,
13,
10,
4,
13,
10,
4,
13,
10,
2,
13,
10,
17,
13
] | [
[
200,
2
],
[
200,
11
],
[
200,
12
],
[
200,
13
],
[
194,
15
],
[
25,
24
],
[
28,
27
],
[
32,
31
],
[
96,
36
],
[
40,
39
],
[
31,
40
],
[
43,
42
],
[
98,
43
],
[
27,
46
],
[
42,
48
],
[
39,
48
],
[
24,
48
],
[
51,
50
],
[
42,
53
],
[
39,
53
],
[
24,
53
],
[
98,
55
],
[
98,
57
],
[
60,
59
],
[
96,
64
],
[
70,
67
],
[
59,
68
],
[
96,
69
],
[
50,
70
],
[
73,
72
],
[
96,
75
],
[
80,
79
],
[
72,
80
],
[
83,
82
],
[
98,
83
],
[
90,
85
],
[
59,
86
],
[
72,
88
],
[
82,
90
],
[
79,
90
],
[
50,
90
],
[
96,
96
],
[
98,
98
],
[
203,
100
],
[
198,
102
],
[
189,
105
],
[
201,
106
],
[
195,
108
],
[
203,
109
],
[
209,
111
],
[
115,
114
],
[
192,
117
],
[
201,
118
],
[
206,
120
],
[
186,
127
],
[
189,
131
],
[
183,
132
],
[
114,
134
],
[
204,
136
],
[
189,
139
],
[
183,
140
],
[
195,
142
],
[
204,
144
],
[
114,
145
],
[
195,
146
],
[
186,
152
],
[
183,
157
],
[
201,
159
],
[
114,
160
],
[
204,
163
],
[
183,
165
],
[
195,
167
],
[
204,
169
],
[
201,
172
],
[
114,
173
],
[
195,
175
],
[
207,
179
],
[
210,
179
],
[
195,
180
],
[
200,
183
],
[
203,
186
],
[
200,
189
],
[
200,
192
],
[
194,
195
],
[
200,
201
],
[
203,
204
],
[
206,
207
],
[
209,
210
]
] | [
"H, W, A, B = map(int,input().split())\nMOD = 10**9 + 7\ndef prepare(n, MOD):\n\n # 1! - n! の計算\n f = 1\n factorials = [1] # 0!の分\n for m in range(1, n + 1):\n f *= m\n f %= MOD\n factorials.append(f)\n # n!^-1 の計算\n inv = pow(f, MOD - 2, MOD)\n # n!^-1 - 1!^-1 の計算\n invs = [1] * (n + 1)\n invs[n] = inv\n for m in range(n, 1, -1):\n inv *= m\n inv %= MOD\n invs[m - 1] = inv\n\n return factorials, invs\n\nfactorials, invs = prepare(H+W+1,MOD)\nans = 0\nfor b in range(B,W):\n ans += (factorials[H-A-1+b] * invs[H-A-1] % MOD * invs[b] % MOD) * (factorials[A-1+W-b-1] * invs[A-1] % MOD * invs[W-b-1] % 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",
"def prepare(n, MOD):\n\n # 1! - n! の計算\n f = 1\n factorials = [1] # 0!の分\n for m in range(1, n + 1):\n f *= m\n f %= MOD\n factorials.append(f)\n # n!^-1 の計算\n inv = pow(f, MOD - 2, MOD)\n # n!^-1 - 1!^-1 の計算\n invs = [1] * (n + 1)\n invs[n] = inv\n for m in range(n, 1, -1):\n inv *= m\n inv %= MOD\n invs[m - 1] = inv\n\n return factorials, invs",
"prepare",
"f = 1",
"f",
"1",
"factorials = [1]",
"factorials",
"[1]",
"1",
"for m in range(1, n + 1):\n f *= m\n f %= MOD\n factorials.append(f)\n # n!^-1 の計算\n ",
"m",
"range(1, n + 1)",
"range",
"1",
"n + 1",
"n",
"1",
"f *= m",
"f",
"m",
"f %= MOD",
"f",
"MOD",
"factorials.append(f)",
"factorials.append",
"factorials",
"append",
"f",
"inv = pow(f, MOD - 2, MOD)",
"inv",
"pow(f, MOD - 2, MOD)",
"pow",
"f",
"MOD - 2",
"MOD",
"2",
"MOD",
"invs = [1] * (n + 1)",
"invs",
"[1] * (n + 1)",
"[1]",
"1",
"n + 1",
"n",
"1",
"invs[n] = inv",
"invs[n]",
"invs",
"n",
"inv",
"for m in range(n, 1, -1):\n inv *= m\n inv %= MOD\n invs[m - 1] = inv\n\n ",
"m",
"range(n, 1, -1)",
"range",
"n",
"1",
"-1",
"inv *= m",
"inv",
"m",
"inv %= MOD",
"inv",
"MOD",
"invs[m - 1] = inv",
"invs[m - 1]",
"invs",
"m - 1",
"m",
"1",
"inv",
"return factorials, invs",
"return factorials, invs",
"factorials",
"invs",
"n",
"n",
"MOD",
"MOD",
"factorials, invs = prepare(H+W+1,MOD)",
"factorials",
"prepare(H+W+1,MOD)",
"prepare",
"H+W+1",
"H+W",
"H",
"W",
"1",
"MOD",
"invs",
"ans = 0",
"ans",
"0",
"for b in range(B,W):\n ans += (factorials[H-A-1+b] * invs[H-A-1] % MOD * invs[b] % MOD) * (factorials[A-1+W-b-1] * invs[A-1] % MOD * invs[W-b-1] % MOD)",
"b",
"range(B,W)",
"range",
"B",
"W",
"ans += (factorials[H-A-1+b] * invs[H-A-1] % MOD * invs[b] % MOD) * (factorials[A-1+W-b-1] * invs[A-1] % MOD * invs[W-b-1] % MOD)",
"ans",
"(factorials[H-A-1+b] * invs[H-A-1] % MOD * invs[b] % MOD) * (factorials[A-1+W-b-1] * invs[A-1] % MOD * invs[W-b-1] % MOD)",
"factorials[H-A-1+b] * invs[H-A-1] % MOD * invs[b] % MOD",
"factorials[H-A-1+b] * invs[H-A-1] % MOD * invs[b]",
"factorials[H-A-1+b] * invs[H-A-1] % MOD",
"factorials[H-A-1+b] * invs[H-A-1]",
"factorials[H-A-1+b]",
"factorials",
"H-A-1+b",
"H-A-1",
"H-A",
"H",
"A",
"1",
"b",
"invs[H-A-1]",
"invs",
"H-A-1",
"H-A",
"H",
"A",
"1",
"MOD",
"invs[b]",
"invs",
"b",
"MOD",
"factorials[A-1+W-b-1] * invs[A-1] % MOD * invs[W-b-1] % MOD",
"factorials[A-1+W-b-1] * invs[A-1] % MOD * invs[W-b-1]",
"factorials[A-1+W-b-1] * invs[A-1] % MOD",
"factorials[A-1+W-b-1] * invs[A-1]",
"factorials[A-1+W-b-1]",
"factorials",
"A-1+W-b-1",
"A-1+W-b",
"A-1+W",
"A-1",
"A",
"1",
"W",
"b",
"1",
"invs[A-1]",
"invs",
"A-1",
"A",
"1",
"MOD",
"invs[W-b-1]",
"invs",
"W-b-1",
"W-b",
"W",
"b",
"1",
"MOD",
"print(ans % MOD)",
"print",
"ans % MOD",
"ans",
"MOD",
"A, B = map(int,input().split())",
"map(int,input().split())",
"A",
"factorials, invs = prepare(H+W+1,MOD)",
"prepare(H+W+1,MOD)",
"factorials",
"H, W, A, B = map(int,input().split())",
"map(int,input().split())",
"H",
"B = map(int,input().split())",
"map(int,input().split())",
"B",
"MOD = 10**9 + 7",
"10**9 + 7",
"MOD",
"def prepare(n, MOD):\n\n # 1! - n! の計算\n f = 1\n factorials = [1] # 0!の分\n for m in range(1, n + 1):\n f *= m\n f %= MOD\n factorials.append(f)\n # n!^-1 の計算\n inv = pow(f, MOD - 2, MOD)\n # n!^-1 - 1!^-1 の計算\n invs = [1] * (n + 1)\n invs[n] = inv\n for m in range(n, 1, -1):\n inv *= m\n inv %= MOD\n invs[m - 1] = inv\n\n return factorials, invs",
"def prepare(n, MOD):\n\n # 1! - n! の計算\n f = 1\n factorials = [1] # 0!の分\n for m in range(1, n + 1):\n f *= m\n f %= MOD\n factorials.append(f)\n # n!^-1 の計算\n inv = pow(f, MOD - 2, MOD)\n # n!^-1 - 1!^-1 の計算\n invs = [1] * (n + 1)\n invs[n] = inv\n for m in range(n, 1, -1):\n inv *= m\n inv %= MOD\n invs[m - 1] = inv\n\n return factorials, invs",
"prepare",
"W, A, B = map(int,input().split())",
"map(int,input().split())",
"W",
"invs = prepare(H+W+1,MOD)",
"prepare(H+W+1,MOD)",
"invs",
"ans += (factorials[H-A-1+b] * invs[H-A-1] % MOD * invs[b] % MOD) * (factorials[A-1+W-b-1] * invs[A-1] % MOD * invs[W-b-1] % MOD)",
"(factorials[H-A-1+b] * invs[H-A-1] % MOD * invs[b] % MOD) * (factorials[A-1+W-b-1] * invs[A-1] % MOD * invs[W-b-1] % MOD)",
"ans",
"ans = 0",
"0",
"ans"
] | H, W, A, B = map(int,input().split())
MOD = 10**9 + 7
def prepare(n, MOD):
# 1! - n! の計算
f = 1
factorials = [1] # 0!の分
for m in range(1, n + 1):
f *= m
f %= MOD
factorials.append(f)
# n!^-1 の計算
inv = pow(f, MOD - 2, MOD)
# n!^-1 - 1!^-1 の計算
invs = [1] * (n + 1)
invs[n] = inv
for m in range(n, 1, -1):
inv *= m
inv %= MOD
invs[m - 1] = inv
return factorials, invs
factorials, invs = prepare(H+W+1,MOD)
ans = 0
for b in range(B,W):
ans += (factorials[H-A-1+b] * invs[H-A-1] % MOD * invs[b] % MOD) * (factorials[A-1+W-b-1] * invs[A-1] % MOD * invs[W-b-1] % MOD)
print(ans % MOD) |
[
7,
15,
13,
0,
13,
18,
18,
13,
13,
13,
0,
13,
4,
13,
13,
4,
18,
4,
13,
13,
13,
13,
13,
0,
13,
2,
2,
17,
17,
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,
18,
13,
2,
13,
17,
13,
13,
0,
18,
13,
17,
4,
13,
18,
13,
17,
2,
13,
17,
13,
28,
13,
18,
4,
13,
17,
2,
13,
17,
39,
17,
0,
18,
13,
2,
13,
17,
2,
2,
18,
13,
13,
13,
13,
12,
13,
14,
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,
0,
13,
17,
28,
13,
4,
13,
2,
13,
17,
2,
13,
17,
0,
13,
2,
4,
13,
2,
2,
13,
17,
2,
2,
13,
13,
17,
2,
13,
17,
4,
13,
2,
2,
13,
17,
2,
13,
13,
2,
13,
17,
0,
13,
13,
4,
13,
13,
10,
4,
13,
10,
4,
13,
10,
4,
13,
10,
4,
13,
10,
18,
13,
10,
2,
13,
10,
17,
13,
10,
17,
13,
10,
2,
13,
10,
2,
13,
10,
2,
13,
10,
12,
13,
10,
13,
13
] | [
[
196,
4
],
[
193,
11
],
[
197,
18
],
[
193,
20
],
[
193,
21
],
[
193,
22
],
[
199,
24
],
[
202,
31
],
[
211,
34
],
[
203,
39
],
[
214,
42
],
[
203,
47
],
[
51,
50
],
[
203,
55
],
[
61,
58
],
[
212,
59
],
[
50,
60
],
[
212,
64
],
[
50,
66
],
[
50,
68
],
[
200,
69
],
[
74,
71
],
[
215,
72
],
[
212,
77
],
[
200,
80
],
[
200,
82
],
[
85,
84
],
[
203,
90
],
[
100,
95
],
[
215,
96
],
[
84,
98
],
[
215,
103
],
[
84,
104
],
[
84,
105
],
[
200,
106
],
[
134,
111
],
[
132,
112
],
[
212,
120
],
[
132,
121
],
[
215,
123
],
[
134,
124
],
[
215,
126
],
[
132,
128
],
[
134,
129
],
[
200,
130
],
[
132,
132
],
[
134,
134
],
[
205,
136
],
[
140,
139
],
[
194,
143
],
[
191,
146
],
[
208,
149
],
[
218,
152
],
[
139,
155
],
[
188,
159
],
[
185,
160
],
[
139,
163
],
[
218,
166
],
[
185,
169
],
[
191,
172
],
[
139,
173
],
[
185,
175
],
[
220,
178
],
[
200,
179
],
[
221,
182
],
[
209,
182
],
[
206,
182
],
[
193,
185
],
[
193,
188
],
[
193,
191
],
[
193,
194
],
[
196,
197
],
[
199,
200
],
[
202,
203
],
[
205,
206
],
[
208,
209
],
[
211,
212
],
[
214,
215
],
[
200,
220
],
[
220,
221
]
] | [
"import sys\ninput = sys.stdin.readline\nH,W,A,B= map(int,input().split())\n\nMOD = 10**9 + 7\nnum = 200010\nfact = [1] * (num+1)\nifact = [1] * (num+1)\n\nfor i in range(1,num+1):\n fact[i] = (fact[i-1] * i) % MOD\nifact[-1] = pow(fact[-1],MOD-2,MOD)\nfor i in range(1,num+1)[::-1]:\n ifact[i-1] = (ifact[i] * i)% MOD\n\ndef nCr(n,r):\n if r > n:\n return 0\n return (fact[n] * ifact[r] * ifact[n-r]) % MOD\n\nans = 0\nfor i in range(B+1,W+1):\n ans += nCr((i-1)+(H-A-1),i-1) * nCr((A-1)+(W-i),A-1)\n ans %= MOD\nprint(ans)",
"import sys",
"sys",
"input = sys.stdin.readline",
"input",
"sys.stdin.readline",
"sys.stdin",
"sys",
"stdin",
"readline",
"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",
"num = 200010",
"num",
"200010",
"fact = [1] * (num+1)",
"fact",
"[1] * (num+1)",
"[1]",
"1",
"num+1",
"num",
"1",
"ifact = [1] * (num+1)",
"ifact",
"[1] * (num+1)",
"[1]",
"1",
"num+1",
"num",
"1",
"for i in range(1,num+1):\n fact[i] = (fact[i-1] * i) % MOD",
"i",
"range(1,num+1)",
"range",
"1",
"num+1",
"num",
"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",
"ifact[-1] = pow(fact[-1],MOD-2,MOD)",
"ifact[-1]",
"ifact",
"-1",
"pow(fact[-1],MOD-2,MOD)",
"pow",
"fact[-1]",
"fact",
"-1",
"MOD-2",
"MOD",
"2",
"MOD",
"for i in range(1,num+1)[::-1]:\n ifact[i-1] = (ifact[i] * i)% MOD",
"i",
"range(1,num+1)[::-1]",
"(1,num+1)",
"range",
"1",
"num+1",
"num",
"1",
"::-1",
"-1",
"ifact[i-1] = (ifact[i] * i)% MOD",
"ifact[i-1]",
"ifact",
"i-1",
"i",
"1",
"(ifact[i] * i)% MOD",
"ifact[i] * i",
"ifact[i]",
"ifact",
"i",
"i",
"MOD",
"def nCr(n,r):\n if r > n:\n return 0\n return (fact[n] * ifact[r] * ifact[n-r]) % MOD",
"nCr",
"if r > n:\n return 0\n ",
"r > n",
"r",
"n",
"return 0",
"0",
"return (fact[n] * ifact[r] * ifact[n-r]) % MOD",
"(fact[n] * ifact[r] * ifact[n-r]) % MOD",
"fact[n] * ifact[r] * ifact[n-r]",
"fact[n] * ifact[r]",
"fact[n]",
"fact",
"n",
"ifact[r]",
"ifact",
"r",
"ifact[n-r]",
"ifact",
"n-r",
"n",
"r",
"MOD",
"n",
"n",
"r",
"r",
"ans = 0",
"ans",
"0",
"for i in range(B+1,W+1):\n ans += nCr((i-1)+(H-A-1),i-1) * nCr((A-1)+(W-i),A-1)\n ans %= MOD",
"i",
"range(B+1,W+1)",
"range",
"B+1",
"B",
"1",
"W+1",
"W",
"1",
"ans += nCr((i-1)+(H-A-1),i-1) * nCr((A-1)+(W-i),A-1)",
"ans",
"nCr((i-1)+(H-A-1),i-1) * nCr((A-1)+(W-i),A-1)",
"nCr((i-1)+(H-A-1),i-1)",
"nCr",
"(i-1)+(H-A-1)",
"i-1",
"i",
"1",
"H-A-1",
"H-A",
"H",
"A",
"1",
"i-1",
"i",
"1",
"nCr((A-1)+(W-i),A-1)",
"nCr",
"(A-1)+(W-i)",
"A-1",
"A",
"1",
"W-i",
"W",
"i",
"A-1",
"A",
"1",
"ans %= MOD",
"ans",
"MOD",
"print(ans)",
"print",
"ans",
"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",
"B= map(int,input().split())",
"map(int,input().split())",
"B",
"input = sys.stdin.readline",
"sys.stdin.readline",
"input",
"MOD = 10**9 + 7",
"10**9 + 7",
"MOD",
"num = 200010",
"200010",
"num",
"ans = 0",
"0",
"ans",
"ans += nCr((i-1)+(H-A-1),i-1) * nCr((A-1)+(W-i),A-1)",
"nCr((i-1)+(H-A-1),i-1) * nCr((A-1)+(W-i),A-1)",
"ans",
"fact = [1] * (num+1)",
"[1] * (num+1)",
"fact",
"ifact = [1] * (num+1)",
"[1] * (num+1)",
"ifact",
"def nCr(n,r):\n if r > n:\n return 0\n return (fact[n] * ifact[r] * ifact[n-r]) % MOD",
"def nCr(n,r):\n if r > n:\n return 0\n return (fact[n] * ifact[r] * ifact[n-r]) % MOD",
"nCr",
"ans %= MOD",
"MOD",
"ans"
] | import sys
input = sys.stdin.readline
H,W,A,B= map(int,input().split())
MOD = 10**9 + 7
num = 200010
fact = [1] * (num+1)
ifact = [1] * (num+1)
for i in range(1,num+1):
fact[i] = (fact[i-1] * i) % MOD
ifact[-1] = pow(fact[-1],MOD-2,MOD)
for i in range(1,num+1)[::-1]:
ifact[i-1] = (ifact[i] * i)% MOD
def nCr(n,r):
if r > n:
return 0
return (fact[n] * ifact[r] * ifact[n-r]) % MOD
ans = 0
for i in range(B+1,W+1):
ans += nCr((i-1)+(H-A-1),i-1) * nCr((A-1)+(W-i),A-1)
ans %= MOD
print(ans)
|
[
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,
2,
13,
17,
13,
13,
17,
2,
13,
17,
13,
13,
4,
13,
2,
13,
13,
10,
2,
13,
10,
4,
13,
10,
17,
13,
10,
4,
13,
10,
2,
13,
10,
4,
13,
10,
12,
13,
10,
39,
13,
10,
4,
13
] | [
[
151,
2
],
[
151,
11
],
[
151,
12
],
[
151,
13
],
[
139,
15
],
[
148,
22
],
[
27,
26
],
[
143,
30
],
[
152,
31
],
[
149,
34
],
[
149,
39
],
[
26,
40
],
[
26,
42
],
[
140,
44
],
[
149,
52
],
[
76,
53
],
[
149,
57
],
[
78,
58
],
[
80,
60
],
[
80,
62
],
[
149,
66
],
[
76,
68
],
[
78,
69
],
[
80,
71
],
[
80,
73
],
[
80,
74
],
[
76,
76
],
[
78,
78
],
[
80,
80
],
[
133,
82
],
[
86,
85
],
[
137,
88
],
[
152,
89
],
[
127,
91
],
[
146,
95
],
[
143,
99
],
[
85,
100
],
[
131,
101
],
[
85,
103
],
[
140,
104
],
[
146,
106
],
[
152,
111
],
[
85,
113
],
[
131,
114
],
[
131,
117
],
[
140,
119
],
[
140,
120
],
[
128,
124
],
[
134,
124
],
[
140,
125
],
[
127,
128
],
[
151,
131
],
[
133,
134
],
[
151,
137
],
[
139,
140
],
[
151,
143
],
[
148,
149
],
[
151,
152
]
] | [
"h,w,a,b = map(int,input().split()) #入力\nmod = 10**9+7 \n\n#前計算 f[i] = i!\nf=[1]\nfor i in range(h+w):\n f.append(f[i]*(i+1)%mod)\n\n#C(n,r,p) = ( n! * r!^(p-2) * (n-r)!^(p-2) )%p\n#pythonだとpow()で二分累乗法が使える\ndef comb(n, r, p):\n return f[n] * pow(f[r], p-2, p) * pow(f[n-r], p-2, p) % p\n\n#紫点ごとに調べる\nans=0\nfor i in range(b, w):\n ans+= comb(h+i-a-1, i, mod) * comb(w-1-i+a-1, a-1, mod) % mod\n\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",
"f=[1]",
"f",
"[1]",
"1",
"for i in range(h+w):\n f.append(f[i]*(i+1)%mod)\n\n#C(n,r,p) = ( n! * r!^(p-2) * (n-r)!^(p-2) )%p\n#pythonだとpow()で二分累乗法が使える",
"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(n, r, p):\n return f[n] * pow(f[r], p-2, p) * pow(f[n-r], p-2, p) % p\n\n#紫点ごとに調べる",
"comb",
"return f[n] * pow(f[r], p-2, p) * pow(f[n-r], p-2, p) % p",
"f[n] * pow(f[r], p-2, p) * pow(f[n-r], p-2, p) % p",
"f[n] * pow(f[r], p-2, p) * pow(f[n-r], p-2, p)",
"f[n] * pow(f[r], p-2, p)",
"f[n]",
"f",
"n",
"pow(f[r], p-2, p)",
"pow",
"f[r]",
"f",
"r",
"p-2",
"p",
"2",
"p",
"pow(f[n-r], p-2, p)",
"pow",
"f[n-r]",
"f",
"n-r",
"n",
"r",
"p-2",
"p",
"2",
"p",
"p",
"n",
"n",
"r",
"r",
"p",
"p",
"ans=0",
"ans",
"0",
"for i in range(b, w):\n ans+= comb(h+i-a-1, i, mod) * comb(w-1-i+a-1, a-1, mod) % mod",
"i",
"range(b, w)",
"range",
"b",
"w",
"ans+= comb(h+i-a-1, i, mod) * comb(w-1-i+a-1, a-1, mod) % mod",
"ans",
"comb(h+i-a-1, i, mod) * comb(w-1-i+a-1, a-1, mod) % mod",
"comb(h+i-a-1, i, mod) * comb(w-1-i+a-1, a-1, mod)",
"comb(h+i-a-1, i, mod)",
"comb",
"h+i-a-1",
"h+i-a",
"h+i",
"h",
"i",
"a",
"1",
"i",
"mod",
"comb(w-1-i+a-1, a-1, mod)",
"comb",
"w-1-i+a-1",
"w-1-i+a",
"w-1-i",
"w-1",
"w",
"1",
"i",
"a",
"1",
"a-1",
"a",
"1",
"mod",
"mod",
"print(ans%mod)",
"print",
"ans%mod",
"ans",
"mod",
"ans+= comb(h+i-a-1, i, mod) * comb(w-1-i+a-1, a-1, mod) % mod",
"comb(h+i-a-1, i, mod) * comb(w-1-i+a-1, a-1, mod) % mod",
"ans",
"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",
"mod = 10**9+7",
"10**9+7",
"mod",
"h,w,a,b = map(int,input().split())",
"map(int,input().split())",
"h",
"def comb(n, r, p):\n return f[n] * pow(f[r], p-2, p) * pow(f[n-r], p-2, p) % p\n\n#紫点ごとに調べる",
"def comb(n, r, p):\n return f[n] * pow(f[r], p-2, p) * pow(f[n-r], p-2, p) % p\n\n#紫点ごとに調べる",
"comb",
"f=[1]",
"[1]",
"f",
"w,a,b = map(int,input().split())",
"map(int,input().split())",
"w"
] | h,w,a,b = map(int,input().split()) #入力
mod = 10**9+7
#前計算 f[i] = i!
f=[1]
for i in range(h+w):
f.append(f[i]*(i+1)%mod)
#C(n,r,p) = ( n! * r!^(p-2) * (n-r)!^(p-2) )%p
#pythonだとpow()で二分累乗法が使える
def comb(n, r, p):
return f[n] * pow(f[r], p-2, p) * pow(f[n-r], p-2, p) % p
#紫点ごとに調べる
ans=0
for i in range(b, w):
ans+= comb(h+i-a-1, i, mod) * comb(w-1-i+a-1, a-1, mod) % mod
print(ans%mod) |
[
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,
28,
13,
4,
13,
17,
2,
13,
17,
0,
18,
13,
13,
2,
2,
18,
13,
2,
13,
17,
13,
13,
0,
18,
13,
17,
4,
13,
18,
13,
17,
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,
4,
40,
40,
13,
13,
17,
0,
13,
18,
13,
13,
0,
13,
18,
13,
2,
13,
13,
0,
13,
13,
0,
13,
18,
13,
13,
29,
2,
13,
13,
23,
13,
23,
13,
0,
13,
4,
13,
2,
2,
4,
13,
2,
2,
2,
13,
13,
13,
17,
13,
4,
13,
2,
2,
2,
13,
13,
17,
13,
2,
13,
17,
13,
4,
13,
2,
13,
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,
10,
2,
13
] | [
[
186,
2
],
[
186,
11
],
[
186,
12
],
[
186,
13
],
[
198,
15
],
[
187,
17
],
[
172,
18
],
[
192,
20
],
[
177,
27
],
[
199,
32
],
[
183,
35
],
[
199,
40
],
[
44,
43
],
[
199,
48
],
[
54,
51
],
[
178,
52
],
[
43,
53
],
[
178,
57
],
[
43,
59
],
[
43,
61
],
[
193,
62
],
[
67,
64
],
[
184,
65
],
[
178,
70
],
[
193,
73
],
[
193,
75
],
[
78,
77
],
[
199,
81
],
[
89,
86
],
[
184,
87
],
[
77,
88
],
[
184,
92
],
[
77,
94
],
[
77,
97
],
[
193,
99
],
[
133,
105
],
[
135,
106
],
[
110,
109
],
[
178,
111
],
[
133,
112
],
[
115,
114
],
[
184,
116
],
[
133,
118
],
[
135,
119
],
[
122,
121
],
[
193,
122
],
[
125,
124
],
[
184,
126
],
[
135,
127
],
[
124,
130
],
[
121,
130
],
[
114,
130
],
[
109,
130
],
[
193,
131
],
[
133,
133
],
[
135,
135
],
[
195,
137
],
[
190,
143
],
[
187,
147
],
[
175,
148
],
[
190,
153
],
[
175,
157
],
[
172,
158
],
[
175,
162
],
[
193,
164
],
[
196,
168
],
[
193,
169
],
[
186,
172
],
[
186,
175
],
[
177,
178
],
[
186,
181
],
[
183,
184
],
[
186,
187
],
[
192,
193
],
[
195,
196
],
[
198,
199
]
] | [
"h, w, a, b = map(int, input().split())\nm = h + w\nmod = 10 ** 9 + 7\n\nfac = [1] * (m + 1)\ninv = [1] * (m + 1)\nfor i in range(1, m + 1):\n fac[i] = fac[i - 1] * i % mod\ninv[-1] = pow(fac[-1], mod - 2, mod)\nfor i in range(m - 1, -1, -1):\n inv[i] = inv[i + 1] * (i + 1) % mod\n\n\ndef cmb(n, r):\n assert n >= r >= 0\n ret = fac[n] \n ret *= inv[n - r]\n ret %= mod\n ret *= inv[r]\n return ret % mod\n\n\nans = sum(cmb(h - a + i - 1, i) * cmb(a + w - 2 - i, a - 1) % mod for i in range(b, w))\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",
"m = h + w",
"m",
"h + w",
"h",
"w",
"mod = 10 ** 9 + 7",
"mod",
"10 ** 9 + 7",
"10 ** 9",
"10",
"9",
"7",
"fac = [1] * (m + 1)",
"fac",
"[1] * (m + 1)",
"[1]",
"1",
"m + 1",
"m",
"1",
"inv = [1] * (m + 1)",
"inv",
"[1] * (m + 1)",
"[1]",
"1",
"m + 1",
"m",
"1",
"for i in range(1, m + 1):\n fac[i] = fac[i - 1] * i % mod",
"i",
"range(1, m + 1)",
"range",
"1",
"m + 1",
"m",
"1",
"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[-1] = pow(fac[-1], mod - 2, mod)",
"inv[-1]",
"inv",
"-1",
"pow(fac[-1], mod - 2, mod)",
"pow",
"fac[-1]",
"fac",
"-1",
"mod - 2",
"mod",
"2",
"mod",
"for i in range(m - 1, -1, -1):\n inv[i] = inv[i + 1] * (i + 1) % mod",
"i",
"range(m - 1, -1, -1)",
"range",
"m - 1",
"m",
"1",
"-1",
"-1",
"inv[i] = inv[i + 1] * (i + 1) % mod",
"inv[i]",
"inv",
"i",
"inv[i + 1] * (i + 1) % mod",
"inv[i + 1] * (i + 1)",
"inv[i + 1]",
"inv",
"i + 1",
"i",
"1",
"i + 1",
"i",
"1",
"mod",
"def cmb(n, r):\n assert n >= r >= 0\n ret = fac[n] \n ret *= inv[n - r]\n ret %= mod\n ret *= inv[r]\n return ret % mod",
"cmb",
"assert n >= r >= 0",
"n >= r >= 0",
"n >= r",
"n",
"r",
"0",
"ret = fac[n]",
"ret",
"fac[n]",
"fac",
"n",
"ret *= inv[n - r]",
"ret",
"inv[n - r]",
"inv",
"n - r",
"n",
"r",
"ret %= mod",
"ret",
"mod",
"ret *= inv[r]",
"ret",
"inv[r]",
"inv",
"r",
"return ret % mod",
"ret % mod",
"ret",
"mod",
"n",
"n",
"r",
"r",
"ans = sum(cmb(h - a + i - 1, i) * cmb(a + w - 2 - i, a - 1) % mod for i in range(b, w))",
"ans",
"sum(cmb(h - a + i - 1, i) * cmb(a + w - 2 - i, a - 1) % mod for i in range(b, w))",
"sum",
"cmb(h - a + i - 1, i) * cmb(a + w - 2 - i, a - 1) % mod",
"cmb(h - a + i - 1, i) * cmb(a + w - 2 - i, a - 1)",
"cmb(h - a + i - 1, i)",
"cmb",
"h - a + i - 1",
"h - a + i",
"h - a",
"h",
"a",
"i",
"1",
"i",
"cmb(a + w - 2 - i, a - 1)",
"cmb",
"a + w - 2 - i",
"a + w - 2",
"a + w",
"a",
"w",
"2",
"i",
"a - 1",
"a",
"1",
"mod",
"print(ans % mod)",
"print",
"ans % mod",
"ans",
"mod",
"w, a, b = map(int, input().split())",
"map(int, input().split())",
"w",
"a, b = map(int, input().split())",
"map(int, input().split())",
"a",
"fac = [1] * (m + 1)",
"[1] * (m + 1)",
"fac",
"b = map(int, input().split())",
"map(int, input().split())",
"b",
"inv = [1] * (m + 1)",
"[1] * (m + 1)",
"inv",
"h, w, a, b = map(int, input().split())",
"map(int, input().split())",
"h",
"def cmb(n, r):\n assert n >= r >= 0\n ret = fac[n] \n ret *= inv[n - r]\n ret %= mod\n ret *= inv[r]\n return ret % mod",
"def cmb(n, r):\n assert n >= r >= 0\n ret = fac[n] \n ret *= inv[n - r]\n ret %= mod\n ret *= inv[r]\n return ret % mod",
"cmb",
"mod = 10 ** 9 + 7",
"10 ** 9 + 7",
"mod",
"ans = sum(cmb(h - a + i - 1, i) * cmb(a + w - 2 - i, a - 1) % mod for i in range(b, w))",
"sum(cmb(h - a + i - 1, i) * cmb(a + w - 2 - i, a - 1) % mod for i in range(b, w))",
"ans",
"m = h + w",
"h + w",
"m"
] | h, w, a, b = map(int, input().split())
m = h + w
mod = 10 ** 9 + 7
fac = [1] * (m + 1)
inv = [1] * (m + 1)
for i in range(1, m + 1):
fac[i] = fac[i - 1] * i % mod
inv[-1] = pow(fac[-1], mod - 2, mod)
for i in range(m - 1, -1, -1):
inv[i] = inv[i + 1] * (i + 1) % mod
def cmb(n, r):
assert n >= r >= 0
ret = fac[n]
ret *= inv[n - r]
ret %= mod
ret *= inv[r]
return ret % mod
ans = sum(cmb(h - a + i - 1, i) * cmb(a + w - 2 - i, a - 1) % mod for i in range(b, w))
print(ans % mod) |
[
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,
0,
13,
13,
12,
13,
0,
13,
39,
17,
28,
13,
4,
13,
17,
13,
4,
18,
13,
13,
2,
2,
18,
13,
2,
13,
17,
13,
13,
0,
13,
2,
39,
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,
13,
2,
2,
18,
13,
2,
13,
17,
2,
13,
17,
13,
29,
39,
13,
13,
23,
13,
23,
13,
2,
2,
17,
17,
17,
0,
13,
4,
13,
2,
2,
13,
13,
17,
13,
13,
0,
13,
17,
42,
2,
40,
13,
17,
2,
13,
13,
0,
13,
2,
2,
2,
2,
18,
13,
2,
13,
13,
18,
13,
13,
13,
18,
13,
13,
13,
0,
13,
2,
2,
2,
2,
18,
13,
2,
2,
2,
13,
13,
17,
2,
2,
13,
13,
17,
18,
13,
2,
2,
13,
13,
17,
13,
18,
13,
2,
2,
13,
13,
17,
13,
0,
13,
2,
2,
13,
13,
13,
0,
13,
17,
0,
13,
17,
4,
13,
2,
13,
13,
10,
4,
13,
10,
17,
13,
10,
17,
13,
10,
4,
13,
10,
2,
13,
10,
4,
13,
10,
2,
13,
10,
13,
13,
10,
2,
13,
10,
2,
13,
10,
2,
13,
10,
12,
13,
10,
4,
13,
10,
4,
13,
10,
17,
13,
10,
4,
13
] | [
[
256,
2
],
[
256,
11
],
[
256,
12
],
[
256,
13
],
[
238,
15
],
[
223,
22
],
[
257,
25
],
[
221,
26
],
[
232,
29
],
[
251,
30
],
[
35,
34
],
[
39,
38
],
[
38,
42
],
[
34,
45
],
[
34,
50
],
[
38,
52
],
[
38,
54
],
[
110,
55
],
[
58,
57
],
[
108,
61
],
[
68,
63
],
[
57,
64
],
[
108,
66
],
[
34,
71
],
[
108,
73
],
[
110,
76
],
[
110,
78
],
[
81,
80
],
[
80,
84
],
[
92,
89
],
[
57,
90
],
[
80,
91
],
[
57,
95
],
[
80,
97
],
[
80,
100
],
[
110,
102
],
[
108,
108
],
[
111,
110
],
[
226,
117
],
[
245,
119
],
[
248,
122
],
[
257,
123
],
[
239,
125
],
[
226,
126
],
[
214,
128
],
[
224,
133
],
[
254,
133
],
[
248,
136
],
[
233,
137
],
[
218,
137
],
[
241,
139
],
[
212,
145
],
[
224,
147
],
[
254,
147
],
[
233,
148
],
[
218,
148
],
[
227,
150
],
[
224,
151
],
[
254,
151
],
[
239,
152
],
[
227,
154
],
[
233,
155
],
[
218,
155
],
[
239,
156
],
[
229,
158
],
[
212,
164
],
[
257,
168
],
[
224,
169
],
[
254,
169
],
[
248,
173
],
[
233,
174
],
[
218,
174
],
[
227,
177
],
[
257,
180
],
[
224,
181
],
[
254,
181
],
[
239,
183
],
[
227,
185
],
[
248,
188
],
[
233,
189
],
[
218,
189
],
[
239,
191
],
[
235,
193
],
[
242,
196
],
[
230,
197
],
[
239,
198
],
[
253,
200
],
[
217,
203
],
[
236,
208
],
[
215,
208
],
[
239,
209
],
[
226,
212
],
[
214,
215
],
[
217,
218
],
[
256,
221
],
[
223,
224
],
[
226,
227
],
[
229,
230
],
[
251,
232
],
[
232,
233
],
[
235,
236
],
[
238,
239
],
[
241,
242
],
[
256,
248
],
[
256,
251
],
[
253,
254
],
[
256,
257
]
] | [
"H, W, A, B = map(int, input().split())\nMOD = 10 ** 9 + 7\n\ni = H - A - 1\nj = B\n\n\n# 階乗とその逆元を事前計算する (O(N))\n# finv[0] := 0の階乗の逆元\ndef factorial_and_inv(n, mod=10 ** 9 + 7):\n f = [1]\n for n in range(1, n):\n f.append(f[n - 1] * n % mod)\n finv = [0] * n\n finv[n - 1] = pow(f[n - 1], mod - 2, mod)\n for n in range(n - 2, -1, -1):\n finv[n] = finv[n + 1] * (n + 1) % mod\n return f, finv\n\n\nf, finv = factorial_and_inv(W + H + 2, MOD)\nans = 0\nwhile i >= 0 and W > j:\n path1 = f[i + j] * finv[i] % MOD * finv[j] % MOD\n path2 = f[(H - i - 1) + (W - j - 1)] * finv[H - i - 1] % MOD * finv[W - j - 1] % MOD\n ans += path1 * path2 % MOD\n i -= 1\n j += 1\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",
"i = H - A - 1",
"i",
"H - A - 1",
"H - A",
"H",
"A",
"1",
"j = B",
"j",
"B",
"def factorial_and_inv(n, mod=10 ** 9 + 7):\n f = [1]\n for n in range(1, n):\n f.append(f[n - 1] * n % mod)\n finv = [0] * n\n finv[n - 1] = pow(f[n - 1], mod - 2, mod)\n for n in range(n - 2, -1, -1):\n finv[n] = finv[n + 1] * (n + 1) % mod\n return f, finv",
"factorial_and_inv",
"f = [1]",
"f",
"[1]",
"1",
"for n in range(1, n):\n f.append(f[n - 1] * n % mod)\n ",
"n",
"range(1, n)",
"range",
"1",
"n",
"f.append(f[n - 1] * n % mod)",
"f.append",
"f",
"append",
"f[n - 1] * n % mod",
"f[n - 1] * n",
"f[n - 1]",
"f",
"n - 1",
"n",
"1",
"n",
"mod",
"finv = [0] * n",
"finv",
"[0] * n",
"[0]",
"0",
"n",
"finv[n - 1] = pow(f[n - 1], mod - 2, mod)",
"finv[n - 1]",
"finv",
"n - 1",
"n",
"1",
"pow(f[n - 1], mod - 2, mod)",
"pow",
"f[n - 1]",
"f",
"n - 1",
"n",
"1",
"mod - 2",
"mod",
"2",
"mod",
"for n in range(n - 2, -1, -1):\n finv[n] = finv[n + 1] * (n + 1) % mod\n ",
"n",
"range(n - 2, -1, -1)",
"range",
"n - 2",
"n",
"2",
"-1",
"-1",
"finv[n] = finv[n + 1] * (n + 1) % mod",
"finv[n]",
"finv",
"n",
"finv[n + 1] * (n + 1) % mod",
"finv[n + 1] * (n + 1)",
"finv[n + 1]",
"finv",
"n + 1",
"n",
"1",
"n + 1",
"n",
"1",
"mod",
"return f, finv",
"return f, finv",
"f",
"finv",
"n",
"n",
"mod=10 ** 9 + 7",
"mod",
"10 ** 9 + 7",
"10 ** 9",
"10",
"9",
"7",
"f, finv = factorial_and_inv(W + H + 2, MOD)",
"f",
"factorial_and_inv(W + H + 2, MOD)",
"factorial_and_inv",
"W + H + 2",
"W + H",
"W",
"H",
"2",
"MOD",
"finv",
"ans = 0",
"ans",
"0",
"while i >= 0 and W > j:\n path1 = f[i + j] * finv[i] % MOD * finv[j] % MOD\n path2 = f[(H - i - 1) + (W - j - 1)] * finv[H - i - 1] % MOD * finv[W - j - 1] % MOD\n ans += path1 * path2 % MOD\n i -= 1\n j += 1",
"i >= 0 and W > j",
"i >= 0",
"i",
"0",
"W > j",
"W",
"j",
"path1 = f[i + j] * finv[i] % MOD * finv[j] % MOD",
"path1",
"f[i + j] * finv[i] % MOD * finv[j] % MOD",
"f[i + j] * finv[i] % MOD * finv[j]",
"f[i + j] * finv[i] % MOD",
"f[i + j] * finv[i]",
"f[i + j]",
"f",
"i + j",
"i",
"j",
"finv[i]",
"finv",
"i",
"MOD",
"finv[j]",
"finv",
"j",
"MOD",
"path2 = f[(H - i - 1) + (W - j - 1)] * finv[H - i - 1] % MOD * finv[W - j - 1] % MOD",
"path2",
"f[(H - i - 1) + (W - j - 1)] * finv[H - i - 1] % MOD * finv[W - j - 1] % MOD",
"f[(H - i - 1) + (W - j - 1)] * finv[H - i - 1] % MOD * finv[W - j - 1]",
"f[(H - i - 1) + (W - j - 1)] * finv[H - i - 1] % MOD",
"f[(H - i - 1) + (W - j - 1)] * finv[H - i - 1]",
"f[(H - i - 1) + (W - j - 1)]",
"f",
"(H - i - 1) + (W - j - 1)",
"H - i - 1",
"H - i",
"H",
"i",
"1",
"W - j - 1",
"W - j",
"W",
"j",
"1",
"finv[H - i - 1]",
"finv",
"H - i - 1",
"H - i",
"H",
"i",
"1",
"MOD",
"finv[W - j - 1]",
"finv",
"W - j - 1",
"W - j",
"W",
"j",
"1",
"MOD",
"ans += path1 * path2 % MOD",
"ans",
"path1 * path2 % MOD",
"path1 * path2",
"path1",
"path2",
"MOD",
"i -= 1",
"i",
"1",
"j += 1",
"j",
"1",
"print(ans % MOD)",
"print",
"ans % MOD",
"ans",
"MOD",
"f, finv = factorial_and_inv(W + H + 2, MOD)",
"factorial_and_inv(W + H + 2, MOD)",
"f",
"ans = 0",
"0",
"ans",
"j += 1",
"1",
"j",
"A, B = map(int, input().split())",
"map(int, input().split())",
"A",
"i = H - A - 1",
"H - A - 1",
"i",
"finv = factorial_and_inv(W + H + 2, MOD)",
"factorial_and_inv(W + H + 2, MOD)",
"finv",
"path2 = f[(H - i - 1) + (W - j - 1)] * finv[H - i - 1] % MOD * finv[W - j - 1] % MOD",
"f[(H - i - 1) + (W - j - 1)] * finv[H - i - 1] % MOD * finv[W - j - 1] % MOD",
"path2",
"j = B",
"B",
"j",
"ans += path1 * path2 % MOD",
"path1 * path2 % MOD",
"ans",
"MOD = 10 ** 9 + 7",
"10 ** 9 + 7",
"MOD",
"path1 = f[i + j] * finv[i] % MOD * finv[j] % MOD",
"f[i + j] * finv[i] % MOD * finv[j] % MOD",
"path1",
"def factorial_and_inv(n, mod=10 ** 9 + 7):\n f = [1]\n for n in range(1, n):\n f.append(f[n - 1] * n % mod)\n finv = [0] * n\n finv[n - 1] = pow(f[n - 1], mod - 2, mod)\n for n in range(n - 2, -1, -1):\n finv[n] = finv[n + 1] * (n + 1) % mod\n return f, finv",
"def factorial_and_inv(n, mod=10 ** 9 + 7):\n f = [1]\n for n in range(1, n):\n f.append(f[n - 1] * n % mod)\n finv = [0] * n\n finv[n - 1] = pow(f[n - 1], mod - 2, mod)\n for n in range(n - 2, -1, -1):\n finv[n] = finv[n + 1] * (n + 1) % mod\n return f, finv",
"factorial_and_inv",
"W, A, B = map(int, input().split())",
"map(int, input().split())",
"W",
"B = map(int, input().split())",
"map(int, input().split())",
"B",
"i -= 1",
"1",
"i",
"H, W, A, B = map(int, input().split())",
"map(int, input().split())",
"H"
] | H, W, A, B = map(int, input().split())
MOD = 10 ** 9 + 7
i = H - A - 1
j = B
# 階乗とその逆元を事前計算する (O(N))
# finv[0] := 0の階乗の逆元
def factorial_and_inv(n, mod=10 ** 9 + 7):
f = [1]
for n in range(1, n):
f.append(f[n - 1] * n % mod)
finv = [0] * n
finv[n - 1] = pow(f[n - 1], mod - 2, mod)
for n in range(n - 2, -1, -1):
finv[n] = finv[n + 1] * (n + 1) % mod
return f, finv
f, finv = factorial_and_inv(W + H + 2, MOD)
ans = 0
while i >= 0 and W > j:
path1 = f[i + j] * finv[i] % MOD * finv[j] % MOD
path2 = f[(H - i - 1) + (W - j - 1)] * finv[H - i - 1] % MOD * finv[W - j - 1] % MOD
ans += path1 * path2 % MOD
i -= 1
j += 1
print(ans % MOD)
|
[
7,
0,
13,
4,
13,
13,
4,
18,
4,
13,
13,
13,
13,
13,
0,
13,
2,
2,
17,
17,
17,
12,
13,
0,
13,
2,
13,
17,
0,
13,
17,
42,
2,
13,
17,
14,
2,
2,
13,
17,
17,
0,
13,
2,
2,
13,
13,
13,
0,
13,
2,
2,
13,
17,
13,
0,
13,
17,
29,
13,
23,
13,
23,
13,
41,
28,
13,
4,
13,
17,
2,
2,
13,
13,
17,
4,
4,
13,
13,
13,
0,
13,
2,
39,
17,
13,
0,
13,
17,
0,
13,
17,
28,
13,
4,
13,
2,
2,
2,
13,
13,
13,
17,
2,
2,
2,
2,
13,
13,
13,
17,
2,
2,
13,
13,
17,
17,
0,
13,
2,
2,
13,
13,
13,
28,
13,
4,
13,
2,
2,
2,
13,
13,
17,
17,
0,
13,
2,
2,
13,
18,
13,
13,
13,
0,
13,
39,
13,
0,
13,
39,
13,
28,
13,
4,
13,
17,
2,
13,
13,
0,
13,
2,
2,
13,
2,
2,
13,
17,
13,
13,
0,
13,
2,
2,
13,
18,
13,
13,
13,
4,
18,
13,
13,
13,
0,
13,
2,
2,
13,
2,
2,
2,
2,
13,
13,
13,
17,
13,
13,
0,
13,
2,
2,
13,
18,
13,
2,
2,
2,
2,
2,
13,
13,
13,
17,
2,
2,
13,
13,
17,
13,
13,
4,
18,
13,
13,
13,
0,
13,
17,
28,
13,
4,
13,
2,
13,
13,
0,
13,
2,
2,
18,
13,
13,
18,
13,
2,
40,
13,
17,
13,
0,
13,
2,
2,
13,
13,
13,
4,
13,
13,
10,
2,
13,
10,
39,
13,
10,
2,
13,
10,
4,
13,
10,
2,
13,
10,
2,
13,
10,
2,
13,
10,
17,
13,
10,
12,
13,
10,
2,
13,
10,
2,
13,
10,
17,
13,
10,
4,
13,
10,
39,
13,
10,
2,
13,
10,
17,
13,
10,
4,
13,
10,
2,
13,
10,
4,
13,
10,
2,
13
] | [
[
317,
2
],
[
317,
11
],
[
317,
12
],
[
317,
13
],
[
305,
15
],
[
25,
24
],
[
63,
26
],
[
30,
29
],
[
24,
33
],
[
56,
33
],
[
24,
38
],
[
56,
38
],
[
43,
42
],
[
29,
45
],
[
42,
45
],
[
61,
46
],
[
49,
46
],
[
63,
47
],
[
50,
49
],
[
61,
52
],
[
49,
52
],
[
63,
54
],
[
57,
56
],
[
42,
59
],
[
29,
59
],
[
61,
61
],
[
63,
63
],
[
67,
66
],
[
312,
72
],
[
318,
73
],
[
288,
77
],
[
66,
78
],
[
306,
79
],
[
275,
81
],
[
296,
87
],
[
284,
90
],
[
94,
93
],
[
318,
99
],
[
273,
100
],
[
300,
101
],
[
318,
107
],
[
273,
108
],
[
300,
109
],
[
318,
113
],
[
273,
114
],
[
293,
118
],
[
285,
121
],
[
294,
121
],
[
93,
122
],
[
306,
123
],
[
126,
125
],
[
318,
131
],
[
273,
132
],
[
290,
136
],
[
294,
139
],
[
285,
139
],
[
291,
139
],
[
276,
141
],
[
125,
142
],
[
306,
143
],
[
302,
145
],
[
266,
149
],
[
154,
153
],
[
312,
158
],
[
300,
159
],
[
263,
161
],
[
297,
164
],
[
321,
164
],
[
264,
164
],
[
273,
167
],
[
153,
169
],
[
306,
170
],
[
320,
172
],
[
264,
175
],
[
297,
175
],
[
321,
175
],
[
276,
177
],
[
153,
178
],
[
306,
179
],
[
303,
182
],
[
321,
184
],
[
264,
184
],
[
297,
184
],
[
269,
186
],
[
291,
189
],
[
294,
189
],
[
285,
189
],
[
315,
189
],
[
270,
189
],
[
318,
194
],
[
273,
195
],
[
300,
196
],
[
153,
198
],
[
306,
199
],
[
314,
201
],
[
270,
204
],
[
291,
204
],
[
294,
204
],
[
285,
204
],
[
315,
204
],
[
276,
206
],
[
318,
212
],
[
273,
213
],
[
300,
214
],
[
318,
218
],
[
273,
219
],
[
153,
221
],
[
306,
222
],
[
267,
225
],
[
315,
227
],
[
270,
227
],
[
291,
227
],
[
294,
227
],
[
285,
227
],
[
308,
229
],
[
233,
232
],
[
312,
236
],
[
300,
237
],
[
281,
239
],
[
303,
243
],
[
232,
244
],
[
267,
246
],
[
232,
249
],
[
306,
251
],
[
278,
253
],
[
309,
256
],
[
279,
256
],
[
282,
257
],
[
306,
258
],
[
279,
261
],
[
309,
261
],
[
263,
264
],
[
266,
267
],
[
269,
270
],
[
317,
273
],
[
275,
276
],
[
278,
279
],
[
281,
282
],
[
284,
285
],
[
290,
291
],
[
293,
294
],
[
296,
297
],
[
317,
300
],
[
302,
303
],
[
305,
306
],
[
308,
309
],
[
317,
312
],
[
314,
315
],
[
317,
318
],
[
320,
321
]
] | [
"h, w, a, b = map(int,input().split())\nmod = 10**9 + 7\n\ndef inv(x, p):\n pp = p-2\n ans = 1\n while pp > 0:\n if pp % 2 == 1:\n ans = (ans * x) % p\n x = (x ** 2) % p\n pp //= 2\n return ans\n\nI = [1] + [inv(i, mod) for i in range(1, h+w+1)]\n\na0 = 1\na1 = 1\nfor i in range(w-b+a-1, (w-b+a-1)-(w-b-1), -1):\n a1 = (a1 * i) % mod\n# print(a1)\nfor i in range(w-b-1+1):\n #print(\"i\",i)\n a1 = (a1 * I[i]) % mod\n\nA0 = [a0]\nA1 = [a1]\nfor i in range(1, h-a):\n a0 = (a0 * (b-1+i)) % mod\n a0 = (a0 * I[i]) % mod\n A0.append(a0)\n\n a1 = (a1 * (w-b+a-1+i)) % mod\n a1 = (a1 * I[(w-b+a-1)-(w-b-1)+i]) % mod\n A1.append(a1)\n\n# print(A0)\n# print(A1)\nans = 0\nfor i in range(h-a):\n pl = (A0[i] * A1[-i-1]) % mod\n ans = (ans + pl) % 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",
"mod = 10**9 + 7",
"mod",
"10**9 + 7",
"10**9",
"10",
"9",
"7",
"def inv(x, p):\n pp = p-2\n ans = 1\n while pp > 0:\n if pp % 2 == 1:\n ans = (ans * x) % p\n x = (x ** 2) % p\n pp //= 2\n return ans",
"inv",
"pp = p-2",
"pp",
"p-2",
"p",
"2",
"ans = 1",
"ans",
"1",
"while pp > 0:\n if pp % 2 == 1:\n ans = (ans * x) % p\n x = (x ** 2) % p\n pp //= 2\n ",
"pp > 0",
"pp",
"0",
"if pp % 2 == 1:\n ans = (ans * x) % p\n ",
"pp % 2 == 1",
"pp % 2",
"pp",
"2",
"1",
"ans = (ans * x) % p",
"ans",
"(ans * x) % p",
"ans * x",
"ans",
"x",
"p",
"x = (x ** 2) % p",
"x",
"(x ** 2) % p",
"x ** 2",
"x",
"2",
"p",
"pp //= 2",
"pp",
"2",
"return ans",
"ans",
"x",
"x",
"p",
"p",
"inv(i, mod) for i in range(1, h+w+1)",
"for i in range(1, h+w+1)",
"i",
"range(1, h+w+1)",
"range",
"1",
"h+w+1",
"h+w",
"h",
"w",
"1",
"for i in range(1, h+w+1)",
"inv(i, mod)",
"inv",
"i",
"mod",
"I = [1] + [inv(i, mod) for i in range(1, h+w+1)]",
"I",
"[1] + [inv(i, mod) for i in range(1, h+w+1)]",
"[1]",
"1",
"[inv(i, mod) for i in range(1, h+w+1)]",
"a0 = 1",
"a0",
"1",
"a1 = 1",
"a1",
"1",
"for i in range(w-b+a-1, (w-b+a-1)-(w-b-1), -1):\n a1 = (a1 * i) % mod\n# print(a1)",
"i",
"range(w-b+a-1, (w-b+a-1)-(w-b-1), -1)",
"range",
"w-b+a-1",
"w-b+a",
"w-b",
"w",
"b",
"a",
"1",
"(w-b+a-1)-(w-b-1)",
"w-b+a-1",
"w-b+a",
"w-b",
"w",
"b",
"a",
"1",
"w-b-1",
"w-b",
"w",
"b",
"1",
"-1",
"a1 = (a1 * i) % mod",
"a1",
"(a1 * i) % mod",
"a1 * i",
"a1",
"i",
"mod",
"for i in range(w-b-1+1):\n #print(\"i\",i)\n a1 = (a1 * I[i]) % mod",
"i",
"range(w-b-1+1)",
"range",
"w-b-1+1",
"w-b-1",
"w-b",
"w",
"b",
"1",
"1",
"a1 = (a1 * I[i]) % mod",
"a1",
"(a1 * I[i]) % mod",
"a1 * I[i]",
"a1",
"I[i]",
"I",
"i",
"mod",
"A0 = [a0]",
"A0",
"[a0]",
"a0",
"A1 = [a1]",
"A1",
"[a1]",
"a1",
"for i in range(1, h-a):\n a0 = (a0 * (b-1+i)) % mod\n a0 = (a0 * I[i]) % mod\n A0.append(a0)\n\n a1 = (a1 * (w-b+a-1+i)) % mod\n a1 = (a1 * I[(w-b+a-1)-(w-b-1)+i]) % mod\n A1.append(a1)\n\n# print(A0)\n# print(A1)",
"i",
"range(1, h-a)",
"range",
"1",
"h-a",
"h",
"a",
"a0 = (a0 * (b-1+i)) % mod",
"a0",
"(a0 * (b-1+i)) % mod",
"a0 * (b-1+i)",
"a0",
"b-1+i",
"b-1",
"b",
"1",
"i",
"mod",
"a0 = (a0 * I[i]) % mod",
"a0",
"(a0 * I[i]) % mod",
"a0 * I[i]",
"a0",
"I[i]",
"I",
"i",
"mod",
"A0.append(a0)",
"A0.append",
"A0",
"append",
"a0",
"a1 = (a1 * (w-b+a-1+i)) % mod",
"a1",
"(a1 * (w-b+a-1+i)) % mod",
"a1 * (w-b+a-1+i)",
"a1",
"w-b+a-1+i",
"w-b+a-1",
"w-b+a",
"w-b",
"w",
"b",
"a",
"1",
"i",
"mod",
"a1 = (a1 * I[(w-b+a-1)-(w-b-1)+i]) % mod",
"a1",
"(a1 * I[(w-b+a-1)-(w-b-1)+i]) % mod",
"a1 * I[(w-b+a-1)-(w-b-1)+i]",
"a1",
"I[(w-b+a-1)-(w-b-1)+i]",
"I",
"(w-b+a-1)-(w-b-1)+i",
"(w-b+a-1)-(w-b-1)",
"w-b+a-1",
"w-b+a",
"w-b",
"w",
"b",
"a",
"1",
"w-b-1",
"w-b",
"w",
"b",
"1",
"i",
"mod",
"A1.append(a1)",
"A1.append",
"A1",
"append",
"a1",
"ans = 0",
"ans",
"0",
"for i in range(h-a):\n pl = (A0[i] * A1[-i-1]) % mod\n ans = (ans + pl) % mod",
"i",
"range(h-a)",
"range",
"h-a",
"h",
"a",
"pl = (A0[i] * A1[-i-1]) % mod",
"pl",
"(A0[i] * A1[-i-1]) % mod",
"A0[i] * A1[-i-1]",
"A0[i]",
"A0",
"i",
"A1[-i-1]",
"A1",
"-i-1",
"-i",
"i",
"1",
"mod",
"ans = (ans + pl) % mod",
"ans",
"(ans + pl) % mod",
"ans + pl",
"ans",
"pl",
"mod",
"print(ans)",
"print",
"ans",
"a0 = (a0 * (b-1+i)) % mod",
"(a0 * (b-1+i)) % mod",
"a0",
"A1 = [a1]",
"[a1]",
"A1",
"a1 = (a1 * (w-b+a-1+i)) % mod",
"(a1 * (w-b+a-1+i)) % mod",
"a1",
"b = map(int,input().split())",
"map(int,input().split())",
"b",
"I = [1] + [inv(i, mod) for i in range(1, h+w+1)]",
"[1] + [inv(i, mod) for i in range(1, h+w+1)]",
"I",
"ans = (ans + pl) % mod",
"(ans + pl) % mod",
"ans",
"pl = (A0[i] * A1[-i-1]) % mod",
"(A0[i] * A1[-i-1]) % mod",
"pl",
"a1 = 1",
"1",
"a1",
"def inv(x, p):\n pp = p-2\n ans = 1\n while pp > 0:\n if pp % 2 == 1:\n ans = (ans * x) % p\n x = (x ** 2) % p\n pp //= 2\n return ans",
"def inv(x, p):\n pp = p-2\n ans = 1\n while pp > 0:\n if pp % 2 == 1:\n ans = (ans * x) % p\n x = (x ** 2) % p\n pp //= 2\n return ans",
"inv",
"a1 = (a1 * I[i]) % mod",
"(a1 * I[i]) % mod",
"a1",
"a1 = (a1 * i) % mod",
"(a1 * i) % mod",
"a1",
"a0 = 1",
"1",
"a0",
"a, b = map(int,input().split())",
"map(int,input().split())",
"a",
"A0 = [a0]",
"[a0]",
"A0",
"mod = 10**9 + 7",
"10**9 + 7",
"mod",
"ans = 0",
"0",
"ans",
"h, w, a, b = map(int,input().split())",
"map(int,input().split())",
"h",
"a1 = (a1 * I[(w-b+a-1)-(w-b-1)+i]) % mod",
"(a1 * I[(w-b+a-1)-(w-b-1)+i]) % mod",
"a1",
"w, a, b = map(int,input().split())",
"map(int,input().split())",
"w",
"a0 = (a0 * I[i]) % mod",
"(a0 * I[i]) % mod",
"a0"
] | h, w, a, b = map(int,input().split())
mod = 10**9 + 7
def inv(x, p):
pp = p-2
ans = 1
while pp > 0:
if pp % 2 == 1:
ans = (ans * x) % p
x = (x ** 2) % p
pp //= 2
return ans
I = [1] + [inv(i, mod) for i in range(1, h+w+1)]
a0 = 1
a1 = 1
for i in range(w-b+a-1, (w-b+a-1)-(w-b-1), -1):
a1 = (a1 * i) % mod
# print(a1)
for i in range(w-b-1+1):
#print("i",i)
a1 = (a1 * I[i]) % mod
A0 = [a0]
A1 = [a1]
for i in range(1, h-a):
a0 = (a0 * (b-1+i)) % mod
a0 = (a0 * I[i]) % mod
A0.append(a0)
a1 = (a1 * (w-b+a-1+i)) % mod
a1 = (a1 * I[(w-b+a-1)-(w-b-1)+i]) % mod
A1.append(a1)
# print(A0)
# print(A1)
ans = 0
for i in range(h-a):
pl = (A0[i] * A1[-i-1]) % mod
ans = (ans + pl) % mod
print(ans) |
[
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,
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,
4,
13,
13,
4,
18,
4,
13,
13,
13,
13,
13,
0,
13,
4,
13,
2,
2,
13,
13,
17,
2,
13,
17,
13,
28,
13,
4,
13,
2,
13,
13,
13,
0,
13,
2,
4,
13,
2,
2,
13,
13,
17,
2,
13,
17,
13,
4,
13,
2,
2,
2,
2,
13,
13,
17,
13,
13,
2,
2,
13,
13,
17,
13,
0,
13,
13,
4,
13,
13,
10,
4,
13,
10,
13,
13,
10,
4,
13,
10,
2,
13,
10,
4,
13,
10,
2,
13,
10,
39,
13,
10,
4,
13,
10,
2,
13,
10,
12,
13,
10,
39,
13,
10,
39,
13,
10,
4,
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
],
[
207,
44
],
[
201,
51
],
[
225,
58
],
[
222,
63
],
[
210,
68
],
[
74,
73
],
[
202,
78
],
[
226,
82
],
[
226,
87
],
[
73,
89
],
[
208,
90
],
[
211,
93
],
[
211,
99
],
[
208,
101
],
[
73,
102
],
[
208,
104
],
[
73,
105
],
[
208,
106
],
[
223,
109
],
[
223,
114
],
[
211,
117
],
[
208,
119
],
[
213,
121
],
[
213,
130
],
[
213,
131
],
[
213,
132
],
[
228,
134
],
[
220,
136
],
[
205,
139
],
[
193,
140
],
[
205,
143
],
[
208,
145
],
[
148,
147
],
[
205,
151
],
[
214,
152
],
[
205,
153
],
[
216,
155
],
[
220,
158
],
[
147,
161
],
[
199,
162
],
[
199,
165
],
[
208,
167
],
[
220,
169
],
[
205,
174
],
[
193,
175
],
[
147,
177
],
[
199,
178
],
[
193,
181
],
[
199,
182
],
[
208,
184
],
[
195,
186
],
[
208,
187
],
[
196,
190
],
[
217,
190
],
[
229,
190
],
[
213,
193
],
[
208,
195
],
[
195,
196
],
[
213,
199
],
[
201,
202
],
[
213,
205
],
[
207,
208
],
[
210,
211
],
[
213,
214
],
[
216,
217
],
[
222,
223
],
[
225,
226
],
[
228,
229
]
] | [
"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 = 2*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\nH,W,A,B=map(int,input().split())\nans=cmb(H+W-2,H-1,mod)\nfor i in range(H-A,H):\n ans-=cmb(i+B-1,B-1,mod)*cmb(H+W-2-i-B,W-B-1,mod)\n ans%=mod\nprint(ans)",
"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 = 2*10**5",
"N",
"2*10**5",
"2",
"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",
"H,W,A,B=map(int,input().split())",
"H",
"map(int,input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"W",
"A",
"B",
"ans=cmb(H+W-2,H-1,mod)",
"ans",
"cmb(H+W-2,H-1,mod)",
"cmb",
"H+W-2",
"H+W",
"H",
"W",
"2",
"H-1",
"H",
"1",
"mod",
"for i in range(H-A,H):\n ans-=cmb(i+B-1,B-1,mod)*cmb(H+W-2-i-B,W-B-1,mod)\n ans%=mod",
"i",
"range(H-A,H)",
"range",
"H-A",
"H",
"A",
"H",
"ans-=cmb(i+B-1,B-1,mod)*cmb(H+W-2-i-B,W-B-1,mod)",
"ans",
"cmb(i+B-1,B-1,mod)*cmb(H+W-2-i-B,W-B-1,mod)",
"cmb(i+B-1,B-1,mod)",
"cmb",
"i+B-1",
"i+B",
"i",
"B",
"1",
"B-1",
"B",
"1",
"mod",
"cmb(H+W-2-i-B,W-B-1,mod)",
"cmb",
"H+W-2-i-B",
"H+W-2-i",
"H+W-2",
"H+W",
"H",
"W",
"2",
"i",
"B",
"W-B-1",
"W-B",
"W",
"B",
"1",
"mod",
"ans%=mod",
"ans",
"mod",
"print(ans)",
"print",
"ans",
"W,A,B=map(int,input().split())",
"map(int,input().split())",
"W",
"ans%=mod",
"mod",
"ans",
"B=map(int,input().split())",
"map(int,input().split())",
"B",
"N = 2*10**5",
"2*10**5",
"N",
"H,W,A,B=map(int,input().split())",
"map(int,input().split())",
"H",
"mod = 10**9+7",
"10**9+7",
"mod",
"inverse = [0, 1]",
"[0, 1]",
"inverse",
"A,B=map(int,input().split())",
"map(int,input().split())",
"A",
"ans-=cmb(i+B-1,B-1,mod)*cmb(H+W-2-i-B,W-B-1,mod)",
"cmb(i+B-1,B-1,mod)*cmb(H+W-2-i-B,W-B-1,mod)",
"ans",
"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",
"g2 = [1, 1]",
"[1, 1]",
"g2",
"g1 = [1, 1]",
"[1, 1]",
"g1",
"ans=cmb(H+W-2,H-1,mod)",
"cmb(H+W-2,H-1,mod)",
"ans"
] | def cmb(n, r, mod):#コンビネーションの高速計算
if ( r<0 or r>n ):
return 0
r = min(r, n-r)
return g1[n] * g2[r] * g2[n-r] % mod
mod = 10**9+7 #出力の制限
N = 2*10**5
g1 = [1, 1] # 元テーブル
g2 = [1, 1] #逆元テーブル
inverse = [0, 1] #逆元テーブル計算用テーブル
for i in range( 2, N + 1 ):
g1.append( ( g1[-1] * i ) % mod )
inverse.append( ( -inverse[mod % i] * (mod//i) ) % mod )
g2.append( (g2[-1] * inverse[-1]) % mod )
H,W,A,B=map(int,input().split())
ans=cmb(H+W-2,H-1,mod)
for i in range(H-A,H):
ans-=cmb(i+B-1,B-1,mod)*cmb(H+W-2-i-B,W-B-1,mod)
ans%=mod
print(ans) |
[
7,
15,
13,
12,
13,
29,
4,
13,
13,
4,
18,
4,
18,
4,
18,
18,
13,
13,
13,
13,
13,
12,
13,
0,
13,
13,
0,
13,
13,
29,
2,
2,
13,
13,
13,
23,
13,
23,
13,
23,
13,
12,
13,
0,
13,
13,
0,
13,
13,
29,
2,
2,
13,
4,
13,
13,
2,
13,
17,
13,
13,
23,
13,
23,
13,
23,
13,
12,
13,
14,
2,
13,
17,
29,
17,
14,
2,
2,
13,
17,
17,
0,
13,
4,
13,
13,
2,
13,
17,
13,
29,
2,
2,
13,
13,
13,
29,
2,
2,
13,
4,
13,
13,
2,
13,
17,
13,
13,
23,
13,
23,
13,
23,
13,
12,
13,
0,
13,
2,
39,
17,
2,
13,
17,
0,
18,
13,
13,
4,
13,
17,
13,
13,
28,
13,
4,
13,
4,
13,
13,
0,
18,
13,
13,
4,
13,
18,
13,
2,
13,
17,
2,
13,
17,
13,
29,
13,
23,
13,
23,
13,
23,
13,
12,
13,
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,
2,
13,
17,
18,
13,
13,
13,
29,
13,
23,
13,
23,
13,
12,
13,
14,
2,
4,
13,
13,
17,
37,
0,
13,
18,
13,
13,
0,
13,
18,
13,
13,
0,
13,
18,
13,
2,
13,
13,
29,
4,
13,
4,
13,
13,
13,
13,
13,
13,
23,
13,
23,
13,
23,
13,
23,
13,
23,
13,
12,
13,
0,
13,
4,
13,
13,
13,
13,
0,
13,
17,
0,
13,
2,
2,
17,
17,
17,
0,
13,
4,
13,
2,
2,
13,
13,
17,
13,
0,
13,
4,
13,
2,
2,
13,
13,
17,
13,
18,
13,
2,
2,
13,
13,
17,
28,
13,
4,
13,
2,
13,
13,
0,
13,
4,
13,
2,
2,
13,
17,
13,
2,
13,
17,
13,
13,
13,
0,
13,
4,
13,
2,
2,
2,
13,
13,
17,
2,
2,
13,
17,
13,
2,
2,
13,
13,
17,
13,
13,
13,
0,
13,
2,
2,
13,
13,
13,
0,
13,
13,
4,
13,
13,
14,
2,
13,
17,
4,
13,
10,
12,
13,
10,
12,
13,
10,
12,
13,
10,
12,
13,
10,
12,
13,
10,
12,
13,
10,
12,
13,
10,
12,
13
] | [
[
25,
24
],
[
40,
25
],
[
28,
27
],
[
40,
28
],
[
24,
32
],
[
36,
32
],
[
27,
33
],
[
38,
33
],
[
40,
34
],
[
36,
36
],
[
38,
38
],
[
40,
40
],
[
45,
44
],
[
66,
45
],
[
48,
47
],
[
66,
48
],
[
44,
52
],
[
62,
52
],
[
47,
55
],
[
64,
55
],
[
66,
57
],
[
66,
59
],
[
66,
60
],
[
62,
62
],
[
64,
64
],
[
66,
66
],
[
111,
71
],
[
111,
78
],
[
83,
82
],
[
109,
85
],
[
111,
87
],
[
113,
89
],
[
82,
93
],
[
82,
94
],
[
113,
95
],
[
109,
99
],
[
109,
102
],
[
111,
104
],
[
113,
106
],
[
113,
107
],
[
109,
109
],
[
111,
111
],
[
113,
113
],
[
118,
117
],
[
158,
122
],
[
128,
125
],
[
117,
126
],
[
158,
127
],
[
377,
129
],
[
162,
131
],
[
160,
132
],
[
135,
134
],
[
158,
139
],
[
144,
141
],
[
117,
142
],
[
134,
143
],
[
383,
145
],
[
117,
147
],
[
134,
149
],
[
134,
152
],
[
160,
154
],
[
117,
156
],
[
158,
158
],
[
160,
160
],
[
162,
162
],
[
167,
166
],
[
201,
171
],
[
177,
174
],
[
166,
175
],
[
180,
179
],
[
201,
182
],
[
189,
184
],
[
166,
185
],
[
179,
187
],
[
179,
192
],
[
166,
195
],
[
179,
196
],
[
203,
197
],
[
166,
199
],
[
201,
201
],
[
203,
203
],
[
247,
210
],
[
215,
214
],
[
247,
216
],
[
241,
217
],
[
220,
219
],
[
249,
221
],
[
243,
222
],
[
225,
224
],
[
249,
226
],
[
241,
228
],
[
243,
229
],
[
383,
232
],
[
383,
234
],
[
214,
235
],
[
219,
236
],
[
245,
237
],
[
224,
238
],
[
245,
239
],
[
241,
241
],
[
243,
243
],
[
245,
245
],
[
247,
247
],
[
249,
249
],
[
254,
253
],
[
362,
255
],
[
254,
256
],
[
254,
257
],
[
254,
258
],
[
261,
260
],
[
264,
263
],
[
271,
270
],
[
374,
272
],
[
253,
275
],
[
256,
276
],
[
263,
278
],
[
281,
280
],
[
368,
282
],
[
253,
285
],
[
256,
286
],
[
263,
288
],
[
270,
290
],
[
253,
293
],
[
256,
294
],
[
298,
297
],
[
253,
301
],
[
257,
302
],
[
305,
304
],
[
380,
306
],
[
258,
309
],
[
297,
311
],
[
258,
313
],
[
263,
315
],
[
270,
316
],
[
280,
317
],
[
320,
319
],
[
380,
321
],
[
253,
325
],
[
256,
326
],
[
258,
330
],
[
297,
332
],
[
256,
335
],
[
258,
336
],
[
263,
338
],
[
270,
339
],
[
280,
340
],
[
343,
342
],
[
304,
345
],
[
319,
346
],
[
263,
347
],
[
350,
349
],
[
263,
350
],
[
349,
353
],
[
342,
353
],
[
260,
353
],
[
371,
359
]
] | [
"#!/usr/bin/python\n# -*- coding: UTF-8 -*-\n\nimport sys\n\n\ndef get_ints():\n return map(int, sys.stdin.readline().strip().split())\n\n\ndef mul(x, y, mod):\n x %= mod\n y %= mod\n return x * y % mod\n\n\ndef div(x, y, mod):\n x %= mod\n y %= mod\n return x * mod_pow(y, mod - 2, mod) % mod\n\n\ndef mod_pow(a, p, mod):\n if p == 0:\n return 1\n if p % 2 == 0:\n root = mod_pow(a, p / 2, mod)\n return root * root % mod\n else:\n return a * mod_pow(a, p - 1, mod) % mod\n\n\ndef pre_factorial_divs(n, mod, factorials):\n factorial_divs = [0] * (n + 1)\n\n factorial_divs[n] = div(1, factorials, mod)\n for i in reversed(range(n)):\n factorial_divs[i] = mul(factorial_divs[i+1], i+1, mod)\n return factorial_divs\n\n\ndef pre_factorials(n, mod):\n factorials = [0] * (n + 1)\n factorials[0] = 1\n for i in range(n):\n factorials[i + 1] = (i + 1) * factorials[i] % mod\n return factorials\n\n\ndef fast_fast_fermat_comb(a, b, mod, factorials, factorial_divs):\n if len(factorials) == 0:\n raise\n af = factorials[a]\n bf = factorial_divs[b]\n abf = factorial_divs[a - b]\n return mul(mul(af, bf, mod), abf, mod)\n\n\ndef main():\n h, w, a, b = get_ints()\n\n ans = 0\n mod = 10 ** 9 + 7\n\n factorials = pre_factorials(h+w-2, mod)\n factorial_divs = pre_factorial_divs(h+w-2, mod, factorials[h+w-2])\n\n for i in range(h-a):\n x = fast_fast_fermat_comb(b-1+i, b-1, mod, factorials, factorial_divs)\n y = fast_fast_fermat_comb(h+w-3-(b-1+i), w-b-1, mod, factorials, factorial_divs)\n ans += x * y % mod\n ans %= mod\n\n print(ans)\n\n\nif __name__ == \"__main__\":\n main()",
"import sys",
"sys",
"def get_ints():\n return map(int, sys.stdin.readline().strip().split())",
"get_ints",
"return map(int, sys.stdin.readline().strip().split())",
"map(int, sys.stdin.readline().strip().split())",
"map",
"int",
"sys.stdin.readline().strip().split()",
"sys.stdin.readline().strip().split",
"sys.stdin.readline().strip()",
"sys.stdin.readline().strip",
"sys.stdin.readline()",
"sys.stdin.readline",
"sys.stdin",
"sys",
"stdin",
"readline",
"strip",
"split",
"def mul(x, y, mod):\n x %= mod\n y %= mod\n return x * y % mod",
"mul",
"x %= mod",
"x",
"mod",
"y %= mod",
"y",
"mod",
"return x * y % mod",
"x * y % mod",
"x * y",
"x",
"y",
"mod",
"x",
"x",
"y",
"y",
"mod",
"mod",
"def div(x, y, mod):\n x %= mod\n y %= mod\n return x * mod_pow(y, mod - 2, mod) % mod",
"div",
"x %= mod",
"x",
"mod",
"y %= mod",
"y",
"mod",
"return x * mod_pow(y, mod - 2, mod) % mod",
"x * mod_pow(y, mod - 2, mod) % mod",
"x * mod_pow(y, mod - 2, mod)",
"x",
"mod_pow(y, mod - 2, mod)",
"mod_pow",
"y",
"mod - 2",
"mod",
"2",
"mod",
"mod",
"x",
"x",
"y",
"y",
"mod",
"mod",
"def mod_pow(a, p, mod):\n if p == 0:\n return 1\n if p % 2 == 0:\n root = mod_pow(a, p / 2, mod)\n return root * root % mod\n else:\n return a * mod_pow(a, p - 1, mod) % mod",
"mod_pow",
"if p == 0:\n return 1\n ",
"p == 0",
"p",
"0",
"return 1",
"1",
"if p % 2 == 0:\n root = mod_pow(a, p / 2, mod)\n return root * root % mod\n else:\n return a * mod_pow(a, p - 1, mod) % mod",
"p % 2 == 0",
"p % 2",
"p",
"2",
"0",
"root = mod_pow(a, p / 2, mod)",
"root",
"mod_pow(a, p / 2, mod)",
"mod_pow",
"a",
"p / 2",
"p",
"2",
"mod",
"return root * root % mod",
"root * root % mod",
"root * root",
"root",
"root",
"mod",
"return a * mod_pow(a, p - 1, mod) % mod",
"a * mod_pow(a, p - 1, mod) % mod",
"a * mod_pow(a, p - 1, mod)",
"a",
"mod_pow(a, p - 1, mod)",
"mod_pow",
"a",
"p - 1",
"p",
"1",
"mod",
"mod",
"a",
"a",
"p",
"p",
"mod",
"mod",
"def pre_factorial_divs(n, mod, factorials):\n factorial_divs = [0] * (n + 1)\n\n factorial_divs[n] = div(1, factorials, mod)\n for i in reversed(range(n)):\n factorial_divs[i] = mul(factorial_divs[i+1], i+1, mod)\n return factorial_divs",
"pre_factorial_divs",
"factorial_divs = [0] * (n + 1)",
"factorial_divs",
"[0] * (n + 1)",
"[0]",
"0",
"n + 1",
"n",
"1",
"factorial_divs[n] = div(1, factorials, mod)",
"factorial_divs[n]",
"factorial_divs",
"n",
"div(1, factorials, mod)",
"div",
"1",
"factorials",
"mod",
"for i in reversed(range(n)):\n factorial_divs[i] = mul(factorial_divs[i+1], i+1, mod)\n ",
"i",
"reversed(range(n))",
"reversed",
"range(n)",
"range",
"n",
"factorial_divs[i] = mul(factorial_divs[i+1], i+1, mod)",
"factorial_divs[i]",
"factorial_divs",
"i",
"mul(factorial_divs[i+1], i+1, mod)",
"mul",
"factorial_divs[i+1]",
"factorial_divs",
"i+1",
"i",
"1",
"i+1",
"i",
"1",
"mod",
"return factorial_divs",
"factorial_divs",
"n",
"n",
"mod",
"mod",
"factorials",
"factorials",
"def pre_factorials(n, mod):\n factorials = [0] * (n + 1)\n factorials[0] = 1\n for i in range(n):\n factorials[i + 1] = (i + 1) * factorials[i] % mod\n return factorials",
"pre_factorials",
"factorials = [0] * (n + 1)",
"factorials",
"[0] * (n + 1)",
"[0]",
"0",
"n + 1",
"n",
"1",
"factorials[0] = 1",
"factorials[0]",
"factorials",
"0",
"1",
"for i in range(n):\n factorials[i + 1] = (i + 1) * factorials[i] % mod\n ",
"i",
"range(n)",
"range",
"n",
"factorials[i + 1] = (i + 1) * factorials[i] % mod",
"factorials[i + 1]",
"factorials",
"i + 1",
"i",
"1",
"(i + 1) * factorials[i] % mod",
"(i + 1) * factorials[i]",
"i + 1",
"i",
"1",
"factorials[i]",
"factorials",
"i",
"mod",
"return factorials",
"factorials",
"n",
"n",
"mod",
"mod",
"def fast_fast_fermat_comb(a, b, mod, factorials, factorial_divs):\n if len(factorials) == 0:\n raise\n af = factorials[a]\n bf = factorial_divs[b]\n abf = factorial_divs[a - b]\n return mul(mul(af, bf, mod), abf, mod)",
"fast_fast_fermat_comb",
"if len(factorials) == 0:\n raise\n ",
"len(factorials) == 0",
"len(factorials)",
"len",
"factorials",
"0",
"raise",
"af = factorials[a]",
"af",
"factorials[a]",
"factorials",
"a",
"bf = factorial_divs[b]",
"bf",
"factorial_divs[b]",
"factorial_divs",
"b",
"abf = factorial_divs[a - b]",
"abf",
"factorial_divs[a - b]",
"factorial_divs",
"a - b",
"a",
"b",
"return mul(mul(af, bf, mod), abf, mod)",
"mul(mul(af, bf, mod), abf, mod)",
"mul",
"mul(af, bf, mod)",
"mul",
"af",
"bf",
"mod",
"abf",
"mod",
"a",
"a",
"b",
"b",
"mod",
"mod",
"factorials",
"factorials",
"factorial_divs",
"factorial_divs",
"def main():\n h, w, a, b = get_ints()\n\n ans = 0\n mod = 10 ** 9 + 7\n\n factorials = pre_factorials(h+w-2, mod)\n factorial_divs = pre_factorial_divs(h+w-2, mod, factorials[h+w-2])\n\n for i in range(h-a):\n x = fast_fast_fermat_comb(b-1+i, b-1, mod, factorials, factorial_divs)\n y = fast_fast_fermat_comb(h+w-3-(b-1+i), w-b-1, mod, factorials, factorial_divs)\n ans += x * y % mod\n ans %= mod\n\n print(ans)",
"main",
"h, w, a, b = get_ints()",
"h",
"get_ints()",
"get_ints",
"w",
"a",
"b",
"ans = 0",
"ans",
"0",
"mod = 10 ** 9 + 7",
"mod",
"10 ** 9 + 7",
"10 ** 9",
"10",
"9",
"7",
"factorials = pre_factorials(h+w-2, mod)",
"factorials",
"pre_factorials(h+w-2, mod)",
"pre_factorials",
"h+w-2",
"h+w",
"h",
"w",
"2",
"mod",
"factorial_divs = pre_factorial_divs(h+w-2, mod, factorials[h+w-2])",
"factorial_divs",
"pre_factorial_divs(h+w-2, mod, factorials[h+w-2])",
"pre_factorial_divs",
"h+w-2",
"h+w",
"h",
"w",
"2",
"mod",
"factorials[h+w-2]",
"factorials",
"h+w-2",
"h+w",
"h",
"w",
"2",
"for i in range(h-a):\n x = fast_fast_fermat_comb(b-1+i, b-1, mod, factorials, factorial_divs)\n y = fast_fast_fermat_comb(h+w-3-(b-1+i), w-b-1, mod, factorials, factorial_divs)\n ans += x * y % mod\n ans %= mod\n\n ",
"i",
"range(h-a)",
"range",
"h-a",
"h",
"a",
"x = fast_fast_fermat_comb(b-1+i, b-1, mod, factorials, factorial_divs)",
"x",
"fast_fast_fermat_comb(b-1+i, b-1, mod, factorials, factorial_divs)",
"fast_fast_fermat_comb",
"b-1+i",
"b-1",
"b",
"1",
"i",
"b-1",
"b",
"1",
"mod",
"factorials",
"factorial_divs",
"y = fast_fast_fermat_comb(h+w-3-(b-1+i), w-b-1, mod, factorials, factorial_divs)",
"y",
"fast_fast_fermat_comb(h+w-3-(b-1+i), w-b-1, mod, factorials, factorial_divs)",
"fast_fast_fermat_comb",
"h+w-3-(b-1+i)",
"h+w-3",
"h+w",
"h",
"w",
"3",
"b-1+i",
"b-1",
"b",
"1",
"i",
"w-b-1",
"w-b",
"w",
"b",
"1",
"mod",
"factorials",
"factorial_divs",
"ans += x * y % mod",
"ans",
"x * y % mod",
"x * y",
"x",
"y",
"mod",
"ans %= mod",
"ans",
"mod",
"print(ans)",
"print",
"ans",
"if __name__ == \"__main__\":\n main()",
"__name__ == \"__main__\"",
"__name__",
"\"__main__\"",
"main()",
"main",
"def get_ints():\n return map(int, sys.stdin.readline().strip().split())",
"def get_ints():\n return map(int, sys.stdin.readline().strip().split())",
"get_ints",
"def mod_pow(a, p, mod):\n if p == 0:\n return 1\n if p % 2 == 0:\n root = mod_pow(a, p / 2, mod)\n return root * root % mod\n else:\n return a * mod_pow(a, p - 1, mod) % mod",
"def mod_pow(a, p, mod):\n if p == 0:\n return 1\n if p % 2 == 0:\n root = mod_pow(a, p / 2, mod)\n return root * root % mod\n else:\n return a * mod_pow(a, p - 1, mod) % mod",
"mod_pow",
"def pre_factorial_divs(n, mod, factorials):\n factorial_divs = [0] * (n + 1)\n\n factorial_divs[n] = div(1, factorials, mod)\n for i in reversed(range(n)):\n factorial_divs[i] = mul(factorial_divs[i+1], i+1, mod)\n return factorial_divs",
"def pre_factorial_divs(n, mod, factorials):\n factorial_divs = [0] * (n + 1)\n\n factorial_divs[n] = div(1, factorials, mod)\n for i in reversed(range(n)):\n factorial_divs[i] = mul(factorial_divs[i+1], i+1, mod)\n return factorial_divs",
"pre_factorial_divs",
"def main():\n h, w, a, b = get_ints()\n\n ans = 0\n mod = 10 ** 9 + 7\n\n factorials = pre_factorials(h+w-2, mod)\n factorial_divs = pre_factorial_divs(h+w-2, mod, factorials[h+w-2])\n\n for i in range(h-a):\n x = fast_fast_fermat_comb(b-1+i, b-1, mod, factorials, factorial_divs)\n y = fast_fast_fermat_comb(h+w-3-(b-1+i), w-b-1, mod, factorials, factorial_divs)\n ans += x * y % mod\n ans %= mod\n\n print(ans)",
"def main():\n h, w, a, b = get_ints()\n\n ans = 0\n mod = 10 ** 9 + 7\n\n factorials = pre_factorials(h+w-2, mod)\n factorial_divs = pre_factorial_divs(h+w-2, mod, factorials[h+w-2])\n\n for i in range(h-a):\n x = fast_fast_fermat_comb(b-1+i, b-1, mod, factorials, factorial_divs)\n y = fast_fast_fermat_comb(h+w-3-(b-1+i), w-b-1, mod, factorials, factorial_divs)\n ans += x * y % mod\n ans %= mod\n\n print(ans)",
"main",
"def pre_factorials(n, mod):\n factorials = [0] * (n + 1)\n factorials[0] = 1\n for i in range(n):\n factorials[i + 1] = (i + 1) * factorials[i] % mod\n return factorials",
"def pre_factorials(n, mod):\n factorials = [0] * (n + 1)\n factorials[0] = 1\n for i in range(n):\n factorials[i + 1] = (i + 1) * factorials[i] % mod\n return factorials",
"pre_factorials",
"def div(x, y, mod):\n x %= mod\n y %= mod\n return x * mod_pow(y, mod - 2, mod) % mod",
"def div(x, y, mod):\n x %= mod\n y %= mod\n return x * mod_pow(y, mod - 2, mod) % mod",
"div",
"def fast_fast_fermat_comb(a, b, mod, factorials, factorial_divs):\n if len(factorials) == 0:\n raise\n af = factorials[a]\n bf = factorial_divs[b]\n abf = factorial_divs[a - b]\n return mul(mul(af, bf, mod), abf, mod)",
"def fast_fast_fermat_comb(a, b, mod, factorials, factorial_divs):\n if len(factorials) == 0:\n raise\n af = factorials[a]\n bf = factorial_divs[b]\n abf = factorial_divs[a - b]\n return mul(mul(af, bf, mod), abf, mod)",
"fast_fast_fermat_comb",
"def mul(x, y, mod):\n x %= mod\n y %= mod\n return x * y % mod",
"def mul(x, y, mod):\n x %= mod\n y %= mod\n return x * y % mod",
"mul"
] | #!/usr/bin/python
# -*- coding: UTF-8 -*-
import sys
def get_ints():
return map(int, sys.stdin.readline().strip().split())
def mul(x, y, mod):
x %= mod
y %= mod
return x * y % mod
def div(x, y, mod):
x %= mod
y %= mod
return x * mod_pow(y, mod - 2, mod) % mod
def mod_pow(a, p, mod):
if p == 0:
return 1
if p % 2 == 0:
root = mod_pow(a, p / 2, mod)
return root * root % mod
else:
return a * mod_pow(a, p - 1, mod) % mod
def pre_factorial_divs(n, mod, factorials):
factorial_divs = [0] * (n + 1)
factorial_divs[n] = div(1, factorials, mod)
for i in reversed(range(n)):
factorial_divs[i] = mul(factorial_divs[i+1], i+1, mod)
return factorial_divs
def pre_factorials(n, mod):
factorials = [0] * (n + 1)
factorials[0] = 1
for i in range(n):
factorials[i + 1] = (i + 1) * factorials[i] % mod
return factorials
def fast_fast_fermat_comb(a, b, mod, factorials, factorial_divs):
if len(factorials) == 0:
raise
af = factorials[a]
bf = factorial_divs[b]
abf = factorial_divs[a - b]
return mul(mul(af, bf, mod), abf, mod)
def main():
h, w, a, b = get_ints()
ans = 0
mod = 10 ** 9 + 7
factorials = pre_factorials(h+w-2, mod)
factorial_divs = pre_factorial_divs(h+w-2, mod, factorials[h+w-2])
for i in range(h-a):
x = fast_fast_fermat_comb(b-1+i, b-1, mod, factorials, factorial_divs)
y = fast_fast_fermat_comb(h+w-3-(b-1+i), w-b-1, mod, factorials, factorial_divs)
ans += x * y % mod
ans %= mod
print(ans)
if __name__ == "__main__":
main()
|
[
7,
6,
13,
12,
13,
17,
0,
13,
2,
2,
17,
17,
17,
0,
13,
2,
17,
2,
17,
17,
0,
18,
13,
13,
2,
39,
17,
13,
0,
18,
13,
13,
2,
39,
17,
13,
0,
18,
13,
13,
2,
39,
17,
13,
0,
18,
18,
13,
13,
17,
17,
0,
18,
18,
13,
13,
17,
17,
0,
18,
18,
13,
13,
17,
17,
0,
18,
18,
13,
13,
17,
17,
0,
18,
18,
13,
13,
17,
17,
28,
13,
4,
13,
17,
13,
0,
18,
18,
13,
13,
13,
2,
2,
18,
18,
13,
13,
2,
13,
17,
13,
13,
0,
18,
18,
13,
13,
13,
2,
13,
2,
2,
18,
18,
13,
13,
2,
13,
13,
2,
13,
13,
13,
0,
18,
18,
13,
13,
13,
2,
2,
18,
18,
13,
13,
2,
13,
17,
18,
18,
13,
13,
13,
13,
23,
13,
12,
13,
0,
13,
2,
2,
17,
17,
17,
14,
2,
13,
13,
29,
17,
14,
2,
2,
13,
17,
2,
13,
17,
29,
17,
29,
2,
2,
18,
18,
13,
13,
13,
2,
2,
18,
18,
13,
13,
13,
18,
18,
13,
13,
2,
13,
13,
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,
0,
13,
17,
0,
13,
2,
2,
17,
17,
17,
28,
13,
4,
13,
2,
13,
13,
0,
13,
4,
18,
13,
13,
2,
2,
13,
17,
13,
13,
0,
13,
2,
2,
13,
17,
13,
0,
13,
2,
2,
13,
17,
13,
0,
13,
4,
18,
13,
13,
2,
13,
13,
13,
0,
13,
13,
0,
13,
13,
0,
13,
13,
4,
13,
13,
10,
4,
13,
10,
17,
13,
10,
4,
13,
10,
4,
13,
10,
13,
13,
10,
13,
13,
10,
4,
13,
10,
4,
13,
10,
13,
13,
10,
2,
13,
10,
4,
13,
10,
2,
13,
10,
2,
13,
10,
4,
13,
10,
6,
13
] | [
[
8,
7
],
[
15,
14
],
[
24,
21
],
[
145,
22
],
[
14,
27
],
[
32,
29
],
[
145,
30
],
[
14,
35
],
[
40,
37
],
[
145,
38
],
[
14,
43
],
[
57,
45
],
[
21,
46
],
[
145,
47
],
[
57,
52
],
[
21,
53
],
[
145,
54
],
[
71,
59
],
[
29,
60
],
[
145,
61
],
[
71,
66
],
[
29,
67
],
[
145,
68
],
[
78,
73
],
[
37,
74
],
[
145,
75
],
[
81,
80
],
[
14,
84
],
[
91,
86
],
[
21,
87
],
[
145,
88
],
[
80,
90
],
[
21,
94
],
[
145,
95
],
[
80,
98
],
[
80,
100
],
[
7,
101
],
[
108,
103
],
[
37,
104
],
[
145,
105
],
[
80,
107
],
[
7,
109
],
[
37,
113
],
[
145,
114
],
[
7,
117
],
[
80,
118
],
[
7,
120
],
[
80,
121
],
[
7,
122
],
[
129,
124
],
[
29,
125
],
[
145,
126
],
[
80,
128
],
[
29,
132
],
[
145,
133
],
[
80,
136
],
[
103,
138
],
[
37,
139
],
[
145,
140
],
[
80,
142
],
[
7,
143
],
[
145,
145
],
[
150,
149
],
[
198,
157
],
[
200,
158
],
[
198,
164
],
[
200,
167
],
[
196,
176
],
[
198,
178
],
[
196,
183
],
[
200,
185
],
[
196,
188
],
[
198,
191
],
[
200,
192
],
[
149,
193
],
[
149,
194
],
[
196,
196
],
[
198,
198
],
[
200,
200
],
[
305,
202
],
[
305,
211
],
[
305,
212
],
[
305,
213
],
[
284,
215
],
[
287,
219
],
[
317,
222
],
[
230,
229
],
[
303,
233
],
[
294,
234
],
[
314,
236
],
[
285,
239
],
[
147,
240
],
[
291,
243
],
[
229,
245
],
[
229,
246
],
[
311,
248
],
[
303,
251
],
[
229,
253
],
[
320,
255
],
[
306,
258
],
[
291,
260
],
[
323,
262
],
[
285,
265
],
[
147,
266
],
[
312,
268
],
[
321,
269
],
[
312,
270
],
[
299,
272
],
[
318,
273
],
[
308,
275
],
[
300,
276
],
[
324,
276
],
[
315,
276
],
[
296,
278
],
[
318,
279
],
[
297,
282
],
[
309,
282
],
[
288,
282
],
[
284,
285
],
[
287,
288
],
[
305,
291
],
[
305,
294
],
[
318,
296
],
[
296,
297
],
[
318,
299
],
[
299,
300
],
[
305,
303
],
[
305,
306
],
[
300,
308
],
[
324,
308
],
[
315,
308
],
[
308,
309
],
[
311,
312
],
[
314,
315
],
[
317,
318
],
[
320,
321
],
[
323,
324
]
] | [
"class CombinationFermat:\n\n def __init__(self):\n \"\"\"O(MAX)で前計算しておく→以降comb(a,b)はO(1)で取得可能\n \"\"\"\n MOD = 10**9 + 7\n MAX = 2*10**5\n\n self.fac = [0]*MAX # self.fac[n]: (n!) mod p\n self.finv = [0]*MAX # self.finv[n]: (n!)^-1 mod p\n self.inv = [0]*MAX # inv[n]: (n)^-1 mod -p\n self.fac[0] = self.fac[1] = 1\n self.finv[0] = self.finv[1] = 1\n self.inv[1] = 1\n for i in range(2, MAX):\n self.fac[i] = self.fac[i-1] * i % MOD\n self.inv[i] = MOD - self.inv[MOD % i] * (MOD//i) % MOD\n self.finv[i] = self.finv[i-1] * self.inv[i] % MOD\n\n def comb(self, n: int, r: int) -> int:\n MOD = 10**9 + 7\n if n < r:\n return 0\n if n < 0 or r < 0:\n return 0\n return self.fac[n] * (self.finv[r] * self.finv[n-r] % MOD) % MOD\n\n\nH, W, A, B = map(int, input().split())\nc = CombinationFermat()\nans = 0\nMOD = 10**9 + 7\n\nfor i in range(H-A):\n x = c.comb(B-1+i, i)\n a = H-1-i\n b = W-1-B\n x *= c.comb(a+b, a)\n x %= MOD\n ans += x\nans %= MOD\nprint(ans)",
"class CombinationFermat:\n\n def __init__(self):\n \"\"\"O(MAX)で前計算しておく→以降comb(a,b)はO(1)で取得可能\n \"\"\"\n MOD = 10**9 + 7\n MAX = 2*10**5\n\n self.fac = [0]*MAX # self.fac[n]: (n!) mod p\n self.finv = [0]*MAX # self.finv[n]: (n!)^-1 mod p\n self.inv = [0]*MAX # inv[n]: (n)^-1 mod -p\n self.fac[0] = self.fac[1] = 1\n self.finv[0] = self.finv[1] = 1\n self.inv[1] = 1\n for i in range(2, MAX):\n self.fac[i] = self.fac[i-1] * i % MOD\n self.inv[i] = MOD - self.inv[MOD % i] * (MOD//i) % MOD\n self.finv[i] = self.finv[i-1] * self.inv[i] % MOD\n\n def comb(self, n: int, r: int) -> int:\n MOD = 10**9 + 7\n if n < r:\n return 0\n if n < 0 or r < 0:\n return 0\n return self.fac[n] * (self.finv[r] * self.finv[n-r] % MOD) % MOD",
"CombinationFermat",
"def __init__(self):\n \"\"\"O(MAX)で前計算しておく→以降comb(a,b)はO(1)で取得可能\n \"\"\"\n MOD = 10**9 + 7\n MAX = 2*10**5\n\n self.fac = [0]*MAX # self.fac[n]: (n!) mod p\n self.finv = [0]*MAX # self.finv[n]: (n!)^-1 mod p\n self.inv = [0]*MAX # inv[n]: (n)^-1 mod -p\n self.fac[0] = self.fac[1] = 1\n self.finv[0] = self.finv[1] = 1\n self.inv[1] = 1\n for i in range(2, MAX):\n self.fac[i] = self.fac[i-1] * i % MOD\n self.inv[i] = MOD - self.inv[MOD % i] * (MOD//i) % MOD\n self.finv[i] = self.finv[i-1] * self.inv[i] % MOD\n\n ",
"__init__",
"\"\"\"O(MAX)で前計算しておく→以降comb(a,b)はO(1)で取得可能\n \"\"\"",
"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",
"self.fac = [0]*MAX",
"self.fac",
"self",
"fac",
"[0]*MAX",
"[0]",
"0",
"MAX",
"self.finv = [0]*MAX",
"self.finv",
"self",
"finv",
"[0]*MAX",
"[0]",
"0",
"MAX",
"self.inv = [0]*MAX",
"self.inv",
"self",
"inv",
"[0]*MAX",
"[0]",
"0",
"MAX",
"self.fac[0] = self.fac[1] = 1",
"self.fac[0]",
"self.fac",
"self",
"fac",
"0",
"1",
"= self.fac[1] = 1",
"self.fac[1]",
"self.fac",
"self",
"fac",
"1",
"1",
"self.finv[0] = self.finv[1] = 1",
"self.finv[0]",
"self.finv",
"self",
"finv",
"0",
"1",
"= self.finv[1] = 1",
"self.finv[1]",
"self.finv",
"self",
"finv",
"1",
"1",
"self.inv[1] = 1",
"self.inv[1]",
"self.inv",
"self",
"inv",
"1",
"1",
"for i in range(2, MAX):\n self.fac[i] = self.fac[i-1] * i % MOD\n self.inv[i] = MOD - self.inv[MOD % i] * (MOD//i) % MOD\n self.finv[i] = self.finv[i-1] * self.inv[i] % MOD\n\n ",
"i",
"range(2, MAX)",
"range",
"2",
"MAX",
"self.fac[i] = self.fac[i-1] * i % MOD",
"self.fac[i]",
"self.fac",
"self",
"fac",
"i",
"self.fac[i-1] * i % MOD",
"self.fac[i-1] * i",
"self.fac[i-1]",
"self.fac",
"self",
"fac",
"i-1",
"i",
"1",
"i",
"MOD",
"self.inv[i] = MOD - self.inv[MOD % i] * (MOD//i) % MOD",
"self.inv[i]",
"self.inv",
"self",
"inv",
"i",
"MOD - self.inv[MOD % i] * (MOD//i) % MOD",
"MOD",
"self.inv[MOD % i] * (MOD//i) % MOD",
"self.inv[MOD % i] * (MOD//i)",
"self.inv[MOD % i]",
"self.inv",
"self",
"inv",
"MOD % i",
"MOD",
"i",
"MOD//i",
"MOD",
"i",
"MOD",
"self.finv[i] = self.finv[i-1] * self.inv[i] % MOD",
"self.finv[i]",
"self.finv",
"self",
"finv",
"i",
"self.finv[i-1] * self.inv[i] % MOD",
"self.finv[i-1] * self.inv[i]",
"self.finv[i-1]",
"self.finv",
"self",
"finv",
"i-1",
"i",
"1",
"self.inv[i]",
"self.inv",
"self",
"inv",
"i",
"MOD",
"self",
"self",
"def comb(self, n: int, r: int) -> int:\n MOD = 10**9 + 7\n if n < r:\n return 0\n if n < 0 or r < 0:\n return 0\n return self.fac[n] * (self.finv[r] * self.finv[n-r] % MOD) % MOD",
"comb",
"MOD = 10**9 + 7",
"MOD",
"10**9 + 7",
"10**9",
"10",
"9",
"7",
"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 self.fac[n] * (self.finv[r] * self.finv[n-r] % MOD) % MOD",
"self.fac[n] * (self.finv[r] * self.finv[n-r] % MOD) % MOD",
"self.fac[n] * (self.finv[r] * self.finv[n-r] % MOD)",
"self.fac[n]",
"self.fac",
"self",
"fac",
"n",
"self.finv[r] * self.finv[n-r] % MOD",
"self.finv[r] * self.finv[n-r]",
"self.finv[r]",
"self.finv",
"self",
"finv",
"r",
"self.finv[n-r]",
"self.finv",
"self",
"finv",
"n-r",
"n",
"r",
"MOD",
"MOD",
"self",
"self",
"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",
"c = CombinationFermat()",
"c",
"CombinationFermat()",
"CombinationFermat",
"ans = 0",
"ans",
"0",
"MOD = 10**9 + 7",
"MOD",
"10**9 + 7",
"10**9",
"10",
"9",
"7",
"for i in range(H-A):\n x = c.comb(B-1+i, i)\n a = H-1-i\n b = W-1-B\n x *= c.comb(a+b, a)\n x %= MOD\n ans += x",
"i",
"range(H-A)",
"range",
"H-A",
"H",
"A",
"x = c.comb(B-1+i, i)",
"x",
"c.comb(B-1+i, i)",
"c.comb",
"c",
"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 *= c.comb(a+b, a)",
"x",
"c.comb(a+b, a)",
"c.comb",
"c",
"comb",
"a+b",
"a",
"b",
"a",
"x %= MOD",
"x",
"MOD",
"ans += x",
"ans",
"x",
"ans %= MOD",
"ans",
"MOD",
"print(ans)",
"print",
"ans",
"c = CombinationFermat()",
"CombinationFermat()",
"c",
"ans = 0",
"0",
"ans",
"B = map(int, input().split())",
"map(int, input().split())",
"B",
"A, B = map(int, input().split())",
"map(int, input().split())",
"A",
"ans %= MOD",
"MOD",
"ans",
"x %= MOD",
"MOD",
"x",
"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 += x",
"x",
"ans",
"a = H-1-i",
"H-1-i",
"a",
"x = c.comb(B-1+i, i)",
"c.comb(B-1+i, i)",
"x",
"MOD = 10**9 + 7",
"10**9 + 7",
"MOD",
"b = W-1-B",
"W-1-B",
"b",
"x *= c.comb(a+b, a)",
"c.comb(a+b, a)",
"x",
"class CombinationFermat:\n\n def __init__(self):\n \"\"\"O(MAX)で前計算しておく→以降comb(a,b)はO(1)で取得可能\n \"\"\"\n MOD = 10**9 + 7\n MAX = 2*10**5\n\n self.fac = [0]*MAX # self.fac[n]: (n!) mod p\n self.finv = [0]*MAX # self.finv[n]: (n!)^-1 mod p\n self.inv = [0]*MAX # inv[n]: (n)^-1 mod -p\n self.fac[0] = self.fac[1] = 1\n self.finv[0] = self.finv[1] = 1\n self.inv[1] = 1\n for i in range(2, MAX):\n self.fac[i] = self.fac[i-1] * i % MOD\n self.inv[i] = MOD - self.inv[MOD % i] * (MOD//i) % MOD\n self.finv[i] = self.finv[i-1] * self.inv[i] % MOD\n\n def comb(self, n: int, r: int) -> int:\n MOD = 10**9 + 7\n if n < r:\n return 0\n if n < 0 or r < 0:\n return 0\n return self.fac[n] * (self.finv[r] * self.finv[n-r] % MOD) % MOD",
"class CombinationFermat:\n\n def __init__(self):\n \"\"\"O(MAX)で前計算しておく→以降comb(a,b)はO(1)で取得可能\n \"\"\"\n MOD = 10**9 + 7\n MAX = 2*10**5\n\n self.fac = [0]*MAX # self.fac[n]: (n!) mod p\n self.finv = [0]*MAX # self.finv[n]: (n!)^-1 mod p\n self.inv = [0]*MAX # inv[n]: (n)^-1 mod -p\n self.fac[0] = self.fac[1] = 1\n self.finv[0] = self.finv[1] = 1\n self.inv[1] = 1\n for i in range(2, MAX):\n self.fac[i] = self.fac[i-1] * i % MOD\n self.inv[i] = MOD - self.inv[MOD % i] * (MOD//i) % MOD\n self.finv[i] = self.finv[i-1] * self.inv[i] % MOD\n\n def comb(self, n: int, r: int) -> int:\n MOD = 10**9 + 7\n if n < r:\n return 0\n if n < 0 or r < 0:\n return 0\n return self.fac[n] * (self.finv[r] * self.finv[n-r] % MOD) % MOD",
"CombinationFermat"
] | class CombinationFermat:
def __init__(self):
"""O(MAX)で前計算しておく→以降comb(a,b)はO(1)で取得可能
"""
MOD = 10**9 + 7
MAX = 2*10**5
self.fac = [0]*MAX # self.fac[n]: (n!) mod p
self.finv = [0]*MAX # self.finv[n]: (n!)^-1 mod p
self.inv = [0]*MAX # inv[n]: (n)^-1 mod -p
self.fac[0] = self.fac[1] = 1
self.finv[0] = self.finv[1] = 1
self.inv[1] = 1
for i in range(2, MAX):
self.fac[i] = self.fac[i-1] * i % MOD
self.inv[i] = MOD - self.inv[MOD % i] * (MOD//i) % MOD
self.finv[i] = self.finv[i-1] * self.inv[i] % MOD
def comb(self, n: int, r: int) -> int:
MOD = 10**9 + 7
if n < r:
return 0
if n < 0 or r < 0:
return 0
return self.fac[n] * (self.finv[r] * self.finv[n-r] % MOD) % MOD
H, W, A, B = map(int, input().split())
c = CombinationFermat()
ans = 0
MOD = 10**9 + 7
for i in range(H-A):
x = c.comb(B-1+i, i)
a = H-1-i
b = W-1-B
x *= c.comb(a+b, a)
x %= MOD
ans += x
ans %= MOD
print(ans)
|
[
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,
17,
2,
13,
13,
4,
18,
13,
13,
2,
2,
18,
13,
2,
13,
17,
13,
13,
12,
13,
0,
13,
17,
42,
2,
13,
17,
14,
2,
13,
17,
0,
13,
2,
13,
13,
0,
13,
17,
29,
13,
23,
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,
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,
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,
2,
4,
13,
2,
2,
2,
2,
13,
13,
17,
13,
13,
2,
13,
13,
4,
13,
2,
2,
2,
2,
2,
13,
17,
13,
13,
13,
17,
2,
13,
17,
13,
0,
13,
13,
4,
13,
13,
10,
39,
13,
10,
4,
13,
10,
12,
13,
10,
2,
13,
10,
2,
13,
10,
4,
13,
10,
4,
13,
10,
17,
13,
10,
2,
13,
10,
13,
13,
10,
12,
13,
10,
4,
13
] | [
[
237,
2
],
[
237,
11
],
[
237,
12
],
[
237,
13
],
[
228,
15
],
[
204,
22
],
[
27,
26
],
[
220,
31
],
[
238,
32
],
[
205,
35
],
[
205,
40
],
[
26,
42
],
[
26,
44
],
[
229,
45
],
[
50,
49
],
[
72,
53
],
[
65,
53
],
[
72,
57
],
[
65,
57
],
[
61,
60
],
[
70,
62
],
[
60,
62
],
[
74,
63
],
[
66,
65
],
[
49,
68
],
[
70,
70
],
[
72,
72
],
[
74,
74
],
[
213,
76
],
[
220,
81
],
[
238,
82
],
[
91,
84
],
[
214,
85
],
[
220,
88
],
[
238,
89
],
[
235,
92
],
[
205,
94
],
[
220,
97
],
[
238,
98
],
[
229,
101
],
[
229,
103
],
[
106,
105
],
[
220,
110
],
[
238,
111
],
[
119,
116
],
[
214,
117
],
[
105,
118
],
[
214,
122
],
[
105,
124
],
[
105,
127
],
[
229,
129
],
[
205,
137
],
[
149,
138
],
[
214,
140
],
[
151,
141
],
[
214,
143
],
[
149,
145
],
[
151,
146
],
[
229,
147
],
[
149,
149
],
[
151,
151
],
[
225,
153
],
[
157,
156
],
[
238,
160
],
[
223,
161
],
[
216,
163
],
[
211,
167
],
[
220,
172
],
[
208,
173
],
[
223,
175
],
[
156,
176
],
[
223,
178
],
[
156,
179
],
[
211,
181
],
[
208,
187
],
[
238,
189
],
[
223,
190
],
[
156,
191
],
[
208,
194
],
[
229,
196
],
[
231,
198
],
[
229,
199
],
[
232,
202
],
[
217,
202
],
[
226,
202
],
[
204,
205
],
[
237,
208
],
[
213,
214
],
[
216,
217
],
[
237,
220
],
[
237,
223
],
[
225,
226
],
[
228,
229
],
[
229,
231
],
[
231,
232
],
[
237,
238
]
] | [
"h, w, a, b = map(int, input().split())\n\nmod = 10**9+7\nfac = [1]\nfor n in range(1, h+w):\n\tfac.append(fac[n-1]*n%mod)\n\ndef modpow(a,n,mod):\n\tr=1\n\twhile n>0:\n\t\tif n&1:\tr = r*(a%mod)\n\t\ta *= a%mod\n\t\tn >>= 1\n\treturn r\n\ninvfac = [0] * (h+w)\ninvfac[h+w-1] = modpow(fac[h+w-1], mod-2, mod)\nfor n in range(h+w-2, -1, -1):\n\tinvfac[n] = invfac[n+1] * (n+1) % mod\n\ndef com(a,b):\n\treturn fac[a] * invfac[b] * invfac[a-b] % mod\n\nr=0\nfor i in range(w-b):\n\tr += com( h-a-1+b+i, b+i ) * com( a-1+w-b-i-1, a-1 ) % mod\n\tr %= mod\n\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",
"mod = 10**9+7",
"mod",
"10**9+7",
"10**9",
"10",
"9",
"7",
"fac = [1]",
"fac",
"[1]",
"1",
"for n in range(1, h+w):\n\tfac.append(fac[n-1]*n%mod)",
"n",
"range(1, h+w)",
"range",
"1",
"h+w",
"h",
"w",
"fac.append(fac[n-1]*n%mod)",
"fac.append",
"fac",
"append",
"fac[n-1]*n%mod",
"fac[n-1]*n",
"fac[n-1]",
"fac",
"n-1",
"n",
"1",
"n",
"mod",
"def modpow(a,n,mod):\n\tr=1\n\twhile n>0:\n\t\tif n&1:\tr = r*(a%mod)\n\t\ta *= a%mod\n\t\tn >>= 1\n\treturn r",
"modpow",
"r=1",
"r",
"1",
"while n>0:\n\t\tif n&1:\tr = r*(a%mod)\n\t\ta *= a%mod\n\t\tn >>= 1\n\t",
"n>0",
"n",
"0",
"if n&1:\tr = r*(a%mod)\n\t\t",
"n&1",
"n",
"1",
"a *= a%mod",
"a",
"a%mod",
"a",
"mod",
"n >>= 1",
"n",
"1",
"return r",
"r",
"a",
"a",
"n",
"n",
"mod",
"mod",
"invfac = [0] * (h+w)",
"invfac",
"[0] * (h+w)",
"[0]",
"0",
"h+w",
"h",
"w",
"invfac[h+w-1] = modpow(fac[h+w-1], mod-2, mod)",
"invfac[h+w-1]",
"invfac",
"h+w-1",
"h+w",
"h",
"w",
"1",
"modpow(fac[h+w-1], mod-2, mod)",
"modpow",
"fac[h+w-1]",
"fac",
"h+w-1",
"h+w",
"h",
"w",
"1",
"mod-2",
"mod",
"2",
"mod",
"for n in range(h+w-2, -1, -1):\n\tinvfac[n] = invfac[n+1] * (n+1) % mod",
"n",
"range(h+w-2, -1, -1)",
"range",
"h+w-2",
"h+w",
"h",
"w",
"2",
"-1",
"-1",
"invfac[n] = invfac[n+1] * (n+1) % mod",
"invfac[n]",
"invfac",
"n",
"invfac[n+1] * (n+1) % mod",
"invfac[n+1] * (n+1)",
"invfac[n+1]",
"invfac",
"n+1",
"n",
"1",
"n+1",
"n",
"1",
"mod",
"def com(a,b):\n\treturn fac[a] * invfac[b] * invfac[a-b] % mod",
"com",
"return fac[a] * invfac[b] * invfac[a-b] % mod",
"fac[a] * invfac[b] * invfac[a-b] % mod",
"fac[a] * invfac[b] * invfac[a-b]",
"fac[a] * invfac[b]",
"fac[a]",
"fac",
"a",
"invfac[b]",
"invfac",
"b",
"invfac[a-b]",
"invfac",
"a-b",
"a",
"b",
"mod",
"a",
"a",
"b",
"b",
"r=0",
"r",
"0",
"for i in range(w-b):\n\tr += com( h-a-1+b+i, b+i ) * com( a-1+w-b-i-1, a-1 ) % mod\n\tr %= mod",
"i",
"range(w-b)",
"range",
"w-b",
"w",
"b",
"r += com( h-a-1+b+i, b+i ) * com( a-1+w-b-i-1, a-1 ) % mod",
"r",
"com( h-a-1+b+i, b+i ) * com( a-1+w-b-i-1, a-1 ) % mod",
"com( h-a-1+b+i, b+i ) * com( a-1+w-b-i-1, a-1 )",
"com( h-a-1+b+i, b+i )",
"com",
"h-a-1+b+i",
"h-a-1+b",
"h-a-1",
"h-a",
"h",
"a",
"1",
"b",
"i",
"b+i",
"b",
"i",
"com( a-1+w-b-i-1, a-1 )",
"com",
"a-1+w-b-i-1",
"a-1+w-b-i",
"a-1+w-b",
"a-1+w",
"a-1",
"a",
"1",
"w",
"b",
"i",
"1",
"a-1",
"a",
"1",
"mod",
"r %= mod",
"r",
"mod",
"print(r)",
"print",
"r",
"fac = [1]",
"[1]",
"fac",
"a, b = map(int, input().split())",
"map(int, input().split())",
"a",
"def com(a,b):\n\treturn fac[a] * invfac[b] * invfac[a-b] % mod",
"def com(a,b):\n\treturn fac[a] * invfac[b] * invfac[a-b] % mod",
"com",
"invfac = [0] * (h+w)",
"[0] * (h+w)",
"invfac",
"r += com( h-a-1+b+i, b+i ) * com( a-1+w-b-i-1, a-1 ) % mod",
"com( h-a-1+b+i, b+i ) * com( a-1+w-b-i-1, a-1 ) % mod",
"r",
"h, w, a, b = map(int, input().split())",
"map(int, input().split())",
"h",
"b = map(int, input().split())",
"map(int, input().split())",
"b",
"r=0",
"0",
"r",
"mod = 10**9+7",
"10**9+7",
"mod",
"r %= mod",
"mod",
"r",
"def modpow(a,n,mod):\n\tr=1\n\twhile n>0:\n\t\tif n&1:\tr = r*(a%mod)\n\t\ta *= a%mod\n\t\tn >>= 1\n\treturn r",
"def modpow(a,n,mod):\n\tr=1\n\twhile n>0:\n\t\tif n&1:\tr = r*(a%mod)\n\t\ta *= a%mod\n\t\tn >>= 1\n\treturn r",
"modpow",
"w, a, b = map(int, input().split())",
"map(int, input().split())",
"w"
] | h, w, a, b = map(int, input().split())
mod = 10**9+7
fac = [1]
for n in range(1, h+w):
fac.append(fac[n-1]*n%mod)
def modpow(a,n,mod):
r=1
while n>0:
if n&1: r = r*(a%mod)
a *= a%mod
n >>= 1
return r
invfac = [0] * (h+w)
invfac[h+w-1] = modpow(fac[h+w-1], mod-2, mod)
for n in range(h+w-2, -1, -1):
invfac[n] = invfac[n+1] * (n+1) % mod
def com(a,b):
return fac[a] * invfac[b] * invfac[a-b] % mod
r=0
for i in range(w-b):
r += com( h-a-1+b+i, b+i ) * com( a-1+w-b-i-1, a-1 ) % mod
r %= mod
print(r)
|
[
7,
15,
13,
15,
0,
13,
2,
2,
17,
17,
17,
14,
2,
13,
17,
0,
39,
13,
13,
13,
13,
4,
13,
13,
4,
18,
4,
13,
13,
0,
13,
2,
39,
17,
2,
13,
13,
0,
18,
13,
17,
17,
0,
18,
13,
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,
18,
13,
13,
4,
13,
18,
13,
13,
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,
17,
28,
13,
4,
13,
2,
13,
13,
0,
13,
2,
13,
2,
13,
17,
0,
13,
2,
2,
2,
13,
13,
17,
2,
2,
13,
13,
17,
0,
13,
2,
2,
13,
2,
4,
13,
13,
2,
13,
17,
4,
13,
13,
2,
2,
13,
13,
17,
13,
4,
13,
13,
10,
17,
13,
10,
2,
13,
10,
2,
13,
10,
2,
13,
10,
2,
13,
10,
2,
13,
10,
2,
13,
10,
12,
13
] | [
[
198,
5
],
[
21,
16
],
[
204,
30
],
[
41,
38
],
[
205,
39
],
[
46,
43
],
[
205,
44
],
[
207,
48
],
[
59,
56
],
[
208,
57
],
[
64,
61
],
[
208,
62
],
[
67,
66
],
[
77,
74
],
[
205,
75
],
[
66,
76
],
[
205,
80
],
[
66,
82
],
[
66,
84
],
[
199,
85
],
[
90,
87
],
[
208,
88
],
[
66,
89
],
[
74,
92
],
[
205,
93
],
[
66,
94
],
[
199,
96
],
[
199,
98
],
[
103,
102
],
[
136,
105
],
[
134,
107
],
[
136,
108
],
[
111,
110
],
[
205,
112
],
[
134,
113
],
[
116,
115
],
[
208,
119
],
[
102,
120
],
[
136,
120
],
[
208,
122
],
[
134,
124
],
[
102,
125
],
[
136,
125
],
[
199,
126
],
[
110,
130
],
[
115,
131
],
[
199,
132
],
[
134,
134
],
[
136,
136
],
[
192,
138
],
[
142,
141
],
[
201,
148
],
[
141,
150
],
[
210,
155
],
[
141,
165
],
[
195,
168
],
[
193,
171
],
[
196,
171
],
[
214,
174
],
[
202,
175
],
[
214,
180
],
[
211,
181
],
[
141,
185
],
[
199,
187
],
[
196,
190
],
[
193,
190
],
[
192,
193
],
[
195,
196
],
[
198,
199
],
[
201,
202
],
[
204,
205
],
[
207,
208
],
[
210,
211
]
] | [
"import operator as op\nfrom functools import reduce\n\nMODULUS = 10**9 + 7\n\nif __name__ == '__main__':\n [h, w, a, b] = map(int, input().split())\n\n # Taken from https://atcoder.jp/contests/abc042/submissions/3178794 for learning purposes.\n factorial = [0] * (h+w)\n factorial[0] = 1\n factorial[1] = 1\n inverse = [0] * (h+w)\n inverse[0] = 1\n inverse[1] = 1\n for i in range(2, h+w):\n factorial[i] = factorial[i-1] * i % MODULUS\n # フェルマーの小定理から(x! ** mod-2 % mod == x! ** -1 % mod)\n # powに第三引数入れると冪乗のmod付計算を高速にやってくれる\n inverse[i] = pow(factorial[i], MODULUS-2, MODULUS)\n \n # 組み合わせの数だけ返してくれる関数(自作)\n 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] % MODULUS\n return numerator * denominator % MODULUS\n\n res = 0\n for i in range(h-a):\n rights_and_downs_to_right_border_of_forbidden_area = i + (b-1)\n\n rights_and_downs_from_right_border_of_forbidden_area = (w - b - 1) + (h - i - 1) \n res = (res + ncr( rights_and_downs_to_right_border_of_forbidden_area, b-1 ) \\\n * ncr( rights_and_downs_from_right_border_of_forbidden_area, (h - i - 1) )) % MODULUS\n\n\n print(res)",
"import operator as op",
"operator",
"from functools import reduce",
"MODULUS = 10**9 + 7",
"MODULUS",
"10**9 + 7",
"10**9",
"10",
"9",
"7",
"if __name__ == '__main__':\n [h, w, a, b] = map(int, input().split())\n\n # Taken from https://atcoder.jp/contests/abc042/submissions/3178794 for learning purposes.\n factorial = [0] * (h+w)\n factorial[0] = 1\n factorial[1] = 1\n inverse = [0] * (h+w)\n inverse[0] = 1\n inverse[1] = 1\n for i in range(2, h+w):\n factorial[i] = factorial[i-1] * i % MODULUS\n # フェルマーの小定理から(x! ** mod-2 % mod == x! ** -1 % mod)\n # powに第三引数入れると冪乗のmod付計算を高速にやってくれる\n inverse[i] = pow(factorial[i], MODULUS-2, MODULUS)\n \n # 組み合わせの数だけ返してくれる関数(自作)\n 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] % MODULUS\n return numerator * denominator % MODULUS\n\n res = 0\n for i in range(h-a):\n rights_and_downs_to_right_border_of_forbidden_area = i + (b-1)\n\n rights_and_downs_from_right_border_of_forbidden_area = (w - b - 1) + (h - i - 1) \n res = (res + ncr( rights_and_downs_to_right_border_of_forbidden_area, b-1 ) \\\n * ncr( rights_and_downs_from_right_border_of_forbidden_area, (h - i - 1) )) % MODULUS\n\n\n print(res)",
"__name__ == '__main__'",
"__name__",
"'__main__'",
"[h, w, a, b] = map(int, input().split())",
"[h, w, a, b]",
"h",
"w",
"a",
"b",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"factorial = [0] * (h+w)",
"factorial",
"[0] * (h+w)",
"[0]",
"0",
"h+w",
"h",
"w",
"factorial[0] = 1",
"factorial[0]",
"factorial",
"0",
"1",
"factorial[1] = 1",
"factorial[1]",
"factorial",
"1",
"1",
"inverse = [0] * (h+w)",
"inverse",
"[0] * (h+w)",
"[0]",
"0",
"h+w",
"h",
"w",
"inverse[0] = 1",
"inverse[0]",
"inverse",
"0",
"1",
"inverse[1] = 1",
"inverse[1]",
"inverse",
"1",
"1",
"for i in range(2, h+w):\n factorial[i] = factorial[i-1] * i % MODULUS\n # フェルマーの小定理から(x! ** mod-2 % mod == x! ** -1 % mod)\n # powに第三引数入れると冪乗のmod付計算を高速にやってくれる\n inverse[i] = pow(factorial[i], MODULUS-2, MODULUS)\n \n # 組み合わせの数だけ返してくれる関数(自作)\n ",
"i",
"range(2, h+w)",
"range",
"2",
"h+w",
"h",
"w",
"factorial[i] = factorial[i-1] * i % MODULUS",
"factorial[i]",
"factorial",
"i",
"factorial[i-1] * i % MODULUS",
"factorial[i-1] * i",
"factorial[i-1]",
"factorial",
"i-1",
"i",
"1",
"i",
"MODULUS",
"inverse[i] = pow(factorial[i], MODULUS-2, MODULUS)",
"inverse[i]",
"inverse",
"i",
"pow(factorial[i], MODULUS-2, MODULUS)",
"pow",
"factorial[i]",
"factorial",
"i",
"MODULUS-2",
"MODULUS",
"2",
"MODULUS",
"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] % MODULUS\n return numerator * denominator % MODULUS\n\n ",
"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] % MODULUS",
"denominator",
"inverse[r] * inverse[n-r] % MODULUS",
"inverse[r] * inverse[n-r]",
"inverse[r]",
"inverse",
"r",
"inverse[n-r]",
"inverse",
"n-r",
"n",
"r",
"MODULUS",
"return numerator * denominator % MODULUS",
"numerator * denominator % MODULUS",
"numerator * denominator",
"numerator",
"denominator",
"MODULUS",
"n",
"n",
"r",
"r",
"res = 0",
"res",
"0",
"for i in range(h-a):\n rights_and_downs_to_right_border_of_forbidden_area = i + (b-1)\n\n rights_and_downs_from_right_border_of_forbidden_area = (w - b - 1) + (h - i - 1) \n res = (res + ncr( rights_and_downs_to_right_border_of_forbidden_area, b-1 ) \\\n * ncr( rights_and_downs_from_right_border_of_forbidden_area, (h - i - 1) )) % MODULUS\n\n\n ",
"i",
"range(h-a)",
"range",
"h-a",
"h",
"a",
"rights_and_downs_to_right_border_of_forbidden_area = i + (b-1)",
"rights_and_downs_to_right_border_of_forbidden_area",
"i + (b-1)",
"i",
"b-1",
"b",
"1",
"rights_and_downs_from_right_border_of_forbidden_area = (w - b - 1) + (h - i - 1)",
"rights_and_downs_from_right_border_of_forbidden_area",
"(w - b - 1) + (h - i - 1)",
"w - b - 1",
"w - b",
"w",
"b",
"1",
"h - i - 1",
"h - i",
"h",
"i",
"1",
"res = (res + ncr( rights_and_downs_to_right_border_of_forbidden_area, b-1 ) \\\n * ncr( rights_and_downs_from_right_border_of_forbidden_area, (h - i - 1) )) % MODULUS",
"res",
"(res + ncr( rights_and_downs_to_right_border_of_forbidden_area, b-1 ) \\\n * ncr( rights_and_downs_from_right_border_of_forbidden_area, (h - i - 1) )) % MODULUS",
"res + ncr( rights_and_downs_to_right_border_of_forbidden_area, b-1 ) \\\n * ncr( rights_and_downs_from_right_border_of_forbidden_area, (h - i - 1) )",
"res",
"ncr( rights_and_downs_to_right_border_of_forbidden_area, b-1 ) \\\n * ncr( rights_and_downs_from_right_border_of_forbidden_area, (h - i - 1) )",
"ncr( rights_and_downs_to_right_border_of_forbidden_area, b-1 )",
"ncr",
"rights_and_downs_to_right_border_of_forbidden_area",
"b-1",
"b",
"1",
"ncr( rights_and_downs_from_right_border_of_forbidden_area, (h - i - 1) )",
"ncr",
"rights_and_downs_from_right_border_of_forbidden_area",
"h - i - 1",
"h - i",
"h",
"i",
"1",
"MODULUS",
"print(res)",
"print",
"res",
"res = 0",
"0",
"res",
"res = (res + ncr( rights_and_downs_to_right_border_of_forbidden_area, b-1 ) \\\n * ncr( rights_and_downs_from_right_border_of_forbidden_area, (h - i - 1) )) % MODULUS",
"(res + ncr( rights_and_downs_to_right_border_of_forbidden_area, b-1 ) \\\n * ncr( rights_and_downs_from_right_border_of_forbidden_area, (h - i - 1) )) % MODULUS",
"res",
"MODULUS = 10**9 + 7",
"10**9 + 7",
"MODULUS",
"rights_and_downs_to_right_border_of_forbidden_area = i + (b-1)",
"i + (b-1)",
"rights_and_downs_to_right_border_of_forbidden_area",
"factorial = [0] * (h+w)",
"[0] * (h+w)",
"factorial",
"inverse = [0] * (h+w)",
"[0] * (h+w)",
"inverse",
"rights_and_downs_from_right_border_of_forbidden_area = (w - b - 1) + (h - i - 1)",
"(w - b - 1) + (h - i - 1)",
"rights_and_downs_from_right_border_of_forbidden_area",
"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] % MODULUS\n return numerator * denominator % MODULUS\n\n ",
"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] % MODULUS\n return numerator * denominator % MODULUS\n\n ",
"ncr"
] | import operator as op
from functools import reduce
MODULUS = 10**9 + 7
if __name__ == '__main__':
[h, w, a, b] = map(int, input().split())
# Taken from https://atcoder.jp/contests/abc042/submissions/3178794 for learning purposes.
factorial = [0] * (h+w)
factorial[0] = 1
factorial[1] = 1
inverse = [0] * (h+w)
inverse[0] = 1
inverse[1] = 1
for i in range(2, h+w):
factorial[i] = factorial[i-1] * i % MODULUS
# フェルマーの小定理から(x! ** mod-2 % mod == x! ** -1 % mod)
# powに第三引数入れると冪乗のmod付計算を高速にやってくれる
inverse[i] = pow(factorial[i], MODULUS-2, MODULUS)
# 組み合わせの数だけ返してくれる関数(自作)
def ncr(n, r):
# 10C7 = 10C3
r = min(r, n-r)
# 分子の計算
numerator = factorial[n]
# 分母の計算
denominator = inverse[r] * inverse[n-r] % MODULUS
return numerator * denominator % MODULUS
res = 0
for i in range(h-a):
rights_and_downs_to_right_border_of_forbidden_area = i + (b-1)
rights_and_downs_from_right_border_of_forbidden_area = (w - b - 1) + (h - i - 1)
res = (res + ncr( rights_and_downs_to_right_border_of_forbidden_area, b-1 ) \
* ncr( rights_and_downs_from_right_border_of_forbidden_area, (h - i - 1) )) % MODULUS
print(res) |
[
7,
0,
13,
2,
2,
17,
17,
17,
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,
0,
13,
2,
2,
2,
13,
2,
2,
2,
2,
13,
13,
13,
17,
13,
4,
13,
2,
13,
17,
2,
13,
17,
13,
13,
0,
13,
2,
28,
13,
4,
13,
17,
2,
13,
13,
0,
13,
2,
2,
2,
2,
13,
2,
2,
13,
17,
13,
2,
13,
13,
4,
13,
2,
13,
2,
2,
2,
2,
13,
13,
13,
17,
13,
2,
13,
17,
13,
13,
0,
13,
13,
4,
13,
2,
13,
13,
10,
17,
13,
10,
4,
13,
10,
2,
13,
10,
2,
13,
10,
2,
13,
10,
4,
13,
10,
17,
13,
10,
4,
13,
10,
2,
13,
10,
13,
13,
10,
4,
13
] | [
[
124,
2
],
[
142,
9
],
[
142,
18
],
[
142,
19
],
[
142,
20
],
[
112,
22
],
[
130,
25
],
[
29,
28
],
[
128,
32
],
[
136,
35
],
[
113,
39
],
[
119,
39
],
[
116,
44
],
[
128,
45
],
[
134,
46
],
[
28,
48
],
[
28,
52
],
[
125,
55
],
[
125,
57
],
[
125,
58
],
[
136,
60
],
[
64,
63
],
[
128,
68
],
[
143,
69
],
[
121,
71
],
[
119,
76
],
[
113,
76
],
[
122,
76
],
[
134,
79
],
[
63,
81
],
[
128,
83
],
[
63,
84
],
[
63,
88
],
[
116,
93
],
[
128,
94
],
[
134,
95
],
[
63,
97
],
[
125,
99
],
[
125,
101
],
[
125,
102
],
[
139,
104
],
[
122,
105
],
[
119,
105
],
[
113,
105
],
[
140,
109
],
[
137,
109
],
[
131,
109
],
[
125,
110
],
[
112,
113
],
[
142,
116
],
[
136,
119
],
[
121,
122
],
[
124,
125
],
[
142,
128
],
[
130,
131
],
[
142,
134
],
[
136,
137
],
[
122,
139
],
[
119,
139
],
[
113,
139
],
[
139,
140
],
[
142,
143
]
] | [
"M=10**9+7\nH,W,A,B = map(int,input().split())\nC = 1\nans = 1\n\nfor I in range(H-1):\n ans = C = C*(W+H-B-2-I)*pow(I+1,M-2,M)%M\n\nfor I in range(1,H-A):\n C = C*(B-1+I)*(H-I)*pow(I*(W+H-B-1-I),M-2,M)%M\n ans+=C\n\nprint(ans%M)",
"M=10**9+7",
"M",
"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",
"C = 1",
"C",
"1",
"ans = 1",
"ans",
"1",
"for I in range(H-1):\n ans = C = C*(W+H-B-2-I)*pow(I+1,M-2,M)%M",
"I",
"range(H-1)",
"range",
"H-1",
"H",
"1",
"ans = C = C*(W+H-B-2-I)*pow(I+1,M-2,M)%M",
"ans",
"C*(W+H-B-2-I)*pow(I+1,M-2,M)%M",
"C*(W+H-B-2-I)*pow(I+1,M-2,M)",
"C*(W+H-B-2-I)",
"C",
"W+H-B-2-I",
"W+H-B-2",
"W+H-B",
"W+H",
"W",
"H",
"B",
"2",
"I",
"pow(I+1,M-2,M)",
"pow",
"I+1",
"I",
"1",
"M-2",
"M",
"2",
"M",
"M",
"= C = C*(W+H-B-2-I)*pow(I+1,M-2,M)%M",
"C",
"C*(W+H-B-2-I)*pow(I+1,M-2,M)%M",
"for I in range(1,H-A):\n C = C*(B-1+I)*(H-I)*pow(I*(W+H-B-1-I),M-2,M)%M\n ans+=C",
"I",
"range(1,H-A)",
"range",
"1",
"H-A",
"H",
"A",
"C = C*(B-1+I)*(H-I)*pow(I*(W+H-B-1-I),M-2,M)%M",
"C",
"C*(B-1+I)*(H-I)*pow(I*(W+H-B-1-I),M-2,M)%M",
"C*(B-1+I)*(H-I)*pow(I*(W+H-B-1-I),M-2,M)",
"C*(B-1+I)*(H-I)",
"C*(B-1+I)",
"C",
"B-1+I",
"B-1",
"B",
"1",
"I",
"H-I",
"H",
"I",
"pow(I*(W+H-B-1-I),M-2,M)",
"pow",
"I*(W+H-B-1-I)",
"I",
"W+H-B-1-I",
"W+H-B-1",
"W+H-B",
"W+H",
"W",
"H",
"B",
"1",
"I",
"M-2",
"M",
"2",
"M",
"M",
"ans+=C",
"ans",
"C",
"print(ans%M)",
"print",
"ans%M",
"ans",
"M",
"C = 1",
"1",
"C",
"W,A,B = map(int,input().split())",
"map(int,input().split())",
"W",
"C = C*(W+H-B-2-I)*pow(I+1,M-2,M)%M",
"C*(W+H-B-2-I)*pow(I+1,M-2,M)%M",
"C",
"C = C*(B-1+I)*(H-I)*pow(I*(W+H-B-1-I),M-2,M)%M",
"C*(B-1+I)*(H-I)*pow(I*(W+H-B-1-I),M-2,M)%M",
"C",
"M=10**9+7",
"10**9+7",
"M",
"H,W,A,B = map(int,input().split())",
"map(int,input().split())",
"H",
"ans = 1",
"1",
"ans",
"B = map(int,input().split())",
"map(int,input().split())",
"B",
"ans = C = C*(W+H-B-2-I)*pow(I+1,M-2,M)%M",
"C*(W+H-B-2-I)*pow(I+1,M-2,M)%M",
"ans",
"ans+=C",
"C",
"ans",
"A,B = map(int,input().split())",
"map(int,input().split())",
"A"
] | M=10**9+7
H,W,A,B = map(int,input().split())
C = 1
ans = 1
for I in range(H-1):
ans = C = C*(W+H-B-2-I)*pow(I+1,M-2,M)%M
for I in range(1,H-A):
C = C*(B-1+I)*(H-I)*pow(I*(W+H-B-1-I),M-2,M)%M
ans+=C
print(ans%M) |
[
7,
0,
13,
2,
2,
17,
17,
17,
41,
28,
13,
4,
13,
17,
4,
17,
0,
13,
13,
41,
28,
13,
4,
13,
17,
4,
17,
0,
13,
13,
41,
28,
13,
4,
13,
17,
4,
17,
0,
13,
13,
28,
13,
4,
13,
17,
17,
0,
18,
13,
13,
2,
2,
18,
13,
2,
13,
17,
13,
13,
0,
18,
13,
13,
2,
2,
13,
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,
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,
0,
13,
17,
28,
13,
4,
13,
2,
13,
13,
0,
13,
2,
4,
13,
2,
2,
2,
2,
13,
13,
13,
13,
17,
2,
13,
17,
4,
13,
2,
2,
2,
2,
2,
13,
13,
17,
13,
13,
17,
2,
2,
13,
13,
17,
0,
13,
13,
4,
13,
13,
10,
4,
13,
10,
4,
13,
10,
2,
13,
10,
4,
13,
10,
13,
13,
10,
17,
13,
10,
13,
13,
10,
13,
13,
10,
12,
13,
10,
13,
13,
10,
2,
13,
10,
4,
13
] | [
[
209,
2
],
[
11,
10
],
[
206,
17
],
[
22,
21
],
[
200,
28
],
[
33,
32
],
[
191,
39
],
[
43,
42
],
[
51,
48
],
[
207,
49
],
[
42,
50
],
[
207,
54
],
[
42,
56
],
[
42,
58
],
[
210,
59
],
[
64,
61
],
[
201,
62
],
[
42,
63
],
[
210,
66
],
[
201,
69
],
[
210,
71
],
[
42,
72
],
[
210,
74
],
[
42,
75
],
[
210,
76
],
[
81,
78
],
[
192,
79
],
[
42,
80
],
[
192,
84
],
[
42,
86
],
[
61,
88
],
[
201,
89
],
[
42,
90
],
[
210,
91
],
[
207,
99
],
[
111,
100
],
[
192,
102
],
[
113,
103
],
[
192,
105
],
[
111,
107
],
[
113,
108
],
[
210,
109
],
[
111,
111
],
[
113,
113
],
[
212,
115
],
[
212,
124
],
[
212,
125
],
[
212,
126
],
[
194,
128
],
[
132,
131
],
[
189,
135
],
[
180,
136
],
[
185,
138
],
[
204,
141
],
[
213,
146
],
[
189,
147
],
[
180,
148
],
[
131,
149
],
[
213,
152
],
[
204,
155
],
[
180,
161
],
[
131,
162
],
[
183,
164
],
[
213,
165
],
[
183,
169
],
[
213,
170
],
[
197,
173
],
[
210,
174
],
[
198,
177
],
[
186,
177
],
[
195,
177
],
[
212,
180
],
[
212,
183
],
[
185,
186
],
[
212,
189
],
[
191,
192
],
[
194,
195
],
[
210,
197
],
[
197,
198
],
[
200,
201
],
[
206,
207
],
[
209,
210
],
[
212,
213
]
] | [
"MOD = 10**9+7\nfac = [1 for k in range(200010)]\ninv = [1 for k in range(200010)]\nfinv = [1 for k in range(200010)]\nfor k in range(2,200010):\n fac[k] = (fac[k-1]*k)%MOD\n inv[k] = (MOD - inv[MOD%k] * (MOD // k))%MOD\n finv[k] = (finv[k - 1] * inv[k]) % MOD;\ndef nCr(n,r):\n return (fac[n]*finv[r]*finv[n-r])%MOD\n\nH, W, A, B = map(int,input().split())\nans = 0\n\nfor k in range(W-B):\n ans += nCr(A+W-B-k-2,A-1)*nCr(B+k+1+H-A-2,H-A-1)\n ans %= MOD\n\nprint(ans)",
"MOD = 10**9+7",
"MOD",
"10**9+7",
"10**9",
"10",
"9",
"7",
"1 for k in range(200010)",
"for k in range(200010)",
"k",
"range(200010)",
"range",
"200010",
"for k in range(200010)",
"1",
"fac = [1 for k in range(200010)]",
"fac",
"[1 for k in range(200010)]",
"1 for k in range(200010)",
"for k in range(200010)",
"k",
"range(200010)",
"range",
"200010",
"for k in range(200010)",
"1",
"inv = [1 for k in range(200010)]",
"inv",
"[1 for k in range(200010)]",
"1 for k in range(200010)",
"for k in range(200010)",
"k",
"range(200010)",
"range",
"200010",
"for k in range(200010)",
"1",
"finv = [1 for k in range(200010)]",
"finv",
"[1 for k in range(200010)]",
"for k in range(2,200010):\n fac[k] = (fac[k-1]*k)%MOD\n inv[k] = (MOD - inv[MOD%k] * (MOD // k))%MOD\n finv[k] = (finv[k - 1] * inv[k]) % MOD;",
"k",
"range(2,200010)",
"range",
"2",
"200010",
"fac[k] = (fac[k-1]*k)%MOD",
"fac[k]",
"fac",
"k",
"(fac[k-1]*k)%MOD",
"fac[k-1]*k",
"fac[k-1]",
"fac",
"k-1",
"k",
"1",
"k",
"MOD",
"inv[k] = (MOD - inv[MOD%k] * (MOD // k))%MOD",
"inv[k]",
"inv",
"k",
"(MOD - inv[MOD%k] * (MOD // k))%MOD",
"MOD - inv[MOD%k] * (MOD // k)",
"MOD",
"inv[MOD%k] * (MOD // k)",
"inv[MOD%k]",
"inv",
"MOD%k",
"MOD",
"k",
"MOD // k",
"MOD",
"k",
"MOD",
"finv[k] = (finv[k - 1] * inv[k]) % MOD",
"finv[k]",
"finv",
"k",
"(finv[k - 1] * inv[k]) % MOD",
"finv[k - 1] * inv[k]",
"finv[k - 1]",
"finv",
"k - 1",
"k",
"1",
"inv[k]",
"inv",
"k",
"MOD",
"def nCr(n,r):\n return (fac[n]*finv[r]*finv[n-r])%MOD",
"nCr",
"return (fac[n]*finv[r]*finv[n-r])%MOD",
"(fac[n]*finv[r]*finv[n-r])%MOD",
"fac[n]*finv[r]*finv[n-r]",
"fac[n]*finv[r]",
"fac[n]",
"fac",
"n",
"finv[r]",
"finv",
"r",
"finv[n-r]",
"finv",
"n-r",
"n",
"r",
"MOD",
"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",
"ans = 0",
"ans",
"0",
"for k in range(W-B):\n ans += nCr(A+W-B-k-2,A-1)*nCr(B+k+1+H-A-2,H-A-1)\n ans %= MOD",
"k",
"range(W-B)",
"range",
"W-B",
"W",
"B",
"ans += nCr(A+W-B-k-2,A-1)*nCr(B+k+1+H-A-2,H-A-1)",
"ans",
"nCr(A+W-B-k-2,A-1)*nCr(B+k+1+H-A-2,H-A-1)",
"nCr(A+W-B-k-2,A-1)",
"nCr",
"A+W-B-k-2",
"A+W-B-k",
"A+W-B",
"A+W",
"A",
"W",
"B",
"k",
"2",
"A-1",
"A",
"1",
"nCr(B+k+1+H-A-2,H-A-1)",
"nCr",
"B+k+1+H-A-2",
"B+k+1+H-A",
"B+k+1+H",
"B+k+1",
"B+k",
"B",
"k",
"1",
"H",
"A",
"2",
"H-A-1",
"H-A",
"H",
"A",
"1",
"ans %= MOD",
"ans",
"MOD",
"print(ans)",
"print",
"ans",
"B = map(int,input().split())",
"map(int,input().split())",
"B",
"H, W, A, B = map(int,input().split())",
"map(int,input().split())",
"H",
"ans += nCr(A+W-B-k-2,A-1)*nCr(B+k+1+H-A-2,H-A-1)",
"nCr(A+W-B-k-2,A-1)*nCr(B+k+1+H-A-2,H-A-1)",
"ans",
"W, A, B = map(int,input().split())",
"map(int,input().split())",
"W",
"finv = [1 for k in range(200010)]",
"[1 for k in range(200010)]",
"finv",
"ans = 0",
"0",
"ans",
"ans %= MOD",
"MOD",
"ans",
"inv = [1 for k in range(200010)]",
"[1 for k in range(200010)]",
"inv",
"def nCr(n,r):\n return (fac[n]*finv[r]*finv[n-r])%MOD",
"def nCr(n,r):\n return (fac[n]*finv[r]*finv[n-r])%MOD",
"nCr",
"fac = [1 for k in range(200010)]",
"[1 for k in range(200010)]",
"fac",
"MOD = 10**9+7",
"10**9+7",
"MOD",
"A, B = map(int,input().split())",
"map(int,input().split())",
"A"
] | MOD = 10**9+7
fac = [1 for k in range(200010)]
inv = [1 for k in range(200010)]
finv = [1 for k in range(200010)]
for k in range(2,200010):
fac[k] = (fac[k-1]*k)%MOD
inv[k] = (MOD - inv[MOD%k] * (MOD // k))%MOD
finv[k] = (finv[k - 1] * inv[k]) % MOD;
def nCr(n,r):
return (fac[n]*finv[r]*finv[n-r])%MOD
H, W, A, B = map(int,input().split())
ans = 0
for k in range(W-B):
ans += nCr(A+W-B-k-2,A-1)*nCr(B+k+1+H-A-2,H-A-1)
ans %= MOD
print(ans)
|
[
7,
0,
13,
2,
2,
17,
17,
17,
0,
13,
39,
17,
0,
13,
39,
17,
28,
13,
4,
13,
17,
4,
18,
13,
13,
2,
2,
18,
13,
13,
2,
13,
17,
13,
4,
18,
13,
13,
4,
13,
18,
13,
2,
13,
17,
2,
13,
17,
13,
12,
13,
14,
2,
2,
2,
13,
17,
2,
13,
17,
2,
2,
13,
13,
17,
29,
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,
0,
13,
4,
13,
2,
2,
13,
13,
17,
2,
13,
17,
28,
13,
4,
13,
4,
13,
13,
13,
0,
13,
2,
4,
13,
2,
2,
2,
13,
13,
13,
17,
2,
2,
13,
13,
13,
4,
13,
2,
2,
2,
13,
13,
13,
17,
2,
2,
13,
13,
13,
4,
13,
2,
13,
13,
10,
4,
13,
10,
2,
13,
10,
39,
13,
10,
4,
13,
10,
2,
13,
10,
4,
13,
10,
12,
13,
10,
4,
13,
10,
39,
13,
10,
4,
13
] | [
[
169,
2
],
[
163,
9
],
[
181,
13
],
[
18,
17
],
[
164,
23
],
[
164,
28
],
[
17,
29
],
[
17,
31
],
[
170,
33
],
[
182,
36
],
[
164,
41
],
[
17,
43
],
[
170,
46
],
[
170,
48
],
[
84,
55
],
[
86,
58
],
[
84,
62
],
[
86,
63
],
[
164,
72
],
[
84,
73
],
[
182,
75
],
[
86,
76
],
[
182,
78
],
[
84,
80
],
[
86,
81
],
[
170,
82
],
[
84,
84
],
[
86,
86
],
[
184,
88
],
[
184,
97
],
[
184,
98
],
[
184,
99
],
[
166,
101
],
[
176,
103
],
[
185,
106
],
[
158,
107
],
[
185,
110
],
[
114,
113
],
[
179,
118
],
[
173,
119
],
[
160,
121
],
[
176,
124
],
[
185,
128
],
[
179,
129
],
[
173,
130
],
[
185,
134
],
[
179,
135
],
[
113,
136
],
[
176,
138
],
[
158,
142
],
[
173,
143
],
[
179,
144
],
[
158,
148
],
[
173,
149
],
[
113,
150
],
[
161,
154
],
[
167,
154
],
[
170,
155
],
[
184,
158
],
[
160,
161
],
[
163,
164
],
[
166,
167
],
[
169,
170
],
[
184,
173
],
[
184,
179
],
[
181,
182
],
[
184,
185
]
] | [
"mod = 10 ** 9 + 7\nfact = [1]\ninv = [1]\nfor i in range(200000):\n fact.append(fact[i] * (i + 1) % mod)\n inv.append(pow(fact[i + 1], mod - 2, mod))\ndef ncr(n, r):\n if n < 0 or r < 0 or n - r < 0:\n return 0\n return fact[n] * inv[r] * inv[n - r] % mod\nh, w, a, b = map(int, input().split())\nans = ncr(h + w - 2, h - 1)\nfor i in range(min(a, b)):\n ans -= ncr(h - a + b - 1, h - a + i) * ncr(w - b + a - 1, w - b + i)\nprint(ans % mod)",
"mod = 10 ** 9 + 7",
"mod",
"10 ** 9 + 7",
"10 ** 9",
"10",
"9",
"7",
"fact = [1]",
"fact",
"[1]",
"1",
"inv = [1]",
"inv",
"[1]",
"1",
"for i in range(200000):\n fact.append(fact[i] * (i + 1) % mod)\n inv.append(pow(fact[i + 1], mod - 2, mod))",
"i",
"range(200000)",
"range",
"200000",
"fact.append(fact[i] * (i + 1) % mod)",
"fact.append",
"fact",
"append",
"fact[i] * (i + 1) % mod",
"fact[i] * (i + 1)",
"fact[i]",
"fact",
"i",
"i + 1",
"i",
"1",
"mod",
"inv.append(pow(fact[i + 1], mod - 2, mod))",
"inv.append",
"inv",
"append",
"pow(fact[i + 1], mod - 2, mod)",
"pow",
"fact[i + 1]",
"fact",
"i + 1",
"i",
"1",
"mod - 2",
"mod",
"2",
"mod",
"def ncr(n, r):\n if n < 0 or r < 0 or n - r < 0:\n return 0\n return fact[n] * inv[r] * inv[n - r] % mod",
"ncr",
"if n < 0 or r < 0 or n - r < 0:\n return 0\n ",
"n < 0 or r < 0 or n - r < 0",
"n < 0 or r < 0",
"n < 0",
"n",
"0",
"r < 0",
"r",
"0",
"n - r < 0",
"n - r",
"n",
"r",
"0",
"return 0",
"0",
"return fact[n] * inv[r] * inv[n - r] % mod",
"fact[n] * inv[r] * inv[n - r] % mod",
"fact[n] * inv[r] * inv[n - r]",
"fact[n] * inv[r]",
"fact[n]",
"fact",
"n",
"inv[r]",
"inv",
"r",
"inv[n - r]",
"inv",
"n - r",
"n",
"r",
"mod",
"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",
"ans = ncr(h + w - 2, h - 1)",
"ans",
"ncr(h + w - 2, h - 1)",
"ncr",
"h + w - 2",
"h + w",
"h",
"w",
"2",
"h - 1",
"h",
"1",
"for i in range(min(a, b)):\n ans -= ncr(h - a + b - 1, h - a + i) * ncr(w - b + a - 1, w - b + i)",
"i",
"range(min(a, b))",
"range",
"min(a, b)",
"min",
"a",
"b",
"ans -= ncr(h - a + b - 1, h - a + i) * ncr(w - b + a - 1, w - b + i)",
"ans",
"ncr(h - a + b - 1, h - a + i) * ncr(w - b + a - 1, w - b + i)",
"ncr(h - a + b - 1, h - a + i)",
"ncr",
"h - a + b - 1",
"h - a + b",
"h - a",
"h",
"a",
"b",
"1",
"h - a + i",
"h - a",
"h",
"a",
"i",
"ncr(w - b + a - 1, w - b + i)",
"ncr",
"w - b + a - 1",
"w - b + a",
"w - b",
"w",
"b",
"a",
"1",
"w - b + i",
"w - b",
"w",
"b",
"i",
"print(ans % mod)",
"print",
"ans % mod",
"ans",
"mod",
"w, a, b = map(int, input().split())",
"map(int, input().split())",
"w",
"ans -= ncr(h - a + b - 1, h - a + i) * ncr(w - b + a - 1, w - b + i)",
"ncr(h - a + b - 1, h - a + i) * ncr(w - b + a - 1, w - b + i)",
"ans",
"fact = [1]",
"[1]",
"fact",
"ans = ncr(h + w - 2, h - 1)",
"ncr(h + w - 2, h - 1)",
"ans",
"mod = 10 ** 9 + 7",
"10 ** 9 + 7",
"mod",
"b = map(int, input().split())",
"map(int, input().split())",
"b",
"def ncr(n, r):\n if n < 0 or r < 0 or n - r < 0:\n return 0\n return fact[n] * inv[r] * inv[n - r] % mod",
"def ncr(n, r):\n if n < 0 or r < 0 or n - r < 0:\n return 0\n return fact[n] * inv[r] * inv[n - r] % mod",
"ncr",
"a, b = map(int, input().split())",
"map(int, input().split())",
"a",
"inv = [1]",
"[1]",
"inv",
"h, w, a, b = map(int, input().split())",
"map(int, input().split())",
"h"
] | mod = 10 ** 9 + 7
fact = [1]
inv = [1]
for i in range(200000):
fact.append(fact[i] * (i + 1) % mod)
inv.append(pow(fact[i + 1], mod - 2, mod))
def ncr(n, r):
if n < 0 or r < 0 or n - r < 0:
return 0
return fact[n] * inv[r] * inv[n - r] % mod
h, w, a, b = map(int, input().split())
ans = ncr(h + w - 2, h - 1)
for i in range(min(a, b)):
ans -= ncr(h - a + b - 1, h - a + i) * ncr(w - b + a - 1, w - b + i)
print(ans % mod)
|
[
7,
15,
13,
13,
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,
0,
13,
2,
17,
2,
17,
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,
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,
13,
18,
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,
4,
13,
13,
13,
13,
0,
13,
17,
28,
13,
4,
13,
13,
13,
0,
13,
2,
2,
4,
13,
2,
2,
2,
13,
13,
17,
13,
13,
4,
13,
2,
2,
2,
2,
13,
13,
17,
13,
17,
2,
13,
17,
13,
0,
13,
2,
2,
13,
13,
13,
4,
13,
13,
10,
12,
13,
10,
4,
13,
10,
4,
13,
10,
2,
13,
10,
12,
13,
10,
2,
13,
10,
12,
13,
10,
12,
13,
10,
4,
13,
10,
4,
13,
10,
2,
13,
10,
2,
13,
10,
2,
13,
10,
2,
13,
10,
12,
13,
10,
17,
13,
10,
4,
13,
10,
12,
13
] | [
[
24,
23
],
[
253,
29
],
[
33,
33
],
[
213,
42
],
[
243,
47
],
[
246,
54
],
[
249,
61
],
[
247,
66
],
[
70,
69
],
[
247,
74
],
[
80,
77
],
[
250,
78
],
[
69,
79
],
[
69,
82
],
[
250,
84
],
[
69,
86
],
[
244,
88
],
[
240,
90
],
[
247,
95
],
[
101,
98
],
[
241,
99
],
[
247,
100
],
[
250,
104
],
[
247,
105
],
[
244,
107
],
[
244,
109
],
[
112,
111
],
[
247,
114
],
[
123,
118
],
[
241,
119
],
[
111,
121
],
[
111,
125
],
[
241,
127
],
[
111,
128
],
[
244,
129
],
[
77,
137
],
[
250,
138
],
[
151,
139
],
[
241,
141
],
[
153,
142
],
[
244,
143
],
[
241,
145
],
[
151,
147
],
[
153,
148
],
[
244,
149
],
[
151,
151
],
[
153,
153
],
[
258,
155
],
[
253,
157
],
[
258,
158
],
[
258,
159
],
[
258,
160
],
[
255,
162
],
[
166,
165
],
[
238,
168
],
[
259,
169
],
[
219,
171
],
[
223,
175
],
[
235,
179
],
[
217,
180
],
[
165,
182
],
[
165,
183
],
[
223,
185
],
[
259,
190
],
[
165,
191
],
[
217,
193
],
[
217,
196
],
[
244,
198
],
[
225,
200
],
[
256,
203
],
[
226,
203
],
[
220,
204
],
[
244,
205
],
[
226,
208
],
[
256,
208
],
[
213,
214
],
[
258,
217
],
[
219,
220
],
[
225,
226
],
[
258,
235
],
[
258,
238
],
[
240,
241
],
[
243,
244
],
[
246,
247
],
[
249,
250
],
[
255,
256
],
[
258,
259
]
] | [
"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\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\nfrom heapq import heappush, heappop\nfrom functools import reduce\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\n\n\nlim = 2*10**5 #必要そうな階乗の限界を入力\n\n#階乗#\nfact = [1] * (lim+1)\nfor n in range(1, lim+1):\n\tfact[n] = n * fact[n-1] % mod\n\n#階乗の逆元#\nfact_inv = [1]*(lim+1)\nfact_inv[lim] = pow(fact[lim], mod-2, mod)\nfor n in range(lim, 0, -1):\n\tfact_inv[n-1] = n*fact_inv[n]%mod\n\ndef C(n, r):\n\treturn (fact[n]*fact_inv[r]%mod)*fact_inv[n-r]%mod\n\n\nH, W, A, B = MAP()\n\nans = 0\nfor n in range(B, W):\n\tway = C(H-A-1+n, n)*C(W-n-1+A-1, A-1)%mod\n\tans = (ans+way)%mod\n\nprint(ans)\n",
"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",
"from heapq import heappush, heappop",
"from functools import reduce",
"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",
"lim = 2*10**5",
"lim",
"2*10**5",
"2",
"10**5",
"10",
"5",
"fact = [1] * (lim+1)",
"fact",
"[1] * (lim+1)",
"[1]",
"1",
"lim+1",
"lim",
"1",
"for n in range(1, lim+1):\n\tfact[n] = n * fact[n-1] % mod\n\n#階乗の逆元#",
"n",
"range(1, lim+1)",
"range",
"1",
"lim+1",
"lim",
"1",
"fact[n] = n * fact[n-1] % mod",
"fact[n]",
"fact",
"n",
"n * fact[n-1] % mod",
"n * fact[n-1]",
"n",
"fact[n-1]",
"fact",
"n-1",
"n",
"1",
"mod",
"fact_inv = [1]*(lim+1)",
"fact_inv",
"[1]*(lim+1)",
"[1]",
"1",
"lim+1",
"lim",
"1",
"fact_inv[lim] = pow(fact[lim], mod-2, mod)",
"fact_inv[lim]",
"fact_inv",
"lim",
"pow(fact[lim], mod-2, mod)",
"pow",
"fact[lim]",
"fact",
"lim",
"mod-2",
"mod",
"2",
"mod",
"for n in range(lim, 0, -1):\n\tfact_inv[n-1] = n*fact_inv[n]%mod",
"n",
"range(lim, 0, -1)",
"range",
"lim",
"0",
"-1",
"fact_inv[n-1] = n*fact_inv[n]%mod",
"fact_inv[n-1]",
"fact_inv",
"n-1",
"n",
"1",
"n*fact_inv[n]%mod",
"n*fact_inv[n]",
"n",
"fact_inv[n]",
"fact_inv",
"n",
"mod",
"def C(n, r):\n\treturn (fact[n]*fact_inv[r]%mod)*fact_inv[n-r]%mod",
"C",
"return (fact[n]*fact_inv[r]%mod)*fact_inv[n-r]%mod",
"(fact[n]*fact_inv[r]%mod)*fact_inv[n-r]%mod",
"(fact[n]*fact_inv[r]%mod)*fact_inv[n-r]",
"fact[n]*fact_inv[r]%mod",
"fact[n]*fact_inv[r]",
"fact[n]",
"fact",
"n",
"fact_inv[r]",
"fact_inv",
"r",
"mod",
"fact_inv[n-r]",
"fact_inv",
"n-r",
"n",
"r",
"mod",
"n",
"n",
"r",
"r",
"H, W, A, B = MAP()",
"H",
"MAP()",
"MAP",
"W",
"A",
"B",
"ans = 0",
"ans",
"0",
"for n in range(B, W):\n\tway = C(H-A-1+n, n)*C(W-n-1+A-1, A-1)%mod\n\tans = (ans+way)%mod",
"n",
"range(B, W)",
"range",
"B",
"W",
"way = C(H-A-1+n, n)*C(W-n-1+A-1, A-1)%mod",
"way",
"C(H-A-1+n, n)*C(W-n-1+A-1, A-1)%mod",
"C(H-A-1+n, n)*C(W-n-1+A-1, A-1)",
"C(H-A-1+n, n)",
"C",
"H-A-1+n",
"H-A-1",
"H-A",
"H",
"A",
"1",
"n",
"n",
"C(W-n-1+A-1, A-1)",
"C",
"W-n-1+A-1",
"W-n-1+A",
"W-n-1",
"W-n",
"W",
"n",
"1",
"A",
"1",
"A-1",
"A",
"1",
"mod",
"ans = (ans+way)%mod",
"ans",
"(ans+way)%mod",
"ans+way",
"ans",
"way",
"mod",
"print(ans)",
"print",
"ans",
"def INT(): return int(input())",
"def INT(): return int(input())",
"INT",
"INF = float('inf')",
"float('inf')",
"INF",
"A, B = MAP()",
"MAP()",
"A",
"way = C(H-A-1+n, n)*C(W-n-1+A-1, A-1)%mod",
"C(H-A-1+n, n)*C(W-n-1+A-1, A-1)%mod",
"way",
"def C(n, r):\n\treturn (fact[n]*fact_inv[r]%mod)*fact_inv[n-r]%mod",
"def C(n, r):\n\treturn (fact[n]*fact_inv[r]%mod)*fact_inv[n-r]%mod",
"C",
"ans = (ans+way)%mod",
"(ans+way)%mod",
"ans",
"def LIST(): return list(map(int, input().split()))",
"def LIST(): return list(map(int, input().split()))",
"LIST",
"def ZIP(n): return zip(*(MAP() for _ in range(n)))",
"def ZIP(n): return zip(*(MAP() for _ in range(n)))",
"ZIP",
"H, W, A, B = MAP()",
"MAP()",
"H",
"B = MAP()",
"MAP()",
"B",
"fact_inv = [1]*(lim+1)",
"[1]*(lim+1)",
"fact_inv",
"mod = 10 ** 9 + 7",
"10 ** 9 + 7",
"mod",
"lim = 2*10**5",
"2*10**5",
"lim",
"fact = [1] * (lim+1)",
"[1] * (lim+1)",
"fact",
"def MAP(): return map(int, input().split())",
"def MAP(): return map(int, input().split())",
"MAP",
"ans = 0",
"0",
"ans",
"W, A, B = MAP()",
"MAP()",
"W",
"def input(): return sys.stdin.readline().strip()",
"def input(): return sys.stdin.readline().strip()",
"input"
] | import 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
from heapq import heappush, heappop
from functools import reduce
def input(): return sys.stdin.readline().strip()
def INT(): return int(input())
def MAP(): return map(int, input().split())
def LIST(): return list(map(int, input().split()))
def ZIP(n): return zip(*(MAP() for _ in range(n)))
sys.setrecursionlimit(10 ** 9)
INF = float('inf')
mod = 10 ** 9 + 7
lim = 2*10**5 #必要そうな階乗の限界を入力
#階乗#
fact = [1] * (lim+1)
for n in range(1, lim+1):
fact[n] = n * fact[n-1] % mod
#階乗の逆元#
fact_inv = [1]*(lim+1)
fact_inv[lim] = pow(fact[lim], mod-2, mod)
for n in range(lim, 0, -1):
fact_inv[n-1] = n*fact_inv[n]%mod
def C(n, r):
return (fact[n]*fact_inv[r]%mod)*fact_inv[n-r]%mod
H, W, A, B = MAP()
ans = 0
for n in range(B, W):
way = C(H-A-1+n, n)*C(W-n-1+A-1, A-1)%mod
ans = (ans+way)%mod
print(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,
17,
2,
17,
17,
0,
13,
2,
39,
17,
13,
12,
13,
28,
13,
4,
13,
17,
13,
0,
18,
13,
13,
2,
2,
13,
18,
13,
2,
13,
17,
13,
12,
13,
0,
13,
2,
18,
13,
13,
13,
0,
13,
2,
2,
18,
13,
13,
18,
13,
2,
13,
13,
13,
0,
13,
4,
13,
13,
2,
13,
17,
13,
29,
2,
2,
13,
13,
13,
23,
13,
23,
13,
4,
13,
0,
13,
4,
13,
2,
2,
13,
13,
17,
2,
13,
17,
0,
13,
17,
28,
13,
4,
13,
17,
2,
13,
17,
0,
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,
0,
13,
2,
13,
13,
14,
40,
2,
13,
13,
17,
4,
13,
2,
2,
13,
13,
13,
4,
13,
2,
13,
13,
10,
4,
13,
10,
17,
13,
10,
2,
13,
10,
12,
13,
10,
2,
13,
10,
2,
13,
10,
12,
13,
10,
4,
13,
10,
2,
13,
10,
4,
13,
10,
4,
13,
10,
4,
13,
10,
2,
13
] | [
[
207,
2
],
[
207,
11
],
[
207,
12
],
[
207,
13
],
[
198,
15
],
[
210,
22
],
[
189,
29
],
[
211,
33
],
[
38,
37
],
[
211,
41
],
[
46,
43
],
[
190,
44
],
[
37,
45
],
[
37,
48
],
[
190,
50
],
[
37,
52
],
[
199,
54
],
[
59,
58
],
[
190,
61
],
[
93,
62
],
[
199,
63
],
[
66,
65
],
[
190,
69
],
[
95,
70
],
[
190,
72
],
[
93,
74
],
[
95,
75
],
[
199,
76
],
[
79,
78
],
[
65,
81
],
[
208,
81
],
[
199,
83
],
[
199,
85
],
[
58,
89
],
[
196,
89
],
[
78,
90
],
[
199,
91
],
[
93,
93
],
[
95,
95
],
[
193,
97
],
[
204,
99
],
[
184,
101
],
[
175,
104
],
[
202,
105
],
[
175,
108
],
[
177,
111
],
[
115,
114
],
[
208,
119
],
[
180,
122
],
[
184,
125
],
[
175,
130
],
[
196,
131
],
[
114,
133
],
[
114,
136
],
[
184,
139
],
[
196,
143
],
[
202,
145
],
[
114,
146
],
[
202,
148
],
[
114,
149
],
[
186,
151
],
[
181,
153
],
[
178,
153
],
[
187,
153
],
[
199,
154
],
[
205,
158
],
[
187,
159
],
[
181,
159
],
[
178,
159
],
[
205,
165
],
[
187,
166
],
[
181,
166
],
[
178,
166
],
[
199,
167
],
[
205,
171
],
[
187,
172
],
[
181,
172
],
[
178,
172
],
[
207,
175
],
[
177,
178
],
[
180,
181
],
[
186,
187
],
[
189,
190
],
[
207,
196
],
[
198,
199
],
[
207,
202
],
[
204,
205
],
[
207,
208
],
[
210,
211
]
] | [
"h, w, a, b = map(int, input().split())\n###############\n# 二項係数テンプレート\n# 出力制限\nmod = 10 ** 9 + 7\nMAX_N = 2 * 10 ** 5\nfactorial = [1] * MAX_N\n#事前に階乗テーブルを用意\ndef calc_factorial():\n for i in range(1, MAX_N):\n factorial[i] = i * factorial[i - 1] % mod\n\ndef comb(n, k):\n a = factorial[n] % mod\n b = (factorial[k] * factorial[n - k]) % mod\n b_ = pow(b, mod - 2, mod)\n return (a * b_) % mod\n\n\n# 階乗を用意\ncalc_factorial()\n#########\n\n# 全体の組み合わせを計算する\n# h-1(高さ)+w-1(横幅)から、h-1(高さ)個取り出す組み合わせ\nall = comb(h + w - 2, h - 1)\nsub = 0\nfor j in range(1, b + 1):\n sub += comb(h - a - 1 + j - 1, j - 1) * comb(a - 1 + w - j, w - j)\n sub = sub % mod\nif all - sub <= 0:\n print(all - sub + mod)\nelse:\n print(all - sub)",
"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",
"MAX_N = 2 * 10 ** 5",
"MAX_N",
"2 * 10 ** 5",
"2",
"10 ** 5",
"10",
"5",
"factorial = [1] * MAX_N",
"factorial",
"[1] * MAX_N",
"[1]",
"1",
"MAX_N",
"def calc_factorial():\n for i in range(1, MAX_N):\n factorial[i] = i * factorial[i - 1] % mod",
"calc_factorial",
"for i in range(1, MAX_N):\n factorial[i] = i * factorial[i - 1] % mod",
"i",
"range(1, MAX_N)",
"range",
"1",
"MAX_N",
"factorial[i] = i * factorial[i - 1] % mod",
"factorial[i]",
"factorial",
"i",
"i * factorial[i - 1] % mod",
"i * factorial[i - 1]",
"i",
"factorial[i - 1]",
"factorial",
"i - 1",
"i",
"1",
"mod",
"def comb(n, k):\n a = factorial[n] % mod\n b = (factorial[k] * factorial[n - k]) % mod\n b_ = pow(b, mod - 2, mod)\n return (a * b_) % mod\n\n\n# 階乗を用意",
"comb",
"a = factorial[n] % mod",
"a",
"factorial[n] % mod",
"factorial[n]",
"factorial",
"n",
"mod",
"b = (factorial[k] * factorial[n - k]) % mod",
"b",
"(factorial[k] * factorial[n - k]) % mod",
"factorial[k] * factorial[n - k]",
"factorial[k]",
"factorial",
"k",
"factorial[n - k]",
"factorial",
"n - k",
"n",
"k",
"mod",
"b_ = pow(b, mod - 2, mod)",
"b_",
"pow(b, mod - 2, mod)",
"pow",
"b",
"mod - 2",
"mod",
"2",
"mod",
"return (a * b_) % mod",
"(a * b_) % mod",
"a * b_",
"a",
"b_",
"mod",
"n",
"n",
"k",
"k",
"calc_factorial()",
"calc_factorial",
"all = comb(h + w - 2, h - 1)",
"all",
"comb(h + w - 2, h - 1)",
"comb",
"h + w - 2",
"h + w",
"h",
"w",
"2",
"h - 1",
"h",
"1",
"sub = 0",
"sub",
"0",
"for j in range(1, b + 1):\n sub += comb(h - a - 1 + j - 1, j - 1) * comb(a - 1 + w - j, w - j)\n sub = sub % mod",
"j",
"range(1, b + 1)",
"range",
"1",
"b + 1",
"b",
"1",
"sub += comb(h - a - 1 + j - 1, j - 1) * comb(a - 1 + w - j, w - j)",
"sub",
"comb(h - a - 1 + j - 1, j - 1) * comb(a - 1 + w - j, w - j)",
"comb(h - a - 1 + j - 1, j - 1)",
"comb",
"h - a - 1 + j - 1",
"h - a - 1 + j",
"h - a - 1",
"h - a",
"h",
"a",
"1",
"j",
"1",
"j - 1",
"j",
"1",
"comb(a - 1 + w - j, w - j)",
"comb",
"a - 1 + w - j",
"a - 1 + w",
"a - 1",
"a",
"1",
"w",
"j",
"w - j",
"w",
"j",
"sub = sub % mod",
"sub",
"sub % mod",
"sub",
"mod",
"if all - sub <= 0:\n print(all - sub + mod)\nelse:\n print(all - sub)",
"all - sub <= 0",
"all - sub",
"all",
"sub",
"0",
"print(all - sub + mod)",
"print",
"all - sub + mod",
"all - sub",
"all",
"sub",
"mod",
"print(all - sub)",
"print",
"all - sub",
"all",
"sub",
"h, w, a, b = map(int, input().split())",
"map(int, input().split())",
"h",
"sub = 0",
"0",
"sub",
"sub += comb(h - a - 1 + j - 1, j - 1) * comb(a - 1 + w - j, w - j)",
"comb(h - a - 1 + j - 1, j - 1) * comb(a - 1 + w - j, w - j)",
"sub",
"def comb(n, k):\n a = factorial[n] % mod\n b = (factorial[k] * factorial[n - k]) % mod\n b_ = pow(b, mod - 2, mod)\n return (a * b_) % mod\n\n\n# 階乗を用意",
"def comb(n, k):\n a = factorial[n] % mod\n b = (factorial[k] * factorial[n - k]) % mod\n b_ = pow(b, mod - 2, mod)\n return (a * b_) % mod\n\n\n# 階乗を用意",
"comb",
"sub = sub % mod",
"sub % mod",
"sub",
"factorial = [1] * MAX_N",
"[1] * MAX_N",
"factorial",
"def calc_factorial():\n for i in range(1, MAX_N):\n factorial[i] = i * factorial[i - 1] % mod",
"def calc_factorial():\n for i in range(1, MAX_N):\n factorial[i] = i * factorial[i - 1] % mod",
"calc_factorial",
"a, b = map(int, input().split())",
"map(int, input().split())",
"a",
"mod = 10 ** 9 + 7",
"10 ** 9 + 7",
"mod",
"w, a, b = map(int, input().split())",
"map(int, input().split())",
"w",
"all = comb(h + w - 2, h - 1)",
"comb(h + w - 2, h - 1)",
"all",
"b = map(int, input().split())",
"map(int, input().split())",
"b",
"MAX_N = 2 * 10 ** 5",
"2 * 10 ** 5",
"MAX_N"
] | h, w, a, b = map(int, input().split())
###############
# 二項係数テンプレート
# 出力制限
mod = 10 ** 9 + 7
MAX_N = 2 * 10 ** 5
factorial = [1] * MAX_N
#事前に階乗テーブルを用意
def calc_factorial():
for i in range(1, MAX_N):
factorial[i] = i * factorial[i - 1] % mod
def comb(n, k):
a = factorial[n] % mod
b = (factorial[k] * factorial[n - k]) % mod
b_ = pow(b, mod - 2, mod)
return (a * b_) % mod
# 階乗を用意
calc_factorial()
#########
# 全体の組み合わせを計算する
# h-1(高さ)+w-1(横幅)から、h-1(高さ)個取り出す組み合わせ
all = comb(h + w - 2, h - 1)
sub = 0
for j in range(1, b + 1):
sub += comb(h - a - 1 + j - 1, j - 1) * comb(a - 1 + w - j, w - j)
sub = sub % mod
if all - sub <= 0:
print(all - sub + mod)
else:
print(all - sub) |
[
7,
15,
13,
0,
13,
18,
18,
13,
13,
13,
12,
13,
0,
13,
2,
39,
17,
13,
13,
2,
39,
17,
13,
13,
2,
39,
17,
13,
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,
29,
39,
13,
13,
13,
23,
13,
23,
13,
12,
13,
14,
2,
13,
13,
29,
17,
29,
2,
2,
18,
13,
13,
2,
2,
18,
13,
13,
18,
13,
2,
13,
13,
13,
13,
23,
13,
23,
13,
23,
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,
17,
13,
13,
13,
0,
13,
17,
28,
13,
4,
13,
2,
13,
13,
0,
13,
2,
4,
13,
2,
2,
13,
13,
17,
13,
13,
13,
13,
4,
13,
2,
2,
2,
2,
2,
13,
13,
17,
13,
13,
17,
2,
2,
13,
13,
17,
13,
13,
13,
0,
13,
13,
4,
13,
13,
10,
17,
13,
10,
4,
13,
10,
12,
13,
10,
4,
13,
10,
4,
13,
10,
13,
13,
10,
4,
13,
10,
18,
13,
10,
2,
13,
10,
4,
13,
10,
2,
13,
10,
12,
13,
10,
4,
13,
10,
4,
13
] | [
[
225,
4
],
[
14,
13
],
[
85,
17
],
[
19,
18
],
[
85,
22
],
[
24,
23
],
[
85,
27
],
[
30,
29
],
[
85,
33
],
[
38,
35
],
[
13,
36
],
[
29,
37
],
[
13,
41
],
[
29,
43
],
[
29,
45
],
[
87,
46
],
[
51,
48
],
[
23,
49
],
[
29,
50
],
[
87,
52
],
[
23,
56
],
[
87,
58
],
[
29,
59
],
[
87,
61
],
[
29,
62
],
[
87,
63
],
[
68,
65
],
[
18,
66
],
[
29,
67
],
[
18,
71
],
[
29,
73
],
[
48,
75
],
[
23,
76
],
[
29,
77
],
[
87,
78
],
[
85,
85
],
[
87,
87
],
[
115,
92
],
[
117,
93
],
[
121,
100
],
[
115,
101
],
[
123,
105
],
[
117,
106
],
[
123,
108
],
[
115,
110
],
[
117,
111
],
[
119,
112
],
[
119,
113
],
[
115,
115
],
[
117,
117
],
[
119,
119
],
[
121,
121
],
[
123,
123
],
[
243,
125
],
[
226,
132
],
[
243,
134
],
[
243,
135
],
[
243,
136
],
[
234,
138
],
[
222,
145
],
[
211,
147
],
[
235,
149
],
[
222,
150
],
[
222,
151
],
[
204,
153
],
[
157,
156
],
[
232,
160
],
[
217,
161
],
[
228,
163
],
[
238,
166
],
[
156,
169
],
[
241,
170
],
[
156,
172
],
[
235,
173
],
[
214,
174
],
[
208,
175
],
[
238,
177
],
[
232,
183
],
[
156,
184
],
[
244,
186
],
[
241,
187
],
[
244,
191
],
[
241,
192
],
[
235,
194
],
[
214,
195
],
[
208,
196
],
[
219,
198
],
[
235,
199
],
[
220,
202
],
[
229,
202
],
[
205,
202
],
[
204,
205
],
[
222,
208
],
[
222,
214
],
[
243,
217
],
[
235,
219
],
[
219,
220
],
[
222,
223
],
[
225,
226
],
[
228,
229
],
[
243,
232
],
[
234,
235
],
[
243,
241
],
[
243,
244
]
] | [
"# python3 (3.4.3)\nimport sys\ninput = sys.stdin.readline\n\n# functions\ndef init_fact(n,mod):\n fact,finv,inv = [1]*n,[1]*n,[1]*n\n for i in range(2,n):\n fact[i] = (fact[i-1]*i) % mod\n inv[i] = mod - inv[mod%i] * (mod//i)%mod\n finv[i] = finv[i-1] * inv[i] % mod\n return (fact,finv,inv)\n\ndef nCr(n,r,mod,fact,finv):\n if n<r:\n return 0\n else:\n return fact[n] * (finv[r] * finv[n-r] % mod) % mod\n\n# main\nH,W,A,B = map(int,input().split())\n\nmodulo = 10**9+7\nfact,finv,inv = init_fact(200000,modulo)\n\nans = 0\nfor i in range(H-A):\n ans += nCr(i+B-1,i,modulo,fact,finv) * nCr(H-i-1+W-B-1,W-B-1,modulo,fact,finv)\n ans %= modulo\n\nprint(ans)",
"import sys",
"sys",
"input = sys.stdin.readline",
"input",
"sys.stdin.readline",
"sys.stdin",
"sys",
"stdin",
"readline",
"def init_fact(n,mod):\n fact,finv,inv = [1]*n,[1]*n,[1]*n\n for i in range(2,n):\n fact[i] = (fact[i-1]*i) % mod\n inv[i] = mod - inv[mod%i] * (mod//i)%mod\n finv[i] = finv[i-1] * inv[i] % mod\n return (fact,finv,inv)",
"init_fact",
"fact,finv,inv = [1]*n,[1]*n,[1]*n",
"fact",
"[1]*n",
"[1]",
"1",
"n",
"finv",
"[1]*n",
"[1]",
"1",
"n",
"inv",
"[1]*n",
"[1]",
"1",
"n",
"for i in range(2,n):\n fact[i] = (fact[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,n)",
"range",
"2",
"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[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",
"return (fact,finv,inv)",
"(fact,finv,inv)",
"fact",
"finv",
"inv",
"n",
"n",
"mod",
"mod",
"def nCr(n,r,mod,fact,finv):\n if n<r:\n return 0\n else:\n return fact[n] * (finv[r] * finv[n-r] % mod) % mod\n\n# main",
"nCr",
"if n<r:\n return 0\n else:\n return fact[n] * (finv[r] * finv[n-r] % mod) % mod\n\n# main",
"n<r",
"n",
"r",
"return 0",
"0",
"return fact[n] * (finv[r] * finv[n-r] % mod) % mod",
"fact[n] * (finv[r] * finv[n-r] % mod) % mod",
"fact[n] * (finv[r] * finv[n-r] % mod)",
"fact[n]",
"fact",
"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",
"mod",
"mod",
"fact",
"fact",
"finv",
"finv",
"H,W,A,B = map(int,input().split())",
"H",
"map(int,input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"W",
"A",
"B",
"modulo = 10**9+7",
"modulo",
"10**9+7",
"10**9",
"10",
"9",
"7",
"fact,finv,inv = init_fact(200000,modulo)",
"fact",
"init_fact(200000,modulo)",
"init_fact",
"200000",
"modulo",
"finv",
"inv",
"ans = 0",
"ans",
"0",
"for i in range(H-A):\n ans += nCr(i+B-1,i,modulo,fact,finv) * nCr(H-i-1+W-B-1,W-B-1,modulo,fact,finv)\n ans %= modulo",
"i",
"range(H-A)",
"range",
"H-A",
"H",
"A",
"ans += nCr(i+B-1,i,modulo,fact,finv) * nCr(H-i-1+W-B-1,W-B-1,modulo,fact,finv)",
"ans",
"nCr(i+B-1,i,modulo,fact,finv) * nCr(H-i-1+W-B-1,W-B-1,modulo,fact,finv)",
"nCr(i+B-1,i,modulo,fact,finv)",
"nCr",
"i+B-1",
"i+B",
"i",
"B",
"1",
"i",
"modulo",
"fact",
"finv",
"nCr(H-i-1+W-B-1,W-B-1,modulo,fact,finv)",
"nCr",
"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",
"modulo",
"fact",
"finv",
"ans %= modulo",
"ans",
"modulo",
"print(ans)",
"print",
"ans",
"ans = 0",
"0",
"ans",
"finv,inv = init_fact(200000,modulo)",
"init_fact(200000,modulo)",
"finv",
"def init_fact(n,mod):\n fact,finv,inv = [1]*n,[1]*n,[1]*n\n for i in range(2,n):\n fact[i] = (fact[i-1]*i) % mod\n inv[i] = mod - inv[mod%i] * (mod//i)%mod\n finv[i] = finv[i-1] * inv[i] % mod\n return (fact,finv,inv)",
"def init_fact(n,mod):\n fact,finv,inv = [1]*n,[1]*n,[1]*n\n for i in range(2,n):\n fact[i] = (fact[i-1]*i) % mod\n inv[i] = mod - inv[mod%i] * (mod//i)%mod\n finv[i] = finv[i-1] * inv[i] % mod\n return (fact,finv,inv)",
"init_fact",
"fact,finv,inv = init_fact(200000,modulo)",
"init_fact(200000,modulo)",
"fact",
"A,B = map(int,input().split())",
"map(int,input().split())",
"A",
"ans %= modulo",
"modulo",
"ans",
"inv = init_fact(200000,modulo)",
"init_fact(200000,modulo)",
"inv",
"input = sys.stdin.readline",
"sys.stdin.readline",
"input",
"ans += nCr(i+B-1,i,modulo,fact,finv) * nCr(H-i-1+W-B-1,W-B-1,modulo,fact,finv)",
"nCr(i+B-1,i,modulo,fact,finv) * nCr(H-i-1+W-B-1,W-B-1,modulo,fact,finv)",
"ans",
"H,W,A,B = map(int,input().split())",
"map(int,input().split())",
"H",
"modulo = 10**9+7",
"10**9+7",
"modulo",
"def nCr(n,r,mod,fact,finv):\n if n<r:\n return 0\n else:\n return fact[n] * (finv[r] * finv[n-r] % mod) % mod\n\n# main",
"def nCr(n,r,mod,fact,finv):\n if n<r:\n return 0\n else:\n return fact[n] * (finv[r] * finv[n-r] % mod) % mod\n\n# main",
"nCr",
"B = map(int,input().split())",
"map(int,input().split())",
"B",
"W,A,B = map(int,input().split())",
"map(int,input().split())",
"W"
] | # python3 (3.4.3)
import sys
input = sys.stdin.readline
# functions
def init_fact(n,mod):
fact,finv,inv = [1]*n,[1]*n,[1]*n
for i in range(2,n):
fact[i] = (fact[i-1]*i) % mod
inv[i] = mod - inv[mod%i] * (mod//i)%mod
finv[i] = finv[i-1] * inv[i] % mod
return (fact,finv,inv)
def nCr(n,r,mod,fact,finv):
if n<r:
return 0
else:
return fact[n] * (finv[r] * finv[n-r] % mod) % mod
# main
H,W,A,B = map(int,input().split())
modulo = 10**9+7
fact,finv,inv = init_fact(200000,modulo)
ans = 0
for i in range(H-A):
ans += nCr(i+B-1,i,modulo,fact,finv) * nCr(H-i-1+W-B-1,W-B-1,modulo,fact,finv)
ans %= modulo
print(ans)
|
[
7,
15,
13,
13,
13,
15,
15,
15,
15,
15,
15,
15,
12,
13,
14,
13,
4,
13,
31,
13,
23,
12,
13,
12,
13,
12,
13,
12,
13,
12,
13,
12,
13,
12,
13,
12,
13,
12,
13,
23,
13,
23,
13,
4,
18,
13,
13,
2,
17,
17,
0,
13,
18,
13,
13,
0,
13,
2,
2,
17,
17,
17,
0,
13,
39,
17,
17,
17,
17,
17,
17,
17,
17,
0,
13,
39,
17,
17,
17,
17,
17,
17,
17,
17,
0,
13,
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,
0,
13,
2,
2,
17,
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,
13,
13,
0,
13,
17,
28,
13,
4,
13,
17,
2,
2,
13,
13,
17,
4,
13,
13,
2,
2,
13,
13,
17,
2,
13,
17,
2,
2,
2,
2,
13,
13,
13,
13,
17,
2,
13,
13,
4,
13,
4,
13,
2,
2,
13,
13,
17,
2,
13,
17,
4,
13,
2,
2,
2,
2,
13,
13,
13,
13,
17,
2,
13,
13,
0,
13,
2,
2,
4,
13,
2,
2,
13,
13,
17,
2,
13,
17,
4,
13,
2,
2,
2,
2,
13,
13,
13,
13,
17,
2,
13,
13,
13,
0,
13,
13,
4,
13,
13,
10,
39,
13,
10,
13,
13,
10,
12,
13,
10,
12,
13,
10,
12,
13,
10,
39,
13,
10,
4,
13,
10,
2,
13,
10,
17,
13,
10,
18,
13,
10,
4,
13,
10,
4,
13,
10,
12,
13,
10,
12,
13,
10,
39,
13,
10,
12,
13,
10,
12,
13,
10,
39,
13,
10,
4,
13,
10,
2,
13,
10,
12,
13,
10,
2,
13,
10,
12,
13,
10,
12,
13,
10,
17,
13,
10,
12,
13,
10,
39,
13
] | [
[
40,
40
],
[
42,
42
],
[
331,
51
],
[
367,
56
],
[
346,
63
],
[
319,
74
],
[
376,
85
],
[
126,
92
],
[
124,
95
],
[
126,
96
],
[
101,
100
],
[
126,
103
],
[
124,
105
],
[
126,
106
],
[
124,
113
],
[
100,
116
],
[
126,
116
],
[
124,
120
],
[
100,
121
],
[
126,
121
],
[
368,
122
],
[
124,
124
],
[
126,
126
],
[
325,
128
],
[
355,
137
],
[
304,
142
],
[
382,
147
],
[
153,
152
],
[
326,
157
],
[
356,
161
],
[
356,
166
],
[
152,
168
],
[
368,
169
],
[
383,
172
],
[
383,
178
],
[
368,
180
],
[
152,
181
],
[
368,
183
],
[
152,
184
],
[
368,
185
],
[
305,
188
],
[
305,
193
],
[
383,
196
],
[
368,
198
],
[
358,
200
],
[
341,
202
],
[
358,
203
],
[
358,
204
],
[
358,
205
],
[
328,
207
],
[
211,
210
],
[
338,
216
],
[
323,
217
],
[
380,
220
],
[
210,
221
],
[
335,
224
],
[
210,
225
],
[
210,
228
],
[
359,
234
],
[
335,
235
],
[
338,
236
],
[
210,
237
],
[
338,
240
],
[
210,
241
],
[
380,
243
],
[
311,
245
],
[
335,
248
],
[
210,
249
],
[
210,
252
],
[
311,
255
],
[
359,
260
],
[
335,
261
],
[
338,
262
],
[
210,
263
],
[
338,
266
],
[
210,
267
],
[
361,
269
],
[
311,
273
],
[
335,
276
],
[
210,
277
],
[
210,
280
],
[
311,
283
],
[
359,
288
],
[
335,
289
],
[
338,
290
],
[
210,
291
],
[
338,
294
],
[
210,
295
],
[
368,
296
],
[
307,
298
],
[
368,
299
],
[
308,
302
],
[
362,
302
],
[
329,
302
],
[
304,
305
],
[
368,
307
],
[
307,
308
],
[
319,
320
],
[
358,
323
],
[
325,
326
],
[
328,
329
],
[
331,
332
],
[
358,
335
],
[
358,
338
],
[
346,
347
],
[
355,
356
],
[
358,
359
],
[
361,
362
],
[
367,
368
],
[
376,
377
],
[
382,
383
]
] | [
"import sys, re, os\nfrom collections import deque, defaultdict, Counter\nfrom math import ceil, sqrt, hypot, factorial, pi, sin, cos, radians, acos, atan, asin, log, log10\nfrom itertools import permutations, combinations, product, accumulate\nfrom operator import itemgetter, mul\nfrom copy import deepcopy\nfrom string import ascii_lowercase, ascii_uppercase, digits\nfrom fractions import gcd\ndef debug(*args):\n if debugmode:\n print(*args)\ndef input(): return sys.stdin.readline().strip()\ndef STR(): return input()\ndef INT(): return int(input())\ndef FLOAT(): return float(input())\ndef MAP(): return map(int, input().split())\ndef S_MAP(): return map(str, input().split())\ndef LIST(): return list(map(int, input().split()))\ndef S_LIST(): return list(map(str, input().split()))\ndef lcm(a, b): return a * b // gcd(a, b)\nsys.setrecursionlimit(10 ** 9)\ninf = sys.maxsize\nmod = 10 ** 9 + 7\ndx = [0, 0, 1, -1, 1, -1, -1, 1]\ndy = [1, -1, 0, 0, 1, -1, 1, -1]\ndebugmode = False\n\n#コンビネーション\ndef cmb(n, r):\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\nN = 2 * 10 ** 5 + 100 # N は必要分だけ用意する\nfact = [1, 1] # fact[n] = (n! mod p)\nfactinv = [1, 1] # factinv[n] = ((n!)^(-1) mod p)\ninv = [0, 1] # factinv 計算用\n\nfor 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\nh, w, a, b = MAP()\nans = 0\nfor i in range(1, h - a + 1):\n debug(i, b + i - 2, i - 1, w - b + h - i - 1, h - i)\n debug(cmb(b + i - 2, i - 1), cmb(w - b + h - i - 1, h - i))\n ans += cmb(b + i - 2, i - 1) * cmb(w - b + h - i - 1, h - i) % mod\n ans %= mod\nprint(ans)\n",
"import sys, re, os",
"sys",
"re",
"os",
"from collections import deque, defaultdict, Counter",
"from math import ceil, sqrt, hypot, factorial, pi, sin, cos, radians, acos, atan, asin, log, log10",
"from itertools import permutations, combinations, product, accumulate",
"from operator import itemgetter, mul",
"from copy import deepcopy",
"from string import ascii_lowercase, ascii_uppercase, digits",
"from fractions import gcd",
"def debug(*args):\n if debugmode:\n print(*args)",
"debug",
"if debugmode:\n print(*args)",
"debugmode",
"print(*args)",
"print",
"*args",
"args",
"*args",
"def input(): return sys.stdin.readline().strip()",
"input",
"def STR(): return input()",
"STR",
"def INT(): return int(input())",
"INT",
"def FLOAT(): return float(input())",
"FLOAT",
"def MAP(): return map(int, input().split())",
"MAP",
"def S_MAP(): return map(str, input().split())",
"S_MAP",
"def LIST(): return list(map(int, input().split()))",
"LIST",
"def S_LIST(): return list(map(str, input().split()))",
"S_LIST",
"def lcm(a, b): return a * b // gcd(a, b)",
"lcm",
"a",
"a",
"b",
"b",
"sys.setrecursionlimit(10 ** 9)",
"sys.setrecursionlimit",
"sys",
"setrecursionlimit",
"10 ** 9",
"10",
"9",
"inf = sys.maxsize",
"inf",
"sys.maxsize",
"sys",
"maxsize",
"mod = 10 ** 9 + 7",
"mod",
"10 ** 9 + 7",
"10 ** 9",
"10",
"9",
"7",
"dx = [0, 0, 1, -1, 1, -1, -1, 1]",
"dx",
"[0, 0, 1, -1, 1, -1, -1, 1]",
"0",
"0",
"1",
"-1",
"1",
"-1",
"-1",
"1",
"dy = [1, -1, 0, 0, 1, -1, 1, -1]",
"dy",
"[1, -1, 0, 0, 1, -1, 1, -1]",
"1",
"-1",
"0",
"0",
"1",
"-1",
"1",
"-1",
"debugmode = False",
"debugmode",
"False",
"def cmb(n, r):\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",
"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",
"N = 2 * 10 ** 5 + 100",
"N",
"2 * 10 ** 5 + 100",
"2 * 10 ** 5",
"2",
"10 ** 5",
"10",
"5",
"100",
"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)",
"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",
"h, w, a, b = MAP()",
"h",
"MAP()",
"MAP",
"w",
"a",
"b",
"ans = 0",
"ans",
"0",
"for i in range(1, h - a + 1):\n debug(i, b + i - 2, i - 1, w - b + h - i - 1, h - i)\n debug(cmb(b + i - 2, i - 1), cmb(w - b + h - i - 1, h - i))\n ans += cmb(b + i - 2, i - 1) * cmb(w - b + h - i - 1, h - i) % mod\n ans %= mod",
"i",
"range(1, h - a + 1)",
"range",
"1",
"h - a + 1",
"h - a",
"h",
"a",
"1",
"debug(i, b + i - 2, i - 1, w - b + h - i - 1, h - i)",
"debug",
"i",
"b + i - 2",
"b + i",
"b",
"i",
"2",
"i - 1",
"i",
"1",
"w - b + h - i - 1",
"w - b + h - i",
"w - b + h",
"w - b",
"w",
"b",
"h",
"i",
"1",
"h - i",
"h",
"i",
"debug(cmb(b + i - 2, i - 1), cmb(w - b + h - i - 1, h - i))",
"debug",
"cmb(b + i - 2, i - 1)",
"cmb",
"b + i - 2",
"b + i",
"b",
"i",
"2",
"i - 1",
"i",
"1",
"cmb(w - b + h - i - 1, h - i)",
"cmb",
"w - b + h - i - 1",
"w - b + h - i",
"w - b + h",
"w - b",
"w",
"b",
"h",
"i",
"1",
"h - i",
"h",
"i",
"ans += cmb(b + i - 2, i - 1) * cmb(w - b + h - i - 1, h - i) % mod",
"ans",
"cmb(b + i - 2, i - 1) * cmb(w - b + h - i - 1, h - i) % mod",
"cmb(b + i - 2, i - 1) * cmb(w - b + h - i - 1, h - i)",
"cmb(b + i - 2, i - 1)",
"cmb",
"b + i - 2",
"b + i",
"b",
"i",
"2",
"i - 1",
"i",
"1",
"cmb(w - b + h - i - 1, h - i)",
"cmb",
"w - b + h - i - 1",
"w - b + h - i",
"w - b + h",
"w - b",
"w",
"b",
"h",
"i",
"1",
"h - i",
"h",
"i",
"mod",
"ans %= mod",
"ans",
"mod",
"print(ans)",
"print",
"ans",
"factinv = [1, 1]",
"[1, 1]",
"factinv",
"ans %= mod",
"mod",
"ans",
"def cmb(n, r):\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",
"def cmb(n, r):\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",
"cmb",
"def INT(): return int(input())",
"def INT(): return int(input())",
"INT",
"def FLOAT(): return float(input())",
"def FLOAT(): return float(input())",
"FLOAT",
"dy = [1, -1, 0, 0, 1, -1, 1, -1]",
"[1, -1, 0, 0, 1, -1, 1, -1]",
"dy",
"a, b = MAP()",
"MAP()",
"a",
"N = 2 * 10 ** 5 + 100",
"2 * 10 ** 5 + 100",
"N",
"ans = 0",
"0",
"ans",
"inf = sys.maxsize",
"sys.maxsize",
"inf",
"b = MAP()",
"MAP()",
"b",
"h, w, a, b = MAP()",
"MAP()",
"h",
"def MAP(): return map(int, input().split())",
"def MAP(): return map(int, input().split())",
"MAP",
"def S_MAP(): return map(str, input().split())",
"def S_MAP(): return map(str, input().split())",
"S_MAP",
"dx = [0, 0, 1, -1, 1, -1, -1, 1]",
"[0, 0, 1, -1, 1, -1, -1, 1]",
"dx",
"def STR(): return input()",
"def STR(): return input()",
"STR",
"def S_LIST(): return list(map(str, input().split()))",
"def S_LIST(): return list(map(str, input().split()))",
"S_LIST",
"fact = [1, 1]",
"[1, 1]",
"fact",
"w, a, b = MAP()",
"MAP()",
"w",
"ans += cmb(b + i - 2, i - 1) * cmb(w - b + h - i - 1, h - i) % mod",
"cmb(b + i - 2, i - 1) * cmb(w - b + h - i - 1, h - i) % mod",
"ans",
"def input(): return sys.stdin.readline().strip()",
"def input(): return sys.stdin.readline().strip()",
"input",
"mod = 10 ** 9 + 7",
"10 ** 9 + 7",
"mod",
"def lcm(a, b): return a * b // gcd(a, b)",
"def lcm(a, b): return a * b // gcd(a, b)",
"lcm",
"def LIST(): return list(map(int, input().split()))",
"def LIST(): return list(map(int, input().split()))",
"LIST",
"debugmode = False",
"False",
"debugmode",
"def debug(*args):\n if debugmode:\n print(*args)",
"def debug(*args):\n if debugmode:\n print(*args)",
"debug",
"inv = [0, 1]",
"[0, 1]",
"inv"
] | import sys, re, os
from collections import deque, defaultdict, Counter
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, radians, acos, atan, asin, log, log10
from itertools import permutations, combinations, product, accumulate
from operator import itemgetter, mul
from copy import deepcopy
from string import ascii_lowercase, ascii_uppercase, digits
from fractions import gcd
def debug(*args):
if debugmode:
print(*args)
def input(): return sys.stdin.readline().strip()
def STR(): return input()
def INT(): return int(input())
def FLOAT(): return float(input())
def MAP(): return map(int, input().split())
def S_MAP(): return map(str, input().split())
def LIST(): return list(map(int, input().split()))
def S_LIST(): return list(map(str, input().split()))
def lcm(a, b): return a * b // gcd(a, b)
sys.setrecursionlimit(10 ** 9)
inf = sys.maxsize
mod = 10 ** 9 + 7
dx = [0, 0, 1, -1, 1, -1, -1, 1]
dy = [1, -1, 0, 0, 1, -1, 1, -1]
debugmode = False
#コンビネーション
def cmb(n, r):
if (r < 0) or (n < r):
return 0
r = min(r, n - r)
return fact[n] * factinv[r] * factinv[n-r] % mod
N = 2 * 10 ** 5 + 100 # N は必要分だけ用意する
fact = [1, 1] # fact[n] = (n! mod p)
factinv = [1, 1] # factinv[n] = ((n!)^(-1) mod p)
inv = [0, 1] # factinv 計算用
for i in range(2, N + 1):
fact.append((fact[-1] * i) % mod)
inv.append((-inv[mod % i] * (mod // i)) % mod)
factinv.append((factinv[-1] * inv[-1]) % mod)
h, w, a, b = MAP()
ans = 0
for i in range(1, h - a + 1):
debug(i, b + i - 2, i - 1, w - b + h - i - 1, h - i)
debug(cmb(b + i - 2, i - 1), cmb(w - b + h - i - 1, h - i))
ans += cmb(b + i - 2, i - 1) * cmb(w - b + h - i - 1, h - i) % mod
ans %= mod
print(ans)
|
[
7,
0,
13,
2,
2,
17,
2,
17,
17,
17,
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,
2,
2,
13,
17,
2,
13,
17,
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,
4,
13,
13,
4,
18,
4,
13,
13,
13,
13,
13,
0,
13,
4,
13,
2,
2,
13,
13,
17,
2,
13,
17,
28,
13,
4,
13,
13,
0,
13,
2,
2,
13,
2,
4,
13,
2,
2,
2,
13,
13,
13,
17,
13,
4,
13,
2,
2,
2,
13,
13,
13,
17,
2,
13,
17,
13,
4,
13,
13,
10,
12,
13,
10,
4,
13,
10,
2,
13,
10,
2,
13,
10,
4,
13,
10,
2,
13,
10,
2,
13,
10,
2,
13,
10,
4,
13,
10,
4,
13,
10,
4,
13
] | [
[
207,
2
],
[
213,
11
],
[
201,
18
],
[
208,
23
],
[
27,
26
],
[
208,
31
],
[
37,
34
],
[
202,
35
],
[
26,
36
],
[
202,
40
],
[
26,
42
],
[
26,
44
],
[
214,
45
],
[
210,
47
],
[
208,
52
],
[
58,
55
],
[
211,
56
],
[
208,
57
],
[
202,
61
],
[
208,
62
],
[
214,
64
],
[
214,
66
],
[
69,
68
],
[
208,
72
],
[
80,
77
],
[
211,
78
],
[
68,
79
],
[
211,
83
],
[
68,
85
],
[
68,
88
],
[
214,
90
],
[
126,
97
],
[
128,
100
],
[
128,
103
],
[
126,
104
],
[
202,
113
],
[
126,
114
],
[
211,
116
],
[
128,
117
],
[
214,
118
],
[
211,
120
],
[
126,
122
],
[
128,
123
],
[
214,
124
],
[
126,
126
],
[
128,
128
],
[
219,
130
],
[
219,
139
],
[
219,
140
],
[
219,
141
],
[
222,
143
],
[
193,
145
],
[
217,
148
],
[
205,
149
],
[
217,
152
],
[
156,
155
],
[
196,
158
],
[
198,
160
],
[
223,
163
],
[
199,
163
],
[
193,
166
],
[
217,
170
],
[
220,
171
],
[
155,
172
],
[
155,
174
],
[
193,
176
],
[
220,
180
],
[
205,
181
],
[
155,
182
],
[
220,
185
],
[
214,
187
],
[
199,
190
],
[
223,
190
],
[
219,
196
],
[
198,
199
],
[
201,
202
],
[
219,
205
],
[
207,
208
],
[
210,
211
],
[
213,
214
],
[
219,
217
],
[
219,
220
],
[
222,
223
]
] | [
"N=2*10**5+3\nmod=10**9+7\nfac=[1]*(N+1)\nfor i in range(1,N+1):\n fac[i]=fac[i-1]*i%mod\ninv_fac=[1]*(N+1)\ninv_fac[N]=pow(fac[N],mod-2,mod)\nfor i in range(N-1,0,-1):\n inv_fac[i]=inv_fac[i+1]*(i+1)%mod\ndef nCr(n,r):\n if n<0 or r<0 or r>n:\n return 0\n return fac[n]*inv_fac[r]%mod*inv_fac[n-r]%mod\nh,w,a,b=map(int,input().split())\nans=nCr(h+w-2,h-1)\nfor i in range(b):\n ans=(ans-nCr(h-a+i-1,i)*nCr(a+w-i-2,a-1))%mod\nprint(ans)",
"N=2*10**5+3",
"N",
"2*10**5+3",
"2*10**5",
"2",
"10**5",
"10",
"5",
"3",
"mod=10**9+7",
"mod",
"10**9+7",
"10**9",
"10",
"9",
"7",
"fac=[1]*(N+1)",
"fac",
"[1]*(N+1)",
"[1]",
"1",
"N+1",
"N",
"1",
"for i in range(1,N+1):\n fac[i]=fac[i-1]*i%mod",
"i",
"range(1,N+1)",
"range",
"1",
"N+1",
"N",
"1",
"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_fac=[1]*(N+1)",
"inv_fac",
"[1]*(N+1)",
"[1]",
"1",
"N+1",
"N",
"1",
"inv_fac[N]=pow(fac[N],mod-2,mod)",
"inv_fac[N]",
"inv_fac",
"N",
"pow(fac[N],mod-2,mod)",
"pow",
"fac[N]",
"fac",
"N",
"mod-2",
"mod",
"2",
"mod",
"for i in range(N-1,0,-1):\n inv_fac[i]=inv_fac[i+1]*(i+1)%mod",
"i",
"range(N-1,0,-1)",
"range",
"N-1",
"N",
"1",
"0",
"-1",
"inv_fac[i]=inv_fac[i+1]*(i+1)%mod",
"inv_fac[i]",
"inv_fac",
"i",
"inv_fac[i+1]*(i+1)%mod",
"inv_fac[i+1]*(i+1)",
"inv_fac[i+1]",
"inv_fac",
"i+1",
"i",
"1",
"i+1",
"i",
"1",
"mod",
"def nCr(n,r):\n if n<0 or r<0 or r>n:\n return 0\n return fac[n]*inv_fac[r]%mod*inv_fac[n-r]%mod",
"nCr",
"if n<0 or r<0 or r>n:\n return 0\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]*inv_fac[r]%mod*inv_fac[n-r]%mod",
"fac[n]*inv_fac[r]%mod*inv_fac[n-r]%mod",
"fac[n]*inv_fac[r]%mod*inv_fac[n-r]",
"fac[n]*inv_fac[r]%mod",
"fac[n]*inv_fac[r]",
"fac[n]",
"fac",
"n",
"inv_fac[r]",
"inv_fac",
"r",
"mod",
"inv_fac[n-r]",
"inv_fac",
"n-r",
"n",
"r",
"mod",
"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",
"ans=nCr(h+w-2,h-1)",
"ans",
"nCr(h+w-2,h-1)",
"nCr",
"h+w-2",
"h+w",
"h",
"w",
"2",
"h-1",
"h",
"1",
"for i in range(b):\n ans=(ans-nCr(h-a+i-1,i)*nCr(a+w-i-2,a-1))%mod",
"i",
"range(b)",
"range",
"b",
"ans=(ans-nCr(h-a+i-1,i)*nCr(a+w-i-2,a-1))%mod",
"ans",
"(ans-nCr(h-a+i-1,i)*nCr(a+w-i-2,a-1))%mod",
"ans-nCr(h-a+i-1,i)*nCr(a+w-i-2,a-1)",
"ans",
"nCr(h-a+i-1,i)*nCr(a+w-i-2,a-1)",
"nCr(h-a+i-1,i)",
"nCr",
"h-a+i-1",
"h-a+i",
"h-a",
"h",
"a",
"i",
"1",
"i",
"nCr(a+w-i-2,a-1)",
"nCr",
"a+w-i-2",
"a+w-i",
"a+w",
"a",
"w",
"i",
"2",
"a-1",
"a",
"1",
"mod",
"print(ans)",
"print",
"ans",
"def nCr(n,r):\n if n<0 or r<0 or r>n:\n return 0\n return fac[n]*inv_fac[r]%mod*inv_fac[n-r]%mod",
"def nCr(n,r):\n if n<0 or r<0 or r>n:\n return 0\n return fac[n]*inv_fac[r]%mod*inv_fac[n-r]%mod",
"nCr",
"b=map(int,input().split())",
"map(int,input().split())",
"b",
"ans=(ans-nCr(h-a+i-1,i)*nCr(a+w-i-2,a-1))%mod",
"(ans-nCr(h-a+i-1,i)*nCr(a+w-i-2,a-1))%mod",
"ans",
"fac=[1]*(N+1)",
"[1]*(N+1)",
"fac",
"w,a,b=map(int,input().split())",
"map(int,input().split())",
"w",
"N=2*10**5+3",
"2*10**5+3",
"N",
"inv_fac=[1]*(N+1)",
"[1]*(N+1)",
"inv_fac",
"mod=10**9+7",
"10**9+7",
"mod",
"h,w,a,b=map(int,input().split())",
"map(int,input().split())",
"h",
"a,b=map(int,input().split())",
"map(int,input().split())",
"a",
"ans=nCr(h+w-2,h-1)",
"nCr(h+w-2,h-1)",
"ans"
] | N=2*10**5+3
mod=10**9+7
fac=[1]*(N+1)
for i in range(1,N+1):
fac[i]=fac[i-1]*i%mod
inv_fac=[1]*(N+1)
inv_fac[N]=pow(fac[N],mod-2,mod)
for i in range(N-1,0,-1):
inv_fac[i]=inv_fac[i+1]*(i+1)%mod
def nCr(n,r):
if n<0 or r<0 or r>n:
return 0
return fac[n]*inv_fac[r]%mod*inv_fac[n-r]%mod
h,w,a,b=map(int,input().split())
ans=nCr(h+w-2,h-1)
for i in range(b):
ans=(ans-nCr(h-a+i-1,i)*nCr(a+w-i-2,a-1))%mod
print(ans) |
[
7,
0,
13,
2,
2,
17,
17,
17,
0,
13,
39,
17,
17,
0,
13,
39,
17,
17,
0,
13,
39,
17,
17,
0,
13,
4,
13,
13,
4,
18,
4,
13,
13,
13,
13,
13,
0,
13,
2,
13,
13,
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,
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,
42,
2,
2,
13,
13,
2,
13,
13,
0,
13,
2,
2,
13,
2,
4,
13,
2,
2,
2,
13,
17,
13,
13,
13,
4,
13,
2,
2,
2,
13,
17,
13,
13,
13,
13,
0,
13,
17,
0,
13,
17,
4,
13,
13,
10,
39,
13,
10,
17,
13,
10,
39,
13,
10,
17,
13,
10,
4,
13,
10,
2,
13,
10,
2,
13,
10,
17,
13,
10,
4,
13,
10,
39,
13,
10,
2,
13,
10,
12,
13,
10,
4,
13,
10,
4,
13
] | [
[
189,
2
],
[
159,
9
],
[
186,
14
],
[
165,
19
],
[
198,
24
],
[
198,
33
],
[
198,
34
],
[
198,
35
],
[
174,
37
],
[
196,
39
],
[
172,
40
],
[
43,
42
],
[
175,
47
],
[
160,
51
],
[
160,
56
],
[
42,
58
],
[
190,
59
],
[
166,
62
],
[
166,
68
],
[
190,
70
],
[
42,
71
],
[
190,
73
],
[
42,
74
],
[
190,
75
],
[
187,
78
],
[
187,
83
],
[
166,
86
],
[
190,
88
],
[
160,
96
],
[
108,
97
],
[
187,
99
],
[
110,
100
],
[
187,
102
],
[
108,
104
],
[
110,
105
],
[
190,
106
],
[
108,
108
],
[
110,
110
],
[
162,
112
],
[
199,
117
],
[
181,
117
],
[
196,
118
],
[
184,
120
],
[
169,
120
],
[
172,
121
],
[
177,
123
],
[
163,
126
],
[
178,
126
],
[
193,
129
],
[
196,
133
],
[
199,
135
],
[
181,
135
],
[
184,
136
],
[
169,
136
],
[
184,
137
],
[
169,
137
],
[
193,
139
],
[
172,
143
],
[
184,
145
],
[
169,
145
],
[
199,
146
],
[
181,
146
],
[
199,
147
],
[
181,
147
],
[
190,
148
],
[
180,
150
],
[
168,
153
],
[
178,
157
],
[
163,
157
],
[
159,
160
],
[
162,
163
],
[
165,
166
],
[
168,
169
],
[
198,
172
],
[
174,
175
],
[
177,
178
],
[
180,
181
],
[
198,
184
],
[
186,
187
],
[
189,
190
],
[
198,
196
],
[
198,
199
]
] | [
"mod=10**9+7\ng1=[1,1]\ng2=[1,1]\ninverse=[0,1]\nh,w,a,b=map(int,input().split())\nn=h+w\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)\ndef cmb(n,r):\n return g1[n]*g2[r]*g2[n-r]%mod\n \nans=0\nwhile a<h and b<w:\n ans=(ans+cmb(h-1-a+b,b)*cmb(w-1-b+a,a))%mod\n a+=1\n b+=1\nprint(ans)",
"mod=10**9+7",
"mod",
"10**9+7",
"10**9",
"10",
"9",
"7",
"g1=[1,1]",
"g1",
"[1,1]",
"1",
"1",
"g2=[1,1]",
"g2",
"[1,1]",
"1",
"1",
"inverse=[0,1]",
"inverse",
"[0,1]",
"0",
"1",
"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",
"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",
"def cmb(n,r):\n return g1[n]*g2[r]*g2[n-r]%mod\n ",
"cmb",
"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",
"ans=0",
"ans",
"0",
"while a<h and b<w:\n ans=(ans+cmb(h-1-a+b,b)*cmb(w-1-b+a,a))%mod\n a+=1\n b+=1",
"a<h and b<w",
"a<h",
"a",
"h",
"b<w",
"b",
"w",
"ans=(ans+cmb(h-1-a+b,b)*cmb(w-1-b+a,a))%mod",
"ans",
"(ans+cmb(h-1-a+b,b)*cmb(w-1-b+a,a))%mod",
"ans+cmb(h-1-a+b,b)*cmb(w-1-b+a,a)",
"ans",
"cmb(h-1-a+b,b)*cmb(w-1-b+a,a)",
"cmb(h-1-a+b,b)",
"cmb",
"h-1-a+b",
"h-1-a",
"h-1",
"h",
"1",
"a",
"b",
"b",
"cmb(w-1-b+a,a)",
"cmb",
"w-1-b+a",
"w-1-b",
"w-1",
"w",
"1",
"b",
"a",
"a",
"mod",
"a+=1",
"a",
"1",
"b+=1",
"b",
"1",
"print(ans)",
"print",
"ans",
"g1=[1,1]",
"[1,1]",
"g1",
"ans=0",
"0",
"ans",
"inverse=[0,1]",
"[0,1]",
"inverse",
"b+=1",
"1",
"b",
"w,a,b=map(int,input().split())",
"map(int,input().split())",
"w",
"n=h+w",
"h+w",
"n",
"ans=(ans+cmb(h-1-a+b,b)*cmb(w-1-b+a,a))%mod",
"(ans+cmb(h-1-a+b,b)*cmb(w-1-b+a,a))%mod",
"ans",
"a+=1",
"1",
"a",
"b=map(int,input().split())",
"map(int,input().split())",
"b",
"g2=[1,1]",
"[1,1]",
"g2",
"mod=10**9+7",
"10**9+7",
"mod",
"def cmb(n,r):\n return g1[n]*g2[r]*g2[n-r]%mod\n ",
"def cmb(n,r):\n return g1[n]*g2[r]*g2[n-r]%mod\n ",
"cmb",
"h,w,a,b=map(int,input().split())",
"map(int,input().split())",
"h",
"a,b=map(int,input().split())",
"map(int,input().split())",
"a"
] | mod=10**9+7
g1=[1,1]
g2=[1,1]
inverse=[0,1]
h,w,a,b=map(int,input().split())
n=h+w
for i in range(2,n+1):
g1.append((g1[-1]*i)%mod)
inverse.append((-inverse[mod % i]*(mod//i))%mod)
g2.append((g2[-1]*inverse[-1])%mod)
def cmb(n,r):
return g1[n]*g2[r]*g2[n-r]%mod
ans=0
while a<h and b<w:
ans=(ans+cmb(h-1-a+b,b)*cmb(w-1-b+a,a))%mod
a+=1
b+=1
print(ans) |
[
7,
15,
15,
13,
0,
13,
4,
13,
13,
4,
18,
4,
13,
13,
17,
13,
13,
13,
0,
13,
2,
2,
17,
17,
17,
0,
13,
4,
13,
2,
2,
2,
13,
13,
13,
17,
2,
13,
13,
12,
13,
0,
13,
17,
42,
13,
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,
12,
13,
14,
2,
2,
13,
17,
2,
13,
13,
29,
17,
29,
2,
2,
2,
2,
18,
13,
13,
18,
13,
2,
13,
13,
13,
18,
13,
13,
13,
23,
13,
23,
13,
0,
13,
2,
39,
17,
13,
0,
13,
4,
13,
17,
13,
0,
13,
2,
39,
17,
13,
0,
13,
4,
13,
17,
13,
28,
13,
4,
13,
17,
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,
0,
13,
17,
28,
13,
4,
13,
13,
13,
0,
13,
2,
2,
13,
13,
17,
0,
13,
13,
0,
13,
2,
13,
17,
0,
13,
2,
2,
13,
13,
17,
0,
13,
2,
2,
4,
13,
2,
13,
13,
13,
4,
13,
2,
13,
13,
13,
13,
0,
13,
2,
2,
13,
13,
13,
4,
13,
4,
13,
13,
10,
2,
13,
10,
12,
13,
10,
2,
13,
10,
13,
13,
10,
2,
13,
10,
2,
13,
10,
4,
13,
10,
2,
13,
10,
2,
13,
10,
4,
13,
10,
12,
13,
10,
4,
13,
10,
2,
13,
10,
2,
13,
10,
4,
13,
10,
4,
13,
10,
4,
13,
10,
4,
13,
10,
17,
13
] | [
[
268,
5
],
[
268,
15
],
[
268,
16
],
[
268,
17
],
[
259,
19
],
[
271,
26
],
[
251,
32
],
[
257,
33
],
[
269,
34
],
[
269,
37
],
[
257,
38
],
[
43,
42
],
[
72,
48
],
[
65,
48
],
[
52,
51
],
[
42,
54
],
[
51,
54
],
[
70,
55
],
[
58,
55
],
[
260,
56
],
[
59,
58
],
[
70,
61
],
[
58,
61
],
[
70,
62
],
[
58,
62
],
[
260,
63
],
[
66,
65
],
[
51,
68
],
[
42,
68
],
[
70,
70
],
[
72,
72
],
[
106,
78
],
[
104,
81
],
[
106,
82
],
[
104,
92
],
[
104,
96
],
[
106,
97
],
[
260,
98
],
[
106,
101
],
[
260,
102
],
[
104,
104
],
[
106,
106
],
[
235,
108
],
[
272,
112
],
[
274,
114
],
[
236,
118
],
[
262,
120
],
[
272,
124
],
[
241,
126
],
[
263,
130
],
[
133,
132
],
[
272,
136
],
[
141,
138
],
[
275,
139
],
[
236,
139
],
[
132,
140
],
[
275,
144
],
[
236,
144
],
[
132,
146
],
[
132,
148
],
[
260,
149
],
[
154,
151
],
[
242,
152
],
[
263,
152
],
[
132,
153
],
[
254,
155
],
[
138,
156
],
[
275,
157
],
[
236,
157
],
[
132,
158
],
[
260,
160
],
[
277,
163
],
[
167,
166
],
[
266,
169
],
[
257,
170
],
[
244,
172
],
[
251,
175
],
[
269,
176
],
[
232,
179
],
[
166,
180
],
[
238,
182
],
[
269,
184
],
[
247,
187
],
[
257,
190
],
[
166,
191
],
[
223,
194
],
[
227,
198
],
[
233,
200
],
[
245,
201
],
[
233,
202
],
[
227,
204
],
[
248,
206
],
[
239,
207
],
[
248,
208
],
[
260,
209
],
[
229,
211
],
[
278,
214
],
[
230,
214
],
[
224,
215
],
[
260,
216
],
[
230,
221
],
[
278,
221
],
[
223,
224
],
[
229,
230
],
[
166,
232
],
[
232,
233
],
[
235,
236
],
[
238,
239
],
[
241,
242
],
[
244,
245
],
[
247,
248
],
[
268,
251
],
[
268,
257
],
[
259,
260
],
[
262,
263
],
[
268,
266
],
[
268,
269
],
[
271,
272
],
[
274,
275
],
[
277,
278
]
] | [
"from array import *\nimport time\nh, w, a, b = map(int, input().split(' '))\nMOD = 10**9 + 7\nMAX = max(h+w-a-1, a+w)\n\n\ndef modpow(a, b):\n res = 1\n while b:\n if (b & 1):\n res = (res * a) % MOD\n a = (a * a) % MOD\n b >>= 1\n return res\n\n\ndef nCr(n, r):\n if r == 0 or n == r:\n return 1\n return (((f[n] * ivf[n-r]) % MOD) * ivf[r]) % MOD\n\n\nf = [1] * MAX\nf = array('q', f)\nivf = [0] * MAX\nivf = array('q', ivf)\nfor i in range(1, MAX):\n f[i] = (f[i-1] * i) % MOD\n ivf[i] = modpow(f[i], MOD-2)\nr = 0\nfor i in range(b, w):\n y1 = h - a - 1\n x1 = i\n y2 = a - 1\n x2 = w - i - 1\n p = (nCr(x1 + y1, x1) * nCr(x2 + y2, x2)) % MOD\n r = (r + p) % MOD\nprint(int(r))",
"from array import *",
"import time",
"time",
"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",
"MAX = max(h+w-a-1, a+w)",
"MAX",
"max(h+w-a-1, a+w)",
"max",
"h+w-a-1",
"h+w-a",
"h+w",
"h",
"w",
"a",
"1",
"a+w",
"a",
"w",
"def modpow(a, b):\n res = 1\n while b:\n if (b & 1):\n res = (res * a) % MOD\n a = (a * a) % MOD\n b >>= 1\n return res",
"modpow",
"res = 1",
"res",
"1",
"while b:\n if (b & 1):\n res = (res * a) % MOD\n a = (a * a) % MOD\n b >>= 1\n ",
"b",
"if (b & 1):\n res = (res * a) % MOD\n ",
"b & 1",
"b",
"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",
"b >>= 1",
"b",
"1",
"return res",
"res",
"a",
"a",
"b",
"b",
"def nCr(n, r):\n if r == 0 or n == r:\n return 1\n return (((f[n] * ivf[n-r]) % MOD) * ivf[r]) % MOD",
"nCr",
"if r == 0 or n == r:\n return 1\n ",
"r == 0 or n == r",
"r == 0",
"r",
"0",
"n == r",
"n",
"r",
"return 1",
"1",
"return (((f[n] * ivf[n-r]) % MOD) * ivf[r]) % MOD",
"(((f[n] * ivf[n-r]) % MOD) * ivf[r]) % MOD",
"((f[n] * ivf[n-r]) % MOD) * ivf[r]",
"(f[n] * ivf[n-r]) % MOD",
"f[n] * ivf[n-r]",
"f[n]",
"f",
"n",
"ivf[n-r]",
"ivf",
"n-r",
"n",
"r",
"MOD",
"ivf[r]",
"ivf",
"r",
"MOD",
"n",
"n",
"r",
"r",
"f = [1] * MAX",
"f",
"[1] * MAX",
"[1]",
"1",
"MAX",
"f = array('q', f)",
"f",
"array('q', f)",
"array",
"'q'",
"f",
"ivf = [0] * MAX",
"ivf",
"[0] * MAX",
"[0]",
"0",
"MAX",
"ivf = array('q', ivf)",
"ivf",
"array('q', ivf)",
"array",
"'q'",
"ivf",
"for i in range(1, MAX):\n f[i] = (f[i-1] * i) % MOD\n ivf[i] = modpow(f[i], MOD-2)",
"i",
"range(1, MAX)",
"range",
"1",
"MAX",
"f[i] = (f[i-1] * i) % MOD",
"f[i]",
"f",
"i",
"(f[i-1] * i) % MOD",
"f[i-1] * i",
"f[i-1]",
"f",
"i-1",
"i",
"1",
"i",
"MOD",
"ivf[i] = modpow(f[i], MOD-2)",
"ivf[i]",
"ivf",
"i",
"modpow(f[i], MOD-2)",
"modpow",
"f[i]",
"f",
"i",
"MOD-2",
"MOD",
"2",
"r = 0",
"r",
"0",
"for i in range(b, w):\n y1 = h - a - 1\n x1 = i\n y2 = a - 1\n x2 = w - i - 1\n p = (nCr(x1 + y1, x1) * nCr(x2 + y2, x2)) % MOD\n r = (r + p) % MOD",
"i",
"range(b, w)",
"range",
"b",
"w",
"y1 = h - a - 1",
"y1",
"h - a - 1",
"h - a",
"h",
"a",
"1",
"x1 = i",
"x1",
"i",
"y2 = a - 1",
"y2",
"a - 1",
"a",
"1",
"x2 = w - i - 1",
"x2",
"w - i - 1",
"w - i",
"w",
"i",
"1",
"p = (nCr(x1 + y1, x1) * nCr(x2 + y2, x2)) % MOD",
"p",
"(nCr(x1 + y1, x1) * nCr(x2 + y2, x2)) % MOD",
"nCr(x1 + y1, x1) * nCr(x2 + y2, x2)",
"nCr(x1 + y1, x1)",
"nCr",
"x1 + y1",
"x1",
"y1",
"x1",
"nCr(x2 + y2, x2)",
"nCr",
"x2 + y2",
"x2",
"y2",
"x2",
"MOD",
"r = (r + p) % MOD",
"r",
"(r + p) % MOD",
"r + p",
"r",
"p",
"MOD",
"print(int(r))",
"print",
"int(r)",
"int",
"r",
"p = (nCr(x1 + y1, x1) * nCr(x2 + y2, x2)) % MOD",
"(nCr(x1 + y1, x1) * nCr(x2 + y2, x2)) % MOD",
"p",
"def nCr(n, r):\n if r == 0 or n == r:\n return 1\n return (((f[n] * ivf[n-r]) % MOD) * ivf[r]) % MOD",
"def nCr(n, r):\n if r == 0 or n == r:\n return 1\n return (((f[n] * ivf[n-r]) % MOD) * ivf[r]) % MOD",
"nCr",
"r = (r + p) % MOD",
"(r + p) % MOD",
"r",
"x1 = i",
"i",
"x1",
"f = [1] * MAX",
"[1] * MAX",
"f",
"y2 = a - 1",
"a - 1",
"y2",
"ivf = array('q', ivf)",
"array('q', ivf)",
"ivf",
"y1 = h - a - 1",
"h - a - 1",
"y1",
"x2 = w - i - 1",
"w - i - 1",
"x2",
"h, w, a, b = map(int, input().split(' '))",
"map(int, input().split(' '))",
"h",
"def modpow(a, b):\n res = 1\n while b:\n if (b & 1):\n res = (res * a) % MOD\n a = (a * a) % MOD\n b >>= 1\n return res",
"def modpow(a, b):\n res = 1\n while b:\n if (b & 1):\n res = (res * a) % MOD\n a = (a * a) % MOD\n b >>= 1\n return res",
"modpow",
"w, a, b = map(int, input().split(' '))",
"map(int, input().split(' '))",
"w",
"MOD = 10**9 + 7",
"10**9 + 7",
"MOD",
"ivf = [0] * MAX",
"[0] * MAX",
"ivf",
"b = map(int, input().split(' '))",
"map(int, input().split(' '))",
"b",
"a, b = map(int, input().split(' '))",
"map(int, input().split(' '))",
"a",
"MAX = max(h+w-a-1, a+w)",
"max(h+w-a-1, a+w)",
"MAX",
"f = array('q', f)",
"array('q', f)",
"f",
"r = 0",
"0",
"r"
] | from array import *
import time
h, w, a, b = map(int, input().split(' '))
MOD = 10**9 + 7
MAX = max(h+w-a-1, a+w)
def modpow(a, b):
res = 1
while b:
if (b & 1):
res = (res * a) % MOD
a = (a * a) % MOD
b >>= 1
return res
def nCr(n, r):
if r == 0 or n == r:
return 1
return (((f[n] * ivf[n-r]) % MOD) * ivf[r]) % MOD
f = [1] * MAX
f = array('q', f)
ivf = [0] * MAX
ivf = array('q', ivf)
for i in range(1, MAX):
f[i] = (f[i-1] * i) % MOD
ivf[i] = modpow(f[i], MOD-2)
r = 0
for i in range(b, w):
y1 = h - a - 1
x1 = i
y2 = a - 1
x2 = w - i - 1
p = (nCr(x1 + y1, x1) * nCr(x2 + y2, x2)) % MOD
r = (r + p) % MOD
print(int(r))
|
[
7,
12,
13,
0,
13,
4,
13,
13,
4,
18,
4,
13,
13,
13,
13,
13,
0,
13,
2,
2,
17,
17,
17,
0,
13,
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,
18,
13,
13,
4,
13,
18,
13,
13,
2,
13,
17,
13,
4,
13,
18,
13,
2,
13,
13,
2,
13,
17,
13,
23,
13,
23,
13,
23,
13,
28,
13,
4,
13,
2,
13,
13,
0,
13,
2,
4,
13,
2,
2,
13,
13,
17,
2,
13,
17,
13,
4,
13,
2,
2,
2,
2,
2,
13,
17,
13,
13,
13,
17,
2,
2,
13,
13,
17,
13,
4,
13,
2,
13,
13,
14,
2,
13,
17,
4,
13,
10,
12,
13
] | [
[
5,
4
],
[
5,
13
],
[
5,
14
],
[
5,
15
],
[
18,
17
],
[
25,
24
],
[
28,
27
],
[
32,
31
],
[
4,
35
],
[
13,
36
],
[
27,
39
],
[
27,
44
],
[
31,
45
],
[
31,
47
],
[
17,
49
],
[
27,
56
],
[
79,
57
],
[
27,
61
],
[
81,
62
],
[
83,
64
],
[
83,
66
],
[
27,
70
],
[
79,
72
],
[
81,
73
],
[
83,
75
],
[
83,
77
],
[
79,
79
],
[
81,
81
],
[
83,
83
],
[
86,
85
],
[
4,
89
],
[
14,
90
],
[
93,
92
],
[
51,
95
],
[
85,
98
],
[
15,
99
],
[
15,
102
],
[
17,
104
],
[
51,
106
],
[
4,
112
],
[
85,
114
],
[
13,
115
],
[
15,
116
],
[
13,
120
],
[
15,
121
],
[
17,
123
],
[
92,
127
],
[
24,
127
],
[
17,
128
],
[
137,
134
]
] | [
"def main():\n H, W, A, B = map(int, input().split())\n mod = 10**9 + 7\n ans = 0\n\n # 予め階乗を計算しておく\n f = [1]\n for i in range(H+W):\n f.append(f[i]*(i+1)%mod)\n\n # 組み合わせ関数\n def comb_mod(n, r, p):\n return f[n] * pow(f[r], p-2, p) * pow(f[n-r], p-2, p)\n\n for i in range(H-A):\n ans += comb_mod(i+B-1,B-1,mod) * comb_mod(H-1-i+W-B-1,W-B-1,mod)\n\n print(ans%mod)\n\nif __name__ == '__main__':\n main()",
"def main():\n H, W, A, B = map(int, input().split())\n mod = 10**9 + 7\n ans = 0\n\n # 予め階乗を計算しておく\n f = [1]\n for i in range(H+W):\n f.append(f[i]*(i+1)%mod)\n\n # 組み合わせ関数\n def comb_mod(n, r, p):\n return f[n] * pow(f[r], p-2, p) * pow(f[n-r], p-2, p)\n\n for i in range(H-A):\n ans += comb_mod(i+B-1,B-1,mod) * comb_mod(H-1-i+W-B-1,W-B-1,mod)\n\n print(ans%mod)",
"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",
"ans = 0",
"ans",
"0",
"f = [1]",
"f",
"[1]",
"1",
"for i in range(H+W):\n f.append(f[i]*(i+1)%mod)\n\n # 組み合わせ関数\n ",
"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_mod(n, r, p):\n return f[n] * pow(f[r], p-2, p) * pow(f[n-r], p-2, p)\n\n ",
"comb_mod",
"return f[n] * pow(f[r], p-2, p) * pow(f[n-r], p-2, p)",
"f[n] * pow(f[r], p-2, p) * pow(f[n-r], p-2, p)",
"f[n] * pow(f[r], p-2, p)",
"f[n]",
"f",
"n",
"pow(f[r], p-2, p)",
"pow",
"f[r]",
"f",
"r",
"p-2",
"p",
"2",
"p",
"pow(f[n-r], p-2, p)",
"pow",
"f[n-r]",
"f",
"n-r",
"n",
"r",
"p-2",
"p",
"2",
"p",
"n",
"n",
"r",
"r",
"p",
"p",
"for i in range(H-A):\n ans += comb_mod(i+B-1,B-1,mod) * comb_mod(H-1-i+W-B-1,W-B-1,mod)\n\n ",
"i",
"range(H-A)",
"range",
"H-A",
"H",
"A",
"ans += comb_mod(i+B-1,B-1,mod) * comb_mod(H-1-i+W-B-1,W-B-1,mod)",
"ans",
"comb_mod(i+B-1,B-1,mod) * comb_mod(H-1-i+W-B-1,W-B-1,mod)",
"comb_mod(i+B-1,B-1,mod)",
"comb_mod",
"i+B-1",
"i+B",
"i",
"B",
"1",
"B-1",
"B",
"1",
"mod",
"comb_mod(H-1-i+W-B-1,W-B-1,mod)",
"comb_mod",
"H-1-i+W-B-1",
"H-1-i+W-B",
"H-1-i+W",
"H-1-i",
"H-1",
"H",
"1",
"i",
"W",
"B",
"1",
"W-B-1",
"W-B",
"W",
"B",
"1",
"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 = map(int, input().split())\n mod = 10**9 + 7\n ans = 0\n\n # 予め階乗を計算しておく\n f = [1]\n for i in range(H+W):\n f.append(f[i]*(i+1)%mod)\n\n # 組み合わせ関数\n def comb_mod(n, r, p):\n return f[n] * pow(f[r], p-2, p) * pow(f[n-r], p-2, p)\n\n for i in range(H-A):\n ans += comb_mod(i+B-1,B-1,mod) * comb_mod(H-1-i+W-B-1,W-B-1,mod)\n\n print(ans%mod)",
"def main():\n H, W, A, B = map(int, input().split())\n mod = 10**9 + 7\n ans = 0\n\n # 予め階乗を計算しておく\n f = [1]\n for i in range(H+W):\n f.append(f[i]*(i+1)%mod)\n\n # 組み合わせ関数\n def comb_mod(n, r, p):\n return f[n] * pow(f[r], p-2, p) * pow(f[n-r], p-2, p)\n\n for i in range(H-A):\n ans += comb_mod(i+B-1,B-1,mod) * comb_mod(H-1-i+W-B-1,W-B-1,mod)\n\n print(ans%mod)",
"main"
] | def main():
H, W, A, B = map(int, input().split())
mod = 10**9 + 7
ans = 0
# 予め階乗を計算しておく
f = [1]
for i in range(H+W):
f.append(f[i]*(i+1)%mod)
# 組み合わせ関数
def comb_mod(n, r, p):
return f[n] * pow(f[r], p-2, p) * pow(f[n-r], p-2, p)
for i in range(H-A):
ans += comb_mod(i+B-1,B-1,mod) * comb_mod(H-1-i+W-B-1,W-B-1,mod)
print(ans%mod)
if __name__ == '__main__':
main() |
[
7,
6,
13,
12,
13,
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,
13,
17,
4,
18,
18,
13,
13,
13,
2,
2,
18,
18,
13,
13,
17,
13,
13,
4,
18,
18,
13,
13,
13,
2,
2,
40,
18,
18,
13,
13,
2,
13,
13,
2,
13,
13,
13,
4,
18,
18,
13,
13,
13,
2,
2,
18,
18,
13,
13,
17,
18,
18,
13,
13,
17,
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,
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,
17,
2,
2,
13,
13,
17,
0,
13,
4,
18,
13,
13,
2,
2,
13,
17,
2,
13,
17,
2,
13,
17,
0,
13,
4,
18,
13,
13,
2,
2,
13,
13,
2,
2,
13,
13,
17,
2,
13,
13,
0,
13,
2,
2,
13,
13,
13,
4,
13,
13,
14,
2,
13,
17,
4,
13,
10,
12,
13,
10,
6,
13
] | [
[
9,
6
],
[
99,
7
],
[
101,
8
],
[
101,
9
],
[
14,
11
],
[
99,
12
],
[
103,
13
],
[
103,
14
],
[
19,
16
],
[
99,
17
],
[
26,
23
],
[
99,
24
],
[
33,
30
],
[
99,
31
],
[
38,
37
],
[
101,
42
],
[
16,
46
],
[
99,
47
],
[
16,
53
],
[
99,
54
],
[
37,
57
],
[
103,
58
],
[
30,
61
],
[
99,
62
],
[
30,
69
],
[
99,
70
],
[
103,
73
],
[
37,
74
],
[
103,
76
],
[
37,
77
],
[
103,
78
],
[
23,
81
],
[
99,
82
],
[
23,
88
],
[
99,
89
],
[
30,
93
],
[
99,
94
],
[
103,
97
],
[
99,
99
],
[
101,
101
],
[
103,
103
],
[
153,
109
],
[
151,
112
],
[
153,
113
],
[
118,
117
],
[
153,
120
],
[
151,
122
],
[
153,
123
],
[
149,
130
],
[
151,
132
],
[
149,
135
],
[
117,
137
],
[
153,
137
],
[
149,
140
],
[
151,
143
],
[
117,
144
],
[
153,
144
],
[
149,
146
],
[
149,
149
],
[
151,
151
],
[
153,
153
],
[
158,
157
],
[
158,
166
],
[
158,
167
],
[
158,
168
],
[
171,
170
],
[
178,
177
],
[
157,
181
],
[
166,
182
],
[
170,
183
],
[
186,
185
],
[
189,
188
],
[
157,
194
],
[
167,
195
],
[
199,
198
],
[
177,
201
],
[
105,
202
],
[
188,
205
],
[
168,
208
],
[
188,
211
],
[
215,
214
],
[
177,
217
],
[
105,
218
],
[
157,
221
],
[
188,
222
],
[
166,
225
],
[
168,
226
],
[
157,
229
],
[
188,
230
],
[
233,
232
],
[
185,
235
],
[
232,
235
],
[
214,
236
],
[
198,
236
],
[
170,
237
],
[
232,
240
],
[
185,
240
],
[
249,
246
]
] | [
"class Combination():\n # コンストラクタ\n def __init__(self, N:int, P:int):\n self.N = N\n self.P = P\n\n # fact[i] = (i! mod P)\n self.fact = [1, 1] \n # factinv[i] = ((i!)^(-1) mod P)\n self.factinv = [1, 1]\n # factinv 計算用\n self.inv = [0, 1] \n\n for i in range(2, N+1):\n self.fact.append((self.fact[-1] * i) % P)\n self.inv.append((-self.inv[P % i] * (P // i)) % P)\n self.factinv.append((self.factinv[-1] * self.inv[-1]) % P)\n \n # nCk (mod P) (ただし、n<=N)\n def getComb(self, n:int, k:int):\n if (k < 0) or (n < k):\n return 0\n k = min(k, n - k)\n return self.fact[n] * self.factinv[k] * self.factinv[n-k] % self.P\n\ndef main():\n H,W,A,B = map(int,input().split())\n MOD = 10**9 + 7\n\n COMB = Combination(H+W, MOD)\n\n # (1,1) -> (i,B-1) -> (i,B+1) -> (H,W)\n\n ans = 0\n for i in range(1,H-A+1):\n tmp = COMB.getComb((i-1)+(B-1), i-1)\n tmp *= COMB.getComb((H-i)+(W-B-1), H-i)\n ans = (ans + tmp) % MOD\n\n print(ans)\n\nif __name__ == \"__main__\":\n main()",
"class Combination():\n # コンストラクタ\n def __init__(self, N:int, P:int):\n self.N = N\n self.P = P\n\n # fact[i] = (i! mod P)\n self.fact = [1, 1] \n # factinv[i] = ((i!)^(-1) mod P)\n self.factinv = [1, 1]\n # factinv 計算用\n self.inv = [0, 1] \n\n for i in range(2, N+1):\n self.fact.append((self.fact[-1] * i) % P)\n self.inv.append((-self.inv[P % i] * (P // i)) % P)\n self.factinv.append((self.factinv[-1] * self.inv[-1]) % P)\n \n # nCk (mod P) (ただし、n<=N)\n def getComb(self, n:int, k:int):\n if (k < 0) or (n < k):\n return 0\n k = min(k, n - k)\n return self.fact[n] * self.factinv[k] * self.factinv[n-k] % self.P",
"Combination",
"def __init__(self, N:int, P:int):\n self.N = N\n self.P = P\n\n # fact[i] = (i! mod P)\n self.fact = [1, 1] \n # factinv[i] = ((i!)^(-1) mod P)\n self.factinv = [1, 1]\n # factinv 計算用\n self.inv = [0, 1] \n\n for i in range(2, N+1):\n self.fact.append((self.fact[-1] * i) % P)\n self.inv.append((-self.inv[P % i] * (P // i)) % P)\n self.factinv.append((self.factinv[-1] * self.inv[-1]) % P)\n \n # nCk (mod P) (ただし、n<=N)\n ",
"__init__",
"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",
"for i in range(2, N+1):\n self.fact.append((self.fact[-1] * i) % P)\n self.inv.append((-self.inv[P % i] * (P // i)) % P)\n self.factinv.append((self.factinv[-1] * self.inv[-1]) % P)\n \n # nCk (mod P) (ただし、n<=N)\n ",
"i",
"range(2, N+1)",
"range",
"2",
"N+1",
"N",
"1",
"self.fact.append((self.fact[-1] * i) % P)",
"self.fact.append",
"self.fact",
"self",
"fact",
"append",
"(self.fact[-1] * i) % P",
"self.fact[-1] * i",
"self.fact[-1]",
"self.fact",
"self",
"fact",
"-1",
"i",
"P",
"self.inv.append((-self.inv[P % i] * (P // i)) % P)",
"self.inv.append",
"self.inv",
"self",
"inv",
"append",
"(-self.inv[P % i] * (P // i)) % P",
"-self.inv[P % i] * (P // i)",
"-self.inv[P % i]",
"self.inv[P % i]",
"self.inv",
"self",
"inv",
"P % i",
"P",
"i",
"P // i",
"P",
"i",
"P",
"self.factinv.append((self.factinv[-1] * self.inv[-1]) % P)",
"self.factinv.append",
"self.factinv",
"self",
"factinv",
"append",
"(self.factinv[-1] * self.inv[-1]) % P",
"self.factinv[-1] * self.inv[-1]",
"self.factinv[-1]",
"self.factinv",
"self",
"factinv",
"-1",
"self.inv[-1]",
"self.inv",
"self",
"inv",
"-1",
"P",
"self",
"self",
"N:int",
"N",
"P:int",
"P",
"def getComb(self, n:int, k:int):\n if (k < 0) or (n < k):\n return 0\n k = min(k, n - k)\n return self.fact[n] * self.factinv[k] * self.factinv[n-k] % self.P",
"getComb",
"if (k < 0) or (n < k):\n return 0\n ",
"(k < 0) or (n < k)",
"k < 0",
"k",
"0",
"n < k",
"n",
"k",
"return 0",
"0",
"k = min(k, n - k)",
"k",
"min(k, n - k)",
"min",
"k",
"n - k",
"n",
"k",
"return self.fact[n] * self.factinv[k] * self.factinv[n-k] % self.P",
"self.fact[n] * self.factinv[k] * self.factinv[n-k] % self.P",
"self.fact[n] * self.factinv[k] * self.factinv[n-k]",
"self.fact[n] * self.factinv[k]",
"self.fact[n]",
"self.fact",
"self",
"fact",
"n",
"self.factinv[k]",
"self.factinv",
"self",
"factinv",
"k",
"self.factinv[n-k]",
"self.factinv",
"self",
"factinv",
"n-k",
"n",
"k",
"self.P",
"self",
"P",
"self",
"self",
"n:int",
"n",
"k:int",
"k",
"def main():\n H,W,A,B = map(int,input().split())\n MOD = 10**9 + 7\n\n COMB = Combination(H+W, MOD)\n\n # (1,1) -> (i,B-1) -> (i,B+1) -> (H,W)\n\n ans = 0\n for i in range(1,H-A+1):\n tmp = COMB.getComb((i-1)+(B-1), i-1)\n tmp *= COMB.getComb((H-i)+(W-B-1), H-i)\n ans = (ans + tmp) % MOD\n\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 = 10**9 + 7",
"MOD",
"10**9 + 7",
"10**9",
"10",
"9",
"7",
"COMB = Combination(H+W, MOD)",
"COMB",
"Combination(H+W, MOD)",
"Combination",
"H+W",
"H",
"W",
"MOD",
"ans = 0",
"ans",
"0",
"for i in range(1,H-A+1):\n tmp = COMB.getComb((i-1)+(B-1), i-1)\n tmp *= COMB.getComb((H-i)+(W-B-1), H-i)\n ans = (ans + tmp) % MOD\n\n ",
"i",
"range(1,H-A+1)",
"range",
"1",
"H-A+1",
"H-A",
"H",
"A",
"1",
"tmp = COMB.getComb((i-1)+(B-1), i-1)",
"tmp",
"COMB.getComb((i-1)+(B-1), i-1)",
"COMB.getComb",
"COMB",
"getComb",
"(i-1)+(B-1)",
"i-1",
"i",
"1",
"B-1",
"B",
"1",
"i-1",
"i",
"1",
"tmp *= COMB.getComb((H-i)+(W-B-1), H-i)",
"tmp",
"COMB.getComb((H-i)+(W-B-1), H-i)",
"COMB.getComb",
"COMB",
"getComb",
"(H-i)+(W-B-1)",
"H-i",
"H",
"i",
"W-B-1",
"W-B",
"W",
"B",
"1",
"H-i",
"H",
"i",
"ans = (ans + tmp) % MOD",
"ans",
"(ans + tmp) % MOD",
"ans + tmp",
"ans",
"tmp",
"MOD",
"print(ans)",
"print",
"ans",
"if __name__ == \"__main__\":\n main()",
"__name__ == \"__main__\"",
"__name__",
"\"__main__\"",
"main()",
"main",
"def main():\n H,W,A,B = map(int,input().split())\n MOD = 10**9 + 7\n\n COMB = Combination(H+W, MOD)\n\n # (1,1) -> (i,B-1) -> (i,B+1) -> (H,W)\n\n ans = 0\n for i in range(1,H-A+1):\n tmp = COMB.getComb((i-1)+(B-1), i-1)\n tmp *= COMB.getComb((H-i)+(W-B-1), H-i)\n ans = (ans + tmp) % MOD\n\n print(ans)",
"def main():\n H,W,A,B = map(int,input().split())\n MOD = 10**9 + 7\n\n COMB = Combination(H+W, MOD)\n\n # (1,1) -> (i,B-1) -> (i,B+1) -> (H,W)\n\n ans = 0\n for i in range(1,H-A+1):\n tmp = COMB.getComb((i-1)+(B-1), i-1)\n tmp *= COMB.getComb((H-i)+(W-B-1), H-i)\n ans = (ans + tmp) % MOD\n\n print(ans)",
"main",
"class Combination():\n # コンストラクタ\n def __init__(self, N:int, P:int):\n self.N = N\n self.P = P\n\n # fact[i] = (i! mod P)\n self.fact = [1, 1] \n # factinv[i] = ((i!)^(-1) mod P)\n self.factinv = [1, 1]\n # factinv 計算用\n self.inv = [0, 1] \n\n for i in range(2, N+1):\n self.fact.append((self.fact[-1] * i) % P)\n self.inv.append((-self.inv[P % i] * (P // i)) % P)\n self.factinv.append((self.factinv[-1] * self.inv[-1]) % P)\n \n # nCk (mod P) (ただし、n<=N)\n def getComb(self, n:int, k:int):\n if (k < 0) or (n < k):\n return 0\n k = min(k, n - k)\n return self.fact[n] * self.factinv[k] * self.factinv[n-k] % self.P",
"class Combination():\n # コンストラクタ\n def __init__(self, N:int, P:int):\n self.N = N\n self.P = P\n\n # fact[i] = (i! mod P)\n self.fact = [1, 1] \n # factinv[i] = ((i!)^(-1) mod P)\n self.factinv = [1, 1]\n # factinv 計算用\n self.inv = [0, 1] \n\n for i in range(2, N+1):\n self.fact.append((self.fact[-1] * i) % P)\n self.inv.append((-self.inv[P % i] * (P // i)) % P)\n self.factinv.append((self.factinv[-1] * self.inv[-1]) % P)\n \n # nCk (mod P) (ただし、n<=N)\n def getComb(self, n:int, k:int):\n if (k < 0) or (n < k):\n return 0\n k = min(k, n - k)\n return self.fact[n] * self.factinv[k] * self.factinv[n-k] % self.P",
"Combination"
] | class Combination():
# コンストラクタ
def __init__(self, N:int, P:int):
self.N = N
self.P = P
# fact[i] = (i! mod P)
self.fact = [1, 1]
# factinv[i] = ((i!)^(-1) mod P)
self.factinv = [1, 1]
# factinv 計算用
self.inv = [0, 1]
for i in range(2, N+1):
self.fact.append((self.fact[-1] * i) % P)
self.inv.append((-self.inv[P % i] * (P // i)) % P)
self.factinv.append((self.factinv[-1] * self.inv[-1]) % P)
# nCk (mod P) (ただし、n<=N)
def getComb(self, n:int, k:int):
if (k < 0) or (n < k):
return 0
k = min(k, n - k)
return self.fact[n] * self.factinv[k] * self.factinv[n-k] % self.P
def main():
H,W,A,B = map(int,input().split())
MOD = 10**9 + 7
COMB = Combination(H+W, MOD)
# (1,1) -> (i,B-1) -> (i,B+1) -> (H,W)
ans = 0
for i in range(1,H-A+1):
tmp = COMB.getComb((i-1)+(B-1), i-1)
tmp *= COMB.getComb((H-i)+(W-B-1), H-i)
ans = (ans + tmp) % MOD
print(ans)
if __name__ == "__main__":
main() |
[
7,
15,
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,
2,
17,
2,
17,
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,
12,
13,
14,
2,
2,
13,
17,
2,
13,
13,
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,
12,
13,
14,
2,
2,
13,
17,
2,
13,
17,
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,
17,
2,
2,
13,
13,
17,
4,
13,
13,
10,
39,
13,
10,
39,
13,
10,
12,
13,
10,
17,
13,
10,
4,
13,
10,
39,
13,
10,
4,
13,
10,
4,
13,
10,
17,
13,
10,
12,
13,
10,
4,
13
] | [
[
183,
4
],
[
159,
7
],
[
162,
12
],
[
174,
17
],
[
23,
22
],
[
160,
35
],
[
160,
40
],
[
22,
42
],
[
184,
43
],
[
175,
46
],
[
175,
52
],
[
184,
54
],
[
22,
55
],
[
184,
57
],
[
22,
58
],
[
184,
59
],
[
163,
62
],
[
163,
67
],
[
175,
70
],
[
184,
72
],
[
110,
78
],
[
110,
81
],
[
108,
82
],
[
85,
84
],
[
110,
87
],
[
108,
89
],
[
110,
90
],
[
160,
96
],
[
108,
97
],
[
163,
99
],
[
84,
100
],
[
110,
100
],
[
163,
102
],
[
108,
104
],
[
84,
105
],
[
110,
105
],
[
112,
106
],
[
108,
108
],
[
110,
110
],
[
112,
112
],
[
124,
118
],
[
126,
121
],
[
124,
124
],
[
126,
126
],
[
128,
128
],
[
189,
130
],
[
189,
139
],
[
189,
140
],
[
189,
141
],
[
168,
143
],
[
147,
146
],
[
172,
152
],
[
178,
153
],
[
169,
157
],
[
159,
160
],
[
162,
163
],
[
168,
169
],
[
189,
172
],
[
174,
175
],
[
189,
178
],
[
189,
181
],
[
183,
184
],
[
189,
190
]
] | [
"import math\np=1000000007\ng1=[1,1]\ng2=[1,1]\ninverse=[0,1]\nfor i in range(2,2*(10**5)+1):\n g1.append((g1[-1]*i)%p)\n inverse.append((-inverse[p%i]*(p//i))%p)\n g2.append((g2[-1]*inverse[-1])%p)\ndef cmb2(n, r, mod):\n if (r<0 or r>n):return 0\n r = min(r,n-r)\n return g1[n]*g2[r]*g2[n-r]%mod\ndef chwp(h,w,p):\n if h==1 or w==1:return 1\n else:return cmb2(h+w-2,h-1,p)\nh,w,a,b= map(int,input().split())\nans=0\nfor i in range(1,h-a+1):ans=(ans+chwp(i,b,p)*chwp(h-i+1,w-b,p))%p\nprint(ans)",
"import math",
"math",
"p=1000000007",
"p",
"1000000007",
"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,2*(10**5)+1):\n g1.append((g1[-1]*i)%p)\n inverse.append((-inverse[p%i]*(p//i))%p)\n g2.append((g2[-1]*inverse[-1])%p)",
"i",
"range(2,2*(10**5)+1)",
"range",
"2",
"2*(10**5)+1",
"2*(10**5)",
"2",
"10**5",
"10",
"5",
"1",
"g1.append((g1[-1]*i)%p)",
"g1.append",
"g1",
"append",
"(g1[-1]*i)%p",
"g1[-1]*i",
"g1[-1]",
"g1",
"-1",
"i",
"p",
"inverse.append((-inverse[p%i]*(p//i))%p)",
"inverse.append",
"inverse",
"append",
"(-inverse[p%i]*(p//i))%p",
"-inverse[p%i]*(p//i)",
"-inverse[p%i]",
"inverse[p%i]",
"inverse",
"p%i",
"p",
"i",
"p//i",
"p",
"i",
"p",
"g2.append((g2[-1]*inverse[-1])%p)",
"g2.append",
"g2",
"append",
"(g2[-1]*inverse[-1])%p",
"g2[-1]*inverse[-1]",
"g2[-1]",
"g2",
"-1",
"inverse[-1]",
"inverse",
"-1",
"p",
"def cmb2(n, r, mod):\n if (r<0 or r>n):return 0\n r = min(r,n-r)\n return g1[n]*g2[r]*g2[n-r]%mod",
"cmb2",
"if (r<0 or r>n):return 0\n ",
"r<0 or r>n",
"r<0",
"r",
"0",
"r>n",
"r",
"n",
"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",
"def chwp(h,w,p):\n if h==1 or w==1:return 1\n else:return cmb2(h+w-2,h-1,p)",
"chwp",
"if h==1 or w==1:return 1\n else:return cmb2(h+w-2,h-1,p)",
"h==1 or w==1",
"h==1",
"h",
"1",
"w==1",
"w",
"1",
"h",
"h",
"w",
"w",
"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(1,h-a+1):ans=(ans+chwp(i,b,p)*chwp(h-i+1,w-b,p))%p",
"i",
"range(1,h-a+1)",
"range",
"1",
"h-a+1",
"h-a",
"h",
"a",
"1",
"print(ans)",
"print",
"ans",
"g1=[1,1]",
"[1,1]",
"g1",
"g2=[1,1]",
"[1,1]",
"g2",
"def chwp(h,w,p):\n if h==1 or w==1:return 1\n else:return cmb2(h+w-2,h-1,p)",
"def chwp(h,w,p):\n if h==1 or w==1:return 1\n else:return cmb2(h+w-2,h-1,p)",
"chwp",
"ans=0",
"0",
"ans",
"h,w,a,b= map(int,input().split())",
"map(int,input().split())",
"h",
"inverse=[0,1]",
"[0,1]",
"inverse",
"a,b= map(int,input().split())",
"map(int,input().split())",
"a",
"b= map(int,input().split())",
"map(int,input().split())",
"b",
"p=1000000007",
"1000000007",
"p",
"def cmb2(n, r, mod):\n if (r<0 or r>n):return 0\n r = min(r,n-r)\n return g1[n]*g2[r]*g2[n-r]%mod",
"def cmb2(n, r, mod):\n if (r<0 or r>n):return 0\n r = min(r,n-r)\n return g1[n]*g2[r]*g2[n-r]%mod",
"cmb2",
"w,a,b= map(int,input().split())",
"map(int,input().split())",
"w"
] | import math
p=1000000007
g1=[1,1]
g2=[1,1]
inverse=[0,1]
for i in range(2,2*(10**5)+1):
g1.append((g1[-1]*i)%p)
inverse.append((-inverse[p%i]*(p//i))%p)
g2.append((g2[-1]*inverse[-1])%p)
def cmb2(n, r, mod):
if (r<0 or r>n):return 0
r = min(r,n-r)
return g1[n]*g2[r]*g2[n-r]%mod
def chwp(h,w,p):
if h==1 or w==1:return 1
else:return cmb2(h+w-2,h-1,p)
h,w,a,b= map(int,input().split())
ans=0
for i in range(1,h-a+1):ans=(ans+chwp(i,b,p)*chwp(h-i+1,w-b,p))%p
print(ans) |
[
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,
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,
4,
13,
2,
2,
2,
13,
13,
17,
13,
13,
13,
4,
13,
2,
2,
2,
2,
13,
13,
17,
13,
17,
2,
13,
17,
13,
0,
13,
17,
4,
13,
2,
13,
13,
10,
4,
13,
10,
2,
13,
10,
2,
13,
10,
4,
13,
10,
39,
13,
10,
2,
13,
10,
4,
13,
10,
39,
13,
10,
17,
13,
10,
4,
13,
10,
17,
13,
10,
12,
13,
10,
39,
13
] | [
[
40,
6
],
[
38,
9
],
[
40,
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
],
[
182,
44
],
[
185,
51
],
[
215,
56
],
[
191,
61
],
[
200,
66
],
[
72,
71
],
[
186,
76
],
[
216,
80
],
[
216,
85
],
[
71,
87
],
[
183,
88
],
[
201,
91
],
[
201,
97
],
[
183,
99
],
[
71,
100
],
[
183,
102
],
[
71,
103
],
[
183,
104
],
[
192,
107
],
[
192,
112
],
[
201,
115
],
[
183,
117
],
[
206,
119
],
[
206,
128
],
[
206,
129
],
[
206,
130
],
[
209,
132
],
[
136,
135
],
[
189,
139
],
[
207,
140
],
[
194,
142
],
[
213,
145
],
[
180,
149
],
[
198,
150
],
[
207,
152
],
[
204,
152
],
[
207,
153
],
[
204,
153
],
[
183,
154
],
[
213,
156
],
[
189,
161
],
[
207,
162
],
[
204,
162
],
[
198,
164
],
[
198,
167
],
[
183,
169
],
[
203,
171
],
[
195,
176
],
[
210,
176
],
[
183,
177
],
[
206,
180
],
[
182,
183
],
[
185,
186
],
[
206,
189
],
[
191,
192
],
[
194,
195
],
[
206,
198
],
[
200,
201
],
[
203,
204
],
[
206,
207
],
[
209,
210
],
[
215,
216
]
] | [
"def nCr(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\nmod = 10 ** 9 + 7\nN = 10 ** 6\nfact = [1, 1]\nfactinv = [1, 1]\ninv = [0, 1]\n\nfor 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\nh, w, a, b = map(int, input().split())\n\nans = 0\n\nfor i in range(w - b):\n ans += nCr(h - a - 1 + b, b, mod) * nCr(w - b - 1 + a - 1, a - 1, mod)\n b += 1\n\nprint(ans % mod)",
"def nCr(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",
"nCr",
"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",
"mod = 10 ** 9 + 7",
"mod",
"10 ** 9 + 7",
"10 ** 9",
"10",
"9",
"7",
"N = 10 ** 6",
"N",
"10 ** 6",
"10",
"6",
"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)",
"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",
"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(w - b):\n ans += nCr(h - a - 1 + b, b, mod) * nCr(w - b - 1 + a - 1, a - 1, mod)\n b += 1",
"i",
"range(w - b)",
"range",
"w - b",
"w",
"b",
"ans += nCr(h - a - 1 + b, b, mod) * nCr(w - b - 1 + a - 1, a - 1, mod)",
"ans",
"nCr(h - a - 1 + b, b, mod) * nCr(w - b - 1 + a - 1, a - 1, mod)",
"nCr(h - a - 1 + b, b, mod)",
"nCr",
"h - a - 1 + b",
"h - a - 1",
"h - a",
"h",
"a",
"1",
"b",
"b",
"mod",
"nCr(w - b - 1 + a - 1, a - 1, mod)",
"nCr",
"w - b - 1 + a - 1",
"w - b - 1 + a",
"w - b - 1",
"w - b",
"w",
"b",
"1",
"a",
"1",
"a - 1",
"a",
"1",
"mod",
"b += 1",
"b",
"1",
"print(ans % mod)",
"print",
"ans % mod",
"ans",
"mod",
"h, w, a, b = map(int, input().split())",
"map(int, input().split())",
"h",
"mod = 10 ** 9 + 7",
"10 ** 9 + 7",
"mod",
"N = 10 ** 6",
"10 ** 6",
"N",
"w, a, b = map(int, input().split())",
"map(int, input().split())",
"w",
"factinv = [1, 1]",
"[1, 1]",
"factinv",
"ans += nCr(h - a - 1 + b, b, mod) * nCr(w - b - 1 + a - 1, a - 1, mod)",
"nCr(h - a - 1 + b, b, mod) * nCr(w - b - 1 + a - 1, a - 1, mod)",
"ans",
"a, b = map(int, input().split())",
"map(int, input().split())",
"a",
"inv = [0, 1]",
"[0, 1]",
"inv",
"b += 1",
"1",
"b",
"b = map(int, input().split())",
"map(int, input().split())",
"b",
"ans = 0",
"0",
"ans",
"def nCr(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",
"def nCr(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",
"nCr",
"fact = [1, 1]",
"[1, 1]",
"fact"
] | def nCr(n, r, mod):
if r < 0 or n < r:
return 0
r = min(r, n - r)
return fact[n] * factinv[r] * factinv[n - r] % mod
mod = 10 ** 9 + 7
N = 10 ** 6
fact = [1, 1]
factinv = [1, 1]
inv = [0, 1]
for i in range(2, N + 1):
fact.append((fact[-1] * i) % mod)
inv.append((-inv[mod % i] * (mod // i)) % mod)
factinv.append((factinv[-1] * inv[-1]) % mod)
h, w, a, b = map(int, input().split())
ans = 0
for i in range(w - b):
ans += nCr(h - a - 1 + b, b, mod) * nCr(w - b - 1 + a - 1, a - 1, mod)
b += 1
print(ans % mod) |
[
7,
0,
13,
4,
13,
13,
4,
18,
4,
13,
13,
13,
13,
13,
0,
13,
2,
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,
2,
17,
17,
17,
0,
13,
39,
17,
28,
13,
4,
13,
17,
13,
4,
18,
13,
13,
2,
2,
18,
13,
2,
13,
17,
13,
13,
0,
13,
2,
39,
17,
13,
0,
18,
13,
2,
13,
17,
4,
13,
18,
13,
2,
13,
17,
2,
13,
17,
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,
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,
17,
2,
2,
13,
13,
17,
0,
13,
2,
4,
13,
2,
2,
13,
13,
17,
2,
13,
17,
4,
13,
2,
2,
2,
2,
13,
13,
13,
13,
17,
2,
2,
13,
13,
17,
0,
13,
13,
4,
13,
13,
10,
4,
13,
10,
2,
13,
10,
12,
13,
10,
13,
13,
10,
4,
13,
10,
4,
13,
10,
12,
13,
10,
4,
13,
10,
17,
13,
10,
2,
13,
10,
39,
13,
10,
2,
13,
10,
2,
13
] | [
[
207,
2
],
[
207,
11
],
[
207,
12
],
[
207,
13
],
[
189,
15
],
[
187,
17
],
[
208,
18
],
[
38,
23
],
[
38,
27
],
[
38,
32
],
[
36,
36
],
[
38,
38
],
[
222,
40
],
[
216,
47
],
[
52,
51
],
[
190,
55
],
[
217,
58
],
[
217,
63
],
[
51,
65
],
[
51,
67
],
[
223,
68
],
[
213,
70
],
[
190,
74
],
[
81,
76
],
[
214,
77
],
[
190,
79
],
[
193,
82
],
[
217,
84
],
[
190,
86
],
[
223,
89
],
[
93,
92
],
[
190,
96
],
[
104,
101
],
[
214,
102
],
[
92,
103
],
[
214,
107
],
[
92,
109
],
[
92,
112
],
[
223,
114
],
[
217,
122
],
[
134,
123
],
[
214,
125
],
[
136,
126
],
[
214,
128
],
[
134,
130
],
[
136,
131
],
[
223,
132
],
[
134,
134
],
[
136,
136
],
[
210,
138
],
[
142,
141
],
[
187,
147
],
[
199,
148
],
[
219,
151
],
[
205,
154
],
[
202,
157
],
[
141,
158
],
[
202,
161
],
[
205,
164
],
[
187,
169
],
[
141,
170
],
[
208,
171
],
[
202,
172
],
[
208,
176
],
[
202,
177
],
[
195,
180
],
[
223,
181
],
[
196,
184
],
[
220,
184
],
[
211,
184
],
[
207,
187
],
[
189,
190
],
[
223,
195
],
[
195,
196
],
[
207,
199
],
[
207,
202
],
[
207,
208
],
[
210,
211
],
[
213,
214
],
[
216,
217
],
[
219,
220
],
[
222,
223
]
] | [
"h, w, a, b = map(int, input().split())\n\nN = h + w\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\nmod = 10 ** 9 + 7\n\nfactorial = [1]\nfor i in range(1, N):\n factorial.append(factorial[i - 1] * i % mod)\n\ninverseFactorial = [0] * N\ninverseFactorial[N - 1] = power(factorial[N - 1], mod - 2)\nfor i in range(N - 2, -1, -1):\n inverseFactorial[i] = inverseFactorial[i + 1] * (i + 1) % mod\n\ndef comb(x, y):\n return factorial[x] * inverseFactorial[y] * inverseFactorial[x - y] % mod\n\n\n\nans = 0\nfor i in range(1, h - a + 1):\n ans += comb(b + i - 2, b - 1) * comb(h - i + w - b - 1, w - b - 1)\n # print(i, ans)\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",
"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",
"mod = 10 ** 9 + 7",
"mod",
"10 ** 9 + 7",
"10 ** 9",
"10",
"9",
"7",
"factorial = [1]",
"factorial",
"[1]",
"1",
"for i in range(1, N):\n factorial.append(factorial[i - 1] * i % mod)",
"i",
"range(1, N)",
"range",
"1",
"N",
"factorial.append(factorial[i - 1] * i % mod)",
"factorial.append",
"factorial",
"append",
"factorial[i - 1] * i % mod",
"factorial[i - 1] * i",
"factorial[i - 1]",
"factorial",
"i - 1",
"i",
"1",
"i",
"mod",
"inverseFactorial = [0] * N",
"inverseFactorial",
"[0] * N",
"[0]",
"0",
"N",
"inverseFactorial[N - 1] = power(factorial[N - 1], mod - 2)",
"inverseFactorial[N - 1]",
"inverseFactorial",
"N - 1",
"N",
"1",
"power(factorial[N - 1], mod - 2)",
"power",
"factorial[N - 1]",
"factorial",
"N - 1",
"N",
"1",
"mod - 2",
"mod",
"2",
"for i in range(N - 2, -1, -1):\n inverseFactorial[i] = inverseFactorial[i + 1] * (i + 1) % mod",
"i",
"range(N - 2, -1, -1)",
"range",
"N - 2",
"N",
"2",
"-1",
"-1",
"inverseFactorial[i] = inverseFactorial[i + 1] * (i + 1) % mod",
"inverseFactorial[i]",
"inverseFactorial",
"i",
"inverseFactorial[i + 1] * (i + 1) % mod",
"inverseFactorial[i + 1] * (i + 1)",
"inverseFactorial[i + 1]",
"inverseFactorial",
"i + 1",
"i",
"1",
"i + 1",
"i",
"1",
"mod",
"def comb(x, y):\n return factorial[x] * inverseFactorial[y] * inverseFactorial[x - y] % mod",
"comb",
"return factorial[x] * inverseFactorial[y] * inverseFactorial[x - y] % mod",
"factorial[x] * inverseFactorial[y] * inverseFactorial[x - y] % mod",
"factorial[x] * inverseFactorial[y] * inverseFactorial[x - y]",
"factorial[x] * inverseFactorial[y]",
"factorial[x]",
"factorial",
"x",
"inverseFactorial[y]",
"inverseFactorial",
"y",
"inverseFactorial[x - y]",
"inverseFactorial",
"x - y",
"x",
"y",
"mod",
"x",
"x",
"y",
"y",
"ans = 0",
"ans",
"0",
"for i in range(1, h - a + 1):\n ans += comb(b + i - 2, b - 1) * comb(h - i + w - b - 1, w - b - 1)\n # print(i, ans)\n ans %= mod",
"i",
"range(1, h - a + 1)",
"range",
"1",
"h - a + 1",
"h - a",
"h",
"a",
"1",
"ans += comb(b + i - 2, b - 1) * comb(h - i + w - b - 1, w - b - 1)",
"ans",
"comb(b + i - 2, b - 1) * comb(h - i + w - b - 1, w - b - 1)",
"comb(b + i - 2, b - 1)",
"comb",
"b + i - 2",
"b + i",
"b",
"i",
"2",
"b - 1",
"b",
"1",
"comb(h - i + w - b - 1, w - b - 1)",
"comb",
"h - i + w - b - 1",
"h - i + w - b",
"h - i + w",
"h - i",
"h",
"i",
"w",
"b",
"1",
"w - b - 1",
"w - b",
"w",
"b",
"1",
"ans %= mod",
"ans",
"mod",
"print(ans)",
"print",
"ans",
"h, w, a, b = map(int, input().split())",
"map(int, input().split())",
"h",
"N = h + w",
"h + w",
"N",
"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",
"ans %= mod",
"mod",
"ans",
"a, b = map(int, input().split())",
"map(int, input().split())",
"a",
"b = map(int, input().split())",
"map(int, input().split())",
"b",
"def comb(x, y):\n return factorial[x] * inverseFactorial[y] * inverseFactorial[x - y] % mod",
"def comb(x, y):\n return factorial[x] * inverseFactorial[y] * inverseFactorial[x - y] % mod",
"comb",
"w, a, b = map(int, input().split())",
"map(int, input().split())",
"w",
"ans = 0",
"0",
"ans",
"inverseFactorial = [0] * N",
"[0] * N",
"inverseFactorial",
"factorial = [1]",
"[1]",
"factorial",
"ans += comb(b + i - 2, b - 1) * comb(h - i + w - b - 1, w - b - 1)",
"comb(b + i - 2, b - 1) * comb(h - i + w - b - 1, w - b - 1)",
"ans",
"mod = 10 ** 9 + 7",
"10 ** 9 + 7",
"mod"
] | h, w, a, b = map(int, input().split())
N = h + w
def power(x, y):
if y == 0 : return 1
elif y == 1 : return x % mod
elif y % 2 == 0 : return power(x, y // 2) ** 2 % mod
else : return power(x, y // 2) ** 2 * x % mod
mod = 10 ** 9 + 7
factorial = [1]
for i in range(1, N):
factorial.append(factorial[i - 1] * i % mod)
inverseFactorial = [0] * N
inverseFactorial[N - 1] = power(factorial[N - 1], mod - 2)
for i in range(N - 2, -1, -1):
inverseFactorial[i] = inverseFactorial[i + 1] * (i + 1) % mod
def comb(x, y):
return factorial[x] * inverseFactorial[y] * inverseFactorial[x - y] % mod
ans = 0
for i in range(1, h - a + 1):
ans += comb(b + i - 2, b - 1) * comb(h - i + w - b - 1, w - b - 1)
# print(i, ans)
ans %= mod
print(ans)
|
[
7,
12,
13,
0,
13,
2,
39,
17,
2,
13,
17,
0,
13,
17,
28,
13,
4,
13,
17,
2,
13,
17,
0,
13,
2,
2,
13,
13,
13,
0,
18,
13,
13,
13,
29,
13,
23,
13,
12,
13,
0,
13,
2,
39,
17,
2,
13,
17,
0,
18,
13,
13,
4,
13,
18,
13,
13,
2,
13,
17,
13,
0,
13,
18,
13,
13,
28,
13,
4,
13,
2,
13,
17,
17,
17,
0,
13,
2,
2,
13,
2,
13,
17,
13,
0,
18,
13,
13,
13,
29,
13,
23,
13,
12,
13,
29,
2,
2,
18,
13,
13,
18,
13,
2,
13,
13,
18,
13,
13,
23,
13,
23,
13,
12,
13,
41,
0,
13,
4,
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,
0,
13,
4,
13,
2,
13,
13,
0,
13,
2,
2,
13,
13,
17,
13,
2,
2,
13,
13,
17,
13,
2,
13,
17,
0,
13,
2,
4,
13,
2,
4,
13,
2,
13,
13,
13,
4,
13,
2,
13,
13,
13,
13,
4,
13,
13,
14,
2,
13,
17,
4,
13,
10,
12,
13,
10,
12,
13,
10,
12,
13,
10,
12,
13
] | [
[
5,
4
],
[
37,
9
],
[
13,
12
],
[
16,
15
],
[
37,
20
],
[
24,
23
],
[
12,
26
],
[
23,
26
],
[
15,
27
],
[
33,
30
],
[
4,
31
],
[
15,
32
],
[
23,
33
],
[
12,
33
],
[
4,
35
],
[
37,
37
],
[
42,
41
],
[
92,
46
],
[
52,
49
],
[
41,
50
],
[
92,
51
],
[
92,
56
],
[
63,
62
],
[
49,
63
],
[
41,
64
],
[
92,
65
],
[
68,
67
],
[
92,
71
],
[
77,
76
],
[
62,
79
],
[
76,
79
],
[
67,
81
],
[
88,
85
],
[
41,
86
],
[
67,
87
],
[
76,
88
],
[
62,
88
],
[
41,
90
],
[
92,
92
],
[
110,
100
],
[
110,
104
],
[
112,
105
],
[
112,
108
],
[
110,
110
],
[
112,
112
],
[
118,
117
],
[
118,
128
],
[
118,
129
],
[
118,
130
],
[
133,
132
],
[
140,
139
],
[
205,
141
],
[
117,
143
],
[
128,
144
],
[
147,
146
],
[
202,
148
],
[
117,
150
],
[
128,
151
],
[
154,
153
],
[
117,
156
],
[
129,
157
],
[
160,
159
],
[
128,
162
],
[
129,
163
],
[
166,
165
],
[
129,
167
],
[
171,
170
],
[
208,
176
],
[
153,
178
],
[
208,
182
],
[
159,
184
],
[
165,
186
],
[
132,
187
],
[
170,
190
],
[
199,
196
]
] | [
"# ARC058D - いろはちゃんとマス目 / Iroha and a Grid (ABC042D)\ndef get_fact(lim):\n # compute a toble of factorials (1-idx)\n fact = [1] * (lim + 1)\n x = 1\n for i in range(1, lim + 1):\n x = (x * i) % MOD\n fact[i] = x\n return fact\n\n\ndef get_inv(lim):\n # compute a toble of inverse factorials (1-idx)\n inv = [1] * (lim + 1)\n inv[lim] = pow(fact[lim], MOD - 2, MOD)\n x = inv[lim]\n for i in range(lim - 1, 0, -1):\n x = (x * (i + 1)) % MOD\n inv[i] = x\n return inv\n\n\ndef comb(n: int, r: int) -> int:\n # compute nCr (n! / r!(n - r)!)\n return fact[n] * inv[n - r] * inv[r]\n\n\ndef main():\n global MOD, fact, inv\n H, W, A, B = tuple(map(int, input().split()))\n MOD = 10 ** 9 + 7\n fact = get_fact(H + W)\n inv = get_inv(H + W)\n x, y, a = H - A - 1, W + A - 2, A - 1 # fixed variables\n ans = sum(comb(x + i, i) * comb(y - i, a) for i in range(B, W)) % MOD\n print(ans)\n\n\nif __name__ == \"__main__\":\n main()",
"def get_fact(lim):\n # compute a toble of factorials (1-idx)\n fact = [1] * (lim + 1)\n x = 1\n for i in range(1, lim + 1):\n x = (x * i) % MOD\n fact[i] = x\n return fact",
"get_fact",
"fact = [1] * (lim + 1)",
"fact",
"[1] * (lim + 1)",
"[1]",
"1",
"lim + 1",
"lim",
"1",
"x = 1",
"x",
"1",
"for i in range(1, lim + 1):\n x = (x * i) % MOD\n fact[i] = x\n ",
"i",
"range(1, lim + 1)",
"range",
"1",
"lim + 1",
"lim",
"1",
"x = (x * i) % MOD",
"x",
"(x * i) % MOD",
"x * i",
"x",
"i",
"MOD",
"fact[i] = x",
"fact[i]",
"fact",
"i",
"x",
"return fact",
"fact",
"lim",
"lim",
"def get_inv(lim):\n # compute a toble of inverse factorials (1-idx)\n inv = [1] * (lim + 1)\n inv[lim] = pow(fact[lim], MOD - 2, MOD)\n x = inv[lim]\n for i in range(lim - 1, 0, -1):\n x = (x * (i + 1)) % MOD\n inv[i] = x\n return inv",
"get_inv",
"inv = [1] * (lim + 1)",
"inv",
"[1] * (lim + 1)",
"[1]",
"1",
"lim + 1",
"lim",
"1",
"inv[lim] = pow(fact[lim], MOD - 2, MOD)",
"inv[lim]",
"inv",
"lim",
"pow(fact[lim], MOD - 2, MOD)",
"pow",
"fact[lim]",
"fact",
"lim",
"MOD - 2",
"MOD",
"2",
"MOD",
"x = inv[lim]",
"x",
"inv[lim]",
"inv",
"lim",
"for i in range(lim - 1, 0, -1):\n x = (x * (i + 1)) % MOD\n inv[i] = x\n ",
"i",
"range(lim - 1, 0, -1)",
"range",
"lim - 1",
"lim",
"1",
"0",
"-1",
"x = (x * (i + 1)) % MOD",
"x",
"(x * (i + 1)) % MOD",
"x * (i + 1)",
"x",
"i + 1",
"i",
"1",
"MOD",
"inv[i] = x",
"inv[i]",
"inv",
"i",
"x",
"return inv",
"inv",
"lim",
"lim",
"def comb(n: int, r: int) -> int:\n # compute nCr (n! / r!(n - r)!)\n return fact[n] * inv[n - r] * inv[r]",
"comb",
"return fact[n] * inv[n - r] * inv[r]",
"fact[n] * inv[n - r] * inv[r]",
"fact[n] * inv[n - r]",
"fact[n]",
"fact",
"n",
"inv[n - r]",
"inv",
"n - r",
"n",
"r",
"inv[r]",
"inv",
"r",
"n: int",
"n",
"r: int",
"r",
"def main():\n global MOD, fact, inv\n H, W, A, B = tuple(map(int, input().split()))\n MOD = 10 ** 9 + 7\n fact = get_fact(H + W)\n inv = get_inv(H + W)\n x, y, a = H - A - 1, W + A - 2, A - 1 # fixed variables\n ans = sum(comb(x + i, i) * comb(y - i, a) for i in range(B, W)) % MOD\n print(ans)",
"main",
"global MOD, fact, inv",
"H, W, A, B = tuple(map(int, input().split()))",
"H",
"tuple(map(int, input().split()))",
"tuple",
"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 = get_fact(H + W)",
"fact",
"get_fact(H + W)",
"get_fact",
"H + W",
"H",
"W",
"inv = get_inv(H + W)",
"inv",
"get_inv(H + W)",
"get_inv",
"H + W",
"H",
"W",
"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",
"ans = sum(comb(x + i, i) * comb(y - i, a) for i in range(B, W)) % MOD",
"ans",
"sum(comb(x + i, i) * comb(y - i, a) for i in range(B, W)) % MOD",
"sum(comb(x + i, i) * comb(y - i, a) for i in range(B, W))",
"sum",
"comb(x + i, i) * comb(y - i, a)",
"comb(x + i, i)",
"comb",
"x + i",
"x",
"i",
"i",
"comb(y - i, a)",
"comb",
"y - i",
"y",
"i",
"a",
"MOD",
"print(ans)",
"print",
"ans",
"if __name__ == \"__main__\":\n main()",
"__name__ == \"__main__\"",
"__name__",
"\"__main__\"",
"main()",
"main",
"def main():\n global MOD, fact, inv\n H, W, A, B = tuple(map(int, input().split()))\n MOD = 10 ** 9 + 7\n fact = get_fact(H + W)\n inv = get_inv(H + W)\n x, y, a = H - A - 1, W + A - 2, A - 1 # fixed variables\n ans = sum(comb(x + i, i) * comb(y - i, a) for i in range(B, W)) % MOD\n print(ans)",
"def main():\n global MOD, fact, inv\n H, W, A, B = tuple(map(int, input().split()))\n MOD = 10 ** 9 + 7\n fact = get_fact(H + W)\n inv = get_inv(H + W)\n x, y, a = H - A - 1, W + A - 2, A - 1 # fixed variables\n ans = sum(comb(x + i, i) * comb(y - i, a) for i in range(B, W)) % MOD\n print(ans)",
"main",
"def get_inv(lim):\n # compute a toble of inverse factorials (1-idx)\n inv = [1] * (lim + 1)\n inv[lim] = pow(fact[lim], MOD - 2, MOD)\n x = inv[lim]\n for i in range(lim - 1, 0, -1):\n x = (x * (i + 1)) % MOD\n inv[i] = x\n return inv",
"def get_inv(lim):\n # compute a toble of inverse factorials (1-idx)\n inv = [1] * (lim + 1)\n inv[lim] = pow(fact[lim], MOD - 2, MOD)\n x = inv[lim]\n for i in range(lim - 1, 0, -1):\n x = (x * (i + 1)) % MOD\n inv[i] = x\n return inv",
"get_inv",
"def get_fact(lim):\n # compute a toble of factorials (1-idx)\n fact = [1] * (lim + 1)\n x = 1\n for i in range(1, lim + 1):\n x = (x * i) % MOD\n fact[i] = x\n return fact",
"def get_fact(lim):\n # compute a toble of factorials (1-idx)\n fact = [1] * (lim + 1)\n x = 1\n for i in range(1, lim + 1):\n x = (x * i) % MOD\n fact[i] = x\n return fact",
"get_fact",
"def comb(n: int, r: int) -> int:\n # compute nCr (n! / r!(n - r)!)\n return fact[n] * inv[n - r] * inv[r]",
"def comb(n: int, r: int) -> int:\n # compute nCr (n! / r!(n - r)!)\n return fact[n] * inv[n - r] * inv[r]",
"comb"
] | # ARC058D - いろはちゃんとマス目 / Iroha and a Grid (ABC042D)
def get_fact(lim):
# compute a toble of factorials (1-idx)
fact = [1] * (lim + 1)
x = 1
for i in range(1, lim + 1):
x = (x * i) % MOD
fact[i] = x
return fact
def get_inv(lim):
# compute a toble of inverse factorials (1-idx)
inv = [1] * (lim + 1)
inv[lim] = pow(fact[lim], MOD - 2, MOD)
x = inv[lim]
for i in range(lim - 1, 0, -1):
x = (x * (i + 1)) % MOD
inv[i] = x
return inv
def comb(n: int, r: int) -> int:
# compute nCr (n! / r!(n - r)!)
return fact[n] * inv[n - r] * inv[r]
def main():
global MOD, fact, inv
H, W, A, B = tuple(map(int, input().split()))
MOD = 10 ** 9 + 7
fact = get_fact(H + W)
inv = get_inv(H + W)
x, y, a = H - A - 1, W + A - 2, A - 1 # fixed variables
ans = sum(comb(x + i, i) * comb(y - i, a) for i in range(B, W)) % MOD
print(ans)
if __name__ == "__main__":
main() |
[
7,
0,
13,
2,
2,
17,
17,
17,
0,
13,
4,
13,
13,
4,
18,
4,
13,
13,
13,
13,
13,
0,
13,
2,
39,
17,
2,
2,
13,
13,
17,
0,
18,
13,
17,
17,
0,
18,
13,
17,
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,
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,
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,
14,
2,
2,
13,
13,
13,
29,
4,
13,
13,
2,
13,
13,
14,
2,
13,
17,
29,
17,
14,
2,
13,
17,
29,
17,
14,
2,
13,
17,
29,
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,
13,
13,
0,
13,
2,
2,
13,
2,
4,
13,
2,
2,
2,
13,
17,
13,
13,
13,
4,
13,
2,
2,
2,
13,
17,
13,
13,
2,
13,
17,
13,
4,
13,
13,
10,
4,
13,
10,
4,
13,
10,
12,
13,
10,
17,
13,
10,
4,
13,
10,
2,
13,
10,
2,
13,
10,
2,
13,
10,
4,
13,
10,
2,
13
] | [
[
230,
2
],
[
236,
9
],
[
236,
18
],
[
236,
19
],
[
236,
20
],
[
227,
22
],
[
225,
28
],
[
237,
29
],
[
35,
32
],
[
228,
33
],
[
40,
37
],
[
228,
38
],
[
43,
42
],
[
225,
48
],
[
237,
49
],
[
55,
52
],
[
228,
53
],
[
42,
54
],
[
42,
57
],
[
228,
59
],
[
42,
61
],
[
231,
63
],
[
233,
65
],
[
225,
71
],
[
237,
72
],
[
80,
75
],
[
234,
76
],
[
225,
78
],
[
237,
79
],
[
228,
83
],
[
225,
85
],
[
237,
86
],
[
231,
88
],
[
231,
90
],
[
93,
92
],
[
225,
97
],
[
237,
98
],
[
106,
103
],
[
234,
104
],
[
92,
105
],
[
234,
109
],
[
92,
111
],
[
92,
114
],
[
231,
116
],
[
167,
122
],
[
169,
123
],
[
169,
124
],
[
167,
128
],
[
167,
130
],
[
169,
131
],
[
169,
134
],
[
169,
140
],
[
169,
146
],
[
167,
149
],
[
228,
155
],
[
167,
156
],
[
234,
158
],
[
169,
159
],
[
234,
161
],
[
167,
163
],
[
169,
164
],
[
231,
165
],
[
167,
167
],
[
169,
169
],
[
221,
171
],
[
175,
174
],
[
216,
177
],
[
237,
178
],
[
239,
180
],
[
222,
183
],
[
240,
183
],
[
219,
186
],
[
225,
190
],
[
213,
192
],
[
174,
193
],
[
174,
194
],
[
219,
196
],
[
237,
200
],
[
213,
202
],
[
174,
203
],
[
213,
205
],
[
231,
207
],
[
240,
210
],
[
222,
210
],
[
236,
213
],
[
236,
216
],
[
221,
222
],
[
236,
225
],
[
227,
228
],
[
230,
231
],
[
233,
234
],
[
236,
237
],
[
239,
240
]
] | [
"mod = 10 ** 9 + 7\n\nH, W, A, B = map(int, input().split())\n\nfact = [-1] * (H + W + 1)\nfact[0] = 1\nfact[1] = 1\nfor x in range(2, H + W + 1):\n fact[x] = x * fact[x - 1] % mod\n\ninvs = [-1] * (H + W + 1)\ninvs[H + W] = pow(fact[H + W], mod - 2, mod)\nfor x in range(H + W - 1, 0, -1):\n invs[x] = invs[x + 1] * (x + 1) % mod\n\n\ndef combination(n, r):\n if n - r < r:\n return combination(n, n - r)\n if r < 0:\n return 0\n if r == 0:\n return 1\n if r == 1:\n return n\n return fact[n] * invs[r] * invs[n - r] % mod\n\n\nret = 0\nfor c in range(B, W):\n ret = (ret + combination(H - 1 - A + c, c) * combination(W - 2 + A - c, A - 1)) % mod\nprint(ret)\n\n# 左下にA*Bの入れない区画\n# S->{aa,bb,cc,dd,ee,ff,gg}->G\n# S->aはcombination(H - 1 - A + c, c):aの座標(H-1-A,c),通る列番号cを選ぶ\n# a->aは1通り\n# a->Gはcombination(W - 2 + A - c, A - 1):aの座標(H-A,c),Gの座標(H-1,W-1)この距離からA-1を選ぶ\n# S**********\n# * *\n# * *\n# * *\n# ****abcdefg\n# * abcdefg\n# * * *\n# * * *\n# **********G",
"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",
"fact = [-1] * (H + W + 1)",
"fact",
"[-1] * (H + W + 1)",
"[-1]",
"-1",
"H + W + 1",
"H + W",
"H",
"W",
"1",
"fact[0] = 1",
"fact[0]",
"fact",
"0",
"1",
"fact[1] = 1",
"fact[1]",
"fact",
"1",
"1",
"for x in range(2, H + W + 1):\n fact[x] = x * fact[x - 1] % mod",
"x",
"range(2, H + W + 1)",
"range",
"2",
"H + W + 1",
"H + W",
"H",
"W",
"1",
"fact[x] = x * fact[x - 1] % mod",
"fact[x]",
"fact",
"x",
"x * fact[x - 1] % mod",
"x * fact[x - 1]",
"x",
"fact[x - 1]",
"fact",
"x - 1",
"x",
"1",
"mod",
"invs = [-1] * (H + W + 1)",
"invs",
"[-1] * (H + W + 1)",
"[-1]",
"-1",
"H + W + 1",
"H + W",
"H",
"W",
"1",
"invs[H + W] = pow(fact[H + W], mod - 2, mod)",
"invs[H + W]",
"invs",
"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 x in range(H + W - 1, 0, -1):\n invs[x] = invs[x + 1] * (x + 1) % mod",
"x",
"range(H + W - 1, 0, -1)",
"range",
"H + W - 1",
"H + W",
"H",
"W",
"1",
"0",
"-1",
"invs[x] = invs[x + 1] * (x + 1) % mod",
"invs[x]",
"invs",
"x",
"invs[x + 1] * (x + 1) % mod",
"invs[x + 1] * (x + 1)",
"invs[x + 1]",
"invs",
"x + 1",
"x",
"1",
"x + 1",
"x",
"1",
"mod",
"def combination(n, r):\n if n - r < r:\n return combination(n, n - r)\n if r < 0:\n return 0\n if r == 0:\n return 1\n if r == 1:\n return n\n return fact[n] * invs[r] * invs[n - r] % mod",
"combination",
"if n - r < r:\n return combination(n, n - r)\n ",
"n - r < r",
"n - r",
"n",
"r",
"r",
"return combination(n, n - r)",
"combination(n, n - r)",
"combination",
"n",
"n - r",
"n",
"r",
"if r < 0:\n return 0\n ",
"r < 0",
"r",
"0",
"return 0",
"0",
"if r == 0:\n return 1\n ",
"r == 0",
"r",
"0",
"return 1",
"1",
"if r == 1:\n return n\n ",
"r == 1",
"r",
"1",
"return n",
"n",
"return fact[n] * invs[r] * invs[n - r] % mod",
"fact[n] * invs[r] * invs[n - r] % mod",
"fact[n] * invs[r] * invs[n - r]",
"fact[n] * invs[r]",
"fact[n]",
"fact",
"n",
"invs[r]",
"invs",
"r",
"invs[n - r]",
"invs",
"n - r",
"n",
"r",
"mod",
"n",
"n",
"r",
"r",
"ret = 0",
"ret",
"0",
"for c in range(B, W):\n ret = (ret + combination(H - 1 - A + c, c) * combination(W - 2 + A - c, A - 1)) % mod",
"c",
"range(B, W)",
"range",
"B",
"W",
"ret = (ret + combination(H - 1 - A + c, c) * combination(W - 2 + A - c, A - 1)) % mod",
"ret",
"(ret + combination(H - 1 - A + c, c) * combination(W - 2 + A - c, A - 1)) % mod",
"ret + combination(H - 1 - A + c, c) * combination(W - 2 + A - c, A - 1)",
"ret",
"combination(H - 1 - A + c, c) * combination(W - 2 + A - c, A - 1)",
"combination(H - 1 - A + c, c)",
"combination",
"H - 1 - A + c",
"H - 1 - A",
"H - 1",
"H",
"1",
"A",
"c",
"c",
"combination(W - 2 + A - c, A - 1)",
"combination",
"W - 2 + A - c",
"W - 2 + A",
"W - 2",
"W",
"2",
"A",
"c",
"A - 1",
"A",
"1",
"mod",
"print(ret)",
"print",
"ret",
"A, B = map(int, input().split())",
"map(int, input().split())",
"A",
"B = map(int, input().split())",
"map(int, input().split())",
"B",
"def combination(n, r):\n if n - r < r:\n return combination(n, n - r)\n if r < 0:\n return 0\n if r == 0:\n return 1\n if r == 1:\n return n\n return fact[n] * invs[r] * invs[n - r] % mod",
"def combination(n, r):\n if n - r < r:\n return combination(n, n - r)\n if r < 0:\n return 0\n if r == 0:\n return 1\n if r == 1:\n return n\n return fact[n] * invs[r] * invs[n - r] % mod",
"combination",
"ret = 0",
"0",
"ret",
"H, W, A, B = map(int, input().split())",
"map(int, input().split())",
"H",
"fact = [-1] * (H + W + 1)",
"[-1] * (H + W + 1)",
"fact",
"mod = 10 ** 9 + 7",
"10 ** 9 + 7",
"mod",
"invs = [-1] * (H + W + 1)",
"[-1] * (H + W + 1)",
"invs",
"W, A, B = map(int, input().split())",
"map(int, input().split())",
"W",
"ret = (ret + combination(H - 1 - A + c, c) * combination(W - 2 + A - c, A - 1)) % mod",
"(ret + combination(H - 1 - A + c, c) * combination(W - 2 + A - c, A - 1)) % mod",
"ret"
] | mod = 10 ** 9 + 7
H, W, A, B = map(int, input().split())
fact = [-1] * (H + W + 1)
fact[0] = 1
fact[1] = 1
for x in range(2, H + W + 1):
fact[x] = x * fact[x - 1] % mod
invs = [-1] * (H + W + 1)
invs[H + W] = pow(fact[H + W], mod - 2, mod)
for x in range(H + W - 1, 0, -1):
invs[x] = invs[x + 1] * (x + 1) % mod
def combination(n, r):
if n - r < r:
return combination(n, n - r)
if r < 0:
return 0
if r == 0:
return 1
if r == 1:
return n
return fact[n] * invs[r] * invs[n - r] % mod
ret = 0
for c in range(B, W):
ret = (ret + combination(H - 1 - A + c, c) * combination(W - 2 + A - c, A - 1)) % mod
print(ret)
# 左下にA*Bの入れない区画
# S->{aa,bb,cc,dd,ee,ff,gg}->G
# S->aはcombination(H - 1 - A + c, c):aの座標(H-1-A,c),通る列番号cを選ぶ
# a->aは1通り
# a->Gはcombination(W - 2 + A - c, A - 1):aの座標(H-A,c),Gの座標(H-1,W-1)この距離からA-1を選ぶ
# S**********
# * *
# * *
# * *
# ****abcdefg
# * abcdefg
# * * *
# * * *
# **********G |
[
7,
15,
13,
12,
13,
0,
13,
17,
0,
13,
4,
13,
17,
4,
18,
13,
13,
2,
17,
17,
12,
13,
12,
13,
12,
13,
12,
13,
12,
13,
12,
13,
12,
13,
12,
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,
29,
13,
23,
13,
23,
13,
12,
13,
17,
0,
13,
18,
13,
13,
0,
13,
2,
2,
18,
13,
2,
13,
13,
18,
13,
13,
13,
29,
2,
2,
13,
4,
13,
13,
2,
13,
17,
13,
13,
23,
13,
23,
13,
23,
13,
23,
13,
0,
13,
4,
13,
13,
13,
13,
0,
13,
4,
13,
2,
2,
17,
13,
2,
17,
13,
13,
0,
13,
17,
28,
13,
4,
13,
13,
13,
0,
13,
2,
2,
13,
2,
4,
13,
2,
2,
2,
13,
17,
13,
13,
2,
2,
13,
17,
13,
13,
13,
4,
13,
2,
2,
2,
2,
13,
17,
13,
17,
13,
2,
13,
17,
13,
13,
13,
4,
13,
13,
14,
2,
13,
17,
4,
13,
10,
12,
13
] | [
[
7,
6
],
[
10,
9
],
[
39,
38
],
[
69,
43
],
[
47,
46
],
[
69,
51
],
[
57,
54
],
[
38,
55
],
[
46,
56
],
[
38,
60
],
[
46,
62
],
[
46,
64
],
[
71,
65
],
[
38,
67
],
[
69,
69
],
[
71,
71
],
[
77,
76
],
[
112,
78
],
[
106,
79
],
[
82,
81
],
[
112,
85
],
[
106,
87
],
[
108,
88
],
[
112,
90
],
[
108,
91
],
[
110,
92
],
[
76,
96
],
[
81,
99
],
[
110,
101
],
[
110,
103
],
[
110,
104
],
[
106,
106
],
[
108,
108
],
[
110,
110
],
[
112,
112
],
[
115,
114
],
[
25,
116
],
[
115,
117
],
[
115,
118
],
[
115,
119
],
[
122,
121
],
[
35,
123
],
[
114,
127
],
[
117,
130
],
[
6,
131
],
[
134,
133
],
[
137,
136
],
[
119,
139
],
[
117,
140
],
[
143,
142
],
[
133,
145
],
[
142,
145
],
[
73,
148
],
[
114,
152
],
[
118,
154
],
[
136,
155
],
[
114,
158
],
[
118,
160
],
[
6,
161
],
[
121,
162
],
[
73,
164
],
[
118,
169
],
[
117,
171
],
[
136,
173
],
[
118,
175
],
[
6,
177
],
[
121,
178
],
[
6,
179
],
[
142,
182
],
[
133,
182
],
[
191,
188
]
] | [
"#!/usr/bin/env python3\n\nimport sys\n# import math\n# from string import ascii_lowercase, ascii_upper_case, ascii_letters, digits, hexdigits\n# import re # re.compile(pattern) => ptn obj; p.search(s), p.match(s), p.finditer(s) => match obj; p.sub(after, s)\n# from operator import itemgetter # itemgetter(1), itemgetter('key')\n# from collections import deque # deque class. deque(L): dq.append(x), dq.appendleft(x), dq.pop(), dq.popleft(), dq.rotate()\n# from collections import defaultdict # subclass of dict. defaultdict(facroty)\n# from collections import Counter # subclass of dict. Counter(iter): c.elements(), c.most_common(n), c.subtract(iter)\n# from heapq import heapify, heappush, heappop # built-in list. heapify(L) changes list in-place to min-heap in O(n), heappush(heapL, x) and heappop(heapL) in O(lgn).\n# from heapq import nlargest, nsmallest # nlargest(n, iter[, key]) returns k-largest-list in O(n+klgn).\n# from itertools import count, cycle, repeat # count(start[,step]), cycle(iter), repeat(elm[,n])\n# from itertools import groupby # [(k, list(g)) for k, g in groupby('000112')] returns [('0',['0','0','0']), ('1',['1','1']), ('2',['2'])]\n# from itertools import starmap # starmap(pow, [[2,5], [3,2]]) returns [32, 9]\n# from itertools import product, permutations # product(iter, repeat=n), permutations(iter[,r])\n# from itertools import combinations, combinations_with_replacement\n# from itertools import accumulate # accumulate(iter[, f])\n# from functools import reduce # reduce(f, iter[, init])\n# from functools import lru_cache # @lrucache ...arguments of functions should be able to be keys of dict (e.g. list is not allowed)\n# from bisect import bisect_left, bisect_right # bisect_left(a, x, lo=0, hi=len(a)) returns i such that all(val<x for val in a[lo:i]) and all(val>-=x for val in a[i:hi]).\n# from copy import deepcopy # to copy multi-dimentional matrix without reference\n# from fractions import gcd # for Python 3.4 (previous contest @AtCoder)\n\n\ndef main():\n mod = 1000000007 # 10^9+7\n inf = float('inf') # sys.float_info.max = 1.79...e+308\n # inf = 2 ** 64 - 1 # (for fast JIT compile in PyPy) 1.84...e+19\n sys.setrecursionlimit(10**6) # 1000 -> 1000000\n def input(): return sys.stdin.readline().rstrip()\n def ii(): return int(input())\n def mi(): return map(int, input().split())\n def mi_0(): return map(lambda x: int(x)-1, input().split())\n def lmi(): return list(map(int, input().split()))\n def lmi_0(): return list(map(lambda x: int(x)-1, input().split()))\n def li(): return list(input())\n \n \n def make_factorial_table(size, mod):\n '''\n fact_mod[i] は i! % mod を表す。fact_mod[0] ~ facto_mod[size] まで計算可能なテーブルを返す\n >>> make_factorial_table(20, 10**9+7)\n [1, 1, 2, 6, 24, 120, 720, 5040, 40320, 362880, 3628800, 39916800, 479001600, 227020758, 178290591, 674358851, 789741546, 425606191, 660911389, 557316307, 146326063]\n '''\n fact_mod = [1] * (size + 1)\n for i in range(1, size + 1):\n fact_mod[i] = (fact_mod[i - 1] * i) % mod\n return fact_mod\n\n def combination(n, r, mod, fact_table):\n '''\n フェルマーの小定理 \n a ^ p-1 ≡ 1 (mod p)\n a ^ p-2 ≡ 1/a (mod p) (逆元)\n nCr = (n!) / ((n-r)! * r!) だが、mod p の世界ではこの分母を逆元を用いて計算しておくことが可能\n \n >>> m = 1000000007\n >>> fact_table = make_factorial_table(100, m)\n >>> combination(10, 5, m, fact_table)\n 252\n >>> combination(100, 50, m, fact_table)\n 538992043\n '''\n numerator = fact_table[n]\n denominator = (fact_table[n-r] * fact_table[r]) % mod\n # pow はすでに繰り返し二乗法で効率的に実装されている\n return (numerator * pow(denominator, mod-2, mod)) % mod\n\n h, w, a, b = mi()\n # sigma {k = b to w-1} h-1-a+kCh-1-a * a-1+w-1-kCa-1\n # sample 2 だと {k=4to6} 6+kC6 * 2+6-kC2 = (10C6 * 4C2 + 11C6 * 3C2 + 12C6 * 2C2)\n fact_table = make_factorial_table(2 * h + 2 * w, mod)\n ans = 0\n for k in range(b, w):\n # print(f\"{h-1-a+k} {h-1-a} / {a-1+w-1-k} {a-1}\")\n ans = (ans + combination(h-1-a+k, h-1-a, mod, fact_table) * combination(a-1+w-1-k, a-1, mod, fact_table)) % mod\n print(ans)\n\n\nif __name__ == \"__main__\":\n main()",
"import sys",
"sys",
"def main():\n mod = 1000000007 # 10^9+7\n inf = float('inf') # sys.float_info.max = 1.79...e+308\n # inf = 2 ** 64 - 1 # (for fast JIT compile in PyPy) 1.84...e+19\n sys.setrecursionlimit(10**6) # 1000 -> 1000000\n def input(): return sys.stdin.readline().rstrip()\n def ii(): return int(input())\n def mi(): return map(int, input().split())\n def mi_0(): return map(lambda x: int(x)-1, input().split())\n def lmi(): return list(map(int, input().split()))\n def lmi_0(): return list(map(lambda x: int(x)-1, input().split()))\n def li(): return list(input())\n \n \n def make_factorial_table(size, mod):\n '''\n fact_mod[i] は i! % mod を表す。fact_mod[0] ~ facto_mod[size] まで計算可能なテーブルを返す\n >>> make_factorial_table(20, 10**9+7)\n [1, 1, 2, 6, 24, 120, 720, 5040, 40320, 362880, 3628800, 39916800, 479001600, 227020758, 178290591, 674358851, 789741546, 425606191, 660911389, 557316307, 146326063]\n '''\n fact_mod = [1] * (size + 1)\n for i in range(1, size + 1):\n fact_mod[i] = (fact_mod[i - 1] * i) % mod\n return fact_mod\n\n def combination(n, r, mod, fact_table):\n '''\n フェルマーの小定理 \n a ^ p-1 ≡ 1 (mod p)\n a ^ p-2 ≡ 1/a (mod p) (逆元)\n nCr = (n!) / ((n-r)! * r!) だが、mod p の世界ではこの分母を逆元を用いて計算しておくことが可能\n \n >>> m = 1000000007\n >>> fact_table = make_factorial_table(100, m)\n >>> combination(10, 5, m, fact_table)\n 252\n >>> combination(100, 50, m, fact_table)\n 538992043\n '''\n numerator = fact_table[n]\n denominator = (fact_table[n-r] * fact_table[r]) % mod\n # pow はすでに繰り返し二乗法で効率的に実装されている\n return (numerator * pow(denominator, mod-2, mod)) % mod\n\n h, w, a, b = mi()\n # sigma {k = b to w-1} h-1-a+kCh-1-a * a-1+w-1-kCa-1\n # sample 2 だと {k=4to6} 6+kC6 * 2+6-kC2 = (10C6 * 4C2 + 11C6 * 3C2 + 12C6 * 2C2)\n fact_table = make_factorial_table(2 * h + 2 * w, mod)\n ans = 0\n for k in range(b, w):\n # print(f\"{h-1-a+k} {h-1-a} / {a-1+w-1-k} {a-1}\")\n ans = (ans + combination(h-1-a+k, h-1-a, mod, fact_table) * combination(a-1+w-1-k, a-1, mod, fact_table)) % mod\n print(ans)",
"main",
"mod = 1000000007",
"mod",
"1000000007",
"inf = float('inf')",
"inf",
"float('inf')",
"float",
"'inf'",
"sys.setrecursionlimit(10**6)",
"sys.setrecursionlimit",
"sys",
"setrecursionlimit",
"10**6",
"10",
"6",
"def input(): return sys.stdin.readline().rstrip()\n ",
"input",
"def ii(): return int(input())\n ",
"ii",
"def mi(): return map(int, input().split())\n ",
"mi",
"def mi_0(): return map(lambda x: int(x)-1, input().split())\n ",
"mi_0",
"def lmi(): return list(map(int, input().split()))\n ",
"lmi",
"def lmi_0(): return list(map(lambda x: int(x)-1, input().split()))\n ",
"lmi_0",
"def li(): return list(input())\n \n \n ",
"li",
"def make_factorial_table(size, mod):\n '''\n fact_mod[i] は i! % mod を表す。fact_mod[0] ~ facto_mod[size] まで計算可能なテーブルを返す\n >>> make_factorial_table(20, 10**9+7)\n [1, 1, 2, 6, 24, 120, 720, 5040, 40320, 362880, 3628800, 39916800, 479001600, 227020758, 178290591, 674358851, 789741546, 425606191, 660911389, 557316307, 146326063]\n '''\n fact_mod = [1] * (size + 1)\n for i in range(1, size + 1):\n fact_mod[i] = (fact_mod[i - 1] * i) % mod\n return fact_mod\n\n ",
"make_factorial_table",
"'''\n fact_mod[i] は i! % mod を表す。fact_mod[0] ~ facto_mod[size] まで計算可能なテーブルを返す\n >>> make_factorial_table(20, 10**9+7)\n [1, 1, 2, 6, 24, 120, 720, 5040, 40320, 362880, 3628800, 39916800, 479001600, 227020758, 178290591, 674358851, 789741546, 425606191, 660911389, 557316307, 146326063]\n '''",
"fact_mod = [1] * (size + 1)",
"fact_mod",
"[1] * (size + 1)",
"[1]",
"1",
"size + 1",
"size",
"1",
"for i in range(1, size + 1):\n fact_mod[i] = (fact_mod[i - 1] * i) % mod\n ",
"i",
"range(1, size + 1)",
"range",
"1",
"size + 1",
"size",
"1",
"fact_mod[i] = (fact_mod[i - 1] * i) % mod",
"fact_mod[i]",
"fact_mod",
"i",
"(fact_mod[i - 1] * i) % mod",
"fact_mod[i - 1] * i",
"fact_mod[i - 1]",
"fact_mod",
"i - 1",
"i",
"1",
"i",
"mod",
"return fact_mod",
"fact_mod",
"size",
"size",
"mod",
"mod",
"def combination(n, r, mod, fact_table):\n '''\n フェルマーの小定理 \n a ^ p-1 ≡ 1 (mod p)\n a ^ p-2 ≡ 1/a (mod p) (逆元)\n nCr = (n!) / ((n-r)! * r!) だが、mod p の世界ではこの分母を逆元を用いて計算しておくことが可能\n \n >>> m = 1000000007\n >>> fact_table = make_factorial_table(100, m)\n >>> combination(10, 5, m, fact_table)\n 252\n >>> combination(100, 50, m, fact_table)\n 538992043\n '''\n numerator = fact_table[n]\n denominator = (fact_table[n-r] * fact_table[r]) % mod\n # pow はすでに繰り返し二乗法で効率的に実装されている\n return (numerator * pow(denominator, mod-2, mod)) % mod\n\n ",
"combination",
"'''\n フェルマーの小定理 \n a ^ p-1 ≡ 1 (mod p)\n a ^ p-2 ≡ 1/a (mod p) (逆元)\n nCr = (n!) / ((n-r)! * r!) だが、mod p の世界ではこの分母を逆元を用いて計算しておくことが可能\n \n >>> m = 1000000007\n >>> fact_table = make_factorial_table(100, m)\n >>> combination(10, 5, m, fact_table)\n 252\n >>> combination(100, 50, m, fact_table)\n 538992043\n '''",
"numerator = fact_table[n]",
"numerator",
"fact_table[n]",
"fact_table",
"n",
"denominator = (fact_table[n-r] * fact_table[r]) % mod",
"denominator",
"(fact_table[n-r] * fact_table[r]) % mod",
"fact_table[n-r] * fact_table[r]",
"fact_table[n-r]",
"fact_table",
"n-r",
"n",
"r",
"fact_table[r]",
"fact_table",
"r",
"mod",
"return (numerator * pow(denominator, mod-2, mod)) % mod",
"(numerator * pow(denominator, mod-2, mod)) % mod",
"numerator * pow(denominator, mod-2, mod)",
"numerator",
"pow(denominator, mod-2, mod)",
"pow",
"denominator",
"mod-2",
"mod",
"2",
"mod",
"mod",
"n",
"n",
"r",
"r",
"mod",
"mod",
"fact_table",
"fact_table",
"h, w, a, b = mi()",
"h",
"mi()",
"mi",
"w",
"a",
"b",
"fact_table = make_factorial_table(2 * h + 2 * w, mod)",
"fact_table",
"make_factorial_table(2 * h + 2 * w, mod)",
"make_factorial_table",
"2 * h + 2 * w",
"2 * h",
"2",
"h",
"2 * w",
"2",
"w",
"mod",
"ans = 0",
"ans",
"0",
"for k in range(b, w):\n # print(f\"{h-1-a+k} {h-1-a} / {a-1+w-1-k} {a-1}\")\n ans = (ans + combination(h-1-a+k, h-1-a, mod, fact_table) * combination(a-1+w-1-k, a-1, mod, fact_table)) % mod\n ",
"k",
"range(b, w)",
"range",
"b",
"w",
"ans = (ans + combination(h-1-a+k, h-1-a, mod, fact_table) * combination(a-1+w-1-k, a-1, mod, fact_table)) % mod",
"ans",
"(ans + combination(h-1-a+k, h-1-a, mod, fact_table) * combination(a-1+w-1-k, a-1, mod, fact_table)) % mod",
"ans + combination(h-1-a+k, h-1-a, mod, fact_table) * combination(a-1+w-1-k, a-1, mod, fact_table)",
"ans",
"combination(h-1-a+k, h-1-a, mod, fact_table) * combination(a-1+w-1-k, a-1, mod, fact_table)",
"combination(h-1-a+k, h-1-a, mod, fact_table)",
"combination",
"h-1-a+k",
"h-1-a",
"h-1",
"h",
"1",
"a",
"k",
"h-1-a",
"h-1",
"h",
"1",
"a",
"mod",
"fact_table",
"combination(a-1+w-1-k, a-1, mod, fact_table)",
"combination",
"a-1+w-1-k",
"a-1+w-1",
"a-1+w",
"a-1",
"a",
"1",
"w",
"1",
"k",
"a-1",
"a",
"1",
"mod",
"fact_table",
"mod",
"print(ans)",
"print",
"ans",
"if __name__ == \"__main__\":\n main()",
"__name__ == \"__main__\"",
"__name__",
"\"__main__\"",
"main()",
"main",
"def main():\n mod = 1000000007 # 10^9+7\n inf = float('inf') # sys.float_info.max = 1.79...e+308\n # inf = 2 ** 64 - 1 # (for fast JIT compile in PyPy) 1.84...e+19\n sys.setrecursionlimit(10**6) # 1000 -> 1000000\n def input(): return sys.stdin.readline().rstrip()\n def ii(): return int(input())\n def mi(): return map(int, input().split())\n def mi_0(): return map(lambda x: int(x)-1, input().split())\n def lmi(): return list(map(int, input().split()))\n def lmi_0(): return list(map(lambda x: int(x)-1, input().split()))\n def li(): return list(input())\n \n \n def make_factorial_table(size, mod):\n '''\n fact_mod[i] は i! % mod を表す。fact_mod[0] ~ facto_mod[size] まで計算可能なテーブルを返す\n >>> make_factorial_table(20, 10**9+7)\n [1, 1, 2, 6, 24, 120, 720, 5040, 40320, 362880, 3628800, 39916800, 479001600, 227020758, 178290591, 674358851, 789741546, 425606191, 660911389, 557316307, 146326063]\n '''\n fact_mod = [1] * (size + 1)\n for i in range(1, size + 1):\n fact_mod[i] = (fact_mod[i - 1] * i) % mod\n return fact_mod\n\n def combination(n, r, mod, fact_table):\n '''\n フェルマーの小定理 \n a ^ p-1 ≡ 1 (mod p)\n a ^ p-2 ≡ 1/a (mod p) (逆元)\n nCr = (n!) / ((n-r)! * r!) だが、mod p の世界ではこの分母を逆元を用いて計算しておくことが可能\n \n >>> m = 1000000007\n >>> fact_table = make_factorial_table(100, m)\n >>> combination(10, 5, m, fact_table)\n 252\n >>> combination(100, 50, m, fact_table)\n 538992043\n '''\n numerator = fact_table[n]\n denominator = (fact_table[n-r] * fact_table[r]) % mod\n # pow はすでに繰り返し二乗法で効率的に実装されている\n return (numerator * pow(denominator, mod-2, mod)) % mod\n\n h, w, a, b = mi()\n # sigma {k = b to w-1} h-1-a+kCh-1-a * a-1+w-1-kCa-1\n # sample 2 だと {k=4to6} 6+kC6 * 2+6-kC2 = (10C6 * 4C2 + 11C6 * 3C2 + 12C6 * 2C2)\n fact_table = make_factorial_table(2 * h + 2 * w, mod)\n ans = 0\n for k in range(b, w):\n # print(f\"{h-1-a+k} {h-1-a} / {a-1+w-1-k} {a-1}\")\n ans = (ans + combination(h-1-a+k, h-1-a, mod, fact_table) * combination(a-1+w-1-k, a-1, mod, fact_table)) % mod\n print(ans)",
"def main():\n mod = 1000000007 # 10^9+7\n inf = float('inf') # sys.float_info.max = 1.79...e+308\n # inf = 2 ** 64 - 1 # (for fast JIT compile in PyPy) 1.84...e+19\n sys.setrecursionlimit(10**6) # 1000 -> 1000000\n def input(): return sys.stdin.readline().rstrip()\n def ii(): return int(input())\n def mi(): return map(int, input().split())\n def mi_0(): return map(lambda x: int(x)-1, input().split())\n def lmi(): return list(map(int, input().split()))\n def lmi_0(): return list(map(lambda x: int(x)-1, input().split()))\n def li(): return list(input())\n \n \n def make_factorial_table(size, mod):\n '''\n fact_mod[i] は i! % mod を表す。fact_mod[0] ~ facto_mod[size] まで計算可能なテーブルを返す\n >>> make_factorial_table(20, 10**9+7)\n [1, 1, 2, 6, 24, 120, 720, 5040, 40320, 362880, 3628800, 39916800, 479001600, 227020758, 178290591, 674358851, 789741546, 425606191, 660911389, 557316307, 146326063]\n '''\n fact_mod = [1] * (size + 1)\n for i in range(1, size + 1):\n fact_mod[i] = (fact_mod[i - 1] * i) % mod\n return fact_mod\n\n def combination(n, r, mod, fact_table):\n '''\n フェルマーの小定理 \n a ^ p-1 ≡ 1 (mod p)\n a ^ p-2 ≡ 1/a (mod p) (逆元)\n nCr = (n!) / ((n-r)! * r!) だが、mod p の世界ではこの分母を逆元を用いて計算しておくことが可能\n \n >>> m = 1000000007\n >>> fact_table = make_factorial_table(100, m)\n >>> combination(10, 5, m, fact_table)\n 252\n >>> combination(100, 50, m, fact_table)\n 538992043\n '''\n numerator = fact_table[n]\n denominator = (fact_table[n-r] * fact_table[r]) % mod\n # pow はすでに繰り返し二乗法で効率的に実装されている\n return (numerator * pow(denominator, mod-2, mod)) % mod\n\n h, w, a, b = mi()\n # sigma {k = b to w-1} h-1-a+kCh-1-a * a-1+w-1-kCa-1\n # sample 2 だと {k=4to6} 6+kC6 * 2+6-kC2 = (10C6 * 4C2 + 11C6 * 3C2 + 12C6 * 2C2)\n fact_table = make_factorial_table(2 * h + 2 * w, mod)\n ans = 0\n for k in range(b, w):\n # print(f\"{h-1-a+k} {h-1-a} / {a-1+w-1-k} {a-1}\")\n ans = (ans + combination(h-1-a+k, h-1-a, mod, fact_table) * combination(a-1+w-1-k, a-1, mod, fact_table)) % mod\n print(ans)",
"main"
] | #!/usr/bin/env python3
import sys
# import math
# from string import ascii_lowercase, ascii_upper_case, ascii_letters, digits, hexdigits
# import re # re.compile(pattern) => ptn obj; p.search(s), p.match(s), p.finditer(s) => match obj; p.sub(after, s)
# from operator import itemgetter # itemgetter(1), itemgetter('key')
# from collections import deque # deque class. deque(L): dq.append(x), dq.appendleft(x), dq.pop(), dq.popleft(), dq.rotate()
# from collections import defaultdict # subclass of dict. defaultdict(facroty)
# from collections import Counter # subclass of dict. Counter(iter): c.elements(), c.most_common(n), c.subtract(iter)
# from heapq import heapify, heappush, heappop # built-in list. heapify(L) changes list in-place to min-heap in O(n), heappush(heapL, x) and heappop(heapL) in O(lgn).
# from heapq import nlargest, nsmallest # nlargest(n, iter[, key]) returns k-largest-list in O(n+klgn).
# from itertools import count, cycle, repeat # count(start[,step]), cycle(iter), repeat(elm[,n])
# from itertools import groupby # [(k, list(g)) for k, g in groupby('000112')] returns [('0',['0','0','0']), ('1',['1','1']), ('2',['2'])]
# from itertools import starmap # starmap(pow, [[2,5], [3,2]]) returns [32, 9]
# from itertools import product, permutations # product(iter, repeat=n), permutations(iter[,r])
# from itertools import combinations, combinations_with_replacement
# from itertools import accumulate # accumulate(iter[, f])
# from functools import reduce # reduce(f, iter[, init])
# from functools import lru_cache # @lrucache ...arguments of functions should be able to be keys of dict (e.g. list is not allowed)
# from bisect import bisect_left, bisect_right # bisect_left(a, x, lo=0, hi=len(a)) returns i such that all(val<x for val in a[lo:i]) and all(val>-=x for val in a[i:hi]).
# from copy import deepcopy # to copy multi-dimentional matrix without reference
# from fractions import gcd # for Python 3.4 (previous contest @AtCoder)
def main():
mod = 1000000007 # 10^9+7
inf = float('inf') # sys.float_info.max = 1.79...e+308
# inf = 2 ** 64 - 1 # (for fast JIT compile in PyPy) 1.84...e+19
sys.setrecursionlimit(10**6) # 1000 -> 1000000
def input(): return sys.stdin.readline().rstrip()
def ii(): return int(input())
def mi(): return map(int, input().split())
def mi_0(): return map(lambda x: int(x)-1, input().split())
def lmi(): return list(map(int, input().split()))
def lmi_0(): return list(map(lambda x: int(x)-1, input().split()))
def li(): return list(input())
def make_factorial_table(size, mod):
'''
fact_mod[i] は i! % mod を表す。fact_mod[0] ~ facto_mod[size] まで計算可能なテーブルを返す
>>> make_factorial_table(20, 10**9+7)
[1, 1, 2, 6, 24, 120, 720, 5040, 40320, 362880, 3628800, 39916800, 479001600, 227020758, 178290591, 674358851, 789741546, 425606191, 660911389, 557316307, 146326063]
'''
fact_mod = [1] * (size + 1)
for i in range(1, size + 1):
fact_mod[i] = (fact_mod[i - 1] * i) % mod
return fact_mod
def combination(n, r, mod, fact_table):
'''
フェルマーの小定理
a ^ p-1 ≡ 1 (mod p)
a ^ p-2 ≡ 1/a (mod p) (逆元)
nCr = (n!) / ((n-r)! * r!) だが、mod p の世界ではこの分母を逆元を用いて計算しておくことが可能
>>> m = 1000000007
>>> fact_table = make_factorial_table(100, m)
>>> combination(10, 5, m, fact_table)
252
>>> combination(100, 50, m, fact_table)
538992043
'''
numerator = fact_table[n]
denominator = (fact_table[n-r] * fact_table[r]) % mod
# pow はすでに繰り返し二乗法で効率的に実装されている
return (numerator * pow(denominator, mod-2, mod)) % mod
h, w, a, b = mi()
# sigma {k = b to w-1} h-1-a+kCh-1-a * a-1+w-1-kCa-1
# sample 2 だと {k=4to6} 6+kC6 * 2+6-kC2 = (10C6 * 4C2 + 11C6 * 3C2 + 12C6 * 2C2)
fact_table = make_factorial_table(2 * h + 2 * w, mod)
ans = 0
for k in range(b, w):
# print(f"{h-1-a+k} {h-1-a} / {a-1+w-1-k} {a-1}")
ans = (ans + combination(h-1-a+k, h-1-a, mod, fact_table) * combination(a-1+w-1-k, a-1, mod, fact_table)) % mod
print(ans)
if __name__ == "__main__":
main()
|
[
7,
0,
13,
2,
2,
17,
17,
17,
0,
13,
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,
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,
4,
13,
13,
4,
18,
4,
13,
13,
13,
13,
13,
14,
2,
13,
2,
13,
17,
0,
13,
17,
0,
13,
4,
13,
2,
2,
13,
17,
2,
13,
17,
2,
13,
17,
13,
28,
13,
4,
13,
13,
0,
13,
2,
13,
13,
0,
13,
2,
13,
17,
0,
13,
13,
0,
13,
2,
13,
13,
0,
13,
2,
2,
4,
13,
2,
2,
13,
17,
2,
13,
17,
2,
13,
17,
13,
4,
13,
2,
2,
13,
17,
2,
13,
17,
2,
13,
17,
13,
13,
0,
13,
2,
2,
13,
13,
13,
0,
13,
2,
2,
13,
13,
13,
4,
13,
13,
0,
13,
17,
28,
13,
4,
13,
13,
13,
0,
13,
2,
13,
13,
0,
13,
2,
13,
17,
0,
13,
13,
0,
13,
2,
13,
13,
0,
13,
2,
4,
13,
2,
2,
13,
17,
2,
13,
17,
2,
13,
17,
13,
4,
13,
2,
2,
13,
17,
2,
13,
17,
2,
13,
17,
13,
0,
13,
2,
2,
13,
13,
13,
0,
13,
13,
4,
13,
13,
10,
12,
13,
10,
4,
13,
10,
2,
13,
10,
39,
13,
10,
2,
13,
10,
13,
13,
10,
39,
13,
10,
4,
13,
10,
2,
13,
10,
17,
13,
10,
2,
13,
10,
2,
13,
10,
2,
13,
10,
4,
13,
10,
2,
13,
10,
17,
13,
10,
2,
13,
10,
2,
13,
10,
2,
13,
10,
39,
13,
10,
4,
13,
10,
4,
13,
10,
13,
13,
10,
2,
13,
10,
13,
13,
10,
2,
13,
10,
2,
13
] | [
[
365,
2
],
[
344,
9
],
[
353,
14
],
[
305,
19
],
[
314,
24
],
[
30,
29
],
[
345,
34
],
[
354,
38
],
[
354,
43
],
[
29,
45
],
[
366,
46
],
[
315,
49
],
[
315,
55
],
[
366,
57
],
[
29,
58
],
[
366,
60
],
[
29,
61
],
[
366,
62
],
[
306,
65
],
[
306,
70
],
[
315,
73
],
[
366,
75
],
[
115,
81
],
[
113,
84
],
[
115,
85
],
[
90,
89
],
[
115,
92
],
[
113,
94
],
[
115,
95
],
[
354,
101
],
[
113,
102
],
[
306,
104
],
[
89,
105
],
[
115,
105
],
[
306,
107
],
[
113,
109
],
[
89,
110
],
[
115,
110
],
[
117,
111
],
[
113,
113
],
[
115,
115
],
[
117,
117
],
[
356,
119
],
[
356,
128
],
[
356,
129
],
[
356,
130
],
[
318,
133
],
[
336,
135
],
[
323,
138
],
[
359,
141
],
[
297,
143
],
[
300,
146
],
[
336,
149
],
[
300,
152
],
[
366,
154
],
[
157,
156
],
[
318,
159
],
[
308,
161
],
[
300,
163
],
[
357,
164
],
[
347,
166
],
[
156,
168
],
[
311,
171
],
[
357,
172
],
[
329,
174
],
[
336,
176
],
[
156,
177
],
[
302,
179
],
[
297,
183
],
[
309,
186
],
[
348,
189
],
[
309,
192
],
[
366,
194
],
[
297,
196
],
[
312,
199
],
[
330,
202
],
[
312,
205
],
[
366,
207
],
[
366,
208
],
[
332,
210
],
[
324,
213
],
[
333,
213
],
[
303,
214
],
[
366,
215
],
[
320,
217
],
[
360,
220
],
[
333,
221
],
[
324,
221
],
[
366,
222
],
[
321,
225
],
[
341,
227
],
[
231,
230
],
[
318,
233
],
[
336,
234
],
[
350,
236
],
[
300,
238
],
[
357,
239
],
[
326,
241
],
[
230,
243
],
[
362,
246
],
[
357,
247
],
[
371,
249
],
[
336,
251
],
[
230,
252
],
[
374,
254
],
[
297,
257
],
[
351,
260
],
[
327,
263
],
[
351,
266
],
[
366,
268
],
[
297,
270
],
[
363,
273
],
[
372,
276
],
[
363,
279
],
[
366,
281
],
[
338,
283
],
[
342,
286
],
[
339,
286
],
[
375,
287
],
[
366,
288
],
[
368,
290
],
[
366,
291
],
[
369,
294
],
[
339,
294
],
[
321,
294
],
[
342,
294
],
[
356,
300
],
[
302,
303
],
[
305,
306
],
[
308,
309
],
[
357,
311
],
[
311,
312
],
[
314,
315
],
[
356,
318
],
[
320,
321
],
[
323,
324
],
[
326,
327
],
[
329,
330
],
[
332,
333
],
[
356,
336
],
[
338,
339
],
[
341,
342
],
[
344,
345
],
[
347,
348
],
[
350,
351
],
[
353,
354
],
[
356,
357
],
[
359,
360
],
[
357,
362
],
[
362,
363
],
[
365,
366
],
[
366,
368
],
[
368,
369
],
[
371,
372
],
[
374,
375
]
] | [
"mod = 10 ** 9 + 7\nN = 10 ** 6\nfact = [1, 1]\nfactinv = [1, 1]\ninv = [0, 1]\n\nfor 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\ndef combi_mod(n, r, p):\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] % p\n\n\nH, W, A, B = map(int, input().split())\n\nif B < W / 2:\n not_ans = 0\n total = combi_mod((H - 1) + (W - 1), H-1, mod)\n for i in range(B):\n sq1h = H - A\n sq1w = i + 1\n sq2h = A\n sq2w = W - i\n n = combi_mod((sq1h -1) + (sq1w - 1), (sq1h -1), mod) * combi_mod((sq2h - 1) + (sq2w - 1), (sq2h - 1), mod) % mod\n not_ans = (not_ans + n) % mod\n ans = (total - not_ans) % mod\n print(ans)\n \nelse:\n ans = 0\n for i in range(B, W):\n sq1h = H - A\n sq1w = i + 1\n sq2h = A\n sq2w = W - i\n n = combi_mod((sq1h - 1) + (sq1w - 1), (sq1h - 1), mod) * combi_mod((sq2h - 1) + (sq2w - 1), (sq2h - 1), mod)\n ans = (ans + n) % mod\n ans %= mod\n print(ans)",
"mod = 10 ** 9 + 7",
"mod",
"10 ** 9 + 7",
"10 ** 9",
"10",
"9",
"7",
"N = 10 ** 6",
"N",
"10 ** 6",
"10",
"6",
"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)",
"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",
"def combi_mod(n, r, p):\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] % p",
"combi_mod",
"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] % p",
"fact[n] * factinv[r] * factinv[n - r] % p",
"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",
"p",
"n",
"n",
"r",
"r",
"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",
"if B < W / 2:\n not_ans = 0\n total = combi_mod((H - 1) + (W - 1), H-1, mod)\n for i in range(B):\n sq1h = H - A\n sq1w = i + 1\n sq2h = A\n sq2w = W - i\n n = combi_mod((sq1h -1) + (sq1w - 1), (sq1h -1), mod) * combi_mod((sq2h - 1) + (sq2w - 1), (sq2h - 1), mod) % mod\n not_ans = (not_ans + n) % mod\n ans = (total - not_ans) % mod\n print(ans)\n \nelse:\n ans = 0\n for i in range(B, W):\n sq1h = H - A\n sq1w = i + 1\n sq2h = A\n sq2w = W - i\n n = combi_mod((sq1h - 1) + (sq1w - 1), (sq1h - 1), mod) * combi_mod((sq2h - 1) + (sq2w - 1), (sq2h - 1), mod)\n ans = (ans + n) % mod\n ans %= mod\n print(ans)",
"B < W / 2",
"B",
"W / 2",
"W",
"2",
"not_ans = 0",
"not_ans",
"0",
"total = combi_mod((H - 1) + (W - 1), H-1, mod)",
"total",
"combi_mod((H - 1) + (W - 1), H-1, mod)",
"combi_mod",
"(H - 1) + (W - 1)",
"H - 1",
"H",
"1",
"W - 1",
"W",
"1",
"H-1",
"H",
"1",
"mod",
"for i in range(B):\n sq1h = H - A\n sq1w = i + 1\n sq2h = A\n sq2w = W - i\n n = combi_mod((sq1h -1) + (sq1w - 1), (sq1h -1), mod) * combi_mod((sq2h - 1) + (sq2w - 1), (sq2h - 1), mod) % mod\n not_ans = (not_ans + n) % mod\n ",
"i",
"range(B)",
"range",
"B",
"sq1h = H - A",
"sq1h",
"H - A",
"H",
"A",
"sq1w = i + 1",
"sq1w",
"i + 1",
"i",
"1",
"sq2h = A",
"sq2h",
"A",
"sq2w = W - i",
"sq2w",
"W - i",
"W",
"i",
"n = combi_mod((sq1h -1) + (sq1w - 1), (sq1h -1), mod) * combi_mod((sq2h - 1) + (sq2w - 1), (sq2h - 1), mod) % mod",
"n",
"combi_mod((sq1h -1) + (sq1w - 1), (sq1h -1), mod) * combi_mod((sq2h - 1) + (sq2w - 1), (sq2h - 1), mod) % mod",
"combi_mod((sq1h -1) + (sq1w - 1), (sq1h -1), mod) * combi_mod((sq2h - 1) + (sq2w - 1), (sq2h - 1), mod)",
"combi_mod((sq1h -1) + (sq1w - 1), (sq1h -1), mod)",
"combi_mod",
"(sq1h -1) + (sq1w - 1)",
"sq1h -1",
"sq1h",
"1",
"sq1w - 1",
"sq1w",
"1",
"sq1h -1",
"sq1h",
"1",
"mod",
"combi_mod((sq2h - 1) + (sq2w - 1), (sq2h - 1), mod)",
"combi_mod",
"(sq2h - 1) + (sq2w - 1)",
"sq2h - 1",
"sq2h",
"1",
"sq2w - 1",
"sq2w",
"1",
"sq2h - 1",
"sq2h",
"1",
"mod",
"mod",
"not_ans = (not_ans + n) % mod",
"not_ans",
"(not_ans + n) % mod",
"not_ans + n",
"not_ans",
"n",
"mod",
"ans = (total - not_ans) % mod",
"ans",
"(total - not_ans) % mod",
"total - not_ans",
"total",
"not_ans",
"mod",
"print(ans)",
"print",
"ans",
"ans = 0",
"ans",
"0",
"for i in range(B, W):\n sq1h = H - A\n sq1w = i + 1\n sq2h = A\n sq2w = W - i\n n = combi_mod((sq1h - 1) + (sq1w - 1), (sq1h - 1), mod) * combi_mod((sq2h - 1) + (sq2w - 1), (sq2h - 1), mod)\n ans = (ans + n) % mod\n ",
"i",
"range(B, W)",
"range",
"B",
"W",
"sq1h = H - A",
"sq1h",
"H - A",
"H",
"A",
"sq1w = i + 1",
"sq1w",
"i + 1",
"i",
"1",
"sq2h = A",
"sq2h",
"A",
"sq2w = W - i",
"sq2w",
"W - i",
"W",
"i",
"n = combi_mod((sq1h - 1) + (sq1w - 1), (sq1h - 1), mod) * combi_mod((sq2h - 1) + (sq2w - 1), (sq2h - 1), mod)",
"n",
"combi_mod((sq1h - 1) + (sq1w - 1), (sq1h - 1), mod) * combi_mod((sq2h - 1) + (sq2w - 1), (sq2h - 1), mod)",
"combi_mod((sq1h - 1) + (sq1w - 1), (sq1h - 1), mod)",
"combi_mod",
"(sq1h - 1) + (sq1w - 1)",
"sq1h - 1",
"sq1h",
"1",
"sq1w - 1",
"sq1w",
"1",
"sq1h - 1",
"sq1h",
"1",
"mod",
"combi_mod((sq2h - 1) + (sq2w - 1), (sq2h - 1), mod)",
"combi_mod",
"(sq2h - 1) + (sq2w - 1)",
"sq2h - 1",
"sq2h",
"1",
"sq2w - 1",
"sq2w",
"1",
"sq2h - 1",
"sq2h",
"1",
"mod",
"ans = (ans + n) % mod",
"ans",
"(ans + n) % mod",
"ans + n",
"ans",
"n",
"mod",
"ans %= mod",
"ans",
"mod",
"print(ans)",
"print",
"ans",
"def combi_mod(n, r, p):\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] % p",
"def combi_mod(n, r, p):\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] % p",
"combi_mod",
"H, W, A, B = map(int, input().split())",
"map(int, input().split())",
"H",
"n = combi_mod((sq1h -1) + (sq1w - 1), (sq1h -1), mod) * combi_mod((sq2h - 1) + (sq2w - 1), (sq2h - 1), mod) % mod",
"combi_mod((sq1h -1) + (sq1w - 1), (sq1h -1), mod) * combi_mod((sq2h - 1) + (sq2w - 1), (sq2h - 1), mod) % mod",
"n",
"factinv = [1, 1]",
"[1, 1]",
"factinv",
"sq1h = H - A",
"H - A",
"sq1h",
"sq2h = A",
"A",
"sq2h",
"inv = [0, 1]",
"[0, 1]",
"inv",
"B = map(int, input().split())",
"map(int, input().split())",
"B",
"ans = (total - not_ans) % mod",
"(total - not_ans) % mod",
"ans",
"not_ans = 0",
"0",
"not_ans",
"sq1w = i + 1",
"i + 1",
"sq1w",
"sq2w = W - i",
"W - i",
"sq2w",
"not_ans = (not_ans + n) % mod",
"(not_ans + n) % mod",
"not_ans",
"W, A, B = map(int, input().split())",
"map(int, input().split())",
"W",
"ans = (ans + n) % mod",
"(ans + n) % mod",
"ans",
"ans = 0",
"0",
"ans",
"N = 10 ** 6",
"10 ** 6",
"N",
"sq1w = i + 1",
"i + 1",
"sq1w",
"sq1h = H - A",
"H - A",
"sq1h",
"fact = [1, 1]",
"[1, 1]",
"fact",
"A, B = map(int, input().split())",
"map(int, input().split())",
"A",
"total = combi_mod((H - 1) + (W - 1), H-1, mod)",
"combi_mod((H - 1) + (W - 1), H-1, mod)",
"total",
"sq2h = A",
"A",
"sq2h",
"mod = 10 ** 9 + 7",
"10 ** 9 + 7",
"mod",
"ans %= mod",
"mod",
"ans",
"sq2w = W - i",
"W - i",
"sq2w",
"n = combi_mod((sq1h - 1) + (sq1w - 1), (sq1h - 1), mod) * combi_mod((sq2h - 1) + (sq2w - 1), (sq2h - 1), mod)",
"combi_mod((sq1h - 1) + (sq1w - 1), (sq1h - 1), mod) * combi_mod((sq2h - 1) + (sq2w - 1), (sq2h - 1), mod)",
"n"
] | mod = 10 ** 9 + 7
N = 10 ** 6
fact = [1, 1]
factinv = [1, 1]
inv = [0, 1]
for i in range(2, N + 1):
fact.append(fact[-1] * i % mod)
inv.append((-inv[mod % i] * (mod // i)) % mod)
factinv.append((factinv[-1] * inv[-1]) % mod)
def combi_mod(n, r, p):
if (r < 0) or (n < r):
return 0
r = min(r, n - r)
return fact[n] * factinv[r] * factinv[n - r] % p
H, W, A, B = map(int, input().split())
if B < W / 2:
not_ans = 0
total = combi_mod((H - 1) + (W - 1), H-1, mod)
for i in range(B):
sq1h = H - A
sq1w = i + 1
sq2h = A
sq2w = W - i
n = combi_mod((sq1h -1) + (sq1w - 1), (sq1h -1), mod) * combi_mod((sq2h - 1) + (sq2w - 1), (sq2h - 1), mod) % mod
not_ans = (not_ans + n) % mod
ans = (total - not_ans) % mod
print(ans)
else:
ans = 0
for i in range(B, W):
sq1h = H - A
sq1w = i + 1
sq2h = A
sq2w = W - i
n = combi_mod((sq1h - 1) + (sq1w - 1), (sq1h - 1), mod) * combi_mod((sq2h - 1) + (sq2w - 1), (sq2h - 1), mod)
ans = (ans + n) % mod
ans %= mod
print(ans)
|
[
7,
15,
15,
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,
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,
17,
0,
13,
4,
18,
4,
13,
13,
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,
17,
28,
13,
4,
13,
2,
13,
13,
0,
13,
4,
13,
2,
2,
2,
2,
13,
13,
13,
17,
13,
2,
2,
13,
13,
17,
13,
0,
13,
4,
13,
2,
2,
2,
2,
13,
13,
13,
17,
13,
2,
13,
17,
13,
0,
13,
2,
2,
13,
2,
2,
13,
13,
13,
13,
4,
13,
13,
10,
2,
13,
10,
4,
13,
10,
4,
13,
10,
39,
13,
10,
4,
13,
10,
39,
13,
10,
4,
13,
10,
4,
13,
10,
4,
13,
10,
2,
13,
10,
17,
13,
10,
12,
13,
10,
39,
13,
10,
2,
13,
10,
4,
13
] | [
[
42,
8
],
[
40,
11
],
[
42,
12
],
[
17,
16
],
[
42,
19
],
[
40,
21
],
[
42,
22
],
[
40,
29
],
[
16,
32
],
[
42,
32
],
[
40,
36
],
[
16,
37
],
[
42,
37
],
[
44,
38
],
[
40,
40
],
[
42,
42
],
[
44,
44
],
[
217,
46
],
[
244,
53
],
[
232,
58
],
[
226,
63
],
[
253,
68
],
[
74,
73
],
[
245,
78
],
[
233,
82
],
[
233,
87
],
[
73,
89
],
[
218,
90
],
[
254,
93
],
[
254,
99
],
[
218,
101
],
[
73,
102
],
[
218,
104
],
[
73,
105
],
[
218,
106
],
[
227,
109
],
[
227,
114
],
[
254,
117
],
[
218,
119
],
[
259,
122
],
[
220,
129
],
[
260,
133
],
[
235,
136
],
[
260,
140
],
[
241,
143
],
[
260,
147
],
[
223,
150
],
[
260,
154
],
[
247,
157
],
[
161,
160
],
[
236,
164
],
[
224,
165
],
[
238,
167
],
[
251,
169
],
[
221,
174
],
[
242,
175
],
[
224,
176
],
[
160,
178
],
[
221,
181
],
[
242,
182
],
[
218,
184
],
[
229,
186
],
[
251,
188
],
[
236,
193
],
[
242,
194
],
[
224,
195
],
[
160,
197
],
[
242,
199
],
[
218,
201
],
[
256,
203
],
[
248,
206
],
[
257,
206
],
[
239,
209
],
[
230,
210
],
[
218,
211
],
[
218,
212
],
[
257,
215
],
[
248,
215
],
[
217,
218
],
[
220,
221
],
[
223,
224
],
[
226,
227
],
[
229,
230
],
[
232,
233
],
[
235,
236
],
[
238,
239
],
[
241,
242
],
[
244,
245
],
[
247,
248
],
[
253,
254
],
[
256,
257
],
[
259,
260
]
] | [
"from operator import mul\nfrom functools import reduce\n\ndef cmb(n, r, p):\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] % p\n\np = 10 ** 9 + 7\nN = 10 ** 6\nfact = [1, 1] # fact[n] = (n! mod p)\nfactinv = [1, 1] # factinv[n] = ((n!)^(-1) mod p)\ninv = [0, 1]\n\nfor i in range(2, N + 1):\n fact.append((fact[-1] * i) % p)\n inv.append((-inv[p % i] * (p // i)) % p)\n factinv.append((factinv[-1] * inv[-1]) % p)\n\n#kari1 = '2 3 1 1' #2\n#kari1 = '10 7 3 4' #3570\n#kari1 = '100000 100000 99999 99999' #1\n#kari1 = '100000 100000 44444 55555' #738162020\n\n\"\"\"\nin1 = kari1.split()\n\"\"\"\nin1 = input().split()\n\nH = int(in1[0])\nW = int(in1[1])\nA = int(in1[2])\nB = int(in1[3])\n\nallCNT = 0\nfor idx1 in range(W - B):\n beforeCNT = cmb(H - A + B - 1 + idx1, H - A - 1, p)\n afterCNT = cmb(W + A - B - 2 - idx1, A - 1, p)\n allCNT = (allCNT + (beforeCNT * afterCNT) % p) % p\n\nprint(allCNT)",
"from operator import mul",
"from functools import reduce",
"def cmb(n, r, p):\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] % p",
"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] % p",
"fact[n] * factinv[r] * factinv[n-r] % p",
"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",
"p",
"n",
"n",
"r",
"r",
"p",
"p",
"p = 10 ** 9 + 7",
"p",
"10 ** 9 + 7",
"10 ** 9",
"10",
"9",
"7",
"N = 10 ** 6",
"N",
"10 ** 6",
"10",
"6",
"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) % p)\n inv.append((-inv[p % i] * (p // i)) % p)\n factinv.append((factinv[-1] * inv[-1]) % p)\n\n#kari1 = '2 3 1 1' #2\n#kari1 = '10 7 3 4' #3570\n#kari1 = '100000 100000 99999 99999' #1\n#kari1 = '100000 100000 44444 55555' #738162020",
"i",
"range(2, N + 1)",
"range",
"2",
"N + 1",
"N",
"1",
"fact.append((fact[-1] * i) % p)",
"fact.append",
"fact",
"append",
"(fact[-1] * i) % p",
"fact[-1] * i",
"fact[-1]",
"fact",
"-1",
"i",
"p",
"inv.append((-inv[p % i] * (p // i)) % p)",
"inv.append",
"inv",
"append",
"(-inv[p % i] * (p // i)) % p",
"-inv[p % i] * (p // i)",
"-inv[p % i]",
"inv[p % i]",
"inv",
"p % i",
"p",
"i",
"p // i",
"p",
"i",
"p",
"factinv.append((factinv[-1] * inv[-1]) % p)",
"factinv.append",
"factinv",
"append",
"(factinv[-1] * inv[-1]) % p",
"factinv[-1] * inv[-1]",
"factinv[-1]",
"factinv",
"-1",
"inv[-1]",
"inv",
"-1",
"p",
"\"\"\"\nin1 = kari1.split()\n\"\"\"",
"in1 = input().split()",
"in1",
"input().split()",
"().split",
"()",
"input",
"split",
"H = int(in1[0])",
"H",
"int(in1[0])",
"int",
"in1[0]",
"in1",
"0",
"W = int(in1[1])",
"W",
"int(in1[1])",
"int",
"in1[1]",
"in1",
"1",
"A = int(in1[2])",
"A",
"int(in1[2])",
"int",
"in1[2]",
"in1",
"2",
"B = int(in1[3])",
"B",
"int(in1[3])",
"int",
"in1[3]",
"in1",
"3",
"allCNT = 0",
"allCNT",
"0",
"for idx1 in range(W - B):\n beforeCNT = cmb(H - A + B - 1 + idx1, H - A - 1, p)\n afterCNT = cmb(W + A - B - 2 - idx1, A - 1, p)\n allCNT = (allCNT + (beforeCNT * afterCNT) % p) % p",
"idx1",
"range(W - B)",
"range",
"W - B",
"W",
"B",
"beforeCNT = cmb(H - A + B - 1 + idx1, H - A - 1, p)",
"beforeCNT",
"cmb(H - A + B - 1 + idx1, H - A - 1, p)",
"cmb",
"H - A + B - 1 + idx1",
"H - A + B - 1",
"H - A + B",
"H - A",
"H",
"A",
"B",
"1",
"idx1",
"H - A - 1",
"H - A",
"H",
"A",
"1",
"p",
"afterCNT = cmb(W + A - B - 2 - idx1, A - 1, p)",
"afterCNT",
"cmb(W + A - B - 2 - idx1, A - 1, p)",
"cmb",
"W + A - B - 2 - idx1",
"W + A - B - 2",
"W + A - B",
"W + A",
"W",
"A",
"B",
"2",
"idx1",
"A - 1",
"A",
"1",
"p",
"allCNT = (allCNT + (beforeCNT * afterCNT) % p) % p",
"allCNT",
"(allCNT + (beforeCNT * afterCNT) % p) % p",
"allCNT + (beforeCNT * afterCNT) % p",
"allCNT",
"(beforeCNT * afterCNT) % p",
"beforeCNT * afterCNT",
"beforeCNT",
"afterCNT",
"p",
"p",
"print(allCNT)",
"print",
"allCNT",
"p = 10 ** 9 + 7",
"10 ** 9 + 7",
"p",
"H = int(in1[0])",
"int(in1[0])",
"H",
"B = int(in1[3])",
"int(in1[3])",
"B",
"factinv = [1, 1]",
"[1, 1]",
"factinv",
"afterCNT = cmb(W + A - B - 2 - idx1, A - 1, p)",
"cmb(W + A - B - 2 - idx1, A - 1, p)",
"afterCNT",
"fact = [1, 1]",
"[1, 1]",
"fact",
"W = int(in1[1])",
"int(in1[1])",
"W",
"beforeCNT = cmb(H - A + B - 1 + idx1, H - A - 1, p)",
"cmb(H - A + B - 1 + idx1, H - A - 1, p)",
"beforeCNT",
"A = int(in1[2])",
"int(in1[2])",
"A",
"N = 10 ** 6",
"10 ** 6",
"N",
"allCNT = 0",
"0",
"allCNT",
"def cmb(n, r, p):\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] % p",
"def cmb(n, r, p):\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] % p",
"cmb",
"inv = [0, 1]",
"[0, 1]",
"inv",
"allCNT = (allCNT + (beforeCNT * afterCNT) % p) % p",
"(allCNT + (beforeCNT * afterCNT) % p) % p",
"allCNT",
"in1 = input().split()",
"input().split()",
"in1"
] | from operator import mul
from functools import reduce
def cmb(n, r, p):
if (r < 0) or (n < r):
return 0
r = min(r, n - r)
return fact[n] * factinv[r] * factinv[n-r] % p
p = 10 ** 9 + 7
N = 10 ** 6
fact = [1, 1] # fact[n] = (n! mod p)
factinv = [1, 1] # factinv[n] = ((n!)^(-1) mod p)
inv = [0, 1]
for i in range(2, N + 1):
fact.append((fact[-1] * i) % p)
inv.append((-inv[p % i] * (p // i)) % p)
factinv.append((factinv[-1] * inv[-1]) % p)
#kari1 = '2 3 1 1' #2
#kari1 = '10 7 3 4' #3570
#kari1 = '100000 100000 99999 99999' #1
#kari1 = '100000 100000 44444 55555' #738162020
"""
in1 = kari1.split()
"""
in1 = input().split()
H = int(in1[0])
W = int(in1[1])
A = int(in1[2])
B = int(in1[3])
allCNT = 0
for idx1 in range(W - B):
beforeCNT = cmb(H - A + B - 1 + idx1, H - A - 1, p)
afterCNT = cmb(W + A - B - 2 - idx1, A - 1, p)
allCNT = (allCNT + (beforeCNT * afterCNT) % p) % p
print(allCNT)
|
[
7,
15,
13,
4,
18,
13,
13,
2,
17,
17,
12,
13,
0,
13,
17,
13,
17,
12,
13,
41,
14,
2,
13,
17,
0,
13,
17,
0,
13,
17,
29,
13,
0,
13,
4,
13,
13,
2,
13,
13,
0,
13,
2,
13,
13,
0,
13,
13,
0,
13,
2,
13,
2,
13,
13,
0,
13,
13,
29,
13,
23,
13,
23,
13,
0,
13,
4,
13,
13,
13,
29,
39,
13,
13,
13,
23,
13,
23,
13,
0,
13,
2,
39,
17,
17,
0,
13,
2,
39,
17,
17,
0,
13,
2,
2,
17,
17,
17,
12,
13,
0,
13,
18,
13,
13,
0,
13,
2,
2,
13,
18,
13,
2,
13,
13,
13,
0,
13,
2,
2,
13,
18,
13,
13,
13,
29,
13,
23,
13,
23,
13,
0,
18,
13,
17,
17,
28,
13,
4,
13,
17,
2,
17,
17,
0,
18,
13,
13,
2,
2,
18,
13,
2,
13,
17,
13,
13,
28,
13,
4,
13,
2,
17,
17,
0,
13,
4,
13,
18,
13,
13,
13,
13,
13,
42,
2,
13,
17,
0,
13,
13,
0,
18,
13,
13,
2,
13,
13,
41,
28,
13,
4,
18,
4,
13,
13,
4,
4,
13,
13,
0,
13,
13,
13,
13,
13,
0,
13,
17,
28,
13,
4,
13,
13,
13,
0,
13,
4,
13,
2,
2,
2,
13,
13,
17,
13,
2,
2,
13,
13,
17,
0,
13,
2,
2,
13,
4,
13,
2,
2,
13,
17,
2,
2,
13,
13,
17,
2,
13,
17,
13,
0,
13,
2,
2,
13,
13,
13,
4,
13,
13,
10,
13,
13,
10,
13,
13,
10,
2,
13,
10,
13,
13,
10,
4,
13,
10,
2,
13,
10,
4,
13,
10,
12,
13,
10,
13,
13,
10,
2,
13,
10,
4,
13,
10,
4,
13,
10,
17,
13,
10,
2,
13,
10,
13,
13,
10,
12,
13,
10,
2,
13
] | [
[
14,
13
],
[
16,
15
],
[
63,
22
],
[
26,
25
],
[
29,
28
],
[
61,
31
],
[
34,
33
],
[
63,
36
],
[
61,
38
],
[
63,
39
],
[
42,
41
],
[
61,
43
],
[
63,
44
],
[
47,
46
],
[
28,
47
],
[
50,
49
],
[
25,
51
],
[
41,
53
],
[
28,
54
],
[
57,
56
],
[
46,
57
],
[
33,
59
],
[
61,
61
],
[
63,
63
],
[
66,
65
],
[
18,
67
],
[
76,
68
],
[
78,
69
],
[
76,
76
],
[
78,
78
],
[
289,
80
],
[
301,
86
],
[
277,
92
],
[
102,
101
],
[
290,
103
],
[
128,
104
],
[
107,
106
],
[
101,
109
],
[
302,
111
],
[
128,
113
],
[
130,
114
],
[
278,
115
],
[
118,
117
],
[
106,
120
],
[
101,
120
],
[
302,
122
],
[
130,
123
],
[
278,
124
],
[
117,
126
],
[
106,
126
],
[
101,
126
],
[
128,
128
],
[
130,
130
],
[
135,
132
],
[
290,
133
],
[
138,
137
],
[
148,
145
],
[
290,
146
],
[
137,
147
],
[
290,
151
],
[
137,
153
],
[
137,
155
],
[
278,
156
],
[
159,
158
],
[
295,
165
],
[
308,
167
],
[
145,
168
],
[
290,
169
],
[
158,
170
],
[
278,
171
],
[
295,
172
],
[
295,
173
],
[
293,
176
],
[
272,
176
],
[
271,
179
],
[
278,
180
],
[
185,
182
],
[
302,
183
],
[
158,
184
],
[
272,
186
],
[
293,
186
],
[
278,
187
],
[
191,
190
],
[
190,
199
],
[
304,
201
],
[
304,
203
],
[
304,
204
],
[
304,
205
],
[
298,
207
],
[
211,
210
],
[
287,
213
],
[
263,
214
],
[
274,
216
],
[
284,
218
],
[
266,
222
],
[
305,
223
],
[
210,
225
],
[
266,
228
],
[
305,
229
],
[
268,
232
],
[
275,
235
],
[
269,
235
],
[
284,
237
],
[
305,
240
],
[
263,
244
],
[
210,
245
],
[
305,
248
],
[
278,
250
],
[
310,
252
],
[
299,
255
],
[
311,
255
],
[
269,
256
],
[
275,
256
],
[
278,
257
],
[
311,
260
],
[
299,
260
],
[
304,
263
],
[
304,
266
],
[
268,
269
],
[
278,
271
],
[
271,
272
],
[
274,
275
],
[
277,
278
],
[
295,
281
],
[
304,
287
],
[
289,
290
],
[
295,
293
],
[
295,
296
],
[
298,
299
],
[
301,
302
],
[
304,
305
],
[
310,
311
]
] | [
"import sys\n\nsys.setrecursionlimit(10 ** 9)\n\n\ndef extgcd(a, b):\n x, y = 0, 0\n\n def f(a, b):\n nonlocal x, y\n if b == 0:\n x = 1\n y = 0\n\n return a\n\n g = f(b, a % b)\n q = a // b\n next_x = y\n y = x - q * y\n x = next_x\n return g\n\n g = f(a, b)\n return x, y, g\n\n\nfact = [0] * 200010\ninvfact = [0] * 200010\nmod = 10 ** 9 + 7\n\n\ndef nCr(n, r):\n ret = fact[n]\n ret = (ret * invfact[n - r]) % mod\n ret = (ret * invfact[r]) % mod\n return ret\n\n\nfact[0] = 1\nfor i in range(1, 200000 + 1):\n fact[i] = (fact[i - 1] * i) % mod\nfor i in range(200000 + 1):\n x, y, g = extgcd(fact[i], mod)\n while x < 0:\n x += mod\n invfact[i] = x % mod\n\nH, W, A, B = [int(_) for _ in input().split()]\n\nans = 0\nfor i in range(B, W):\n tmp = nCr((H - A - 1) + i, H - A - 1)\n tmp = tmp * nCr((A - 1) + (W - i - 1), A - 1) % mod\n ans = (ans + tmp) % mod\nprint(ans)",
"import sys",
"sys",
"sys.setrecursionlimit(10 ** 9)",
"sys.setrecursionlimit",
"sys",
"setrecursionlimit",
"10 ** 9",
"10",
"9",
"def extgcd(a, b):\n x, y = 0, 0\n\n def f(a, b):\n nonlocal x, y\n if b == 0:\n x = 1\n y = 0\n\n return a\n\n g = f(b, a % b)\n q = a // b\n next_x = y\n y = x - q * y\n x = next_x\n return g\n\n g = f(a, b)\n return x, y, g",
"extgcd",
"x, y = 0, 0",
"x",
"0",
"y",
"0",
"def f(a, b):\n nonlocal x, y\n if b == 0:\n x = 1\n y = 0\n\n return a\n\n g = f(b, a % b)\n q = a // b\n next_x = y\n y = x - q * y\n x = next_x\n return g\n\n ",
"f",
"nonlocal x, y",
"if b == 0:\n x = 1\n y = 0\n\n return a\n\n ",
"b == 0",
"b",
"0",
"x = 1",
"x",
"1",
"y = 0",
"y",
"0",
"return a",
"a",
"g = f(b, a % b)",
"g",
"f(b, a % b)",
"f",
"b",
"a % b",
"a",
"b",
"q = a // b",
"q",
"a // b",
"a",
"b",
"next_x = y",
"next_x",
"y",
"y = x - q * y",
"y",
"x - q * y",
"x",
"q * y",
"q",
"y",
"x = next_x",
"x",
"next_x",
"return g",
"g",
"a",
"a",
"b",
"b",
"g = f(a, b)",
"g",
"f(a, b)",
"f",
"a",
"b",
"return x, y, g",
"return x, y, g",
"x",
"y",
"g",
"a",
"a",
"b",
"b",
"fact = [0] * 200010",
"fact",
"[0] * 200010",
"[0]",
"0",
"200010",
"invfact = [0] * 200010",
"invfact",
"[0] * 200010",
"[0]",
"0",
"200010",
"mod = 10 ** 9 + 7",
"mod",
"10 ** 9 + 7",
"10 ** 9",
"10",
"9",
"7",
"def nCr(n, r):\n ret = fact[n]\n ret = (ret * invfact[n - r]) % mod\n ret = (ret * invfact[r]) % mod\n return ret",
"nCr",
"ret = fact[n]",
"ret",
"fact[n]",
"fact",
"n",
"ret = (ret * invfact[n - r]) % mod",
"ret",
"(ret * invfact[n - r]) % mod",
"ret * invfact[n - r]",
"ret",
"invfact[n - r]",
"invfact",
"n - r",
"n",
"r",
"mod",
"ret = (ret * invfact[r]) % mod",
"ret",
"(ret * invfact[r]) % mod",
"ret * invfact[r]",
"ret",
"invfact[r]",
"invfact",
"r",
"mod",
"return ret",
"ret",
"n",
"n",
"r",
"r",
"fact[0] = 1",
"fact[0]",
"fact",
"0",
"1",
"for i in range(1, 200000 + 1):\n fact[i] = (fact[i - 1] * i) % mod",
"i",
"range(1, 200000 + 1)",
"range",
"1",
"200000 + 1",
"200000",
"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",
"for i in range(200000 + 1):\n x, y, g = extgcd(fact[i], mod)\n while x < 0:\n x += mod\n invfact[i] = x % mod",
"i",
"range(200000 + 1)",
"range",
"200000 + 1",
"200000",
"1",
"x, y, g = extgcd(fact[i], mod)",
"x",
"extgcd(fact[i], mod)",
"extgcd",
"fact[i]",
"fact",
"i",
"mod",
"y",
"g",
"while x < 0:\n x += mod\n ",
"x < 0",
"x",
"0",
"x += mod",
"x",
"mod",
"invfact[i] = x % mod",
"invfact[i]",
"invfact",
"i",
"x % mod",
"x",
"mod",
"int(_) for _ in input().split()",
"for _ in input().split()",
"_",
"input().split()",
"().split",
"()",
"input",
"split",
"for _ in input().split()",
"int(_)",
"int",
"_",
"H, W, A, B = [int(_) for _ in input().split()]",
"H",
"[int(_) for _ in input().split()]",
"W",
"A",
"B",
"ans = 0",
"ans",
"0",
"for i in range(B, W):\n tmp = nCr((H - A - 1) + i, H - A - 1)\n tmp = tmp * nCr((A - 1) + (W - i - 1), A - 1) % mod\n ans = (ans + tmp) % mod",
"i",
"range(B, W)",
"range",
"B",
"W",
"tmp = nCr((H - A - 1) + i, H - A - 1)",
"tmp",
"nCr((H - A - 1) + i, H - A - 1)",
"nCr",
"(H - A - 1) + i",
"H - A - 1",
"H - A",
"H",
"A",
"1",
"i",
"H - A - 1",
"H - A",
"H",
"A",
"1",
"tmp = tmp * nCr((A - 1) + (W - i - 1), A - 1) % mod",
"tmp",
"tmp * nCr((A - 1) + (W - i - 1), A - 1) % mod",
"tmp * nCr((A - 1) + (W - i - 1), A - 1)",
"tmp",
"nCr((A - 1) + (W - i - 1), A - 1)",
"nCr",
"(A - 1) + (W - i - 1)",
"A - 1",
"A",
"1",
"W - i - 1",
"W - i",
"W",
"i",
"1",
"A - 1",
"A",
"1",
"mod",
"ans = (ans + tmp) % mod",
"ans",
"(ans + tmp) % mod",
"ans + tmp",
"ans",
"tmp",
"mod",
"print(ans)",
"print",
"ans",
"W, A, B = [int(_) for _ in input().split()]",
"[int(_) for _ in input().split()]",
"W",
"H, W, A, B = [int(_) for _ in input().split()]",
"[int(_) for _ in input().split()]",
"H",
"tmp = tmp * nCr((A - 1) + (W - i - 1), A - 1) % mod",
"tmp * nCr((A - 1) + (W - i - 1), A - 1) % mod",
"tmp",
"x += mod",
"mod",
"x",
"tmp = nCr((H - A - 1) + i, H - A - 1)",
"nCr((H - A - 1) + i, H - A - 1)",
"tmp",
"mod = 10 ** 9 + 7",
"10 ** 9 + 7",
"mod",
"y, g = extgcd(fact[i], mod)",
"extgcd(fact[i], mod)",
"y",
"def nCr(n, r):\n ret = fact[n]\n ret = (ret * invfact[n - r]) % mod\n ret = (ret * invfact[r]) % mod\n return ret",
"def nCr(n, r):\n ret = fact[n]\n ret = (ret * invfact[n - r]) % mod\n ret = (ret * invfact[r]) % mod\n return ret",
"nCr",
"B = [int(_) for _ in input().split()]",
"[int(_) for _ in input().split()]",
"B",
"fact = [0] * 200010",
"[0] * 200010",
"fact",
"x, y, g = extgcd(fact[i], mod)",
"extgcd(fact[i], mod)",
"x",
"g = extgcd(fact[i], mod)",
"extgcd(fact[i], mod)",
"g",
"ans = 0",
"0",
"ans",
"invfact = [0] * 200010",
"[0] * 200010",
"invfact",
"A, B = [int(_) for _ in input().split()]",
"[int(_) for _ in input().split()]",
"A",
"def extgcd(a, b):\n x, y = 0, 0\n\n def f(a, b):\n nonlocal x, y\n if b == 0:\n x = 1\n y = 0\n\n return a\n\n g = f(b, a % b)\n q = a // b\n next_x = y\n y = x - q * y\n x = next_x\n return g\n\n g = f(a, b)\n return x, y, g",
"def extgcd(a, b):\n x, y = 0, 0\n\n def f(a, b):\n nonlocal x, y\n if b == 0:\n x = 1\n y = 0\n\n return a\n\n g = f(b, a % b)\n q = a // b\n next_x = y\n y = x - q * y\n x = next_x\n return g\n\n g = f(a, b)\n return x, y, g",
"extgcd",
"ans = (ans + tmp) % mod",
"(ans + tmp) % mod",
"ans"
] | import sys
sys.setrecursionlimit(10 ** 9)
def extgcd(a, b):
x, y = 0, 0
def f(a, b):
nonlocal x, y
if b == 0:
x = 1
y = 0
return a
g = f(b, a % b)
q = a // b
next_x = y
y = x - q * y
x = next_x
return g
g = f(a, b)
return x, y, g
fact = [0] * 200010
invfact = [0] * 200010
mod = 10 ** 9 + 7
def nCr(n, r):
ret = fact[n]
ret = (ret * invfact[n - r]) % mod
ret = (ret * invfact[r]) % mod
return ret
fact[0] = 1
for i in range(1, 200000 + 1):
fact[i] = (fact[i - 1] * i) % mod
for i in range(200000 + 1):
x, y, g = extgcd(fact[i], mod)
while x < 0:
x += mod
invfact[i] = x % mod
H, W, A, B = [int(_) for _ in input().split()]
ans = 0
for i in range(B, W):
tmp = nCr((H - A - 1) + i, H - A - 1)
tmp = tmp * nCr((A - 1) + (W - i - 1), A - 1) % mod
ans = (ans + tmp) % mod
print(ans)
|
[
7,
0,
13,
2,
2,
17,
17,
17,
0,
13,
17,
0,
13,
17,
0,
13,
39,
17,
0,
13,
39,
17,
28,
13,
4,
13,
17,
13,
4,
18,
13,
13,
2,
2,
18,
13,
17,
13,
13,
28,
13,
4,
13,
17,
13,
4,
18,
13,
13,
4,
13,
18,
13,
13,
2,
13,
17,
13,
12,
13,
14,
2,
2,
13,
17,
2,
13,
17,
29,
17,
29,
2,
2,
2,
18,
13,
13,
18,
13,
2,
13,
13,
18,
13,
13,
13,
23,
13,
23,
13,
0,
13,
4,
13,
13,
4,
18,
4,
13,
13,
17,
13,
13,
13,
0,
13,
4,
13,
2,
2,
13,
13,
17,
2,
13,
17,
0,
13,
2,
2,
2,
13,
13,
13,
17,
28,
13,
4,
13,
17,
2,
4,
13,
13,
13,
17,
0,
13,
2,
2,
13,
2,
2,
4,
13,
13,
2,
13,
13,
4,
13,
2,
2,
2,
13,
13,
17,
13,
2,
2,
2,
13,
13,
13,
17,
13,
13,
4,
13,
13,
10,
17,
13,
10,
4,
13,
10,
12,
13,
10,
39,
13,
10,
4,
13,
10,
17,
13,
10,
4,
13,
10,
2,
13,
10,
2,
13,
10,
39,
13,
10,
4,
13,
10,
4,
13,
10,
2,
13
] | [
[
207,
2
],
[
186,
9
],
[
171,
12
],
[
180,
15
],
[
198,
19
],
[
24,
23
],
[
172,
27
],
[
181,
30
],
[
181,
35
],
[
23,
37
],
[
208,
38
],
[
41,
40
],
[
172,
44
],
[
199,
47
],
[
181,
52
],
[
40,
53
],
[
208,
55
],
[
208,
57
],
[
87,
63
],
[
89,
66
],
[
181,
75
],
[
87,
76
],
[
199,
78
],
[
87,
80
],
[
89,
81
],
[
199,
83
],
[
89,
84
],
[
208,
85
],
[
87,
87
],
[
89,
89
],
[
204,
91
],
[
204,
101
],
[
204,
102
],
[
204,
103
],
[
183,
105
],
[
178,
107
],
[
202,
110
],
[
205,
111
],
[
202,
114
],
[
195,
117
],
[
202,
121
],
[
175,
122
],
[
190,
123
],
[
127,
126
],
[
175,
133
],
[
190,
134
],
[
192,
137
],
[
184,
140
],
[
193,
140
],
[
178,
144
],
[
196,
145
],
[
190,
147
],
[
126,
148
],
[
178,
150
],
[
202,
154
],
[
205,
155
],
[
196,
157
],
[
205,
161
],
[
190,
162
],
[
126,
163
],
[
208,
165
],
[
208,
166
],
[
193,
169
],
[
184,
169
],
[
171,
172
],
[
204,
175
],
[
180,
181
],
[
183,
184
],
[
186,
187
],
[
204,
190
],
[
192,
193
],
[
195,
196
],
[
198,
199
],
[
204,
202
],
[
204,
205
],
[
207,
208
]
] | [
"mod = 10**9+7\nmod2 = 998244353\nrng = 200001\nfctr = [1]\nfinv = [1]\nfor i in range(1,rng):\n fctr.append(fctr[-1]*i%mod)\nfor i in range(1,rng):\n finv.append(pow(fctr[i],mod-2,mod))\ndef cmb(n,k):\n if n<0 or k<0:\n return 0\n else:\n return fctr[n]*finv[n-k]*finv[k]%mod\nh,w,a,b = map(int, input().split(' '))\nans = cmb(h+w-2,h-1)\nx = h-a+b-1\nfor i in range(1,min(a,b)+1):\n ans = (ans-(cmb(x,b-i)*cmb(h+w-2-x,w-b+i-1))%mod)%mod\nprint(ans)",
"mod = 10**9+7",
"mod",
"10**9+7",
"10**9",
"10",
"9",
"7",
"mod2 = 998244353",
"mod2",
"998244353",
"rng = 200001",
"rng",
"200001",
"fctr = [1]",
"fctr",
"[1]",
"1",
"finv = [1]",
"finv",
"[1]",
"1",
"for i in range(1,rng):\n fctr.append(fctr[-1]*i%mod)",
"i",
"range(1,rng)",
"range",
"1",
"rng",
"fctr.append(fctr[-1]*i%mod)",
"fctr.append",
"fctr",
"append",
"fctr[-1]*i%mod",
"fctr[-1]*i",
"fctr[-1]",
"fctr",
"-1",
"i",
"mod",
"for i in range(1,rng):\n finv.append(pow(fctr[i],mod-2,mod))",
"i",
"range(1,rng)",
"range",
"1",
"rng",
"finv.append(pow(fctr[i],mod-2,mod))",
"finv.append",
"finv",
"append",
"pow(fctr[i],mod-2,mod)",
"pow",
"fctr[i]",
"fctr",
"i",
"mod-2",
"mod",
"2",
"mod",
"def cmb(n,k):\n if n<0 or k<0:\n return 0\n else:\n return fctr[n]*finv[n-k]*finv[k]%mod",
"cmb",
"if n<0 or k<0:\n return 0\n else:\n return fctr[n]*finv[n-k]*finv[k]%mod",
"n<0 or k<0",
"n<0",
"n",
"0",
"k<0",
"k",
"0",
"return 0",
"0",
"return fctr[n]*finv[n-k]*finv[k]%mod",
"fctr[n]*finv[n-k]*finv[k]%mod",
"fctr[n]*finv[n-k]*finv[k]",
"fctr[n]*finv[n-k]",
"fctr[n]",
"fctr",
"n",
"finv[n-k]",
"finv",
"n-k",
"n",
"k",
"finv[k]",
"finv",
"k",
"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",
"ans = cmb(h+w-2,h-1)",
"ans",
"cmb(h+w-2,h-1)",
"cmb",
"h+w-2",
"h+w",
"h",
"w",
"2",
"h-1",
"h",
"1",
"x = h-a+b-1",
"x",
"h-a+b-1",
"h-a+b",
"h-a",
"h",
"a",
"b",
"1",
"for i in range(1,min(a,b)+1):\n ans = (ans-(cmb(x,b-i)*cmb(h+w-2-x,w-b+i-1))%mod)%mod",
"i",
"range(1,min(a,b)+1)",
"range",
"1",
"min(a,b)+1",
"min(a,b)",
"min",
"a",
"b",
"1",
"ans = (ans-(cmb(x,b-i)*cmb(h+w-2-x,w-b+i-1))%mod)%mod",
"ans",
"(ans-(cmb(x,b-i)*cmb(h+w-2-x,w-b+i-1))%mod)%mod",
"ans-(cmb(x,b-i)*cmb(h+w-2-x,w-b+i-1))%mod",
"ans",
"(cmb(x,b-i)*cmb(h+w-2-x,w-b+i-1))%mod",
"cmb(x,b-i)*cmb(h+w-2-x,w-b+i-1)",
"cmb(x,b-i)",
"cmb",
"x",
"b-i",
"b",
"i",
"cmb(h+w-2-x,w-b+i-1)",
"cmb",
"h+w-2-x",
"h+w-2",
"h+w",
"h",
"w",
"2",
"x",
"w-b+i-1",
"w-b+i",
"w-b",
"w",
"b",
"i",
"1",
"mod",
"mod",
"print(ans)",
"print",
"ans",
"rng = 200001",
"200001",
"rng",
"a,b = map(int, input().split(' '))",
"map(int, input().split(' '))",
"a",
"def cmb(n,k):\n if n<0 or k<0:\n return 0\n else:\n return fctr[n]*finv[n-k]*finv[k]%mod",
"def cmb(n,k):\n if n<0 or k<0:\n return 0\n else:\n return fctr[n]*finv[n-k]*finv[k]%mod",
"cmb",
"fctr = [1]",
"[1]",
"fctr",
"ans = cmb(h+w-2,h-1)",
"cmb(h+w-2,h-1)",
"ans",
"mod2 = 998244353",
"998244353",
"mod2",
"b = map(int, input().split(' '))",
"map(int, input().split(' '))",
"b",
"ans = (ans-(cmb(x,b-i)*cmb(h+w-2-x,w-b+i-1))%mod)%mod",
"(ans-(cmb(x,b-i)*cmb(h+w-2-x,w-b+i-1))%mod)%mod",
"ans",
"x = h-a+b-1",
"h-a+b-1",
"x",
"finv = [1]",
"[1]",
"finv",
"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"
] | mod = 10**9+7
mod2 = 998244353
rng = 200001
fctr = [1]
finv = [1]
for i in range(1,rng):
fctr.append(fctr[-1]*i%mod)
for i in range(1,rng):
finv.append(pow(fctr[i],mod-2,mod))
def cmb(n,k):
if n<0 or k<0:
return 0
else:
return fctr[n]*finv[n-k]*finv[k]%mod
h,w,a,b = map(int, input().split(' '))
ans = cmb(h+w-2,h-1)
x = h-a+b-1
for i in range(1,min(a,b)+1):
ans = (ans-(cmb(x,b-i)*cmb(h+w-2-x,w-b+i-1))%mod)%mod
print(ans) |
[
7,
15,
13,
0,
13,
18,
18,
13,
13,
13,
0,
13,
2,
2,
17,
17,
17,
12,
13,
29,
2,
2,
2,
18,
13,
13,
18,
13,
13,
18,
13,
2,
13,
13,
13,
23,
13,
23,
13,
23,
13,
23,
13,
12,
13,
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,
2,
13,
17,
13,
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,
13,
28,
13,
4,
13,
2,
13,
13,
17,
17,
0,
18,
13,
2,
13,
17,
2,
2,
18,
13,
13,
13,
13,
0,
13,
17,
28,
13,
4,
13,
2,
13,
13,
0,
13,
2,
2,
2,
2,
13,
13,
17,
13,
13,
0,
13,
2,
2,
13,
13,
17,
0,
13,
2,
2,
2,
2,
2,
13,
17,
13,
13,
17,
13,
0,
13,
2,
13,
17,
0,
13,
2,
2,
4,
13,
13,
13,
13,
13,
4,
13,
13,
13,
13,
13,
13,
4,
13,
2,
13,
13,
14,
2,
13,
17,
4,
13,
10,
12,
13,
10,
18,
13,
10,
2,
13,
10,
12,
13
] | [
[
212,
4
],
[
215,
11
],
[
36,
24
],
[
40,
25
],
[
38,
27
],
[
42,
28
],
[
38,
30
],
[
40,
32
],
[
42,
33
],
[
216,
34
],
[
36,
36
],
[
38,
38
],
[
40,
40
],
[
42,
42
],
[
47,
46
],
[
213,
53
],
[
47,
55
],
[
47,
56
],
[
47,
57
],
[
60,
59
],
[
64,
63
],
[
46,
69
],
[
55,
70
],
[
59,
74
],
[
59,
79
],
[
63,
81
],
[
63,
83
],
[
216,
84
],
[
87,
86
],
[
46,
92
],
[
55,
93
],
[
101,
96
],
[
86,
97
],
[
46,
99
],
[
55,
100
],
[
59,
104
],
[
46,
106
],
[
55,
107
],
[
216,
109
],
[
216,
111
],
[
114,
113
],
[
46,
117
],
[
55,
118
],
[
127,
122
],
[
86,
123
],
[
113,
125
],
[
86,
130
],
[
113,
131
],
[
113,
132
],
[
216,
133
],
[
136,
135
],
[
139,
138
],
[
55,
142
],
[
57,
143
],
[
146,
145
],
[
46,
150
],
[
56,
151
],
[
57,
153
],
[
138,
154
],
[
157,
156
],
[
46,
159
],
[
56,
160
],
[
164,
163
],
[
56,
169
],
[
55,
171
],
[
57,
172
],
[
138,
174
],
[
177,
176
],
[
56,
178
],
[
182,
181
],
[
219,
185
],
[
59,
186
],
[
86,
187
],
[
145,
188
],
[
156,
189
],
[
219,
191
],
[
59,
192
],
[
86,
193
],
[
163,
194
],
[
176,
195
],
[
216,
196
],
[
181,
200
],
[
135,
200
],
[
216,
201
],
[
210,
207
],
[
212,
213
],
[
215,
216
]
] | [
"import sys\ninput=sys.stdin.readline\n\nmod = 10**9+7\ndef nCr(fact, inv, n, r):\n return fact[n] * inv[r] * inv[n-r] % mod\n\ndef main():\n H,W,A,B = map(int,input().split())\n fact = [1]\n for i in range(1, H+W+1):\n fact.append(fact[i-1] * i % mod)\n \n inv = [0] * (H+W+1)\n inv[H+W] = pow(fact[H+W], mod-2, mod) # フェルマーの小定理より a**(mod-2)はaの逆元\n for i in range(H+W, 0, -1):\n inv[i-1] = inv[i] * i % mod\n\n ans = 0\n for i in range(W-B):\n n0 = H-A-1+B+i\n r0 = H-A-1\n n1 = A-1+W-B-1-i\n r1 = A-1\n ans += nCr(fact, inv, n0, r0) * nCr(fact, inv, n1, r1) % mod\n print(ans%mod)\n\nif __name__ == '__main__':\n main()",
"import sys",
"sys",
"input=sys.stdin.readline",
"input",
"sys.stdin.readline",
"sys.stdin",
"sys",
"stdin",
"readline",
"mod = 10**9+7",
"mod",
"10**9+7",
"10**9",
"10",
"9",
"7",
"def nCr(fact, inv, n, r):\n return fact[n] * inv[r] * inv[n-r] % mod",
"nCr",
"return fact[n] * inv[r] * inv[n-r] % mod",
"fact[n] * inv[r] * inv[n-r] % mod",
"fact[n] * inv[r] * inv[n-r]",
"fact[n] * inv[r]",
"fact[n]",
"fact",
"n",
"inv[r]",
"inv",
"r",
"inv[n-r]",
"inv",
"n-r",
"n",
"r",
"mod",
"fact",
"fact",
"inv",
"inv",
"n",
"n",
"r",
"r",
"def main():\n H,W,A,B = map(int,input().split())\n fact = [1]\n for i in range(1, H+W+1):\n fact.append(fact[i-1] * i % mod)\n \n inv = [0] * (H+W+1)\n inv[H+W] = pow(fact[H+W], mod-2, mod) # フェルマーの小定理より a**(mod-2)はaの逆元\n for i in range(H+W, 0, -1):\n inv[i-1] = inv[i] * i % mod\n\n ans = 0\n for i in range(W-B):\n n0 = H-A-1+B+i\n r0 = H-A-1\n n1 = A-1+W-B-1-i\n r1 = A-1\n ans += nCr(fact, inv, n0, r0) * nCr(fact, inv, n1, r1) % mod\n print(ans%mod)",
"main",
"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, H+W+1):\n fact.append(fact[i-1] * i % mod)\n \n ",
"i",
"range(1, H+W+1)",
"range",
"1",
"H+W+1",
"H+W",
"H",
"W",
"1",
"fact.append(fact[i-1] * i % mod)",
"fact.append",
"fact",
"append",
"fact[i-1] * i % mod",
"fact[i-1] * i",
"fact[i-1]",
"fact",
"i-1",
"i",
"1",
"i",
"mod",
"inv = [0] * (H+W+1)",
"inv",
"[0] * (H+W+1)",
"[0]",
"0",
"H+W+1",
"H+W",
"H",
"W",
"1",
"inv[H+W] = pow(fact[H+W], mod-2, mod)",
"inv[H+W]",
"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(H+W, 0, -1):\n inv[i-1] = inv[i] * i % mod\n\n ",
"i",
"range(H+W, 0, -1)",
"range",
"H+W",
"H",
"W",
"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",
"ans = 0",
"ans",
"0",
"for i in range(W-B):\n n0 = H-A-1+B+i\n r0 = H-A-1\n n1 = A-1+W-B-1-i\n r1 = A-1\n ans += nCr(fact, inv, n0, r0) * nCr(fact, inv, n1, r1) % mod\n ",
"i",
"range(W-B)",
"range",
"W-B",
"W",
"B",
"n0 = H-A-1+B+i",
"n0",
"H-A-1+B+i",
"H-A-1+B",
"H-A-1",
"H-A",
"H",
"A",
"1",
"B",
"i",
"r0 = H-A-1",
"r0",
"H-A-1",
"H-A",
"H",
"A",
"1",
"n1 = A-1+W-B-1-i",
"n1",
"A-1+W-B-1-i",
"A-1+W-B-1",
"A-1+W-B",
"A-1+W",
"A-1",
"A",
"1",
"W",
"B",
"1",
"i",
"r1 = A-1",
"r1",
"A-1",
"A",
"1",
"ans += nCr(fact, inv, n0, r0) * nCr(fact, inv, n1, r1) % mod",
"ans",
"nCr(fact, inv, n0, r0) * nCr(fact, inv, n1, r1) % mod",
"nCr(fact, inv, n0, r0) * nCr(fact, inv, n1, r1)",
"nCr(fact, inv, n0, r0)",
"nCr",
"fact",
"inv",
"n0",
"r0",
"nCr(fact, inv, n1, r1)",
"nCr",
"fact",
"inv",
"n1",
"r1",
"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 = map(int,input().split())\n fact = [1]\n for i in range(1, H+W+1):\n fact.append(fact[i-1] * i % mod)\n \n inv = [0] * (H+W+1)\n inv[H+W] = pow(fact[H+W], mod-2, mod) # フェルマーの小定理より a**(mod-2)はaの逆元\n for i in range(H+W, 0, -1):\n inv[i-1] = inv[i] * i % mod\n\n ans = 0\n for i in range(W-B):\n n0 = H-A-1+B+i\n r0 = H-A-1\n n1 = A-1+W-B-1-i\n r1 = A-1\n ans += nCr(fact, inv, n0, r0) * nCr(fact, inv, n1, r1) % mod\n print(ans%mod)",
"def main():\n H,W,A,B = map(int,input().split())\n fact = [1]\n for i in range(1, H+W+1):\n fact.append(fact[i-1] * i % mod)\n \n inv = [0] * (H+W+1)\n inv[H+W] = pow(fact[H+W], mod-2, mod) # フェルマーの小定理より a**(mod-2)はaの逆元\n for i in range(H+W, 0, -1):\n inv[i-1] = inv[i] * i % mod\n\n ans = 0\n for i in range(W-B):\n n0 = H-A-1+B+i\n r0 = H-A-1\n n1 = A-1+W-B-1-i\n r1 = A-1\n ans += nCr(fact, inv, n0, r0) * nCr(fact, inv, n1, r1) % mod\n print(ans%mod)",
"main",
"input=sys.stdin.readline",
"sys.stdin.readline",
"input",
"mod = 10**9+7",
"10**9+7",
"mod",
"def nCr(fact, inv, n, r):\n return fact[n] * inv[r] * inv[n-r] % mod",
"def nCr(fact, inv, n, r):\n return fact[n] * inv[r] * inv[n-r] % mod",
"nCr"
] | import sys
input=sys.stdin.readline
mod = 10**9+7
def nCr(fact, inv, n, r):
return fact[n] * inv[r] * inv[n-r] % mod
def main():
H,W,A,B = map(int,input().split())
fact = [1]
for i in range(1, H+W+1):
fact.append(fact[i-1] * i % mod)
inv = [0] * (H+W+1)
inv[H+W] = pow(fact[H+W], mod-2, mod) # フェルマーの小定理より a**(mod-2)はaの逆元
for i in range(H+W, 0, -1):
inv[i-1] = inv[i] * i % mod
ans = 0
for i in range(W-B):
n0 = H-A-1+B+i
r0 = H-A-1
n1 = A-1+W-B-1-i
r1 = A-1
ans += nCr(fact, inv, n0, r0) * nCr(fact, inv, n1, r1) % mod
print(ans%mod)
if __name__ == '__main__':
main()
|
[
7,
12,
13,
0,
13,
4,
13,
13,
4,
18,
4,
13,
13,
13,
13,
13,
0,
13,
2,
4,
13,
17,
17,
17,
0,
13,
17,
0,
13,
39,
13,
28,
13,
4,
13,
17,
2,
2,
13,
13,
17,
0,
13,
2,
2,
13,
13,
13,
4,
18,
13,
13,
13,
0,
13,
4,
13,
2,
2,
13,
13,
17,
13,
0,
13,
39,
13,
28,
13,
4,
13,
2,
2,
13,
13,
17,
17,
17,
0,
13,
2,
2,
13,
13,
13,
4,
18,
13,
13,
13,
0,
13,
18,
13,
39,
17,
0,
13,
2,
2,
2,
18,
13,
2,
2,
13,
13,
17,
18,
13,
2,
13,
17,
18,
13,
2,
13,
17,
13,
0,
13,
17,
28,
13,
4,
13,
13,
0,
13,
2,
2,
2,
18,
13,
2,
2,
2,
13,
17,
13,
13,
18,
13,
13,
18,
13,
2,
2,
13,
17,
13,
13,
0,
13,
2,
2,
2,
18,
13,
2,
2,
2,
2,
13,
17,
13,
17,
13,
18,
13,
2,
13,
17,
18,
13,
2,
2,
13,
17,
13,
13,
0,
13,
2,
13,
13,
0,
13,
13,
29,
2,
2,
13,
13,
13,
12,
13,
14,
2,
13,
17,
14,
2,
13,
17,
14,
2,
2,
13,
17,
17,
14,
2,
2,
13,
17,
17,
23,
13,
23,
13,
23,
13,
12,
13,
0,
13,
17,
28,
13,
4,
13,
17,
2,
13,
17,
0,
13,
2,
2,
13,
13,
13,
29,
4,
13,
13,
2,
13,
17,
13,
23,
13,
23,
13,
14,
2,
13,
17,
4,
13,
4,
13,
10,
12,
13,
10,
12,
13,
10,
12,
13
] | [
[
5,
4
],
[
5,
13
],
[
5,
14
],
[
5,
15
],
[
18,
17
],
[
26,
25
],
[
29,
28
],
[
33,
32
],
[
4,
38
],
[
13,
39
],
[
43,
42
],
[
25,
45
],
[
42,
45
],
[
32,
46
],
[
17,
47
],
[
28,
50
],
[
42,
52
],
[
25,
52
],
[
55,
54
],
[
4,
59
],
[
13,
60
],
[
17,
62
],
[
65,
64
],
[
69,
68
],
[
4,
73
],
[
13,
74
],
[
80,
79
],
[
54,
82
],
[
42,
82
],
[
25,
82
],
[
79,
82
],
[
68,
83
],
[
17,
84
],
[
64,
87
],
[
79,
89
],
[
54,
89
],
[
42,
89
],
[
25,
89
],
[
92,
91
],
[
64,
93
],
[
98,
97
],
[
28,
102
],
[
4,
105
],
[
13,
106
],
[
91,
109
],
[
64,
109
],
[
4,
111
],
[
91,
114
],
[
64,
114
],
[
13,
116
],
[
17,
118
],
[
121,
120
],
[
124,
123
],
[
15,
126
],
[
129,
128
],
[
28,
133
],
[
4,
137
],
[
14,
139
],
[
123,
140
],
[
91,
142
],
[
64,
142
],
[
123,
143
],
[
91,
145
],
[
64,
145
],
[
4,
148
],
[
14,
150
],
[
17,
151
],
[
154,
153
],
[
28,
158
],
[
14,
163
],
[
13,
165
],
[
123,
167
],
[
91,
169
],
[
64,
169
],
[
14,
171
],
[
91,
174
],
[
64,
174
],
[
13,
177
],
[
123,
179
],
[
17,
180
],
[
183,
182
],
[
128,
184
],
[
153,
185
],
[
188,
187
],
[
17,
188
],
[
97,
192
],
[
187,
193
],
[
182,
193
],
[
120,
193
],
[
17,
194
],
[
220,
199
],
[
220,
203
],
[
220,
208
],
[
220,
214
],
[
218,
218
],
[
220,
220
],
[
222,
222
],
[
227,
226
],
[
230,
229
],
[
252,
234
],
[
238,
237
],
[
226,
240
],
[
237,
240
],
[
229,
241
],
[
254,
242
],
[
268,
245
],
[
237,
246
],
[
226,
246
],
[
254,
248
],
[
254,
250
],
[
252,
252
],
[
254,
254
],
[
271,
262
]
] | [
"def main():\n\n H, W, A, B = map(int, input().split())\n mod = pow(10, 9) + 7\n\n v = 1\n fs = [v]\n for i in range(1, H+W-1):\n v = (v * i) % mod\n fs.append(v)\n\n v = invfactorial(H+W-2, mod)\n invfs = [v]\n for i in range(H+W-2, 0, -1):\n v = (v * i) % mod\n invfs.append(v)\n invfs = invfs[::-1]\n\n tot = (fs[H+W-2] * invfs[H-1] * invfs[W-1] ) % mod\n subtract = 0\n for b in range(B):\n v1 = (fs[H-1-A+b]*invfs[b]*invfs[H-1-A]) % mod\n v2 = (fs[A-1+W-1-b] * invfs[A-1] * invfs[W-1-b]) % mod\n subtract += v1 * v2\n subtract %= mod\n # print(tot, subtract)\n return (tot - subtract) % mod\n\n\ndef powquick(x, y, mod):\n if y == 0: return 1\n elif y == 1: return x % mod\n elif y % 2 == 0: return pow(powquick(x, y // 2, mod) , 2) % mod\n elif y % 2 == 1: return (x * pow(powquick(x, y // 2, mod), 2)) % mod\n\ndef invfactorial(x, mod):\n v = 1\n for i in range(1, x+1):\n v = (v * i) % mod\n return powquick(v, mod-2, mod)\n\n\n\nif __name__ == '__main__':\n print(main())",
"def main():\n\n H, W, A, B = map(int, input().split())\n mod = pow(10, 9) + 7\n\n v = 1\n fs = [v]\n for i in range(1, H+W-1):\n v = (v * i) % mod\n fs.append(v)\n\n v = invfactorial(H+W-2, mod)\n invfs = [v]\n for i in range(H+W-2, 0, -1):\n v = (v * i) % mod\n invfs.append(v)\n invfs = invfs[::-1]\n\n tot = (fs[H+W-2] * invfs[H-1] * invfs[W-1] ) % mod\n subtract = 0\n for b in range(B):\n v1 = (fs[H-1-A+b]*invfs[b]*invfs[H-1-A]) % mod\n v2 = (fs[A-1+W-1-b] * invfs[A-1] * invfs[W-1-b]) % mod\n subtract += v1 * v2\n subtract %= mod\n # print(tot, subtract)\n return (tot - subtract) % mod",
"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 = pow(10, 9) + 7",
"mod",
"pow(10, 9) + 7",
"pow(10, 9)",
"pow",
"10",
"9",
"7",
"v = 1",
"v",
"1",
"fs = [v]",
"fs",
"[v]",
"v",
"for i in range(1, H+W-1):\n v = (v * i) % mod\n fs.append(v)\n\n ",
"i",
"range(1, H+W-1)",
"range",
"1",
"H+W-1",
"H+W",
"H",
"W",
"1",
"v = (v * i) % mod",
"v",
"(v * i) % mod",
"v * i",
"v",
"i",
"mod",
"fs.append(v)",
"fs.append",
"fs",
"append",
"v",
"v = invfactorial(H+W-2, mod)",
"v",
"invfactorial(H+W-2, mod)",
"invfactorial",
"H+W-2",
"H+W",
"H",
"W",
"2",
"mod",
"invfs = [v]",
"invfs",
"[v]",
"v",
"for i in range(H+W-2, 0, -1):\n v = (v * i) % mod\n invfs.append(v)\n ",
"i",
"range(H+W-2, 0, -1)",
"range",
"H+W-2",
"H+W",
"H",
"W",
"2",
"0",
"-1",
"v = (v * i) % mod",
"v",
"(v * i) % mod",
"v * i",
"v",
"i",
"mod",
"invfs.append(v)",
"invfs.append",
"invfs",
"append",
"v",
"invfs = invfs[::-1]",
"invfs",
"invfs[::-1]",
"invfs",
"::-1",
"-1",
"tot = (fs[H+W-2] * invfs[H-1] * invfs[W-1] ) % mod",
"tot",
"(fs[H+W-2] * invfs[H-1] * invfs[W-1] ) % mod",
"fs[H+W-2] * invfs[H-1] * invfs[W-1]",
"fs[H+W-2] * invfs[H-1]",
"fs[H+W-2]",
"fs",
"H+W-2",
"H+W",
"H",
"W",
"2",
"invfs[H-1]",
"invfs",
"H-1",
"H",
"1",
"invfs[W-1]",
"invfs",
"W-1",
"W",
"1",
"mod",
"subtract = 0",
"subtract",
"0",
"for b in range(B):\n v1 = (fs[H-1-A+b]*invfs[b]*invfs[H-1-A]) % mod\n v2 = (fs[A-1+W-1-b] * invfs[A-1] * invfs[W-1-b]) % mod\n subtract += v1 * v2\n subtract %= mod\n # print(tot, subtract)\n ",
"b",
"range(B)",
"range",
"B",
"v1 = (fs[H-1-A+b]*invfs[b]*invfs[H-1-A]) % mod",
"v1",
"(fs[H-1-A+b]*invfs[b]*invfs[H-1-A]) % mod",
"fs[H-1-A+b]*invfs[b]*invfs[H-1-A]",
"fs[H-1-A+b]*invfs[b]",
"fs[H-1-A+b]",
"fs",
"H-1-A+b",
"H-1-A",
"H-1",
"H",
"1",
"A",
"b",
"invfs[b]",
"invfs",
"b",
"invfs[H-1-A]",
"invfs",
"H-1-A",
"H-1",
"H",
"1",
"A",
"mod",
"v2 = (fs[A-1+W-1-b] * invfs[A-1] * invfs[W-1-b]) % mod",
"v2",
"(fs[A-1+W-1-b] * invfs[A-1] * invfs[W-1-b]) % mod",
"fs[A-1+W-1-b] * invfs[A-1] * invfs[W-1-b]",
"fs[A-1+W-1-b] * invfs[A-1]",
"fs[A-1+W-1-b]",
"fs",
"A-1+W-1-b",
"A-1+W-1",
"A-1+W",
"A-1",
"A",
"1",
"W",
"1",
"b",
"invfs[A-1]",
"invfs",
"A-1",
"A",
"1",
"invfs[W-1-b]",
"invfs",
"W-1-b",
"W-1",
"W",
"1",
"b",
"mod",
"subtract += v1 * v2",
"subtract",
"v1 * v2",
"v1",
"v2",
"subtract %= mod",
"subtract",
"mod",
"return (tot - subtract) % mod",
"(tot - subtract) % mod",
"tot - subtract",
"tot",
"subtract",
"mod",
"def powquick(x, y, mod):\n if y == 0: return 1\n elif y == 1: return x % mod\n elif y % 2 == 0: return pow(powquick(x, y // 2, mod) , 2) % mod\n elif y % 2 == 1: return (x * pow(powquick(x, y // 2, mod), 2)) % mod",
"powquick",
"if y == 0: return 1\n elif y == 1: return x % mod\n elif y % 2 == 0: return pow(powquick(x, y // 2, mod) , 2) % mod\n elif y % 2 == 1: return (x * pow(powquick(x, y // 2, mod), 2)) % mod",
"y == 0",
"y",
"0",
"elif y == 1: return x % mod\n ",
"y == 1",
"y",
"1",
"elif y % 2 == 0: return pow(powquick(x, y // 2, mod) , 2) % mod\n ",
"y % 2 == 0",
"y % 2",
"y",
"2",
"0",
"elif y % 2 == 1: return (x * pow(powquick(x, y // 2, mod), 2)) %",
"y % 2 == 1",
"y % 2",
"y",
"2",
"1",
"x",
"x",
"y",
"y",
"mod",
"mod",
"def invfactorial(x, mod):\n v = 1\n for i in range(1, x+1):\n v = (v * i) % mod\n return powquick(v, mod-2, mod)",
"invfactorial",
"v = 1",
"v",
"1",
"for i in range(1, x+1):\n v = (v * i) % mod\n ",
"i",
"range(1, x+1)",
"range",
"1",
"x+1",
"x",
"1",
"v = (v * i) % mod",
"v",
"(v * i) % mod",
"v * i",
"v",
"i",
"mod",
"return powquick(v, mod-2, mod)",
"powquick(v, mod-2, mod)",
"powquick",
"v",
"mod-2",
"mod",
"2",
"mod",
"x",
"x",
"mod",
"mod",
"if __name__ == '__main__':\n print(main())",
"__name__ == '__main__'",
"__name__",
"'__main__'",
"print(main())",
"print",
"main()",
"main",
"def invfactorial(x, mod):\n v = 1\n for i in range(1, x+1):\n v = (v * i) % mod\n return powquick(v, mod-2, mod)",
"def invfactorial(x, mod):\n v = 1\n for i in range(1, x+1):\n v = (v * i) % mod\n return powquick(v, mod-2, mod)",
"invfactorial",
"def powquick(x, y, mod):\n if y == 0: return 1\n elif y == 1: return x % mod\n elif y % 2 == 0: return pow(powquick(x, y // 2, mod) , 2) % mod\n elif y % 2 == 1: return (x * pow(powquick(x, y // 2, mod), 2)) % mod",
"def powquick(x, y, mod):\n if y == 0: return 1\n elif y == 1: return x % mod\n elif y % 2 == 0: return pow(powquick(x, y // 2, mod) , 2) % mod\n elif y % 2 == 1: return (x * pow(powquick(x, y // 2, mod), 2)) % mod",
"powquick",
"def main():\n\n H, W, A, B = map(int, input().split())\n mod = pow(10, 9) + 7\n\n v = 1\n fs = [v]\n for i in range(1, H+W-1):\n v = (v * i) % mod\n fs.append(v)\n\n v = invfactorial(H+W-2, mod)\n invfs = [v]\n for i in range(H+W-2, 0, -1):\n v = (v * i) % mod\n invfs.append(v)\n invfs = invfs[::-1]\n\n tot = (fs[H+W-2] * invfs[H-1] * invfs[W-1] ) % mod\n subtract = 0\n for b in range(B):\n v1 = (fs[H-1-A+b]*invfs[b]*invfs[H-1-A]) % mod\n v2 = (fs[A-1+W-1-b] * invfs[A-1] * invfs[W-1-b]) % mod\n subtract += v1 * v2\n subtract %= mod\n # print(tot, subtract)\n return (tot - subtract) % mod",
"def main():\n\n H, W, A, B = map(int, input().split())\n mod = pow(10, 9) + 7\n\n v = 1\n fs = [v]\n for i in range(1, H+W-1):\n v = (v * i) % mod\n fs.append(v)\n\n v = invfactorial(H+W-2, mod)\n invfs = [v]\n for i in range(H+W-2, 0, -1):\n v = (v * i) % mod\n invfs.append(v)\n invfs = invfs[::-1]\n\n tot = (fs[H+W-2] * invfs[H-1] * invfs[W-1] ) % mod\n subtract = 0\n for b in range(B):\n v1 = (fs[H-1-A+b]*invfs[b]*invfs[H-1-A]) % mod\n v2 = (fs[A-1+W-1-b] * invfs[A-1] * invfs[W-1-b]) % mod\n subtract += v1 * v2\n subtract %= mod\n # print(tot, subtract)\n return (tot - subtract) % mod",
"main"
] | def main():
H, W, A, B = map(int, input().split())
mod = pow(10, 9) + 7
v = 1
fs = [v]
for i in range(1, H+W-1):
v = (v * i) % mod
fs.append(v)
v = invfactorial(H+W-2, mod)
invfs = [v]
for i in range(H+W-2, 0, -1):
v = (v * i) % mod
invfs.append(v)
invfs = invfs[::-1]
tot = (fs[H+W-2] * invfs[H-1] * invfs[W-1] ) % mod
subtract = 0
for b in range(B):
v1 = (fs[H-1-A+b]*invfs[b]*invfs[H-1-A]) % mod
v2 = (fs[A-1+W-1-b] * invfs[A-1] * invfs[W-1-b]) % mod
subtract += v1 * v2
subtract %= mod
# print(tot, subtract)
return (tot - subtract) % mod
def powquick(x, y, mod):
if y == 0: return 1
elif y == 1: return x % mod
elif y % 2 == 0: return pow(powquick(x, y // 2, mod) , 2) % mod
elif y % 2 == 1: return (x * pow(powquick(x, y // 2, mod), 2)) % mod
def invfactorial(x, mod):
v = 1
for i in range(1, x+1):
v = (v * i) % mod
return powquick(v, mod-2, mod)
if __name__ == '__main__':
print(main()) |
[
7,
15,
13,
15,
13,
15,
13,
4,
18,
13,
13,
17,
15,
15,
15,
15,
15,
15,
15,
0,
13,
2,
2,
17,
17,
17,
0,
13,
4,
13,
13,
4,
18,
4,
13,
13,
13,
13,
13,
0,
13,
2,
39,
17,
2,
17,
17,
28,
13,
4,
13,
17,
2,
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,
0,
13,
17,
28,
13,
4,
13,
13,
13,
0,
13,
2,
2,
4,
13,
2,
2,
2,
13,
13,
17,
13,
13,
4,
13,
2,
2,
2,
2,
13,
17,
13,
13,
17,
2,
13,
17,
13,
0,
13,
13,
0,
13,
13,
4,
13,
13,
10,
4,
13,
10,
2,
13,
10,
2,
13,
10,
4,
13,
10,
12,
13,
10,
13,
13,
10,
4,
13,
10,
2,
13,
10,
4,
13,
10,
13,
13,
10,
17,
13
] | [
[
156,
20
],
[
174,
27
],
[
174,
36
],
[
174,
37
],
[
174,
38
],
[
153,
40
],
[
49,
48
],
[
59,
56
],
[
154,
57
],
[
48,
58
],
[
154,
62
],
[
48,
64
],
[
48,
66
],
[
157,
67
],
[
154,
75
],
[
99,
76
],
[
154,
80
],
[
101,
81
],
[
157,
83
],
[
157,
85
],
[
154,
89
],
[
99,
91
],
[
101,
92
],
[
157,
94
],
[
157,
96
],
[
157,
97
],
[
99,
99
],
[
101,
101
],
[
180,
103
],
[
107,
106
],
[
169,
109
],
[
151,
110
],
[
171,
112
],
[
163,
116
],
[
160,
120
],
[
175,
121
],
[
106,
123
],
[
106,
124
],
[
163,
126
],
[
175,
131
],
[
151,
133
],
[
106,
134
],
[
175,
137
],
[
157,
139
],
[
177,
141
],
[
172,
142
],
[
165,
144
],
[
157,
145
],
[
166,
148
],
[
178,
148
],
[
181,
148
],
[
174,
151
],
[
153,
154
],
[
156,
157
],
[
174,
160
],
[
157,
165
],
[
165,
166
],
[
174,
169
],
[
171,
172
],
[
174,
175
],
[
172,
177
],
[
177,
178
],
[
180,
181
]
] | [
"#!/usr/bin/env python3\n#ABC42 D\n\nimport sys\nimport math\nimport bisect\nsys.setrecursionlimit(1000000000)\nfrom heapq import heappush, heappop\nfrom collections import defaultdict\nfrom itertools import accumulate\nfrom collections import Counter\nfrom collections import deque\nfrom operator import itemgetter\nfrom itertools import permutations\nmod = 10**9 + 7\n\nh,w,a,b = map(int,input().split())\n\nfact = [1]*(200000+1)\nfor i in range(1,200000+1):\n fact[i] = fact[i-1]*(i) % mod\n\ndef comb(n,r):\n return fact[n] * pow(fact[r],mod-2,mod) * pow(fact[n-r],mod-2,mod) % mod\nans = 0\nfor i in range(b,w):\n x = comb(h-a-1+i,i)*comb(a-1+w-i-1,a-1) % mod\n ans += x\n ans %= mod\nprint(ans)",
"import sys",
"sys",
"import math",
"math",
"import bisect",
"bisect",
"sys.setrecursionlimit(1000000000)",
"sys.setrecursionlimit",
"sys",
"setrecursionlimit",
"1000000000",
"from heapq import heappush, heappop",
"from collections import defaultdict",
"from itertools import accumulate",
"from collections import Counter",
"from collections import deque",
"from operator import itemgetter",
"from itertools import permutations",
"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",
"fact = [1]*(200000+1)",
"fact",
"[1]*(200000+1)",
"[1]",
"1",
"200000+1",
"200000",
"1",
"for i in range(1,200000+1):\n fact[i] = fact[i-1]*(i) % mod",
"i",
"range(1,200000+1)",
"range",
"1",
"200000+1",
"200000",
"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",
"def comb(n,r):\n return fact[n] * pow(fact[r],mod-2,mod) * pow(fact[n-r],mod-2,mod) % mod",
"comb",
"return fact[n] * pow(fact[r],mod-2,mod) * pow(fact[n-r],mod-2,mod) % mod",
"fact[n] * pow(fact[r],mod-2,mod) * pow(fact[n-r],mod-2,mod) % mod",
"fact[n] * pow(fact[r],mod-2,mod) * pow(fact[n-r],mod-2,mod)",
"fact[n] * pow(fact[r],mod-2,mod)",
"fact[n]",
"fact",
"n",
"pow(fact[r],mod-2,mod)",
"pow",
"fact[r]",
"fact",
"r",
"mod-2",
"mod",
"2",
"mod",
"pow(fact[n-r],mod-2,mod)",
"pow",
"fact[n-r]",
"fact",
"n-r",
"n",
"r",
"mod-2",
"mod",
"2",
"mod",
"mod",
"n",
"n",
"r",
"r",
"ans = 0",
"ans",
"0",
"for i in range(b,w):\n x = comb(h-a-1+i,i)*comb(a-1+w-i-1,a-1) % mod\n ans += x\n ans %= mod",
"i",
"range(b,w)",
"range",
"b",
"w",
"x = comb(h-a-1+i,i)*comb(a-1+w-i-1,a-1) % mod",
"x",
"comb(h-a-1+i,i)*comb(a-1+w-i-1,a-1) % mod",
"comb(h-a-1+i,i)*comb(a-1+w-i-1,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-i-1,a-1)",
"comb",
"a-1+w-i-1",
"a-1+w-i",
"a-1+w",
"a-1",
"a",
"1",
"w",
"i",
"1",
"a-1",
"a",
"1",
"mod",
"ans += x",
"ans",
"x",
"ans %= mod",
"ans",
"mod",
"print(ans)",
"print",
"ans",
"w,a,b = map(int,input().split())",
"map(int,input().split())",
"w",
"fact = [1]*(200000+1)",
"[1]*(200000+1)",
"fact",
"mod = 10**9 + 7",
"10**9 + 7",
"mod",
"h,w,a,b = map(int,input().split())",
"map(int,input().split())",
"h",
"def comb(n,r):\n return fact[n] * pow(fact[r],mod-2,mod) * pow(fact[n-r],mod-2,mod) % mod",
"def comb(n,r):\n return fact[n] * pow(fact[r],mod-2,mod) * pow(fact[n-r],mod-2,mod) % mod",
"comb",
"ans %= mod",
"mod",
"ans",
"b = map(int,input().split())",
"map(int,input().split())",
"b",
"x = comb(h-a-1+i,i)*comb(a-1+w-i-1,a-1) % mod",
"comb(h-a-1+i,i)*comb(a-1+w-i-1,a-1) % mod",
"x",
"a,b = map(int,input().split())",
"map(int,input().split())",
"a",
"ans += x",
"x",
"ans",
"ans = 0",
"0",
"ans"
] | #!/usr/bin/env python3
#ABC42 D
import sys
import math
import bisect
sys.setrecursionlimit(1000000000)
from heapq import heappush, heappop
from collections import defaultdict
from itertools import accumulate
from collections import Counter
from collections import deque
from operator import itemgetter
from itertools import permutations
mod = 10**9 + 7
h,w,a,b = map(int,input().split())
fact = [1]*(200000+1)
for i in range(1,200000+1):
fact[i] = fact[i-1]*(i) % mod
def comb(n,r):
return fact[n] * pow(fact[r],mod-2,mod) * pow(fact[n-r],mod-2,mod) % mod
ans = 0
for i in range(b,w):
x = comb(h-a-1+i,i)*comb(a-1+w-i-1,a-1) % mod
ans += x
ans %= mod
print(ans)
|
[
7,
0,
13,
4,
13,
13,
4,
18,
4,
13,
13,
13,
13,
13,
0,
13,
17,
0,
13,
39,
17,
0,
13,
39,
17,
28,
13,
4,
13,
17,
17,
4,
18,
13,
13,
2,
2,
18,
13,
2,
13,
17,
13,
13,
4,
18,
13,
13,
4,
13,
18,
13,
13,
2,
13,
17,
13,
0,
13,
17,
28,
13,
4,
13,
2,
13,
17,
2,
13,
17,
0,
13,
2,
2,
2,
2,
2,
2,
18,
13,
2,
2,
2,
13,
13,
13,
17,
18,
13,
2,
2,
13,
13,
17,
18,
13,
2,
13,
17,
18,
13,
2,
2,
2,
13,
13,
13,
17,
18,
13,
2,
13,
17,
18,
13,
2,
13,
13,
13,
0,
13,
13,
4,
13,
13,
10,
4,
13,
10,
4,
13,
10,
4,
13,
10,
39,
13,
10,
4,
13,
10,
2,
13,
10,
17,
13,
10,
17,
13,
10,
39,
13,
10,
13,
13
] | [
[
138,
2
],
[
138,
11
],
[
138,
12
],
[
138,
13
],
[
147,
15
],
[
135,
18
],
[
150,
22
],
[
27,
26
],
[
136,
33
],
[
136,
38
],
[
26,
40
],
[
26,
42
],
[
148,
43
],
[
151,
46
],
[
136,
51
],
[
26,
52
],
[
148,
54
],
[
148,
56
],
[
144,
58
],
[
62,
61
],
[
127,
65
],
[
139,
68
],
[
141,
71
],
[
136,
79
],
[
133,
83
],
[
130,
84
],
[
61,
85
],
[
151,
88
],
[
133,
91
],
[
130,
92
],
[
151,
95
],
[
61,
97
],
[
136,
100
],
[
130,
104
],
[
139,
105
],
[
61,
106
],
[
151,
109
],
[
130,
111
],
[
151,
114
],
[
139,
116
],
[
61,
117
],
[
148,
118
],
[
153,
120
],
[
148,
121
],
[
154,
124
],
[
142,
124
],
[
145,
124
],
[
138,
127
],
[
138,
130
],
[
138,
133
],
[
135,
136
],
[
138,
139
],
[
141,
142
],
[
144,
145
],
[
147,
148
],
[
150,
151
],
[
148,
153
],
[
153,
154
]
] | [
"h,w,a,b = map(int,input().split())\n\nMOD = 1000000007\nfac = [1]\ninv = [1]\nfor i in range(1,200010):\n\tfac.append(fac[i-1]*i%MOD)\n\tinv.append(pow(fac[i],MOD-2,MOD))\n\nans = 0\n\nfor i in range(b+1,w+1):\n\tans += fac[h-a+i-2]*inv[h-a-1]*inv[i-1]*fac[a+w-i-1]*inv[a-1]*inv[w-i]%MOD\n\tans %= 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",
"MOD = 1000000007",
"MOD",
"1000000007",
"fac = [1]",
"fac",
"[1]",
"1",
"inv = [1]",
"inv",
"[1]",
"1",
"for i in range(1,200010):\n\tfac.append(fac[i-1]*i%MOD)\n\tinv.append(pow(fac[i],MOD-2,MOD))",
"i",
"range(1,200010)",
"range",
"1",
"200010",
"fac.append(fac[i-1]*i%MOD)",
"fac.append",
"fac",
"append",
"fac[i-1]*i%MOD",
"fac[i-1]*i",
"fac[i-1]",
"fac",
"i-1",
"i",
"1",
"i",
"MOD",
"inv.append(pow(fac[i],MOD-2,MOD))",
"inv.append",
"inv",
"append",
"pow(fac[i],MOD-2,MOD)",
"pow",
"fac[i]",
"fac",
"i",
"MOD-2",
"MOD",
"2",
"MOD",
"ans = 0",
"ans",
"0",
"for i in range(b+1,w+1):\n\tans += fac[h-a+i-2]*inv[h-a-1]*inv[i-1]*fac[a+w-i-1]*inv[a-1]*inv[w-i]%MOD\n\tans %= MOD",
"i",
"range(b+1,w+1)",
"range",
"b+1",
"b",
"1",
"w+1",
"w",
"1",
"ans += fac[h-a+i-2]*inv[h-a-1]*inv[i-1]*fac[a+w-i-1]*inv[a-1]*inv[w-i]%MOD",
"ans",
"fac[h-a+i-2]*inv[h-a-1]*inv[i-1]*fac[a+w-i-1]*inv[a-1]*inv[w-i]%MOD",
"fac[h-a+i-2]*inv[h-a-1]*inv[i-1]*fac[a+w-i-1]*inv[a-1]*inv[w-i]",
"fac[h-a+i-2]*inv[h-a-1]*inv[i-1]*fac[a+w-i-1]*inv[a-1]",
"fac[h-a+i-2]*inv[h-a-1]*inv[i-1]*fac[a+w-i-1]",
"fac[h-a+i-2]*inv[h-a-1]*inv[i-1]",
"fac[h-a+i-2]*inv[h-a-1]",
"fac[h-a+i-2]",
"fac",
"h-a+i-2",
"h-a+i",
"h-a",
"h",
"a",
"i",
"2",
"inv[h-a-1]",
"inv",
"h-a-1",
"h-a",
"h",
"a",
"1",
"inv[i-1]",
"inv",
"i-1",
"i",
"1",
"fac[a+w-i-1]",
"fac",
"a+w-i-1",
"a+w-i",
"a+w",
"a",
"w",
"i",
"1",
"inv[a-1]",
"inv",
"a-1",
"a",
"1",
"inv[w-i]",
"inv",
"w-i",
"w",
"i",
"MOD",
"ans %= MOD",
"ans",
"MOD",
"print(ans)",
"print",
"ans",
"b = map(int,input().split())",
"map(int,input().split())",
"b",
"a,b = map(int,input().split())",
"map(int,input().split())",
"a",
"h,w,a,b = map(int,input().split())",
"map(int,input().split())",
"h",
"fac = [1]",
"[1]",
"fac",
"w,a,b = map(int,input().split())",
"map(int,input().split())",
"w",
"ans += fac[h-a+i-2]*inv[h-a-1]*inv[i-1]*fac[a+w-i-1]*inv[a-1]*inv[w-i]%MOD",
"fac[h-a+i-2]*inv[h-a-1]*inv[i-1]*fac[a+w-i-1]*inv[a-1]*inv[w-i]%MOD",
"ans",
"ans = 0",
"0",
"ans",
"MOD = 1000000007",
"1000000007",
"MOD",
"inv = [1]",
"[1]",
"inv",
"ans %= MOD",
"MOD",
"ans"
] | h,w,a,b = map(int,input().split())
MOD = 1000000007
fac = [1]
inv = [1]
for i in range(1,200010):
fac.append(fac[i-1]*i%MOD)
inv.append(pow(fac[i],MOD-2,MOD))
ans = 0
for i in range(b+1,w+1):
ans += fac[h-a+i-2]*inv[h-a-1]*inv[i-1]*fac[a+w-i-1]*inv[a-1]*inv[w-i]%MOD
ans %= MOD
print(ans) |
[
7,
0,
13,
4,
13,
13,
4,
18,
4,
13,
13,
13,
13,
13,
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,
17,
0,
13,
2,
2,
17,
17,
17,
28,
13,
4,
13,
17,
2,
2,
13,
13,
17,
0,
13,
2,
2,
4,
13,
2,
2,
13,
13,
17,
4,
13,
2,
13,
17,
2,
13,
17,
4,
13,
2,
2,
2,
2,
13,
13,
13,
13,
17,
4,
13,
2,
13,
13,
2,
2,
13,
13,
17,
13,
0,
13,
2,
13,
13,
4,
13,
13,
10,
4,
13,
10,
2,
13,
10,
4,
13,
10,
17,
13,
10,
4,
13,
10,
2,
13,
10,
12,
13,
10,
2,
13,
10,
2,
13,
10,
4,
13,
10,
2,
13,
10,
2,
13,
10,
2,
13
] | [
[
236,
2
],
[
236,
11
],
[
236,
12
],
[
236,
13
],
[
224,
15
],
[
242,
22
],
[
233,
29
],
[
225,
34
],
[
212,
37
],
[
225,
42
],
[
46,
45
],
[
225,
50
],
[
56,
53
],
[
234,
54
],
[
45,
55
],
[
234,
59
],
[
45,
61
],
[
45,
63
],
[
243,
64
],
[
69,
66
],
[
213,
67
],
[
225,
68
],
[
234,
72
],
[
225,
73
],
[
243,
75
],
[
243,
77
],
[
80,
79
],
[
225,
82
],
[
91,
86
],
[
213,
87
],
[
79,
89
],
[
213,
94
],
[
79,
95
],
[
79,
96
],
[
243,
97
],
[
138,
103
],
[
138,
106
],
[
136,
107
],
[
112,
111
],
[
234,
113
],
[
136,
114
],
[
117,
116
],
[
213,
118
],
[
138,
119
],
[
122,
121
],
[
243,
122
],
[
125,
124
],
[
213,
126
],
[
136,
128
],
[
138,
129
],
[
132,
131
],
[
243,
132
],
[
131,
134
],
[
124,
134
],
[
121,
134
],
[
116,
134
],
[
111,
134
],
[
136,
136
],
[
138,
138
],
[
218,
140
],
[
230,
143
],
[
151,
150
],
[
216,
156
],
[
222,
157
],
[
239,
160
],
[
228,
164
],
[
150,
167
],
[
210,
168
],
[
150,
173
],
[
210,
176
],
[
228,
179
],
[
216,
184
],
[
150,
185
],
[
237,
186
],
[
210,
187
],
[
216,
192
],
[
150,
193
],
[
237,
196
],
[
210,
197
],
[
231,
199
],
[
245,
201
],
[
240,
203
],
[
219,
203
],
[
246,
203
],
[
231,
204
],
[
246,
207
],
[
240,
207
],
[
219,
207
],
[
236,
210
],
[
212,
213
],
[
236,
216
],
[
218,
219
],
[
236,
222
],
[
224,
225
],
[
230,
231
],
[
233,
234
],
[
236,
237
],
[
239,
240
],
[
242,
243
],
[
245,
246
]
] | [
"h,w,a,b=map(int,input().split())\n\nU = 2*10**5\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\tfact_inv[i-1] = (fact_inv[i]*i)%MOD\n \ndef comb(n,k):\n if k < 0 or k > n:\n return 0\n x = fact[n]\n x *= fact_inv[k]\n x %= MOD\n x *= fact_inv[n-k]\n x %= MOD\n return x\nans=0\nmod=10**9+7\nfor i in range(1,h-a+1):\n ans+=(comb(i+b-2,min(i-1,b-1))*comb(h-i+w-b-1,min(h-i,w-b-1)))%mod\n ans=ans%mod\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",
"U = 2*10**5",
"U",
"2*10**5",
"2",
"10**5",
"10",
"5",
"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\tfact_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 x = fact[n]\n x *= fact_inv[k]\n x %= MOD\n x *= fact_inv[n-k]\n x %= MOD\n return x",
"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",
"x = fact[n]",
"x",
"fact[n]",
"fact",
"n",
"x *= fact_inv[k]",
"x",
"fact_inv[k]",
"fact_inv",
"k",
"x %= MOD",
"x",
"MOD",
"x *= fact_inv[n-k]",
"x",
"fact_inv[n-k]",
"fact_inv",
"n-k",
"n",
"k",
"x %= MOD",
"x",
"MOD",
"return x",
"x",
"n",
"n",
"k",
"k",
"ans=0",
"ans",
"0",
"mod=10**9+7",
"mod",
"10**9+7",
"10**9",
"10",
"9",
"7",
"for i in range(1,h-a+1):\n ans+=(comb(i+b-2,min(i-1,b-1))*comb(h-i+w-b-1,min(h-i,w-b-1)))%mod\n ans=ans%mod",
"i",
"range(1,h-a+1)",
"range",
"1",
"h-a+1",
"h-a",
"h",
"a",
"1",
"ans+=(comb(i+b-2,min(i-1,b-1))*comb(h-i+w-b-1,min(h-i,w-b-1)))%mod",
"ans",
"(comb(i+b-2,min(i-1,b-1))*comb(h-i+w-b-1,min(h-i,w-b-1)))%mod",
"comb(i+b-2,min(i-1,b-1))*comb(h-i+w-b-1,min(h-i,w-b-1))",
"comb(i+b-2,min(i-1,b-1))",
"comb",
"i+b-2",
"i+b",
"i",
"b",
"2",
"min(i-1,b-1)",
"min",
"i-1",
"i",
"1",
"b-1",
"b",
"1",
"comb(h-i+w-b-1,min(h-i,w-b-1))",
"comb",
"h-i+w-b-1",
"h-i+w-b",
"h-i+w",
"h-i",
"h",
"i",
"w",
"b",
"1",
"min(h-i,w-b-1)",
"min",
"h-i",
"h",
"i",
"w-b-1",
"w-b",
"w",
"b",
"1",
"mod",
"ans=ans%mod",
"ans",
"ans%mod",
"ans",
"mod",
"print(ans)",
"print",
"ans",
"b=map(int,input().split())",
"map(int,input().split())",
"b",
"fact_inv = [1]*(U+1)",
"[1]*(U+1)",
"fact_inv",
"h,w,a,b=map(int,input().split())",
"map(int,input().split())",
"h",
"ans=0",
"0",
"ans",
"a,b=map(int,input().split())",
"map(int,input().split())",
"a",
"U = 2*10**5",
"2*10**5",
"U",
"def comb(n,k):\n if k < 0 or k > n:\n return 0\n x = fact[n]\n x *= fact_inv[k]\n x %= MOD\n x *= fact_inv[n-k]\n x %= MOD\n return x",
"def comb(n,k):\n if k < 0 or k > n:\n return 0\n x = fact[n]\n x *= fact_inv[k]\n x %= MOD\n x *= fact_inv[n-k]\n x %= MOD\n return x",
"comb",
"mod=10**9+7",
"10**9+7",
"mod",
"fact = [1]*(U+1)",
"[1]*(U+1)",
"fact",
"w,a,b=map(int,input().split())",
"map(int,input().split())",
"w",
"ans+=(comb(i+b-2,min(i-1,b-1))*comb(h-i+w-b-1,min(h-i,w-b-1)))%mod",
"(comb(i+b-2,min(i-1,b-1))*comb(h-i+w-b-1,min(h-i,w-b-1)))%mod",
"ans",
"MOD = 10**9+7",
"10**9+7",
"MOD",
"ans=ans%mod",
"ans%mod",
"ans"
] | h,w,a,b=map(int,input().split())
U = 2*10**5
MOD = 10**9+7
fact = [1]*(U+1)
fact_inv = [1]*(U+1)
for i in range(1,U+1):
fact[i] = (fact[i-1]*i)%MOD
fact_inv[U] = pow(fact[U],MOD-2,MOD)
for i in range(U,0,-1):
fact_inv[i-1] = (fact_inv[i]*i)%MOD
def comb(n,k):
if k < 0 or k > n:
return 0
x = fact[n]
x *= fact_inv[k]
x %= MOD
x *= fact_inv[n-k]
x %= MOD
return x
ans=0
mod=10**9+7
for i in range(1,h-a+1):
ans+=(comb(i+b-2,min(i-1,b-1))*comb(h-i+w-b-1,min(h-i,w-b-1)))%mod
ans=ans%mod
print(ans)
|
[
7,
0,
13,
4,
13,
13,
4,
18,
4,
13,
13,
13,
13,
13,
0,
13,
17,
0,
13,
4,
13,
2,
13,
13,
2,
13,
13,
0,
13,
2,
2,
17,
17,
17,
0,
13,
2,
39,
17,
2,
2,
13,
13,
17,
0,
18,
13,
17,
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,
13,
13,
4,
13,
18,
13,
2,
13,
13,
2,
13,
17,
13,
28,
13,
4,
13,
2,
13,
13,
17,
17,
0,
18,
13,
2,
13,
17,
2,
2,
18,
13,
13,
13,
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,
4,
13,
2,
2,
2,
13,
13,
17,
13,
13,
0,
13,
4,
13,
2,
2,
2,
13,
13,
13,
17,
13,
0,
13,
2,
13,
13,
0,
13,
13,
28,
13,
4,
13,
17,
13,
0,
13,
2,
4,
13,
2,
2,
2,
13,
13,
17,
13,
2,
13,
13,
4,
13,
2,
2,
2,
13,
13,
13,
17,
2,
13,
13,
0,
13,
13,
4,
13,
4,
13,
13,
10,
2,
13,
10,
2,
13,
10,
2,
13,
10,
2,
13,
10,
4,
13,
10,
13,
13,
10,
4,
13,
10,
2,
13,
10,
17,
13,
10,
12,
13,
10,
4,
13,
10,
4,
13,
10,
4,
13,
10,
4,
13,
10,
4,
13,
10,
13,
13
] | [
[
259,
2
],
[
259,
11
],
[
259,
12
],
[
259,
13
],
[
241,
15
],
[
250,
18
],
[
260,
22
],
[
254,
23
],
[
230,
25
],
[
257,
26
],
[
217,
28
],
[
220,
35
],
[
230,
41
],
[
260,
42
],
[
48,
45
],
[
221,
46
],
[
51,
50
],
[
230,
56
],
[
260,
57
],
[
63,
60
],
[
221,
61
],
[
50,
62
],
[
221,
66
],
[
50,
68
],
[
50,
70
],
[
218,
71
],
[
223,
73
],
[
230,
79
],
[
260,
80
],
[
88,
83
],
[
224,
84
],
[
230,
86
],
[
260,
87
],
[
221,
91
],
[
230,
93
],
[
260,
94
],
[
218,
96
],
[
218,
98
],
[
101,
100
],
[
230,
104
],
[
260,
105
],
[
114,
109
],
[
224,
110
],
[
100,
112
],
[
224,
117
],
[
100,
118
],
[
100,
119
],
[
218,
120
],
[
221,
128
],
[
140,
129
],
[
224,
131
],
[
142,
132
],
[
224,
134
],
[
140,
136
],
[
142,
137
],
[
218,
138
],
[
140,
140
],
[
142,
142
],
[
247,
144
],
[
245,
146
],
[
230,
150
],
[
257,
151
],
[
254,
153
],
[
254,
154
],
[
235,
156
],
[
245,
158
],
[
257,
162
],
[
260,
163
],
[
254,
164
],
[
257,
166
],
[
226,
168
],
[
248,
170
],
[
236,
171
],
[
262,
173
],
[
227,
174
],
[
177,
176
],
[
251,
180
],
[
238,
182
],
[
245,
185
],
[
230,
189
],
[
257,
190
],
[
254,
192
],
[
254,
194
],
[
176,
195
],
[
245,
197
],
[
257,
201
],
[
260,
202
],
[
254,
203
],
[
257,
206
],
[
176,
207
],
[
232,
209
],
[
218,
210
],
[
233,
215
],
[
239,
215
],
[
263,
215
],
[
242,
215
],
[
217,
218
],
[
220,
221
],
[
223,
224
],
[
226,
227
],
[
259,
230
],
[
218,
232
],
[
232,
233
],
[
235,
236
],
[
238,
239
],
[
241,
242
],
[
247,
248
],
[
250,
251
],
[
259,
254
],
[
259,
257
],
[
259,
260
],
[
227,
262
],
[
262,
263
]
] | [
"h, w, a, b = map(int, input().split())\nres = 0\nkai = min(w - b, h - a)\nmod = 10 ** 9 + 7\n\nkaijo = [0] * (h + w + 1)\nkaijo[0] = 1\nfor i in range(1, h + w + 1):\n kaijo[i] = (kaijo[i - 1] * i) % mod\ngyaku = [0] * (h + w + 1)\ngyaku[h + w] = pow(kaijo[h + w], mod - 2, mod)\nfor i in range(h + w, 0, -1):\n gyaku[i - 1] = (gyaku[i] * i) % mod\n\n\ndef conb(x, k):\n return (kaijo[x] * gyaku[k] * gyaku[x - k]) % mod\n\n\nconb1 = conb(h - a - 1 + b, b)\nconb2 = conb(a + w - b - 1, a)\ncombi = conb1 * conb2\nres = combi\n\nfor i in range(1, kai):\n res += conb(h - a - 1 + b, b + i) * conb(a + w - b - 1, a + i)\n\nres %= mod\nprint(int(res))",
"h, w, a, b = map(int, input().split())",
"h",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"w",
"a",
"b",
"res = 0",
"res",
"0",
"kai = min(w - b, h - a)",
"kai",
"min(w - b, h - a)",
"min",
"w - b",
"w",
"b",
"h - a",
"h",
"a",
"mod = 10 ** 9 + 7",
"mod",
"10 ** 9 + 7",
"10 ** 9",
"10",
"9",
"7",
"kaijo = [0] * (h + w + 1)",
"kaijo",
"[0] * (h + w + 1)",
"[0]",
"0",
"h + w + 1",
"h + w",
"h",
"w",
"1",
"kaijo[0] = 1",
"kaijo[0]",
"kaijo",
"0",
"1",
"for i in range(1, h + w + 1):\n kaijo[i] = (kaijo[i - 1] * i) % mod",
"i",
"range(1, h + w + 1)",
"range",
"1",
"h + w + 1",
"h + w",
"h",
"w",
"1",
"kaijo[i] = (kaijo[i - 1] * i) % mod",
"kaijo[i]",
"kaijo",
"i",
"(kaijo[i - 1] * i) % mod",
"kaijo[i - 1] * i",
"kaijo[i - 1]",
"kaijo",
"i - 1",
"i",
"1",
"i",
"mod",
"gyaku = [0] * (h + w + 1)",
"gyaku",
"[0] * (h + w + 1)",
"[0]",
"0",
"h + w + 1",
"h + w",
"h",
"w",
"1",
"gyaku[h + w] = pow(kaijo[h + w], mod - 2, mod)",
"gyaku[h + w]",
"gyaku",
"h + w",
"h",
"w",
"pow(kaijo[h + w], mod - 2, mod)",
"pow",
"kaijo[h + w]",
"kaijo",
"h + w",
"h",
"w",
"mod - 2",
"mod",
"2",
"mod",
"for i in range(h + w, 0, -1):\n gyaku[i - 1] = (gyaku[i] * i) % mod",
"i",
"range(h + w, 0, -1)",
"range",
"h + w",
"h",
"w",
"0",
"-1",
"gyaku[i - 1] = (gyaku[i] * i) % mod",
"gyaku[i - 1]",
"gyaku",
"i - 1",
"i",
"1",
"(gyaku[i] * i) % mod",
"gyaku[i] * i",
"gyaku[i]",
"gyaku",
"i",
"i",
"mod",
"def conb(x, k):\n return (kaijo[x] * gyaku[k] * gyaku[x - k]) % mod",
"conb",
"return (kaijo[x] * gyaku[k] * gyaku[x - k]) % mod",
"(kaijo[x] * gyaku[k] * gyaku[x - k]) % mod",
"kaijo[x] * gyaku[k] * gyaku[x - k]",
"kaijo[x] * gyaku[k]",
"kaijo[x]",
"kaijo",
"x",
"gyaku[k]",
"gyaku",
"k",
"gyaku[x - k]",
"gyaku",
"x - k",
"x",
"k",
"mod",
"x",
"x",
"k",
"k",
"conb1 = conb(h - a - 1 + b, b)",
"conb1",
"conb(h - a - 1 + b, b)",
"conb",
"h - a - 1 + b",
"h - a - 1",
"h - a",
"h",
"a",
"1",
"b",
"b",
"conb2 = conb(a + w - b - 1, a)",
"conb2",
"conb(a + w - b - 1, a)",
"conb",
"a + w - b - 1",
"a + w - b",
"a + w",
"a",
"w",
"b",
"1",
"a",
"combi = conb1 * conb2",
"combi",
"conb1 * conb2",
"conb1",
"conb2",
"res = combi",
"res",
"combi",
"for i in range(1, kai):\n res += conb(h - a - 1 + b, b + i) * conb(a + w - b - 1, a + i)",
"i",
"range(1, kai)",
"range",
"1",
"kai",
"res += conb(h - a - 1 + b, b + i) * conb(a + w - b - 1, a + i)",
"res",
"conb(h - a - 1 + b, b + i) * conb(a + w - b - 1, a + i)",
"conb(h - a - 1 + b, b + i)",
"conb",
"h - a - 1 + b",
"h - a - 1",
"h - a",
"h",
"a",
"1",
"b",
"b + i",
"b",
"i",
"conb(a + w - b - 1, a + i)",
"conb",
"a + w - b - 1",
"a + w - b",
"a + w",
"a",
"w",
"b",
"1",
"a + i",
"a",
"i",
"res %= mod",
"res",
"mod",
"print(int(res))",
"print",
"int(res)",
"int",
"res",
"mod = 10 ** 9 + 7",
"10 ** 9 + 7",
"mod",
"kaijo = [0] * (h + w + 1)",
"[0] * (h + w + 1)",
"kaijo",
"gyaku = [0] * (h + w + 1)",
"[0] * (h + w + 1)",
"gyaku",
"combi = conb1 * conb2",
"conb1 * conb2",
"combi",
"h, w, a, b = map(int, input().split())",
"map(int, input().split())",
"h",
"res %= mod",
"mod",
"res",
"conb2 = conb(a + w - b - 1, a)",
"conb(a + w - b - 1, a)",
"conb2",
"res += conb(h - a - 1 + b, b + i) * conb(a + w - b - 1, a + i)",
"conb(h - a - 1 + b, b + i) * conb(a + w - b - 1, a + i)",
"res",
"res = 0",
"0",
"res",
"def conb(x, k):\n return (kaijo[x] * gyaku[k] * gyaku[x - k]) % mod",
"def conb(x, k):\n return (kaijo[x] * gyaku[k] * gyaku[x - k]) % mod",
"conb",
"conb1 = conb(h - a - 1 + b, b)",
"conb(h - a - 1 + b, b)",
"conb1",
"kai = min(w - b, h - a)",
"min(w - b, h - a)",
"kai",
"b = map(int, input().split())",
"map(int, input().split())",
"b",
"a, b = map(int, input().split())",
"map(int, input().split())",
"a",
"w, a, b = map(int, input().split())",
"map(int, input().split())",
"w",
"res = combi",
"combi",
"res"
] | h, w, a, b = map(int, input().split())
res = 0
kai = min(w - b, h - a)
mod = 10 ** 9 + 7
kaijo = [0] * (h + w + 1)
kaijo[0] = 1
for i in range(1, h + w + 1):
kaijo[i] = (kaijo[i - 1] * i) % mod
gyaku = [0] * (h + w + 1)
gyaku[h + w] = pow(kaijo[h + w], mod - 2, mod)
for i in range(h + w, 0, -1):
gyaku[i - 1] = (gyaku[i] * i) % mod
def conb(x, k):
return (kaijo[x] * gyaku[k] * gyaku[x - k]) % mod
conb1 = conb(h - a - 1 + b, b)
conb2 = conb(a + w - b - 1, a)
combi = conb1 * conb2
res = combi
for i in range(1, kai):
res += conb(h - a - 1 + b, b + i) * conb(a + w - b - 1, a + i)
res %= mod
print(int(res))
|
[
7,
6,
13,
12,
13,
0,
18,
13,
13,
39,
17,
28,
13,
4,
13,
17,
2,
13,
17,
4,
18,
18,
13,
13,
13,
2,
2,
18,
18,
13,
13,
17,
13,
13,
0,
18,
13,
13,
39,
4,
13,
18,
18,
13,
13,
17,
2,
13,
17,
13,
28,
13,
18,
4,
13,
17,
2,
13,
17,
39,
17,
4,
18,
18,
13,
13,
13,
2,
2,
18,
18,
13,
13,
17,
13,
13,
4,
18,
18,
13,
13,
13,
23,
13,
23,
13,
23,
13,
12,
13,
29,
18,
18,
13,
13,
13,
23,
13,
23,
13,
12,
13,
29,
18,
18,
13,
13,
13,
23,
13,
23,
13,
12,
13,
29,
2,
2,
2,
2,
18,
18,
13,
13,
13,
18,
18,
13,
13,
2,
13,
13,
13,
18,
18,
13,
13,
13,
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,
4,
13,
2,
13,
13,
13,
0,
13,
17,
28,
13,
4,
13,
13,
13,
0,
13,
2,
2,
13,
2,
4,
18,
13,
13,
2,
2,
2,
13,
13,
17,
13,
13,
4,
18,
13,
13,
2,
2,
2,
2,
13,
17,
13,
13,
17,
2,
2,
13,
13,
17,
13,
4,
13,
13,
10,
4,
13,
10,
4,
13,
10,
17,
13,
10,
4,
13,
10,
4,
13,
10,
2,
13,
10,
4,
13,
10,
2,
13,
10,
6,
13
] | [
[
9,
6
],
[
83,
7
],
[
13,
12
],
[
85,
17
],
[
6,
21
],
[
83,
22
],
[
6,
28
],
[
83,
29
],
[
12,
32
],
[
87,
33
],
[
38,
35
],
[
83,
36
],
[
6,
42
],
[
83,
43
],
[
87,
47
],
[
87,
49
],
[
52,
51
],
[
85,
57
],
[
35,
63
],
[
83,
64
],
[
51,
65
],
[
35,
70
],
[
83,
71
],
[
51,
72
],
[
51,
74
],
[
87,
75
],
[
35,
78
],
[
83,
79
],
[
83,
83
],
[
85,
85
],
[
87,
87
],
[
97,
93
],
[
99,
95
],
[
97,
97
],
[
99,
99
],
[
109,
105
],
[
111,
106
],
[
111,
107
],
[
109,
109
],
[
111,
111
],
[
139,
121
],
[
141,
123
],
[
139,
126
],
[
141,
129
],
[
143,
130
],
[
139,
134
],
[
143,
136
],
[
139,
139
],
[
141,
141
],
[
143,
143
],
[
237,
145
],
[
240,
152
],
[
240,
161
],
[
240,
162
],
[
240,
163
],
[
234,
165
],
[
223,
169
],
[
232,
170
],
[
238,
171
],
[
228,
173
],
[
177,
176
],
[
241,
179
],
[
232,
180
],
[
243,
182
],
[
229,
185
],
[
244,
185
],
[
235,
189
],
[
113,
190
],
[
223,
194
],
[
226,
195
],
[
176,
197
],
[
176,
198
],
[
235,
201
],
[
113,
202
],
[
226,
207
],
[
232,
209
],
[
176,
210
],
[
232,
214
],
[
176,
215
],
[
238,
217
],
[
244,
220
],
[
229,
220
],
[
240,
223
],
[
240,
226
],
[
228,
229
],
[
240,
232
],
[
234,
235
],
[
237,
238
],
[
240,
241
],
[
243,
244
]
] | [
"class Factorial:\n def __init__(self,n,mod):\n self.f=[1]\n for i in range(1,n+1):\n self.f.append(self.f[-1]*i%mod)\n self.i=[pow(self.f[-1],mod-2,mod)]\n for i in range(1,n+1)[::-1]:\n self.i.append(self.i[-1]*i%mod)\n self.i.reverse()\n def factorial(self,i):\n return self.f[i]\n def ifactorial(self,i):\n return self.i[i]\n def comb(self,n,k):\n return self.f[n]*self.i[n-k]%mod*self.i[k]%mod\nmod=10**9+7\nh,w,a,b=map(int,input().split())\nf=Factorial(h+w,mod)\nans=0\nfor i in range(b,w):\n ans=(ans+f.comb(h-a-1+i,i)*f.comb(a-1+w-i-1,w-i-1))%mod\nprint(ans)",
"class Factorial:\n def __init__(self,n,mod):\n self.f=[1]\n for i in range(1,n+1):\n self.f.append(self.f[-1]*i%mod)\n self.i=[pow(self.f[-1],mod-2,mod)]\n for i in range(1,n+1)[::-1]:\n self.i.append(self.i[-1]*i%mod)\n self.i.reverse()\n def factorial(self,i):\n return self.f[i]\n def ifactorial(self,i):\n return self.i[i]\n def comb(self,n,k):\n return self.f[n]*self.i[n-k]%mod*self.i[k]%mod",
"Factorial",
"def __init__(self,n,mod):\n self.f=[1]\n for i in range(1,n+1):\n self.f.append(self.f[-1]*i%mod)\n self.i=[pow(self.f[-1],mod-2,mod)]\n for i in range(1,n+1)[::-1]:\n self.i.append(self.i[-1]*i%mod)\n self.i.reverse()\n ",
"__init__",
"self.f=[1]",
"self.f",
"self",
"f",
"[1]",
"1",
"for i in range(1,n+1):\n self.f.append(self.f[-1]*i%mod)\n ",
"i",
"range(1,n+1)",
"range",
"1",
"n+1",
"n",
"1",
"self.f.append(self.f[-1]*i%mod)",
"self.f.append",
"self.f",
"self",
"f",
"append",
"self.f[-1]*i%mod",
"self.f[-1]*i",
"self.f[-1]",
"self.f",
"self",
"f",
"-1",
"i",
"mod",
"self.i=[pow(self.f[-1],mod-2,mod)]",
"self.i",
"self",
"i",
"[pow(self.f[-1],mod-2,mod)]",
"pow(self.f[-1],mod-2,mod)",
"pow",
"self.f[-1]",
"self.f",
"self",
"f",
"-1",
"mod-2",
"mod",
"2",
"mod",
"for i in range(1,n+1)[::-1]:\n self.i.append(self.i[-1]*i%mod)\n ",
"i",
"range(1,n+1)[::-1]",
"(1,n+1)",
"range",
"1",
"n+1",
"n",
"1",
"::-1",
"-1",
"self.i.append(self.i[-1]*i%mod)",
"self.i.append",
"self.i",
"self",
"i",
"append",
"self.i[-1]*i%mod",
"self.i[-1]*i",
"self.i[-1]",
"self.i",
"self",
"i",
"-1",
"i",
"mod",
"self.i.reverse()",
"self.i.reverse",
"self.i",
"self",
"i",
"reverse",
"self",
"self",
"n",
"n",
"mod",
"mod",
"def factorial(self,i):\n return self.f[i]\n ",
"factorial",
"return self.f[i]",
"self.f[i]",
"self.f",
"self",
"f",
"i",
"self",
"self",
"i",
"i",
"def ifactorial(self,i):\n return self.i[i]\n ",
"ifactorial",
"return self.i[i]",
"self.i[i]",
"self.i",
"self",
"i",
"i",
"self",
"self",
"i",
"i",
"def comb(self,n,k):\n return self.f[n]*self.i[n-k]%mod*self.i[k]%mod",
"comb",
"return self.f[n]*self.i[n-k]%mod*self.i[k]%mod",
"self.f[n]*self.i[n-k]%mod*self.i[k]%mod",
"self.f[n]*self.i[n-k]%mod*self.i[k]",
"self.f[n]*self.i[n-k]%mod",
"self.f[n]*self.i[n-k]",
"self.f[n]",
"self.f",
"self",
"f",
"n",
"self.i[n-k]",
"self.i",
"self",
"i",
"n-k",
"n",
"k",
"mod",
"self.i[k]",
"self.i",
"self",
"i",
"k",
"mod",
"self",
"self",
"n",
"n",
"k",
"k",
"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",
"f=Factorial(h+w,mod)",
"f",
"Factorial(h+w,mod)",
"Factorial",
"h+w",
"h",
"w",
"mod",
"ans=0",
"ans",
"0",
"for i in range(b,w):\n ans=(ans+f.comb(h-a-1+i,i)*f.comb(a-1+w-i-1,w-i-1))%mod",
"i",
"range(b,w)",
"range",
"b",
"w",
"ans=(ans+f.comb(h-a-1+i,i)*f.comb(a-1+w-i-1,w-i-1))%mod",
"ans",
"(ans+f.comb(h-a-1+i,i)*f.comb(a-1+w-i-1,w-i-1))%mod",
"ans+f.comb(h-a-1+i,i)*f.comb(a-1+w-i-1,w-i-1)",
"ans",
"f.comb(h-a-1+i,i)*f.comb(a-1+w-i-1,w-i-1)",
"f.comb(h-a-1+i,i)",
"f.comb",
"f",
"comb",
"h-a-1+i",
"h-a-1",
"h-a",
"h",
"a",
"1",
"i",
"i",
"f.comb(a-1+w-i-1,w-i-1)",
"f.comb",
"f",
"comb",
"a-1+w-i-1",
"a-1+w-i",
"a-1+w",
"a-1",
"a",
"1",
"w",
"i",
"1",
"w-i-1",
"w-i",
"w",
"i",
"1",
"mod",
"print(ans)",
"print",
"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",
"ans=0",
"0",
"ans",
"w,a,b=map(int,input().split())",
"map(int,input().split())",
"w",
"f=Factorial(h+w,mod)",
"Factorial(h+w,mod)",
"f",
"mod=10**9+7",
"10**9+7",
"mod",
"b=map(int,input().split())",
"map(int,input().split())",
"b",
"ans=(ans+f.comb(h-a-1+i,i)*f.comb(a-1+w-i-1,w-i-1))%mod",
"(ans+f.comb(h-a-1+i,i)*f.comb(a-1+w-i-1,w-i-1))%mod",
"ans",
"class Factorial:\n def __init__(self,n,mod):\n self.f=[1]\n for i in range(1,n+1):\n self.f.append(self.f[-1]*i%mod)\n self.i=[pow(self.f[-1],mod-2,mod)]\n for i in range(1,n+1)[::-1]:\n self.i.append(self.i[-1]*i%mod)\n self.i.reverse()\n def factorial(self,i):\n return self.f[i]\n def ifactorial(self,i):\n return self.i[i]\n def comb(self,n,k):\n return self.f[n]*self.i[n-k]%mod*self.i[k]%mod",
"class Factorial:\n def __init__(self,n,mod):\n self.f=[1]\n for i in range(1,n+1):\n self.f.append(self.f[-1]*i%mod)\n self.i=[pow(self.f[-1],mod-2,mod)]\n for i in range(1,n+1)[::-1]:\n self.i.append(self.i[-1]*i%mod)\n self.i.reverse()\n def factorial(self,i):\n return self.f[i]\n def ifactorial(self,i):\n return self.i[i]\n def comb(self,n,k):\n return self.f[n]*self.i[n-k]%mod*self.i[k]%mod",
"Factorial"
] | class Factorial:
def __init__(self,n,mod):
self.f=[1]
for i in range(1,n+1):
self.f.append(self.f[-1]*i%mod)
self.i=[pow(self.f[-1],mod-2,mod)]
for i in range(1,n+1)[::-1]:
self.i.append(self.i[-1]*i%mod)
self.i.reverse()
def factorial(self,i):
return self.f[i]
def ifactorial(self,i):
return self.i[i]
def comb(self,n,k):
return self.f[n]*self.i[n-k]%mod*self.i[k]%mod
mod=10**9+7
h,w,a,b=map(int,input().split())
f=Factorial(h+w,mod)
ans=0
for i in range(b,w):
ans=(ans+f.comb(h-a-1+i,i)*f.comb(a-1+w-i-1,w-i-1))%mod
print(ans) |
[
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,
0,
13,
2,
13,
17,
0,
13,
2,
2,
13,
13,
17,
0,
13,
2,
2,
13,
13,
17,
0,
13,
2,
13,
17,
0,
13,
4,
13,
2,
13,
13,
2,
13,
13,
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,
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,
13,
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,
17,
0,
13,
2,
2,
2,
2,
2,
18,
13,
2,
13,
13,
18,
13,
13,
18,
13,
13,
13,
2,
2,
18,
13,
2,
2,
13,
13,
13,
18,
13,
13,
18,
13,
2,
13,
13,
13,
0,
13,
13,
0,
13,
13,
4,
13,
13,
10,
13,
13,
10,
2,
13,
10,
2,
13,
10,
2,
13,
10,
13,
13,
10,
2,
13,
10,
2,
13,
10,
2,
13,
10,
2,
13,
10,
13,
13,
10,
2,
13,
10,
13,
13,
10,
12,
13,
10,
13,
13,
10,
17,
13,
10,
13,
13,
10,
4,
13
] | [
[
4,
3
],
[
3,
12
],
[
274,
14
],
[
274,
16
],
[
274,
17
],
[
274,
18
],
[
253,
20
],
[
250,
27
],
[
269,
29
],
[
265,
32
],
[
275,
35
],
[
236,
36
],
[
259,
39
],
[
263,
42
],
[
269,
43
],
[
256,
46
],
[
275,
48
],
[
283,
51
],
[
251,
55
],
[
266,
56
],
[
260,
58
],
[
257,
59
],
[
64,
63
],
[
104,
67
],
[
95,
67
],
[
83,
67
],
[
104,
72
],
[
95,
72
],
[
83,
72
],
[
77,
76
],
[
102,
79
],
[
76,
79
],
[
102,
80
],
[
76,
80
],
[
106,
81
],
[
84,
83
],
[
104,
85
],
[
95,
85
],
[
83,
85
],
[
89,
88
],
[
102,
91
],
[
76,
91
],
[
63,
92
],
[
88,
92
],
[
106,
93
],
[
96,
95
],
[
104,
97
],
[
95,
97
],
[
83,
97
],
[
88,
100
],
[
63,
100
],
[
102,
102
],
[
104,
104
],
[
106,
106
],
[
241,
108
],
[
284,
113
],
[
117,
116
],
[
284,
121
],
[
127,
124
],
[
242,
125
],
[
116,
126
],
[
242,
130
],
[
116,
132
],
[
116,
134
],
[
254,
135
],
[
244,
137
],
[
284,
142
],
[
148,
145
],
[
245,
146
],
[
284,
147
],
[
272,
149
],
[
242,
151
],
[
284,
152
],
[
254,
154
],
[
254,
156
],
[
159,
158
],
[
284,
161
],
[
170,
165
],
[
245,
166
],
[
158,
168
],
[
245,
173
],
[
158,
174
],
[
158,
175
],
[
254,
176
],
[
277,
178
],
[
182,
181
],
[
266,
186
],
[
238,
189
],
[
242,
196
],
[
181,
198
],
[
251,
199
],
[
245,
201
],
[
181,
202
],
[
245,
204
],
[
251,
205
],
[
254,
206
],
[
242,
210
],
[
260,
213
],
[
257,
214
],
[
181,
215
],
[
245,
217
],
[
260,
218
],
[
245,
220
],
[
257,
222
],
[
181,
223
],
[
254,
224
],
[
247,
226
],
[
254,
227
],
[
280,
229
],
[
254,
230
],
[
281,
233
],
[
248,
233
],
[
239,
233
],
[
278,
233
],
[
274,
236
],
[
238,
239
],
[
241,
242
],
[
244,
245
],
[
254,
247
],
[
247,
248
],
[
250,
251
],
[
253,
254
],
[
256,
257
],
[
259,
260
],
[
274,
263
],
[
265,
266
],
[
274,
269
],
[
274,
275
],
[
277,
278
],
[
254,
280
],
[
280,
281
],
[
283,
284
]
] | [
"iH,iW,iA,iB = [int(x) for x in input().split()]\niD = 10**9+7 #法\n\niLBoxW=iB-1\niLBoxH=iH-iA-1\niRBoxW=iW-iB-1\niRBoxH=iH-1\n#iMax = iH+iW-2\niMax = max(iLBoxW+iLBoxH,iRBoxW+iRBoxH)\n\n#nCr = n!/r!(n-r)!\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#階乗(iDを法とした)の配列\naM = [1]*(iMax+1)\nfor i in range(1,iMax+1):\n aM[i]=aM[i-1]*i %iD\n#各階乗のiDを法とした逆元の配列\naInvM = [1]*(iMax+1)\naInvM[iMax] = fBiPow(aM[iMax],iD-2,iD)\nfor i in range(iMax,0,-1):\n aInvM[i-1]=aInvM[i]*i % iD\n\niRet = 0\nfor iL in range(0,iLBoxH+1):\n iRet += (aM[iL+iLBoxW]*aInvM[iL]*aInvM[iLBoxW]) % iD * (aM[iRBoxW+iRBoxH-iL]*aInvM[iRBoxW]*aInvM[iRBoxH-iL])%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",
"iLBoxW=iB-1",
"iLBoxW",
"iB-1",
"iB",
"1",
"iLBoxH=iH-iA-1",
"iLBoxH",
"iH-iA-1",
"iH-iA",
"iH",
"iA",
"1",
"iRBoxW=iW-iB-1",
"iRBoxW",
"iW-iB-1",
"iW-iB",
"iW",
"iB",
"1",
"iRBoxH=iH-1",
"iRBoxH",
"iH-1",
"iH",
"1",
"iMax = max(iLBoxW+iLBoxH,iRBoxW+iRBoxH)",
"iMax",
"max(iLBoxW+iLBoxH,iRBoxW+iRBoxH)",
"max",
"iLBoxW+iLBoxH",
"iLBoxW",
"iLBoxH",
"iRBoxW+iRBoxH",
"iRBoxW",
"iRBoxH",
"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#階乗(iDを法とした)の配列",
"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",
"aM = [1]*(iMax+1)",
"aM",
"[1]*(iMax+1)",
"[1]",
"1",
"iMax+1",
"iMax",
"1",
"for i in range(1,iMax+1):\n aM[i]=aM[i-1]*i %iD\n#各階乗のiDを法とした逆元の配列",
"i",
"range(1,iMax+1)",
"range",
"1",
"iMax+1",
"iMax",
"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]*(iMax+1)",
"aInvM",
"[1]*(iMax+1)",
"[1]",
"1",
"iMax+1",
"iMax",
"1",
"aInvM[iMax] = fBiPow(aM[iMax],iD-2,iD)",
"aInvM[iMax]",
"aInvM",
"iMax",
"fBiPow(aM[iMax],iD-2,iD)",
"fBiPow",
"aM[iMax]",
"aM",
"iMax",
"iD-2",
"iD",
"2",
"iD",
"for i in range(iMax,0,-1):\n aInvM[i-1]=aInvM[i]*i % iD",
"i",
"range(iMax,0,-1)",
"range",
"iMax",
"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,iLBoxH+1):\n iRet += (aM[iL+iLBoxW]*aInvM[iL]*aInvM[iLBoxW]) % iD * (aM[iRBoxW+iRBoxH-iL]*aInvM[iRBoxW]*aInvM[iRBoxH-iL])%iD\n iRet %= iD",
"iL",
"range(0,iLBoxH+1)",
"range",
"0",
"iLBoxH+1",
"iLBoxH",
"1",
"iRet += (aM[iL+iLBoxW]*aInvM[iL]*aInvM[iLBoxW]) % iD * (aM[iRBoxW+iRBoxH-iL]*aInvM[iRBoxW]*aInvM[iRBoxH-iL])%iD",
"iRet",
"(aM[iL+iLBoxW]*aInvM[iL]*aInvM[iLBoxW]) % iD * (aM[iRBoxW+iRBoxH-iL]*aInvM[iRBoxW]*aInvM[iRBoxH-iL])%iD",
"(aM[iL+iLBoxW]*aInvM[iL]*aInvM[iLBoxW]) % iD * (aM[iRBoxW+iRBoxH-iL]*aInvM[iRBoxW]*aInvM[iRBoxH-iL])",
"(aM[iL+iLBoxW]*aInvM[iL]*aInvM[iLBoxW]) % iD",
"aM[iL+iLBoxW]*aInvM[iL]*aInvM[iLBoxW]",
"aM[iL+iLBoxW]*aInvM[iL]",
"aM[iL+iLBoxW]",
"aM",
"iL+iLBoxW",
"iL",
"iLBoxW",
"aInvM[iL]",
"aInvM",
"iL",
"aInvM[iLBoxW]",
"aInvM",
"iLBoxW",
"iD",
"aM[iRBoxW+iRBoxH-iL]*aInvM[iRBoxW]*aInvM[iRBoxH-iL]",
"aM[iRBoxW+iRBoxH-iL]*aInvM[iRBoxW]",
"aM[iRBoxW+iRBoxH-iL]",
"aM",
"iRBoxW+iRBoxH-iL",
"iRBoxW+iRBoxH",
"iRBoxW",
"iRBoxH",
"iL",
"aInvM[iRBoxW]",
"aInvM",
"iRBoxW",
"aInvM[iRBoxH-iL]",
"aInvM",
"iRBoxH-iL",
"iRBoxH",
"iL",
"iD",
"iRet %= iD",
"iRet",
"iD",
"iRet %= iD",
"iRet",
"iD",
"print(iRet)",
"print",
"iRet",
"iA,iB = [int(x) for x in input().split()]",
"[int(x) for x in input().split()]",
"iA",
"iRet += (aM[iL+iLBoxW]*aInvM[iL]*aInvM[iLBoxW]) % iD * (aM[iRBoxW+iRBoxH-iL]*aInvM[iRBoxW]*aInvM[iRBoxH-iL])%iD",
"(aM[iL+iLBoxW]*aInvM[iL]*aInvM[iLBoxW]) % iD * (aM[iRBoxW+iRBoxH-iL]*aInvM[iRBoxW]*aInvM[iRBoxH-iL])%iD",
"iRet",
"aM = [1]*(iMax+1)",
"[1]*(iMax+1)",
"aM",
"aInvM = [1]*(iMax+1)",
"[1]*(iMax+1)",
"aInvM",
"iRet %= iD",
"iD",
"iRet",
"iLBoxW=iB-1",
"iB-1",
"iLBoxW",
"iD = 10**9+7",
"10**9+7",
"iD",
"iRBoxH=iH-1",
"iH-1",
"iRBoxH",
"iRBoxW=iW-iB-1",
"iW-iB-1",
"iRBoxW",
"iW,iA,iB = [int(x) for x in input().split()]",
"[int(x) for x in input().split()]",
"iW",
"iLBoxH=iH-iA-1",
"iH-iA-1",
"iLBoxH",
"iB = [int(x) for x in input().split()]",
"[int(x) for x in input().split()]",
"iB",
"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#階乗(iDを法とした)の配列",
"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#階乗(iDを法とした)の配列",
"fBiPow",
"iH,iW,iA,iB = [int(x) for x in input().split()]",
"[int(x) for x in input().split()]",
"iH",
"iRet = 0",
"0",
"iRet",
"iRet %= iD",
"iD",
"iRet",
"iMax = max(iLBoxW+iLBoxH,iRBoxW+iRBoxH)",
"max(iLBoxW+iLBoxH,iRBoxW+iRBoxH)",
"iMax"
] | iH,iW,iA,iB = [int(x) for x in input().split()]
iD = 10**9+7 #法
iLBoxW=iB-1
iLBoxH=iH-iA-1
iRBoxW=iW-iB-1
iRBoxH=iH-1
#iMax = iH+iW-2
iMax = max(iLBoxW+iLBoxH,iRBoxW+iRBoxH)
#nCr = n!/r!(n-r)!
#二分累乗法 iDを法として
def fBiPow(iX,iN,iD):
iY = 1
while iN > 0:
if iN % 2 == 0:
iX = iX * iX % iD
iN = iN // 2
else:
iY = iX * iY % iD
iN = iN - 1
return iY
#階乗(iDを法とした)の配列
aM = [1]*(iMax+1)
for i in range(1,iMax+1):
aM[i]=aM[i-1]*i %iD
#各階乗のiDを法とした逆元の配列
aInvM = [1]*(iMax+1)
aInvM[iMax] = fBiPow(aM[iMax],iD-2,iD)
for i in range(iMax,0,-1):
aInvM[i-1]=aInvM[i]*i % iD
iRet = 0
for iL in range(0,iLBoxH+1):
iRet += (aM[iL+iLBoxW]*aInvM[iL]*aInvM[iLBoxW]) % iD * (aM[iRBoxW+iRBoxH-iL]*aInvM[iRBoxW]*aInvM[iRBoxH-iL])%iD
iRet %= iD
iRet %= iD
print(iRet)
|
[
7,
0,
13,
2,
2,
17,
17,
17,
41,
28,
13,
4,
13,
17,
4,
17,
0,
13,
13,
41,
28,
13,
4,
13,
17,
4,
17,
0,
13,
13,
12,
13,
28,
13,
4,
13,
17,
2,
2,
13,
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,
23,
13,
23,
13,
12,
13,
29,
2,
2,
2,
2,
18,
13,
13,
18,
13,
2,
13,
13,
13,
18,
13,
13,
13,
23,
13,
23,
13,
12,
13,
0,
13,
4,
13,
13,
4,
18,
4,
13,
13,
13,
13,
13,
4,
13,
13,
13,
41,
28,
13,
4,
13,
13,
13,
4,
2,
2,
4,
13,
2,
2,
2,
13,
13,
17,
13,
13,
4,
13,
2,
2,
2,
2,
13,
17,
13,
13,
17,
2,
13,
17,
13,
4,
13,
2,
4,
13,
13,
13,
14,
2,
13,
17,
4,
13,
10,
13,
13,
10,
13,
13,
10,
12,
13,
10,
2,
13,
10,
12,
13,
10,
12,
13
] | [
[
173,
2
],
[
11,
10
],
[
164,
17
],
[
22,
21
],
[
167,
28
],
[
34,
33
],
[
69,
39
],
[
71,
40
],
[
46,
43
],
[
165,
44
],
[
33,
45
],
[
165,
49
],
[
33,
51
],
[
33,
53
],
[
174,
54
],
[
59,
56
],
[
168,
57
],
[
33,
58
],
[
43,
61
],
[
165,
62
],
[
33,
63
],
[
174,
65
],
[
174,
67
],
[
69,
69
],
[
71,
71
],
[
165,
80
],
[
93,
81
],
[
168,
83
],
[
93,
85
],
[
95,
86
],
[
174,
87
],
[
168,
89
],
[
95,
90
],
[
174,
91
],
[
93,
93
],
[
95,
95
],
[
100,
99
],
[
100,
108
],
[
100,
109
],
[
100,
110
],
[
177,
112
],
[
99,
113
],
[
108,
114
],
[
118,
117
],
[
110,
120
],
[
108,
121
],
[
180,
126
],
[
99,
130
],
[
109,
131
],
[
117,
133
],
[
117,
134
],
[
180,
136
],
[
109,
141
],
[
108,
143
],
[
117,
144
],
[
109,
147
],
[
174,
149
],
[
174,
156
],
[
171,
162
],
[
164,
165
],
[
167,
168
],
[
173,
174
]
] | [
"mod = 10 ** 9 + 7\nfac_table = [1 for i in range(200001)]\ninv_table = [1 for i in range(200001)]\n\n\ndef make_table(h, w):\n\n for i in range(1, h + w - 1):\n fac_table[i] = fac_table[i - 1] * i % mod\n inv_table[i] = pow(fac_table[i], mod - 2, mod)\n\n\ndef comb(n, r):\n return fac_table[n] * inv_table[n - r] % mod * inv_table[r] % mod\n\n\ndef resolve():\n H, W, A, B = map(int, input().split())\n make_table(H, W)\n print(\n sum(\n [\n comb(H - A - 1 + i, i) * comb(A - 1 + W - i - 1, A - 1) % mod\n for i in range(B, W)\n ]\n )\n % mod\n )\n\nif __name__ == \"__main__\":\n resolve()",
"mod = 10 ** 9 + 7",
"mod",
"10 ** 9 + 7",
"10 ** 9",
"10",
"9",
"7",
"1 for i in range(200001)",
"for i in range(200001)",
"i",
"range(200001)",
"range",
"200001",
"for i in range(200001)",
"1",
"fac_table = [1 for i in range(200001)]",
"fac_table",
"[1 for i in range(200001)]",
"1 for i in range(200001)",
"for i in range(200001)",
"i",
"range(200001)",
"range",
"200001",
"for i in range(200001)",
"1",
"inv_table = [1 for i in range(200001)]",
"inv_table",
"[1 for i in range(200001)]",
"def make_table(h, w):\n\n for i in range(1, h + w - 1):\n fac_table[i] = fac_table[i - 1] * i % mod\n inv_table[i] = pow(fac_table[i], mod - 2, mod)",
"make_table",
"for i in range(1, h + w - 1):\n fac_table[i] = fac_table[i - 1] * i % mod\n inv_table[i] = pow(fac_table[i], mod - 2, mod)",
"i",
"range(1, h + w - 1)",
"range",
"1",
"h + w - 1",
"h + w",
"h",
"w",
"1",
"fac_table[i] = fac_table[i - 1] * i % mod",
"fac_table[i]",
"fac_table",
"i",
"fac_table[i - 1] * i % mod",
"fac_table[i - 1] * i",
"fac_table[i - 1]",
"fac_table",
"i - 1",
"i",
"1",
"i",
"mod",
"inv_table[i] = pow(fac_table[i], mod - 2, mod)",
"inv_table[i]",
"inv_table",
"i",
"pow(fac_table[i], mod - 2, mod)",
"pow",
"fac_table[i]",
"fac_table",
"i",
"mod - 2",
"mod",
"2",
"mod",
"h",
"h",
"w",
"w",
"def comb(n, r):\n return fac_table[n] * inv_table[n - r] % mod * inv_table[r] % mod",
"comb",
"return fac_table[n] * inv_table[n - r] % mod * inv_table[r] % mod",
"fac_table[n] * inv_table[n - r] % mod * inv_table[r] % mod",
"fac_table[n] * inv_table[n - r] % mod * inv_table[r]",
"fac_table[n] * inv_table[n - r] % mod",
"fac_table[n] * inv_table[n - r]",
"fac_table[n]",
"fac_table",
"n",
"inv_table[n - r]",
"inv_table",
"n - r",
"n",
"r",
"mod",
"inv_table[r]",
"inv_table",
"r",
"mod",
"n",
"n",
"r",
"r",
"def resolve():\n H, W, A, B = map(int, input().split())\n make_table(H, W)\n print(\n sum(\n [\n comb(H - A - 1 + i, i) * comb(A - 1 + W - i - 1, A - 1) % mod\n for i in range(B, W)\n ]\n )\n % mod\n )",
"resolve",
"H, W, A, B = map(int, input().split())",
"H",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"W",
"A",
"B",
"make_table(H, W)",
"make_table",
"H",
"W",
"comb(H - A - 1 + i, i) * comb(A - 1 + W - i - 1, A - 1) % mod\n for i in range(B, W)",
"for i in range(B, W)",
"i",
"range(B, W)",
"range",
"B",
"W",
"for i in range(B, W)",
"comb(H - A - 1 + i, i) * comb(A - 1 + W - i - 1, A - 1) % mod",
"comb(H - A - 1 + i, i) * comb(A - 1 + W - i - 1, 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 - i - 1, A - 1)",
"comb",
"A - 1 + W - i - 1",
"A - 1 + W - i",
"A - 1 + W",
"A - 1",
"A",
"1",
"W",
"i",
"1",
"A - 1",
"A",
"1",
"mod",
"print(\n sum(\n [\n comb(H - A - 1 + i, i) * comb(A - 1 + W - i - 1, A - 1) % mod\n for i in range(B, W)\n ]\n )\n % mod\n )",
"print",
"sum(\n [\n comb(H - A - 1 + i, i) * comb(A - 1 + W - i - 1, A - 1) % mod\n for i in range(B, W)\n ]\n )\n % mod",
"sum(\n [\n comb(H - A - 1 + i, i) * comb(A - 1 + W - i - 1, A - 1) % mod\n for i in range(B, W)\n ]\n )",
"sum",
"[\n comb(H - A - 1 + i, i) * comb(A - 1 + W - i - 1, A - 1) % mod\n for i in range(B, W)\n ]",
"mod",
"if __name__ == \"__main__\":\n resolve()",
"__name__ == \"__main__\"",
"__name__",
"\"__main__\"",
"resolve()",
"resolve",
"fac_table = [1 for i in range(200001)]",
"[1 for i in range(200001)]",
"fac_table",
"inv_table = [1 for i in range(200001)]",
"[1 for i in range(200001)]",
"inv_table",
"def resolve():\n H, W, A, B = map(int, input().split())\n make_table(H, W)\n print(\n sum(\n [\n comb(H - A - 1 + i, i) * comb(A - 1 + W - i - 1, A - 1) % mod\n for i in range(B, W)\n ]\n )\n % mod\n )",
"def resolve():\n H, W, A, B = map(int, input().split())\n make_table(H, W)\n print(\n sum(\n [\n comb(H - A - 1 + i, i) * comb(A - 1 + W - i - 1, A - 1) % mod\n for i in range(B, W)\n ]\n )\n % mod\n )",
"resolve",
"mod = 10 ** 9 + 7",
"10 ** 9 + 7",
"mod",
"def make_table(h, w):\n\n for i in range(1, h + w - 1):\n fac_table[i] = fac_table[i - 1] * i % mod\n inv_table[i] = pow(fac_table[i], mod - 2, mod)",
"def make_table(h, w):\n\n for i in range(1, h + w - 1):\n fac_table[i] = fac_table[i - 1] * i % mod\n inv_table[i] = pow(fac_table[i], mod - 2, mod)",
"make_table",
"def comb(n, r):\n return fac_table[n] * inv_table[n - r] % mod * inv_table[r] % mod",
"def comb(n, r):\n return fac_table[n] * inv_table[n - r] % mod * inv_table[r] % mod",
"comb"
] | mod = 10 ** 9 + 7
fac_table = [1 for i in range(200001)]
inv_table = [1 for i in range(200001)]
def make_table(h, w):
for i in range(1, h + w - 1):
fac_table[i] = fac_table[i - 1] * i % mod
inv_table[i] = pow(fac_table[i], mod - 2, mod)
def comb(n, r):
return fac_table[n] * inv_table[n - r] % mod * inv_table[r] % mod
def resolve():
H, W, A, B = map(int, input().split())
make_table(H, W)
print(
sum(
[
comb(H - A - 1 + i, i) * comb(A - 1 + W - i - 1, A - 1) % mod
for i in range(B, W)
]
)
% mod
)
if __name__ == "__main__":
resolve() |
[
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,
18,
13,
2,
13,
17,
13,
13,
28,
13,
4,
13,
17,
2,
2,
13,
13,
17,
0,
18,
13,
13,
4,
13,
18,
13,
13,
2,
13,
17,
13,
12,
13,
29,
2,
2,
18,
13,
13,
18,
13,
13,
18,
13,
2,
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,
13,
17,
2,
13,
17,
2,
13,
17,
4,
13,
2,
2,
2,
13,
13,
17,
2,
13,
13,
2,
2,
13,
13,
17,
13,
4,
13,
4,
13,
2,
13,
13,
10,
2,
13,
10,
2,
13,
10,
17,
13,
10,
4,
13,
10,
4,
13,
10,
4,
13,
10,
2,
13,
10,
4,
13,
10,
12,
13,
10,
2,
13
] | [
[
182,
2
],
[
182,
11
],
[
182,
12
],
[
182,
13
],
[
188,
15
],
[
161,
22
],
[
183,
28
],
[
177,
29
],
[
164,
32
],
[
183,
38
],
[
177,
39
],
[
43,
42
],
[
183,
48
],
[
177,
49
],
[
55,
52
],
[
162,
53
],
[
42,
54
],
[
162,
58
],
[
42,
60
],
[
42,
62
],
[
189,
63
],
[
66,
65
],
[
183,
71
],
[
177,
72
],
[
78,
75
],
[
165,
76
],
[
65,
77
],
[
52,
80
],
[
162,
81
],
[
65,
82
],
[
189,
84
],
[
189,
86
],
[
162,
93
],
[
104,
94
],
[
165,
96
],
[
106,
97
],
[
165,
99
],
[
104,
101
],
[
106,
102
],
[
104,
104
],
[
106,
106
],
[
167,
108
],
[
112,
111
],
[
183,
117
],
[
171,
118
],
[
179,
121
],
[
186,
125
],
[
174,
128
],
[
111,
131
],
[
111,
134
],
[
186,
137
],
[
177,
141
],
[
174,
142
],
[
183,
145
],
[
111,
146
],
[
177,
149
],
[
174,
150
],
[
189,
152
],
[
180,
158
],
[
168,
158
],
[
189,
159
],
[
161,
162
],
[
164,
165
],
[
167,
168
],
[
182,
171
],
[
182,
174
],
[
182,
177
],
[
179,
180
],
[
182,
183
],
[
188,
189
]
] | [
"H, W, A, B = map(int, input().split())\n\nmod = 10**9 + 7\n\nfact = [1] * (H + W - 1)\ninvfact = [1] * (H + W - 1)\n\nfor i in range(1, H + W - 1):\n fact[i] = fact[i - 1] * i % mod\nfor i in range(1, H + W - 1):\n invfact[i] = pow(fact[i], mod-2, mod)\n\ndef nCr(n,r):\n return fact[n] * invfact[r] * invfact[n-r]\n\nresult = 0\nfor i in range(1, H - A + 1):\n result += (nCr((B-1)+(i-1), i-1) * nCr((W-B-1)+(H-i), W-B-1)) % mod\nprint(int(result % 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",
"fact = [1] * (H + W - 1)",
"fact",
"[1] * (H + W - 1)",
"[1]",
"1",
"H + W - 1",
"H + W",
"H",
"W",
"1",
"invfact = [1] * (H + W - 1)",
"invfact",
"[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] = fact[i - 1] * i % mod",
"i",
"range(1, H + W - 1)",
"range",
"1",
"H + W - 1",
"H + W",
"H",
"W",
"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",
"for i in range(1, H + W - 1):\n invfact[i] = pow(fact[i], mod-2, mod)",
"i",
"range(1, H + W - 1)",
"range",
"1",
"H + W - 1",
"H + W",
"H",
"W",
"1",
"invfact[i] = pow(fact[i], mod-2, mod)",
"invfact[i]",
"invfact",
"i",
"pow(fact[i], mod-2, mod)",
"pow",
"fact[i]",
"fact",
"i",
"mod-2",
"mod",
"2",
"mod",
"def nCr(n,r):\n return fact[n] * invfact[r] * invfact[n-r]",
"nCr",
"return fact[n] * invfact[r] * invfact[n-r]",
"fact[n] * invfact[r] * invfact[n-r]",
"fact[n] * invfact[r]",
"fact[n]",
"fact",
"n",
"invfact[r]",
"invfact",
"r",
"invfact[n-r]",
"invfact",
"n-r",
"n",
"r",
"n",
"n",
"r",
"r",
"result = 0",
"result",
"0",
"for i in range(1, H - A + 1):\n result += (nCr((B-1)+(i-1), i-1) * nCr((W-B-1)+(H-i), W-B-1)) % mod",
"i",
"range(1, H - A + 1)",
"range",
"1",
"H - A + 1",
"H - A",
"H",
"A",
"1",
"result += (nCr((B-1)+(i-1), i-1) * nCr((W-B-1)+(H-i), W-B-1)) % mod",
"result",
"(nCr((B-1)+(i-1), i-1) * nCr((W-B-1)+(H-i), W-B-1)) % mod",
"nCr((B-1)+(i-1), i-1) * nCr((W-B-1)+(H-i), W-B-1)",
"nCr((B-1)+(i-1), i-1)",
"nCr",
"(B-1)+(i-1)",
"B-1",
"B",
"1",
"i-1",
"i",
"1",
"i-1",
"i",
"1",
"nCr((W-B-1)+(H-i), W-B-1)",
"nCr",
"(W-B-1)+(H-i)",
"W-B-1",
"W-B",
"W",
"B",
"1",
"H-i",
"H",
"i",
"W-B-1",
"W-B",
"W",
"B",
"1",
"mod",
"print(int(result % mod))",
"print",
"int(result % mod)",
"int",
"result % mod",
"result",
"mod",
"fact = [1] * (H + W - 1)",
"[1] * (H + W - 1)",
"fact",
"invfact = [1] * (H + W - 1)",
"[1] * (H + W - 1)",
"invfact",
"result = 0",
"0",
"result",
"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",
"result += (nCr((B-1)+(i-1), i-1) * nCr((W-B-1)+(H-i), W-B-1)) % mod",
"(nCr((B-1)+(i-1), i-1) * nCr((W-B-1)+(H-i), W-B-1)) % mod",
"result",
"H, W, A, B = map(int, input().split())",
"map(int, input().split())",
"H",
"def nCr(n,r):\n return fact[n] * invfact[r] * invfact[n-r]",
"def nCr(n,r):\n return fact[n] * invfact[r] * invfact[n-r]",
"nCr",
"mod = 10**9 + 7",
"10**9 + 7",
"mod"
] | H, W, A, B = map(int, input().split())
mod = 10**9 + 7
fact = [1] * (H + W - 1)
invfact = [1] * (H + W - 1)
for i in range(1, H + W - 1):
fact[i] = fact[i - 1] * i % mod
for i in range(1, H + W - 1):
invfact[i] = pow(fact[i], mod-2, mod)
def nCr(n,r):
return fact[n] * invfact[r] * invfact[n-r]
result = 0
for i in range(1, H - A + 1):
result += (nCr((B-1)+(i-1), i-1) * nCr((W-B-1)+(H-i), W-B-1)) % mod
print(int(result % mod)) |
[
7,
0,
13,
4,
13,
13,
4,
18,
4,
13,
13,
13,
13,
13,
0,
13,
2,
2,
17,
17,
17,
6,
13,
12,
13,
0,
18,
13,
13,
2,
39,
17,
2,
13,
17,
0,
18,
13,
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,
40,
2,
13,
13,
18,
13,
2,
13,
13,
13,
28,
13,
4,
13,
17,
2,
13,
17,
0,
18,
18,
13,
13,
13,
2,
2,
18,
18,
13,
13,
2,
13,
17,
13,
13,
0,
18,
18,
13,
13,
13,
2,
2,
18,
18,
13,
13,
2,
13,
17,
18,
13,
13,
13,
23,
13,
23,
13,
12,
13,
14,
2,
40,
13,
17,
2,
13,
13,
29,
17,
14,
2,
13,
17,
29,
13,
0,
13,
2,
2,
2,
2,
18,
18,
13,
13,
13,
18,
18,
13,
13,
13,
13,
18,
18,
13,
13,
2,
13,
13,
13,
29,
13,
23,
13,
23,
13,
23,
13,
0,
13,
4,
13,
2,
13,
13,
0,
13,
17,
0,
13,
2,
2,
13,
13,
17,
0,
13,
2,
2,
13,
13,
17,
28,
13,
4,
13,
2,
13,
13,
0,
13,
2,
2,
2,
2,
13,
13,
17,
13,
13,
0,
13,
2,
4,
18,
13,
13,
2,
2,
13,
13,
17,
2,
13,
17,
4,
18,
13,
13,
13,
2,
2,
13,
13,
17,
0,
13,
13,
4,
13,
2,
13,
13,
10,
4,
13,
10,
4,
13,
10,
4,
13,
10,
4,
13,
10,
2,
13,
10,
2,
13,
10,
4,
13,
10,
2,
13,
10,
13,
13,
10,
6,
13,
10,
2,
13,
10,
2,
13,
10,
17,
13
] | [
[
270,
2
],
[
270,
11
],
[
270,
12
],
[
270,
13
],
[
273,
15
],
[
29,
26
],
[
122,
27
],
[
124,
33
],
[
39,
36
],
[
122,
37
],
[
124,
43
],
[
47,
46
],
[
124,
51
],
[
55,
54
],
[
124,
59
],
[
65,
62
],
[
46,
63
],
[
54,
64
],
[
274,
69
],
[
54,
70
],
[
46,
72
],
[
274,
74
],
[
54,
75
],
[
274,
76
],
[
79,
78
],
[
124,
83
],
[
91,
86
],
[
36,
87
],
[
122,
88
],
[
78,
90
],
[
36,
94
],
[
122,
95
],
[
78,
98
],
[
78,
100
],
[
274,
101
],
[
108,
103
],
[
26,
104
],
[
122,
105
],
[
78,
107
],
[
26,
111
],
[
122,
112
],
[
78,
115
],
[
62,
117
],
[
46,
118
],
[
78,
119
],
[
274,
120
],
[
122,
122
],
[
124,
124
],
[
173,
130
],
[
173,
133
],
[
175,
134
],
[
175,
139
],
[
173,
142
],
[
145,
144
],
[
171,
151
],
[
173,
153
],
[
171,
156
],
[
175,
158
],
[
274,
159
],
[
171,
162
],
[
173,
165
],
[
175,
166
],
[
274,
167
],
[
144,
169
],
[
171,
171
],
[
173,
173
],
[
175,
175
],
[
255,
177
],
[
259,
181
],
[
271,
182
],
[
288,
184
],
[
267,
187
],
[
259,
190
],
[
253,
191
],
[
285,
194
],
[
271,
197
],
[
262,
198
],
[
202,
201
],
[
259,
205
],
[
253,
206
],
[
282,
208
],
[
259,
213
],
[
271,
214
],
[
201,
216
],
[
262,
217
],
[
264,
219
],
[
256,
223
],
[
126,
224
],
[
201,
227
],
[
262,
228
],
[
262,
231
],
[
256,
235
],
[
126,
236
],
[
283,
237
],
[
271,
240
],
[
262,
241
],
[
276,
244
],
[
274,
245
],
[
277,
249
],
[
265,
249
],
[
289,
249
],
[
274,
250
],
[
270,
253
],
[
255,
256
],
[
270,
259
],
[
270,
262
],
[
264,
265
],
[
267,
268
],
[
270,
271
],
[
273,
274
],
[
274,
276
],
[
276,
277
],
[
282,
283
],
[
285,
286
],
[
288,
289
]
] | [
"h, w, a, b = map(int, input().split())\n\nMOD = 10 ** 9 + 7\n\nclass ModCmb:\n def __init__(self, size):\n self.inv = [1] * (size + 1)\n self.fact = [1] * (size + 1)\n temp_inv = [1] * (size + 1)\n for i in range(2, size + 1):\n temp_inv[i] = ( -(MOD // i) * temp_inv[MOD%i] ) % MOD\n for i in range(2, size + 1):\n self.fact[i] = self.fact[i-1] * i % MOD\n self.inv[i] = self.inv[i-1] * temp_inv[i] % MOD\n\n def cmb(self, n, r):\n #print(n, r)\n if n <= 1 or n == r:\n return 1\n elif r == 1:\n return n\n res = (self.fact[n] * self.inv[r] % MOD ) * self.inv[n-r] % MOD\n #print(res)\n return res\n\nc = ModCmb(h+w)\n\nans = 0\nx = h-a-1\ny = w-b-1\nfor i in range(h-a):\n j = h+w-2-i-b\n #print(i, j)\n #print(i+b-1, b-1, j, w-b-1)\n ans += c.cmb(i+b-1, b-1) * c.cmb(j, w-b-1)\n ans %= MOD\n\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",
"class ModCmb:\n def __init__(self, size):\n self.inv = [1] * (size + 1)\n self.fact = [1] * (size + 1)\n temp_inv = [1] * (size + 1)\n for i in range(2, size + 1):\n temp_inv[i] = ( -(MOD // i) * temp_inv[MOD%i] ) % MOD\n for i in range(2, size + 1):\n self.fact[i] = self.fact[i-1] * i % MOD\n self.inv[i] = self.inv[i-1] * temp_inv[i] % MOD\n\n def cmb(self, n, r):\n #print(n, r)\n if n <= 1 or n == r:\n return 1\n elif r == 1:\n return n\n res = (self.fact[n] * self.inv[r] % MOD ) * self.inv[n-r] % MOD\n #print(res)\n return res",
"ModCmb",
"def __init__(self, size):\n self.inv = [1] * (size + 1)\n self.fact = [1] * (size + 1)\n temp_inv = [1] * (size + 1)\n for i in range(2, size + 1):\n temp_inv[i] = ( -(MOD // i) * temp_inv[MOD%i] ) % MOD\n for i in range(2, size + 1):\n self.fact[i] = self.fact[i-1] * i % MOD\n self.inv[i] = self.inv[i-1] * temp_inv[i] % MOD\n\n ",
"__init__",
"self.inv = [1] * (size + 1)",
"self.inv",
"self",
"inv",
"[1] * (size + 1)",
"[1]",
"1",
"size + 1",
"size",
"1",
"self.fact = [1] * (size + 1)",
"self.fact",
"self",
"fact",
"[1] * (size + 1)",
"[1]",
"1",
"size + 1",
"size",
"1",
"temp_inv = [1] * (size + 1)",
"temp_inv",
"[1] * (size + 1)",
"[1]",
"1",
"size + 1",
"size",
"1",
"for i in range(2, size + 1):\n temp_inv[i] = ( -(MOD // i) * temp_inv[MOD%i] ) % MOD\n ",
"i",
"range(2, size + 1)",
"range",
"2",
"size + 1",
"size",
"1",
"temp_inv[i] = ( -(MOD // i) * temp_inv[MOD%i] ) % MOD",
"temp_inv[i]",
"temp_inv",
"i",
"( -(MOD // i) * temp_inv[MOD%i] ) % MOD",
"-(MOD // i) * temp_inv[MOD%i]",
"-(MOD // i)",
"MOD // i",
"MOD",
"i",
"temp_inv[MOD%i]",
"temp_inv",
"MOD%i",
"MOD",
"i",
"MOD",
"for i in range(2, size + 1):\n self.fact[i] = self.fact[i-1] * i % MOD\n self.inv[i] = self.inv[i-1] * temp_inv[i] % MOD\n\n ",
"i",
"range(2, size + 1)",
"range",
"2",
"size + 1",
"size",
"1",
"self.fact[i] = self.fact[i-1] * i % MOD",
"self.fact[i]",
"self.fact",
"self",
"fact",
"i",
"self.fact[i-1] * i % MOD",
"self.fact[i-1] * i",
"self.fact[i-1]",
"self.fact",
"self",
"fact",
"i-1",
"i",
"1",
"i",
"MOD",
"self.inv[i] = self.inv[i-1] * temp_inv[i] % MOD",
"self.inv[i]",
"self.inv",
"self",
"inv",
"i",
"self.inv[i-1] * temp_inv[i] % MOD",
"self.inv[i-1] * temp_inv[i]",
"self.inv[i-1]",
"self.inv",
"self",
"inv",
"i-1",
"i",
"1",
"temp_inv[i]",
"temp_inv",
"i",
"MOD",
"self",
"self",
"size",
"size",
"def cmb(self, n, r):\n #print(n, r)\n if n <= 1 or n == r:\n return 1\n elif r == 1:\n return n\n res = (self.fact[n] * self.inv[r] % MOD ) * self.inv[n-r] % MOD\n #print(res)\n return res",
"cmb",
"if n <= 1 or n == r:\n return 1\n elif r == 1:\n return n\n ",
"n <= 1 or n == r",
"n <= 1",
"n",
"1",
"n == r",
"n",
"r",
"return 1",
"1",
"elif r == 1:\n return n\n ",
"r == 1",
"r",
"1",
"return n",
"n",
"res = (self.fact[n] * self.inv[r] % MOD ) * self.inv[n-r] % MOD",
"res",
"(self.fact[n] * self.inv[r] % MOD ) * self.inv[n-r] % MOD",
"(self.fact[n] * self.inv[r] % MOD ) * self.inv[n-r]",
"self.fact[n] * self.inv[r] % MOD",
"self.fact[n] * self.inv[r]",
"self.fact[n]",
"self.fact",
"self",
"fact",
"n",
"self.inv[r]",
"self.inv",
"self",
"inv",
"r",
"MOD",
"self.inv[n-r]",
"self.inv",
"self",
"inv",
"n-r",
"n",
"r",
"MOD",
"return res",
"res",
"self",
"self",
"n",
"n",
"r",
"r",
"c = ModCmb(h+w)",
"c",
"ModCmb(h+w)",
"ModCmb",
"h+w",
"h",
"w",
"ans = 0",
"ans",
"0",
"x = h-a-1",
"x",
"h-a-1",
"h-a",
"h",
"a",
"1",
"y = w-b-1",
"y",
"w-b-1",
"w-b",
"w",
"b",
"1",
"for i in range(h-a):\n j = h+w-2-i-b\n #print(i, j)\n #print(i+b-1, b-1, j, w-b-1)\n ans += c.cmb(i+b-1, b-1) * c.cmb(j, w-b-1)\n ans %= MOD",
"i",
"range(h-a)",
"range",
"h-a",
"h",
"a",
"j = h+w-2-i-b",
"j",
"h+w-2-i-b",
"h+w-2-i",
"h+w-2",
"h+w",
"h",
"w",
"2",
"i",
"b",
"ans += c.cmb(i+b-1, b-1) * c.cmb(j, w-b-1)",
"ans",
"c.cmb(i+b-1, b-1) * c.cmb(j, w-b-1)",
"c.cmb(i+b-1, b-1)",
"c.cmb",
"c",
"cmb",
"i+b-1",
"i+b",
"i",
"b",
"1",
"b-1",
"b",
"1",
"c.cmb(j, w-b-1)",
"c.cmb",
"c",
"cmb",
"j",
"w-b-1",
"w-b",
"w",
"b",
"1",
"ans %= MOD",
"ans",
"MOD",
"print(ans % MOD)",
"print",
"ans % MOD",
"ans",
"MOD",
"a, b = map(int, input().split())",
"map(int, input().split())",
"a",
"c = ModCmb(h+w)",
"ModCmb(h+w)",
"c",
"h, w, a, b = map(int, input().split())",
"map(int, input().split())",
"h",
"b = map(int, input().split())",
"map(int, input().split())",
"b",
"ans += c.cmb(i+b-1, b-1) * c.cmb(j, w-b-1)",
"c.cmb(i+b-1, b-1) * c.cmb(j, w-b-1)",
"ans",
"x = h-a-1",
"h-a-1",
"x",
"w, a, b = map(int, input().split())",
"map(int, input().split())",
"w",
"MOD = 10 ** 9 + 7",
"10 ** 9 + 7",
"MOD",
"ans %= MOD",
"MOD",
"ans",
"class ModCmb:\n def __init__(self, size):\n self.inv = [1] * (size + 1)\n self.fact = [1] * (size + 1)\n temp_inv = [1] * (size + 1)\n for i in range(2, size + 1):\n temp_inv[i] = ( -(MOD // i) * temp_inv[MOD%i] ) % MOD\n for i in range(2, size + 1):\n self.fact[i] = self.fact[i-1] * i % MOD\n self.inv[i] = self.inv[i-1] * temp_inv[i] % MOD\n\n def cmb(self, n, r):\n #print(n, r)\n if n <= 1 or n == r:\n return 1\n elif r == 1:\n return n\n res = (self.fact[n] * self.inv[r] % MOD ) * self.inv[n-r] % MOD\n #print(res)\n return res",
"class ModCmb:\n def __init__(self, size):\n self.inv = [1] * (size + 1)\n self.fact = [1] * (size + 1)\n temp_inv = [1] * (size + 1)\n for i in range(2, size + 1):\n temp_inv[i] = ( -(MOD // i) * temp_inv[MOD%i] ) % MOD\n for i in range(2, size + 1):\n self.fact[i] = self.fact[i-1] * i % MOD\n self.inv[i] = self.inv[i-1] * temp_inv[i] % MOD\n\n def cmb(self, n, r):\n #print(n, r)\n if n <= 1 or n == r:\n return 1\n elif r == 1:\n return n\n res = (self.fact[n] * self.inv[r] % MOD ) * self.inv[n-r] % MOD\n #print(res)\n return res",
"ModCmb",
"j = h+w-2-i-b",
"h+w-2-i-b",
"j",
"y = w-b-1",
"w-b-1",
"y",
"ans = 0",
"0",
"ans"
] | h, w, a, b = map(int, input().split())
MOD = 10 ** 9 + 7
class ModCmb:
def __init__(self, size):
self.inv = [1] * (size + 1)
self.fact = [1] * (size + 1)
temp_inv = [1] * (size + 1)
for i in range(2, size + 1):
temp_inv[i] = ( -(MOD // i) * temp_inv[MOD%i] ) % MOD
for i in range(2, size + 1):
self.fact[i] = self.fact[i-1] * i % MOD
self.inv[i] = self.inv[i-1] * temp_inv[i] % MOD
def cmb(self, n, r):
#print(n, r)
if n <= 1 or n == r:
return 1
elif r == 1:
return n
res = (self.fact[n] * self.inv[r] % MOD ) * self.inv[n-r] % MOD
#print(res)
return res
c = ModCmb(h+w)
ans = 0
x = h-a-1
y = w-b-1
for i in range(h-a):
j = h+w-2-i-b
#print(i, j)
#print(i+b-1, b-1, j, w-b-1)
ans += c.cmb(i+b-1, b-1) * c.cmb(j, w-b-1)
ans %= MOD
print(ans % MOD)
|
[
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,
17,
0,
13,
17,
28,
13,
4,
13,
17,
4,
13,
13,
0,
18,
13,
13,
2,
2,
13,
13,
13,
0,
13,
2,
12,
13,
29,
2,
2,
2,
18,
13,
13,
4,
13,
18,
13,
2,
13,
13,
2,
13,
17,
13,
4,
13,
18,
13,
13,
2,
13,
17,
13,
13,
23,
13,
23,
13,
0,
13,
17,
28,
13,
4,
13,
2,
13,
13,
0,
13,
4,
13,
2,
2,
13,
17,
13,
13,
0,
13,
4,
13,
2,
2,
2,
2,
13,
13,
13,
13,
17,
2,
2,
13,
13,
17,
0,
13,
2,
13,
13,
0,
13,
13,
4,
13,
13,
10,
2,
13,
10,
17,
13,
10,
4,
13,
10,
13,
13,
10,
12,
13,
10,
4,
13,
10,
4,
13,
10,
4,
13,
10,
4,
13,
10,
17,
13,
10,
2,
13,
10,
2,
13,
10,
4,
13,
10,
2,
13
] | [
[
170,
2
],
[
170,
11
],
[
170,
12
],
[
170,
13
],
[
173,
15
],
[
164,
22
],
[
161,
28
],
[
32,
31
],
[
165,
37
],
[
134,
39
],
[
165,
40
],
[
31,
41
],
[
162,
44
],
[
135,
44
],
[
31,
45
],
[
174,
46
],
[
134,
48
],
[
165,
57
],
[
81,
58
],
[
165,
62
],
[
81,
64
],
[
83,
65
],
[
174,
67
],
[
174,
69
],
[
165,
73
],
[
83,
74
],
[
174,
76
],
[
174,
78
],
[
174,
79
],
[
81,
81
],
[
83,
83
],
[
137,
85
],
[
89,
88
],
[
153,
92
],
[
141,
93
],
[
158,
95
],
[
147,
97
],
[
171,
100
],
[
88,
102
],
[
88,
103
],
[
149,
105
],
[
147,
107
],
[
156,
112
],
[
153,
113
],
[
171,
114
],
[
88,
115
],
[
153,
119
],
[
88,
120
],
[
167,
123
],
[
159,
125
],
[
150,
126
],
[
143,
128
],
[
174,
129
],
[
144,
132
],
[
168,
132
],
[
138,
132
],
[
134,
135
],
[
137,
138
],
[
170,
141
],
[
174,
143
],
[
143,
144
],
[
149,
150
],
[
170,
153
],
[
170,
156
],
[
158,
159
],
[
161,
162
],
[
164,
165
],
[
167,
168
],
[
170,
171
],
[
173,
174
]
] | [
"H, W, A, B = map(int, input().split())\nmod = 10**9+7\n\nF = [1]*200010\np = 1\nfor i in range(1, len(F)):\n F[i] = p = p*i%mod\n\ndef comb(n, k):\n return F[n]*pow(F[n-k], mod-2, mod)*pow(F[k], mod-2, mod)%mod\n\nans = 0\nfor h in range(H-A):\n x = comb(B-1+h, h) # 右にB-1回、下にh回移動する方法の数\n y = comb(W+H-B-h-2, H-h-1) # 右にW-B-1回、下にH-h-1回移動する方法の数\n ans += x*y\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",
"F = [1]*200010",
"F",
"[1]*200010",
"[1]",
"1",
"200010",
"p = 1",
"p",
"1",
"for i in range(1, len(F)):\n F[i] = p = p*i%mod",
"i",
"range(1, len(F))",
"range",
"1",
"len(F)",
"len",
"F",
"F[i] = p = p*i%mod",
"F[i]",
"F",
"i",
"p*i%mod",
"p*i",
"p",
"i",
"mod",
"= p = p*i%mod",
"p",
"p*i%mod",
"def comb(n, k):\n return F[n]*pow(F[n-k], mod-2, mod)*pow(F[k], mod-2, mod)%mod",
"comb",
"return F[n]*pow(F[n-k], mod-2, mod)*pow(F[k], mod-2, mod)%mod",
"F[n]*pow(F[n-k], mod-2, mod)*pow(F[k], mod-2, mod)%mod",
"F[n]*pow(F[n-k], mod-2, mod)*pow(F[k], mod-2, mod)",
"F[n]*pow(F[n-k], mod-2, mod)",
"F[n]",
"F",
"n",
"pow(F[n-k], mod-2, mod)",
"pow",
"F[n-k]",
"F",
"n-k",
"n",
"k",
"mod-2",
"mod",
"2",
"mod",
"pow(F[k], mod-2, mod)",
"pow",
"F[k]",
"F",
"k",
"mod-2",
"mod",
"2",
"mod",
"mod",
"n",
"n",
"k",
"k",
"ans = 0",
"ans",
"0",
"for h in range(H-A):\n x = comb(B-1+h, h) # 右にB-1回、下にh回移動する方法の数\n y = comb(W+H-B-h-2, H-h-1) # 右にW-B-1回、下にH-h-1回移動する方法の数\n ans += x*y\n ans %= mod",
"h",
"range(H-A)",
"range",
"H-A",
"H",
"A",
"x = comb(B-1+h, h)",
"x",
"comb(B-1+h, h)",
"comb",
"B-1+h",
"B-1",
"B",
"1",
"h",
"h",
"y = comb(W+H-B-h-2, H-h-1)",
"y",
"comb(W+H-B-h-2, H-h-1)",
"comb",
"W+H-B-h-2",
"W+H-B-h",
"W+H-B",
"W+H",
"W",
"H",
"B",
"h",
"2",
"H-h-1",
"H-h",
"H",
"h",
"1",
"ans += x*y",
"ans",
"x*y",
"x",
"y",
"ans %= mod",
"ans",
"mod",
"print(ans)",
"print",
"ans",
"p = p*i%mod",
"p*i%mod",
"p",
"ans = 0",
"0",
"ans",
"A, B = map(int, input().split())",
"map(int, input().split())",
"A",
"ans %= mod",
"mod",
"ans",
"def comb(n, k):\n return F[n]*pow(F[n-k], mod-2, mod)*pow(F[k], mod-2, mod)%mod",
"def comb(n, k):\n return F[n]*pow(F[n-k], mod-2, mod)*pow(F[k], mod-2, mod)%mod",
"comb",
"y = comb(W+H-B-h-2, H-h-1)",
"comb(W+H-B-h-2, H-h-1)",
"y",
"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",
"x = comb(B-1+h, h)",
"comb(B-1+h, h)",
"x",
"p = 1",
"1",
"p",
"F = [1]*200010",
"[1]*200010",
"F",
"ans += x*y",
"x*y",
"ans",
"B = map(int, input().split())",
"map(int, input().split())",
"B",
"mod = 10**9+7",
"10**9+7",
"mod"
] | H, W, A, B = map(int, input().split())
mod = 10**9+7
F = [1]*200010
p = 1
for i in range(1, len(F)):
F[i] = p = p*i%mod
def comb(n, k):
return F[n]*pow(F[n-k], mod-2, mod)*pow(F[k], mod-2, mod)%mod
ans = 0
for h in range(H-A):
x = comb(B-1+h, h) # 右にB-1回、下にh回移動する方法の数
y = comb(W+H-B-h-2, H-h-1) # 右にW-B-1回、下にH-h-1回移動する方法の数
ans += x*y
ans %= mod
print(ans) |
[
7,
6,
13,
12,
13,
0,
18,
13,
13,
2,
13,
17,
0,
18,
13,
13,
13,
0,
18,
13,
13,
2,
39,
17,
17,
2,
39,
17,
13,
0,
18,
13,
13,
2,
39,
17,
17,
2,
39,
17,
13,
0,
18,
13,
13,
2,
39,
17,
17,
2,
39,
17,
13,
28,
13,
4,
13,
17,
2,
13,
17,
0,
18,
18,
13,
13,
13,
2,
2,
18,
18,
13,
13,
2,
13,
17,
13,
13,
0,
18,
18,
13,
13,
13,
2,
2,
40,
18,
18,
13,
13,
2,
13,
13,
2,
13,
13,
13,
0,
18,
18,
13,
13,
13,
2,
2,
18,
18,
13,
13,
2,
13,
17,
18,
18,
13,
13,
13,
13,
23,
13,
23,
13,
17,
23,
13,
2,
2,
17,
17,
17,
12,
13,
14,
2,
2,
2,
13,
13,
2,
13,
17,
2,
13,
17,
29,
17,
29,
2,
2,
18,
18,
13,
13,
13,
2,
2,
18,
18,
13,
13,
13,
18,
18,
13,
13,
2,
13,
13,
18,
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,
2,
2,
17,
17,
17,
0,
13,
4,
13,
2,
2,
13,
13,
17,
0,
13,
17,
28,
13,
4,
13,
2,
13,
13,
0,
13,
2,
2,
13,
2,
4,
18,
13,
13,
2,
2,
2,
2,
13,
17,
13,
13,
13,
2,
2,
13,
17,
13,
4,
18,
13,
13,
2,
2,
2,
2,
2,
13,
17,
13,
17,
13,
13,
2,
13,
17,
13,
4,
13,
13,
4,
13,
10,
12,
13,
10,
6,
13
] | [
[
9,
6
],
[
120,
7
],
[
122,
8
],
[
122,
10
],
[
16,
13
],
[
120,
14
],
[
125,
15
],
[
125,
16
],
[
21,
18
],
[
120,
19
],
[
122,
28
],
[
33,
30
],
[
120,
31
],
[
122,
40
],
[
45,
42
],
[
120,
43
],
[
122,
52
],
[
55,
54
],
[
122,
59
],
[
67,
62
],
[
18,
63
],
[
120,
64
],
[
54,
66
],
[
18,
70
],
[
120,
71
],
[
54,
74
],
[
54,
76
],
[
125,
77
],
[
84,
79
],
[
42,
80
],
[
120,
81
],
[
54,
83
],
[
42,
88
],
[
120,
89
],
[
125,
92
],
[
54,
93
],
[
125,
95
],
[
54,
96
],
[
125,
97
],
[
104,
99
],
[
30,
100
],
[
120,
101
],
[
54,
103
],
[
30,
107
],
[
120,
108
],
[
54,
111
],
[
79,
113
],
[
42,
114
],
[
120,
115
],
[
54,
117
],
[
125,
118
],
[
120,
120
],
[
123,
122
],
[
126,
125
],
[
178,
137
],
[
180,
138
],
[
178,
140
],
[
180,
143
],
[
176,
152
],
[
178,
154
],
[
176,
159
],
[
180,
161
],
[
176,
164
],
[
178,
167
],
[
180,
168
],
[
176,
170
],
[
176,
173
],
[
176,
176
],
[
178,
178
],
[
180,
180
],
[
185,
184
],
[
185,
193
],
[
185,
194
],
[
185,
195
],
[
198,
197
],
[
205,
204
],
[
184,
209
],
[
193,
210
],
[
214,
213
],
[
217,
216
],
[
193,
220
],
[
195,
221
],
[
224,
223
],
[
213,
226
],
[
223,
226
],
[
204,
230
],
[
132,
231
],
[
184,
236
],
[
194,
238
],
[
195,
239
],
[
216,
240
],
[
184,
243
],
[
194,
245
],
[
204,
248
],
[
132,
249
],
[
194,
255
],
[
193,
257
],
[
195,
259
],
[
216,
260
],
[
194,
262
],
[
197,
264
],
[
223,
267
],
[
213,
267
],
[
272,
269
]
] | [
"class Combination:\n def __init__(self, size=100, mod=10**9 + 7):\n self.size = size + 2\n self.mod = mod\n self.fact = [1, 1] + [0] * size\n self.factInv = [1, 1] + [0] * size\n self.inv = [0, 1] + [0] * size\n\n for i in range(2, size + 2):\n self.fact[i] = self.fact[i - 1] * i % mod\n self.inv[i] = -self.inv[mod % i] * (mod // i) % mod\n self.factInv[i] = self.factInv[i - 1] * self.inv[i] % mod\n\n def ncr(self, n, r):\n if n < r or n < 0 or r < 0:\n return 0\n return self.fact[n] * (self.factInv[r] * self.factInv[n - r] % self.mod) % self.mod\n\ndef sol():\n H, W, A, B = map(int, input().split())\n MOD = 10**9 + 7\n\n comb = Combination(H + W + 100)\n\n ans = 0\n for i in range(W - B):\n ans = (ans + comb.ncr(H - 1 - A + B + i, H - 1 - A) * comb.ncr(A - 1 + W - 1 - B - i, A - 1)) % MOD\n\n print(ans)\n\n\nsol()",
"class Combination:\n def __init__(self, size=100, mod=10**9 + 7):\n self.size = size + 2\n self.mod = mod\n self.fact = [1, 1] + [0] * size\n self.factInv = [1, 1] + [0] * size\n self.inv = [0, 1] + [0] * size\n\n for i in range(2, size + 2):\n self.fact[i] = self.fact[i - 1] * i % mod\n self.inv[i] = -self.inv[mod % i] * (mod // i) % mod\n self.factInv[i] = self.factInv[i - 1] * self.inv[i] % mod\n\n def ncr(self, n, r):\n if n < r or n < 0 or r < 0:\n return 0\n return self.fact[n] * (self.factInv[r] * self.factInv[n - r] % self.mod) % self.mod",
"Combination",
"def __init__(self, size=100, mod=10**9 + 7):\n self.size = size + 2\n self.mod = mod\n self.fact = [1, 1] + [0] * size\n self.factInv = [1, 1] + [0] * size\n self.inv = [0, 1] + [0] * size\n\n for i in range(2, size + 2):\n self.fact[i] = self.fact[i - 1] * i % mod\n self.inv[i] = -self.inv[mod % i] * (mod // i) % mod\n self.factInv[i] = self.factInv[i - 1] * self.inv[i] % mod\n\n ",
"__init__",
"self.size = size + 2",
"self.size",
"self",
"size",
"size + 2",
"size",
"2",
"self.mod = mod",
"self.mod",
"self",
"mod",
"mod",
"self.fact = [1, 1] + [0] * size",
"self.fact",
"self",
"fact",
"[1, 1] + [0] * size",
"[1, 1]",
"1",
"1",
"[0] * size",
"[0]",
"0",
"size",
"self.factInv = [1, 1] + [0] * size",
"self.factInv",
"self",
"factInv",
"[1, 1] + [0] * size",
"[1, 1]",
"1",
"1",
"[0] * size",
"[0]",
"0",
"size",
"self.inv = [0, 1] + [0] * size",
"self.inv",
"self",
"inv",
"[0, 1] + [0] * size",
"[0, 1]",
"0",
"1",
"[0] * size",
"[0]",
"0",
"size",
"for i in range(2, size + 2):\n self.fact[i] = self.fact[i - 1] * i % mod\n self.inv[i] = -self.inv[mod % i] * (mod // i) % mod\n self.factInv[i] = self.factInv[i - 1] * self.inv[i] % mod\n\n ",
"i",
"range(2, size + 2)",
"range",
"2",
"size + 2",
"size",
"2",
"self.fact[i] = self.fact[i - 1] * i % mod",
"self.fact[i]",
"self.fact",
"self",
"fact",
"i",
"self.fact[i - 1] * i % mod",
"self.fact[i - 1] * i",
"self.fact[i - 1]",
"self.fact",
"self",
"fact",
"i - 1",
"i",
"1",
"i",
"mod",
"self.inv[i] = -self.inv[mod % i] * (mod // i) % mod",
"self.inv[i]",
"self.inv",
"self",
"inv",
"i",
"-self.inv[mod % i] * (mod // i) % mod",
"-self.inv[mod % i] * (mod // i)",
"-self.inv[mod % i]",
"self.inv[mod % i]",
"self.inv",
"self",
"inv",
"mod % i",
"mod",
"i",
"mod // i",
"mod",
"i",
"mod",
"self.factInv[i] = self.factInv[i - 1] * self.inv[i] % mod",
"self.factInv[i]",
"self.factInv",
"self",
"factInv",
"i",
"self.factInv[i - 1] * self.inv[i] % mod",
"self.factInv[i - 1] * self.inv[i]",
"self.factInv[i - 1]",
"self.factInv",
"self",
"factInv",
"i - 1",
"i",
"1",
"self.inv[i]",
"self.inv",
"self",
"inv",
"i",
"mod",
"self",
"self",
"size=100",
"size",
"100",
"mod=10**9 + 7",
"mod",
"10**9 + 7",
"10**9",
"10",
"9",
"7",
"def ncr(self, n, r):\n if n < r or n < 0 or r < 0:\n return 0\n return self.fact[n] * (self.factInv[r] * self.factInv[n - r] % self.mod) % self.mod",
"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",
"return self.fact[n] * (self.factInv[r] * self.factInv[n - r] % self.mod) % self.mod",
"self.fact[n] * (self.factInv[r] * self.factInv[n - r] % self.mod) % self.mod",
"self.fact[n] * (self.factInv[r] * self.factInv[n - r] % self.mod)",
"self.fact[n]",
"self.fact",
"self",
"fact",
"n",
"self.factInv[r] * self.factInv[n - r] % self.mod",
"self.factInv[r] * self.factInv[n - r]",
"self.factInv[r]",
"self.factInv",
"self",
"factInv",
"r",
"self.factInv[n - r]",
"self.factInv",
"self",
"factInv",
"n - r",
"n",
"r",
"self.mod",
"self",
"mod",
"self.mod",
"self",
"mod",
"self",
"self",
"n",
"n",
"r",
"r",
"def sol():\n H, W, A, B = map(int, input().split())\n MOD = 10**9 + 7\n\n comb = Combination(H + W + 100)\n\n ans = 0\n for i in range(W - B):\n ans = (ans + comb.ncr(H - 1 - A + B + i, H - 1 - A) * comb.ncr(A - 1 + W - 1 - B - i, A - 1)) % MOD\n\n print(ans)",
"sol",
"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(H + W + 100)",
"comb",
"Combination(H + W + 100)",
"Combination",
"H + W + 100",
"H + W",
"H",
"W",
"100",
"ans = 0",
"ans",
"0",
"for i in range(W - B):\n ans = (ans + comb.ncr(H - 1 - A + B + i, H - 1 - A) * comb.ncr(A - 1 + W - 1 - B - i, A - 1)) % MOD\n\n ",
"i",
"range(W - B)",
"range",
"W - B",
"W",
"B",
"ans = (ans + comb.ncr(H - 1 - A + B + i, H - 1 - A) * comb.ncr(A - 1 + W - 1 - B - i, A - 1)) % MOD",
"ans",
"(ans + comb.ncr(H - 1 - A + B + i, H - 1 - A) * comb.ncr(A - 1 + W - 1 - B - i, A - 1)) % MOD",
"ans + comb.ncr(H - 1 - A + B + i, H - 1 - A) * comb.ncr(A - 1 + W - 1 - B - i, A - 1)",
"ans",
"comb.ncr(H - 1 - A + B + i, H - 1 - A) * comb.ncr(A - 1 + W - 1 - B - i, A - 1)",
"comb.ncr(H - 1 - A + B + i, H - 1 - A)",
"comb.ncr",
"comb",
"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",
"comb.ncr(A - 1 + W - 1 - B - i, A - 1)",
"comb.ncr",
"comb",
"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",
"MOD",
"print(ans)",
"print",
"ans",
"sol()",
"sol",
"def sol():\n H, W, A, B = map(int, input().split())\n MOD = 10**9 + 7\n\n comb = Combination(H + W + 100)\n\n ans = 0\n for i in range(W - B):\n ans = (ans + comb.ncr(H - 1 - A + B + i, H - 1 - A) * comb.ncr(A - 1 + W - 1 - B - i, A - 1)) % MOD\n\n print(ans)",
"def sol():\n H, W, A, B = map(int, input().split())\n MOD = 10**9 + 7\n\n comb = Combination(H + W + 100)\n\n ans = 0\n for i in range(W - B):\n ans = (ans + comb.ncr(H - 1 - A + B + i, H - 1 - A) * comb.ncr(A - 1 + W - 1 - B - i, A - 1)) % MOD\n\n print(ans)",
"sol",
"class Combination:\n def __init__(self, size=100, mod=10**9 + 7):\n self.size = size + 2\n self.mod = mod\n self.fact = [1, 1] + [0] * size\n self.factInv = [1, 1] + [0] * size\n self.inv = [0, 1] + [0] * size\n\n for i in range(2, size + 2):\n self.fact[i] = self.fact[i - 1] * i % mod\n self.inv[i] = -self.inv[mod % i] * (mod // i) % mod\n self.factInv[i] = self.factInv[i - 1] * self.inv[i] % mod\n\n def ncr(self, n, r):\n if n < r or n < 0 or r < 0:\n return 0\n return self.fact[n] * (self.factInv[r] * self.factInv[n - r] % self.mod) % self.mod",
"class Combination:\n def __init__(self, size=100, mod=10**9 + 7):\n self.size = size + 2\n self.mod = mod\n self.fact = [1, 1] + [0] * size\n self.factInv = [1, 1] + [0] * size\n self.inv = [0, 1] + [0] * size\n\n for i in range(2, size + 2):\n self.fact[i] = self.fact[i - 1] * i % mod\n self.inv[i] = -self.inv[mod % i] * (mod // i) % mod\n self.factInv[i] = self.factInv[i - 1] * self.inv[i] % mod\n\n def ncr(self, n, r):\n if n < r or n < 0 or r < 0:\n return 0\n return self.fact[n] * (self.factInv[r] * self.factInv[n - r] % self.mod) % self.mod",
"Combination"
] | class Combination:
def __init__(self, size=100, mod=10**9 + 7):
self.size = size + 2
self.mod = mod
self.fact = [1, 1] + [0] * size
self.factInv = [1, 1] + [0] * size
self.inv = [0, 1] + [0] * size
for i in range(2, size + 2):
self.fact[i] = self.fact[i - 1] * i % mod
self.inv[i] = -self.inv[mod % i] * (mod // i) % mod
self.factInv[i] = self.factInv[i - 1] * self.inv[i] % mod
def ncr(self, n, r):
if n < r or n < 0 or r < 0:
return 0
return self.fact[n] * (self.factInv[r] * self.factInv[n - r] % self.mod) % self.mod
def sol():
H, W, A, B = map(int, input().split())
MOD = 10**9 + 7
comb = Combination(H + W + 100)
ans = 0
for i in range(W - B):
ans = (ans + comb.ncr(H - 1 - A + B + i, H - 1 - A) * comb.ncr(A - 1 + W - 1 - B - i, A - 1)) % MOD
print(ans)
sol() |
[
7,
0,
13,
2,
2,
17,
17,
17,
12,
13,
0,
13,
2,
39,
17,
2,
13,
17,
0,
18,
13,
17,
17,
0,
18,
13,
17,
17,
28,
13,
4,
13,
17,
2,
13,
17,
0,
18,
13,
13,
2,
2,
40,
2,
13,
13,
18,
13,
2,
13,
13,
13,
29,
13,
23,
13,
0,
13,
2,
39,
17,
2,
2,
17,
2,
17,
17,
17,
0,
13,
4,
13,
2,
2,
17,
17,
17,
0,
13,
2,
39,
17,
2,
2,
17,
17,
17,
28,
13,
4,
13,
2,
17,
17,
0,
18,
13,
2,
13,
17,
2,
2,
18,
13,
13,
18,
13,
2,
13,
17,
13,
28,
13,
4,
13,
2,
17,
2,
17,
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,
28,
13,
4,
13,
2,
13,
17,
2,
13,
17,
0,
13,
2,
2,
2,
2,
2,
18,
13,
2,
2,
2,
13,
13,
13,
17,
18,
13,
2,
13,
17,
18,
13,
2,
2,
13,
13,
17,
13,
2,
2,
2,
18,
13,
2,
2,
2,
13,
13,
13,
17,
18,
13,
2,
13,
17,
18,
13,
2,
13,
13,
13,
13,
0,
13,
13,
4,
13,
13,
10,
4,
13,
10,
2,
13,
10,
4,
13,
10,
17,
13,
10,
4,
13,
10,
2,
13,
10,
2,
13,
10,
13,
13,
10,
4,
13,
10,
12,
13,
10,
4,
13,
10,
2,
13
] | [
[
236,
2
],
[
12,
11
],
[
55,
16
],
[
22,
19
],
[
11,
20
],
[
27,
24
],
[
11,
25
],
[
30,
29
],
[
55,
34
],
[
40,
37
],
[
11,
38
],
[
29,
39
],
[
237,
44
],
[
29,
45
],
[
11,
47
],
[
237,
49
],
[
29,
50
],
[
237,
51
],
[
11,
53
],
[
55,
55
],
[
254,
57
],
[
221,
69
],
[
249,
71
],
[
224,
78
],
[
89,
88
],
[
100,
95
],
[
225,
96
],
[
88,
98
],
[
225,
103
],
[
88,
104
],
[
222,
106
],
[
88,
108
],
[
237,
110
],
[
113,
112
],
[
126,
121
],
[
255,
122
],
[
112,
124
],
[
255,
129
],
[
112,
130
],
[
112,
132
],
[
237,
134
],
[
251,
136
],
[
251,
145
],
[
251,
146
],
[
251,
147
],
[
230,
149
],
[
153,
152
],
[
246,
156
],
[
228,
159
],
[
239,
162
],
[
255,
169
],
[
152,
173
],
[
234,
174
],
[
252,
175
],
[
225,
178
],
[
152,
180
],
[
225,
183
],
[
234,
186
],
[
252,
187
],
[
237,
189
],
[
255,
194
],
[
252,
198
],
[
228,
199
],
[
152,
200
],
[
225,
203
],
[
252,
205
],
[
225,
208
],
[
228,
210
],
[
152,
211
],
[
237,
212
],
[
237,
213
],
[
242,
215
],
[
237,
216
],
[
243,
219
],
[
240,
219
],
[
231,
219
],
[
221,
222
],
[
224,
225
],
[
251,
228
],
[
230,
231
],
[
251,
234
],
[
236,
237
],
[
239,
240
],
[
237,
242
],
[
242,
243
],
[
251,
246
],
[
251,
252
],
[
254,
255
]
] | [
"Q = 10**9+7\ndef getInv(N):#Qはmod\n inv = [0] * (N + 1)\n inv[0] = 1\n inv[1] = 1\n for i in range(2, N + 1):\n inv[i] = (-(Q // i) * inv[Q%i]) % Q\n return inv\nmodfunctional = [1]*(2*10**5+1)\nmodinv = getInv(10**5+1)\nmodinvfunctional = [1]*(10**5+1)\nfor i in range(10**5):\n modinvfunctional[i+1] = (modinvfunctional[i]*modinv[i+1])%Q\nfor i in range(2*10**5):\n modfunctional[i+1] = (modfunctional[i]*(i+1))%Q\nH, W, A, B = map( int, input().split())\nans = 0\nfor i in range(B+1, W+1):\n ans += (modfunctional[i+H-A-2]*modinvfunctional[i-1]*modinvfunctional[H-A-1]%Q)*(modfunctional[A+W-i-1]*modinvfunctional[A-1]*modinvfunctional[W-i]%Q)%Q\n ans %= Q\nprint(ans)",
"Q = 10**9+7",
"Q",
"10**9+7",
"10**9",
"10",
"9",
"7",
"def getInv(N):#Qはmod\n inv = [0] * (N + 1)\n inv[0] = 1\n inv[1] = 1\n for i in range(2, N + 1):\n inv[i] = (-(Q // i) * inv[Q%i]) % Q\n return inv",
"getInv",
"inv = [0] * (N + 1)",
"inv",
"[0] * (N + 1)",
"[0]",
"0",
"N + 1",
"N",
"1",
"inv[0] = 1",
"inv[0]",
"inv",
"0",
"1",
"inv[1] = 1",
"inv[1]",
"inv",
"1",
"1",
"for i in range(2, N + 1):\n inv[i] = (-(Q // i) * inv[Q%i]) % Q\n ",
"i",
"range(2, N + 1)",
"range",
"2",
"N + 1",
"N",
"1",
"inv[i] = (-(Q // i) * inv[Q%i]) % Q",
"inv[i]",
"inv",
"i",
"(-(Q // i) * inv[Q%i]) % Q",
"-(Q // i) * inv[Q%i]",
"-(Q // i)",
"Q // i",
"Q",
"i",
"inv[Q%i]",
"inv",
"Q%i",
"Q",
"i",
"Q",
"return inv",
"inv",
"N",
"N",
"modfunctional = [1]*(2*10**5+1)",
"modfunctional",
"[1]*(2*10**5+1)",
"[1]",
"1",
"2*10**5+1",
"2*10**5",
"2",
"10**5",
"10",
"5",
"1",
"modinv = getInv(10**5+1)",
"modinv",
"getInv(10**5+1)",
"getInv",
"10**5+1",
"10**5",
"10",
"5",
"1",
"modinvfunctional = [1]*(10**5+1)",
"modinvfunctional",
"[1]*(10**5+1)",
"[1]",
"1",
"10**5+1",
"10**5",
"10",
"5",
"1",
"for i in range(10**5):\n modinvfunctional[i+1] = (modinvfunctional[i]*modinv[i+1])%Q",
"i",
"range(10**5)",
"range",
"10**5",
"10",
"5",
"modinvfunctional[i+1] = (modinvfunctional[i]*modinv[i+1])%Q",
"modinvfunctional[i+1]",
"modinvfunctional",
"i+1",
"i",
"1",
"(modinvfunctional[i]*modinv[i+1])%Q",
"modinvfunctional[i]*modinv[i+1]",
"modinvfunctional[i]",
"modinvfunctional",
"i",
"modinv[i+1]",
"modinv",
"i+1",
"i",
"1",
"Q",
"for i in range(2*10**5):\n modfunctional[i+1] = (modfunctional[i]*(i+1))%Q",
"i",
"range(2*10**5)",
"range",
"2*10**5",
"2",
"10**5",
"10",
"5",
"modfunctional[i+1] = (modfunctional[i]*(i+1))%Q",
"modfunctional[i+1]",
"modfunctional",
"i+1",
"i",
"1",
"(modfunctional[i]*(i+1))%Q",
"modfunctional[i]*(i+1)",
"modfunctional[i]",
"modfunctional",
"i",
"i+1",
"i",
"1",
"Q",
"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(B+1, W+1):\n ans += (modfunctional[i+H-A-2]*modinvfunctional[i-1]*modinvfunctional[H-A-1]%Q)*(modfunctional[A+W-i-1]*modinvfunctional[A-1]*modinvfunctional[W-i]%Q)%Q\n ans %= Q",
"i",
"range(B+1, W+1)",
"range",
"B+1",
"B",
"1",
"W+1",
"W",
"1",
"ans += (modfunctional[i+H-A-2]*modinvfunctional[i-1]*modinvfunctional[H-A-1]%Q)*(modfunctional[A+W-i-1]*modinvfunctional[A-1]*modinvfunctional[W-i]%Q)%Q",
"ans",
"(modfunctional[i+H-A-2]*modinvfunctional[i-1]*modinvfunctional[H-A-1]%Q)*(modfunctional[A+W-i-1]*modinvfunctional[A-1]*modinvfunctional[W-i]%Q)%Q",
"(modfunctional[i+H-A-2]*modinvfunctional[i-1]*modinvfunctional[H-A-1]%Q)*(modfunctional[A+W-i-1]*modinvfunctional[A-1]*modinvfunctional[W-i]%Q)",
"modfunctional[i+H-A-2]*modinvfunctional[i-1]*modinvfunctional[H-A-1]%Q",
"modfunctional[i+H-A-2]*modinvfunctional[i-1]*modinvfunctional[H-A-1]",
"modfunctional[i+H-A-2]*modinvfunctional[i-1]",
"modfunctional[i+H-A-2]",
"modfunctional",
"i+H-A-2",
"i+H-A",
"i+H",
"i",
"H",
"A",
"2",
"modinvfunctional[i-1]",
"modinvfunctional",
"i-1",
"i",
"1",
"modinvfunctional[H-A-1]",
"modinvfunctional",
"H-A-1",
"H-A",
"H",
"A",
"1",
"Q",
"modfunctional[A+W-i-1]*modinvfunctional[A-1]*modinvfunctional[W-i]%Q",
"modfunctional[A+W-i-1]*modinvfunctional[A-1]*modinvfunctional[W-i]",
"modfunctional[A+W-i-1]*modinvfunctional[A-1]",
"modfunctional[A+W-i-1]",
"modfunctional",
"A+W-i-1",
"A+W-i",
"A+W",
"A",
"W",
"i",
"1",
"modinvfunctional[A-1]",
"modinvfunctional",
"A-1",
"A",
"1",
"modinvfunctional[W-i]",
"modinvfunctional",
"W-i",
"W",
"i",
"Q",
"Q",
"ans %= Q",
"ans",
"Q",
"print(ans)",
"print",
"ans",
"modinv = getInv(10**5+1)",
"getInv(10**5+1)",
"modinv",
"modinvfunctional = [1]*(10**5+1)",
"[1]*(10**5+1)",
"modinvfunctional",
"W, A, B = map( int, input().split())",
"map( int, input().split())",
"W",
"ans = 0",
"0",
"ans",
"H, W, A, B = map( int, input().split())",
"map( int, input().split())",
"H",
"Q = 10**9+7",
"10**9+7",
"Q",
"ans += (modfunctional[i+H-A-2]*modinvfunctional[i-1]*modinvfunctional[H-A-1]%Q)*(modfunctional[A+W-i-1]*modinvfunctional[A-1]*modinvfunctional[W-i]%Q)%Q",
"(modfunctional[i+H-A-2]*modinvfunctional[i-1]*modinvfunctional[H-A-1]%Q)*(modfunctional[A+W-i-1]*modinvfunctional[A-1]*modinvfunctional[W-i]%Q)%Q",
"ans",
"ans %= Q",
"Q",
"ans",
"B = map( int, input().split())",
"map( int, input().split())",
"B",
"def getInv(N):#Qはmod\n inv = [0] * (N + 1)\n inv[0] = 1\n inv[1] = 1\n for i in range(2, N + 1):\n inv[i] = (-(Q // i) * inv[Q%i]) % Q\n return inv",
"def getInv(N):#Qはmod\n inv = [0] * (N + 1)\n inv[0] = 1\n inv[1] = 1\n for i in range(2, N + 1):\n inv[i] = (-(Q // i) * inv[Q%i]) % Q\n return inv",
"getInv",
"A, B = map( int, input().split())",
"map( int, input().split())",
"A",
"modfunctional = [1]*(2*10**5+1)",
"[1]*(2*10**5+1)",
"modfunctional"
] | Q = 10**9+7
def getInv(N):#Qはmod
inv = [0] * (N + 1)
inv[0] = 1
inv[1] = 1
for i in range(2, N + 1):
inv[i] = (-(Q // i) * inv[Q%i]) % Q
return inv
modfunctional = [1]*(2*10**5+1)
modinv = getInv(10**5+1)
modinvfunctional = [1]*(10**5+1)
for i in range(10**5):
modinvfunctional[i+1] = (modinvfunctional[i]*modinv[i+1])%Q
for i in range(2*10**5):
modfunctional[i+1] = (modfunctional[i]*(i+1))%Q
H, W, A, B = map( int, input().split())
ans = 0
for i in range(B+1, W+1):
ans += (modfunctional[i+H-A-2]*modinvfunctional[i-1]*modinvfunctional[H-A-1]%Q)*(modfunctional[A+W-i-1]*modinvfunctional[A-1]*modinvfunctional[W-i]%Q)%Q
ans %= Q
print(ans)
|
[
7,
15,
13,
0,
13,
4,
13,
13,
4,
18,
4,
13,
13,
13,
13,
13,
0,
13,
2,
4,
13,
17,
17,
17,
12,
13,
29,
4,
13,
13,
2,
13,
17,
13,
23,
13,
23,
13,
2,
2,
17,
17,
17,
12,
13,
0,
13,
2,
2,
18,
13,
2,
13,
13,
18,
13,
13,
13,
29,
2,
2,
18,
13,
13,
4,
13,
13,
13,
23,
13,
23,
13,
0,
13,
39,
17,
28,
13,
4,
13,
17,
2,
13,
13,
4,
18,
13,
13,
2,
2,
13,
18,
13,
2,
13,
17,
13,
0,
13,
17,
28,
13,
4,
13,
2,
13,
13,
0,
13,
2,
2,
4,
13,
2,
2,
13,
17,
13,
13,
4,
13,
2,
2,
2,
2,
13,
13,
13,
17,
13,
2,
2,
13,
13,
17,
13,
0,
13,
13,
0,
13,
2,
13,
13,
4,
13,
4,
13,
13,
17,
17,
10,
4,
13,
10,
4,
13,
10,
2,
13,
10,
12,
13,
10,
2,
13,
10,
17,
13,
10,
13,
13,
10,
4,
13,
10,
39,
13,
10,
12,
13,
10,
4,
13,
10,
2,
13
] | [
[
182,
4
],
[
182,
13
],
[
182,
14
],
[
182,
15
],
[
164,
17
],
[
35,
29
],
[
37,
31
],
[
37,
33
],
[
35,
35
],
[
38,
37
],
[
47,
46
],
[
69,
52
],
[
71,
53
],
[
71,
56
],
[
165,
57
],
[
69,
63
],
[
180,
65
],
[
46,
66
],
[
165,
67
],
[
69,
69
],
[
71,
71
],
[
176,
73
],
[
78,
77
],
[
174,
82
],
[
156,
83
],
[
177,
86
],
[
77,
90
],
[
177,
92
],
[
77,
94
],
[
165,
96
],
[
167,
98
],
[
102,
101
],
[
174,
105
],
[
153,
106
],
[
185,
108
],
[
162,
112
],
[
183,
115
],
[
101,
117
],
[
101,
118
],
[
162,
120
],
[
156,
125
],
[
174,
126
],
[
183,
127
],
[
101,
129
],
[
156,
132
],
[
183,
133
],
[
165,
135
],
[
170,
137
],
[
186,
138
],
[
158,
140
],
[
171,
142
],
[
168,
142
],
[
159,
142
],
[
165,
143
],
[
159,
148
],
[
171,
148
],
[
168,
148
],
[
182,
153
],
[
182,
156
],
[
158,
159
],
[
164,
165
],
[
167,
168
],
[
186,
170
],
[
170,
171
],
[
182,
174
],
[
176,
177
],
[
182,
183
],
[
185,
186
]
] | [
"import math\n\nh, w, a, b = map(int, input().split())\n\n#divmod\nmod = pow(10,9)+7\ndef divmod(num, mod=10**9+7):\n return pow(num, mod-2, mod)\n\n#combination\ndef comb(a,b):\n\tp=fact[a-b]*fact[b]%mod\n\treturn fact[a]*divmod(p)%mod\n\nfact = [1]\nfor i in range(1,h+w):\n fact.append(i*fact[i-1]%mod)\n#print(fact)\n\nans = 0\nfor j in range(h-a):\n tmp = comb(b-1+j,j)*comb(w+h-b-2-j,w-b-1)%mod\n ans += tmp\n ans = ans%mod\n# ans = ans + fact[b-1+j]*fact[w+h-b-2-j]/fact[b-1]/fact[j]/fact[w-b-1]/fact[h-1-j]\nprint(int(ans))\n\n'''\n単純なh*wのマス目だった場合\n#h-row / w-col\ncon = [[0]*w]*h\nfor i in range(h):\n con[i][0] = 1\nfor j in range(w):\n con[0][j] = 1\n\nfor k in range(1,h):\n for l in range(1,w):\n con[k][l] = con[k-1][l] + con[k][l-1]\n\nprint(con[h-1][w-1])\n'''\n\n'''\n全量を計算するやり方\nH*Wがデカすぎると時間というよりもメモリエラー\nprint('initialize')\ncon = [[0 for i in range(w)] for j in range(h)]\n#リスト内包表記で作らないとバグる\n#ダメな例 -> con = [[0]*w]*h\n#https://qiita.com/utgwkk/items/5ad2527f19150ae33322\nprint('initialize finished')\n\n\nfor i in range(h-a):\n con[i][0] = 1\n#print(con[0])\nfor j in range(w):\n #wは先に初期化やっちゃう\n con[0][j] = 1\n#print(con)\n\nfor k in range(1,h-a):\n# print(k)\n for l in range(1,b+1):\n con[k][l] = con[k-1][l] + con[k][l-1]\n#print(con[h-a-1][b-1])\n#print(con[h-a][b-1])\n#print(con[h-a-1][b])\n\nfor m in range(1,h):\n# print('---{} row---'.format(m))\n# print(con[m])\n for n in range(b,w):\n# print('m,n:('+str(m)+','+str(n)+')')\n con[m][n] = con[m-1][n] + con[m][n-1]\n# print(con[m])\n\nprint(con[h-1][w-1])\n'''\n",
"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",
"mod = pow(10,9)+7",
"mod",
"pow(10,9)+7",
"pow(10,9)",
"pow",
"10",
"9",
"7",
"def divmod(num, mod=10**9+7):\n return pow(num, mod-2, mod)\n\n#combination",
"divmod",
"return pow(num, mod-2, mod)",
"pow(num, mod-2, mod)",
"pow",
"num",
"mod-2",
"mod",
"2",
"mod",
"num",
"num",
"mod=10**9+7",
"mod",
"10**9+7",
"10**9",
"10",
"9",
"7",
"def comb(a,b):\n\tp=fact[a-b]*fact[b]%mod\n\treturn fact[a]*divmod(p)%mod",
"comb",
"p=fact[a-b]*fact[b]%mod",
"p",
"fact[a-b]*fact[b]%mod",
"fact[a-b]*fact[b]",
"fact[a-b]",
"fact",
"a-b",
"a",
"b",
"fact[b]",
"fact",
"b",
"mod",
"return fact[a]*divmod(p)%mod",
"fact[a]*divmod(p)%mod",
"fact[a]*divmod(p)",
"fact[a]",
"fact",
"a",
"divmod(p)",
"divmod",
"p",
"mod",
"a",
"a",
"b",
"b",
"fact = [1]",
"fact",
"[1]",
"1",
"for i in range(1,h+w):\n fact.append(i*fact[i-1]%mod)\n#print(fact)",
"i",
"range(1,h+w)",
"range",
"1",
"h+w",
"h",
"w",
"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",
"ans = 0",
"ans",
"0",
"for j in range(h-a):\n tmp = comb(b-1+j,j)*comb(w+h-b-2-j,w-b-1)%mod\n ans += tmp\n ans = ans%mod\n# ans = ans + fact[b-1+j]*fact[w+h-b-2-j]/fact[b-1]/fact[j]/fact[w-b-1]/fact[h-1-j]",
"j",
"range(h-a)",
"range",
"h-a",
"h",
"a",
"tmp = comb(b-1+j,j)*comb(w+h-b-2-j,w-b-1)%mod",
"tmp",
"comb(b-1+j,j)*comb(w+h-b-2-j,w-b-1)%mod",
"comb(b-1+j,j)*comb(w+h-b-2-j,w-b-1)",
"comb(b-1+j,j)",
"comb",
"b-1+j",
"b-1",
"b",
"1",
"j",
"j",
"comb(w+h-b-2-j,w-b-1)",
"comb",
"w+h-b-2-j",
"w+h-b-2",
"w+h-b",
"w+h",
"w",
"h",
"b",
"2",
"j",
"w-b-1",
"w-b",
"w",
"b",
"1",
"mod",
"ans += tmp",
"ans",
"tmp",
"ans = ans%mod",
"ans",
"ans%mod",
"ans",
"mod",
"print(int(ans))",
"print",
"int(ans)",
"int",
"ans",
"'''\n単純なh*wのマス目だった場合\n#h-row / w-col\ncon = [[0]*w]*h\nfor i in range(h):\n con[i][0] = 1\nfor j in range(w):\n con[0][j] = 1\n\nfor k in range(1,h):\n for l in range(1,w):\n con[k][l] = con[k-1][l] + con[k][l-1]\n\nprint(con[h-1][w-1])\n'''",
"'''\n全量を計算するやり方\nH*Wがデカすぎると時間というよりもメモリエラー\nprint('initialize')\ncon = [[0 for i in range(w)] for j in range(h)]\n#リスト内包表記で作らないとバグる\n#ダメな例 -> con = [[0]*w]*h\n#https://qiita.com/utgwkk/items/5ad2527f19150ae33322\nprint('initialize finished')\n\n\nfor i in range(h-a):\n con[i][0] = 1\n#print(con[0])\nfor j in range(w):\n #wは先に初期化やっちゃう\n con[0][j] = 1\n#print(con)\n\nfor k in range(1,h-a):\n# print(k)\n for l in range(1,b+1):\n con[k][l] = con[k-1][l] + con[k][l-1]\n#print(con[h-a-1][b-1])\n#print(con[h-a][b-1])\n#print(con[h-a-1][b])\n\nfor m in range(1,h):\n# print('---{} row---'.format(m))\n# print(con[m])\n for n in range(b,w):\n# print('m,n:('+str(m)+','+str(n)+')')\n con[m][n] = con[m-1][n] + con[m][n-1]\n# print(con[m])\n\nprint(con[h-1][w-1])\n'''",
"a, b = map(int, input().split())",
"map(int, input().split())",
"a",
"w, a, b = map(int, input().split())",
"map(int, input().split())",
"w",
"ans = ans%mod",
"ans%mod",
"ans",
"def comb(a,b):\n\tp=fact[a-b]*fact[b]%mod\n\treturn fact[a]*divmod(p)%mod",
"def comb(a,b):\n\tp=fact[a-b]*fact[b]%mod\n\treturn fact[a]*divmod(p)%mod",
"comb",
"mod = pow(10,9)+7",
"pow(10,9)+7",
"mod",
"ans = 0",
"0",
"ans",
"ans += tmp",
"tmp",
"ans",
"h, w, a, b = map(int, input().split())",
"map(int, input().split())",
"h",
"fact = [1]",
"[1]",
"fact",
"def divmod(num, mod=10**9+7):\n return pow(num, mod-2, mod)\n\n#combination",
"def divmod(num, mod=10**9+7):\n return pow(num, mod-2, mod)\n\n#combination",
"divmod",
"b = map(int, input().split())",
"map(int, input().split())",
"b",
"tmp = comb(b-1+j,j)*comb(w+h-b-2-j,w-b-1)%mod",
"comb(b-1+j,j)*comb(w+h-b-2-j,w-b-1)%mod",
"tmp"
] | import math
h, w, a, b = map(int, input().split())
#divmod
mod = pow(10,9)+7
def divmod(num, mod=10**9+7):
return pow(num, mod-2, mod)
#combination
def comb(a,b):
p=fact[a-b]*fact[b]%mod
return fact[a]*divmod(p)%mod
fact = [1]
for i in range(1,h+w):
fact.append(i*fact[i-1]%mod)
#print(fact)
ans = 0
for j in range(h-a):
tmp = comb(b-1+j,j)*comb(w+h-b-2-j,w-b-1)%mod
ans += tmp
ans = ans%mod
# ans = ans + fact[b-1+j]*fact[w+h-b-2-j]/fact[b-1]/fact[j]/fact[w-b-1]/fact[h-1-j]
print(int(ans))
'''
単純なh*wのマス目だった場合
#h-row / w-col
con = [[0]*w]*h
for i in range(h):
con[i][0] = 1
for j in range(w):
con[0][j] = 1
for k in range(1,h):
for l in range(1,w):
con[k][l] = con[k-1][l] + con[k][l-1]
print(con[h-1][w-1])
'''
'''
全量を計算するやり方
H*Wがデカすぎると時間というよりもメモリエラー
print('initialize')
con = [[0 for i in range(w)] for j in range(h)]
#リスト内包表記で作らないとバグる
#ダメな例 -> con = [[0]*w]*h
#https://qiita.com/utgwkk/items/5ad2527f19150ae33322
print('initialize finished')
for i in range(h-a):
con[i][0] = 1
#print(con[0])
for j in range(w):
#wは先に初期化やっちゃう
con[0][j] = 1
#print(con)
for k in range(1,h-a):
# print(k)
for l in range(1,b+1):
con[k][l] = con[k-1][l] + con[k][l-1]
#print(con[h-a-1][b-1])
#print(con[h-a][b-1])
#print(con[h-a-1][b])
for m in range(1,h):
# print('---{} row---'.format(m))
# print(con[m])
for n in range(b,w):
# print('m,n:('+str(m)+','+str(n)+')')
con[m][n] = con[m-1][n] + con[m][n-1]
# print(con[m])
print(con[h-1][w-1])
'''
|
[
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,
17,
0,
13,
39,
17,
17,
0,
13,
39,
17,
17,
28,
13,
4,
13,
17,
2,
2,
13,
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,
17,
28,
13,
4,
13,
2,
13,
13,
0,
13,
2,
2,
18,
13,
2,
2,
13,
13,
17,
18,
13,
2,
2,
2,
2,
2,
13,
17,
13,
13,
13,
17,
13,
0,
13,
2,
2,
13,
18,
13,
2,
13,
17,
13,
0,
13,
2,
2,
13,
18,
13,
13,
13,
0,
13,
2,
2,
13,
18,
13,
2,
2,
13,
13,
17,
13,
0,
13,
2,
2,
13,
18,
13,
2,
2,
13,
13,
17,
13,
0,
13,
13,
0,
13,
13,
4,
13,
13,
10,
2,
13,
10,
4,
13,
10,
2,
13,
10,
39,
13,
10,
13,
13,
10,
4,
13,
10,
13,
13,
10,
2,
13,
10,
4,
13,
10,
39,
13,
10,
2,
13,
10,
17,
13,
10,
39,
13,
10,
2,
13,
10,
2,
13,
10,
4,
13
] | [
[
222,
2
],
[
222,
11
],
[
222,
12
],
[
222,
13
],
[
183,
15
],
[
213,
22
],
[
186,
27
],
[
204,
32
],
[
38,
37
],
[
193,
43
],
[
181,
44
],
[
214,
48
],
[
214,
53
],
[
37,
55
],
[
184,
56
],
[
187,
59
],
[
187,
65
],
[
184,
67
],
[
37,
68
],
[
184,
70
],
[
37,
71
],
[
184,
72
],
[
205,
75
],
[
205,
80
],
[
187,
83
],
[
184,
85
],
[
210,
87
],
[
91,
90
],
[
193,
94
],
[
223,
95
],
[
207,
97
],
[
214,
101
],
[
90,
104
],
[
202,
105
],
[
214,
108
],
[
193,
114
],
[
90,
116
],
[
181,
117
],
[
202,
118
],
[
184,
120
],
[
198,
122
],
[
208,
125
],
[
178,
125
],
[
220,
125
],
[
217,
125
],
[
199,
125
],
[
205,
127
],
[
202,
129
],
[
184,
131
],
[
216,
133
],
[
199,
136
],
[
208,
136
],
[
178,
136
],
[
220,
136
],
[
217,
136
],
[
205,
138
],
[
90,
139
],
[
184,
140
],
[
219,
142
],
[
217,
145
],
[
199,
145
],
[
208,
145
],
[
178,
145
],
[
220,
145
],
[
205,
147
],
[
181,
150
],
[
202,
151
],
[
184,
153
],
[
177,
155
],
[
220,
158
],
[
217,
158
],
[
199,
158
],
[
208,
158
],
[
178,
158
],
[
205,
160
],
[
193,
163
],
[
90,
164
],
[
184,
166
],
[
195,
168
],
[
178,
169
],
[
220,
169
],
[
217,
169
],
[
199,
169
],
[
208,
169
],
[
189,
171
],
[
184,
172
],
[
190,
175
],
[
196,
175
],
[
211,
175
],
[
177,
178
],
[
222,
181
],
[
183,
184
],
[
186,
187
],
[
184,
189
],
[
189,
190
],
[
222,
193
],
[
178,
195
],
[
220,
195
],
[
217,
195
],
[
199,
195
],
[
208,
195
],
[
195,
196
],
[
198,
199
],
[
222,
202
],
[
204,
205
],
[
207,
208
],
[
210,
211
],
[
213,
214
],
[
216,
217
],
[
219,
220
],
[
222,
223
]
] | [
"H, W, A, B = map(int,input().split())\nmod = 10**9+7\nC = [1,1]\ninv = [0,1]\nCinv = [1,1]\nfor i in range(2,H+W+1):\n C.append((C[-1]*i)%mod)\n inv.append((-inv[mod%i]*(mod//i)%mod))\n Cinv.append(Cinv[-1]*inv[-1]%mod)\nans = 0\nfor i in range(H-A):\n a = (C[i+B-1]*C[H-1-i+W-B-1])%mod\n a = (a*Cinv[B-1])%mod\n a = (a*Cinv[i])%mod\n a = (a*Cinv[W-B-1])%mod\n a = (a*Cinv[H-i-1])%mod\n ans += a\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",
"C = [1,1]",
"C",
"[1,1]",
"1",
"1",
"inv = [0,1]",
"inv",
"[0,1]",
"0",
"1",
"Cinv = [1,1]",
"Cinv",
"[1,1]",
"1",
"1",
"for i in range(2,H+W+1):\n C.append((C[-1]*i)%mod)\n inv.append((-inv[mod%i]*(mod//i)%mod))\n Cinv.append(Cinv[-1]*inv[-1]%mod)",
"i",
"range(2,H+W+1)",
"range",
"2",
"H+W+1",
"H+W",
"H",
"W",
"1",
"C.append((C[-1]*i)%mod)",
"C.append",
"C",
"append",
"(C[-1]*i)%mod",
"C[-1]*i",
"C[-1]",
"C",
"-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",
"Cinv.append(Cinv[-1]*inv[-1]%mod)",
"Cinv.append",
"Cinv",
"append",
"Cinv[-1]*inv[-1]%mod",
"Cinv[-1]*inv[-1]",
"Cinv[-1]",
"Cinv",
"-1",
"inv[-1]",
"inv",
"-1",
"mod",
"ans = 0",
"ans",
"0",
"for i in range(H-A):\n a = (C[i+B-1]*C[H-1-i+W-B-1])%mod\n a = (a*Cinv[B-1])%mod\n a = (a*Cinv[i])%mod\n a = (a*Cinv[W-B-1])%mod\n a = (a*Cinv[H-i-1])%mod\n ans += a\n ans %= mod",
"i",
"range(H-A)",
"range",
"H-A",
"H",
"A",
"a = (C[i+B-1]*C[H-1-i+W-B-1])%mod",
"a",
"(C[i+B-1]*C[H-1-i+W-B-1])%mod",
"C[i+B-1]*C[H-1-i+W-B-1]",
"C[i+B-1]",
"C",
"i+B-1",
"i+B",
"i",
"B",
"1",
"C[H-1-i+W-B-1]",
"C",
"H-1-i+W-B-1",
"H-1-i+W-B",
"H-1-i+W",
"H-1-i",
"H-1",
"H",
"1",
"i",
"W",
"B",
"1",
"mod",
"a = (a*Cinv[B-1])%mod",
"a",
"(a*Cinv[B-1])%mod",
"a*Cinv[B-1]",
"a",
"Cinv[B-1]",
"Cinv",
"B-1",
"B",
"1",
"mod",
"a = (a*Cinv[i])%mod",
"a",
"(a*Cinv[i])%mod",
"a*Cinv[i]",
"a",
"Cinv[i]",
"Cinv",
"i",
"mod",
"a = (a*Cinv[W-B-1])%mod",
"a",
"(a*Cinv[W-B-1])%mod",
"a*Cinv[W-B-1]",
"a",
"Cinv[W-B-1]",
"Cinv",
"W-B-1",
"W-B",
"W",
"B",
"1",
"mod",
"a = (a*Cinv[H-i-1])%mod",
"a",
"(a*Cinv[H-i-1])%mod",
"a*Cinv[H-i-1]",
"a",
"Cinv[H-i-1]",
"Cinv",
"H-i-1",
"H-i",
"H",
"i",
"1",
"mod",
"ans += a",
"ans",
"a",
"ans %= mod",
"ans",
"mod",
"print(ans)",
"print",
"ans",
"a = (a*Cinv[H-i-1])%mod",
"(a*Cinv[H-i-1])%mod",
"a",
"W, A, B = map(int,input().split())",
"map(int,input().split())",
"W",
"mod = 10**9+7",
"10**9+7",
"mod",
"inv = [0,1]",
"[0,1]",
"inv",
"ans %= mod",
"mod",
"ans",
"H, W, A, B = map(int,input().split())",
"map(int,input().split())",
"H",
"ans += a",
"a",
"ans",
"a = (a*Cinv[B-1])%mod",
"(a*Cinv[B-1])%mod",
"a",
"B = map(int,input().split())",
"map(int,input().split())",
"B",
"Cinv = [1,1]",
"[1,1]",
"Cinv",
"a = (C[i+B-1]*C[H-1-i+W-B-1])%mod",
"(C[i+B-1]*C[H-1-i+W-B-1])%mod",
"a",
"ans = 0",
"0",
"ans",
"C = [1,1]",
"[1,1]",
"C",
"a = (a*Cinv[i])%mod",
"(a*Cinv[i])%mod",
"a",
"a = (a*Cinv[W-B-1])%mod",
"(a*Cinv[W-B-1])%mod",
"a",
"A, B = map(int,input().split())",
"map(int,input().split())",
"A"
] | H, W, A, B = map(int,input().split())
mod = 10**9+7
C = [1,1]
inv = [0,1]
Cinv = [1,1]
for i in range(2,H+W+1):
C.append((C[-1]*i)%mod)
inv.append((-inv[mod%i]*(mod//i)%mod))
Cinv.append(Cinv[-1]*inv[-1]%mod)
ans = 0
for i in range(H-A):
a = (C[i+B-1]*C[H-1-i+W-B-1])%mod
a = (a*Cinv[B-1])%mod
a = (a*Cinv[i])%mod
a = (a*Cinv[W-B-1])%mod
a = (a*Cinv[H-i-1])%mod
ans += a
ans %= mod
print(ans)
|
[
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,
2,
13,
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,
2,
13,
13,
10,
12,
13,
10,
2,
13,
10,
4,
13,
10,
2,
13,
10,
2,
13,
10,
4,
13,
10,
2,
13,
10,
13,
13,
10,
4,
13,
10,
4,
13,
10,
17,
13,
10,
2,
13
] | [
[
177,
2
],
[
177,
11
],
[
177,
12
],
[
177,
13
],
[
180,
15
],
[
162,
18
],
[
159,
25
],
[
175,
28
],
[
166,
29
],
[
168,
32
],
[
160,
37
],
[
153,
40
],
[
160,
45
],
[
49,
48
],
[
160,
53
],
[
59,
56
],
[
169,
57
],
[
48,
58
],
[
48,
61
],
[
169,
63
],
[
48,
65
],
[
163,
67
],
[
70,
69
],
[
160,
74
],
[
80,
77
],
[
154,
78
],
[
69,
79
],
[
56,
82
],
[
169,
83
],
[
69,
84
],
[
163,
86
],
[
163,
88
],
[
93,
92
],
[
169,
97
],
[
111,
99
],
[
113,
100
],
[
154,
102
],
[
111,
103
],
[
154,
105
],
[
113,
106
],
[
163,
107
],
[
92,
109
],
[
181,
109
],
[
111,
111
],
[
113,
113
],
[
116,
115
],
[
157,
118
],
[
166,
119
],
[
183,
121
],
[
151,
124
],
[
115,
125
],
[
175,
128
],
[
178,
129
],
[
151,
132
],
[
166,
135
],
[
115,
137
],
[
178,
139
],
[
171,
142
],
[
163,
143
],
[
172,
147
],
[
184,
147
],
[
181,
147
],
[
163,
148
],
[
153,
154
],
[
177,
157
],
[
159,
160
],
[
162,
163
],
[
177,
166
],
[
168,
169
],
[
163,
171
],
[
171,
172
],
[
177,
175
],
[
177,
178
],
[
180,
181
],
[
183,
184
]
] | [
"H, W, A, B = map(int, input().split())\n\nans = 0 \nMOD = 10**9 + 7\nN = H + W - 2\nfac = [1] * (N+1)\ninv = [1] * (N+1)\n\n# 階乗\nfor i in range(1, N+1):\n fac[i] = i * fac[i - 1] % MOD\n \n# 普通の逆元テーブル\nfor i in range(1, N+1):\n inv[i] = pow(fac[i], MOD-2, MOD)\n \n \ndef f(x, y):\n ans = fac[x + y] * inv[x] * inv[y] % MOD\n return ans\n \n\nfor x in range(B, W):\n ans += f(x, H - A - 1) * f(W - 1 - x, A - 1)\n ans %= MOD\n \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",
"ans = 0",
"ans",
"0",
"MOD = 10**9 + 7",
"MOD",
"10**9 + 7",
"10**9",
"10",
"9",
"7",
"N = H + W - 2",
"N",
"H + W - 2",
"H + W",
"H",
"W",
"2",
"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\n \n# 普通の逆元テーブル",
"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)\n \n ",
"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 f(x, y):\n ans = fac[x + y] * inv[x] * inv[y] % MOD\n return ans\n ",
"f",
"ans = fac[x + y] * inv[x] * inv[y] % MOD",
"ans",
"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 ans",
"ans",
"x",
"x",
"y",
"y",
"for x in range(B, W):\n ans += f(x, H - A - 1) * f(W - 1 - x, A - 1)\n ans %= MOD\n ",
"x",
"range(B, W)",
"range",
"B",
"W",
"ans += f(x, H - A - 1) * f(W - 1 - x, A - 1)",
"ans",
"f(x, H - A - 1) * f(W - 1 - x, A - 1)",
"f(x, H - A - 1)",
"f",
"x",
"H - A - 1",
"H - A",
"H",
"A",
"1",
"f(W - 1 - x, A - 1)",
"f",
"W - 1 - x",
"W - 1",
"W",
"1",
"x",
"A - 1",
"A",
"1",
"ans %= MOD",
"ans",
"MOD",
"print(ans % MOD)",
"print",
"ans % MOD",
"ans",
"MOD",
"def f(x, y):\n ans = fac[x + y] * inv[x] * inv[y] % MOD\n return ans\n ",
"def f(x, y):\n ans = fac[x + y] * inv[x] * inv[y] % MOD\n return ans\n ",
"f",
"inv = [1] * (N+1)",
"[1] * (N+1)",
"inv",
"B = map(int, input().split())",
"map(int, input().split())",
"B",
"N = H + W - 2",
"H + W - 2",
"N",
"MOD = 10**9 + 7",
"10**9 + 7",
"MOD",
"W, A, B = map(int, input().split())",
"map(int, input().split())",
"W",
"fac = [1] * (N+1)",
"[1] * (N+1)",
"fac",
"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",
"ans = 0",
"0",
"ans",
"ans += f(x, H - A - 1) * f(W - 1 - x, A - 1)",
"f(x, H - A - 1) * f(W - 1 - x, A - 1)",
"ans"
] | H, W, A, B = map(int, input().split())
ans = 0
MOD = 10**9 + 7
N = H + W - 2
fac = [1] * (N+1)
inv = [1] * (N+1)
# 階乗
for i in range(1, N+1):
fac[i] = i * fac[i - 1] % MOD
# 普通の逆元テーブル
for i in range(1, N+1):
inv[i] = pow(fac[i], MOD-2, MOD)
def f(x, y):
ans = fac[x + y] * inv[x] * inv[y] % MOD
return ans
for x in range(B, W):
ans += f(x, H - A - 1) * f(W - 1 - x, A - 1)
ans %= MOD
print(ans % MOD) |
[
7,
15,
13,
0,
13,
18,
18,
13,
13,
13,
6,
13,
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,
12,
13,
0,
13,
4,
13,
13,
4,
18,
4,
13,
13,
13,
13,
13,
0,
13,
4,
13,
2,
17,
17,
0,
13,
4,
13,
2,
13,
13,
2,
13,
13,
0,
13,
17,
28,
13,
4,
13,
13,
0,
13,
2,
4,
13,
2,
2,
2,
13,
13,
13,
17,
2,
13,
13,
2,
2,
17,
17,
17,
0,
13,
2,
4,
13,
2,
2,
2,
13,
13,
13,
17,
2,
13,
13,
2,
2,
17,
17,
17,
0,
13,
2,
2,
13,
2,
2,
13,
13,
2,
2,
17,
17,
17,
2,
2,
17,
17,
17,
4,
13,
13,
14,
2,
13,
17,
4,
13,
10,
18,
13,
10,
12,
13,
10,
6,
13
] | [
[
310,
4
],
[
18,
15
],
[
41,
16
],
[
45,
17
],
[
45,
18
],
[
23,
20
],
[
41,
21
],
[
41,
25
],
[
43,
27
],
[
32,
29
],
[
41,
30
],
[
41,
34
],
[
43,
36
],
[
32,
37
],
[
41,
38
],
[
41,
41
],
[
43,
43
],
[
46,
45
],
[
82,
60
],
[
84,
62
],
[
82,
65
],
[
86,
67
],
[
82,
69
],
[
82,
73
],
[
84,
76
],
[
86,
77
],
[
82,
79
],
[
82,
82
],
[
84,
84
],
[
86,
86
],
[
91,
90
],
[
95,
94
],
[
99,
98
],
[
146,
103
],
[
90,
107
],
[
90,
112
],
[
98,
114
],
[
98,
116
],
[
144,
118
],
[
94,
122
],
[
94,
127
],
[
98,
129
],
[
144,
133
],
[
98,
135
],
[
144,
137
],
[
144,
144
],
[
146,
146
],
[
151,
150
],
[
200,
155
],
[
161,
158
],
[
150,
159
],
[
164,
163
],
[
200,
168
],
[
174,
171
],
[
150,
172
],
[
163,
173
],
[
198,
176
],
[
198,
182
],
[
163,
184
],
[
150,
186
],
[
198,
189
],
[
163,
191
],
[
198,
193
],
[
150,
196
],
[
198,
198
],
[
200,
200
],
[
205,
204
],
[
311,
211
],
[
205,
213
],
[
205,
214
],
[
205,
215
],
[
218,
217
],
[
225,
224
],
[
204,
228
],
[
214,
229
],
[
213,
231
],
[
215,
232
],
[
235,
234
],
[
238,
237
],
[
224,
240
],
[
243,
242
],
[
217,
245
],
[
204,
249
],
[
214,
250
],
[
215,
251
],
[
215,
254
],
[
237,
255
],
[
263,
262
],
[
217,
265
],
[
213,
269
],
[
214,
270
],
[
215,
271
],
[
214,
274
],
[
237,
275
],
[
283,
282
],
[
234,
285
],
[
282,
285
],
[
242,
288
],
[
262,
289
],
[
282,
302
],
[
234,
302
],
[
314,
308
],
[
310,
311
]
] | [
"import sys\ninput = sys.stdin.readline\n#str 注意\n\nclass Combination:\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\n\ndef main():\n h,w,a,b = map(int,input().split())\n cmb = Combination(10**6)\n roop = min(h-a,w-b)\n ans = 0\n for i in range(roop):\n before = cmb(h-a+b-1,b+i) % (10**9+7)\n after = cmb(w+a-b-1,a+i) % (10**9+7)\n ans = (ans+(before*after)%(10**9+7)) % (10**9+7)\n print(ans)\nif __name__=='__main__':\n main()",
"import sys",
"sys",
"input = sys.stdin.readline",
"input",
"sys.stdin.readline",
"sys.stdin",
"sys",
"stdin",
"readline",
"class Combination:\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",
"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",
"def main():\n h,w,a,b = map(int,input().split())\n cmb = Combination(10**6)\n roop = min(h-a,w-b)\n ans = 0\n for i in range(roop):\n before = cmb(h-a+b-1,b+i) % (10**9+7)\n after = cmb(w+a-b-1,a+i) % (10**9+7)\n ans = (ans+(before*after)%(10**9+7)) % (10**9+7)\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",
"cmb = Combination(10**6)",
"cmb",
"Combination(10**6)",
"Combination",
"10**6",
"10",
"6",
"roop = min(h-a,w-b)",
"roop",
"min(h-a,w-b)",
"min",
"h-a",
"h",
"a",
"w-b",
"w",
"b",
"ans = 0",
"ans",
"0",
"for i in range(roop):\n before = cmb(h-a+b-1,b+i) % (10**9+7)\n after = cmb(w+a-b-1,a+i) % (10**9+7)\n ans = (ans+(before*after)%(10**9+7)) % (10**9+7)\n ",
"i",
"range(roop)",
"range",
"roop",
"before = cmb(h-a+b-1,b+i) % (10**9+7)",
"before",
"cmb(h-a+b-1,b+i) % (10**9+7)",
"cmb(h-a+b-1,b+i)",
"cmb",
"h-a+b-1",
"h-a+b",
"h-a",
"h",
"a",
"b",
"1",
"b+i",
"b",
"i",
"10**9+7",
"10**9",
"10",
"9",
"7",
"after = cmb(w+a-b-1,a+i) % (10**9+7)",
"after",
"cmb(w+a-b-1,a+i) % (10**9+7)",
"cmb(w+a-b-1,a+i)",
"cmb",
"w+a-b-1",
"w+a-b",
"w+a",
"w",
"a",
"b",
"1",
"a+i",
"a",
"i",
"10**9+7",
"10**9",
"10",
"9",
"7",
"ans = (ans+(before*after)%(10**9+7)) % (10**9+7)",
"ans",
"(ans+(before*after)%(10**9+7)) % (10**9+7)",
"ans+(before*after)%(10**9+7)",
"ans",
"(before*after)%(10**9+7)",
"before*after",
"before",
"after",
"10**9+7",
"10**9",
"10",
"9",
"7",
"10**9+7",
"10**9",
"10",
"9",
"7",
"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 cmb = Combination(10**6)\n roop = min(h-a,w-b)\n ans = 0\n for i in range(roop):\n before = cmb(h-a+b-1,b+i) % (10**9+7)\n after = cmb(w+a-b-1,a+i) % (10**9+7)\n ans = (ans+(before*after)%(10**9+7)) % (10**9+7)\n print(ans)",
"def main():\n h,w,a,b = map(int,input().split())\n cmb = Combination(10**6)\n roop = min(h-a,w-b)\n ans = 0\n for i in range(roop):\n before = cmb(h-a+b-1,b+i) % (10**9+7)\n after = cmb(w+a-b-1,a+i) % (10**9+7)\n ans = (ans+(before*after)%(10**9+7)) % (10**9+7)\n print(ans)",
"main",
"class Combination:\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 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"
] | import sys
input = sys.stdin.readline
#str 注意
class Combination:
def __init__(self, n_max, mod=10**9+7):
self.mod = mod
self.modinv = self.make_modinv_list(n_max)
self.fac, self.facinv = self.make_factorial_list(n_max)
def __call__(self, n, r):
return self.fac[n] * self.facinv[r] % self.mod * self.facinv[n-r] % self.mod
def make_factorial_list(self, n):
# 階乗のリストと階乗のmod逆元のリストを返す O(n)
# self.make_modinv_list()が先に実行されている必要がある
fac = [1]
facinv = [1]
for i in range(1, n+1):
fac.append(fac[i-1] * i % self.mod)
facinv.append(facinv[i-1] * self.modinv[i] % self.mod)
return fac, facinv
def make_modinv_list(self, n):
# 0からnまでのmod逆元のリストを返す O(n)
modinv = [0] * (n+1)
modinv[1] = 1
for i in range(2, n+1):
modinv[i] = self.mod - self.mod//i * modinv[self.mod%i] % self.mod
return modinv
def main():
h,w,a,b = map(int,input().split())
cmb = Combination(10**6)
roop = min(h-a,w-b)
ans = 0
for i in range(roop):
before = cmb(h-a+b-1,b+i) % (10**9+7)
after = cmb(w+a-b-1,a+i) % (10**9+7)
ans = (ans+(before*after)%(10**9+7)) % (10**9+7)
print(ans)
if __name__=='__main__':
main() |
[
7,
6,
13,
12,
13,
0,
18,
13,
13,
39,
17,
0,
18,
13,
13,
2,
39,
17,
2,
13,
17,
0,
18,
13,
13,
13,
14,
2,
13,
13,
28,
13,
4,
13,
2,
13,
17,
4,
18,
18,
13,
13,
13,
2,
2,
18,
18,
13,
13,
17,
2,
13,
17,
18,
13,
13,
0,
18,
18,
13,
13,
17,
4,
13,
18,
18,
13,
13,
17,
2,
18,
13,
13,
17,
18,
13,
13,
28,
13,
4,
13,
2,
13,
17,
17,
17,
0,
18,
18,
13,
13,
13,
2,
2,
18,
18,
13,
13,
2,
13,
17,
2,
13,
17,
18,
13,
13,
23,
13,
23,
13,
2,
17,
17,
23,
13,
2,
2,
17,
17,
17,
12,
13,
14,
2,
13,
13,
4,
13,
17,
29,
17,
23,
13,
23,
13,
23,
13,
0,
13,
4,
13,
13,
4,
18,
4,
13,
13,
13,
13,
13,
0,
13,
4,
13,
0,
13,
2,
2,
17,
17,
17,
0,
13,
4,
18,
13,
13,
2,
2,
13,
13,
17,
2,
13,
17,
28,
13,
4,
13,
13,
0,
13,
2,
2,
4,
18,
13,
13,
2,
2,
2,
13,
13,
13,
17,
13,
4,
18,
13,
13,
2,
2,
2,
13,
13,
17,
13,
2,
13,
17,
13,
4,
13,
2,
13,
13,
10,
4,
13,
10,
4,
13,
10,
4,
13,
10,
6,
13,
10,
2,
13,
10,
4,
13,
10,
4,
13,
10,
2,
13,
10,
4,
13
] | [
[
9,
6
],
[
108,
7
],
[
15,
12
],
[
108,
13
],
[
110,
19
],
[
25,
22
],
[
108,
23
],
[
115,
24
],
[
115,
25
],
[
110,
28
],
[
115,
29
],
[
32,
31
],
[
110,
35
],
[
6,
39
],
[
108,
40
],
[
6,
46
],
[
108,
47
],
[
31,
51
],
[
22,
53
],
[
108,
54
],
[
115,
55
],
[
62,
57
],
[
12,
58
],
[
108,
59
],
[
6,
65
],
[
108,
66
],
[
22,
70
],
[
108,
71
],
[
115,
72
],
[
22,
74
],
[
108,
75
],
[
115,
76
],
[
79,
78
],
[
110,
82
],
[
92,
87
],
[
12,
88
],
[
108,
89
],
[
78,
91
],
[
12,
95
],
[
108,
96
],
[
78,
99
],
[
78,
102
],
[
22,
104
],
[
108,
105
],
[
115,
106
],
[
108,
108
],
[
111,
110
],
[
116,
115
],
[
135,
125
],
[
137,
126
],
[
133,
133
],
[
135,
135
],
[
137,
137
],
[
236,
139
],
[
236,
148
],
[
236,
149
],
[
236,
150
],
[
221,
152
],
[
230,
156
],
[
242,
163
],
[
222,
166
],
[
122,
167
],
[
219,
170
],
[
225,
171
],
[
225,
174
],
[
178,
177
],
[
234,
180
],
[
239,
182
],
[
222,
187
],
[
122,
188
],
[
177,
192
],
[
219,
193
],
[
237,
194
],
[
177,
196
],
[
222,
199
],
[
122,
200
],
[
237,
204
],
[
225,
205
],
[
177,
207
],
[
237,
209
],
[
231,
211
],
[
240,
215
],
[
243,
215
],
[
231,
216
],
[
236,
219
],
[
221,
222
],
[
236,
225
],
[
230,
231
],
[
236,
234
],
[
236,
237
],
[
239,
240
],
[
242,
243
]
] | [
"class mod_comb_k():\n def __init__(self, MAX_N = 10**6, mod = 10**9+7):\n self.fact = [1]\n self.fact_inv = [0] * (MAX_N + 4)\n self.mod = mod\n if MAX_N > mod:print('MAX_N > mod !')\n for i in range(MAX_N + 3):\n self.fact.append(self.fact[-1] * (i + 1) % self.mod)\n self.fact_inv[-1] = pow(self.fact[-1], self.mod - 2, self.mod)\n for i in range(MAX_N + 2, -1, -1):\n self.fact_inv[i] = self.fact_inv[i + 1] * (i + 1) % self.mod\n def comb(self, n, k):\n if n < k:\n print('n < k !')\n return 0\n else:return self.fact[n] * self.fact_inv[k] % self.mod * self.fact_inv[n - k] % self.mod\nh,w,a,b=map(int,input().split())\nc=mod_comb_k()\nmod=10**9+7\nans=c.comb(h+w-2,w-1)\nfor i in range(b):\n ans-=(c.comb(i+h-a-1,i)*c.comb(a+w-2-i,a-1))%mod\nprint(ans%mod)",
"class mod_comb_k():\n def __init__(self, MAX_N = 10**6, mod = 10**9+7):\n self.fact = [1]\n self.fact_inv = [0] * (MAX_N + 4)\n self.mod = mod\n if MAX_N > mod:print('MAX_N > mod !')\n for i in range(MAX_N + 3):\n self.fact.append(self.fact[-1] * (i + 1) % self.mod)\n self.fact_inv[-1] = pow(self.fact[-1], self.mod - 2, self.mod)\n for i in range(MAX_N + 2, -1, -1):\n self.fact_inv[i] = self.fact_inv[i + 1] * (i + 1) % self.mod\n def comb(self, n, k):\n if n < k:\n print('n < k !')\n return 0\n else:return self.fact[n] * self.fact_inv[k] % self.mod * self.fact_inv[n - k] % self.mod",
"mod_comb_k",
"def __init__(self, MAX_N = 10**6, mod = 10**9+7):\n self.fact = [1]\n self.fact_inv = [0] * (MAX_N + 4)\n self.mod = mod\n if MAX_N > mod:print('MAX_N > mod !')\n for i in range(MAX_N + 3):\n self.fact.append(self.fact[-1] * (i + 1) % self.mod)\n self.fact_inv[-1] = pow(self.fact[-1], self.mod - 2, self.mod)\n for i in range(MAX_N + 2, -1, -1):\n self.fact_inv[i] = self.fact_inv[i + 1] * (i + 1) % self.mod\n ",
"__init__",
"self.fact = [1]",
"self.fact",
"self",
"fact",
"[1]",
"1",
"self.fact_inv = [0] * (MAX_N + 4)",
"self.fact_inv",
"self",
"fact_inv",
"[0] * (MAX_N + 4)",
"[0]",
"0",
"MAX_N + 4",
"MAX_N",
"4",
"self.mod = mod",
"self.mod",
"self",
"mod",
"mod",
"if MAX_N > mod:print('MAX_N > mod !')\n ",
"MAX_N > mod",
"MAX_N",
"mod",
"for i in range(MAX_N + 3):\n self.fact.append(self.fact[-1] * (i + 1) % self.mod)\n ",
"i",
"range(MAX_N + 3)",
"range",
"MAX_N + 3",
"MAX_N",
"3",
"self.fact.append(self.fact[-1] * (i + 1) % self.mod)",
"self.fact.append",
"self.fact",
"self",
"fact",
"append",
"self.fact[-1] * (i + 1) % self.mod",
"self.fact[-1] * (i + 1)",
"self.fact[-1]",
"self.fact",
"self",
"fact",
"-1",
"i + 1",
"i",
"1",
"self.mod",
"self",
"mod",
"self.fact_inv[-1] = pow(self.fact[-1], self.mod - 2, self.mod)",
"self.fact_inv[-1]",
"self.fact_inv",
"self",
"fact_inv",
"-1",
"pow(self.fact[-1], self.mod - 2, self.mod)",
"pow",
"self.fact[-1]",
"self.fact",
"self",
"fact",
"-1",
"self.mod - 2",
"self.mod",
"self",
"mod",
"2",
"self.mod",
"self",
"mod",
"for i in range(MAX_N + 2, -1, -1):\n self.fact_inv[i] = self.fact_inv[i + 1] * (i + 1) % self.mod\n ",
"i",
"range(MAX_N + 2, -1, -1)",
"range",
"MAX_N + 2",
"MAX_N",
"2",
"-1",
"-1",
"self.fact_inv[i] = self.fact_inv[i + 1] * (i + 1) % self.mod",
"self.fact_inv[i]",
"self.fact_inv",
"self",
"fact_inv",
"i",
"self.fact_inv[i + 1] * (i + 1) % self.mod",
"self.fact_inv[i + 1] * (i + 1)",
"self.fact_inv[i + 1]",
"self.fact_inv",
"self",
"fact_inv",
"i + 1",
"i",
"1",
"i + 1",
"i",
"1",
"self.mod",
"self",
"mod",
"self",
"self",
"MAX_N = 10**6",
"MAX_N",
"10**6",
"10",
"6",
"mod = 10**9+7",
"mod",
"10**9+7",
"10**9",
"10",
"9",
"7",
"def comb(self, n, k):\n if n < k:\n print('n < k !')\n return 0\n else:return self.fact[n] * self.fact_inv[k] % self.mod * self.fact_inv[n - k] % self.mod",
"comb",
"if n < k:\n print('n < k !')\n return 0\n else:return self.fact[n] * self.fact_inv[k] % self.mod * self.fact_inv[n - k] % self.mod",
"n < k",
"n",
"k",
"print('n < k !')",
"print",
"'n < k !'",
"return 0",
"0",
"self",
"self",
"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",
"c=mod_comb_k()",
"c",
"mod_comb_k()",
"mod_comb_k",
"mod=10**9+7",
"mod",
"10**9+7",
"10**9",
"10",
"9",
"7",
"ans=c.comb(h+w-2,w-1)",
"ans",
"c.comb(h+w-2,w-1)",
"c.comb",
"c",
"comb",
"h+w-2",
"h+w",
"h",
"w",
"2",
"w-1",
"w",
"1",
"for i in range(b):\n ans-=(c.comb(i+h-a-1,i)*c.comb(a+w-2-i,a-1))%mod",
"i",
"range(b)",
"range",
"b",
"ans-=(c.comb(i+h-a-1,i)*c.comb(a+w-2-i,a-1))%mod",
"ans",
"(c.comb(i+h-a-1,i)*c.comb(a+w-2-i,a-1))%mod",
"c.comb(i+h-a-1,i)*c.comb(a+w-2-i,a-1)",
"c.comb(i+h-a-1,i)",
"c.comb",
"c",
"comb",
"i+h-a-1",
"i+h-a",
"i+h",
"i",
"h",
"a",
"1",
"i",
"c.comb(a+w-2-i,a-1)",
"c.comb",
"c",
"comb",
"a+w-2-i",
"a+w-2",
"a+w",
"a",
"w",
"2",
"i",
"a-1",
"a",
"1",
"mod",
"print(ans%mod)",
"print",
"ans%mod",
"ans",
"mod",
"h,w,a,b=map(int,input().split())",
"map(int,input().split())",
"h",
"c=mod_comb_k()",
"mod_comb_k()",
"c",
"w,a,b=map(int,input().split())",
"map(int,input().split())",
"w",
"class mod_comb_k():\n def __init__(self, MAX_N = 10**6, mod = 10**9+7):\n self.fact = [1]\n self.fact_inv = [0] * (MAX_N + 4)\n self.mod = mod\n if MAX_N > mod:print('MAX_N > mod !')\n for i in range(MAX_N + 3):\n self.fact.append(self.fact[-1] * (i + 1) % self.mod)\n self.fact_inv[-1] = pow(self.fact[-1], self.mod - 2, self.mod)\n for i in range(MAX_N + 2, -1, -1):\n self.fact_inv[i] = self.fact_inv[i + 1] * (i + 1) % self.mod\n def comb(self, n, k):\n if n < k:\n print('n < k !')\n return 0\n else:return self.fact[n] * self.fact_inv[k] % self.mod * self.fact_inv[n - k] % self.mod",
"class mod_comb_k():\n def __init__(self, MAX_N = 10**6, mod = 10**9+7):\n self.fact = [1]\n self.fact_inv = [0] * (MAX_N + 4)\n self.mod = mod\n if MAX_N > mod:print('MAX_N > mod !')\n for i in range(MAX_N + 3):\n self.fact.append(self.fact[-1] * (i + 1) % self.mod)\n self.fact_inv[-1] = pow(self.fact[-1], self.mod - 2, self.mod)\n for i in range(MAX_N + 2, -1, -1):\n self.fact_inv[i] = self.fact_inv[i + 1] * (i + 1) % self.mod\n def comb(self, n, k):\n if n < k:\n print('n < k !')\n return 0\n else:return self.fact[n] * self.fact_inv[k] % self.mod * self.fact_inv[n - k] % self.mod",
"mod_comb_k",
"mod=10**9+7",
"10**9+7",
"mod",
"b=map(int,input().split())",
"map(int,input().split())",
"b",
"a,b=map(int,input().split())",
"map(int,input().split())",
"a",
"ans-=(c.comb(i+h-a-1,i)*c.comb(a+w-2-i,a-1))%mod",
"(c.comb(i+h-a-1,i)*c.comb(a+w-2-i,a-1))%mod",
"ans",
"ans=c.comb(h+w-2,w-1)",
"c.comb(h+w-2,w-1)",
"ans"
] | class mod_comb_k():
def __init__(self, MAX_N = 10**6, mod = 10**9+7):
self.fact = [1]
self.fact_inv = [0] * (MAX_N + 4)
self.mod = mod
if MAX_N > mod:print('MAX_N > mod !')
for i in range(MAX_N + 3):
self.fact.append(self.fact[-1] * (i + 1) % self.mod)
self.fact_inv[-1] = pow(self.fact[-1], self.mod - 2, self.mod)
for i in range(MAX_N + 2, -1, -1):
self.fact_inv[i] = self.fact_inv[i + 1] * (i + 1) % self.mod
def comb(self, n, k):
if n < k:
print('n < k !')
return 0
else:return self.fact[n] * self.fact_inv[k] % self.mod * self.fact_inv[n - k] % self.mod
h,w,a,b=map(int,input().split())
c=mod_comb_k()
mod=10**9+7
ans=c.comb(h+w-2,w-1)
for i in range(b):
ans-=(c.comb(i+h-a-1,i)*c.comb(a+w-2-i,a-1))%mod
print(ans%mod) |
[
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,
2,
17,
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,
18,
13,
13,
2,
2,
13,
13,
13,
0,
13,
2,
0,
18,
13,
13,
4,
13,
18,
13,
13,
2,
13,
17,
13,
0,
13,
4,
28,
13,
4,
13,
13,
17,
17,
0,
18,
13,
2,
13,
17,
2,
2,
13,
13,
13,
0,
13,
2,
12,
13,
29,
2,
2,
18,
13,
13,
18,
13,
2,
13,
13,
13,
23,
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,
17,
28,
13,
4,
13,
13,
13,
0,
13,
2,
2,
13,
2,
4,
13,
2,
2,
2,
13,
13,
17,
13,
13,
4,
13,
2,
2,
2,
13,
13,
13,
17,
2,
13,
17,
13,
4,
13,
13,
10,
4,
13,
10,
2,
13,
10,
2,
13,
10,
17,
13,
10,
2,
13,
10,
4,
13,
10,
4,
13,
10,
4,
13,
10,
2,
13,
10,
12,
13,
10,
12,
13,
10,
2,
13,
10,
17,
13,
10,
2,
13,
10,
4,
13,
10,
2,
13
] | [
[
230,
2
],
[
230,
11
],
[
230,
12
],
[
230,
13
],
[
191,
15
],
[
221,
22
],
[
194,
31
],
[
222,
36
],
[
233,
39
],
[
222,
44
],
[
197,
47
],
[
51,
50
],
[
222,
55
],
[
212,
58
],
[
195,
59
],
[
50,
60
],
[
198,
63
],
[
213,
63
],
[
50,
64
],
[
192,
65
],
[
212,
67
],
[
206,
70
],
[
234,
71
],
[
222,
72
],
[
195,
76
],
[
222,
77
],
[
192,
79
],
[
192,
81
],
[
206,
83
],
[
87,
86
],
[
222,
89
],
[
227,
93
],
[
234,
94
],
[
86,
96
],
[
207,
100
],
[
213,
100
],
[
198,
100
],
[
228,
100
],
[
86,
101
],
[
192,
102
],
[
227,
104
],
[
195,
112
],
[
121,
113
],
[
234,
115
],
[
121,
117
],
[
123,
118
],
[
192,
119
],
[
121,
121
],
[
123,
123
],
[
195,
131
],
[
143,
132
],
[
234,
134
],
[
145,
135
],
[
234,
137
],
[
143,
139
],
[
145,
140
],
[
192,
141
],
[
143,
143
],
[
145,
145
],
[
224,
147
],
[
151,
150
],
[
189,
153
],
[
231,
154
],
[
200,
156
],
[
225,
159
],
[
201,
159
],
[
216,
162
],
[
204,
166
],
[
210,
167
],
[
150,
169
],
[
150,
170
],
[
216,
172
],
[
231,
176
],
[
150,
177
],
[
210,
178
],
[
210,
181
],
[
192,
183
],
[
201,
186
],
[
225,
186
],
[
230,
189
],
[
191,
192
],
[
194,
195
],
[
197,
198
],
[
200,
201
],
[
230,
204
],
[
206,
207
],
[
230,
210
],
[
212,
213
],
[
221,
222
],
[
224,
225
],
[
227,
228
],
[
230,
231
],
[
233,
234
]
] | [
"h,w,a,b = map(int, input().split())\n\nmod = 10**9 + 7\nn = 10**5 * 2 + 1\n\nfact = [1]*(n+1)\nrfact = [1]*(n+1)\nr = 1\nfor i in range(1, n+1):\n fact[i] = r = r * i % mod\nrfact[n] = r = pow(fact[n], mod-2, mod)\nfor i in range(n, 0, -1):\n rfact[i-1] = r = r * i % mod\n\n# nPk (mod MOD) を求める\ndef perm(n, k):\n return fact[n] * rfact[n-k] % mod\n\n# nCk (mod MOD) を求める\ndef comb(n, k):\n return fact[n] * rfact[k] * rfact[n-k] % mod \nans = 0\nfor i in range(b,w):\n ans = (ans + comb(h-a-1+i,i) * comb(w-i+a-2,a-1)) % 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",
"n = 10**5 * 2 + 1",
"n",
"10**5 * 2 + 1",
"10**5 * 2",
"10**5",
"10",
"5",
"2",
"1",
"fact = [1]*(n+1)",
"fact",
"[1]*(n+1)",
"[1]",
"1",
"n+1",
"n",
"1",
"rfact = [1]*(n+1)",
"rfact",
"[1]*(n+1)",
"[1]",
"1",
"n+1",
"n",
"1",
"r = 1",
"r",
"1",
"for i in range(1, n+1):\n fact[i] = r = r * i % mod",
"i",
"range(1, n+1)",
"range",
"1",
"n+1",
"n",
"1",
"fact[i] = r = r * i % mod",
"fact[i]",
"fact",
"i",
"r * i % mod",
"r * i",
"r",
"i",
"mod",
"= r = r * i % mod",
"r",
"r * i % mod",
"rfact[n] = r = pow(fact[n], mod-2, mod)",
"rfact[n]",
"rfact",
"n",
"pow(fact[n], mod-2, mod)",
"pow",
"fact[n]",
"fact",
"n",
"mod-2",
"mod",
"2",
"mod",
"= r = pow(fact[n], mod-2, mod)",
"r",
"pow(fact[n], mod-2, mod)",
"for i in range(n, 0, -1):\n rfact[i-1] = r = r * i % mod\n\n# nPk (mod MOD) を求める",
"i",
"range(n, 0, -1)",
"range",
"n",
"0",
"-1",
"rfact[i-1] = r = r * i % mod",
"rfact[i-1]",
"rfact",
"i-1",
"i",
"1",
"r * i % mod",
"r * i",
"r",
"i",
"mod",
"= r = r * i % mod",
"r",
"r * i % mod",
"def perm(n, k):\n return fact[n] * rfact[n-k] % mod\n\n# nCk (mod MOD) を求める",
"perm",
"return fact[n] * rfact[n-k] % mod",
"fact[n] * rfact[n-k] % mod",
"fact[n] * rfact[n-k]",
"fact[n]",
"fact",
"n",
"rfact[n-k]",
"rfact",
"n-k",
"n",
"k",
"mod",
"n",
"n",
"k",
"k",
"def comb(n, k):\n return fact[n] * rfact[k] * rfact[n-k] % mod ",
"comb",
"return fact[n] * rfact[k] * rfact[n-k] % mod",
"fact[n] * rfact[k] * rfact[n-k] % mod",
"fact[n] * rfact[k] * rfact[n-k]",
"fact[n] * rfact[k]",
"fact[n]",
"fact",
"n",
"rfact[k]",
"rfact",
"k",
"rfact[n-k]",
"rfact",
"n-k",
"n",
"k",
"mod",
"n",
"n",
"k",
"k",
"ans = 0",
"ans",
"0",
"for i in range(b,w):\n ans = (ans + comb(h-a-1+i,i) * comb(w-i+a-2,a-1)) % mod",
"i",
"range(b,w)",
"range",
"b",
"w",
"ans = (ans + comb(h-a-1+i,i) * comb(w-i+a-2,a-1)) % mod",
"ans",
"(ans + comb(h-a-1+i,i) * comb(w-i+a-2,a-1)) % mod",
"ans + comb(h-a-1+i,i) * comb(w-i+a-2,a-1)",
"ans",
"comb(h-a-1+i,i) * comb(w-i+a-2,a-1)",
"comb(h-a-1+i,i)",
"comb",
"h-a-1+i",
"h-a-1",
"h-a",
"h",
"a",
"1",
"i",
"i",
"comb(w-i+a-2,a-1)",
"comb",
"w-i+a-2",
"w-i+a",
"w-i",
"w",
"i",
"a",
"2",
"a-1",
"a",
"1",
"mod",
"print(ans)",
"print",
"ans",
"b = map(int, input().split())",
"map(int, input().split())",
"b",
"mod = 10**9 + 7",
"10**9 + 7",
"mod",
"fact = [1]*(n+1)",
"[1]*(n+1)",
"fact",
"r = 1",
"1",
"r",
"ans = (ans + comb(h-a-1+i,i) * comb(w-i+a-2,a-1)) % mod",
"(ans + comb(h-a-1+i,i) * comb(w-i+a-2,a-1)) % mod",
"ans",
"h,w,a,b = map(int, input().split())",
"map(int, input().split())",
"h",
"r = pow(fact[n], mod-2, mod)",
"pow(fact[n], mod-2, mod)",
"r",
"a,b = map(int, input().split())",
"map(int, input().split())",
"a",
"r = r * i % mod",
"r * i % mod",
"r",
"def comb(n, k):\n return fact[n] * rfact[k] * rfact[n-k] % mod ",
"def comb(n, k):\n return fact[n] * rfact[k] * rfact[n-k] % mod ",
"comb",
"def perm(n, k):\n return fact[n] * rfact[n-k] % mod\n\n# nCk (mod MOD) を求める",
"def perm(n, k):\n return fact[n] * rfact[n-k] % mod\n\n# nCk (mod MOD) を求める",
"perm",
"n = 10**5 * 2 + 1",
"10**5 * 2 + 1",
"n",
"ans = 0",
"0",
"ans",
"r = r * i % mod",
"r * i % mod",
"r",
"w,a,b = map(int, input().split())",
"map(int, input().split())",
"w",
"rfact = [1]*(n+1)",
"[1]*(n+1)",
"rfact"
] | h,w,a,b = map(int, input().split())
mod = 10**9 + 7
n = 10**5 * 2 + 1
fact = [1]*(n+1)
rfact = [1]*(n+1)
r = 1
for i in range(1, n+1):
fact[i] = r = r * i % mod
rfact[n] = r = pow(fact[n], mod-2, mod)
for i in range(n, 0, -1):
rfact[i-1] = r = r * i % mod
# nPk (mod MOD) を求める
def perm(n, k):
return fact[n] * rfact[n-k] % mod
# nCk (mod MOD) を求める
def comb(n, k):
return fact[n] * rfact[k] * rfact[n-k] % mod
ans = 0
for i in range(b,w):
ans = (ans + comb(h-a-1+i,i) * comb(w-i+a-2,a-1)) % mod
print(ans) |
[
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,
0,
13,
17,
28,
13,
4,
13,
13,
0,
13,
2,
2,
13,
2,
13,
13,
13,
29,
13,
23,
13,
23,
13,
23,
13,
12,
13,
14,
2,
13,
2,
13,
13,
0,
13,
2,
13,
13,
0,
13,
4,
13,
13,
13,
13,
0,
13,
4,
13,
4,
13,
13,
13,
13,
2,
13,
17,
13,
29,
2,
2,
13,
13,
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,
2,
13,
17,
13,
13,
0,
13,
2,
2,
13,
4,
13,
13,
2,
13,
17,
13,
13,
0,
13,
2,
2,
13,
13,
13,
4,
13,
13,
10,
4,
13,
10,
2,
13,
10,
2,
13,
10,
4,
13,
10,
2,
13,
10,
4,
13,
10,
4,
13,
10,
13,
13,
10,
12,
13,
10,
2,
13,
10,
4,
13,
10,
2,
13,
10,
2,
13,
10,
2,
13,
10,
2,
13,
10,
4,
13,
10,
12,
13,
10,
2,
13
] | [
[
252,
2
],
[
252,
15
],
[
252,
16
],
[
252,
17
],
[
258,
19
],
[
29,
28
],
[
32,
31
],
[
49,
34
],
[
37,
36
],
[
28,
39
],
[
36,
39
],
[
47,
41
],
[
31,
42
],
[
51,
43
],
[
36,
45
],
[
28,
45
],
[
47,
47
],
[
49,
49
],
[
51,
51
],
[
94,
56
],
[
92,
58
],
[
94,
59
],
[
62,
61
],
[
92,
63
],
[
94,
64
],
[
67,
66
],
[
232,
68
],
[
92,
69
],
[
61,
70
],
[
94,
70
],
[
96,
71
],
[
74,
73
],
[
232,
77
],
[
61,
78
],
[
94,
78
],
[
61,
79
],
[
94,
79
],
[
96,
80
],
[
96,
82
],
[
96,
84
],
[
66,
88
],
[
73,
89
],
[
96,
90
],
[
92,
92
],
[
94,
94
],
[
96,
96
],
[
207,
98
],
[
256,
100
],
[
223,
103
],
[
253,
104
],
[
253,
107
],
[
259,
109
],
[
225,
111
],
[
256,
113
],
[
238,
116
],
[
253,
117
],
[
253,
120
],
[
259,
122
],
[
228,
124
],
[
226,
125
],
[
128,
127
],
[
217,
131
],
[
240,
134
],
[
223,
137
],
[
238,
138
],
[
127,
139
],
[
234,
141
],
[
127,
143
],
[
246,
146
],
[
253,
149
],
[
127,
150
],
[
210,
153
],
[
253,
157
],
[
238,
158
],
[
127,
160
],
[
243,
162
],
[
226,
166
],
[
220,
166
],
[
250,
166
],
[
244,
166
],
[
241,
167
],
[
247,
168
],
[
259,
169
],
[
249,
171
],
[
244,
174
],
[
226,
174
],
[
220,
174
],
[
250,
174
],
[
235,
177
],
[
259,
179
],
[
259,
181
],
[
259,
182
],
[
219,
184
],
[
250,
187
],
[
244,
187
],
[
226,
187
],
[
220,
187
],
[
211,
190
],
[
259,
192
],
[
259,
194
],
[
259,
195
],
[
213,
197
],
[
229,
200
],
[
208,
200
],
[
214,
200
],
[
220,
201
],
[
250,
201
],
[
244,
201
],
[
226,
201
],
[
259,
202
],
[
214,
205
],
[
229,
205
],
[
208,
205
],
[
207,
208
],
[
210,
211
],
[
213,
214
],
[
252,
217
],
[
219,
220
],
[
252,
223
],
[
225,
226
],
[
226,
228
],
[
228,
229
],
[
234,
235
],
[
252,
238
],
[
240,
241
],
[
243,
244
],
[
246,
247
],
[
249,
250
],
[
252,
253
],
[
258,
259
]
] | [
"H, W, A, B = map(int, open(0).read().split())\nMOD = 10**9+7\n\ndef modperm(m, n, mod):\n p = 1\n for i in range(n):\n p = p * (m - i) % mod\n return p\n\ndef modcomb(m, n, mod):\n if n > m - n:\n n = m - n\n p = modperm(m, n, mod)\n q = pow(modperm(n, n, mod), mod - 2, mod)\n return p * q % mod\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, MOD - 2, MOD) % MOD\n tmp = tmp * pow(d, MOD - 2, 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 modperm(m, n, mod):\n p = 1\n for i in range(n):\n p = p * (m - i) % mod\n return p",
"modperm",
"p = 1",
"p",
"1",
"for i in range(n):\n p = p * (m - i) % 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",
"return p",
"p",
"m",
"m",
"n",
"n",
"mod",
"mod",
"def modcomb(m, n, mod):\n if n > m - n:\n n = m - n\n p = modperm(m, n, mod)\n q = pow(modperm(n, n, mod), mod - 2, mod)\n return p * q % mod",
"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 = modperm(m, n, mod)",
"p",
"modperm(m, n, mod)",
"modperm",
"m",
"n",
"mod",
"q = pow(modperm(n, n, mod), mod - 2, mod)",
"q",
"pow(modperm(n, n, mod), mod - 2, mod)",
"pow",
"modperm(n, n, mod)",
"modperm",
"n",
"n",
"mod",
"mod - 2",
"mod",
"2",
"mod",
"return p * q % mod",
"p * q % mod",
"p * q",
"p",
"q",
"mod",
"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, MOD - 2, MOD) % MOD\n tmp = tmp * pow(d, MOD - 2, 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, MOD - 2, MOD) % MOD",
"tmp",
"tmp * pow(b, MOD - 2, MOD) % MOD",
"tmp * pow(b, MOD - 2, MOD)",
"tmp",
"pow(b, MOD - 2, MOD)",
"pow",
"b",
"MOD - 2",
"MOD",
"2",
"MOD",
"MOD",
"tmp = tmp * pow(d, MOD - 2, MOD) % MOD",
"tmp",
"tmp * pow(d, MOD - 2, MOD) % MOD",
"tmp * pow(d, MOD - 2, MOD)",
"tmp",
"pow(d, MOD - 2, MOD)",
"pow",
"d",
"MOD - 2",
"MOD",
"2",
"MOD",
"MOD",
"total = (total - tmp) % MOD",
"total",
"(total - tmp) % MOD",
"total - tmp",
"total",
"tmp",
"MOD",
"print(total)",
"print",
"total",
"total = modcomb(H + W - 2, W - 1, MOD)",
"modcomb(H + W - 2, W - 1, MOD)",
"total",
"d = W + A - 2 - i",
"W + A - 2 - i",
"d",
"total = (total - tmp) % MOD",
"(total - tmp) % MOD",
"total",
"B = map(int, open(0).read().split())",
"map(int, open(0).read().split())",
"B",
"tmp = tmp * pow(d, MOD - 2, MOD) % MOD",
"tmp * pow(d, MOD - 2, MOD) % MOD",
"tmp",
"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",
"total -= tmp",
"tmp",
"total",
"def modperm(m, n, mod):\n p = 1\n for i in range(n):\n p = p * (m - i) % mod\n return p",
"def modperm(m, n, mod):\n p = 1\n for i in range(n):\n p = p * (m - i) % mod\n return p",
"modperm",
"b = i + 1",
"i + 1",
"b",
"A, B = map(int, open(0).read().split())",
"map(int, open(0).read().split())",
"A",
"a = H - A + i",
"H - A + i",
"a",
"tmp = tmp * a * c % MOD",
"tmp * a * c % MOD",
"tmp",
"c = W - i - 1",
"W - i - 1",
"c",
"tmp = tmp * pow(b, MOD - 2, MOD) % MOD",
"tmp * pow(b, MOD - 2, MOD) % MOD",
"tmp",
"W, A, B = map(int, open(0).read().split())",
"map(int, open(0).read().split())",
"W",
"def modcomb(m, n, mod):\n if n > m - n:\n n = m - n\n p = modperm(m, n, mod)\n q = pow(modperm(n, n, mod), mod - 2, mod)\n return p * q % mod",
"def modcomb(m, n, mod):\n if n > m - n:\n n = m - n\n p = modperm(m, n, mod)\n q = pow(modperm(n, n, mod), mod - 2, mod)\n return p * q % mod",
"modcomb",
"MOD = 10**9+7",
"10**9+7",
"MOD"
] | H, W, A, B = map(int, open(0).read().split())
MOD = 10**9+7
def modperm(m, n, mod):
p = 1
for i in range(n):
p = p * (m - i) % mod
return p
def modcomb(m, n, mod):
if n > m - n:
n = m - n
p = modperm(m, n, mod)
q = pow(modperm(n, n, mod), mod - 2, mod)
return p * q % mod
total = modcomb(H + W - 2, W - 1, MOD)
tmp = modcomb(A + W - 2, W - 1, MOD)
total -= tmp
for i in range(B - 1):
a = H - A + i
b = i + 1
c = W - i - 1
d = W + A - 2 - i
# print(a,b,c,d)
tmp = tmp * a * c % MOD
tmp = tmp * pow(b, MOD - 2, MOD) % MOD
tmp = tmp * pow(d, MOD - 2, MOD) % MOD
# print(tmp)
total = (total - tmp) % MOD
print(total) |
[
7,
15,
13,
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,
41,
28,
13,
4,
13,
13,
4,
17,
0,
13,
13,
28,
13,
4,
13,
13,
14,
2,
13,
17,
0,
18,
13,
13,
2,
2,
18,
13,
2,
13,
17,
13,
13,
41,
28,
13,
4,
13,
13,
4,
17,
0,
13,
13,
0,
13,
2,
13,
17,
0,
13,
4,
13,
13,
0,
13,
4,
18,
13,
13,
17,
0,
13,
18,
13,
39,
17,
0,
13,
4,
13,
13,
28,
13,
4,
13,
13,
41,
28,
13,
4,
13,
13,
4,
17,
0,
13,
13,
28,
13,
4,
13,
13,
14,
2,
13,
17,
0,
18,
13,
17,
18,
13,
13,
0,
18,
13,
13,
2,
2,
18,
13,
2,
13,
17,
17,
13,
28,
13,
4,
13,
13,
14,
2,
18,
13,
13,
17,
0,
18,
13,
13,
18,
13,
13,
0,
18,
13,
13,
13,
0,
13,
13,
0,
13,
2,
13,
13,
0,
13,
17,
28,
13,
4,
13,
13,
0,
13,
2,
13,
13,
0,
13,
2,
2,
2,
18,
13,
2,
2,
2,
13,
13,
13,
17,
18,
13,
2,
2,
13,
13,
17,
18,
13,
13,
13,
0,
13,
2,
2,
2,
18,
13,
2,
2,
2,
13,
13,
13,
17,
18,
13,
2,
2,
13,
13,
17,
18,
13,
2,
13,
17,
13,
0,
13,
2,
13,
13,
0,
13,
13,
4,
13,
13,
10,
2,
13,
10,
4,
13,
10,
2,
13,
10,
13,
13,
10,
2,
13,
10,
2,
13,
10,
4,
13,
10,
13,
13,
10,
18,
13,
10,
4,
13,
10,
13,
13,
10,
2,
13,
10,
2,
13,
10,
2,
13,
10,
17,
13,
10,
2,
13,
10,
13,
13,
10,
4,
13,
10,
13,
13,
10,
4,
13,
10,
4,
13,
10,
4,
13
] | [
[
318,
4
],
[
318,
13
],
[
318,
14
],
[
318,
15
],
[
294,
17
],
[
261,
24
],
[
319,
27
],
[
283,
28
],
[
33,
32
],
[
262,
35
],
[
285,
39
],
[
43,
42
],
[
262,
45
],
[
42,
48
],
[
54,
51
],
[
286,
52
],
[
42,
53
],
[
286,
57
],
[
42,
59
],
[
42,
61
],
[
295,
62
],
[
66,
65
],
[
262,
68
],
[
303,
72
],
[
291,
75
],
[
295,
77
],
[
273,
80
],
[
292,
83
],
[
312,
85
],
[
274,
88
],
[
279,
92
],
[
313,
94
],
[
274,
94
],
[
306,
98
],
[
280,
101
],
[
313,
101
],
[
274,
101
],
[
104,
103
],
[
262,
106
],
[
110,
109
],
[
307,
112
],
[
264,
116
],
[
120,
119
],
[
307,
122
],
[
119,
125
],
[
131,
128
],
[
265,
129
],
[
51,
131
],
[
286,
132
],
[
103,
133
],
[
138,
135
],
[
265,
136
],
[
119,
137
],
[
265,
141
],
[
119,
143
],
[
295,
146
],
[
149,
148
],
[
307,
151
],
[
280,
155
],
[
313,
155
],
[
274,
155
],
[
148,
156
],
[
162,
159
],
[
304,
160
],
[
103,
161
],
[
135,
162
],
[
265,
163
],
[
148,
164
],
[
169,
166
],
[
304,
167
],
[
103,
168
],
[
295,
169
],
[
276,
171
],
[
259,
172
],
[
288,
174
],
[
283,
176
],
[
259,
177
],
[
297,
179
],
[
183,
182
],
[
289,
185
],
[
267,
187
],
[
259,
189
],
[
182,
190
],
[
270,
192
],
[
286,
197
],
[
319,
201
],
[
316,
202
],
[
268,
203
],
[
277,
203
],
[
304,
206
],
[
319,
209
],
[
316,
210
],
[
304,
213
],
[
268,
214
],
[
277,
214
],
[
295,
215
],
[
255,
217
],
[
286,
222
],
[
283,
226
],
[
316,
227
],
[
268,
228
],
[
277,
228
],
[
304,
231
],
[
283,
234
],
[
268,
235
],
[
277,
235
],
[
304,
238
],
[
316,
240
],
[
295,
242
],
[
300,
244
],
[
271,
246
],
[
256,
247
],
[
309,
249
],
[
295,
250
],
[
310,
253
],
[
301,
253
],
[
298,
253
],
[
255,
256
],
[
318,
259
],
[
261,
262
],
[
264,
265
],
[
267,
268
],
[
270,
271
],
[
273,
274
],
[
259,
276
],
[
276,
277
],
[
279,
280
],
[
318,
283
],
[
285,
286
],
[
288,
289
],
[
291,
292
],
[
294,
295
],
[
297,
298
],
[
300,
301
],
[
303,
304
],
[
306,
307
],
[
295,
309
],
[
309,
310
],
[
312,
313
],
[
318,
316
],
[
318,
319
]
] | [
"#D問題\nimport math\nH,W,A,B = map(int,input().split())\nmod = 10**9 + 7\n\nM = H+W-1\nfact = [1 for i in range(M)]\nfor i in range(M):\n if i == 0:\n pass\n else:\n fact[i] = (fact[i-1]*i)%mod\n \nrefact = [1 for i in range(M)]\nm = mod-2\nb = bin(m)\nb = b.lstrip(\"0b\")\nb = b[::-1]\nm2 = len(b)\nfor i in range(M): \n flog = [0 for j in range(m2)]\n for j in range(m2):\n if j == 0:\n flog[0] = fact[i]\n else:\n flog[j] = (flog[j-1]**2)%mod\n #print(flog)\n for j in range(m2):\n if b[j] == \"1\":\n refact[i]*=flog[j]\n refact[i]%=mod\n \nrow = B\nwide = W-B\nans = 0\nfor i in range(wide):\n row = B+i\n C1 = (fact[H-A+row-1]*refact[H-A-1]*refact[row])%mod\n C2 = (fact[W+A-row-2]*refact[W-row-1]*refact[A-1])%mod\n #print(C1,C2)\n ans+=C1*C2\n ans%=mod\n\n#print(fact)\n#print(refact)\n\nprint(ans)",
"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",
"mod = 10**9 + 7",
"mod",
"10**9 + 7",
"10**9",
"10",
"9",
"7",
"M = H+W-1",
"M",
"H+W-1",
"H+W",
"H",
"W",
"1",
"1 for i in range(M)",
"for i in range(M)",
"i",
"range(M)",
"range",
"M",
"for i in range(M)",
"1",
"fact = [1 for i in range(M)]",
"fact",
"[1 for i in range(M)]",
"for i in range(M):\n if i == 0:\n pass\n else:\n fact[i] = (fact[i-1]*i)%mod\n ",
"i",
"range(M)",
"range",
"M",
"if i == 0:\n pass\n else:\n fact[i] = (fact[i-1]*i)%mod\n ",
"i == 0",
"i",
"0",
"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",
"1 for i in range(M)",
"for i in range(M)",
"i",
"range(M)",
"range",
"M",
"for i in range(M)",
"1",
"refact = [1 for i in range(M)]",
"refact",
"[1 for i in range(M)]",
"m = mod-2",
"m",
"mod-2",
"mod",
"2",
"b = bin(m)",
"b",
"bin(m)",
"bin",
"m",
"b = b.lstrip(\"0b\")",
"b",
"b.lstrip(\"0b\")",
"b.lstrip",
"b",
"lstrip",
"\"0b\"",
"b = b[::-1]",
"b",
"b[::-1]",
"b",
"::-1",
"-1",
"m2 = len(b)",
"m2",
"len(b)",
"len",
"b",
"for i in range(M): \n flog = [0 for j in range(m2)]\n for j in range(m2):\n if j == 0:\n flog[0] = fact[i]\n else:\n flog[j] = (flog[j-1]**2)%mod\n #print(flog)\n for j in range(m2):\n if b[j] == \"1\":\n refact[i]*=flog[j]\n refact[i]%=mod\n ",
"i",
"range(M)",
"range",
"M",
"0 for j in range(m2)",
"for j in range(m2)",
"j",
"range(m2)",
"range",
"m2",
"for j in range(m2)",
"0",
"flog = [0 for j in range(m2)]",
"flog",
"[0 for j in range(m2)]",
"for j in range(m2):\n if j == 0:\n flog[0] = fact[i]\n else:\n flog[j] = (flog[j-1]**2)%mod\n #print(flog)\n ",
"j",
"range(m2)",
"range",
"m2",
"if j == 0:\n flog[0] = fact[i]\n else:\n flog[j] = (flog[j-1]**2)%mod\n #print(flog)\n ",
"j == 0",
"j",
"0",
"flog[0] = fact[i]",
"flog[0]",
"flog",
"0",
"fact[i]",
"fact",
"i",
"flog[j] = (flog[j-1]**2)%mod",
"flog[j]",
"flog",
"j",
"(flog[j-1]**2)%mod",
"flog[j-1]**2",
"flog[j-1]",
"flog",
"j-1",
"j",
"1",
"2",
"mod",
"for j in range(m2):\n if b[j] == \"1\":\n refact[i]*=flog[j]\n refact[i]%=mod\n ",
"j",
"range(m2)",
"range",
"m2",
"if b[j] == \"1\":\n refact[i]*=flog[j]\n refact[i]%=mod\n ",
"b[j] == \"1\"",
"b[j]",
"b",
"j",
"\"1\"",
"refact[i]*=flog[j]",
"refact[i]",
"refact",
"i",
"flog[j]",
"flog",
"j",
"refact[i]%=mod",
"refact[i]",
"refact",
"i",
"mod",
"row = B",
"row",
"B",
"wide = W-B",
"wide",
"W-B",
"W",
"B",
"ans = 0",
"ans",
"0",
"for i in range(wide):\n row = B+i\n C1 = (fact[H-A+row-1]*refact[H-A-1]*refact[row])%mod\n C2 = (fact[W+A-row-2]*refact[W-row-1]*refact[A-1])%mod\n #print(C1,C2)\n ans+=C1*C2\n ans%=mod\n\n#print(fact)\n#print(refact)",
"i",
"range(wide)",
"range",
"wide",
"row = B+i",
"row",
"B+i",
"B",
"i",
"C1 = (fact[H-A+row-1]*refact[H-A-1]*refact[row])%mod",
"C1",
"(fact[H-A+row-1]*refact[H-A-1]*refact[row])%mod",
"fact[H-A+row-1]*refact[H-A-1]*refact[row]",
"fact[H-A+row-1]*refact[H-A-1]",
"fact[H-A+row-1]",
"fact",
"H-A+row-1",
"H-A+row",
"H-A",
"H",
"A",
"row",
"1",
"refact[H-A-1]",
"refact",
"H-A-1",
"H-A",
"H",
"A",
"1",
"refact[row]",
"refact",
"row",
"mod",
"C2 = (fact[W+A-row-2]*refact[W-row-1]*refact[A-1])%mod",
"C2",
"(fact[W+A-row-2]*refact[W-row-1]*refact[A-1])%mod",
"fact[W+A-row-2]*refact[W-row-1]*refact[A-1]",
"fact[W+A-row-2]*refact[W-row-1]",
"fact[W+A-row-2]",
"fact",
"W+A-row-2",
"W+A-row",
"W+A",
"W",
"A",
"row",
"2",
"refact[W-row-1]",
"refact",
"W-row-1",
"W-row",
"W",
"row",
"1",
"refact[A-1]",
"refact",
"A-1",
"A",
"1",
"mod",
"ans+=C1*C2",
"ans",
"C1*C2",
"C1",
"C2",
"ans%=mod",
"ans",
"mod",
"print(ans)",
"print",
"ans",
"C2 = (fact[W+A-row-2]*refact[W-row-1]*refact[A-1])%mod",
"(fact[W+A-row-2]*refact[W-row-1]*refact[A-1])%mod",
"C2",
"B = map(int,input().split())",
"map(int,input().split())",
"B",
"M = H+W-1",
"H+W-1",
"M",
"flog = [0 for j in range(m2)]",
"[0 for j in range(m2)]",
"flog",
"row = B+i",
"B+i",
"row",
"C1 = (fact[H-A+row-1]*refact[H-A-1]*refact[row])%mod",
"(fact[H-A+row-1]*refact[H-A-1]*refact[row])%mod",
"C1",
"b = bin(m)",
"bin(m)",
"b",
"row = B",
"B",
"row",
"b = b[::-1]",
"b[::-1]",
"b",
"W,A,B = map(int,input().split())",
"map(int,input().split())",
"W",
"fact = [1 for i in range(M)]",
"[1 for i in range(M)]",
"fact",
"wide = W-B",
"W-B",
"wide",
"m = mod-2",
"mod-2",
"m",
"mod = 10**9 + 7",
"10**9 + 7",
"mod",
"ans = 0",
"0",
"ans",
"ans+=C1*C2",
"C1*C2",
"ans",
"refact = [1 for i in range(M)]",
"[1 for i in range(M)]",
"refact",
"m2 = len(b)",
"len(b)",
"m2",
"ans%=mod",
"mod",
"ans",
"b = b.lstrip(\"0b\")",
"b.lstrip(\"0b\")",
"b",
"A,B = map(int,input().split())",
"map(int,input().split())",
"A",
"H,W,A,B = map(int,input().split())",
"map(int,input().split())",
"H"
] | #D問題
import math
H,W,A,B = map(int,input().split())
mod = 10**9 + 7
M = H+W-1
fact = [1 for i in range(M)]
for i in range(M):
if i == 0:
pass
else:
fact[i] = (fact[i-1]*i)%mod
refact = [1 for i in range(M)]
m = mod-2
b = bin(m)
b = b.lstrip("0b")
b = b[::-1]
m2 = len(b)
for i in range(M):
flog = [0 for j in range(m2)]
for j in range(m2):
if j == 0:
flog[0] = fact[i]
else:
flog[j] = (flog[j-1]**2)%mod
#print(flog)
for j in range(m2):
if b[j] == "1":
refact[i]*=flog[j]
refact[i]%=mod
row = B
wide = W-B
ans = 0
for i in range(wide):
row = B+i
C1 = (fact[H-A+row-1]*refact[H-A-1]*refact[row])%mod
C2 = (fact[W+A-row-2]*refact[W-row-1]*refact[A-1])%mod
#print(C1,C2)
ans+=C1*C2
ans%=mod
#print(fact)
#print(refact)
print(ans) |
[
7,
0,
13,
4,
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,
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,
12,
13,
29,
4,
13,
2,
13,
13,
13,
2,
2,
17,
17,
17,
23,
13,
23,
13,
0,
13,
4,
13,
2,
13,
17,
2,
13,
17,
28,
13,
4,
13,
13,
0,
13,
2,
2,
4,
13,
13,
2,
2,
13,
13,
17,
4,
13,
2,
13,
17,
2,
2,
13,
13,
17,
13,
0,
13,
13,
0,
13,
13,
0,
13,
13,
4,
13,
13,
10,
12,
13,
10,
4,
13,
10,
2,
13,
10,
13,
13,
10,
39,
13,
10,
2,
13,
10,
4,
13,
10,
13,
13,
10,
4,
13,
10,
4,
13,
10,
39,
13,
10,
4,
13,
10,
13,
13,
10,
12,
13,
10,
39,
13,
10,
2,
13
] | [
[
237,
2
],
[
237,
13
],
[
237,
14
],
[
237,
15
],
[
55,
21
],
[
53,
24
],
[
55,
25
],
[
30,
29
],
[
55,
32
],
[
53,
34
],
[
55,
35
],
[
53,
42
],
[
29,
45
],
[
55,
45
],
[
53,
49
],
[
29,
50
],
[
55,
50
],
[
57,
51
],
[
53,
53
],
[
55,
55
],
[
57,
57
],
[
210,
59
],
[
249,
66
],
[
234,
73
],
[
216,
78
],
[
246,
83
],
[
89,
88
],
[
250,
93
],
[
235,
97
],
[
235,
102
],
[
88,
104
],
[
211,
105
],
[
247,
108
],
[
247,
114
],
[
211,
116
],
[
88,
117
],
[
211,
119
],
[
88,
120
],
[
211,
121
],
[
217,
124
],
[
217,
129
],
[
247,
132
],
[
211,
134
],
[
205,
139
],
[
150,
141
],
[
152,
142
],
[
150,
143
],
[
150,
150
],
[
152,
152
],
[
231,
154
],
[
244,
156
],
[
208,
158
],
[
238,
161
],
[
165,
164
],
[
223,
167
],
[
219,
169
],
[
244,
173
],
[
164,
174
],
[
238,
177
],
[
229,
178
],
[
244,
181
],
[
229,
183
],
[
208,
187
],
[
164,
188
],
[
211,
190
],
[
225,
192
],
[
211,
193
],
[
213,
195
],
[
220,
196
],
[
240,
198
],
[
211,
199
],
[
241,
202
],
[
214,
202
],
[
226,
202
],
[
232,
202
],
[
237,
208
],
[
210,
211
],
[
220,
213
],
[
213,
214
],
[
216,
217
],
[
219,
220
],
[
237,
223
],
[
211,
225
],
[
225,
226
],
[
237,
229
],
[
231,
232
],
[
234,
235
],
[
237,
238
],
[
211,
240
],
[
240,
241
],
[
246,
247
],
[
249,
250
]
] | [
"\na,b,c,d = list(map(int, input().split()))\n\ndef cmb(n, r, p):\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] % p\n\np = 10**9+7\nN = 10 ** 6 + 2\nfact = [1, 1] # fact[n] = (n! mod p)\nfactinv = [1, 1] # factinv[n] = ((n!)^(-1) mod p)\ninv = [0, 1] # factinv 計算用\n\nfor i in range(2, N + 1):\n fact.append((fact[-1] * i) % p)\n inv.append((-inv[p % i] * (p // i)) % p)\n factinv.append((factinv[-1] * inv[-1]) % p)\n \ndef wh(w,h):\n return cmb(w+h,w,10**9+7)\n\nans = wh(b-1,a-1)\n#print(ans)\n\nfor i in range(d):\n tmp = wh(i,a-c-1) * wh(c-1,b-i-1) % p\n ans += p\n ans -= tmp\n ans %= p\n #print(ans)\n \nprint(ans)\n\n",
"a,b,c,d = list(map(int, input().split()))",
"a",
"list(map(int, input().split()))",
"list",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"b",
"c",
"d",
"def cmb(n, r, p):\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] % p",
"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] % p",
"fact[n] * factinv[r] * factinv[n-r] % p",
"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",
"p",
"n",
"n",
"r",
"r",
"p",
"p",
"p = 10**9+7",
"p",
"10**9+7",
"10**9",
"10",
"9",
"7",
"N = 10 ** 6 + 2",
"N",
"10 ** 6 + 2",
"10 ** 6",
"10",
"6",
"2",
"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) % p)\n inv.append((-inv[p % i] * (p // i)) % p)\n factinv.append((factinv[-1] * inv[-1]) % p)\n ",
"i",
"range(2, N + 1)",
"range",
"2",
"N + 1",
"N",
"1",
"fact.append((fact[-1] * i) % p)",
"fact.append",
"fact",
"append",
"(fact[-1] * i) % p",
"fact[-1] * i",
"fact[-1]",
"fact",
"-1",
"i",
"p",
"inv.append((-inv[p % i] * (p // i)) % p)",
"inv.append",
"inv",
"append",
"(-inv[p % i] * (p // i)) % p",
"-inv[p % i] * (p // i)",
"-inv[p % i]",
"inv[p % i]",
"inv",
"p % i",
"p",
"i",
"p // i",
"p",
"i",
"p",
"factinv.append((factinv[-1] * inv[-1]) % p)",
"factinv.append",
"factinv",
"append",
"(factinv[-1] * inv[-1]) % p",
"factinv[-1] * inv[-1]",
"factinv[-1]",
"factinv",
"-1",
"inv[-1]",
"inv",
"-1",
"p",
"def wh(w,h):\n return cmb(w+h,w,10**9+7)",
"wh",
"return cmb(w+h,w,10**9+7)",
"cmb(w+h,w,10**9+7)",
"cmb",
"w+h",
"w",
"h",
"w",
"10**9+7",
"10**9",
"10",
"9",
"7",
"w",
"w",
"h",
"h",
"ans = wh(b-1,a-1)",
"ans",
"wh(b-1,a-1)",
"wh",
"b-1",
"b",
"1",
"a-1",
"a",
"1",
"for i in range(d):\n tmp = wh(i,a-c-1) * wh(c-1,b-i-1) % p\n ans += p\n ans -= tmp\n ans %= p\n #print(ans)\n ",
"i",
"range(d)",
"range",
"d",
"tmp = wh(i,a-c-1) * wh(c-1,b-i-1) % p",
"tmp",
"wh(i,a-c-1) * wh(c-1,b-i-1) % p",
"wh(i,a-c-1) * wh(c-1,b-i-1)",
"wh(i,a-c-1)",
"wh",
"i",
"a-c-1",
"a-c",
"a",
"c",
"1",
"wh(c-1,b-i-1)",
"wh",
"c-1",
"c",
"1",
"b-i-1",
"b-i",
"b",
"i",
"1",
"p",
"ans += p",
"ans",
"p",
"ans -= tmp",
"ans",
"tmp",
"ans %= p",
"ans",
"p",
"print(ans)",
"print",
"ans",
"def cmb(n, r, p):\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] % p",
"def cmb(n, r, p):\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] % p",
"cmb",
"b,c,d = list(map(int, input().split()))",
"list(map(int, input().split()))",
"b",
"p = 10**9+7",
"10**9+7",
"p",
"ans -= tmp",
"tmp",
"ans",
"factinv = [1, 1]",
"[1, 1]",
"factinv",
"tmp = wh(i,a-c-1) * wh(c-1,b-i-1) % p",
"wh(i,a-c-1) * wh(c-1,b-i-1) % p",
"tmp",
"d = list(map(int, input().split()))",
"list(map(int, input().split()))",
"d",
"ans += p",
"p",
"ans",
"c,d = list(map(int, input().split()))",
"list(map(int, input().split()))",
"c",
"ans = wh(b-1,a-1)",
"wh(b-1,a-1)",
"ans",
"fact = [1, 1]",
"[1, 1]",
"fact",
"a,b,c,d = list(map(int, input().split()))",
"list(map(int, input().split()))",
"a",
"ans %= p",
"p",
"ans",
"def wh(w,h):\n return cmb(w+h,w,10**9+7)",
"def wh(w,h):\n return cmb(w+h,w,10**9+7)",
"wh",
"inv = [0, 1]",
"[0, 1]",
"inv",
"N = 10 ** 6 + 2",
"10 ** 6 + 2",
"N"
] |
a,b,c,d = list(map(int, input().split()))
def cmb(n, r, p):
if (r < 0) or (n < r):
return 0
r = min(r, n - r)
return fact[n] * factinv[r] * factinv[n-r] % p
p = 10**9+7
N = 10 ** 6 + 2
fact = [1, 1] # fact[n] = (n! mod p)
factinv = [1, 1] # factinv[n] = ((n!)^(-1) mod p)
inv = [0, 1] # factinv 計算用
for i in range(2, N + 1):
fact.append((fact[-1] * i) % p)
inv.append((-inv[p % i] * (p // i)) % p)
factinv.append((factinv[-1] * inv[-1]) % p)
def wh(w,h):
return cmb(w+h,w,10**9+7)
ans = wh(b-1,a-1)
#print(ans)
for i in range(d):
tmp = wh(i,a-c-1) * wh(c-1,b-i-1) % p
ans += p
ans -= tmp
ans %= p
#print(ans)
print(ans)
|
[
7,
15,
13,
12,
13,
0,
13,
13,
0,
13,
17,
0,
13,
17,
42,
13,
0,
13,
2,
13,
13,
0,
13,
2,
13,
13,
0,
13,
13,
13,
13,
0,
13,
2,
13,
13,
0,
13,
13,
13,
13,
0,
13,
13,
14,
2,
13,
17,
0,
13,
13,
29,
13,
23,
13,
23,
13,
0,
13,
4,
18,
4,
13,
13,
17,
41,
28,
13,
13,
4,
4,
13,
13,
0,
13,
13,
0,
13,
18,
13,
17,
0,
13,
18,
13,
17,
0,
13,
18,
13,
17,
0,
13,
18,
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,
28,
13,
4,
13,
2,
2,
13,
13,
17,
14,
2,
13,
17,
0,
18,
13,
13,
17,
0,
18,
13,
13,
2,
2,
18,
13,
2,
13,
17,
13,
17,
28,
13,
4,
13,
4,
13,
2,
2,
13,
13,
17,
14,
2,
13,
2,
2,
13,
13,
17,
0,
18,
13,
13,
4,
13,
4,
18,
13,
13,
13,
17,
0,
18,
13,
13,
2,
2,
18,
13,
2,
13,
17,
2,
13,
17,
17,
12,
13,
29,
2,
2,
2,
18,
13,
13,
18,
13,
13,
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,
2,
2,
13,
13,
17,
4,
13,
2,
2,
2,
2,
13,
17,
13,
13,
17,
2,
2,
13,
13,
17,
0,
13,
17,
4,
13,
13,
10,
17,
13,
10,
18,
13,
10,
17,
13,
10,
18,
13,
10,
12,
13,
10,
12,
13,
10,
18,
13,
10,
13,
13,
10,
2,
13,
10,
13,
13,
10,
13,
13,
10,
18,
13,
10,
4,
13
] | [
[
7,
6
],
[
56,
7
],
[
10,
9
],
[
13,
12
],
[
18,
17
],
[
54,
19
],
[
27,
19
],
[
22,
19
],
[
6,
20
],
[
29,
20
],
[
23,
22
],
[
17,
24
],
[
6,
25
],
[
29,
25
],
[
28,
27
],
[
6,
28
],
[
29,
28
],
[
30,
29
],
[
27,
30
],
[
22,
30
],
[
54,
30
],
[
33,
32
],
[
17,
34
],
[
12,
35
],
[
39,
35
],
[
38,
37
],
[
12,
38
],
[
39,
38
],
[
40,
39
],
[
37,
40
],
[
32,
40
],
[
9,
40
],
[
43,
42
],
[
56,
43
],
[
42,
46
],
[
37,
46
],
[
32,
46
],
[
9,
46
],
[
50,
49
],
[
56,
50
],
[
49,
52
],
[
42,
52
],
[
37,
52
],
[
32,
52
],
[
9,
52
],
[
54,
54
],
[
56,
56
],
[
310,
58
],
[
68,
67
],
[
311,
67
],
[
67,
72
],
[
301,
74
],
[
283,
77
],
[
302,
79
],
[
307,
82
],
[
302,
84
],
[
277,
87
],
[
302,
89
],
[
292,
92
],
[
302,
94
],
[
99,
98
],
[
284,
103
],
[
308,
104
],
[
304,
109
],
[
114,
113
],
[
284,
118
],
[
308,
119
],
[
295,
124
],
[
128,
127
],
[
284,
132
],
[
308,
133
],
[
127,
137
],
[
143,
140
],
[
305,
141
],
[
127,
142
],
[
148,
145
],
[
305,
146
],
[
127,
147
],
[
305,
151
],
[
127,
153
],
[
127,
155
],
[
159,
158
],
[
284,
165
],
[
308,
166
],
[
158,
170
],
[
284,
173
],
[
308,
174
],
[
180,
177
],
[
296,
178
],
[
158,
179
],
[
287,
181
],
[
158,
186
],
[
192,
189
],
[
296,
190
],
[
158,
191
],
[
296,
195
],
[
158,
197
],
[
158,
200
],
[
305,
210
],
[
222,
211
],
[
296,
213
],
[
224,
214
],
[
296,
216
],
[
222,
218
],
[
224,
219
],
[
222,
222
],
[
224,
224
],
[
280,
226
],
[
230,
229
],
[
293,
232
],
[
308,
233
],
[
298,
235
],
[
290,
238
],
[
229,
242
],
[
284,
243
],
[
278,
244
],
[
284,
248
],
[
278,
249
],
[
290,
252
],
[
278,
257
],
[
308,
259
],
[
229,
260
],
[
308,
264
],
[
229,
265
],
[
274,
268
],
[
275,
272
],
[
299,
272
],
[
281,
272
],
[
274,
275
],
[
277,
278
],
[
280,
281
],
[
283,
284
],
[
292,
293
],
[
295,
296
],
[
298,
299
],
[
301,
302
],
[
304,
305
],
[
307,
308
],
[
310,
311
]
] | [
"import math\n\ndef modinv(a,m):\n\tb = m\n\tu = 1\n\tv = 0\n\twhile(b):\n\t\tt = a // b\n\t\ta -= t * b\n\t\ta,b = b,a\n\t\tu -= t * v\n\t\tu,v = v,u\n\tu %= m\n\tif u < 0:\n\t\tu += m\n\treturn u\n\ninp = input().split(' ')\ninpint = [int(i) for i in inp]\nh = inpint[0]\nw = inpint[1]\na = inpint[2]\nb = inpint[3]\n\nxfac = [0 for r in range(h+w-2)]\nxfac_inv = [0 for r in range(h+w-2)]\n\nfor i in range(h+w-2):\n\tif i == 0:\n\t\txfac[i] = 1\n\telse:\n\t\txfac[i] = (xfac[i-1]*i)%1000000007\n\nfor i in reversed(range(h+w-2)):\n\tif i == h+w-3:\n\t\txfac_inv[i] = modinv(math.factorial(i),1000000007)\n\telse:\n\t\txfac_inv[i] = xfac_inv[i+1] * (i+1) % 1000000007\n\n# print(xfac)\n# print(xfac_inv)\n\n# for i in range(h+w-2):\n# \tprint(xfac[i]*xfac_inv[i]%1000000007)\n\ndef com(a,b):\n\treturn (xfac[a] * xfac_inv[b] * xfac_inv[a-b])%1000000007\n\nsum = 0\nfor i in range(b,w):\n\tsum += com(i + h-a-1,h-a-1) * com((a-1)+w-i-1, w-i-1)\n\tsum %= 1000000007\n\nprint(sum)",
"import math",
"math",
"def modinv(a,m):\n\tb = m\n\tu = 1\n\tv = 0\n\twhile(b):\n\t\tt = a // b\n\t\ta -= t * b\n\t\ta,b = b,a\n\t\tu -= t * v\n\t\tu,v = v,u\n\tu %= m\n\tif u < 0:\n\t\tu += m\n\treturn u",
"modinv",
"b = m",
"b",
"m",
"u = 1",
"u",
"1",
"v = 0",
"v",
"0",
"while(b):\n\t\tt = a // b\n\t\ta -= t * b\n\t\ta,b = b,a\n\t\tu -= t * v\n\t\tu,v = v,u\n\t",
"b",
"t = a // b",
"t",
"a // b",
"a",
"b",
"a -= t * b",
"a",
"t * b",
"t",
"b",
"a,b = b,a",
"a",
"b",
"b",
"a",
"u -= t * v",
"u",
"t * v",
"t",
"v",
"u,v = v,u",
"u",
"v",
"v",
"u",
"u %= m",
"u",
"m",
"if u < 0:\n\t\tu += m\n\t",
"u < 0",
"u",
"0",
"u += m",
"u",
"m",
"return u",
"u",
"a",
"a",
"m",
"m",
"inp = input().split(' ')",
"inp",
"input().split(' ')",
"().split",
"()",
"input",
"split",
"' '",
"int(i) for i in inp",
"for i in inp",
"i",
"inp",
"for i in inp",
"int(i)",
"int",
"i",
"inpint = [int(i) for i in inp]",
"inpint",
"[int(i) for i in inp]",
"h = inpint[0]",
"h",
"inpint[0]",
"inpint",
"0",
"w = inpint[1]",
"w",
"inpint[1]",
"inpint",
"1",
"a = inpint[2]",
"a",
"inpint[2]",
"inpint",
"2",
"b = inpint[3]",
"b",
"inpint[3]",
"inpint",
"3",
"0 for r in range(h+w-2)",
"for r in range(h+w-2)",
"r",
"range(h+w-2)",
"range",
"h+w-2",
"h+w",
"h",
"w",
"2",
"for r in range(h+w-2)",
"0",
"xfac = [0 for r in range(h+w-2)]",
"xfac",
"[0 for r in range(h+w-2)]",
"0 for r in range(h+w-2)",
"for r in range(h+w-2)",
"r",
"range(h+w-2)",
"range",
"h+w-2",
"h+w",
"h",
"w",
"2",
"for r in range(h+w-2)",
"0",
"xfac_inv = [0 for r in range(h+w-2)]",
"xfac_inv",
"[0 for r in range(h+w-2)]",
"for i in range(h+w-2):\n\tif i == 0:\n\t\txfac[i] = 1\n\telse:\n\t\txfac[i] = (xfac[i-1]*i)%1000000007",
"i",
"range(h+w-2)",
"range",
"h+w-2",
"h+w",
"h",
"w",
"2",
"if i == 0:\n\t\txfac[i] = 1\n\telse:\n\t\txfac[i] = (xfac[i-1]*i)%1000000007",
"i == 0",
"i",
"0",
"xfac[i] = 1",
"xfac[i]",
"xfac",
"i",
"1",
"xfac[i] = (xfac[i-1]*i)%1000000007",
"xfac[i]",
"xfac",
"i",
"(xfac[i-1]*i)%1000000007",
"xfac[i-1]*i",
"xfac[i-1]",
"xfac",
"i-1",
"i",
"1",
"i",
"1000000007",
"for i in reversed(range(h+w-2)):\n\tif i == h+w-3:\n\t\txfac_inv[i] = modinv(math.factorial(i),1000000007)\n\telse:\n\t\txfac_inv[i] = xfac_inv[i+1] * (i+1) % 1000000007\n\n# print(xfac)\n# print(xfac_inv)\n\n# for i in range(h+w-2):\n# \tprint(xfac[i]*xfac_inv[i]%1000000007)",
"i",
"reversed(range(h+w-2))",
"reversed",
"range(h+w-2)",
"range",
"h+w-2",
"h+w",
"h",
"w",
"2",
"if i == h+w-3:\n\t\txfac_inv[i] = modinv(math.factorial(i),1000000007)\n\telse:\n\t\txfac_inv[i] = xfac_inv[i+1] * (i+1) % 1000000007\n\n# print(xfac)\n# print(xfac_inv)\n\n# for i in range(h+w-2):\n# \tprint(xfac[i]*xfac_inv[i]%1000000007)",
"i == h+w-3",
"i",
"h+w-3",
"h+w",
"h",
"w",
"3",
"xfac_inv[i] = modinv(math.factorial(i),1000000007)",
"xfac_inv[i]",
"xfac_inv",
"i",
"modinv(math.factorial(i),1000000007)",
"modinv",
"math.factorial(i)",
"math.factorial",
"math",
"factorial",
"i",
"1000000007",
"xfac_inv[i] = xfac_inv[i+1] * (i+1) % 1000000007",
"xfac_inv[i]",
"xfac_inv",
"i",
"xfac_inv[i+1] * (i+1) % 1000000007",
"xfac_inv[i+1] * (i+1)",
"xfac_inv[i+1]",
"xfac_inv",
"i+1",
"i",
"1",
"i+1",
"i",
"1",
"1000000007",
"def com(a,b):\n\treturn (xfac[a] * xfac_inv[b] * xfac_inv[a-b])%1000000007",
"com",
"return (xfac[a] * xfac_inv[b] * xfac_inv[a-b])%1000000007",
"(xfac[a] * xfac_inv[b] * xfac_inv[a-b])%1000000007",
"xfac[a] * xfac_inv[b] * xfac_inv[a-b]",
"xfac[a] * xfac_inv[b]",
"xfac[a]",
"xfac",
"a",
"xfac_inv[b]",
"xfac_inv",
"b",
"xfac_inv[a-b]",
"xfac_inv",
"a-b",
"a",
"b",
"1000000007",
"a",
"a",
"b",
"b",
"sum = 0",
"sum",
"0",
"for i in range(b,w):\n\tsum += com(i + h-a-1,h-a-1) * com((a-1)+w-i-1, w-i-1)\n\tsum %= 1000000007",
"i",
"range(b,w)",
"range",
"b",
"w",
"sum += com(i + h-a-1,h-a-1) * com((a-1)+w-i-1, w-i-1)",
"sum",
"com(i + h-a-1,h-a-1) * com((a-1)+w-i-1, w-i-1)",
"com(i + h-a-1,h-a-1)",
"com",
"i + h-a-1",
"i + h-a",
"i + h",
"i",
"h",
"a",
"1",
"h-a-1",
"h-a",
"h",
"a",
"1",
"com((a-1)+w-i-1, w-i-1)",
"com",
"(a-1)+w-i-1",
"(a-1)+w-i",
"(a-1)+w",
"a-1",
"a",
"1",
"w",
"i",
"1",
"w-i-1",
"w-i",
"w",
"i",
"1",
"sum %= 1000000007",
"sum",
"1000000007",
"print(sum)",
"print",
"sum",
"sum %= 1000000007",
"1000000007",
"sum",
"a = inpint[2]",
"inpint[2]",
"a",
"sum = 0",
"0",
"sum",
"h = inpint[0]",
"inpint[0]",
"h",
"def modinv(a,m):\n\tb = m\n\tu = 1\n\tv = 0\n\twhile(b):\n\t\tt = a // b\n\t\ta -= t * b\n\t\ta,b = b,a\n\t\tu -= t * v\n\t\tu,v = v,u\n\tu %= m\n\tif u < 0:\n\t\tu += m\n\treturn u",
"def modinv(a,m):\n\tb = m\n\tu = 1\n\tv = 0\n\twhile(b):\n\t\tt = a // b\n\t\ta -= t * b\n\t\ta,b = b,a\n\t\tu -= t * v\n\t\tu,v = v,u\n\tu %= m\n\tif u < 0:\n\t\tu += m\n\treturn u",
"modinv",
"def com(a,b):\n\treturn (xfac[a] * xfac_inv[b] * xfac_inv[a-b])%1000000007",
"def com(a,b):\n\treturn (xfac[a] * xfac_inv[b] * xfac_inv[a-b])%1000000007",
"com",
"b = inpint[3]",
"inpint[3]",
"b",
"xfac_inv = [0 for r in range(h+w-2)]",
"[0 for r in range(h+w-2)]",
"xfac_inv",
"sum += com(i + h-a-1,h-a-1) * com((a-1)+w-i-1, w-i-1)",
"com(i + h-a-1,h-a-1) * com((a-1)+w-i-1, w-i-1)",
"sum",
"inpint = [int(i) for i in inp]",
"[int(i) for i in inp]",
"inpint",
"xfac = [0 for r in range(h+w-2)]",
"[0 for r in range(h+w-2)]",
"xfac",
"w = inpint[1]",
"inpint[1]",
"w",
"inp = input().split(' ')",
"input().split(' ')",
"inp"
] | import math
def modinv(a,m):
b = m
u = 1
v = 0
while(b):
t = a // b
a -= t * b
a,b = b,a
u -= t * v
u,v = v,u
u %= m
if u < 0:
u += m
return u
inp = input().split(' ')
inpint = [int(i) for i in inp]
h = inpint[0]
w = inpint[1]
a = inpint[2]
b = inpint[3]
xfac = [0 for r in range(h+w-2)]
xfac_inv = [0 for r in range(h+w-2)]
for i in range(h+w-2):
if i == 0:
xfac[i] = 1
else:
xfac[i] = (xfac[i-1]*i)%1000000007
for i in reversed(range(h+w-2)):
if i == h+w-3:
xfac_inv[i] = modinv(math.factorial(i),1000000007)
else:
xfac_inv[i] = xfac_inv[i+1] * (i+1) % 1000000007
# print(xfac)
# print(xfac_inv)
# for i in range(h+w-2):
# print(xfac[i]*xfac_inv[i]%1000000007)
def com(a,b):
return (xfac[a] * xfac_inv[b] * xfac_inv[a-b])%1000000007
sum = 0
for i in range(b,w):
sum += com(i + h-a-1,h-a-1) * com((a-1)+w-i-1, w-i-1)
sum %= 1000000007
print(sum) |
[
7,
0,
13,
4,
13,
13,
4,
18,
4,
13,
13,
13,
13,
13,
0,
13,
2,
2,
17,
17,
17,
12,
13,
0,
13,
17,
42,
13,
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,
0,
13,
39,
17,
0,
13,
39,
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,
17,
2,
2,
13,
13,
17,
4,
18,
13,
13,
2,
2,
18,
13,
17,
13,
13,
4,
18,
13,
13,
4,
13,
18,
13,
17,
2,
13,
17,
28,
13,
4,
13,
2,
4,
13,
13,
17,
4,
18,
13,
13,
2,
2,
18,
13,
17,
2,
4,
13,
13,
4,
13,
13,
13,
0,
13,
18,
13,
39,
17,
0,
13,
17,
28,
13,
4,
13,
2,
13,
17,
2,
13,
17,
0,
13,
2,
2,
13,
13,
17,
0,
13,
2,
13,
17,
0,
13,
2,
2,
13,
2,
4,
13,
2,
2,
2,
2,
13,
13,
17,
13,
17,
2,
2,
13,
13,
17,
4,
13,
2,
2,
2,
13,
17,
13,
13,
2,
13,
13,
13,
4,
13,
13,
10,
12,
13,
10,
4,
13,
10,
18,
13,
10,
2,
13,
10,
39,
13,
10,
12,
13,
10,
4,
13,
10,
2,
13,
10,
2,
13,
10,
17,
13,
10,
2,
13,
10,
4,
13,
10,
4,
13,
10,
39,
13
] | [
[
249,
2
],
[
249,
11
],
[
249,
12
],
[
249,
13
],
[
234,
15
],
[
25,
24
],
[
54,
30
],
[
47,
30
],
[
34,
33
],
[
24,
36
],
[
33,
36
],
[
52,
37
],
[
40,
37
],
[
235,
38
],
[
41,
40
],
[
52,
43
],
[
40,
43
],
[
52,
44
],
[
40,
44
],
[
235,
45
],
[
48,
47
],
[
33,
50
],
[
24,
50
],
[
52,
52
],
[
54,
54
],
[
252,
56
],
[
225,
60
],
[
253,
69
],
[
81,
70
],
[
226,
72
],
[
83,
73
],
[
226,
75
],
[
81,
77
],
[
83,
78
],
[
235,
79
],
[
81,
81
],
[
83,
83
],
[
86,
85
],
[
250,
91
],
[
217,
92
],
[
253,
96
],
[
253,
101
],
[
85,
103
],
[
235,
104
],
[
226,
107
],
[
214,
110
],
[
253,
112
],
[
235,
115
],
[
119,
118
],
[
253,
124
],
[
226,
128
],
[
226,
133
],
[
253,
138
],
[
226,
141
],
[
235,
142
],
[
219,
144
],
[
226,
146
],
[
240,
150
],
[
154,
153
],
[
232,
157
],
[
217,
160
],
[
243,
163
],
[
250,
166
],
[
247,
167
],
[
222,
170
],
[
153,
172
],
[
237,
175
],
[
241,
178
],
[
238,
178
],
[
229,
181
],
[
250,
186
],
[
247,
187
],
[
153,
189
],
[
250,
193
],
[
247,
194
],
[
229,
197
],
[
247,
201
],
[
217,
203
],
[
153,
204
],
[
217,
206
],
[
153,
207
],
[
235,
208
],
[
238,
211
],
[
241,
211
],
[
249,
217
],
[
219,
220
],
[
222,
223
],
[
225,
226
],
[
249,
232
],
[
234,
235
],
[
237,
238
],
[
240,
241
],
[
243,
244
],
[
249,
247
],
[
249,
250
],
[
252,
253
]
] | [
"H, W, A, B = map(int, input().split())\n\nMOD = 10 ** 9 + 7\n\n\ndef pow_mod(x, p):\n res = 1\n while p:\n if p % 2:\n res = res * x % MOD\n x = x * x % MOD\n p //= 2\n return res\n\n\nF = [1]\ninvF = []\n\n\ndef comb_mod(n, r):\n return F[n] * invF[r] * invF[n - r] % MOD\n\n\nfor i in range(1, H + W - 1):\n F.append(F[-1] * i % MOD)\n\ninvF.append(pow_mod(F[-1], (MOD - 2)))\nfor f in range(len(F) - 1):\n invF.append(invF[-1] * (len(F) - len(invF)) % MOD)\ninvF = invF[::-1]\n\nres = 0\nfor i in range(B + 1, W + 1):\n p = H - A - 1\n q = i - 1\n\n res = (\n res\n + comb_mod(H - A - 1 + i - 1, H - A - 1)\n * comb_mod(A - 1 + W - i, W - i)\n ) % MOD\n\nprint(res)",
"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",
"def pow_mod(x, p):\n res = 1\n while p:\n if p % 2:\n res = res * x % MOD\n x = x * x % MOD\n p //= 2\n return res",
"pow_mod",
"res = 1",
"res",
"1",
"while p:\n if p % 2:\n res = res * x % MOD\n x = x * x % MOD\n p //= 2\n ",
"p",
"if p % 2:\n res = res * x % MOD\n ",
"p % 2",
"p",
"2",
"res = res * x % MOD",
"res",
"res * x % MOD",
"res * x",
"res",
"x",
"MOD",
"x = x * x % MOD",
"x",
"x * x % MOD",
"x * x",
"x",
"x",
"MOD",
"p //= 2",
"p",
"2",
"return res",
"res",
"x",
"x",
"p",
"p",
"F = [1]",
"F",
"[1]",
"1",
"invF = []",
"invF",
"[]",
"def comb_mod(n, r):\n return F[n] * invF[r] * invF[n - r] % MOD",
"comb_mod",
"return F[n] * invF[r] * invF[n - r] % MOD",
"F[n] * invF[r] * invF[n - r] % MOD",
"F[n] * invF[r] * invF[n - r]",
"F[n] * invF[r]",
"F[n]",
"F",
"n",
"invF[r]",
"invF",
"r",
"invF[n - r]",
"invF",
"n - r",
"n",
"r",
"MOD",
"n",
"n",
"r",
"r",
"for i in range(1, H + W - 1):\n F.append(F[-1] * i % MOD)",
"i",
"range(1, H + W - 1)",
"range",
"1",
"H + W - 1",
"H + W",
"H",
"W",
"1",
"F.append(F[-1] * i % MOD)",
"F.append",
"F",
"append",
"F[-1] * i % MOD",
"F[-1] * i",
"F[-1]",
"F",
"-1",
"i",
"MOD",
"invF.append(pow_mod(F[-1], (MOD - 2)))",
"invF.append",
"invF",
"append",
"pow_mod(F[-1], (MOD - 2))",
"pow_mod",
"F[-1]",
"F",
"-1",
"MOD - 2",
"MOD",
"2",
"for f in range(len(F) - 1):\n invF.append(invF[-1] * (len(F) - len(invF)) % MOD)",
"f",
"range(len(F) - 1)",
"range",
"len(F) - 1",
"len(F)",
"len",
"F",
"1",
"invF.append(invF[-1] * (len(F) - len(invF)) % MOD)",
"invF.append",
"invF",
"append",
"invF[-1] * (len(F) - len(invF)) % MOD",
"invF[-1] * (len(F) - len(invF))",
"invF[-1]",
"invF",
"-1",
"len(F) - len(invF)",
"len(F)",
"len",
"F",
"len(invF)",
"len",
"invF",
"MOD",
"invF = invF[::-1]",
"invF",
"invF[::-1]",
"invF",
"::-1",
"-1",
"res = 0",
"res",
"0",
"for i in range(B + 1, W + 1):\n p = H - A - 1\n q = i - 1\n\n res = (\n res\n + comb_mod(H - A - 1 + i - 1, H - A - 1)\n * comb_mod(A - 1 + W - i, W - i)\n ) % MOD",
"i",
"range(B + 1, W + 1)",
"range",
"B + 1",
"B",
"1",
"W + 1",
"W",
"1",
"p = H - A - 1",
"p",
"H - A - 1",
"H - A",
"H",
"A",
"1",
"q = i - 1",
"q",
"i - 1",
"i",
"1",
"res = (\n res\n + comb_mod(H - A - 1 + i - 1, H - A - 1)\n * comb_mod(A - 1 + W - i, W - i)\n ) % MOD",
"res",
"(\n res\n + comb_mod(H - A - 1 + i - 1, H - A - 1)\n * comb_mod(A - 1 + W - i, W - i)\n ) % MOD",
"res\n + comb_mod(H - A - 1 + i - 1, H - A - 1)\n * comb_mod(A - 1 + W - i, W - i)",
"res",
"comb_mod(H - A - 1 + i - 1, H - A - 1)\n * comb_mod(A - 1 + W - i, W - i)",
"comb_mod(H - A - 1 + i - 1, H - A - 1)",
"comb_mod",
"H - A - 1 + i - 1",
"H - A - 1 + i",
"H - A - 1",
"H - A",
"H",
"A",
"1",
"i",
"1",
"H - A - 1",
"H - A",
"H",
"A",
"1",
"comb_mod(A - 1 + W - i, W - i)",
"comb_mod",
"A - 1 + W - i",
"A - 1 + W",
"A - 1",
"A",
"1",
"W",
"i",
"W - i",
"W",
"i",
"MOD",
"print(res)",
"print",
"res",
"def pow_mod(x, p):\n res = 1\n while p:\n if p % 2:\n res = res * x % MOD\n x = x * x % MOD\n p //= 2\n return res",
"def pow_mod(x, p):\n res = 1\n while p:\n if p % 2:\n res = res * x % MOD\n x = x * x % MOD\n p //= 2\n return res",
"pow_mod",
"W, A, B = map(int, input().split())",
"map(int, input().split())",
"W",
"invF = invF[::-1]",
"invF[::-1]",
"invF",
"q = i - 1",
"i - 1",
"q",
"invF = []",
"[]",
"invF",
"def comb_mod(n, r):\n return F[n] * invF[r] * invF[n - r] % MOD",
"def comb_mod(n, r):\n return F[n] * invF[r] * invF[n - r] % MOD",
"comb_mod",
"B = map(int, input().split())",
"map(int, input().split())",
"B",
"MOD = 10 ** 9 + 7",
"10 ** 9 + 7",
"MOD",
"res = (\n res\n + comb_mod(H - A - 1 + i - 1, H - A - 1)\n * comb_mod(A - 1 + W - i, W - i)\n ) % MOD",
"(\n res\n + comb_mod(H - A - 1 + i - 1, H - A - 1)\n * comb_mod(A - 1 + W - i, W - i)\n ) % MOD",
"res",
"res = 0",
"0",
"res",
"p = H - A - 1",
"H - A - 1",
"p",
"A, B = map(int, input().split())",
"map(int, input().split())",
"A",
"H, W, A, B = map(int, input().split())",
"map(int, input().split())",
"H",
"F = [1]",
"[1]",
"F"
] | H, W, A, B = map(int, input().split())
MOD = 10 ** 9 + 7
def pow_mod(x, p):
res = 1
while p:
if p % 2:
res = res * x % MOD
x = x * x % MOD
p //= 2
return res
F = [1]
invF = []
def comb_mod(n, r):
return F[n] * invF[r] * invF[n - r] % MOD
for i in range(1, H + W - 1):
F.append(F[-1] * i % MOD)
invF.append(pow_mod(F[-1], (MOD - 2)))
for f in range(len(F) - 1):
invF.append(invF[-1] * (len(F) - len(invF)) % MOD)
invF = invF[::-1]
res = 0
for i in range(B + 1, W + 1):
p = H - A - 1
q = i - 1
res = (
res
+ comb_mod(H - A - 1 + i - 1, H - A - 1)
* comb_mod(A - 1 + W - i, W - i)
) % MOD
print(res)
|
[
7,
12,
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,
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,
4,
13,
2,
2,
13,
13,
17,
2,
4,
13,
13,
13,
17,
13,
0,
13,
17,
28,
13,
4,
13,
13,
0,
13,
4,
13,
2,
2,
2,
13,
13,
17,
13,
13,
13,
0,
13,
4,
13,
2,
2,
2,
2,
13,
17,
13,
13,
17,
2,
13,
17,
13,
0,
13,
13,
0,
13,
13,
4,
13,
2,
2,
13,
13,
13,
4,
13,
10,
12,
13
] | [
[
42,
8
],
[
42,
11
],
[
40,
12
],
[
17,
16
],
[
42,
19
],
[
40,
21
],
[
42,
22
],
[
40,
29
],
[
16,
32
],
[
42,
32
],
[
40,
36
],
[
16,
37
],
[
42,
37
],
[
44,
38
],
[
40,
40
],
[
42,
42
],
[
44,
44
],
[
47,
46
],
[
54,
53
],
[
59,
58
],
[
64,
63
],
[
69,
68
],
[
74,
73
],
[
53,
78
],
[
58,
82
],
[
58,
87
],
[
73,
89
],
[
46,
90
],
[
68,
93
],
[
68,
99
],
[
46,
101
],
[
73,
102
],
[
46,
104
],
[
73,
105
],
[
46,
106
],
[
63,
109
],
[
63,
114
],
[
68,
117
],
[
46,
119
],
[
122,
121
],
[
122,
130
],
[
122,
131
],
[
122,
132
],
[
135,
134
],
[
4,
136
],
[
121,
139
],
[
130,
140
],
[
121,
145
],
[
130,
146
],
[
46,
148
],
[
151,
150
],
[
154,
153
],
[
132,
156
],
[
159,
158
],
[
4,
160
],
[
121,
164
],
[
131,
165
],
[
153,
167
],
[
153,
168
],
[
46,
169
],
[
172,
171
],
[
4,
173
],
[
130,
178
],
[
153,
180
],
[
131,
181
],
[
131,
184
],
[
46,
186
],
[
189,
188
],
[
171,
189
],
[
158,
189
],
[
192,
191
],
[
46,
192
],
[
134,
197
],
[
191,
198
],
[
188,
198
],
[
150,
198
],
[
46,
199
],
[
204,
201
]
] | [
"def main():\n 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\n mod = 10**9+7 # 出力の制限\n N = 10**6\n g1 = [1, 1] # 元テーブル\n g2 = [1, 1] # 逆元テーブル\n inverse = [0, 1] # 逆元テーブル計算用テーブル\n\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\n H, W, A, B = map(int, input().split())\n\n ans = cmb((H+W-2), min(H, W)-1, mod)\n\n tmp = 0\n for i in range(B):\n t = cmb(H-A-1+i, i, mod)\n t *= cmb(W-1-i + A - 1, A-1, mod)\n tmp += t\n tmp %= mod\n print((ans - tmp) % mod)\n\n\nmain()",
"def main():\n 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\n mod = 10**9+7 # 出力の制限\n N = 10**6\n g1 = [1, 1] # 元テーブル\n g2 = [1, 1] # 逆元テーブル\n inverse = [0, 1] # 逆元テーブル計算用テーブル\n\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\n H, W, A, B = map(int, input().split())\n\n ans = cmb((H+W-2), min(H, W)-1, mod)\n\n tmp = 0\n for i in range(B):\n t = cmb(H-A-1+i, i, mod)\n t *= cmb(W-1-i + A - 1, A-1, mod)\n tmp += t\n tmp %= mod\n print((ans - tmp) % mod)",
"main",
"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\n ",
"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",
"N",
"10**6",
"10",
"6",
"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\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",
"H, W, A, B = map(int, input().split())",
"H",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"W",
"A",
"B",
"ans = cmb((H+W-2), min(H, W)-1, mod)",
"ans",
"cmb((H+W-2), min(H, W)-1, mod)",
"cmb",
"H+W-2",
"H+W",
"H",
"W",
"2",
"min(H, W)-1",
"min(H, W)",
"min",
"H",
"W",
"1",
"mod",
"tmp = 0",
"tmp",
"0",
"for i in range(B):\n t = cmb(H-A-1+i, i, mod)\n t *= cmb(W-1-i + A - 1, A-1, mod)\n tmp += t\n tmp %= mod\n ",
"i",
"range(B)",
"range",
"B",
"t = cmb(H-A-1+i, i, mod)",
"t",
"cmb(H-A-1+i, i, mod)",
"cmb",
"H-A-1+i",
"H-A-1",
"H-A",
"H",
"A",
"1",
"i",
"i",
"mod",
"t *= cmb(W-1-i + A - 1, A-1, mod)",
"t",
"cmb(W-1-i + A - 1, A-1, mod)",
"cmb",
"W-1-i + A - 1",
"W-1-i + A",
"W-1-i",
"W-1",
"W",
"1",
"i",
"A",
"1",
"A-1",
"A",
"1",
"mod",
"tmp += t",
"tmp",
"t",
"tmp %= mod",
"tmp",
"mod",
"print((ans - tmp) % mod)",
"print",
"(ans - tmp) % mod",
"ans - tmp",
"ans",
"tmp",
"mod",
"main()",
"main",
"def main():\n 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\n mod = 10**9+7 # 出力の制限\n N = 10**6\n g1 = [1, 1] # 元テーブル\n g2 = [1, 1] # 逆元テーブル\n inverse = [0, 1] # 逆元テーブル計算用テーブル\n\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\n H, W, A, B = map(int, input().split())\n\n ans = cmb((H+W-2), min(H, W)-1, mod)\n\n tmp = 0\n for i in range(B):\n t = cmb(H-A-1+i, i, mod)\n t *= cmb(W-1-i + A - 1, A-1, mod)\n tmp += t\n tmp %= mod\n print((ans - tmp) % mod)",
"def main():\n 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\n mod = 10**9+7 # 出力の制限\n N = 10**6\n g1 = [1, 1] # 元テーブル\n g2 = [1, 1] # 逆元テーブル\n inverse = [0, 1] # 逆元テーブル計算用テーブル\n\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\n H, W, A, B = map(int, input().split())\n\n ans = cmb((H+W-2), min(H, W)-1, mod)\n\n tmp = 0\n for i in range(B):\n t = cmb(H-A-1+i, i, mod)\n t *= cmb(W-1-i + A - 1, A-1, mod)\n tmp += t\n tmp %= mod\n print((ans - tmp) % mod)",
"main"
] | def main():
def cmb(n, r, mod):
if (r < 0 or r > n):
return 0
r = min(r, n-r)
return g1[n] * g2[r] * g2[n-r] % mod
mod = 10**9+7 # 出力の制限
N = 10**6
g1 = [1, 1] # 元テーブル
g2 = [1, 1] # 逆元テーブル
inverse = [0, 1] # 逆元テーブル計算用テーブル
for i in range(2, N + 1):
g1.append((g1[-1] * i) % mod)
inverse.append((-inverse[mod % i] * (mod//i)) % mod)
g2.append((g2[-1] * inverse[-1]) % mod)
H, W, A, B = map(int, input().split())
ans = cmb((H+W-2), min(H, W)-1, mod)
tmp = 0
for i in range(B):
t = cmb(H-A-1+i, i, mod)
t *= cmb(W-1-i + A - 1, A-1, mod)
tmp += t
tmp %= mod
print((ans - tmp) % mod)
main()
|
Subsets and Splits
No saved queries yet
Save your SQL queries to embed, download, and access them later. Queries will appear here once saved.