node_ids
sequencelengths 4
1.4k
| edge_index
sequencelengths 1
2.22k
| text
sequencelengths 4
1.4k
| source
stringlengths 14
427k
|
|---|---|---|---|
[
7,
6,
13,
12,
13,
0,
18,
13,
13,
13,
0,
18,
13,
13,
39,
17,
17,
0,
18,
13,
13,
39,
17,
17,
0,
13,
39,
17,
17,
28,
13,
4,
13,
17,
2,
2,
17,
17,
17,
4,
18,
18,
13,
13,
13,
2,
2,
18,
18,
13,
13,
17,
13,
13,
4,
18,
13,
13,
2,
2,
40,
18,
13,
2,
13,
13,
2,
13,
13,
13,
4,
18,
18,
13,
13,
13,
2,
2,
18,
18,
13,
13,
17,
18,
13,
17,
13,
23,
13,
23,
13,
12,
13,
14,
2,
13,
2,
17,
17,
29,
4,
18,
13,
13,
13,
13,
29,
4,
18,
13,
13,
13,
13,
23,
13,
23,
13,
23,
13,
12,
13,
14,
2,
2,
13,
17,
2,
13,
13,
29,
17,
0,
13,
4,
13,
13,
2,
13,
13,
29,
2,
2,
2,
18,
18,
13,
13,
13,
18,
18,
13,
13,
13,
18,
18,
13,
13,
2,
13,
13,
18,
13,
13,
23,
13,
23,
13,
23,
13,
12,
13,
0,
13,
17,
0,
13,
4,
13,
13,
2,
13,
13,
28,
13,
4,
13,
2,
2,
13,
13,
17,
2,
13,
17,
0,
13,
2,
2,
13,
13,
18,
13,
13,
29,
2,
2,
13,
18,
18,
13,
13,
13,
18,
13,
13,
23,
13,
23,
13,
23,
13,
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,
13,
0,
13,
4,
18,
13,
13,
2,
2,
13,
13,
17,
2,
13,
17,
28,
13,
4,
13,
17,
2,
13,
17,
0,
13,
2,
4,
18,
13,
13,
2,
2,
2,
13,
13,
13,
17,
2,
13,
17,
4,
18,
13,
13,
2,
2,
2,
13,
17,
13,
13,
2,
13,
17,
29,
2,
13,
13,
4,
13,
4,
13,
10,
6,
13,
10,
12,
13
] | [
[
9,
6
],
[
88,
7
],
[
90,
8
],
[
90,
9
],
[
14,
11
],
[
88,
12
],
[
21,
18
],
[
88,
19
],
[
26,
25
],
[
31,
30
],
[
11,
41
],
[
88,
42
],
[
11,
48
],
[
88,
49
],
[
30,
52
],
[
90,
53
],
[
25,
56
],
[
25,
62
],
[
90,
64
],
[
30,
65
],
[
90,
67
],
[
30,
68
],
[
90,
69
],
[
18,
72
],
[
88,
73
],
[
18,
79
],
[
88,
80
],
[
25,
84
],
[
90,
86
],
[
88,
88
],
[
90,
90
],
[
116,
95
],
[
114,
102
],
[
116,
104
],
[
118,
105
],
[
114,
109
],
[
116,
111
],
[
118,
112
],
[
114,
114
],
[
116,
116
],
[
118,
118
],
[
168,
124
],
[
168,
127
],
[
166,
128
],
[
133,
132
],
[
168,
135
],
[
166,
137
],
[
168,
138
],
[
164,
145
],
[
166,
147
],
[
164,
150
],
[
132,
152
],
[
168,
152
],
[
164,
155
],
[
166,
158
],
[
132,
159
],
[
168,
159
],
[
164,
161
],
[
164,
164
],
[
166,
166
],
[
168,
168
],
[
173,
172
],
[
176,
175
],
[
220,
178
],
[
218,
180
],
[
220,
181
],
[
184,
183
],
[
218,
188
],
[
175,
189
],
[
220,
189
],
[
218,
192
],
[
196,
195
],
[
172,
198
],
[
195,
198
],
[
183,
199
],
[
216,
201
],
[
195,
206
],
[
172,
206
],
[
216,
209
],
[
175,
211
],
[
220,
211
],
[
216,
213
],
[
216,
216
],
[
218,
218
],
[
220,
220
],
[
226,
225
],
[
226,
234
],
[
226,
235
],
[
226,
236
],
[
239,
238
],
[
246,
245
],
[
238,
248
],
[
251,
250
],
[
245,
253
],
[
92,
254
],
[
225,
257
],
[
234,
258
],
[
225,
261
],
[
265,
264
],
[
236,
269
],
[
273,
272
],
[
245,
276
],
[
92,
277
],
[
225,
281
],
[
235,
282
],
[
264,
283
],
[
264,
286
],
[
245,
290
],
[
92,
291
],
[
235,
295
],
[
234,
297
],
[
264,
298
],
[
235,
300
],
[
272,
304
],
[
250,
304
],
[
238,
305
],
[
315,
309
]
] | [
"class cmbs(object):\n def __init__(self, mod):\n self.mod = mod\n self.g1 = [1, 1]\n self.g2 = [1, 1]\n inverse = [0, 1]\n for i in range(2, 10 ** 6 + 1):\n self.g1.append((self.g1[-1] * i) % mod)\n inverse.append((-inverse[mod % i] * (mod // i)) % mod)\n self.g2.append((self.g2[-1] * inverse[-1]) % mod)\n\n def cmb(self, n, r):\n if n > 10 ** 6:\n return self.cmbl(n, r)\n return self.cmbr(n, r)\n\n def cmbr(self, n, r):\n if r < 0 or r > n:\n return 0\n r = min(r, n - r)\n return self.g1[n] * self.g2[r] * self.g2[n-r] % self.mod\n\n def cmbl(self, n, r):\n t = 1\n r = min(r, n-r)\n for i in range(n - r + 1, n + 1):\n t = t * i % self.mod\n return t * self.g2[r] % self.mod\ndef main():\n H, W, A, B = map(int, input().split())\n mod = 10**9 + 7\n c = cmbs(mod)\n r = c.cmb(H+W-2, H-1)\n for i in range(1, B+1):\n r -= c.cmb(H-A+i-2, i-1) * c.cmb(A-1+W-i, A-1)\n return r % mod\nprint(main())",
"class cmbs(object):\n def __init__(self, mod):\n self.mod = mod\n self.g1 = [1, 1]\n self.g2 = [1, 1]\n inverse = [0, 1]\n for i in range(2, 10 ** 6 + 1):\n self.g1.append((self.g1[-1] * i) % mod)\n inverse.append((-inverse[mod % i] * (mod // i)) % mod)\n self.g2.append((self.g2[-1] * inverse[-1]) % mod)\n\n def cmb(self, n, r):\n if n > 10 ** 6:\n return self.cmbl(n, r)\n return self.cmbr(n, r)\n\n def cmbr(self, n, r):\n if r < 0 or r > n:\n return 0\n r = min(r, n - r)\n return self.g1[n] * self.g2[r] * self.g2[n-r] % self.mod\n\n def cmbl(self, n, r):\n t = 1\n r = min(r, n-r)\n for i in range(n - r + 1, n + 1):\n t = t * i % self.mod\n return t * self.g2[r] % self.mod",
"cmbs",
"def __init__(self, mod):\n self.mod = mod\n self.g1 = [1, 1]\n self.g2 = [1, 1]\n inverse = [0, 1]\n for i in range(2, 10 ** 6 + 1):\n self.g1.append((self.g1[-1] * i) % mod)\n inverse.append((-inverse[mod % i] * (mod // i)) % mod)\n self.g2.append((self.g2[-1] * inverse[-1]) % mod)\n\n ",
"__init__",
"self.mod = mod",
"self.mod",
"self",
"mod",
"mod",
"self.g1 = [1, 1]",
"self.g1",
"self",
"g1",
"[1, 1]",
"1",
"1",
"self.g2 = [1, 1]",
"self.g2",
"self",
"g2",
"[1, 1]",
"1",
"1",
"inverse = [0, 1]",
"inverse",
"[0, 1]",
"0",
"1",
"for i in range(2, 10 ** 6 + 1):\n self.g1.append((self.g1[-1] * i) % mod)\n inverse.append((-inverse[mod % i] * (mod // i)) % mod)\n self.g2.append((self.g2[-1] * inverse[-1]) % mod)\n\n ",
"i",
"range(2, 10 ** 6 + 1)",
"range",
"2",
"10 ** 6 + 1",
"10 ** 6",
"10",
"6",
"1",
"self.g1.append((self.g1[-1] * i) % mod)",
"self.g1.append",
"self.g1",
"self",
"g1",
"append",
"(self.g1[-1] * i) % mod",
"self.g1[-1] * i",
"self.g1[-1]",
"self.g1",
"self",
"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",
"self.g2.append((self.g2[-1] * inverse[-1]) % mod)",
"self.g2.append",
"self.g2",
"self",
"g2",
"append",
"(self.g2[-1] * inverse[-1]) % mod",
"self.g2[-1] * inverse[-1]",
"self.g2[-1]",
"self.g2",
"self",
"g2",
"-1",
"inverse[-1]",
"inverse",
"-1",
"mod",
"self",
"self",
"mod",
"mod",
"def cmb(self, n, r):\n if n > 10 ** 6:\n return self.cmbl(n, r)\n return self.cmbr(n, r)\n\n ",
"cmb",
"if n > 10 ** 6:\n return self.cmbl(n, r)\n ",
"n > 10 ** 6",
"n",
"10 ** 6",
"10",
"6",
"return self.cmbl(n, r)",
"self.cmbl(n, r)",
"self.cmbl",
"self",
"cmbl",
"n",
"r",
"return self.cmbr(n, r)",
"self.cmbr(n, r)",
"self.cmbr",
"self",
"cmbr",
"n",
"r",
"self",
"self",
"n",
"n",
"r",
"r",
"def cmbr(self, n, r):\n if r < 0 or r > n:\n return 0\n r = min(r, n - r)\n return self.g1[n] * self.g2[r] * self.g2[n-r] % self.mod\n\n ",
"cmbr",
"if r < 0 or r > n:\n return 0\n ",
"r < 0 or r > n",
"r < 0",
"r",
"0",
"r > n",
"r",
"n",
"return 0",
"0",
"r = min(r, n - r)",
"r",
"min(r, n - r)",
"min",
"r",
"n - r",
"n",
"r",
"return self.g1[n] * self.g2[r] * self.g2[n-r] % self.mod",
"self.g1[n] * self.g2[r] * self.g2[n-r] % self.mod",
"self.g1[n] * self.g2[r] * self.g2[n-r]",
"self.g1[n] * self.g2[r]",
"self.g1[n]",
"self.g1",
"self",
"g1",
"n",
"self.g2[r]",
"self.g2",
"self",
"g2",
"r",
"self.g2[n-r]",
"self.g2",
"self",
"g2",
"n-r",
"n",
"r",
"self.mod",
"self",
"mod",
"self",
"self",
"n",
"n",
"r",
"r",
"def cmbl(self, n, r):\n t = 1\n r = min(r, n-r)\n for i in range(n - r + 1, n + 1):\n t = t * i % self.mod\n return t * self.g2[r] % self.mod",
"cmbl",
"t = 1",
"t",
"1",
"r = min(r, n-r)",
"r",
"min(r, n-r)",
"min",
"r",
"n-r",
"n",
"r",
"for i in range(n - r + 1, n + 1):\n t = t * i % self.mod\n ",
"i",
"range(n - r + 1, n + 1)",
"range",
"n - r + 1",
"n - r",
"n",
"r",
"1",
"n + 1",
"n",
"1",
"t = t * i % self.mod",
"t",
"t * i % self.mod",
"t * i",
"t",
"i",
"self.mod",
"self",
"mod",
"return t * self.g2[r] % self.mod",
"t * self.g2[r] % self.mod",
"t * self.g2[r]",
"t",
"self.g2[r]",
"self.g2",
"self",
"g2",
"r",
"self.mod",
"self",
"mod",
"self",
"self",
"n",
"n",
"r",
"r",
"object",
"def main():\n H, W, A, B = map(int, input().split())\n mod = 10**9 + 7\n c = cmbs(mod)\n r = c.cmb(H+W-2, H-1)\n for i in range(1, B+1):\n r -= c.cmb(H-A+i-2, i-1) * c.cmb(A-1+W-i, A-1)\n return r % 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",
"c = cmbs(mod)",
"c",
"cmbs(mod)",
"cmbs",
"mod",
"r = c.cmb(H+W-2, H-1)",
"r",
"c.cmb(H+W-2, H-1)",
"c.cmb",
"c",
"cmb",
"H+W-2",
"H+W",
"H",
"W",
"2",
"H-1",
"H",
"1",
"for i in range(1, B+1):\n r -= c.cmb(H-A+i-2, i-1) * c.cmb(A-1+W-i, A-1)\n ",
"i",
"range(1, B+1)",
"range",
"1",
"B+1",
"B",
"1",
"r -= c.cmb(H-A+i-2, i-1) * c.cmb(A-1+W-i, A-1)",
"r",
"c.cmb(H-A+i-2, i-1) * c.cmb(A-1+W-i, A-1)",
"c.cmb(H-A+i-2, i-1)",
"c.cmb",
"c",
"cmb",
"H-A+i-2",
"H-A+i",
"H-A",
"H",
"A",
"i",
"2",
"i-1",
"i",
"1",
"c.cmb(A-1+W-i, A-1)",
"c.cmb",
"c",
"cmb",
"A-1+W-i",
"A-1+W",
"A-1",
"A",
"1",
"W",
"i",
"A-1",
"A",
"1",
"return r % mod",
"r % mod",
"r",
"mod",
"print(main())",
"print",
"main()",
"main",
"class cmbs(object):\n def __init__(self, mod):\n self.mod = mod\n self.g1 = [1, 1]\n self.g2 = [1, 1]\n inverse = [0, 1]\n for i in range(2, 10 ** 6 + 1):\n self.g1.append((self.g1[-1] * i) % mod)\n inverse.append((-inverse[mod % i] * (mod // i)) % mod)\n self.g2.append((self.g2[-1] * inverse[-1]) % mod)\n\n def cmb(self, n, r):\n if n > 10 ** 6:\n return self.cmbl(n, r)\n return self.cmbr(n, r)\n\n def cmbr(self, n, r):\n if r < 0 or r > n:\n return 0\n r = min(r, n - r)\n return self.g1[n] * self.g2[r] * self.g2[n-r] % self.mod\n\n def cmbl(self, n, r):\n t = 1\n r = min(r, n-r)\n for i in range(n - r + 1, n + 1):\n t = t * i % self.mod\n return t * self.g2[r] % self.mod",
"class cmbs(object):\n def __init__(self, mod):\n self.mod = mod\n self.g1 = [1, 1]\n self.g2 = [1, 1]\n inverse = [0, 1]\n for i in range(2, 10 ** 6 + 1):\n self.g1.append((self.g1[-1] * i) % mod)\n inverse.append((-inverse[mod % i] * (mod // i)) % mod)\n self.g2.append((self.g2[-1] * inverse[-1]) % mod)\n\n def cmb(self, n, r):\n if n > 10 ** 6:\n return self.cmbl(n, r)\n return self.cmbr(n, r)\n\n def cmbr(self, n, r):\n if r < 0 or r > n:\n return 0\n r = min(r, n - r)\n return self.g1[n] * self.g2[r] * self.g2[n-r] % self.mod\n\n def cmbl(self, n, r):\n t = 1\n r = min(r, n-r)\n for i in range(n - r + 1, n + 1):\n t = t * i % self.mod\n return t * self.g2[r] % self.mod",
"cmbs",
"def main():\n H, W, A, B = map(int, input().split())\n mod = 10**9 + 7\n c = cmbs(mod)\n r = c.cmb(H+W-2, H-1)\n for i in range(1, B+1):\n r -= c.cmb(H-A+i-2, i-1) * c.cmb(A-1+W-i, A-1)\n return r % mod",
"def main():\n H, W, A, B = map(int, input().split())\n mod = 10**9 + 7\n c = cmbs(mod)\n r = c.cmb(H+W-2, H-1)\n for i in range(1, B+1):\n r -= c.cmb(H-A+i-2, i-1) * c.cmb(A-1+W-i, A-1)\n return r % mod",
"main"
] | class cmbs(object):
def __init__(self, mod):
self.mod = mod
self.g1 = [1, 1]
self.g2 = [1, 1]
inverse = [0, 1]
for i in range(2, 10 ** 6 + 1):
self.g1.append((self.g1[-1] * i) % mod)
inverse.append((-inverse[mod % i] * (mod // i)) % mod)
self.g2.append((self.g2[-1] * inverse[-1]) % mod)
def cmb(self, n, r):
if n > 10 ** 6:
return self.cmbl(n, r)
return self.cmbr(n, r)
def cmbr(self, n, r):
if r < 0 or r > n:
return 0
r = min(r, n - r)
return self.g1[n] * self.g2[r] * self.g2[n-r] % self.mod
def cmbl(self, n, r):
t = 1
r = min(r, n-r)
for i in range(n - r + 1, n + 1):
t = t * i % self.mod
return t * self.g2[r] % self.mod
def main():
H, W, A, B = map(int, input().split())
mod = 10**9 + 7
c = cmbs(mod)
r = c.cmb(H+W-2, H-1)
for i in range(1, B+1):
r -= c.cmb(H-A+i-2, i-1) * c.cmb(A-1+W-i, A-1)
return r % mod
print(main())
|
[
7,
12,
13,
0,
13,
4,
13,
13,
4,
18,
4,
13,
13,
13,
13,
13,
29,
39,
13,
13,
13,
13,
12,
13,
0,
13,
21,
22,
17,
17,
0,
13,
17,
0,
13,
17,
0,
13,
2,
2,
17,
17,
17,
42,
40,
13,
13,
0,
13,
13,
0,
13,
13,
0,
18,
13,
13,
13,
0,
13,
17,
29,
13,
23,
13,
12,
13,
29,
4,
13,
13,
2,
2,
17,
17,
17,
23,
13,
12,
13,
0,
13,
17,
0,
13,
13,
0,
13,
2,
2,
17,
17,
17,
42,
13,
14,
2,
17,
13,
0,
13,
13,
0,
13,
13,
0,
13,
2,
13,
17,
0,
13,
13,
0,
13,
13,
29,
13,
23,
13,
23,
13,
12,
13,
29,
2,
2,
18,
13,
13,
4,
13,
18,
13,
13,
4,
13,
18,
13,
2,
13,
13,
23,
13,
23,
13,
23,
13,
12,
13,
0,
13,
2,
18,
13,
17,
18,
13,
17,
0,
13,
2,
18,
13,
17,
18,
13,
17,
29,
2,
4,
13,
2,
13,
13,
13,
13,
13,
23,
13,
23,
13,
23,
13,
23,
13,
12,
13,
0,
13,
4,
13,
13,
13,
13,
0,
13,
4,
13,
2,
2,
13,
13,
17,
0,
13,
17,
0,
13,
2,
2,
17,
17,
17,
28,
13,
4,
13,
2,
13,
13,
0,
13,
2,
4,
13,
39,
17,
17,
39,
13,
2,
13,
17,
13,
13,
4,
13,
39,
13,
13,
39,
2,
13,
17,
2,
13,
17,
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
] | [
[
5,
4
],
[
5,
13
],
[
5,
14
],
[
5,
15
],
[
26,
25
],
[
32,
31
],
[
35,
34
],
[
38,
37
],
[
31,
45
],
[
59,
45
],
[
64,
46
],
[
49,
48
],
[
31,
49
],
[
59,
49
],
[
52,
51
],
[
37,
52
],
[
57,
54
],
[
25,
55
],
[
31,
56
],
[
59,
56
],
[
51,
57
],
[
48,
57
],
[
34,
57
],
[
60,
59
],
[
25,
62
],
[
64,
64
],
[
77,
70
],
[
77,
77
],
[
82,
81
],
[
85,
84
],
[
119,
85
],
[
88,
87
],
[
121,
98
],
[
106,
98
],
[
101,
100
],
[
84,
101
],
[
114,
101
],
[
111,
101
],
[
104,
103
],
[
87,
104
],
[
107,
106
],
[
121,
108
],
[
106,
108
],
[
112,
111
],
[
111,
112
],
[
84,
112
],
[
114,
112
],
[
115,
114
],
[
87,
115
],
[
103,
117
],
[
100,
117
],
[
81,
117
],
[
119,
119
],
[
121,
121
],
[
147,
128
],
[
143,
129
],
[
264,
131
],
[
147,
133
],
[
145,
134
],
[
264,
136
],
[
147,
138
],
[
143,
140
],
[
145,
141
],
[
143,
143
],
[
145,
145
],
[
147,
147
],
[
152,
151
],
[
181,
154
],
[
179,
157
],
[
161,
160
],
[
181,
163
],
[
179,
166
],
[
273,
171
],
[
151,
173
],
[
160,
174
],
[
151,
175
],
[
183,
176
],
[
185,
177
],
[
179,
179
],
[
181,
181
],
[
183,
183
],
[
185,
185
],
[
190,
189
],
[
270,
191
],
[
190,
192
],
[
190,
193
],
[
190,
194
],
[
197,
196
],
[
276,
198
],
[
189,
201
],
[
192,
202
],
[
206,
205
],
[
209,
208
],
[
216,
215
],
[
189,
219
],
[
193,
220
],
[
223,
222
],
[
282,
225
],
[
194,
232
],
[
196,
234
],
[
208,
235
],
[
282,
237
],
[
189,
243
],
[
192,
246
],
[
196,
248
],
[
208,
249
],
[
252,
251
],
[
208,
252
],
[
251,
255
],
[
222,
255
],
[
205,
255
],
[
267,
261
]
] | [
"\ndef read_input():\n h, w, a, b = map(int, input().split())\n return h, w, a, b\n\n\n# xの階乗 mod 10**9 + 7 について、1~nまでの結果を辞書にして返す\ndef factorial_table(n):\n result = {0:1}\n\n curr = 1\n acc = 1\n modmax = (10**9) + 7\n while curr <= n:\n acc *= curr\n acc %= modmax\n result[curr] = acc\n curr += 1\n\n return result\n\n\n# xの逆元 mod 10**9 + 7を求める\ndef reverse_mod(x):\n return power_n(x, 10**9 + 5)\n\n\n# xのn乗 mod 10**9 + 7を求める\ndef power_n(x, n):\n r = 1\n curr_a = x\n modmax = (10 ** 9) + 7\n while n:\n if 1 & n:\n r *= curr_a\n r %= modmax\n\n n = n >> 1\n curr_a *= curr_a\n curr_a %= modmax\n\n return r\n\n\ndef comb(x, y, factorial_dic):\n return factorial_dic[x] * reverse_mod(factorial_dic[y]) * reverse_mod(factorial_dic[x - y])\n\n\ndef path(s, e, factorial_dic, modmax):\n x = e[0] - s[0]\n y = e[1] - s[1]\n\n return comb(x + y, x, factorial_dic) % modmax\n\n\ndef submit():\n h, w, a, b = read_input()\n f_dic = factorial_table(h + w - 2)\n count = 0\n modmax = 10**9 + 7\n for i in range(h - a):\n count += path((0, 0), (i, b - 1), f_dic, modmax) * path((i, b), (h - 1, w - 1), f_dic, modmax)\n count %= modmax\n\n print(count)\n\nif __name__ == '__main__':\n submit()",
"def read_input():\n h, w, a, b = map(int, input().split())\n return h, w, a, b\n\n\n# xの階乗 mod 10**9 + 7 について、1~nまでの結果を辞書にして返す",
"read_input",
"h, w, a, b = map(int, input().split())",
"h",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"w",
"a",
"b",
"return h, w, a, b",
"return h, w, a, b",
"h",
"w",
"a",
"b",
"def factorial_table(n):\n result = {0:1}\n\n curr = 1\n acc = 1\n modmax = (10**9) + 7\n while curr <= n:\n acc *= curr\n acc %= modmax\n result[curr] = acc\n curr += 1\n\n return result\n\n\n# xの逆元 mod 10**9 + 7を求める",
"factorial_table",
"result = {0:1}",
"result",
"{0:1}",
"0",
"0",
"1",
"curr = 1",
"curr",
"1",
"acc = 1",
"acc",
"1",
"modmax = (10**9) + 7",
"modmax",
"(10**9) + 7",
"10**9",
"10",
"9",
"7",
"while curr <= n:\n acc *= curr\n acc %= modmax\n result[curr] = acc\n curr += 1\n\n ",
"curr <= n",
"curr",
"n",
"acc *= curr",
"acc",
"curr",
"acc %= modmax",
"acc",
"modmax",
"result[curr] = acc",
"result[curr]",
"result",
"curr",
"acc",
"curr += 1",
"curr",
"1",
"return result",
"result",
"n",
"n",
"def reverse_mod(x):\n return power_n(x, 10**9 + 5)\n\n\n# xのn乗 mod 10**9 + 7を求める",
"reverse_mod",
"return power_n(x, 10**9 + 5)",
"power_n(x, 10**9 + 5)",
"power_n",
"x",
"10**9 + 5",
"10**9",
"10",
"9",
"5",
"x",
"x",
"def power_n(x, n):\n r = 1\n curr_a = x\n modmax = (10 ** 9) + 7\n while n:\n if 1 & n:\n r *= curr_a\n r %= modmax\n\n n = n >> 1\n curr_a *= curr_a\n curr_a %= modmax\n\n return r",
"power_n",
"r = 1",
"r",
"1",
"curr_a = x",
"curr_a",
"x",
"modmax = (10 ** 9) + 7",
"modmax",
"(10 ** 9) + 7",
"10 ** 9",
"10",
"9",
"7",
"while n:\n if 1 & n:\n r *= curr_a\n r %= modmax\n\n n = n >> 1\n curr_a *= curr_a\n curr_a %= modmax\n\n ",
"n",
"if 1 & n:\n r *= curr_a\n r %= modmax\n\n ",
"1 & n",
"1",
"n",
"r *= curr_a",
"r",
"curr_a",
"r %= modmax",
"r",
"modmax",
"n = n >> 1",
"n",
"n >> 1",
"n",
"1",
"curr_a *= curr_a",
"curr_a",
"curr_a",
"curr_a %= modmax",
"curr_a",
"modmax",
"return r",
"r",
"x",
"x",
"n",
"n",
"def comb(x, y, factorial_dic):\n return factorial_dic[x] * reverse_mod(factorial_dic[y]) * reverse_mod(factorial_dic[x - y])",
"comb",
"return factorial_dic[x] * reverse_mod(factorial_dic[y]) * reverse_mod(factorial_dic[x - y])",
"factorial_dic[x] * reverse_mod(factorial_dic[y]) * reverse_mod(factorial_dic[x - y])",
"factorial_dic[x] * reverse_mod(factorial_dic[y])",
"factorial_dic[x]",
"factorial_dic",
"x",
"reverse_mod(factorial_dic[y])",
"reverse_mod",
"factorial_dic[y]",
"factorial_dic",
"y",
"reverse_mod(factorial_dic[x - y])",
"reverse_mod",
"factorial_dic[x - y]",
"factorial_dic",
"x - y",
"x",
"y",
"x",
"x",
"y",
"y",
"factorial_dic",
"factorial_dic",
"def path(s, e, factorial_dic, modmax):\n x = e[0] - s[0]\n y = e[1] - s[1]\n\n return comb(x + y, x, factorial_dic) % modmax",
"path",
"x = e[0] - s[0]",
"x",
"e[0] - s[0]",
"e[0]",
"e",
"0",
"s[0]",
"s",
"0",
"y = e[1] - s[1]",
"y",
"e[1] - s[1]",
"e[1]",
"e",
"1",
"s[1]",
"s",
"1",
"return comb(x + y, x, factorial_dic) % modmax",
"comb(x + y, x, factorial_dic) % modmax",
"comb(x + y, x, factorial_dic)",
"comb",
"x + y",
"x",
"y",
"x",
"factorial_dic",
"modmax",
"s",
"s",
"e",
"e",
"factorial_dic",
"factorial_dic",
"modmax",
"modmax",
"def submit():\n h, w, a, b = read_input()\n f_dic = factorial_table(h + w - 2)\n count = 0\n modmax = 10**9 + 7\n for i in range(h - a):\n count += path((0, 0), (i, b - 1), f_dic, modmax) * path((i, b), (h - 1, w - 1), f_dic, modmax)\n count %= modmax\n\n print(count)",
"submit",
"h, w, a, b = read_input()",
"h",
"read_input()",
"read_input",
"w",
"a",
"b",
"f_dic = factorial_table(h + w - 2)",
"f_dic",
"factorial_table(h + w - 2)",
"factorial_table",
"h + w - 2",
"h + w",
"h",
"w",
"2",
"count = 0",
"count",
"0",
"modmax = 10**9 + 7",
"modmax",
"10**9 + 7",
"10**9",
"10",
"9",
"7",
"for i in range(h - a):\n count += path((0, 0), (i, b - 1), f_dic, modmax) * path((i, b), (h - 1, w - 1), f_dic, modmax)\n count %= modmax\n\n ",
"i",
"range(h - a)",
"range",
"h - a",
"h",
"a",
"count += path((0, 0), (i, b - 1), f_dic, modmax) * path((i, b), (h - 1, w - 1), f_dic, modmax)",
"count",
"path((0, 0), (i, b - 1), f_dic, modmax) * path((i, b), (h - 1, w - 1), f_dic, modmax)",
"path((0, 0), (i, b - 1), f_dic, modmax)",
"path",
"(0, 0)",
"0",
"0",
"(i, b - 1)",
"i",
"b - 1",
"b",
"1",
"f_dic",
"modmax",
"path((i, b), (h - 1, w - 1), f_dic, modmax)",
"path",
"(i, b)",
"i",
"b",
"(h - 1, w - 1)",
"h - 1",
"h",
"1",
"w - 1",
"w",
"1",
"f_dic",
"modmax",
"count %= modmax",
"count",
"modmax",
"print(count)",
"print",
"count",
"if __name__ == '__main__':\n submit()",
"__name__ == '__main__'",
"__name__",
"'__main__'",
"submit()",
"submit",
"def reverse_mod(x):\n return power_n(x, 10**9 + 5)\n\n\n# xのn乗 mod 10**9 + 7を求める",
"def reverse_mod(x):\n return power_n(x, 10**9 + 5)\n\n\n# xのn乗 mod 10**9 + 7を求める",
"reverse_mod",
"def submit():\n h, w, a, b = read_input()\n f_dic = factorial_table(h + w - 2)\n count = 0\n modmax = 10**9 + 7\n for i in range(h - a):\n count += path((0, 0), (i, b - 1), f_dic, modmax) * path((i, b), (h - 1, w - 1), f_dic, modmax)\n count %= modmax\n\n print(count)",
"def submit():\n h, w, a, b = read_input()\n f_dic = factorial_table(h + w - 2)\n count = 0\n modmax = 10**9 + 7\n for i in range(h - a):\n count += path((0, 0), (i, b - 1), f_dic, modmax) * path((i, b), (h - 1, w - 1), f_dic, modmax)\n count %= modmax\n\n print(count)",
"submit",
"def read_input():\n h, w, a, b = map(int, input().split())\n return h, w, a, b\n\n\n# xの階乗 mod 10**9 + 7 について、1~nまでの結果を辞書にして返す",
"def read_input():\n h, w, a, b = map(int, input().split())\n return h, w, a, b\n\n\n# xの階乗 mod 10**9 + 7 について、1~nまでの結果を辞書にして返す",
"read_input",
"def comb(x, y, factorial_dic):\n return factorial_dic[x] * reverse_mod(factorial_dic[y]) * reverse_mod(factorial_dic[x - y])",
"def comb(x, y, factorial_dic):\n return factorial_dic[x] * reverse_mod(factorial_dic[y]) * reverse_mod(factorial_dic[x - y])",
"comb",
"def factorial_table(n):\n result = {0:1}\n\n curr = 1\n acc = 1\n modmax = (10**9) + 7\n while curr <= n:\n acc *= curr\n acc %= modmax\n result[curr] = acc\n curr += 1\n\n return result\n\n\n# xの逆元 mod 10**9 + 7を求める",
"def factorial_table(n):\n result = {0:1}\n\n curr = 1\n acc = 1\n modmax = (10**9) + 7\n while curr <= n:\n acc *= curr\n acc %= modmax\n result[curr] = acc\n curr += 1\n\n return result\n\n\n# xの逆元 mod 10**9 + 7を求める",
"factorial_table",
"def power_n(x, n):\n r = 1\n curr_a = x\n modmax = (10 ** 9) + 7\n while n:\n if 1 & n:\n r *= curr_a\n r %= modmax\n\n n = n >> 1\n curr_a *= curr_a\n curr_a %= modmax\n\n return r",
"def power_n(x, n):\n r = 1\n curr_a = x\n modmax = (10 ** 9) + 7\n while n:\n if 1 & n:\n r *= curr_a\n r %= modmax\n\n n = n >> 1\n curr_a *= curr_a\n curr_a %= modmax\n\n return r",
"power_n",
"def path(s, e, factorial_dic, modmax):\n x = e[0] - s[0]\n y = e[1] - s[1]\n\n return comb(x + y, x, factorial_dic) % modmax",
"def path(s, e, factorial_dic, modmax):\n x = e[0] - s[0]\n y = e[1] - s[1]\n\n return comb(x + y, x, factorial_dic) % modmax",
"path"
] |
def read_input():
h, w, a, b = map(int, input().split())
return h, w, a, b
# xの階乗 mod 10**9 + 7 について、1~nまでの結果を辞書にして返す
def factorial_table(n):
result = {0:1}
curr = 1
acc = 1
modmax = (10**9) + 7
while curr <= n:
acc *= curr
acc %= modmax
result[curr] = acc
curr += 1
return result
# xの逆元 mod 10**9 + 7を求める
def reverse_mod(x):
return power_n(x, 10**9 + 5)
# xのn乗 mod 10**9 + 7を求める
def power_n(x, n):
r = 1
curr_a = x
modmax = (10 ** 9) + 7
while n:
if 1 & n:
r *= curr_a
r %= modmax
n = n >> 1
curr_a *= curr_a
curr_a %= modmax
return r
def comb(x, y, factorial_dic):
return factorial_dic[x] * reverse_mod(factorial_dic[y]) * reverse_mod(factorial_dic[x - y])
def path(s, e, factorial_dic, modmax):
x = e[0] - s[0]
y = e[1] - s[1]
return comb(x + y, x, factorial_dic) % modmax
def submit():
h, w, a, b = read_input()
f_dic = factorial_table(h + w - 2)
count = 0
modmax = 10**9 + 7
for i in range(h - a):
count += path((0, 0), (i, b - 1), f_dic, modmax) * path((i, b), (h - 1, w - 1), f_dic, modmax)
count %= modmax
print(count)
if __name__ == '__main__':
submit()
|
[
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,
2,
13,
17,
13,
13,
4,
18,
13,
13,
2,
13,
2,
2,
18,
13,
2,
13,
13,
2,
13,
13,
13,
4,
18,
13,
13,
2,
2,
18,
13,
2,
13,
17,
18,
13,
13,
13,
12,
13,
14,
2,
13,
13,
29,
17,
14,
2,
2,
13,
17,
2,
13,
17,
29,
17,
29,
2,
2,
18,
13,
13,
2,
2,
18,
13,
13,
18,
13,
2,
13,
13,
13,
13,
23,
13,
23,
13,
0,
13,
39,
28,
13,
4,
13,
2,
13,
13,
4,
18,
13,
13,
4,
13,
2,
13,
13,
13,
0,
13,
17,
28,
13,
4,
13,
2,
4,
13,
13,
17,
0,
13,
2,
18,
13,
13,
4,
13,
2,
2,
2,
2,
2,
13,
13,
17,
13,
17,
13,
2,
2,
13,
17,
13,
0,
13,
13,
0,
13,
2,
18,
13,
17,
4,
13,
2,
2,
2,
13,
13,
17,
13,
13,
0,
13,
13,
4,
13,
13,
10,
39,
13,
10,
4,
13,
10,
4,
13,
10,
4,
13,
10,
13,
13,
10,
39,
13,
10,
39,
13,
10,
12,
13,
10,
39,
13,
10,
17,
13,
10,
2,
13,
10,
4,
13,
10,
2,
13,
10,
13,
13,
10,
2,
13
] | [
[
246,
2
],
[
246,
11
],
[
246,
12
],
[
246,
13
],
[
249,
15
],
[
231,
22
],
[
228,
27
],
[
213,
32
],
[
38,
37
],
[
247,
43
],
[
223,
44
],
[
232,
48
],
[
232,
53
],
[
37,
55
],
[
37,
57
],
[
250,
58
],
[
229,
61
],
[
250,
64
],
[
229,
68
],
[
250,
70
],
[
37,
71
],
[
250,
73
],
[
37,
74
],
[
250,
75
],
[
214,
78
],
[
214,
83
],
[
37,
85
],
[
229,
88
],
[
37,
89
],
[
250,
90
],
[
128,
95
],
[
130,
96
],
[
128,
102
],
[
130,
105
],
[
232,
113
],
[
128,
114
],
[
214,
118
],
[
130,
119
],
[
214,
121
],
[
128,
123
],
[
130,
124
],
[
250,
125
],
[
250,
126
],
[
128,
128
],
[
130,
130
],
[
237,
132
],
[
136,
135
],
[
223,
139
],
[
217,
140
],
[
238,
143
],
[
235,
146
],
[
220,
148
],
[
135,
149
],
[
135,
150
],
[
240,
152
],
[
156,
155
],
[
238,
161
],
[
243,
164
],
[
238,
167
],
[
155,
168
],
[
235,
170
],
[
247,
176
],
[
220,
177
],
[
223,
179
],
[
155,
181
],
[
223,
184
],
[
155,
186
],
[
252,
188
],
[
250,
189
],
[
255,
191
],
[
238,
194
],
[
235,
197
],
[
247,
201
],
[
220,
202
],
[
217,
204
],
[
217,
205
],
[
225,
207
],
[
250,
208
],
[
226,
211
],
[
256,
211
],
[
253,
211
],
[
244,
211
],
[
241,
211
],
[
213,
214
],
[
246,
217
],
[
246,
220
],
[
246,
223
],
[
250,
225
],
[
225,
226
],
[
228,
229
],
[
231,
232
],
[
237,
238
],
[
240,
241
],
[
243,
244
],
[
246,
247
],
[
249,
250
],
[
250,
252
],
[
252,
253
],
[
255,
256
]
] | [
"h, w, a, b = map(int, input().split())\nm = 10**9 + 7\n\nfac = [1, 1]\ninv = [1, 1]\nfinv = [1, 1]\nfor i in range(2, w+h+5):\n fac.append(fac[i-1] * i % m)\n inv.append(m - inv[m%i] * (m//i) % m)\n finv.append(finv[i-1] * inv[i] % m)\n\ndef nck(n, k):\n if n < k:\n return 0\n if n < 0 or k < 0:\n return 0\n return fac[n] * (finv[k] * finv[n-k] % m) % m\n\n\nrow = []\nfor i in range(h-a):\n row.append(nck(b+i, i))\n\nans = 0\nfor i in range(len(row)-1):\n ans += row[i] * nck(w-b-2 + h-1-i, h-1-i)\n ans %= m\n\nans += row[-1] * nck(w-b-1 + a, a)\nans %= m\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",
"m = 10**9 + 7",
"m",
"10**9 + 7",
"10**9",
"10",
"9",
"7",
"fac = [1, 1]",
"fac",
"[1, 1]",
"1",
"1",
"inv = [1, 1]",
"inv",
"[1, 1]",
"1",
"1",
"finv = [1, 1]",
"finv",
"[1, 1]",
"1",
"1",
"for i in range(2, w+h+5):\n fac.append(fac[i-1] * i % m)\n inv.append(m - inv[m%i] * (m//i) % m)\n finv.append(finv[i-1] * inv[i] % m)",
"i",
"range(2, w+h+5)",
"range",
"2",
"w+h+5",
"w+h",
"w",
"h",
"5",
"fac.append(fac[i-1] * i % m)",
"fac.append",
"fac",
"append",
"fac[i-1] * i % m",
"fac[i-1] * i",
"fac[i-1]",
"fac",
"i-1",
"i",
"1",
"i",
"m",
"inv.append(m - inv[m%i] * (m//i) % m)",
"inv.append",
"inv",
"append",
"m - inv[m%i] * (m//i) % m",
"m",
"inv[m%i] * (m//i) % m",
"inv[m%i] * (m//i)",
"inv[m%i]",
"inv",
"m%i",
"m",
"i",
"m//i",
"m",
"i",
"m",
"finv.append(finv[i-1] * inv[i] % m)",
"finv.append",
"finv",
"append",
"finv[i-1] * inv[i] % m",
"finv[i-1] * inv[i]",
"finv[i-1]",
"finv",
"i-1",
"i",
"1",
"inv[i]",
"inv",
"i",
"m",
"def nck(n, k):\n if n < k:\n return 0\n if n < 0 or k < 0:\n return 0\n return fac[n] * (finv[k] * finv[n-k] % m) % m",
"nck",
"if n < k:\n return 0\n ",
"n < k",
"n",
"k",
"return 0",
"0",
"if n < 0 or k < 0:\n return 0\n ",
"n < 0 or k < 0",
"n < 0",
"n",
"0",
"k < 0",
"k",
"0",
"return 0",
"0",
"return fac[n] * (finv[k] * finv[n-k] % m) % m",
"fac[n] * (finv[k] * finv[n-k] % m) % m",
"fac[n] * (finv[k] * finv[n-k] % m)",
"fac[n]",
"fac",
"n",
"finv[k] * finv[n-k] % m",
"finv[k] * finv[n-k]",
"finv[k]",
"finv",
"k",
"finv[n-k]",
"finv",
"n-k",
"n",
"k",
"m",
"m",
"n",
"n",
"k",
"k",
"row = []",
"row",
"[]",
"for i in range(h-a):\n row.append(nck(b+i, i))",
"i",
"range(h-a)",
"range",
"h-a",
"h",
"a",
"row.append(nck(b+i, i))",
"row.append",
"row",
"append",
"nck(b+i, i)",
"nck",
"b+i",
"b",
"i",
"i",
"ans = 0",
"ans",
"0",
"for i in range(len(row)-1):\n ans += row[i] * nck(w-b-2 + h-1-i, h-1-i)\n ans %= m",
"i",
"range(len(row)-1)",
"range",
"len(row)-1",
"len(row)",
"len",
"row",
"1",
"ans += row[i] * nck(w-b-2 + h-1-i, h-1-i)",
"ans",
"row[i] * nck(w-b-2 + h-1-i, h-1-i)",
"row[i]",
"row",
"i",
"nck(w-b-2 + h-1-i, h-1-i)",
"nck",
"w-b-2 + h-1-i",
"w-b-2 + h-1",
"w-b-2 + h",
"w-b-2",
"w-b",
"w",
"b",
"2",
"h",
"1",
"i",
"h-1-i",
"h-1",
"h",
"1",
"i",
"ans %= m",
"ans",
"m",
"ans += row[-1] * nck(w-b-1 + a, a)",
"ans",
"row[-1] * nck(w-b-1 + a, a)",
"row[-1]",
"row",
"-1",
"nck(w-b-1 + a, a)",
"nck",
"w-b-1 + a",
"w-b-1",
"w-b",
"w",
"b",
"1",
"a",
"a",
"ans %= m",
"ans",
"m",
"print(ans)",
"print",
"ans",
"finv = [1, 1]",
"[1, 1]",
"finv",
"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())",
"map(int, input().split())",
"h",
"ans %= m",
"m",
"ans",
"inv = [1, 1]",
"[1, 1]",
"inv",
"fac = [1, 1]",
"[1, 1]",
"fac",
"def nck(n, k):\n if n < k:\n return 0\n if n < 0 or k < 0:\n return 0\n return fac[n] * (finv[k] * finv[n-k] % m) % m",
"def nck(n, k):\n if n < k:\n return 0\n if n < 0 or k < 0:\n return 0\n return fac[n] * (finv[k] * finv[n-k] % m) % m",
"nck",
"row = []",
"[]",
"row",
"ans = 0",
"0",
"ans",
"ans += row[i] * nck(w-b-2 + h-1-i, h-1-i)",
"row[i] * nck(w-b-2 + h-1-i, h-1-i)",
"ans",
"w, a, b = map(int, input().split())",
"map(int, input().split())",
"w",
"m = 10**9 + 7",
"10**9 + 7",
"m",
"ans %= m",
"m",
"ans",
"ans += row[-1] * nck(w-b-1 + a, a)",
"row[-1] * nck(w-b-1 + a, a)",
"ans"
] | h, w, a, b = map(int, input().split())
m = 10**9 + 7
fac = [1, 1]
inv = [1, 1]
finv = [1, 1]
for i in range(2, w+h+5):
fac.append(fac[i-1] * i % m)
inv.append(m - inv[m%i] * (m//i) % m)
finv.append(finv[i-1] * inv[i] % m)
def nck(n, k):
if n < k:
return 0
if n < 0 or k < 0:
return 0
return fac[n] * (finv[k] * finv[n-k] % m) % m
row = []
for i in range(h-a):
row.append(nck(b+i, i))
ans = 0
for i in range(len(row)-1):
ans += row[i] * nck(w-b-2 + h-1-i, h-1-i)
ans %= m
ans += row[-1] * nck(w-b-1 + a, a)
ans %= m
print(ans)
|
[
7,
15,
13,
0,
13,
2,
2,
17,
17,
17,
12,
13,
0,
13,
2,
39,
17,
2,
13,
17,
0,
18,
13,
17,
17,
0,
13,
4,
18,
13,
13,
28,
13,
4,
13,
17,
2,
13,
17,
0,
18,
13,
13,
2,
2,
18,
13,
2,
13,
17,
13,
13,
0,
18,
13,
13,
4,
13,
18,
13,
13,
2,
13,
17,
13,
28,
13,
4,
13,
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,
2,
17,
17,
23,
13,
2,
2,
17,
17,
17,
0,
13,
4,
13,
13,
12,
13,
14,
2,
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,
23,
13,
2,
2,
17,
17,
17,
0,
13,
4,
13,
13,
4,
18,
4,
18,
18,
13,
13,
13,
13,
13,
13,
13,
12,
13,
0,
13,
4,
13,
2,
2,
13,
13,
17,
2,
13,
17,
0,
13,
17,
0,
13,
2,
13,
17,
28,
13,
4,
13,
2,
13,
13,
13,
0,
13,
2,
2,
4,
13,
2,
13,
13,
13,
4,
13,
2,
2,
2,
2,
2,
13,
17,
13,
13,
17,
13,
2,
2,
13,
17,
13,
13,
0,
13,
13,
0,
13,
2,
2,
13,
13,
13,
29,
13,
14,
2,
13,
17,
0,
13,
4,
13,
4,
13,
13,
10,
12,
13,
10,
4,
13,
10,
4,
13,
10,
2,
13,
10,
12,
13,
10,
12,
13,
10,
4,
13,
10,
4,
13,
10,
4,
13,
10,
4,
13,
10,
4,
13
] | [
[
260,
4
],
[
14,
13
],
[
94,
18
],
[
24,
21
],
[
13,
22
],
[
27,
26
],
[
13,
29
],
[
33,
32
],
[
94,
37
],
[
43,
40
],
[
13,
41
],
[
32,
42
],
[
13,
46
],
[
32,
48
],
[
32,
50
],
[
99,
51
],
[
56,
53
],
[
26,
54
],
[
94,
55
],
[
13,
59
],
[
94,
60
],
[
99,
62
],
[
99,
64
],
[
67,
66
],
[
94,
70
],
[
78,
75
],
[
26,
76
],
[
66,
77
],
[
26,
81
],
[
66,
83
],
[
66,
86
],
[
99,
88
],
[
95,
94
],
[
100,
99
],
[
281,
106
],
[
264,
108
],
[
281,
109
],
[
143,
115
],
[
143,
118
],
[
141,
119
],
[
279,
128
],
[
141,
129
],
[
282,
131
],
[
143,
132
],
[
145,
133
],
[
282,
135
],
[
141,
137
],
[
143,
138
],
[
145,
139
],
[
141,
141
],
[
143,
143
],
[
146,
145
],
[
275,
152
],
[
275,
165
],
[
275,
166
],
[
275,
167
],
[
172,
171
],
[
267,
173
],
[
273,
176
],
[
255,
177
],
[
273,
180
],
[
184,
183
],
[
187,
186
],
[
276,
188
],
[
192,
191
],
[
273,
195
],
[
270,
196
],
[
273,
197
],
[
200,
199
],
[
267,
203
],
[
191,
205
],
[
186,
206
],
[
191,
207
],
[
267,
209
],
[
273,
215
],
[
191,
217
],
[
255,
218
],
[
276,
220
],
[
273,
223
],
[
191,
225
],
[
261,
226
],
[
229,
228
],
[
261,
229
],
[
232,
231
],
[
171,
234
],
[
228,
235
],
[
199,
235
],
[
183,
235
],
[
261,
236
],
[
231,
238
],
[
257,
244
],
[
252,
246
],
[
258,
249
],
[
275,
255
],
[
257,
258
],
[
260,
261
],
[
275,
270
],
[
275,
273
],
[
275,
276
],
[
281,
279
],
[
281,
282
]
] | [
"import sys\n\nMOD = 10 ** 9 + 7\n\ndef make_table(n=10**6, p=10**9+7):\n fac = [None] * (n + 1)\n fac[0] = 1\n ifac = fac.copy()\n for i in range(1, n + 1):\n fac[i] = fac[i-1] * i % p\n ifac[n] = pow(fac[n], p - 2, p)\n for i in range(n-1, 0, -1):\n ifac[i] = ifac[i+1] * (i + 1) % p\n return fac, ifac\nfac, ifac = make_table()\ndef comb_mod(n, r, mod=10**9+7):\n if r < 0 or r > n:\n return 0\n return fac[n] * ifac[r] % mod * ifac[n-r] % mod\n\nh, w, a, b = map(int, sys.stdin.readline().split())\n\ndef main():\n total = comb_mod(h+w-2, h-1)\n\n ng = 0\n j = b - 1\n for i in range(h - a, h):\n ng += comb_mod(i + j, i) * comb_mod(h-1-i + w-1-b, h-1-i) % MOD\n ng %= MOD\n \n ans = (total - ng) % MOD\n return ans \n\nif __name__ == '__main__':\n ans = main()\n print(ans)",
"import sys",
"sys",
"MOD = 10 ** 9 + 7",
"MOD",
"10 ** 9 + 7",
"10 ** 9",
"10",
"9",
"7",
"def make_table(n=10**6, p=10**9+7):\n fac = [None] * (n + 1)\n fac[0] = 1\n ifac = fac.copy()\n for i in range(1, n + 1):\n fac[i] = fac[i-1] * i % p\n ifac[n] = pow(fac[n], p - 2, p)\n for i in range(n-1, 0, -1):\n ifac[i] = ifac[i+1] * (i + 1) % p\n return fac, ifac",
"make_table",
"fac = [None] * (n + 1)",
"fac",
"[None] * (n + 1)",
"[None]",
"None",
"n + 1",
"n",
"1",
"fac[0] = 1",
"fac[0]",
"fac",
"0",
"1",
"ifac = fac.copy()",
"ifac",
"fac.copy()",
"fac.copy",
"fac",
"copy",
"for i in range(1, n + 1):\n fac[i] = fac[i-1] * i % p\n ",
"i",
"range(1, n + 1)",
"range",
"1",
"n + 1",
"n",
"1",
"fac[i] = fac[i-1] * i % p",
"fac[i]",
"fac",
"i",
"fac[i-1] * i % p",
"fac[i-1] * i",
"fac[i-1]",
"fac",
"i-1",
"i",
"1",
"i",
"p",
"ifac[n] = pow(fac[n], p - 2, p)",
"ifac[n]",
"ifac",
"n",
"pow(fac[n], p - 2, p)",
"pow",
"fac[n]",
"fac",
"n",
"p - 2",
"p",
"2",
"p",
"for i in range(n-1, 0, -1):\n ifac[i] = ifac[i+1] * (i + 1) % p\n ",
"i",
"range(n-1, 0, -1)",
"range",
"n-1",
"n",
"1",
"0",
"-1",
"ifac[i] = ifac[i+1] * (i + 1) % p",
"ifac[i]",
"ifac",
"i",
"ifac[i+1] * (i + 1) % p",
"ifac[i+1] * (i + 1)",
"ifac[i+1]",
"ifac",
"i+1",
"i",
"1",
"i + 1",
"i",
"1",
"p",
"return fac, ifac",
"return fac, ifac",
"fac",
"ifac",
"n=10**6",
"n",
"10**6",
"10",
"6",
"p=10**9+7",
"p",
"10**9+7",
"10**9",
"10",
"9",
"7",
"fac, ifac = make_table()",
"fac",
"make_table()",
"make_table",
"ifac",
"def comb_mod(n, r, mod=10**9+7):\n if r < 0 or r > n:\n return 0\n return fac[n] * ifac[r] % mod * ifac[n-r] % mod",
"comb_mod",
"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",
"return fac[n] * ifac[r] % mod * ifac[n-r] % mod",
"fac[n] * ifac[r] % mod * ifac[n-r] % mod",
"fac[n] * ifac[r] % mod * ifac[n-r]",
"fac[n] * ifac[r] % mod",
"fac[n] * ifac[r]",
"fac[n]",
"fac",
"n",
"ifac[r]",
"ifac",
"r",
"mod",
"ifac[n-r]",
"ifac",
"n-r",
"n",
"r",
"mod",
"n",
"n",
"r",
"r",
"mod=10**9+7",
"mod",
"10**9+7",
"10**9",
"10",
"9",
"7",
"h, w, a, b = map(int, sys.stdin.readline().split())",
"h",
"map(int, sys.stdin.readline().split())",
"map",
"int",
"sys.stdin.readline().split()",
"sys.stdin.readline().split",
"sys.stdin.readline()",
"sys.stdin.readline",
"sys.stdin",
"sys",
"stdin",
"readline",
"split",
"w",
"a",
"b",
"def main():\n total = comb_mod(h+w-2, h-1)\n\n ng = 0\n j = b - 1\n for i in range(h - a, h):\n ng += comb_mod(i + j, i) * comb_mod(h-1-i + w-1-b, h-1-i) % MOD\n ng %= MOD\n \n ans = (total - ng) % MOD\n return ans ",
"main",
"total = comb_mod(h+w-2, h-1)",
"total",
"comb_mod(h+w-2, h-1)",
"comb_mod",
"h+w-2",
"h+w",
"h",
"w",
"2",
"h-1",
"h",
"1",
"ng = 0",
"ng",
"0",
"j = b - 1",
"j",
"b - 1",
"b",
"1",
"for i in range(h - a, h):\n ng += comb_mod(i + j, i) * comb_mod(h-1-i + w-1-b, h-1-i) % MOD\n ng %= MOD\n \n ",
"i",
"range(h - a, h)",
"range",
"h - a",
"h",
"a",
"h",
"ng += comb_mod(i + j, i) * comb_mod(h-1-i + w-1-b, h-1-i) % MOD",
"ng",
"comb_mod(i + j, i) * comb_mod(h-1-i + w-1-b, h-1-i) % MOD",
"comb_mod(i + j, i) * comb_mod(h-1-i + w-1-b, h-1-i)",
"comb_mod(i + j, i)",
"comb_mod",
"i + j",
"i",
"j",
"i",
"comb_mod(h-1-i + w-1-b, h-1-i)",
"comb_mod",
"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",
"ng %= MOD",
"ng",
"MOD",
"ans = (total - ng) % MOD",
"ans",
"(total - ng) % MOD",
"total - ng",
"total",
"ng",
"MOD",
"return ans",
"ans",
"if __name__ == '__main__':\n ans = main()\n print(ans)",
"__name__ == '__main__'",
"__name__",
"'__main__'",
"ans = main()",
"ans",
"main()",
"main",
"print(ans)",
"print",
"ans",
"def main():\n total = comb_mod(h+w-2, h-1)\n\n ng = 0\n j = b - 1\n for i in range(h - a, h):\n ng += comb_mod(i + j, i) * comb_mod(h-1-i + w-1-b, h-1-i) % MOD\n ng %= MOD\n \n ans = (total - ng) % MOD\n return ans ",
"def main():\n total = comb_mod(h+w-2, h-1)\n\n ng = 0\n j = b - 1\n for i in range(h - a, h):\n ng += comb_mod(i + j, i) * comb_mod(h-1-i + w-1-b, h-1-i) % MOD\n ng %= MOD\n \n ans = (total - ng) % MOD\n return ans ",
"main",
"w, a, b = map(int, sys.stdin.readline().split())",
"map(int, sys.stdin.readline().split())",
"w",
"ans = main()",
"main()",
"ans",
"MOD = 10 ** 9 + 7",
"10 ** 9 + 7",
"MOD",
"def make_table(n=10**6, p=10**9+7):\n fac = [None] * (n + 1)\n fac[0] = 1\n ifac = fac.copy()\n for i in range(1, n + 1):\n fac[i] = fac[i-1] * i % p\n ifac[n] = pow(fac[n], p - 2, p)\n for i in range(n-1, 0, -1):\n ifac[i] = ifac[i+1] * (i + 1) % p\n return fac, ifac",
"def make_table(n=10**6, p=10**9+7):\n fac = [None] * (n + 1)\n fac[0] = 1\n ifac = fac.copy()\n for i in range(1, n + 1):\n fac[i] = fac[i-1] * i % p\n ifac[n] = pow(fac[n], p - 2, p)\n for i in range(n-1, 0, -1):\n ifac[i] = ifac[i+1] * (i + 1) % p\n return fac, ifac",
"make_table",
"def comb_mod(n, r, mod=10**9+7):\n if r < 0 or r > n:\n return 0\n return fac[n] * ifac[r] % mod * ifac[n-r] % mod",
"def comb_mod(n, r, mod=10**9+7):\n if r < 0 or r > n:\n return 0\n return fac[n] * ifac[r] % mod * ifac[n-r] % mod",
"comb_mod",
"a, b = map(int, sys.stdin.readline().split())",
"map(int, sys.stdin.readline().split())",
"a",
"h, w, a, b = map(int, sys.stdin.readline().split())",
"map(int, sys.stdin.readline().split())",
"h",
"b = map(int, sys.stdin.readline().split())",
"map(int, sys.stdin.readline().split())",
"b",
"fac, ifac = make_table()",
"make_table()",
"fac",
"ifac = make_table()",
"make_table()",
"ifac"
] | import sys
MOD = 10 ** 9 + 7
def make_table(n=10**6, p=10**9+7):
fac = [None] * (n + 1)
fac[0] = 1
ifac = fac.copy()
for i in range(1, n + 1):
fac[i] = fac[i-1] * i % p
ifac[n] = pow(fac[n], p - 2, p)
for i in range(n-1, 0, -1):
ifac[i] = ifac[i+1] * (i + 1) % p
return fac, ifac
fac, ifac = make_table()
def comb_mod(n, r, mod=10**9+7):
if r < 0 or r > n:
return 0
return fac[n] * ifac[r] % mod * ifac[n-r] % mod
h, w, a, b = map(int, sys.stdin.readline().split())
def main():
total = comb_mod(h+w-2, h-1)
ng = 0
j = b - 1
for i in range(h - a, h):
ng += comb_mod(i + j, i) * comb_mod(h-1-i + w-1-b, h-1-i) % MOD
ng %= MOD
ans = (total - ng) % MOD
return ans
if __name__ == '__main__':
ans = main()
print(ans) |
[
7,
0,
13,
4,
13,
13,
4,
18,
4,
13,
13,
13,
13,
13,
0,
13,
2,
13,
13,
0,
13,
2,
39,
17,
2,
13,
17,
0,
13,
2,
39,
17,
2,
13,
17,
0,
13,
2,
39,
17,
2,
13,
17,
0,
13,
2,
2,
17,
17,
17,
12,
13,
0,
18,
13,
17,
17,
0,
18,
13,
17,
17,
0,
18,
13,
17,
17,
0,
18,
13,
17,
17,
0,
18,
13,
17,
17,
28,
13,
4,
13,
17,
2,
13,
17,
0,
18,
13,
13,
2,
2,
18,
13,
2,
13,
17,
13,
13,
0,
18,
13,
13,
2,
13,
2,
2,
18,
13,
2,
13,
13,
2,
13,
13,
13,
0,
18,
13,
13,
2,
2,
18,
13,
2,
13,
17,
18,
13,
13,
13,
23,
13,
12,
13,
14,
2,
2,
2,
13,
17,
2,
13,
13,
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,
4,
13,
13,
0,
13,
4,
13,
2,
2,
2,
13,
13,
13,
17,
13,
0,
13,
17,
28,
13,
4,
13,
13,
0,
13,
2,
2,
13,
4,
13,
2,
2,
2,
13,
13,
17,
13,
13,
13,
0,
13,
2,
2,
13,
13,
13,
28,
13,
4,
13,
2,
13,
13,
0,
13,
2,
2,
13,
2,
4,
13,
2,
13,
13,
13,
4,
13,
2,
2,
2,
2,
2,
13,
13,
17,
13,
13,
17,
2,
2,
13,
13,
17,
13,
14,
2,
2,
2,
13,
13,
17,
2,
2,
13,
13,
17,
0,
13,
17,
14,
2,
2,
13,
13,
17,
0,
13,
4,
13,
2,
2,
2,
13,
13,
13,
17,
2,
13,
17,
14,
2,
2,
13,
13,
17,
0,
13,
4,
13,
2,
2,
2,
13,
13,
13,
17,
2,
13,
17,
4,
13,
13,
10,
2,
13,
10,
2,
13,
10,
4,
13,
10,
4,
13,
10,
4,
13,
10,
4,
13,
10,
2,
13,
10,
4,
13,
10,
17,
13,
10,
2,
13,
10,
2,
13,
10,
2,
13,
10,
4,
13,
10,
12,
13,
10,
17,
13,
10,
2,
13,
10,
12,
13,
10,
4,
13,
10,
2,
13
] | [
[
332,
2
],
[
332,
11
],
[
332,
12
],
[
332,
13
],
[
329,
15
],
[
327,
17
],
[
318,
18
],
[
356,
20
],
[
330,
25
],
[
365,
28
],
[
330,
33
],
[
338,
36
],
[
330,
41
],
[
344,
44
],
[
56,
53
],
[
357,
54
],
[
61,
58
],
[
357,
59
],
[
66,
63
],
[
366,
64
],
[
71,
68
],
[
366,
69
],
[
76,
73
],
[
339,
74
],
[
79,
78
],
[
131,
83
],
[
89,
86
],
[
357,
87
],
[
78,
88
],
[
357,
92
],
[
78,
94
],
[
78,
96
],
[
345,
97
],
[
102,
99
],
[
339,
100
],
[
78,
101
],
[
345,
103
],
[
339,
107
],
[
345,
109
],
[
78,
110
],
[
345,
112
],
[
78,
113
],
[
345,
114
],
[
119,
116
],
[
366,
117
],
[
78,
118
],
[
366,
122
],
[
78,
124
],
[
99,
126
],
[
339,
127
],
[
78,
128
],
[
345,
129
],
[
131,
131
],
[
167,
138
],
[
167,
141
],
[
165,
142
],
[
165,
144
],
[
357,
153
],
[
165,
154
],
[
366,
156
],
[
167,
157
],
[
366,
159
],
[
165,
161
],
[
167,
162
],
[
345,
163
],
[
165,
165
],
[
167,
167
],
[
351,
169
],
[
330,
170
],
[
362,
172
],
[
360,
174
],
[
327,
178
],
[
333,
179
],
[
324,
180
],
[
324,
182
],
[
335,
184
],
[
188,
187
],
[
333,
190
],
[
311,
192
],
[
336,
195
],
[
312,
195
],
[
360,
197
],
[
318,
201
],
[
324,
202
],
[
187,
204
],
[
187,
205
],
[
345,
206
],
[
314,
208
],
[
312,
211
],
[
336,
211
],
[
363,
212
],
[
345,
213
],
[
216,
215
],
[
327,
219
],
[
333,
220
],
[
341,
222
],
[
315,
225
],
[
312,
225
],
[
336,
225
],
[
342,
225
],
[
360,
228
],
[
324,
230
],
[
215,
231
],
[
215,
232
],
[
360,
234
],
[
327,
240
],
[
215,
241
],
[
318,
243
],
[
324,
244
],
[
318,
248
],
[
324,
249
],
[
345,
251
],
[
327,
256
],
[
333,
257
],
[
318,
261
],
[
324,
262
],
[
353,
265
],
[
327,
270
],
[
333,
271
],
[
320,
274
],
[
360,
276
],
[
318,
280
],
[
324,
281
],
[
327,
282
],
[
327,
285
],
[
318,
290
],
[
324,
291
],
[
347,
294
],
[
360,
296
],
[
327,
300
],
[
333,
301
],
[
318,
302
],
[
318,
305
],
[
348,
309
],
[
321,
309
],
[
354,
309
],
[
342,
309
],
[
315,
309
],
[
312,
309
],
[
336,
309
],
[
311,
312
],
[
314,
315
],
[
332,
318
],
[
320,
321
],
[
332,
324
],
[
332,
327
],
[
329,
330
],
[
332,
333
],
[
335,
336
],
[
338,
339
],
[
341,
342
],
[
344,
345
],
[
347,
348
],
[
353,
354
],
[
356,
357
],
[
362,
363
],
[
365,
366
]
] | [
"H,W,A,B = map(int,input().split())\nN=H+W\nfact = [0]*(N+1)\nifact = [0]*(N+1)\ninv = [0]*(N+1)\np=10**9+7\n\ndef combination(n):\n fact[0] = 1\n fact[1] = 1\n ifact[0] = 1\n ifact[1] = 1\n inv[1] = 1\n for i in range(2,n+1):\n fact[i] = (fact[i-1]*i)%p\n inv[i] = p - inv[p%i]*(p//i)%p\n ifact[i] = (ifact[i-1]*inv[i])%p\ndef op(n,k):\n if k<0 or k>n or n<0:\n return 0\n return (fact[n]*ifact[k]*ifact[n-k])%p\ncombination(N)\n\nb = op(H-A+B-1, B)\nres = 0\nfor i in range(A):\n res = (res + op(W-B-2+i, i))%p\nres = (res*b)%p\nfor i in range(H-A):\n res = (res + op(B+i, i)*op(H-i-1+W-B-2,W-B-2))%p\nif H-A==1 and W-B==1:\n res = 1\nelif H-A==1:\n res = op(W-B+H-2, H-1)\nelif W-B==1:\n res = op(H-A+W-2, W-1)\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",
"N=H+W",
"N",
"H+W",
"H",
"W",
"fact = [0]*(N+1)",
"fact",
"[0]*(N+1)",
"[0]",
"0",
"N+1",
"N",
"1",
"ifact = [0]*(N+1)",
"ifact",
"[0]*(N+1)",
"[0]",
"0",
"N+1",
"N",
"1",
"inv = [0]*(N+1)",
"inv",
"[0]*(N+1)",
"[0]",
"0",
"N+1",
"N",
"1",
"p=10**9+7",
"p",
"10**9+7",
"10**9",
"10",
"9",
"7",
"def combination(n):\n fact[0] = 1\n fact[1] = 1\n ifact[0] = 1\n ifact[1] = 1\n inv[1] = 1\n for i in range(2,n+1):\n fact[i] = (fact[i-1]*i)%p\n inv[i] = p - inv[p%i]*(p//i)%p\n ifact[i] = (ifact[i-1]*inv[i])%p",
"combination",
"fact[0] = 1",
"fact[0]",
"fact",
"0",
"1",
"fact[1] = 1",
"fact[1]",
"fact",
"1",
"1",
"ifact[0] = 1",
"ifact[0]",
"ifact",
"0",
"1",
"ifact[1] = 1",
"ifact[1]",
"ifact",
"1",
"1",
"inv[1] = 1",
"inv[1]",
"inv",
"1",
"1",
"for i in range(2,n+1):\n fact[i] = (fact[i-1]*i)%p\n inv[i] = p - inv[p%i]*(p//i)%p\n ifact[i] = (ifact[i-1]*inv[i])%p",
"i",
"range(2,n+1)",
"range",
"2",
"n+1",
"n",
"1",
"fact[i] = (fact[i-1]*i)%p",
"fact[i]",
"fact",
"i",
"(fact[i-1]*i)%p",
"fact[i-1]*i",
"fact[i-1]",
"fact",
"i-1",
"i",
"1",
"i",
"p",
"inv[i] = p - inv[p%i]*(p//i)%p",
"inv[i]",
"inv",
"i",
"p - inv[p%i]*(p//i)%p",
"p",
"inv[p%i]*(p//i)%p",
"inv[p%i]*(p//i)",
"inv[p%i]",
"inv",
"p%i",
"p",
"i",
"p//i",
"p",
"i",
"p",
"ifact[i] = (ifact[i-1]*inv[i])%p",
"ifact[i]",
"ifact",
"i",
"(ifact[i-1]*inv[i])%p",
"ifact[i-1]*inv[i]",
"ifact[i-1]",
"ifact",
"i-1",
"i",
"1",
"inv[i]",
"inv",
"i",
"p",
"n",
"n",
"def op(n,k):\n if k<0 or k>n or n<0:\n return 0\n return (fact[n]*ifact[k]*ifact[n-k])%p",
"op",
"if k<0 or k>n or n<0:\n return 0\n ",
"k<0 or k>n or n<0",
"k<0 or k>n",
"k<0",
"k",
"0",
"k>n",
"k",
"n",
"n<0",
"n",
"0",
"return 0",
"0",
"return (fact[n]*ifact[k]*ifact[n-k])%p",
"(fact[n]*ifact[k]*ifact[n-k])%p",
"fact[n]*ifact[k]*ifact[n-k]",
"fact[n]*ifact[k]",
"fact[n]",
"fact",
"n",
"ifact[k]",
"ifact",
"k",
"ifact[n-k]",
"ifact",
"n-k",
"n",
"k",
"p",
"n",
"n",
"k",
"k",
"combination(N)",
"combination",
"N",
"b = op(H-A+B-1, B)",
"b",
"op(H-A+B-1, B)",
"op",
"H-A+B-1",
"H-A+B",
"H-A",
"H",
"A",
"B",
"1",
"B",
"res = 0",
"res",
"0",
"for i in range(A):\n res = (res + op(W-B-2+i, i))%p",
"i",
"range(A)",
"range",
"A",
"res = (res + op(W-B-2+i, i))%p",
"res",
"(res + op(W-B-2+i, i))%p",
"res + op(W-B-2+i, i)",
"res",
"op(W-B-2+i, i)",
"op",
"W-B-2+i",
"W-B-2",
"W-B",
"W",
"B",
"2",
"i",
"i",
"p",
"res = (res*b)%p",
"res",
"(res*b)%p",
"res*b",
"res",
"b",
"p",
"for i in range(H-A):\n res = (res + op(B+i, i)*op(H-i-1+W-B-2,W-B-2))%p",
"i",
"range(H-A)",
"range",
"H-A",
"H",
"A",
"res = (res + op(B+i, i)*op(H-i-1+W-B-2,W-B-2))%p",
"res",
"(res + op(B+i, i)*op(H-i-1+W-B-2,W-B-2))%p",
"res + op(B+i, i)*op(H-i-1+W-B-2,W-B-2)",
"res",
"op(B+i, i)*op(H-i-1+W-B-2,W-B-2)",
"op(B+i, i)",
"op",
"B+i",
"B",
"i",
"i",
"op(H-i-1+W-B-2,W-B-2)",
"op",
"H-i-1+W-B-2",
"H-i-1+W-B",
"H-i-1+W",
"H-i-1",
"H-i",
"H",
"i",
"1",
"W",
"B",
"2",
"W-B-2",
"W-B",
"W",
"B",
"2",
"p",
"if H-A==1 and W-B==1:\n res = 1\nelif H-A==1:\n res = op(W-B+H-2, H-1)\nelif W-B==1:\n res = op(H-A+W-2, W-1)",
"H-A==1 and W-B==1",
"H-A==1",
"H-A",
"H",
"A",
"1",
"W-B==1",
"W-B",
"W",
"B",
"1",
"res = 1",
"res",
"1",
"elif H-A==1:\n res = op(W-B+H-2, H-1)",
"H-A==1",
"H-A",
"H",
"A",
"1",
"res = op(W-B+H-2, H-1)",
"res",
"op(W-B+H-2, H-1)",
"op",
"W-B+H-2",
"W-B+H",
"W-B",
"W",
"B",
"H",
"2",
"H-1",
"H",
"1",
"elif W-B==1:\n res = op(H-A+W-2, W-1)",
"W-B==1",
"W-B",
"W",
"B",
"1",
"res = op(H-A+W-2, W-1)",
"res",
"op(H-A+W-2, W-1)",
"op",
"H-A+W-2",
"H-A+W",
"H-A",
"H",
"A",
"W",
"2",
"W-1",
"W",
"1",
"print(res)",
"print",
"res",
"res = (res + op(W-B-2+i, i))%p",
"(res + op(W-B-2+i, i))%p",
"res",
"res = (res*b)%p",
"(res*b)%p",
"res",
"W,A,B = map(int,input().split())",
"map(int,input().split())",
"W",
"res = op(W-B+H-2, H-1)",
"op(W-B+H-2, H-1)",
"res",
"B = map(int,input().split())",
"map(int,input().split())",
"B",
"H,W,A,B = map(int,input().split())",
"map(int,input().split())",
"H",
"N=H+W",
"H+W",
"N",
"A,B = map(int,input().split())",
"map(int,input().split())",
"A",
"res = 0",
"0",
"res",
"inv = [0]*(N+1)",
"[0]*(N+1)",
"inv",
"res = (res + op(B+i, i)*op(H-i-1+W-B-2,W-B-2))%p",
"(res + op(B+i, i)*op(H-i-1+W-B-2,W-B-2))%p",
"res",
"p=10**9+7",
"10**9+7",
"p",
"res = op(H-A+W-2, W-1)",
"op(H-A+W-2, W-1)",
"res",
"def combination(n):\n fact[0] = 1\n fact[1] = 1\n ifact[0] = 1\n ifact[1] = 1\n inv[1] = 1\n for i in range(2,n+1):\n fact[i] = (fact[i-1]*i)%p\n inv[i] = p - inv[p%i]*(p//i)%p\n ifact[i] = (ifact[i-1]*inv[i])%p",
"def combination(n):\n fact[0] = 1\n fact[1] = 1\n ifact[0] = 1\n ifact[1] = 1\n inv[1] = 1\n for i in range(2,n+1):\n fact[i] = (fact[i-1]*i)%p\n inv[i] = p - inv[p%i]*(p//i)%p\n ifact[i] = (ifact[i-1]*inv[i])%p",
"combination",
"res = 1",
"1",
"res",
"fact = [0]*(N+1)",
"[0]*(N+1)",
"fact",
"def op(n,k):\n if k<0 or k>n or n<0:\n return 0\n return (fact[n]*ifact[k]*ifact[n-k])%p",
"def op(n,k):\n if k<0 or k>n or n<0:\n return 0\n return (fact[n]*ifact[k]*ifact[n-k])%p",
"op",
"b = op(H-A+B-1, B)",
"op(H-A+B-1, B)",
"b",
"ifact = [0]*(N+1)",
"[0]*(N+1)",
"ifact"
] | H,W,A,B = map(int,input().split())
N=H+W
fact = [0]*(N+1)
ifact = [0]*(N+1)
inv = [0]*(N+1)
p=10**9+7
def combination(n):
fact[0] = 1
fact[1] = 1
ifact[0] = 1
ifact[1] = 1
inv[1] = 1
for i in range(2,n+1):
fact[i] = (fact[i-1]*i)%p
inv[i] = p - inv[p%i]*(p//i)%p
ifact[i] = (ifact[i-1]*inv[i])%p
def op(n,k):
if k<0 or k>n or n<0:
return 0
return (fact[n]*ifact[k]*ifact[n-k])%p
combination(N)
b = op(H-A+B-1, B)
res = 0
for i in range(A):
res = (res + op(W-B-2+i, i))%p
res = (res*b)%p
for i in range(H-A):
res = (res + op(B+i, i)*op(H-i-1+W-B-2,W-B-2))%p
if H-A==1 and W-B==1:
res = 1
elif H-A==1:
res = op(W-B+H-2, H-1)
elif W-B==1:
res = op(H-A+W-2, W-1)
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,
17,
2,
17,
17,
12,
13,
0,
13,
2,
2,
18,
13,
13,
18,
13,
13,
13,
0,
13,
2,
2,
13,
18,
13,
2,
13,
13,
13,
29,
13,
23,
13,
23,
13,
23,
13,
12,
13,
29,
4,
13,
2,
2,
13,
13,
17,
13,
13,
23,
13,
23,
13,
23,
13,
12,
13,
14,
2,
13,
17,
29,
17,
14,
2,
2,
13,
17,
17,
29,
2,
13,
4,
13,
13,
2,
13,
17,
13,
29,
2,
2,
2,
4,
13,
13,
2,
13,
17,
13,
13,
17,
13,
23,
13,
23,
13,
23,
13,
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,
4,
13,
17,
2,
13,
17,
0,
18,
13,
2,
13,
17,
2,
2,
18,
13,
13,
13,
13,
0,
13,
13,
0,
13,
2,
2,
13,
13,
17,
0,
13,
17,
0,
13,
2,
13,
17,
0,
13,
17,
28,
13,
4,
13,
2,
13,
13,
0,
13,
2,
4,
13,
2,
13,
13,
13,
13,
4,
13,
2,
13,
13,
13,
13,
0,
13,
13,
4,
13,
13,
10,
2,
13,
10,
13,
13,
10,
17,
13,
10,
17,
13,
10,
4,
13,
10,
2,
13,
10,
13,
13,
10,
2,
13,
10,
2,
13,
10,
12,
13,
10,
4,
13,
10,
2,
13,
10,
4,
13,
10,
12,
13,
10,
12,
13,
10,
2,
13,
10,
4,
13,
10,
2,
13
] | [
[
295,
2
],
[
295,
11
],
[
295,
12
],
[
295,
13
],
[
268,
15
],
[
280,
22
],
[
32,
31
],
[
55,
36
],
[
57,
39
],
[
59,
40
],
[
43,
42
],
[
31,
45
],
[
55,
49
],
[
57,
50
],
[
59,
51
],
[
42,
53
],
[
31,
53
],
[
55,
55
],
[
57,
57
],
[
59,
59
],
[
287,
64
],
[
73,
67
],
[
75,
68
],
[
75,
70
],
[
77,
71
],
[
73,
73
],
[
75,
75
],
[
77,
77
],
[
119,
82
],
[
119,
89
],
[
117,
94
],
[
117,
97
],
[
119,
99
],
[
121,
101
],
[
117,
108
],
[
119,
110
],
[
121,
112
],
[
121,
113
],
[
121,
115
],
[
117,
117
],
[
119,
119
],
[
121,
121
],
[
262,
123
],
[
281,
128
],
[
292,
131
],
[
281,
136
],
[
140,
139
],
[
281,
144
],
[
150,
147
],
[
263,
148
],
[
139,
149
],
[
263,
153
],
[
139,
155
],
[
139,
157
],
[
269,
158
],
[
163,
160
],
[
293,
161
],
[
281,
162
],
[
290,
164
],
[
263,
166
],
[
281,
167
],
[
269,
169
],
[
269,
171
],
[
174,
173
],
[
281,
180
],
[
188,
183
],
[
293,
184
],
[
173,
186
],
[
293,
191
],
[
173,
192
],
[
173,
193
],
[
269,
194
],
[
250,
196
],
[
296,
197
],
[
247,
199
],
[
284,
202
],
[
260,
203
],
[
253,
206
],
[
271,
209
],
[
260,
211
],
[
256,
214
],
[
218,
217
],
[
296,
221
],
[
278,
222
],
[
298,
224
],
[
275,
227
],
[
251,
229
],
[
217,
230
],
[
248,
231
],
[
269,
232
],
[
275,
234
],
[
254,
236
],
[
217,
237
],
[
272,
238
],
[
269,
239
],
[
265,
241
],
[
269,
242
],
[
266,
245
],
[
299,
245
],
[
257,
245
],
[
247,
248
],
[
296,
250
],
[
250,
251
],
[
253,
254
],
[
256,
257
],
[
295,
260
],
[
262,
263
],
[
269,
265
],
[
265,
266
],
[
268,
269
],
[
271,
272
],
[
295,
278
],
[
280,
281
],
[
295,
284
],
[
292,
293
],
[
295,
296
],
[
298,
299
]
] | [
"H, W, A, B = map(int, input().split())\nMOD = 10 ** 9 + 7\nlimit = 2 * 10 ** 5\n\n\n# modしながらコンビネーションを求める\ndef mod_cmb(n, r, mod):\n x = fact[n] * fact_inverse[r] % mod\n x = x * fact_inverse[n - r] % mod\n return x\n\n\ndef d_cmb(n, r, mod):\n return mod_cmb(n + r - 1, r, mod)\n\n\n# modしたa^bを求める\ndef mod_pow(a, p, mod):\n if p == 0:\n return 1\n elif p % 2 == 1:\n return a * mod_pow(a, p - 1, mod)\n else:\n return (mod_pow(a, p // 2, mod) % mod) ** 2 % mod\n\n\nfact = [1] * (limit + 1)\nfact_inverse = [1] * (limit + 1)\n\nfor i in range(1, limit + 1):\n fact[i] = fact[i - 1] * i % MOD\n\nfact_inverse[limit] = mod_pow(fact[limit], MOD - 2, MOD)\nfor i in reversed(range(1, limit + 1)):\n fact_inverse[i - 1] = fact_inverse[i] * i % MOD\n\nn1 = W\nr1 = H - A - 1\nn2 = 1\nr2 = A - 1\nans = 0\nfor i in range(W - B):\n ans += d_cmb(n1 - i, r1, MOD) * d_cmb(n2 + i, r2, 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",
"MOD = 10 ** 9 + 7",
"MOD",
"10 ** 9 + 7",
"10 ** 9",
"10",
"9",
"7",
"limit = 2 * 10 ** 5",
"limit",
"2 * 10 ** 5",
"2",
"10 ** 5",
"10",
"5",
"def mod_cmb(n, r, mod):\n x = fact[n] * fact_inverse[r] % mod\n x = x * fact_inverse[n - r] % mod\n return x",
"mod_cmb",
"x = fact[n] * fact_inverse[r] % mod",
"x",
"fact[n] * fact_inverse[r] % mod",
"fact[n] * fact_inverse[r]",
"fact[n]",
"fact",
"n",
"fact_inverse[r]",
"fact_inverse",
"r",
"mod",
"x = x * fact_inverse[n - r] % mod",
"x",
"x * fact_inverse[n - r] % mod",
"x * fact_inverse[n - r]",
"x",
"fact_inverse[n - r]",
"fact_inverse",
"n - r",
"n",
"r",
"mod",
"return x",
"x",
"n",
"n",
"r",
"r",
"mod",
"mod",
"def d_cmb(n, r, mod):\n return mod_cmb(n + r - 1, r, mod)\n\n\n# modしたa^bを求める",
"d_cmb",
"return mod_cmb(n + r - 1, r, mod)",
"mod_cmb(n + r - 1, r, mod)",
"mod_cmb",
"n + r - 1",
"n + r",
"n",
"r",
"1",
"r",
"mod",
"n",
"n",
"r",
"r",
"mod",
"mod",
"def mod_pow(a, p, mod):\n if p == 0:\n return 1\n elif p % 2 == 1:\n return a * mod_pow(a, p - 1, mod)\n else:\n return (mod_pow(a, p // 2, mod) % mod) ** 2 % mod",
"mod_pow",
"if p == 0:\n return 1\n elif p % 2 == 1:\n return a * mod_pow(a, p - 1, mod)\n else:\n return (mod_pow(a, p // 2, mod) % mod) ** 2 % mod",
"p == 0",
"p",
"0",
"return 1",
"1",
"elif p % 2 == 1:\n return a * mod_pow(a, p - 1, mod)\n ",
"p % 2 == 1",
"p % 2",
"p",
"2",
"1",
"return a * mod_pow(a, p - 1, mod)",
"a * mod_pow(a, p - 1, mod)",
"a",
"mod_pow(a, p - 1, mod)",
"mod_pow",
"a",
"p - 1",
"p",
"1",
"mod",
"return (mod_pow(a, p // 2, mod) % mod) ** 2 % mod",
"(mod_pow(a, p // 2, mod) % mod) ** 2 % mod",
"(mod_pow(a, p // 2, mod) % mod) ** 2",
"mod_pow(a, p // 2, mod) % mod",
"mod_pow(a, p // 2, mod)",
"mod_pow",
"a",
"p // 2",
"p",
"2",
"mod",
"mod",
"2",
"mod",
"a",
"a",
"p",
"p",
"mod",
"mod",
"fact = [1] * (limit + 1)",
"fact",
"[1] * (limit + 1)",
"[1]",
"1",
"limit + 1",
"limit",
"1",
"fact_inverse = [1] * (limit + 1)",
"fact_inverse",
"[1] * (limit + 1)",
"[1]",
"1",
"limit + 1",
"limit",
"1",
"for i in range(1, limit + 1):\n fact[i] = fact[i - 1] * i % MOD",
"i",
"range(1, limit + 1)",
"range",
"1",
"limit + 1",
"limit",
"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_inverse[limit] = mod_pow(fact[limit], MOD - 2, MOD)",
"fact_inverse[limit]",
"fact_inverse",
"limit",
"mod_pow(fact[limit], MOD - 2, MOD)",
"mod_pow",
"fact[limit]",
"fact",
"limit",
"MOD - 2",
"MOD",
"2",
"MOD",
"for i in reversed(range(1, limit + 1)):\n fact_inverse[i - 1] = fact_inverse[i] * i % MOD",
"i",
"reversed(range(1, limit + 1))",
"reversed",
"range(1, limit + 1)",
"range",
"1",
"limit + 1",
"limit",
"1",
"fact_inverse[i - 1] = fact_inverse[i] * i % MOD",
"fact_inverse[i - 1]",
"fact_inverse",
"i - 1",
"i",
"1",
"fact_inverse[i] * i % MOD",
"fact_inverse[i] * i",
"fact_inverse[i]",
"fact_inverse",
"i",
"i",
"MOD",
"n1 = W",
"n1",
"W",
"r1 = H - A - 1",
"r1",
"H - A - 1",
"H - A",
"H",
"A",
"1",
"n2 = 1",
"n2",
"1",
"r2 = A - 1",
"r2",
"A - 1",
"A",
"1",
"ans = 0",
"ans",
"0",
"for i in range(W - B):\n ans += d_cmb(n1 - i, r1, MOD) * d_cmb(n2 + i, r2, MOD)\n ans %= MOD",
"i",
"range(W - B)",
"range",
"W - B",
"W",
"B",
"ans += d_cmb(n1 - i, r1, MOD) * d_cmb(n2 + i, r2, MOD)",
"ans",
"d_cmb(n1 - i, r1, MOD) * d_cmb(n2 + i, r2, MOD)",
"d_cmb(n1 - i, r1, MOD)",
"d_cmb",
"n1 - i",
"n1",
"i",
"r1",
"MOD",
"d_cmb(n2 + i, r2, MOD)",
"d_cmb",
"n2 + i",
"n2",
"i",
"r2",
"MOD",
"ans %= MOD",
"ans",
"MOD",
"print(ans)",
"print",
"ans",
"r1 = H - A - 1",
"H - A - 1",
"r1",
"n1 = W",
"W",
"n1",
"n2 = 1",
"1",
"n2",
"ans = 0",
"0",
"ans",
"A, B = map(int, input().split())",
"map(int, input().split())",
"A",
"fact = [1] * (limit + 1)",
"[1] * (limit + 1)",
"fact",
"ans %= MOD",
"MOD",
"ans",
"MOD = 10 ** 9 + 7",
"10 ** 9 + 7",
"MOD",
"r2 = A - 1",
"A - 1",
"r2",
"def d_cmb(n, r, mod):\n return mod_cmb(n + r - 1, r, mod)\n\n\n# modしたa^bを求める",
"def d_cmb(n, r, mod):\n return mod_cmb(n + r - 1, r, mod)\n\n\n# modしたa^bを求める",
"d_cmb",
"B = map(int, input().split())",
"map(int, input().split())",
"B",
"limit = 2 * 10 ** 5",
"2 * 10 ** 5",
"limit",
"H, W, A, B = map(int, input().split())",
"map(int, input().split())",
"H",
"def mod_cmb(n, r, mod):\n x = fact[n] * fact_inverse[r] % mod\n x = x * fact_inverse[n - r] % mod\n return x",
"def mod_cmb(n, r, mod):\n x = fact[n] * fact_inverse[r] % mod\n x = x * fact_inverse[n - r] % mod\n return x",
"mod_cmb",
"def mod_pow(a, p, mod):\n if p == 0:\n return 1\n elif p % 2 == 1:\n return a * mod_pow(a, p - 1, mod)\n else:\n return (mod_pow(a, p // 2, mod) % mod) ** 2 % mod",
"def mod_pow(a, p, mod):\n if p == 0:\n return 1\n elif p % 2 == 1:\n return a * mod_pow(a, p - 1, mod)\n else:\n return (mod_pow(a, p // 2, mod) % mod) ** 2 % mod",
"mod_pow",
"fact_inverse = [1] * (limit + 1)",
"[1] * (limit + 1)",
"fact_inverse",
"W, A, B = map(int, input().split())",
"map(int, input().split())",
"W",
"ans += d_cmb(n1 - i, r1, MOD) * d_cmb(n2 + i, r2, MOD)",
"d_cmb(n1 - i, r1, MOD) * d_cmb(n2 + i, r2, MOD)",
"ans"
] | H, W, A, B = map(int, input().split())
MOD = 10 ** 9 + 7
limit = 2 * 10 ** 5
# modしながらコンビネーションを求める
def mod_cmb(n, r, mod):
x = fact[n] * fact_inverse[r] % mod
x = x * fact_inverse[n - r] % mod
return x
def d_cmb(n, r, mod):
return mod_cmb(n + r - 1, r, mod)
# modしたa^bを求める
def mod_pow(a, p, mod):
if p == 0:
return 1
elif p % 2 == 1:
return a * mod_pow(a, p - 1, mod)
else:
return (mod_pow(a, p // 2, mod) % mod) ** 2 % mod
fact = [1] * (limit + 1)
fact_inverse = [1] * (limit + 1)
for i in range(1, limit + 1):
fact[i] = fact[i - 1] * i % MOD
fact_inverse[limit] = mod_pow(fact[limit], MOD - 2, MOD)
for i in reversed(range(1, limit + 1)):
fact_inverse[i - 1] = fact_inverse[i] * i % MOD
n1 = W
r1 = H - A - 1
n2 = 1
r2 = A - 1
ans = 0
for i in range(W - B):
ans += d_cmb(n1 - i, r1, MOD) * d_cmb(n2 + i, r2, MOD)
ans %= MOD
print(ans) |
[
7,
15,
13,
18,
18,
13,
13,
13,
0,
13,
2,
2,
17,
17,
17,
6,
13,
12,
13,
23,
13,
23,
13,
17,
12,
13,
23,
13,
12,
13,
23,
13,
23,
13,
12,
13,
23,
13,
23,
13,
12,
13,
23,
13,
23,
13,
12,
13,
23,
13,
23,
13,
12,
13,
23,
13,
23,
13,
0,
13,
13,
0,
13,
13,
12,
13,
23,
13,
23,
13,
12,
13,
23,
13,
23,
13,
12,
13,
23,
13,
23,
13,
12,
13,
23,
13,
23,
13,
12,
13,
23,
13,
23,
13,
12,
13,
23,
13,
23,
13,
12,
13,
23,
13,
23,
13,
12,
13,
23,
13,
13,
6,
13,
12,
13,
0,
18,
13,
13,
17,
0,
18,
13,
13,
39,
4,
13,
17,
0,
18,
13,
13,
39,
4,
13,
17,
4,
18,
13,
13,
13,
23,
13,
23,
13,
12,
13,
23,
13,
23,
13,
23,
13,
12,
13,
23,
13,
23,
13,
23,
13,
12,
13,
23,
13,
23,
13,
23,
13,
12,
13,
14,
40,
13,
18,
13,
13,
0,
18,
13,
13,
2,
39,
4,
13,
17,
2,
13,
18,
13,
13,
0,
18,
13,
13,
2,
39,
4,
13,
17,
2,
13,
18,
13,
13,
28,
13,
4,
13,
2,
18,
13,
13,
17,
2,
13,
17,
0,
18,
18,
13,
13,
13,
2,
18,
18,
13,
13,
2,
13,
17,
13,
0,
18,
18,
13,
13,
13,
2,
18,
18,
13,
13,
2,
13,
17,
13,
0,
18,
13,
13,
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,
13,
13,
0,
13,
4,
18,
13,
13,
2,
2,
13,
13,
17,
2,
13,
17,
28,
13,
4,
13,
13,
0,
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,
13,
17,
4,
13,
13,
14,
2,
13,
17,
4,
13,
10,
12,
13,
10,
6,
13,
10,
2,
13,
10,
6,
13
] | [
[
344,
9
],
[
20,
20
],
[
23,
22
],
[
27,
27
],
[
31,
31
],
[
33,
33
],
[
37,
37
],
[
39,
39
],
[
43,
43
],
[
45,
45
],
[
49,
49
],
[
51,
51
],
[
55,
55
],
[
57,
57
],
[
60,
59
],
[
29,
60
],
[
63,
62
],
[
41,
63
],
[
67,
67
],
[
69,
69
],
[
73,
73
],
[
75,
75
],
[
79,
79
],
[
81,
81
],
[
85,
85
],
[
87,
87
],
[
91,
91
],
[
93,
93
],
[
97,
97
],
[
99,
99
],
[
103,
103
],
[
105,
105
],
[
109,
109
],
[
119,
116
],
[
142,
117
],
[
144,
118
],
[
124,
121
],
[
142,
122
],
[
132,
129
],
[
142,
130
],
[
142,
138
],
[
144,
140
],
[
142,
142
],
[
144,
144
],
[
148,
148
],
[
150,
150
],
[
152,
152
],
[
156,
156
],
[
158,
158
],
[
160,
160
],
[
164,
164
],
[
166,
166
],
[
168,
168
],
[
255,
173
],
[
253,
175
],
[
255,
176
],
[
181,
178
],
[
253,
179
],
[
255,
187
],
[
253,
189
],
[
255,
190
],
[
195,
192
],
[
253,
193
],
[
255,
201
],
[
253,
203
],
[
255,
204
],
[
207,
206
],
[
253,
211
],
[
255,
212
],
[
255,
215
],
[
223,
218
],
[
178,
219
],
[
253,
220
],
[
206,
222
],
[
178,
225
],
[
253,
226
],
[
206,
229
],
[
206,
231
],
[
238,
233
],
[
192,
234
],
[
253,
235
],
[
206,
237
],
[
192,
240
],
[
253,
241
],
[
206,
244
],
[
206,
246
],
[
251,
248
],
[
253,
249
],
[
255,
250
],
[
255,
251
],
[
253,
253
],
[
255,
255
],
[
260,
259
],
[
260,
268
],
[
260,
269
],
[
260,
270
],
[
273,
272
],
[
259,
276
],
[
154,
276
],
[
268,
277
],
[
280,
279
],
[
272,
282
],
[
146,
282
],
[
272,
283
],
[
146,
283
],
[
259,
286
],
[
154,
286
],
[
268,
287
],
[
259,
290
],
[
154,
290
],
[
294,
293
],
[
270,
296
],
[
299,
298
],
[
272,
302
],
[
146,
302
],
[
272,
303
],
[
146,
303
],
[
259,
307
],
[
154,
307
],
[
269,
308
],
[
293,
310
],
[
293,
311
],
[
272,
314
],
[
146,
314
],
[
272,
315
],
[
146,
315
],
[
269,
320
],
[
268,
322
],
[
293,
323
],
[
269,
326
],
[
298,
330
],
[
279,
330
],
[
339,
336
],
[
344,
345
]
] | [
"import sys\nsys.stdin.readline\n\nMOD=10**9+7\nclass Fp(int):\n def __new__(self,x=0):return super().__new__(self,x%MOD)\n def inv(self):return self.__class__(super().__pow__(MOD-2,MOD))\n def __add__(self,value):return self.__class__(super().__add__(value))\n def __sub__(self,value):return self.__class__(super().__sub__(value))\n def __mul__(self,value):return self.__class__(super().__mul__(value))\n def __floordiv__(self,value):return self.__class__(self*self.__class__(value).inv())\n def __pow__(self,value):return self.__class__(super().__pow__(value%(MOD-1), MOD))\n __radd__=__add__\n __rmul__=__mul__\n def __rsub__(self,value):return self.__class__(-super().__sub__(value))\n def __rfloordiv__(self,value):return self.__class__(self.inv()*value)\n def __iadd__(self,value):self=self+value;return self\n def __isub__(self,value):self=self-value;return self\n def __imul__(self,value):self=self*value;return self\n def __ifloordiv__(self,value):self=self//value;return self\n def __ipow__(self,value):self=self**value;return self\n def __neg__(self):return self.__class__(super().__neg__())\n\nclass Combination:\n def __init__(self,max_n):\n self.max_n=0\n self.fact=[Fp(1)]\n self.ifact=[Fp(1)]\n self.make_fact_list(max_n)\n def C(self,n,k):return self.fact[n]*self.ifact[k]*self.ifact[n-k] if 0<=k<=n else 0\n def H(self,n,k):return self.C(n+k-1,k) if n or k else 1\n def P(self,n,k):return self.fact[n]*self.ifact[n-k] if 0<=k<=n else 0\n def make_fact_list(self,max_n):\n if max_n<=self.max_n: return\n self.fact+=[Fp(0)]*(max_n-self.max_n)\n self.ifact+=[Fp(0)]*(max_n-self.max_n)\n for i in range(self.max_n+1,max_n+1):\n self.fact[i]=self.fact[i-1]*i\n self.ifact[i]=self.ifact[i-1]//i\n self.max_n=max_n\n\ndef main():\n H, W, A, B = map(int, input().split())\n C = Combination(H+W)\n ans = C.C(H+W-2, H-1)\n for b in range(B):\n ans -= C.C(H-A-1+b, b) * C.C(A-1+W-b-1, A-1)\n print(ans)\n\n\nif __name__ == \"__main__\":\n main()",
"import sys",
"sys",
"sys.stdin.readline",
"sys.stdin",
"sys",
"stdin",
"readline",
"MOD=10**9+7",
"MOD",
"10**9+7",
"10**9",
"10",
"9",
"7",
"class Fp(int):\n def __new__(self,x=0):return super().__new__(self,x%MOD)\n def inv(self):return self.__class__(super().__pow__(MOD-2,MOD))\n def __add__(self,value):return self.__class__(super().__add__(value))\n def __sub__(self,value):return self.__class__(super().__sub__(value))\n def __mul__(self,value):return self.__class__(super().__mul__(value))\n def __floordiv__(self,value):return self.__class__(self*self.__class__(value).inv())\n def __pow__(self,value):return self.__class__(super().__pow__(value%(MOD-1), MOD))\n __radd__=__add__\n __rmul__=__mul__\n def __rsub__(self,value):return self.__class__(-super().__sub__(value))\n def __rfloordiv__(self,value):return self.__class__(self.inv()*value)\n def __iadd__(self,value):self=self+value;return self\n def __isub__(self,value):self=self-value;return self\n def __imul__(self,value):self=self*value;return self\n def __ifloordiv__(self,value):self=self//value;return self\n def __ipow__(self,value):self=self**value;return self\n def __neg__(self):return self.__class__(super().__neg__())",
"Fp",
"def __new__(self,x=0):return super().__new__(self,x%MOD)\n ",
"__new__",
"self",
"self",
"x=0",
"x",
"0",
"def inv(self):return self.__class__(super().__pow__(MOD-2,MOD))\n ",
"inv",
"self",
"self",
"def __add__(self,value):return self.__class__(super().__add__(value))\n ",
"__add__",
"self",
"self",
"value",
"value",
"def __sub__(self,value):return self.__class__(super().__sub__(value))\n ",
"__sub__",
"self",
"self",
"value",
"value",
"def __mul__(self,value):return self.__class__(super().__mul__(value))\n ",
"__mul__",
"self",
"self",
"value",
"value",
"def __floordiv__(self,value):return self.__class__(self*self.__class__(value).inv())\n ",
"__floordiv__",
"self",
"self",
"value",
"value",
"def __pow__(self,value):return self.__class__(super().__pow__(value%(MOD-1), MOD))\n ",
"__pow__",
"self",
"self",
"value",
"value",
"__radd__=__add__",
"__radd__",
"__add__",
"__rmul__=__mul__",
"__rmul__",
"__mul__",
"def __rsub__(self,value):return self.__class__(-super().__sub__(value))\n ",
"__rsub__",
"self",
"self",
"value",
"value",
"def __rfloordiv__(self,value):return self.__class__(self.inv()*value)\n ",
"__rfloordiv__",
"self",
"self",
"value",
"value",
"def __iadd__(self,value):self=self+value;return self\n ",
"__iadd__",
"self",
"self",
"value",
"value",
"def __isub__(self,value):self=self-value;return self\n ",
"__isub__",
"self",
"self",
"value",
"value",
"def __imul__(self,value):self=self*value;return self\n ",
"__imul__",
"self",
"self",
"value",
"value",
"def __ifloordiv__(self,value):self=self//value;return self\n ",
"__ifloordiv__",
"self",
"self",
"value",
"value",
"def __ipow__(self,value):self=self**value;return self\n ",
"__ipow__",
"self",
"self",
"value",
"value",
"def __neg__(self):return self.__class__(super().__neg_",
"__neg__",
"self",
"self",
"int",
"class Combination:\n def __init__(self,max_n):\n self.max_n=0\n self.fact=[Fp(1)]\n self.ifact=[Fp(1)]\n self.make_fact_list(max_n)\n def C(self,n,k):return self.fact[n]*self.ifact[k]*self.ifact[n-k] if 0<=k<=n else 0\n def H(self,n,k):return self.C(n+k-1,k) if n or k else 1\n def P(self,n,k):return self.fact[n]*self.ifact[n-k] if 0<=k<=n else 0\n def make_fact_list(self,max_n):\n if max_n<=self.max_n: return\n self.fact+=[Fp(0)]*(max_n-self.max_n)\n self.ifact+=[Fp(0)]*(max_n-self.max_n)\n for i in range(self.max_n+1,max_n+1):\n self.fact[i]=self.fact[i-1]*i\n self.ifact[i]=self.ifact[i-1]//i\n self.max_n=max_n",
"Combination",
"def __init__(self,max_n):\n self.max_n=0\n self.fact=[Fp(1)]\n self.ifact=[Fp(1)]\n self.make_fact_list(max_n)\n ",
"__init__",
"self.max_n=0",
"self.max_n",
"self",
"max_n",
"0",
"self.fact=[Fp(1)]",
"self.fact",
"self",
"fact",
"[Fp(1)]",
"Fp(1)",
"Fp",
"1",
"self.ifact=[Fp(1)]",
"self.ifact",
"self",
"ifact",
"[Fp(1)]",
"Fp(1)",
"Fp",
"1",
"self.make_fact_list(max_n)",
"self.make_fact_list",
"self",
"make_fact_list",
"max_n",
"self",
"self",
"max_n",
"max_n",
"def C(self,n,k):return self.fact[n]*self.ifact[k]*self.ifact[n-k] if 0<=k<=n else 0\n ",
"C",
"self",
"self",
"n",
"n",
"k",
"k",
"def H(self,n,k):return self.C(n+k-1,k) if n or k else 1\n ",
"H",
"self",
"self",
"n",
"n",
"k",
"k",
"def P(self,n,k):return self.fact[n]*self.ifact[n-k] if 0<=k<=n else 0\n ",
"P",
"self",
"self",
"n",
"n",
"k",
"k",
"def make_fact_list(self,max_n):\n if max_n<=self.max_n: return\n self.fact+=[Fp(0)]*(max_n-self.max_n)\n self.ifact+=[Fp(0)]*(max_n-self.max_n)\n for i in range(self.max_n+1,max_n+1):\n self.fact[i]=self.fact[i-1]*i\n self.ifact[i]=self.ifact[i-1]//i\n self.max_n=max_n",
"make_fact_list",
"if max_n<=self.max_n: return\n ",
"max_n<=self.max_n",
"max_n",
"self.max_n",
"self",
"max_n",
"self.fact+=[Fp(0)]*(max_n-self.max_n)",
"self.fact",
"self",
"fact",
"[Fp(0)]*(max_n-self.max_n)",
"[Fp(0)]",
"Fp(0)",
"Fp",
"0",
"max_n-self.max_n",
"max_n",
"self.max_n",
"self",
"max_n",
"self.ifact+=[Fp(0)]*(max_n-self.max_n)",
"self.ifact",
"self",
"ifact",
"[Fp(0)]*(max_n-self.max_n)",
"[Fp(0)]",
"Fp(0)",
"Fp",
"0",
"max_n-self.max_n",
"max_n",
"self.max_n",
"self",
"max_n",
"for i in range(self.max_n+1,max_n+1):\n self.fact[i]=self.fact[i-1]*i\n self.ifact[i]=self.ifact[i-1]//i\n ",
"i",
"range(self.max_n+1,max_n+1)",
"range",
"self.max_n+1",
"self.max_n",
"self",
"max_n",
"1",
"max_n+1",
"max_n",
"1",
"self.fact[i]=self.fact[i-1]*i",
"self.fact[i]",
"self.fact",
"self",
"fact",
"i",
"self.fact[i-1]*i",
"self.fact[i-1]",
"self.fact",
"self",
"fact",
"i-1",
"i",
"1",
"i",
"self.ifact[i]=self.ifact[i-1]//i",
"self.ifact[i]",
"self.ifact",
"self",
"ifact",
"i",
"self.ifact[i-1]//i",
"self.ifact[i-1]",
"self.ifact",
"self",
"ifact",
"i-1",
"i",
"1",
"i",
"self.max_n=max_n",
"self.max_n",
"self",
"max_n",
"max_n",
"self",
"self",
"max_n",
"max_n",
"def main():\n H, W, A, B = map(int, input().split())\n C = Combination(H+W)\n ans = C.C(H+W-2, H-1)\n for b in range(B):\n ans -= C.C(H-A-1+b, b) * C.C(A-1+W-b-1, A-1)\n print(ans)",
"main",
"H, W, A, B = map(int, input().split())",
"H",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"W",
"A",
"B",
"C = Combination(H+W)",
"C",
"Combination(H+W)",
"Combination",
"H+W",
"H",
"W",
"ans = C.C(H+W-2, H-1)",
"ans",
"C.C(H+W-2, H-1)",
"C.C",
"C",
"C",
"H+W-2",
"H+W",
"H",
"W",
"2",
"H-1",
"H",
"1",
"for b in range(B):\n ans -= C.C(H-A-1+b, b) * C.C(A-1+W-b-1, A-1)\n ",
"b",
"range(B)",
"range",
"B",
"ans -= C.C(H-A-1+b, b) * C.C(A-1+W-b-1, A-1)",
"ans",
"C.C(H-A-1+b, b) * C.C(A-1+W-b-1, A-1)",
"C.C(H-A-1+b, b)",
"C.C",
"C",
"C",
"H-A-1+b",
"H-A-1",
"H-A",
"H",
"A",
"1",
"b",
"b",
"C.C(A-1+W-b-1, A-1)",
"C.C",
"C",
"C",
"A-1+W-b-1",
"A-1+W-b",
"A-1+W",
"A-1",
"A",
"1",
"W",
"b",
"1",
"A-1",
"A",
"1",
"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 C = Combination(H+W)\n ans = C.C(H+W-2, H-1)\n for b in range(B):\n ans -= C.C(H-A-1+b, b) * C.C(A-1+W-b-1, A-1)\n print(ans)",
"def main():\n H, W, A, B = map(int, input().split())\n C = Combination(H+W)\n ans = C.C(H+W-2, H-1)\n for b in range(B):\n ans -= C.C(H-A-1+b, b) * C.C(A-1+W-b-1, A-1)\n print(ans)",
"main",
"class Combination:\n def __init__(self,max_n):\n self.max_n=0\n self.fact=[Fp(1)]\n self.ifact=[Fp(1)]\n self.make_fact_list(max_n)\n def C(self,n,k):return self.fact[n]*self.ifact[k]*self.ifact[n-k] if 0<=k<=n else 0\n def H(self,n,k):return self.C(n+k-1,k) if n or k else 1\n def P(self,n,k):return self.fact[n]*self.ifact[n-k] if 0<=k<=n else 0\n def make_fact_list(self,max_n):\n if max_n<=self.max_n: return\n self.fact+=[Fp(0)]*(max_n-self.max_n)\n self.ifact+=[Fp(0)]*(max_n-self.max_n)\n for i in range(self.max_n+1,max_n+1):\n self.fact[i]=self.fact[i-1]*i\n self.ifact[i]=self.ifact[i-1]//i\n self.max_n=max_n",
"class Combination:\n def __init__(self,max_n):\n self.max_n=0\n self.fact=[Fp(1)]\n self.ifact=[Fp(1)]\n self.make_fact_list(max_n)\n def C(self,n,k):return self.fact[n]*self.ifact[k]*self.ifact[n-k] if 0<=k<=n else 0\n def H(self,n,k):return self.C(n+k-1,k) if n or k else 1\n def P(self,n,k):return self.fact[n]*self.ifact[n-k] if 0<=k<=n else 0\n def make_fact_list(self,max_n):\n if max_n<=self.max_n: return\n self.fact+=[Fp(0)]*(max_n-self.max_n)\n self.ifact+=[Fp(0)]*(max_n-self.max_n)\n for i in range(self.max_n+1,max_n+1):\n self.fact[i]=self.fact[i-1]*i\n self.ifact[i]=self.ifact[i-1]//i\n self.max_n=max_n",
"Combination",
"MOD=10**9+7",
"10**9+7",
"MOD",
"class Fp(int):\n def __new__(self,x=0):return super().__new__(self,x%MOD)\n def inv(self):return self.__class__(super().__pow__(MOD-2,MOD))\n def __add__(self,value):return self.__class__(super().__add__(value))\n def __sub__(self,value):return self.__class__(super().__sub__(value))\n def __mul__(self,value):return self.__class__(super().__mul__(value))\n def __floordiv__(self,value):return self.__class__(self*self.__class__(value).inv())\n def __pow__(self,value):return self.__class__(super().__pow__(value%(MOD-1), MOD))\n __radd__=__add__\n __rmul__=__mul__\n def __rsub__(self,value):return self.__class__(-super().__sub__(value))\n def __rfloordiv__(self,value):return self.__class__(self.inv()*value)\n def __iadd__(self,value):self=self+value;return self\n def __isub__(self,value):self=self-value;return self\n def __imul__(self,value):self=self*value;return self\n def __ifloordiv__(self,value):self=self//value;return self\n def __ipow__(self,value):self=self**value;return self\n def __neg__(self):return self.__class__(super().__neg__())",
"class Fp(int):\n def __new__(self,x=0):return super().__new__(self,x%MOD)\n def inv(self):return self.__class__(super().__pow__(MOD-2,MOD))\n def __add__(self,value):return self.__class__(super().__add__(value))\n def __sub__(self,value):return self.__class__(super().__sub__(value))\n def __mul__(self,value):return self.__class__(super().__mul__(value))\n def __floordiv__(self,value):return self.__class__(self*self.__class__(value).inv())\n def __pow__(self,value):return self.__class__(super().__pow__(value%(MOD-1), MOD))\n __radd__=__add__\n __rmul__=__mul__\n def __rsub__(self,value):return self.__class__(-super().__sub__(value))\n def __rfloordiv__(self,value):return self.__class__(self.inv()*value)\n def __iadd__(self,value):self=self+value;return self\n def __isub__(self,value):self=self-value;return self\n def __imul__(self,value):self=self*value;return self\n def __ifloordiv__(self,value):self=self//value;return self\n def __ipow__(self,value):self=self**value;return self\n def __neg__(self):return self.__class__(super().__neg__())",
"Fp"
] | import sys
sys.stdin.readline
MOD=10**9+7
class Fp(int):
def __new__(self,x=0):return super().__new__(self,x%MOD)
def inv(self):return self.__class__(super().__pow__(MOD-2,MOD))
def __add__(self,value):return self.__class__(super().__add__(value))
def __sub__(self,value):return self.__class__(super().__sub__(value))
def __mul__(self,value):return self.__class__(super().__mul__(value))
def __floordiv__(self,value):return self.__class__(self*self.__class__(value).inv())
def __pow__(self,value):return self.__class__(super().__pow__(value%(MOD-1), MOD))
__radd__=__add__
__rmul__=__mul__
def __rsub__(self,value):return self.__class__(-super().__sub__(value))
def __rfloordiv__(self,value):return self.__class__(self.inv()*value)
def __iadd__(self,value):self=self+value;return self
def __isub__(self,value):self=self-value;return self
def __imul__(self,value):self=self*value;return self
def __ifloordiv__(self,value):self=self//value;return self
def __ipow__(self,value):self=self**value;return self
def __neg__(self):return self.__class__(super().__neg__())
class Combination:
def __init__(self,max_n):
self.max_n=0
self.fact=[Fp(1)]
self.ifact=[Fp(1)]
self.make_fact_list(max_n)
def C(self,n,k):return self.fact[n]*self.ifact[k]*self.ifact[n-k] if 0<=k<=n else 0
def H(self,n,k):return self.C(n+k-1,k) if n or k else 1
def P(self,n,k):return self.fact[n]*self.ifact[n-k] if 0<=k<=n else 0
def make_fact_list(self,max_n):
if max_n<=self.max_n: return
self.fact+=[Fp(0)]*(max_n-self.max_n)
self.ifact+=[Fp(0)]*(max_n-self.max_n)
for i in range(self.max_n+1,max_n+1):
self.fact[i]=self.fact[i-1]*i
self.ifact[i]=self.ifact[i-1]//i
self.max_n=max_n
def main():
H, W, A, B = map(int, input().split())
C = Combination(H+W)
ans = C.C(H+W-2, H-1)
for b in range(B):
ans -= C.C(H-A-1+b, b) * C.C(A-1+W-b-1, A-1)
print(ans)
if __name__ == "__main__":
main() |
[
7,
12,
13,
0,
13,
39,
17,
17,
28,
13,
4,
13,
17,
2,
13,
17,
4,
18,
13,
13,
2,
13,
2,
2,
2,
13,
13,
18,
13,
2,
13,
13,
13,
29,
13,
23,
13,
23,
13,
12,
13,
0,
13,
39,
17,
17,
0,
13,
17,
28,
13,
4,
13,
17,
2,
13,
17,
0,
13,
2,
2,
13,
13,
13,
4,
18,
13,
13,
13,
29,
13,
23,
13,
23,
13,
12,
13,
0,
13,
39,
17,
17,
28,
13,
4,
13,
17,
2,
13,
17,
4,
18,
13,
13,
2,
2,
18,
13,
2,
13,
17,
18,
13,
13,
13,
29,
13,
23,
13,
23,
13,
23,
13,
12,
13,
14,
40,
2,
40,
17,
13,
40,
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,
23,
13,
23,
13,
23,
13,
0,
13,
2,
2,
17,
17,
17,
0,
13,
2,
2,
17,
2,
17,
17,
17,
0,
13,
4,
13,
13,
4,
18,
4,
13,
13,
13,
13,
13,
0,
13,
4,
13,
13,
13,
0,
13,
4,
13,
13,
13,
0,
13,
4,
13,
13,
13,
13,
0,
13,
17,
28,
13,
4,
13,
2,
13,
13,
0,
13,
2,
4,
13,
2,
13,
2,
13,
17,
13,
13,
13,
13,
4,
13,
2,
2,
2,
13,
13,
17,
2,
2,
13,
13,
17,
2,
2,
13,
13,
17,
13,
13,
13,
0,
13,
2,
2,
13,
13,
13,
4,
13,
13,
10,
12,
13,
10,
2,
13,
10,
4,
13,
10,
12,
13,
10,
2,
13,
10,
4,
13,
10,
17,
13,
10,
4,
13,
10,
4,
13,
10,
12,
13,
10,
4,
13,
10,
2,
13,
10,
4,
13,
10,
2,
13,
10,
12,
13,
10,
4,
13
] | [
[
5,
4
],
[
10,
9
],
[
36,
14
],
[
4,
18
],
[
38,
21
],
[
38,
25
],
[
9,
26
],
[
4,
28
],
[
38,
30
],
[
9,
31
],
[
38,
32
],
[
4,
34
],
[
36,
36
],
[
38,
38
],
[
43,
42
],
[
48,
47
],
[
51,
50
],
[
72,
55
],
[
59,
58
],
[
47,
61
],
[
58,
61
],
[
50,
62
],
[
74,
63
],
[
42,
66
],
[
58,
68
],
[
47,
68
],
[
42,
70
],
[
72,
72
],
[
74,
74
],
[
79,
78
],
[
84,
83
],
[
108,
88
],
[
78,
92
],
[
78,
97
],
[
83,
99
],
[
110,
102
],
[
83,
103
],
[
112,
104
],
[
78,
106
],
[
108,
108
],
[
110,
110
],
[
112,
112
],
[
147,
120
],
[
147,
122
],
[
145,
123
],
[
151,
132
],
[
145,
133
],
[
153,
135
],
[
147,
136
],
[
149,
137
],
[
153,
139
],
[
145,
141
],
[
147,
142
],
[
149,
143
],
[
145,
145
],
[
147,
147
],
[
149,
149
],
[
151,
151
],
[
153,
153
],
[
291,
155
],
[
261,
162
],
[
288,
171
],
[
288,
180
],
[
288,
181
],
[
288,
182
],
[
303,
184
],
[
301,
186
],
[
262,
187
],
[
292,
188
],
[
294,
190
],
[
286,
192
],
[
262,
193
],
[
292,
194
],
[
279,
196
],
[
259,
198
],
[
262,
199
],
[
304,
200
],
[
292,
201
],
[
276,
203
],
[
207,
206
],
[
283,
210
],
[
274,
211
],
[
297,
213
],
[
268,
216
],
[
206,
218
],
[
289,
220
],
[
206,
222
],
[
292,
223
],
[
295,
224
],
[
280,
225
],
[
268,
227
],
[
283,
231
],
[
206,
232
],
[
265,
236
],
[
289,
237
],
[
265,
241
],
[
289,
242
],
[
292,
244
],
[
295,
245
],
[
280,
246
],
[
270,
248
],
[
277,
251
],
[
271,
251
],
[
298,
252
],
[
292,
253
],
[
271,
256
],
[
277,
256
],
[
261,
262
],
[
288,
265
],
[
270,
271
],
[
288,
274
],
[
276,
277
],
[
279,
280
],
[
288,
283
],
[
288,
289
],
[
291,
292
],
[
294,
295
],
[
297,
298
],
[
303,
304
]
] | [
"# nの逆元のリスト\ndef inv_mod(n:int, mod:int) -> list:\n inv = [0,1]\n for i in range(2,n+1):\n inv.append(mod - ((mod//i)*inv[mod%i]) % mod)\n return inv\n \n# nの階乗のリスト\ndef fact(n:int, mod:int) -> list:\n fac = [1,1]\n res = 1\n for i in range(2,n+1):\n res = res*i%mod\n fac.append(res)\n return fac\n\n# nの階乗の逆元のリスト\ndef fact_inv(n:int, inv:list, mod:int) -> list:\n facInv = [1,1]\n for i in range(2,n+1):\n facInv.append(facInv[i-1]*inv[i] % mod)\n return facInv\n \n# 二項係数\ndef nCr(n:int, r:int, mod:int, fac:list, facInv:list) -> int:\n if not (0<=r and r<=n):\n return 0\n \n return ((fac[n]*facInv[r]) % mod) * facInv[n-r] % mod\n\n\n\nMOD = 10**9+7\nn = 2*10**5 + 1\n\nH,W,A,B = map(int, input().split())\n\n# 二項係数の準備\ninv = inv_mod(n,MOD)\nfac = fact(n,MOD)\nfacInv = fact_inv(n,inv,MOD)\n\n# 手前×奥を実行して足していく\nans = 0\nfor h in range(H-A):\n temp = nCr(h+(B-1), h, MOD, fac, facInv) \\\n * nCr((H-h-1)+(W-B-1), W-B-1, MOD, fac, facInv)\n ans = (ans + temp) % MOD\n \nprint(ans)",
"def inv_mod(n:int, mod:int) -> list:\n inv = [0,1]\n for i in range(2,n+1):\n inv.append(mod - ((mod//i)*inv[mod%i]) % mod)\n return inv\n \n# nの階乗のリスト",
"inv_mod",
"inv = [0,1]",
"inv",
"[0,1]",
"0",
"1",
"for i in range(2,n+1):\n inv.append(mod - ((mod//i)*inv[mod%i]) % mod)\n ",
"i",
"range(2,n+1)",
"range",
"2",
"n+1",
"n",
"1",
"inv.append(mod - ((mod//i)*inv[mod%i]) % mod)",
"inv.append",
"inv",
"append",
"mod - ((mod//i)*inv[mod%i]) % mod",
"mod",
"((mod//i)*inv[mod%i]) % mod",
"(mod//i)*inv[mod%i]",
"mod//i",
"mod",
"i",
"inv[mod%i]",
"inv",
"mod%i",
"mod",
"i",
"mod",
"return inv",
"inv",
"n:int",
"n",
"mod:int",
"mod",
"def fact(n:int, mod:int) -> list:\n fac = [1,1]\n res = 1\n for i in range(2,n+1):\n res = res*i%mod\n fac.append(res)\n return fac\n\n# nの階乗の逆元のリスト",
"fact",
"fac = [1,1]",
"fac",
"[1,1]",
"1",
"1",
"res = 1",
"res",
"1",
"for i in range(2,n+1):\n res = res*i%mod\n fac.append(res)\n ",
"i",
"range(2,n+1)",
"range",
"2",
"n+1",
"n",
"1",
"res = res*i%mod",
"res",
"res*i%mod",
"res*i",
"res",
"i",
"mod",
"fac.append(res)",
"fac.append",
"fac",
"append",
"res",
"return fac",
"fac",
"n:int",
"n",
"mod:int",
"mod",
"def fact_inv(n:int, inv:list, mod:int) -> list:\n facInv = [1,1]\n for i in range(2,n+1):\n facInv.append(facInv[i-1]*inv[i] % mod)\n return facInv\n \n# 二項係数",
"fact_inv",
"facInv = [1,1]",
"facInv",
"[1,1]",
"1",
"1",
"for i in range(2,n+1):\n facInv.append(facInv[i-1]*inv[i] % mod)\n ",
"i",
"range(2,n+1)",
"range",
"2",
"n+1",
"n",
"1",
"facInv.append(facInv[i-1]*inv[i] % mod)",
"facInv.append",
"facInv",
"append",
"facInv[i-1]*inv[i] % mod",
"facInv[i-1]*inv[i]",
"facInv[i-1]",
"facInv",
"i-1",
"i",
"1",
"inv[i]",
"inv",
"i",
"mod",
"return facInv",
"facInv",
"n:int",
"n",
"inv:list",
"inv",
"mod:int",
"mod",
"def nCr(n:int, r:int, mod:int, fac:list, facInv:list) -> int:\n if not (0<=r and r<=n):\n return 0\n \n return ((fac[n]*facInv[r]) % mod) * facInv[n-r] % mod",
"nCr",
"if not (0<=r and r<=n):\n return 0\n \n ",
"not (0<=r and r<=n)",
"0<=r and r<=n",
"0<=r",
"0",
"r",
"r<=n",
"r",
"n",
"return 0",
"0",
"return ((fac[n]*facInv[r]) % mod) * facInv[n-r] % mod",
"((fac[n]*facInv[r]) % mod) * facInv[n-r] % mod",
"((fac[n]*facInv[r]) % mod) * facInv[n-r]",
"(fac[n]*facInv[r]) % mod",
"fac[n]*facInv[r]",
"fac[n]",
"fac",
"n",
"facInv[r]",
"facInv",
"r",
"mod",
"facInv[n-r]",
"facInv",
"n-r",
"n",
"r",
"mod",
"n:int",
"n",
"r:int",
"r",
"mod:int",
"mod",
"fac:list",
"fac",
"facInv:list",
"facInv",
"MOD = 10**9+7",
"MOD",
"10**9+7",
"10**9",
"10",
"9",
"7",
"n = 2*10**5 + 1",
"n",
"2*10**5 + 1",
"2*10**5",
"2",
"10**5",
"10",
"5",
"1",
"H,W,A,B = map(int, input().split())",
"H",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"W",
"A",
"B",
"inv = inv_mod(n,MOD)",
"inv",
"inv_mod(n,MOD)",
"inv_mod",
"n",
"MOD",
"fac = fact(n,MOD)",
"fac",
"fact(n,MOD)",
"fact",
"n",
"MOD",
"facInv = fact_inv(n,inv,MOD)",
"facInv",
"fact_inv(n,inv,MOD)",
"fact_inv",
"n",
"inv",
"MOD",
"ans = 0",
"ans",
"0",
"for h in range(H-A):\n temp = nCr(h+(B-1), h, MOD, fac, facInv) \\\n * nCr((H-h-1)+(W-B-1), W-B-1, MOD, fac, facInv)\n ans = (ans + temp) % MOD\n ",
"h",
"range(H-A)",
"range",
"H-A",
"H",
"A",
"temp = nCr(h+(B-1), h, MOD, fac, facInv) \\\n * nCr((H-h-1)+(W-B-1), W-B-1, MOD, fac, facInv)",
"temp",
"nCr(h+(B-1), h, MOD, fac, facInv) \\\n * nCr((H-h-1)+(W-B-1), W-B-1, MOD, fac, facInv)",
"nCr(h+(B-1), h, MOD, fac, facInv)",
"nCr",
"h+(B-1)",
"h",
"B-1",
"B",
"1",
"h",
"MOD",
"fac",
"facInv",
"nCr((H-h-1)+(W-B-1), W-B-1, MOD, fac, facInv)",
"nCr",
"(H-h-1)+(W-B-1)",
"H-h-1",
"H-h",
"H",
"h",
"1",
"W-B-1",
"W-B",
"W",
"B",
"1",
"W-B-1",
"W-B",
"W",
"B",
"1",
"MOD",
"fac",
"facInv",
"ans = (ans + temp) % MOD",
"ans",
"(ans + temp) % MOD",
"ans + temp",
"ans",
"temp",
"MOD",
"print(ans)",
"print",
"ans",
"def fact_inv(n:int, inv:list, mod:int) -> list:\n facInv = [1,1]\n for i in range(2,n+1):\n facInv.append(facInv[i-1]*inv[i] % mod)\n return facInv\n \n# 二項係数",
"def fact_inv(n:int, inv:list, mod:int) -> list:\n facInv = [1,1]\n for i in range(2,n+1):\n facInv.append(facInv[i-1]*inv[i] % mod)\n return facInv\n \n# 二項係数",
"fact_inv",
"n = 2*10**5 + 1",
"2*10**5 + 1",
"n",
"W,A,B = map(int, input().split())",
"map(int, input().split())",
"W",
"def nCr(n:int, r:int, mod:int, fac:list, facInv:list) -> int:\n if not (0<=r and r<=n):\n return 0\n \n return ((fac[n]*facInv[r]) % mod) * facInv[n-r] % mod",
"def nCr(n:int, r:int, mod:int, fac:list, facInv:list) -> int:\n if not (0<=r and r<=n):\n return 0\n \n return ((fac[n]*facInv[r]) % mod) * facInv[n-r] % mod",
"nCr",
"ans = (ans + temp) % MOD",
"(ans + temp) % MOD",
"ans",
"A,B = map(int, input().split())",
"map(int, input().split())",
"A",
"ans = 0",
"0",
"ans",
"facInv = fact_inv(n,inv,MOD)",
"fact_inv(n,inv,MOD)",
"facInv",
"H,W,A,B = map(int, input().split())",
"map(int, input().split())",
"H",
"def fact(n:int, mod:int) -> list:\n fac = [1,1]\n res = 1\n for i in range(2,n+1):\n res = res*i%mod\n fac.append(res)\n return fac\n\n# nの階乗の逆元のリスト",
"def fact(n:int, mod:int) -> list:\n fac = [1,1]\n res = 1\n for i in range(2,n+1):\n res = res*i%mod\n fac.append(res)\n return fac\n\n# nの階乗の逆元のリスト",
"fact",
"B = map(int, input().split())",
"map(int, input().split())",
"B",
"MOD = 10**9+7",
"10**9+7",
"MOD",
"fac = fact(n,MOD)",
"fact(n,MOD)",
"fac",
"temp = nCr(h+(B-1), h, MOD, fac, facInv) \\\n * nCr((H-h-1)+(W-B-1), W-B-1, MOD, fac, facInv)",
"nCr(h+(B-1), h, MOD, fac, facInv) \\\n * nCr((H-h-1)+(W-B-1), W-B-1, MOD, fac, facInv)",
"temp",
"def inv_mod(n:int, mod:int) -> list:\n inv = [0,1]\n for i in range(2,n+1):\n inv.append(mod - ((mod//i)*inv[mod%i]) % mod)\n return inv\n \n# nの階乗のリスト",
"def inv_mod(n:int, mod:int) -> list:\n inv = [0,1]\n for i in range(2,n+1):\n inv.append(mod - ((mod//i)*inv[mod%i]) % mod)\n return inv\n \n# nの階乗のリスト",
"inv_mod",
"inv = inv_mod(n,MOD)",
"inv_mod(n,MOD)",
"inv"
] | # nの逆元のリスト
def inv_mod(n:int, mod:int) -> list:
inv = [0,1]
for i in range(2,n+1):
inv.append(mod - ((mod//i)*inv[mod%i]) % mod)
return inv
# nの階乗のリスト
def fact(n:int, mod:int) -> list:
fac = [1,1]
res = 1
for i in range(2,n+1):
res = res*i%mod
fac.append(res)
return fac
# nの階乗の逆元のリスト
def fact_inv(n:int, inv:list, mod:int) -> list:
facInv = [1,1]
for i in range(2,n+1):
facInv.append(facInv[i-1]*inv[i] % mod)
return facInv
# 二項係数
def nCr(n:int, r:int, mod:int, fac:list, facInv:list) -> int:
if not (0<=r and r<=n):
return 0
return ((fac[n]*facInv[r]) % mod) * facInv[n-r] % mod
MOD = 10**9+7
n = 2*10**5 + 1
H,W,A,B = map(int, input().split())
# 二項係数の準備
inv = inv_mod(n,MOD)
fac = fact(n,MOD)
facInv = fact_inv(n,inv,MOD)
# 手前×奥を実行して足していく
ans = 0
for h in range(H-A):
temp = nCr(h+(B-1), h, MOD, fac, facInv) \
* nCr((H-h-1)+(W-B-1), W-B-1, MOD, fac, facInv)
ans = (ans + temp) % 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,
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,
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,
13,
17,
13,
4,
13,
2,
2,
2,
2,
13,
17,
13,
13,
17,
2,
2,
13,
13,
17,
13,
4,
13,
2,
13,
13,
10,
4,
13,
10,
2,
13,
10,
4,
13,
10,
2,
13,
10,
17,
13,
10,
2,
13,
10,
4,
13,
10,
12,
13,
10,
4,
13
] | [
[
158,
2
],
[
158,
11
],
[
158,
12
],
[
158,
13
],
[
143,
15
],
[
137,
22
],
[
135,
28
],
[
141,
29
],
[
33,
32
],
[
135,
38
],
[
141,
39
],
[
45,
42
],
[
138,
43
],
[
32,
44
],
[
138,
48
],
[
32,
50
],
[
32,
52
],
[
144,
53
],
[
138,
61
],
[
85,
62
],
[
138,
66
],
[
87,
67
],
[
144,
69
],
[
144,
71
],
[
138,
75
],
[
85,
77
],
[
87,
78
],
[
144,
80
],
[
144,
82
],
[
144,
83
],
[
85,
85
],
[
87,
87
],
[
146,
89
],
[
93,
92
],
[
159,
95
],
[
141,
96
],
[
149,
98
],
[
156,
102
],
[
135,
106
],
[
153,
107
],
[
92,
108
],
[
92,
110
],
[
156,
112
],
[
141,
117
],
[
92,
119
],
[
153,
120
],
[
141,
124
],
[
92,
125
],
[
144,
127
],
[
150,
131
],
[
147,
131
],
[
144,
132
],
[
158,
135
],
[
137,
138
],
[
158,
141
],
[
143,
144
],
[
146,
147
],
[
149,
150
],
[
158,
153
],
[
158,
159
]
] | [
"h,w,a,b=map(int,input().split())\nmod=10**9+7\nfact=[1]*(h+w+1)\nfor i in range(1,h+w+1):\n fact[i]=(fact[i-1]*i)%mod\ndef cmb(a,b):\n return fact[a]*pow(fact[b],mod-2,mod)*pow(fact[a-b],mod-2,mod)%mod\nans=0\nfor i in range(b,w):\n ans+=cmb(h-a+i-1,i)*cmb(w-1-i+a-1,w-i-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",
"fact=[1]*(h+w+1)",
"fact",
"[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",
"def cmb(a,b):\n return fact[a]*pow(fact[b],mod-2,mod)*pow(fact[a-b],mod-2,mod)%mod",
"cmb",
"return fact[a]*pow(fact[b],mod-2,mod)*pow(fact[a-b],mod-2,mod)%mod",
"fact[a]*pow(fact[b],mod-2,mod)*pow(fact[a-b],mod-2,mod)%mod",
"fact[a]*pow(fact[b],mod-2,mod)*pow(fact[a-b],mod-2,mod)",
"fact[a]*pow(fact[b],mod-2,mod)",
"fact[a]",
"fact",
"a",
"pow(fact[b],mod-2,mod)",
"pow",
"fact[b]",
"fact",
"b",
"mod-2",
"mod",
"2",
"mod",
"pow(fact[a-b],mod-2,mod)",
"pow",
"fact[a-b]",
"fact",
"a-b",
"a",
"b",
"mod-2",
"mod",
"2",
"mod",
"mod",
"a",
"a",
"b",
"b",
"ans=0",
"ans",
"0",
"for i in range(b,w):\n ans+=cmb(h-a+i-1,i)*cmb(w-1-i+a-1,w-i-1)%mod",
"i",
"range(b,w)",
"range",
"b",
"w",
"ans+=cmb(h-a+i-1,i)*cmb(w-1-i+a-1,w-i-1)%mod",
"ans",
"cmb(h-a+i-1,i)*cmb(w-1-i+a-1,w-i-1)%mod",
"cmb(h-a+i-1,i)*cmb(w-1-i+a-1,w-i-1)",
"cmb(h-a+i-1,i)",
"cmb",
"h-a+i-1",
"h-a+i",
"h-a",
"h",
"a",
"i",
"1",
"i",
"cmb(w-1-i+a-1,w-i-1)",
"cmb",
"w-1-i+a-1",
"w-1-i+a",
"w-1-i",
"w-1",
"w",
"1",
"i",
"a",
"1",
"w-i-1",
"w-i",
"w",
"i",
"1",
"mod",
"print(ans%mod)",
"print",
"ans%mod",
"ans",
"mod",
"h,w,a,b=map(int,input().split())",
"map(int,input().split())",
"h",
"fact=[1]*(h+w+1)",
"[1]*(h+w+1)",
"fact",
"w,a,b=map(int,input().split())",
"map(int,input().split())",
"w",
"mod=10**9+7",
"10**9+7",
"mod",
"ans=0",
"0",
"ans",
"ans+=cmb(h-a+i-1,i)*cmb(w-1-i+a-1,w-i-1)%mod",
"cmb(h-a+i-1,i)*cmb(w-1-i+a-1,w-i-1)%mod",
"ans",
"a,b=map(int,input().split())",
"map(int,input().split())",
"a",
"def cmb(a,b):\n return fact[a]*pow(fact[b],mod-2,mod)*pow(fact[a-b],mod-2,mod)%mod",
"def cmb(a,b):\n return fact[a]*pow(fact[b],mod-2,mod)*pow(fact[a-b],mod-2,mod)%mod",
"cmb",
"b=map(int,input().split())",
"map(int,input().split())",
"b"
] | h,w,a,b=map(int,input().split())
mod=10**9+7
fact=[1]*(h+w+1)
for i in range(1,h+w+1):
fact[i]=(fact[i-1]*i)%mod
def cmb(a,b):
return fact[a]*pow(fact[b],mod-2,mod)*pow(fact[a-b],mod-2,mod)%mod
ans=0
for i in range(b,w):
ans+=cmb(h-a+i-1,i)*cmb(w-1-i+a-1,w-i-1)%mod
print(ans%mod)
|
[
7,
0,
13,
2,
2,
17,
17,
17,
0,
13,
4,
13,
13,
4,
18,
4,
13,
13,
13,
13,
13,
12,
13,
0,
13,
2,
2,
18,
13,
2,
13,
13,
18,
13,
13,
13,
29,
2,
2,
18,
13,
13,
4,
13,
13,
2,
13,
17,
13,
13,
23,
13,
23,
13,
0,
13,
39,
17,
28,
13,
4,
13,
2,
13,
13,
4,
18,
13,
13,
2,
2,
18,
13,
17,
2,
13,
17,
13,
0,
13,
17,
28,
13,
4,
13,
2,
13,
13,
0,
13,
2,
4,
13,
2,
2,
2,
2,
13,
13,
17,
13,
13,
2,
13,
13,
4,
13,
2,
2,
2,
2,
13,
13,
13,
17,
13,
2,
13,
17,
0,
13,
2,
13,
13,
0,
13,
13,
4,
13,
13,
10,
2,
13,
10,
4,
13,
10,
13,
13,
10,
12,
13,
10,
4,
13,
10,
2,
13,
10,
2,
13,
10,
4,
13,
10,
17,
13,
10,
4,
13,
10,
39,
13
] | [
[
149,
2
],
[
158,
9
],
[
158,
18
],
[
158,
19
],
[
158,
20
],
[
25,
24
],
[
51,
30
],
[
53,
31
],
[
53,
34
],
[
150,
35
],
[
51,
41
],
[
24,
44
],
[
150,
46
],
[
150,
48
],
[
150,
49
],
[
51,
51
],
[
53,
53
],
[
161,
55
],
[
60,
59
],
[
144,
63
],
[
153,
64
],
[
162,
67
],
[
162,
72
],
[
59,
75
],
[
150,
77
],
[
155,
79
],
[
83,
82
],
[
153,
86
],
[
135,
87
],
[
131,
89
],
[
141,
92
],
[
144,
97
],
[
159,
98
],
[
135,
100
],
[
82,
101
],
[
135,
103
],
[
82,
104
],
[
141,
106
],
[
153,
111
],
[
135,
112
],
[
82,
113
],
[
159,
115
],
[
159,
117
],
[
146,
120
],
[
132,
122
],
[
150,
123
],
[
137,
125
],
[
150,
126
],
[
138,
129
],
[
147,
129
],
[
156,
129
],
[
131,
132
],
[
158,
135
],
[
150,
137
],
[
137,
138
],
[
158,
144
],
[
146,
147
],
[
149,
150
],
[
158,
153
],
[
155,
156
],
[
158,
159
],
[
161,
162
]
] | [
"mod=10**9+7\nh,w,a,b=map(int,input().split())\ndef comb(a,b):\n\tp=fac[a-b]*fac[b]%mod\n\treturn fac[a]*pow(p,mod-2,mod)%mod\nfac=[1]\nfor i in range(h+w):\n\tfac.append(fac[-1]*(i+1)%mod)\nans=0\nfor i in range(w-b):\n\tp=comb(h-a-1+b+i,b+i)*comb(w-b-i-2+a,a-1)\n\tans+=p%mod\n\tans%=mod\nprint(ans)",
"mod=10**9+7",
"mod",
"10**9+7",
"10**9",
"10",
"9",
"7",
"h,w,a,b=map(int,input().split())",
"h",
"map(int,input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"w",
"a",
"b",
"def comb(a,b):\n\tp=fac[a-b]*fac[b]%mod\n\treturn fac[a]*pow(p,mod-2,mod)%mod",
"comb",
"p=fac[a-b]*fac[b]%mod",
"p",
"fac[a-b]*fac[b]%mod",
"fac[a-b]*fac[b]",
"fac[a-b]",
"fac",
"a-b",
"a",
"b",
"fac[b]",
"fac",
"b",
"mod",
"return fac[a]*pow(p,mod-2,mod)%mod",
"fac[a]*pow(p,mod-2,mod)%mod",
"fac[a]*pow(p,mod-2,mod)",
"fac[a]",
"fac",
"a",
"pow(p,mod-2,mod)",
"pow",
"p",
"mod-2",
"mod",
"2",
"mod",
"mod",
"a",
"a",
"b",
"b",
"fac=[1]",
"fac",
"[1]",
"1",
"for i in range(h+w):\n\tfac.append(fac[-1]*(i+1)%mod)",
"i",
"range(h+w)",
"range",
"h+w",
"h",
"w",
"fac.append(fac[-1]*(i+1)%mod)",
"fac.append",
"fac",
"append",
"fac[-1]*(i+1)%mod",
"fac[-1]*(i+1)",
"fac[-1]",
"fac",
"-1",
"i+1",
"i",
"1",
"mod",
"ans=0",
"ans",
"0",
"for i in range(w-b):\n\tp=comb(h-a-1+b+i,b+i)*comb(w-b-i-2+a,a-1)\n\tans+=p%mod\n\tans%=mod",
"i",
"range(w-b)",
"range",
"w-b",
"w",
"b",
"p=comb(h-a-1+b+i,b+i)*comb(w-b-i-2+a,a-1)",
"p",
"comb(h-a-1+b+i,b+i)*comb(w-b-i-2+a,a-1)",
"comb(h-a-1+b+i,b+i)",
"comb",
"h-a-1+b+i",
"h-a-1+b",
"h-a-1",
"h-a",
"h",
"a",
"1",
"b",
"i",
"b+i",
"b",
"i",
"comb(w-b-i-2+a,a-1)",
"comb",
"w-b-i-2+a",
"w-b-i-2",
"w-b-i",
"w-b",
"w",
"b",
"i",
"2",
"a",
"a-1",
"a",
"1",
"ans+=p%mod",
"ans",
"p%mod",
"p",
"mod",
"ans%=mod",
"ans",
"mod",
"print(ans)",
"print",
"ans",
"p=comb(h-a-1+b+i,b+i)*comb(w-b-i-2+a,a-1)",
"comb(h-a-1+b+i,b+i)*comb(w-b-i-2+a,a-1)",
"p",
"b=map(int,input().split())",
"map(int,input().split())",
"b",
"ans%=mod",
"mod",
"ans",
"def comb(a,b):\n\tp=fac[a-b]*fac[b]%mod\n\treturn fac[a]*pow(p,mod-2,mod)%mod",
"def comb(a,b):\n\tp=fac[a-b]*fac[b]%mod\n\treturn fac[a]*pow(p,mod-2,mod)%mod",
"comb",
"h,w,a,b=map(int,input().split())",
"map(int,input().split())",
"h",
"ans+=p%mod",
"p%mod",
"ans",
"mod=10**9+7",
"10**9+7",
"mod",
"w,a,b=map(int,input().split())",
"map(int,input().split())",
"w",
"ans=0",
"0",
"ans",
"a,b=map(int,input().split())",
"map(int,input().split())",
"a",
"fac=[1]",
"[1]",
"fac"
] | mod=10**9+7
h,w,a,b=map(int,input().split())
def comb(a,b):
p=fac[a-b]*fac[b]%mod
return fac[a]*pow(p,mod-2,mod)%mod
fac=[1]
for i in range(h+w):
fac.append(fac[-1]*(i+1)%mod)
ans=0
for i in range(w-b):
p=comb(h-a-1+b+i,b+i)*comb(w-b-i-2+a,a-1)
ans+=p%mod
ans%=mod
print(ans) |
[
7,
15,
13,
15,
13,
15,
13,
15,
15,
13,
15,
13,
15,
13,
15,
15,
4,
18,
13,
13,
2,
17,
17,
0,
13,
2,
17,
17,
12,
13,
12,
13,
12,
13,
12,
13,
41,
28,
13,
4,
13,
13,
4,
4,
13,
12,
13,
23,
13,
41,
28,
13,
4,
13,
13,
4,
4,
13,
12,
13,
23,
13,
41,
28,
13,
4,
13,
13,
4,
4,
13,
12,
13,
23,
13,
41,
28,
13,
4,
13,
13,
4,
4,
13,
12,
13,
23,
13,
41,
28,
13,
4,
13,
13,
4,
4,
13,
4,
13,
12,
13,
23,
13,
41,
28,
13,
4,
13,
13,
4,
13,
12,
13,
23,
13,
12,
13,
23,
13,
12,
13,
23,
13,
23,
13,
12,
13,
23,
13,
23,
13,
0,
13,
17,
12,
13,
0,
13,
4,
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,
0,
13,
17,
28,
13,
4,
13,
17,
2,
2,
13,
13,
17,
0,
13,
2,
4,
13,
2,
2,
2,
2,
13,
13,
13,
13,
17,
4,
13,
2,
2,
13,
13,
17,
2,
2,
13,
13,
17,
13,
4,
13,
2,
2,
2,
2,
13,
13,
13,
13,
17,
4,
13,
2,
13,
17,
2,
2,
13,
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,
10,
12,
13,
10,
12,
13,
10,
12,
13,
10,
2,
13,
10,
12,
13,
10,
17,
13,
10,
12,
13,
10,
12,
13
] | [
[
370,
24
],
[
39,
38
],
[
356,
44
],
[
48,
48
],
[
52,
51
],
[
344,
57
],
[
61,
61
],
[
65,
64
],
[
362,
70
],
[
74,
74
],
[
78,
77
],
[
347,
83
],
[
87,
87
],
[
91,
90
],
[
362,
98
],
[
102,
102
],
[
106,
105
],
[
114,
114
],
[
118,
118
],
[
122,
122
],
[
124,
124
],
[
128,
128
],
[
130,
130
],
[
376,
132
],
[
138,
137
],
[
344,
139
],
[
138,
140
],
[
138,
141
],
[
138,
142
],
[
182,
148
],
[
180,
151
],
[
182,
152
],
[
157,
156
],
[
182,
159
],
[
180,
161
],
[
182,
162
],
[
180,
169
],
[
156,
172
],
[
182,
172
],
[
180,
176
],
[
156,
177
],
[
182,
177
],
[
184,
178
],
[
180,
180
],
[
182,
182
],
[
184,
184
],
[
187,
186
],
[
194,
193
],
[
201,
200
],
[
206,
205
],
[
211,
210
],
[
216,
215
],
[
193,
220
],
[
200,
224
],
[
200,
229
],
[
215,
231
],
[
186,
232
],
[
210,
235
],
[
210,
241
],
[
186,
243
],
[
215,
244
],
[
186,
246
],
[
215,
247
],
[
186,
248
],
[
205,
251
],
[
205,
256
],
[
210,
259
],
[
186,
261
],
[
264,
263
],
[
267,
266
],
[
140,
272
],
[
142,
273
],
[
277,
276
],
[
144,
279
],
[
137,
284
],
[
141,
285
],
[
142,
286
],
[
266,
287
],
[
137,
293
],
[
141,
294
],
[
142,
298
],
[
266,
299
],
[
377,
301
],
[
144,
303
],
[
141,
308
],
[
140,
309
],
[
142,
310
],
[
266,
311
],
[
141,
316
],
[
140,
320
],
[
142,
321
],
[
266,
322
],
[
377,
323
],
[
326,
325
],
[
377,
326
],
[
325,
329
],
[
276,
329
],
[
263,
329
],
[
353,
335
],
[
370,
371
],
[
376,
377
]
] | [
"import sys\nimport numpy as np\nimport random\nfrom decimal import Decimal\nimport itertools\nimport re\nimport bisect\nfrom collections import deque, Counter\nfrom functools import lru_cache\n\nsys.setrecursionlimit(10**9)\nINF = 10**13\ndef LI(): return list(map(int, sys.stdin.buffer.readline().split()))\ndef I(): return int(sys.stdin.buffer.readline())\ndef LS(): return sys.stdin.buffer.readline().rstrip().decode('utf-8').split()\ndef S(): return sys.stdin.buffer.readline().rstrip().decode('utf-8')\ndef IR(n): return [I() for i in range(n)]\ndef LIR(n): return [LI() for i in range(n)]\ndef SR(n): return [S() for i in range(n)]\ndef LSR(n): return [LS() for i in range(n)]\ndef SRL(n): return [list(S()) for i in range(n)]\ndef MSRL(n): return [[int(j) for j in list(S())] for i in range(n)]\ndef SERIES(n): return np.fromstring(sys.stdin.buffer.read(), dtype=np.int32, sep=' ')\ndef GRID(h,w): return np.fromstring(sys.stdin.buffer.read(), dtype=np.int32, sep=' ').reshape(h,-1)[:,:w]\ndef GRIDfromString(h,w): return np.frombuffer(sys.stdin.buffer.read(), 'S1').reshape(h,-1)[:,:w]\nMOD = 1000000007\n\n\n\ndef main():\n\th, w, a, b = LI()\n\n\tdef comb(n, r, p):\n\t\tif (r < 0) or (n < r):\n\t\t\treturn 0\n\t\tr = min(r, n - r)\n\t\treturn fact[n] * factinv[r] * factinv[n-r] % p\n\n\n\tp = 10 ** 9 + 7\n\tN = 10 ** 5 * 2\n\tfact = [1, 1]\n\tfactinv = [1, 1]\n\tinv = [0, 1]\n\n\tfor i in range(2, N + 1):\n\t\tfact.append((fact[-1] * i) % p)\n\t\tinv.append((-inv[p % i] * (p // i)) % p)\n\t\tfactinv.append((factinv[-1]) * inv[-1] % p)\n\n\tans = 0\n\tfor i in range(1,w-b+1):\n\t\tans += comb(h-a+b+i-2, max(h-a-1, b+i-1), MOD) * comb(a+w-b-i-1, max(a-1, w-b-i), MOD)\n\t\tans %= MOD\n\tprint(ans)\n\n\nif __name__ == '__main__':\n main()",
"import sys",
"sys",
"import numpy as np",
"numpy",
"import random",
"random",
"from decimal import Decimal",
"import itertools",
"itertools",
"import re",
"re",
"import bisect",
"bisect",
"from collections import deque, Counter",
"from functools import lru_cache",
"sys.setrecursionlimit(10**9)",
"sys.setrecursionlimit",
"sys",
"setrecursionlimit",
"10**9",
"10",
"9",
"INF = 10**13",
"INF",
"10**13",
"10",
"13",
"def LI(): return list(map(int, sys.stdin.buffer.readline().split()))",
"LI",
"def I(): return int(sys.stdin.buffer.readline())",
"I",
"def LS(): return sys.stdin.buffer.readline().rstrip().decode('utf-8').split()",
"LS",
"def S(): return sys.stdin.buffer.readline().rstrip().decode('utf-8')",
"S",
"I() for i in range(n)",
"for i in range(n)",
"i",
"range(n)",
"range",
"n",
"for i in range(n)",
"I()",
"I",
"def IR(n): return [I() for i in range(n)]",
"IR",
"n",
"n",
"LI() for i in range(n)",
"for i in range(n)",
"i",
"range(n)",
"range",
"n",
"for i in range(n)",
"LI()",
"LI",
"def LIR(n): return [LI() for i in range(n)]",
"LIR",
"n",
"n",
"S() for i in range(n)",
"for i in range(n)",
"i",
"range(n)",
"range",
"n",
"for i in range(n)",
"S()",
"S",
"def SR(n): return [S() for i in range(n)]",
"SR",
"n",
"n",
"LS() for i in range(n)",
"for i in range(n)",
"i",
"range(n)",
"range",
"n",
"for i in range(n)",
"LS()",
"LS",
"def LSR(n): return [LS() for i in range(n)]",
"LSR",
"n",
"n",
"list(S()) for i in range(n)",
"for i in range(n)",
"i",
"range(n)",
"range",
"n",
"for i in range(n)",
"list(S())",
"list",
"S()",
"S",
"def SRL(n): return [list(S()) for i in range(n)]",
"SRL",
"n",
"n",
"[int(j) for j in list(S())] for i in range(n)",
"for i in range(n)",
"i",
"range(n)",
"range",
"n",
"for i in range(n)",
"[int(j) for j in list(S())]",
"def MSRL(n): return [[int(j) for j in list(S())] for i in range(n)]",
"MSRL",
"n",
"n",
"def SERIES(n): return np.fromstring(sys.stdin.buffer.read(), dtype=np.int32, sep=' ')",
"SERIES",
"n",
"n",
"def GRID(h,w): return np.fromstring(sys.stdin.buffer.read(), dtype=np.int32, sep=' ').reshape(h,-1)[:,:w]",
"GRID",
"h",
"h",
"w",
"w",
"def GRIDfromString(h,w): return np.frombuffer(sys.stdin.buffer.read(), 'S1').reshape(h,-1)[:,:w]",
"GRIDfromString",
"h",
"h",
"w",
"w",
"MOD = 1000000007",
"MOD",
"1000000007",
"def main():\n\th, w, a, b = LI()\n\n\tdef comb(n, r, p):\n\t\tif (r < 0) or (n < r):\n\t\t\treturn 0\n\t\tr = min(r, n - r)\n\t\treturn fact[n] * factinv[r] * factinv[n-r] % p\n\n\n\tp = 10 ** 9 + 7\n\tN = 10 ** 5 * 2\n\tfact = [1, 1]\n\tfactinv = [1, 1]\n\tinv = [0, 1]\n\n\tfor i in range(2, N + 1):\n\t\tfact.append((fact[-1] * i) % p)\n\t\tinv.append((-inv[p % i] * (p // i)) % p)\n\t\tfactinv.append((factinv[-1]) * inv[-1] % p)\n\n\tans = 0\n\tfor i in range(1,w-b+1):\n\t\tans += comb(h-a+b+i-2, max(h-a-1, b+i-1), MOD) * comb(a+w-b-i-1, max(a-1, w-b-i), MOD)\n\t\tans %= MOD\n\tprint(ans)",
"main",
"h, w, a, b = LI()",
"h",
"LI()",
"LI",
"w",
"a",
"b",
"def comb(n, r, p):\n\t\tif (r < 0) or (n < r):\n\t\t\treturn 0\n\t\tr = min(r, n - r)\n\t\treturn fact[n] * factinv[r] * factinv[n-r] % p\n\n\n\t",
"comb",
"if (r < 0) or (n < r):\n\t\t\treturn 0\n\t\t",
"(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 ** 5 * 2",
"N",
"10 ** 5 * 2",
"10 ** 5",
"10",
"5",
"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\t\tfact.append((fact[-1] * i) % p)\n\t\tinv.append((-inv[p % i] * (p // i)) % p)\n\t\tfactinv.append((factinv[-1]) * inv[-1] % p)\n\n\t",
"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",
"ans = 0",
"ans",
"0",
"for i in range(1,w-b+1):\n\t\tans += comb(h-a+b+i-2, max(h-a-1, b+i-1), MOD) * comb(a+w-b-i-1, max(a-1, w-b-i), MOD)\n\t\tans %= MOD\n\t",
"i",
"range(1,w-b+1)",
"range",
"1",
"w-b+1",
"w-b",
"w",
"b",
"1",
"ans += comb(h-a+b+i-2, max(h-a-1, b+i-1), MOD) * comb(a+w-b-i-1, max(a-1, w-b-i), MOD)",
"ans",
"comb(h-a+b+i-2, max(h-a-1, b+i-1), MOD) * comb(a+w-b-i-1, max(a-1, w-b-i), MOD)",
"comb(h-a+b+i-2, max(h-a-1, b+i-1), MOD)",
"comb",
"h-a+b+i-2",
"h-a+b+i",
"h-a+b",
"h-a",
"h",
"a",
"b",
"i",
"2",
"max(h-a-1, b+i-1)",
"max",
"h-a-1",
"h-a",
"h",
"a",
"1",
"b+i-1",
"b+i",
"b",
"i",
"1",
"MOD",
"comb(a+w-b-i-1, max(a-1, w-b-i), MOD)",
"comb",
"a+w-b-i-1",
"a+w-b-i",
"a+w-b",
"a+w",
"a",
"w",
"b",
"i",
"1",
"max(a-1, w-b-i)",
"max",
"a-1",
"a",
"1",
"w-b-i",
"w-b",
"w",
"b",
"i",
"MOD",
"ans %= MOD",
"ans",
"MOD",
"print(ans)",
"print",
"ans",
"if __name__ == '__main__':\n main()",
"__name__ == '__main__'",
"__name__",
"'__main__'",
"main()",
"main",
"def SERIES(n): return np.fromstring(sys.stdin.buffer.read(), dtype=np.int32, sep=' ')",
"def SERIES(n): return np.fromstring(sys.stdin.buffer.read(), dtype=np.int32, sep=' ')",
"SERIES",
"def GRID(h,w): return np.fromstring(sys.stdin.buffer.read(), dtype=np.int32, sep=' ').reshape(h,-1)[:,:w]",
"def GRID(h,w): return np.fromstring(sys.stdin.buffer.read(), dtype=np.int32, sep=' ').reshape(h,-1)[:,:w]",
"GRID",
"def LI(): return list(map(int, sys.stdin.buffer.readline().split()))",
"def LI(): return list(map(int, sys.stdin.buffer.readline().split()))",
"LI",
"def LS(): return sys.stdin.buffer.readline().rstrip().decode('utf-8').split()",
"def LS(): return sys.stdin.buffer.readline().rstrip().decode('utf-8').split()",
"LS",
"def SR(n): return [S() for i in range(n)]",
"def SR(n): return [S() for i in range(n)]",
"SR",
"def main():\n\th, w, a, b = LI()\n\n\tdef comb(n, r, p):\n\t\tif (r < 0) or (n < r):\n\t\t\treturn 0\n\t\tr = min(r, n - r)\n\t\treturn fact[n] * factinv[r] * factinv[n-r] % p\n\n\n\tp = 10 ** 9 + 7\n\tN = 10 ** 5 * 2\n\tfact = [1, 1]\n\tfactinv = [1, 1]\n\tinv = [0, 1]\n\n\tfor i in range(2, N + 1):\n\t\tfact.append((fact[-1] * i) % p)\n\t\tinv.append((-inv[p % i] * (p // i)) % p)\n\t\tfactinv.append((factinv[-1]) * inv[-1] % p)\n\n\tans = 0\n\tfor i in range(1,w-b+1):\n\t\tans += comb(h-a+b+i-2, max(h-a-1, b+i-1), MOD) * comb(a+w-b-i-1, max(a-1, w-b-i), MOD)\n\t\tans %= MOD\n\tprint(ans)",
"def main():\n\th, w, a, b = LI()\n\n\tdef comb(n, r, p):\n\t\tif (r < 0) or (n < r):\n\t\t\treturn 0\n\t\tr = min(r, n - r)\n\t\treturn fact[n] * factinv[r] * factinv[n-r] % p\n\n\n\tp = 10 ** 9 + 7\n\tN = 10 ** 5 * 2\n\tfact = [1, 1]\n\tfactinv = [1, 1]\n\tinv = [0, 1]\n\n\tfor i in range(2, N + 1):\n\t\tfact.append((fact[-1] * i) % p)\n\t\tinv.append((-inv[p % i] * (p // i)) % p)\n\t\tfactinv.append((factinv[-1]) * inv[-1] % p)\n\n\tans = 0\n\tfor i in range(1,w-b+1):\n\t\tans += comb(h-a+b+i-2, max(h-a-1, b+i-1), MOD) * comb(a+w-b-i-1, max(a-1, w-b-i), MOD)\n\t\tans %= MOD\n\tprint(ans)",
"main",
"def I(): return int(sys.stdin.buffer.readline())",
"def I(): return int(sys.stdin.buffer.readline())",
"I",
"def LIR(n): return [LI() for i in range(n)]",
"def LIR(n): return [LI() for i in range(n)]",
"LIR",
"def S(): return sys.stdin.buffer.readline().rstrip().decode('utf-8')",
"def S(): return sys.stdin.buffer.readline().rstrip().decode('utf-8')",
"S",
"def MSRL(n): return [[int(j) for j in list(S())] for i in range(n)]",
"def MSRL(n): return [[int(j) for j in list(S())] for i in range(n)]",
"MSRL",
"def LSR(n): return [LS() for i in range(n)]",
"def LSR(n): return [LS() for i in range(n)]",
"LSR",
"INF = 10**13",
"10**13",
"INF",
"def SRL(n): return [list(S()) for i in range(n)]",
"def SRL(n): return [list(S()) for i in range(n)]",
"SRL",
"MOD = 1000000007",
"1000000007",
"MOD",
"def IR(n): return [I() for i in range(n)]",
"def IR(n): return [I() for i in range(n)]",
"IR",
"def GRIDfromString(h,w): return np.frombuffer(sys.stdin.buffer.read(), 'S1').reshape(h,-1)[:,:w]",
"def GRIDfromString(h,w): return np.frombuffer(sys.stdin.buffer.read(), 'S1').reshape(h,-1)[:,:w]",
"GRIDfromString"
] | import sys
import numpy as np
import random
from decimal import Decimal
import itertools
import re
import bisect
from collections import deque, Counter
from functools import lru_cache
sys.setrecursionlimit(10**9)
INF = 10**13
def LI(): return list(map(int, sys.stdin.buffer.readline().split()))
def I(): return int(sys.stdin.buffer.readline())
def LS(): return sys.stdin.buffer.readline().rstrip().decode('utf-8').split()
def S(): return sys.stdin.buffer.readline().rstrip().decode('utf-8')
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)]
def SRL(n): return [list(S()) for i in range(n)]
def MSRL(n): return [[int(j) for j in list(S())] for i in range(n)]
def SERIES(n): return np.fromstring(sys.stdin.buffer.read(), dtype=np.int32, sep=' ')
def GRID(h,w): return np.fromstring(sys.stdin.buffer.read(), dtype=np.int32, sep=' ').reshape(h,-1)[:,:w]
def GRIDfromString(h,w): return np.frombuffer(sys.stdin.buffer.read(), 'S1').reshape(h,-1)[:,:w]
MOD = 1000000007
def main():
h, w, a, b = LI()
def comb(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 ** 5 * 2
fact = [1, 1]
factinv = [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)
factinv.append((factinv[-1]) * inv[-1] % p)
ans = 0
for i in range(1,w-b+1):
ans += comb(h-a+b+i-2, max(h-a-1, b+i-1), MOD) * comb(a+w-b-i-1, max(a-1, w-b-i), MOD)
ans %= MOD
print(ans)
if __name__ == '__main__':
main() |
[
7,
12,
13,
0,
13,
39,
17,
17,
28,
13,
4,
13,
17,
2,
13,
17,
4,
18,
13,
13,
2,
13,
2,
2,
2,
13,
13,
18,
13,
2,
13,
13,
13,
29,
13,
23,
13,
23,
13,
12,
13,
0,
13,
39,
17,
17,
0,
13,
17,
28,
13,
4,
13,
17,
2,
13,
17,
0,
13,
2,
2,
13,
13,
13,
4,
18,
13,
13,
13,
29,
13,
23,
13,
23,
13,
12,
13,
0,
13,
39,
17,
17,
28,
13,
4,
13,
17,
2,
13,
17,
4,
18,
13,
13,
2,
2,
18,
13,
2,
13,
17,
18,
13,
13,
13,
29,
13,
23,
13,
23,
13,
23,
13,
12,
13,
14,
2,
2,
13,
17,
2,
13,
17,
29,
17,
14,
40,
2,
40,
17,
13,
40,
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,
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,
13,
13,
13,
0,
13,
4,
13,
2,
13,
13,
13,
0,
13,
4,
13,
2,
13,
13,
13,
13,
0,
13,
39,
28,
13,
4,
13,
2,
13,
13,
4,
18,
13,
13,
39,
13,
2,
13,
17,
0,
13,
17,
28,
13,
13,
13,
0,
13,
2,
2,
13,
2,
4,
13,
2,
13,
13,
13,
13,
13,
13,
4,
13,
2,
2,
2,
2,
13,
13,
13,
13,
17,
2,
2,
13,
13,
17,
13,
13,
13,
13,
4,
13,
13,
10,
4,
13,
10,
39,
13,
10,
17,
13,
10,
4,
13,
10,
12,
13,
10,
12,
13,
10,
4,
13,
10,
4,
13,
10,
4,
13,
10,
4,
13,
10,
2,
13,
10,
4,
13,
10,
12,
13,
10,
2,
13,
10,
12,
13
] | [
[
5,
4
],
[
10,
9
],
[
36,
14
],
[
4,
18
],
[
38,
21
],
[
38,
25
],
[
9,
26
],
[
4,
28
],
[
38,
30
],
[
9,
31
],
[
38,
32
],
[
4,
34
],
[
36,
36
],
[
38,
38
],
[
43,
42
],
[
48,
47
],
[
51,
50
],
[
72,
55
],
[
59,
58
],
[
47,
61
],
[
58,
61
],
[
50,
62
],
[
74,
63
],
[
42,
66
],
[
58,
68
],
[
47,
68
],
[
42,
70
],
[
72,
72
],
[
74,
74
],
[
79,
78
],
[
84,
83
],
[
108,
88
],
[
78,
92
],
[
78,
97
],
[
83,
99
],
[
110,
102
],
[
83,
103
],
[
112,
104
],
[
78,
106
],
[
108,
108
],
[
110,
110
],
[
112,
112
],
[
155,
118
],
[
157,
121
],
[
157,
130
],
[
157,
132
],
[
155,
133
],
[
161,
142
],
[
155,
143
],
[
163,
145
],
[
157,
146
],
[
159,
147
],
[
163,
149
],
[
155,
151
],
[
157,
152
],
[
159,
153
],
[
155,
155
],
[
157,
157
],
[
159,
159
],
[
161,
161
],
[
163,
163
],
[
301,
165
],
[
301,
174
],
[
301,
175
],
[
301,
176
],
[
304,
178
],
[
298,
185
],
[
317,
187
],
[
284,
189
],
[
296,
190
],
[
305,
191
],
[
274,
193
],
[
287,
195
],
[
284,
197
],
[
296,
198
],
[
305,
199
],
[
307,
201
],
[
290,
203
],
[
284,
205
],
[
296,
206
],
[
299,
207
],
[
305,
208
],
[
277,
210
],
[
214,
213
],
[
284,
217
],
[
293,
218
],
[
278,
221
],
[
302,
226
],
[
280,
229
],
[
313,
236
],
[
281,
239
],
[
314,
239
],
[
311,
242
],
[
305,
247
],
[
275,
248
],
[
308,
249
],
[
311,
251
],
[
284,
256
],
[
296,
257
],
[
284,
263
],
[
305,
266
],
[
275,
267
],
[
308,
268
],
[
305,
269
],
[
314,
272
],
[
281,
272
],
[
274,
275
],
[
277,
278
],
[
280,
281
],
[
301,
284
],
[
301,
293
],
[
301,
296
],
[
298,
299
],
[
301,
302
],
[
304,
305
],
[
307,
308
],
[
313,
314
]
] | [
"# nの逆元のリスト\ndef inv_mod(n:int, mod:int) -> list:\n inv = [0,1]\n for i in range(2,n+1):\n inv.append(mod - ((mod//i)*inv[mod%i]) % mod)\n return inv\n \n# nの階乗のリスト\ndef fact(n:int, mod:int) -> list:\n fac = [1,1]\n res = 1\n for i in range(2,n+1):\n res = res*i%mod\n fac.append(res)\n return fac\n\n# nの階乗の逆元のリスト\ndef fact_inv(n:int, inv:list, mod:int) -> list:\n facInv = [1,1]\n for i in range(2,n+1):\n facInv.append(facInv[i-1]*inv[i] % mod)\n return facInv\n \n# 二項係数\ndef nCr(n:int, r:int, mod:int, fac:list, facInv:list) -> int:\n if n==0 and r==0:\n return 1\n\n elif not (0<=r and r<=n):\n return 0\n \n return ((fac[n]*facInv[r]) % mod) * facInv[n-r] % mod\n\n\nH,W,A,B = map(int, input().split())\nmod = 10**9+7\n\ninv = inv_mod(H+W, mod)\nfac = fact(H+W, mod)\nfacInv = fact_inv(H+W,inv,mod)\n\ncheckPoint = []\nfor i in range(H-A):\n checkPoint.append((i,B-1))\n \nans = 0\nfor h,w in checkPoint:\n ans = (ans + nCr(h+w,h,mod,fac,facInv) \\\n * nCr(H+W-h-w-3, H-h-1, mod, fac, facInv)) % mod\n \nprint(ans)",
"def inv_mod(n:int, mod:int) -> list:\n inv = [0,1]\n for i in range(2,n+1):\n inv.append(mod - ((mod//i)*inv[mod%i]) % mod)\n return inv\n \n# nの階乗のリスト",
"inv_mod",
"inv = [0,1]",
"inv",
"[0,1]",
"0",
"1",
"for i in range(2,n+1):\n inv.append(mod - ((mod//i)*inv[mod%i]) % mod)\n ",
"i",
"range(2,n+1)",
"range",
"2",
"n+1",
"n",
"1",
"inv.append(mod - ((mod//i)*inv[mod%i]) % mod)",
"inv.append",
"inv",
"append",
"mod - ((mod//i)*inv[mod%i]) % mod",
"mod",
"((mod//i)*inv[mod%i]) % mod",
"(mod//i)*inv[mod%i]",
"mod//i",
"mod",
"i",
"inv[mod%i]",
"inv",
"mod%i",
"mod",
"i",
"mod",
"return inv",
"inv",
"n:int",
"n",
"mod:int",
"mod",
"def fact(n:int, mod:int) -> list:\n fac = [1,1]\n res = 1\n for i in range(2,n+1):\n res = res*i%mod\n fac.append(res)\n return fac\n\n# nの階乗の逆元のリスト",
"fact",
"fac = [1,1]",
"fac",
"[1,1]",
"1",
"1",
"res = 1",
"res",
"1",
"for i in range(2,n+1):\n res = res*i%mod\n fac.append(res)\n ",
"i",
"range(2,n+1)",
"range",
"2",
"n+1",
"n",
"1",
"res = res*i%mod",
"res",
"res*i%mod",
"res*i",
"res",
"i",
"mod",
"fac.append(res)",
"fac.append",
"fac",
"append",
"res",
"return fac",
"fac",
"n:int",
"n",
"mod:int",
"mod",
"def fact_inv(n:int, inv:list, mod:int) -> list:\n facInv = [1,1]\n for i in range(2,n+1):\n facInv.append(facInv[i-1]*inv[i] % mod)\n return facInv\n \n# 二項係数",
"fact_inv",
"facInv = [1,1]",
"facInv",
"[1,1]",
"1",
"1",
"for i in range(2,n+1):\n facInv.append(facInv[i-1]*inv[i] % mod)\n ",
"i",
"range(2,n+1)",
"range",
"2",
"n+1",
"n",
"1",
"facInv.append(facInv[i-1]*inv[i] % mod)",
"facInv.append",
"facInv",
"append",
"facInv[i-1]*inv[i] % mod",
"facInv[i-1]*inv[i]",
"facInv[i-1]",
"facInv",
"i-1",
"i",
"1",
"inv[i]",
"inv",
"i",
"mod",
"return facInv",
"facInv",
"n:int",
"n",
"inv:list",
"inv",
"mod:int",
"mod",
"def nCr(n:int, r:int, mod:int, fac:list, facInv:list) -> int:\n if n==0 and r==0:\n return 1\n\n elif not (0<=r and r<=n):\n return 0\n \n return ((fac[n]*facInv[r]) % mod) * facInv[n-r] % mod",
"nCr",
"if n==0 and r==0:\n return 1\n\n elif not (0<=r and r<=n):\n return 0\n \n ",
"n==0 and r==0",
"n==0",
"n",
"0",
"r==0",
"r",
"0",
"return 1",
"1",
"elif not (0<=r and r<=n):\n return 0\n \n ",
"not (0<=r and r<=n)",
"0<=r and r<=n",
"0<=r",
"0",
"r",
"r<=n",
"r",
"n",
"return 0",
"0",
"return ((fac[n]*facInv[r]) % mod) * facInv[n-r] % mod",
"((fac[n]*facInv[r]) % mod) * facInv[n-r] % mod",
"((fac[n]*facInv[r]) % mod) * facInv[n-r]",
"(fac[n]*facInv[r]) % mod",
"fac[n]*facInv[r]",
"fac[n]",
"fac",
"n",
"facInv[r]",
"facInv",
"r",
"mod",
"facInv[n-r]",
"facInv",
"n-r",
"n",
"r",
"mod",
"n:int",
"n",
"r:int",
"r",
"mod:int",
"mod",
"fac:list",
"fac",
"facInv:list",
"facInv",
"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",
"inv = inv_mod(H+W, mod)",
"inv",
"inv_mod(H+W, mod)",
"inv_mod",
"H+W",
"H",
"W",
"mod",
"fac = fact(H+W, mod)",
"fac",
"fact(H+W, mod)",
"fact",
"H+W",
"H",
"W",
"mod",
"facInv = fact_inv(H+W,inv,mod)",
"facInv",
"fact_inv(H+W,inv,mod)",
"fact_inv",
"H+W",
"H",
"W",
"inv",
"mod",
"checkPoint = []",
"checkPoint",
"[]",
"for i in range(H-A):\n checkPoint.append((i,B-1))\n ",
"i",
"range(H-A)",
"range",
"H-A",
"H",
"A",
"checkPoint.append((i,B-1))",
"checkPoint.append",
"checkPoint",
"append",
"(i,B-1)",
"i",
"B-1",
"B",
"1",
"ans = 0",
"ans",
"0",
"for h,w in checkPoint:\n ans = (ans + nCr(h+w,h,mod,fac,facInv) \\\n * nCr(H+W-h-w-3, H-h-1, mod, fac, facInv)) % mod\n ",
"h",
"w",
"checkPoint",
"ans = (ans + nCr(h+w,h,mod,fac,facInv) \\\n * nCr(H+W-h-w-3, H-h-1, mod, fac, facInv)) % mod",
"ans",
"(ans + nCr(h+w,h,mod,fac,facInv) \\\n * nCr(H+W-h-w-3, H-h-1, mod, fac, facInv)) % mod",
"ans + nCr(h+w,h,mod,fac,facInv) \\\n * nCr(H+W-h-w-3, H-h-1, mod, fac, facInv)",
"ans",
"nCr(h+w,h,mod,fac,facInv) \\\n * nCr(H+W-h-w-3, H-h-1, mod, fac, facInv)",
"nCr(h+w,h,mod,fac,facInv)",
"nCr",
"h+w",
"h",
"w",
"h",
"mod",
"fac",
"facInv",
"nCr(H+W-h-w-3, H-h-1, mod, fac, facInv)",
"nCr",
"H+W-h-w-3",
"H+W-h-w",
"H+W-h",
"H+W",
"H",
"W",
"h",
"w",
"3",
"H-h-1",
"H-h",
"H",
"h",
"1",
"mod",
"fac",
"facInv",
"mod",
"print(ans)",
"print",
"ans",
"fac = fact(H+W, mod)",
"fact(H+W, mod)",
"fac",
"checkPoint = []",
"[]",
"checkPoint",
"ans = 0",
"0",
"ans",
"H,W,A,B = map(int, input().split())",
"map(int, input().split())",
"H",
"def fact(n:int, mod:int) -> list:\n fac = [1,1]\n res = 1\n for i in range(2,n+1):\n res = res*i%mod\n fac.append(res)\n return fac\n\n# nの階乗の逆元のリスト",
"def fact(n:int, mod:int) -> list:\n fac = [1,1]\n res = 1\n for i in range(2,n+1):\n res = res*i%mod\n fac.append(res)\n return fac\n\n# nの階乗の逆元のリスト",
"fact",
"def fact_inv(n:int, inv:list, mod:int) -> list:\n facInv = [1,1]\n for i in range(2,n+1):\n facInv.append(facInv[i-1]*inv[i] % mod)\n return facInv\n \n# 二項係数",
"def fact_inv(n:int, inv:list, mod:int) -> list:\n facInv = [1,1]\n for i in range(2,n+1):\n facInv.append(facInv[i-1]*inv[i] % mod)\n return facInv\n \n# 二項係数",
"fact_inv",
"A,B = map(int, input().split())",
"map(int, input().split())",
"A",
"W,A,B = map(int, input().split())",
"map(int, input().split())",
"W",
"inv = inv_mod(H+W, mod)",
"inv_mod(H+W, mod)",
"inv",
"B = map(int, input().split())",
"map(int, input().split())",
"B",
"mod = 10**9+7",
"10**9+7",
"mod",
"facInv = fact_inv(H+W,inv,mod)",
"fact_inv(H+W,inv,mod)",
"facInv",
"def nCr(n:int, r:int, mod:int, fac:list, facInv:list) -> int:\n if n==0 and r==0:\n return 1\n\n elif not (0<=r and r<=n):\n return 0\n \n return ((fac[n]*facInv[r]) % mod) * facInv[n-r] % mod",
"def nCr(n:int, r:int, mod:int, fac:list, facInv:list) -> int:\n if n==0 and r==0:\n return 1\n\n elif not (0<=r and r<=n):\n return 0\n \n return ((fac[n]*facInv[r]) % mod) * facInv[n-r] % mod",
"nCr",
"ans = (ans + nCr(h+w,h,mod,fac,facInv) \\\n * nCr(H+W-h-w-3, H-h-1, mod, fac, facInv)) % mod",
"(ans + nCr(h+w,h,mod,fac,facInv) \\\n * nCr(H+W-h-w-3, H-h-1, mod, fac, facInv)) % mod",
"ans",
"def inv_mod(n:int, mod:int) -> list:\n inv = [0,1]\n for i in range(2,n+1):\n inv.append(mod - ((mod//i)*inv[mod%i]) % mod)\n return inv\n \n# nの階乗のリスト",
"def inv_mod(n:int, mod:int) -> list:\n inv = [0,1]\n for i in range(2,n+1):\n inv.append(mod - ((mod//i)*inv[mod%i]) % mod)\n return inv\n \n# nの階乗のリスト",
"inv_mod"
] | # nの逆元のリスト
def inv_mod(n:int, mod:int) -> list:
inv = [0,1]
for i in range(2,n+1):
inv.append(mod - ((mod//i)*inv[mod%i]) % mod)
return inv
# nの階乗のリスト
def fact(n:int, mod:int) -> list:
fac = [1,1]
res = 1
for i in range(2,n+1):
res = res*i%mod
fac.append(res)
return fac
# nの階乗の逆元のリスト
def fact_inv(n:int, inv:list, mod:int) -> list:
facInv = [1,1]
for i in range(2,n+1):
facInv.append(facInv[i-1]*inv[i] % mod)
return facInv
# 二項係数
def nCr(n:int, r:int, mod:int, fac:list, facInv:list) -> int:
if n==0 and r==0:
return 1
elif not (0<=r and r<=n):
return 0
return ((fac[n]*facInv[r]) % mod) * facInv[n-r] % mod
H,W,A,B = map(int, input().split())
mod = 10**9+7
inv = inv_mod(H+W, mod)
fac = fact(H+W, mod)
facInv = fact_inv(H+W,inv,mod)
checkPoint = []
for i in range(H-A):
checkPoint.append((i,B-1))
ans = 0
for h,w in checkPoint:
ans = (ans + nCr(h+w,h,mod,fac,facInv) \
* nCr(H+W-h-w-3, H-h-1, mod, fac, facInv)) % mod
print(ans) |
[
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,
4,
13,
10,
4,
13,
10,
2,
13,
10,
13,
13,
10,
17,
13
] | [
[
136,
2
],
[
133,
9
],
[
133,
18
],
[
133,
19
],
[
133,
20
],
[
142,
22
],
[
142,
25
],
[
29,
28
],
[
128,
32
],
[
121,
35
],
[
143,
39
],
[
122,
39
],
[
131,
44
],
[
128,
45
],
[
134,
46
],
[
28,
48
],
[
28,
52
],
[
137,
55
],
[
137,
57
],
[
137,
58
],
[
121,
60
],
[
64,
63
],
[
128,
68
],
[
116,
69
],
[
124,
71
],
[
122,
76
],
[
143,
76
],
[
125,
76
],
[
134,
79
],
[
63,
81
],
[
128,
83
],
[
63,
84
],
[
63,
88
],
[
131,
93
],
[
128,
94
],
[
134,
95
],
[
63,
97
],
[
137,
99
],
[
137,
101
],
[
137,
102
],
[
139,
104
],
[
125,
105
],
[
122,
105
],
[
143,
105
],
[
140,
109
],
[
119,
109
],
[
113,
109
],
[
137,
110
],
[
142,
113
],
[
133,
116
],
[
121,
119
],
[
121,
122
],
[
124,
125
],
[
133,
128
],
[
133,
131
],
[
133,
134
],
[
136,
137
],
[
125,
139
],
[
122,
139
],
[
143,
139
],
[
139,
140
],
[
142,
143
]
] | [
"m=10**9+7\nh,w,a,b=map(int,input().split())\nd=c=1\nfor i in range(h-1):\n d=c=c*(w+h-b-2-i)*pow(i+1,m-2,m)%m\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 d+=c\nprint(d%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",
"d=c=1",
"d",
"1",
"=c=1",
"c",
"1",
"for i in range(h-1):\n d=c=c*(w+h-b-2-i)*pow(i+1,m-2,m)%m",
"i",
"range(h-1)",
"range",
"h-1",
"h",
"1",
"d=c=c*(w+h-b-2-i)*pow(i+1,m-2,m)%m",
"d",
"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 d+=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",
"d+=c",
"d",
"c",
"print(d%m)",
"print",
"d%m",
"d",
"m",
"d=c=1",
"1",
"d",
"a,b=map(int,input().split())",
"map(int,input().split())",
"a",
"d=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",
"d",
"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",
"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",
"m=10**9+7",
"10**9+7",
"m",
"d+=c",
"c",
"d",
"c=1",
"1",
"c"
] | m=10**9+7
h,w,a,b=map(int,input().split())
d=c=1
for i in range(h-1):
d=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
d+=c
print(d%m) |
[
7,
0,
13,
4,
13,
13,
4,
18,
4,
18,
4,
13,
17,
13,
13,
13,
13,
13,
0,
13,
2,
2,
17,
17,
17,
0,
13,
2,
39,
17,
2,
2,
13,
13,
17,
0,
13,
2,
39,
17,
2,
2,
13,
13,
17,
28,
13,
4,
13,
2,
13,
13,
0,
18,
13,
2,
13,
17,
2,
2,
18,
13,
13,
2,
13,
17,
13,
0,
13,
4,
13,
4,
13,
12,
4,
13,
13,
2,
13,
17,
13,
23,
13,
12,
13,
29,
2,
2,
2,
2,
18,
13,
13,
18,
13,
13,
13,
18,
13,
2,
13,
13,
13,
23,
13,
23,
13,
23,
13,
0,
13,
17,
28,
13,
4,
13,
13,
13,
0,
13,
2,
2,
4,
13,
2,
2,
2,
13,
13,
17,
13,
13,
13,
4,
13,
2,
2,
2,
2,
13,
17,
13,
17,
13,
2,
2,
13,
17,
13,
13,
13,
0,
13,
13,
4,
13,
13,
10,
2,
13,
10,
4,
13,
10,
4,
13,
10,
12,
13,
10,
2,
13,
10,
4,
13,
10,
17,
13,
10,
4,
13,
10,
2,
13,
10,
13,
13,
10,
4,
13,
10,
2,
13
] | [
[
188,
2
],
[
188,
15
],
[
188,
16
],
[
188,
17
],
[
170,
19
],
[
182,
26
],
[
189,
32
],
[
162,
33
],
[
191,
36
],
[
189,
42
],
[
162,
43
],
[
47,
46
],
[
189,
50
],
[
162,
51
],
[
58,
53
],
[
183,
54
],
[
46,
56
],
[
183,
61
],
[
46,
62
],
[
46,
64
],
[
171,
66
],
[
173,
68
],
[
171,
78
],
[
171,
80
],
[
183,
82
],
[
183,
91
],
[
104,
92
],
[
174,
94
],
[
192,
94
],
[
106,
95
],
[
171,
96
],
[
174,
98
],
[
192,
98
],
[
104,
100
],
[
106,
101
],
[
171,
102
],
[
104,
104
],
[
106,
106
],
[
108,
108
],
[
176,
110
],
[
114,
113
],
[
180,
116
],
[
162,
117
],
[
158,
119
],
[
168,
123
],
[
189,
127
],
[
165,
128
],
[
113,
130
],
[
113,
131
],
[
171,
132
],
[
168,
134
],
[
165,
139
],
[
162,
141
],
[
113,
143
],
[
162,
146
],
[
113,
148
],
[
171,
149
],
[
171,
150
],
[
185,
152
],
[
171,
153
],
[
186,
156
],
[
159,
156
],
[
177,
156
],
[
158,
159
],
[
188,
162
],
[
188,
165
],
[
170,
171
],
[
173,
174
],
[
176,
177
],
[
188,
180
],
[
182,
183
],
[
171,
185
],
[
185,
186
],
[
188,
189
],
[
191,
192
]
] | [
"H, W, A, B = map(int, open(0).read().split())\nMOD = 10**9+7\n\nfactorials = [1] * (H + W + 1)\ninv_factorials = [1] * (H + W + 1)\n\nfor i in range(H + W):\n factorials[i+1] = factorials[i] * (i + 1) % MOD\n\ninv_factorials = list(map(lambda n: pow(n, MOD - 2, MOD), factorials))\n\ndef modcomb(m, n, mod):\n return factorials[m] * inv_factorials[n] % MOD * inv_factorials[m - n] % MOD\n \n# total = modcomb(H + W - 2, W - 1, MOD)\ntotal = 0\n \n# for i in range(B):\nfor i in range(B, W):\n total += modcomb(H - A - 1 + i, i, MOD) * modcomb(A - 1 + W - 1 - i, W - 1 - i, MOD) % MOD\n total %= MOD\n \nprint(total)",
"H, W, A, B = map(int, open(0).read().split())",
"H",
"map(int, open(0).read().split())",
"map",
"int",
"open(0).read().split()",
"(0).read().split",
"(0).read()",
"(0).read",
"(0)",
"open",
"0",
"read",
"split",
"W",
"A",
"B",
"MOD = 10**9+7",
"MOD",
"10**9+7",
"10**9",
"10",
"9",
"7",
"factorials = [1] * (H + W + 1)",
"factorials",
"[1] * (H + W + 1)",
"[1]",
"1",
"H + W + 1",
"H + W",
"H",
"W",
"1",
"inv_factorials = [1] * (H + W + 1)",
"inv_factorials",
"[1] * (H + W + 1)",
"[1]",
"1",
"H + W + 1",
"H + W",
"H",
"W",
"1",
"for i in range(H + W):\n factorials[i+1] = factorials[i] * (i + 1) % MOD",
"i",
"range(H + W)",
"range",
"H + W",
"H",
"W",
"factorials[i+1] = factorials[i] * (i + 1) % MOD",
"factorials[i+1]",
"factorials",
"i+1",
"i",
"1",
"factorials[i] * (i + 1) % MOD",
"factorials[i] * (i + 1)",
"factorials[i]",
"factorials",
"i",
"i + 1",
"i",
"1",
"MOD",
"inv_factorials = list(map(lambda n: pow(n, MOD - 2, MOD), factorials))",
"inv_factorials",
"list(map(lambda n: pow(n, MOD - 2, MOD), factorials))",
"list",
"map(lambda n: pow(n, MOD - 2, MOD), factorials)",
"map",
"lambda n: pow(n, MOD - 2, MOD)",
"pow(n, MOD - 2, MOD)",
"pow",
"n",
"MOD - 2",
"MOD",
"2",
"MOD",
"n",
"factorials",
"def modcomb(m, n, mod):\n return factorials[m] * inv_factorials[n] % MOD * inv_factorials[m - n] % MOD\n \n# total = modcomb(H + W - 2, W - 1, MOD)",
"modcomb",
"return factorials[m] * inv_factorials[n] % MOD * inv_factorials[m - n] % MOD",
"factorials[m] * inv_factorials[n] % MOD * inv_factorials[m - n] % MOD",
"factorials[m] * inv_factorials[n] % MOD * inv_factorials[m - n]",
"factorials[m] * inv_factorials[n] % MOD",
"factorials[m] * inv_factorials[n]",
"factorials[m]",
"factorials",
"m",
"inv_factorials[n]",
"inv_factorials",
"n",
"MOD",
"inv_factorials[m - n]",
"inv_factorials",
"m - n",
"m",
"n",
"MOD",
"m",
"m",
"n",
"n",
"mod",
"mod",
"total = 0",
"total",
"0",
"for i in range(B, W):\n total += modcomb(H - A - 1 + i, i, MOD) * modcomb(A - 1 + W - 1 - i, W - 1 - i, MOD) % MOD\n total %= MOD\n ",
"i",
"range(B, W)",
"range",
"B",
"W",
"total += modcomb(H - A - 1 + i, i, MOD) * modcomb(A - 1 + W - 1 - i, W - 1 - i, MOD) % MOD",
"total",
"modcomb(H - A - 1 + i, i, MOD) * modcomb(A - 1 + W - 1 - i, W - 1 - i, MOD) % MOD",
"modcomb(H - A - 1 + i, i, MOD) * modcomb(A - 1 + W - 1 - i, W - 1 - i, MOD)",
"modcomb(H - A - 1 + i, i, MOD)",
"modcomb",
"H - A - 1 + i",
"H - A - 1",
"H - A",
"H",
"A",
"1",
"i",
"i",
"MOD",
"modcomb(A - 1 + W - 1 - i, W - 1 - i, MOD)",
"modcomb",
"A - 1 + W - 1 - i",
"A - 1 + W - 1",
"A - 1 + W",
"A - 1",
"A",
"1",
"W",
"1",
"i",
"W - 1 - i",
"W - 1",
"W",
"1",
"i",
"MOD",
"MOD",
"total %= MOD",
"total",
"MOD",
"print(total)",
"print",
"total",
"total += modcomb(H - A - 1 + i, i, MOD) * modcomb(A - 1 + W - 1 - i, W - 1 - i, MOD) % MOD",
"modcomb(H - A - 1 + i, i, MOD) * modcomb(A - 1 + W - 1 - i, W - 1 - i, MOD) % MOD",
"total",
"W, A, B = map(int, open(0).read().split())",
"map(int, open(0).read().split())",
"W",
"A, B = map(int, open(0).read().split())",
"map(int, open(0).read().split())",
"A",
"def modcomb(m, n, mod):\n return factorials[m] * inv_factorials[n] % MOD * inv_factorials[m - n] % MOD\n \n# total = modcomb(H + W - 2, W - 1, MOD)",
"def modcomb(m, n, mod):\n return factorials[m] * inv_factorials[n] % MOD * inv_factorials[m - n] % MOD\n \n# total = modcomb(H + W - 2, W - 1, MOD)",
"modcomb",
"MOD = 10**9+7",
"10**9+7",
"MOD",
"inv_factorials = list(map(lambda n: pow(n, MOD - 2, MOD), factorials))",
"list(map(lambda n: pow(n, MOD - 2, MOD), factorials))",
"inv_factorials",
"total = 0",
"0",
"total",
"B = map(int, open(0).read().split())",
"map(int, open(0).read().split())",
"B",
"factorials = [1] * (H + W + 1)",
"[1] * (H + W + 1)",
"factorials",
"total %= MOD",
"MOD",
"total",
"H, W, A, B = map(int, open(0).read().split())",
"map(int, open(0).read().split())",
"H",
"inv_factorials = [1] * (H + W + 1)",
"[1] * (H + W + 1)",
"inv_factorials"
] | H, W, A, B = map(int, open(0).read().split())
MOD = 10**9+7
factorials = [1] * (H + W + 1)
inv_factorials = [1] * (H + W + 1)
for i in range(H + W):
factorials[i+1] = factorials[i] * (i + 1) % MOD
inv_factorials = list(map(lambda n: pow(n, MOD - 2, MOD), factorials))
def modcomb(m, n, mod):
return factorials[m] * inv_factorials[n] % MOD * inv_factorials[m - n] % MOD
# total = modcomb(H + W - 2, W - 1, MOD)
total = 0
# for i in range(B):
for i in range(B, W):
total += modcomb(H - A - 1 + i, i, MOD) * modcomb(A - 1 + W - 1 - i, W - 1 - i, MOD) % MOD
total %= MOD
print(total) |
[
7,
12,
13,
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,
29,
13,
23,
13,
23,
13,
0,
13,
4,
13,
2,
17,
2,
17,
17,
2,
2,
17,
17,
17,
12,
13,
41,
29,
2,
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,
13,
23,
13,
23,
13,
23,
13,
0,
13,
2,
2,
17,
17,
17,
41,
28,
13,
4,
18,
4,
13,
13,
4,
4,
13,
13,
0,
13,
13,
13,
13,
13,
0,
13,
2,
13,
13,
0,
13,
2,
13,
13,
14,
2,
13,
17,
41,
28,
13,
4,
13,
13,
4,
17,
0,
13,
13,
41,
28,
13,
4,
13,
13,
4,
4,
13,
2,
2,
13,
17,
13,
2,
13,
17,
13,
0,
13,
13,
0,
13,
4,
13,
13,
13,
13,
28,
13,
4,
13,
13,
0,
18,
13,
13,
2,
2,
13,
18,
13,
13,
13,
0,
13,
18,
13,
13,
0,
18,
13,
13,
2,
2,
4,
13,
13,
2,
13,
13,
13,
18,
13,
13,
13,
4,
13,
2,
4,
13,
13,
13,
10,
13,
13,
10,
12,
13,
10,
18,
13,
10,
13,
13,
10,
12,
13,
10,
2,
13,
10,
13,
13,
10,
2,
13,
10,
13,
13,
10,
4,
13,
10,
2,
13,
10,
13,
13,
10,
4,
13,
10,
13,
13
] | [
[
6,
5
],
[
40,
9
],
[
15,
14
],
[
18,
17
],
[
40,
22
],
[
28,
25
],
[
14,
26
],
[
17,
27
],
[
14,
31
],
[
17,
33
],
[
17,
35
],
[
42,
36
],
[
14,
38
],
[
40,
40
],
[
42,
42
],
[
260,
44
],
[
237,
46
],
[
95,
68
],
[
97,
69
],
[
95,
76
],
[
99,
79
],
[
99,
81
],
[
97,
87
],
[
99,
90
],
[
99,
92
],
[
99,
93
],
[
95,
95
],
[
97,
97
],
[
99,
99
],
[
239,
101
],
[
110,
109
],
[
109,
118
],
[
257,
120
],
[
257,
122
],
[
257,
123
],
[
257,
124
],
[
254,
126
],
[
234,
128
],
[
225,
129
],
[
245,
131
],
[
249,
133
],
[
258,
134
],
[
255,
137
],
[
142,
141
],
[
246,
144
],
[
242,
148
],
[
153,
152
],
[
246,
155
],
[
228,
158
],
[
258,
161
],
[
152,
163
],
[
255,
165
],
[
240,
167
],
[
263,
169
],
[
251,
172
],
[
228,
174
],
[
258,
175
],
[
255,
176
],
[
240,
177
],
[
180,
179
],
[
246,
182
],
[
187,
184
],
[
264,
185
],
[
243,
185
],
[
179,
186
],
[
252,
189
],
[
231,
189
],
[
200,
190
],
[
184,
190
],
[
264,
191
],
[
243,
191
],
[
179,
192
],
[
240,
193
],
[
230,
195
],
[
184,
196
],
[
200,
196
],
[
264,
197
],
[
243,
197
],
[
179,
198
],
[
203,
200
],
[
264,
201
],
[
243,
201
],
[
179,
202
],
[
228,
206
],
[
225,
207
],
[
246,
209
],
[
179,
210
],
[
240,
211
],
[
184,
212
],
[
200,
212
],
[
264,
213
],
[
243,
213
],
[
179,
214
],
[
240,
215
],
[
264,
221
],
[
243,
221
],
[
240,
222
],
[
257,
225
],
[
184,
230
],
[
200,
230
],
[
230,
231
],
[
257,
234
],
[
239,
240
],
[
242,
243
],
[
245,
246
],
[
257,
249
],
[
251,
252
],
[
254,
255
],
[
257,
258
],
[
260,
261
],
[
263,
264
]
] | [
"def frac_with_mod(a,m):\n outlist = [ 1 for i in range(a+1) ]\n for i in range(1,a+1):\n outlist[i] = (outlist[i-1] * i)% m\n return outlist\n\nfrac_list = frac_with_mod(2*10**5,10**9+7)\n\ndef comb_with_mod(a,b,m):\n global frac_list\n return ( frac_list[a+b-2] * pow(frac_list[a-1],m-2,m) * pow(frac_list[b-1],m-2,m) ) % m\n\nmod = 10**9+7\nh, w, a, b = [ int(v) for v in input().split() ]\n\nc = h - a\nd = w - b\n\n\nif c == 1:\n waypoint_list = [ 1 for i in range(d) ]\nelse:\n waypoint_list = [ comb_with_mod(b+1+i,c-1,mod) for i in range(d) ]\n s = comb_with_mod(b,c,mod)\n\n for i in range(d):\n waypoint_list[i] = ( s + waypoint_list[i] ) % mod\n s = waypoint_list[i]\n waypoint_list[i] = ( comb_with_mod(a,d-i,mod) * waypoint_list[i] ) % mod\n\nprint(sum(waypoint_list)%mod)",
"def frac_with_mod(a,m):\n outlist = [ 1 for i in range(a+1) ]\n for i in range(1,a+1):\n outlist[i] = (outlist[i-1] * i)% m\n return outlist",
"frac_with_mod",
"1 for i in range(a+1)",
"for i in range(a+1)",
"i",
"range(a+1)",
"range",
"a+1",
"a",
"1",
"for i in range(a+1)",
"1",
"outlist = [ 1 for i in range(a+1) ]",
"outlist",
"[ 1 for i in range(a+1) ]",
"for i in range(1,a+1):\n outlist[i] = (outlist[i-1] * i)% m\n ",
"i",
"range(1,a+1)",
"range",
"1",
"a+1",
"a",
"1",
"outlist[i] = (outlist[i-1] * i)% m",
"outlist[i]",
"outlist",
"i",
"(outlist[i-1] * i)% m",
"outlist[i-1] * i",
"outlist[i-1]",
"outlist",
"i-1",
"i",
"1",
"i",
"m",
"return outlist",
"outlist",
"a",
"a",
"m",
"m",
"frac_list = frac_with_mod(2*10**5,10**9+7)",
"frac_list",
"frac_with_mod(2*10**5,10**9+7)",
"frac_with_mod",
"2*10**5",
"2",
"10**5",
"10",
"5",
"10**9+7",
"10**9",
"10",
"9",
"7",
"def comb_with_mod(a,b,m):\n global frac_list\n return ( frac_list[a+b-2] * pow(frac_list[a-1],m-2,m) * pow(frac_list[b-1],m-2,m) ) % m",
"comb_with_mod",
"global frac_list",
"return ( frac_list[a+b-2] * pow(frac_list[a-1],m-2,m) * pow(frac_list[b-1],m-2,m) ) % m",
"( frac_list[a+b-2] * pow(frac_list[a-1],m-2,m) * pow(frac_list[b-1],m-2,m) ) % m",
"frac_list[a+b-2] * pow(frac_list[a-1],m-2,m) * pow(frac_list[b-1],m-2,m)",
"frac_list[a+b-2] * pow(frac_list[a-1],m-2,m)",
"frac_list[a+b-2]",
"frac_list",
"a+b-2",
"a+b",
"a",
"b",
"2",
"pow(frac_list[a-1],m-2,m)",
"pow",
"frac_list[a-1]",
"frac_list",
"a-1",
"a",
"1",
"m-2",
"m",
"2",
"m",
"pow(frac_list[b-1],m-2,m)",
"pow",
"frac_list[b-1]",
"frac_list",
"b-1",
"b",
"1",
"m-2",
"m",
"2",
"m",
"m",
"a",
"a",
"b",
"b",
"m",
"m",
"mod = 10**9+7",
"mod",
"10**9+7",
"10**9",
"10",
"9",
"7",
"int(v) for v in input().split()",
"for v in input().split()",
"v",
"input().split()",
"().split",
"()",
"input",
"split",
"for v in input().split()",
"int(v)",
"int",
"v",
"h, w, a, b = [ int(v) for v in input().split() ]",
"h",
"[ int(v) for v in input().split() ]",
"w",
"a",
"b",
"c = h - a",
"c",
"h - a",
"h",
"a",
"d = w - b",
"d",
"w - b",
"w",
"b",
"if c == 1:\n waypoint_list = [ 1 for i in range(d) ]\nelse:\n waypoint_list = [ comb_with_mod(b+1+i,c-1,mod) for i in range(d) ]\n s = comb_with_mod(b,c,mod)\n\n for i in range(d):\n waypoint_list[i] = ( s + waypoint_list[i] ) % mod\n s = waypoint_list[i]\n waypoint_list[i] = ( comb_with_mod(a,d-i,mod) * waypoint_list[i] ) % mod",
"c == 1",
"c",
"1",
"1 for i in range(d)",
"for i in range(d)",
"i",
"range(d)",
"range",
"d",
"for i in range(d)",
"1",
"waypoint_list = [ 1 for i in range(d) ]",
"waypoint_list",
"[ 1 for i in range(d) ]",
"comb_with_mod(b+1+i,c-1,mod) for i in range(d)",
"for i in range(d)",
"i",
"range(d)",
"range",
"d",
"for i in range(d)",
"comb_with_mod(b+1+i,c-1,mod)",
"comb_with_mod",
"b+1+i",
"b+1",
"b",
"1",
"i",
"c-1",
"c",
"1",
"mod",
"waypoint_list = [ comb_with_mod(b+1+i,c-1,mod) for i in range(d) ]",
"waypoint_list",
"[ comb_with_mod(b+1+i,c-1,mod) for i in range(d) ]",
"s = comb_with_mod(b,c,mod)",
"s",
"comb_with_mod(b,c,mod)",
"comb_with_mod",
"b",
"c",
"mod",
"for i in range(d):\n waypoint_list[i] = ( s + waypoint_list[i] ) % mod\n s = waypoint_list[i]\n waypoint_list[i] = ( comb_with_mod(a,d-i,mod) * waypoint_list[i] ) % mod",
"i",
"range(d)",
"range",
"d",
"waypoint_list[i] = ( s + waypoint_list[i] ) % mod",
"waypoint_list[i]",
"waypoint_list",
"i",
"( s + waypoint_list[i] ) % mod",
"s + waypoint_list[i]",
"s",
"waypoint_list[i]",
"waypoint_list",
"i",
"mod",
"s = waypoint_list[i]",
"s",
"waypoint_list[i]",
"waypoint_list",
"i",
"waypoint_list[i] = ( comb_with_mod(a,d-i,mod) * waypoint_list[i] ) % mod",
"waypoint_list[i]",
"waypoint_list",
"i",
"( comb_with_mod(a,d-i,mod) * waypoint_list[i] ) % mod",
"comb_with_mod(a,d-i,mod) * waypoint_list[i]",
"comb_with_mod(a,d-i,mod)",
"comb_with_mod",
"a",
"d-i",
"d",
"i",
"mod",
"waypoint_list[i]",
"waypoint_list",
"i",
"mod",
"print(sum(waypoint_list)%mod)",
"print",
"sum(waypoint_list)%mod",
"sum(waypoint_list)",
"sum",
"waypoint_list",
"mod",
"a, b = [ int(v) for v in input().split() ]",
"[ int(v) for v in input().split() ]",
"a",
"def comb_with_mod(a,b,m):\n global frac_list\n return ( frac_list[a+b-2] * pow(frac_list[a-1],m-2,m) * pow(frac_list[b-1],m-2,m) ) % m",
"def comb_with_mod(a,b,m):\n global frac_list\n return ( frac_list[a+b-2] * pow(frac_list[a-1],m-2,m) * pow(frac_list[b-1],m-2,m) ) % m",
"comb_with_mod",
"s = waypoint_list[i]",
"waypoint_list[i]",
"s",
"h, w, a, b = [ int(v) for v in input().split() ]",
"[ int(v) for v in input().split() ]",
"h",
"def frac_with_mod(a,m):\n outlist = [ 1 for i in range(a+1) ]\n for i in range(1,a+1):\n outlist[i] = (outlist[i-1] * i)% m\n return outlist",
"def frac_with_mod(a,m):\n outlist = [ 1 for i in range(a+1) ]\n for i in range(1,a+1):\n outlist[i] = (outlist[i-1] * i)% m\n return outlist",
"frac_with_mod",
"mod = 10**9+7",
"10**9+7",
"mod",
"waypoint_list = [ 1 for i in range(d) ]",
"[ 1 for i in range(d) ]",
"waypoint_list",
"d = w - b",
"w - b",
"d",
"w, a, b = [ int(v) for v in input().split() ]",
"[ int(v) for v in input().split() ]",
"w",
"s = comb_with_mod(b,c,mod)",
"comb_with_mod(b,c,mod)",
"s",
"c = h - a",
"h - a",
"c",
"b = [ int(v) for v in input().split() ]",
"[ int(v) for v in input().split() ]",
"b",
"frac_list = frac_with_mod(2*10**5,10**9+7)",
"frac_with_mod(2*10**5,10**9+7)",
"frac_list",
"waypoint_list = [ comb_with_mod(b+1+i,c-1,mod) for i in range(d) ]",
"[ comb_with_mod(b+1+i,c-1,mod) for i in range(d) ]",
"waypoint_list"
] | def frac_with_mod(a,m):
outlist = [ 1 for i in range(a+1) ]
for i in range(1,a+1):
outlist[i] = (outlist[i-1] * i)% m
return outlist
frac_list = frac_with_mod(2*10**5,10**9+7)
def comb_with_mod(a,b,m):
global frac_list
return ( frac_list[a+b-2] * pow(frac_list[a-1],m-2,m) * pow(frac_list[b-1],m-2,m) ) % m
mod = 10**9+7
h, w, a, b = [ int(v) for v in input().split() ]
c = h - a
d = w - b
if c == 1:
waypoint_list = [ 1 for i in range(d) ]
else:
waypoint_list = [ comb_with_mod(b+1+i,c-1,mod) for i in range(d) ]
s = comb_with_mod(b,c,mod)
for i in range(d):
waypoint_list[i] = ( s + waypoint_list[i] ) % mod
s = waypoint_list[i]
waypoint_list[i] = ( comb_with_mod(a,d-i,mod) * waypoint_list[i] ) % mod
print(sum(waypoint_list)%mod) |
[
7,
12,
13,
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,
29,
39,
13,
13,
23,
13,
23,
13,
12,
13,
17,
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,
23,
13,
23,
13,
0,
13,
2,
2,
17,
17,
17,
0,
13,
2,
17,
17,
0,
13,
4,
13,
13,
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,
13,
13,
13,
13,
0,
13,
4,
13,
2,
2,
2,
13,
13,
17,
13,
2,
2,
13,
17,
13,
13,
13,
13,
0,
13,
2,
13,
13,
4,
13,
2,
13,
13,
10,
4,
13,
10,
2,
13,
10,
13,
13,
10,
4,
13,
10,
12,
13,
10,
4,
13,
10,
12,
13,
10,
13,
13,
10,
2,
13,
10,
2,
13,
10,
13,
13,
10,
13,
13,
10,
17,
13,
10,
4,
13
] | [
[
6,
5
],
[
11,
10
],
[
16,
15
],
[
21,
20
],
[
72,
25
],
[
5,
29
],
[
5,
34
],
[
20,
36
],
[
74,
37
],
[
15,
40
],
[
15,
46
],
[
74,
48
],
[
20,
49
],
[
74,
51
],
[
20,
52
],
[
74,
53
],
[
10,
56
],
[
10,
61
],
[
15,
64
],
[
74,
66
],
[
72,
72
],
[
74,
74
],
[
107,
81
],
[
105,
84
],
[
107,
85
],
[
109,
93
],
[
105,
94
],
[
111,
96
],
[
107,
97
],
[
111,
99
],
[
105,
101
],
[
107,
102
],
[
113,
103
],
[
105,
105
],
[
107,
107
],
[
109,
109
],
[
111,
111
],
[
113,
113
],
[
232,
115
],
[
208,
122
],
[
244,
127
],
[
224,
129
],
[
209,
130
],
[
233,
131
],
[
244,
132
],
[
136,
135
],
[
135,
144
],
[
238,
146
],
[
238,
148
],
[
238,
149
],
[
238,
150
],
[
241,
152
],
[
156,
155
],
[
227,
158
],
[
212,
159
],
[
205,
161
],
[
218,
163
],
[
236,
167
],
[
239,
168
],
[
155,
170
],
[
155,
171
],
[
221,
172
],
[
245,
173
],
[
233,
174
],
[
214,
176
],
[
218,
178
],
[
239,
182
],
[
212,
183
],
[
155,
185
],
[
212,
188
],
[
155,
190
],
[
221,
191
],
[
245,
192
],
[
233,
193
],
[
229,
195
],
[
206,
197
],
[
215,
198
],
[
230,
202
],
[
242,
202
],
[
233,
203
],
[
205,
206
],
[
208,
209
],
[
238,
212
],
[
214,
215
],
[
244,
221
],
[
238,
227
],
[
229,
230
],
[
232,
233
],
[
238,
236
],
[
238,
239
],
[
241,
242
],
[
244,
245
]
] | [
"def combmod_pre(N, p):\n '''\n sample usage:\n p = 10**9+7\n N = 10**6\n fact, finv = combmod_pre(N, p)\n combmod(n, r, p)\n '''\n fact = [1, 1]\n finv = [1, 1]\n inv = [0, 1]\n 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)\n return (fact, finv)\n\n\ndef combmod(n, r, fact, finv, p):\n '''\n sample usage:\n combmod(3000, 1000, fact, finv, p)\n p is a same value of combmod_pre's argument\n fact, finv is return value of combmod_pre\n '''\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, finv = combmod_pre(N, p)\n\nh, w, a, b = (int(x) for x in input().split())\nans = 0\nfor j in range(b, w):\n x = combmod(h - a - 1 + j, j, fact, finv, p)\n y = combmod(a + w - 2 - j, w-1 - j, fact, finv, p)\n ans += x * y\nprint(ans % p)\n\n",
"def combmod_pre(N, p):\n '''\n sample usage:\n p = 10**9+7\n N = 10**6\n fact, finv = combmod_pre(N, p)\n combmod(n, r, p)\n '''\n fact = [1, 1]\n finv = [1, 1]\n inv = [0, 1]\n 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)\n return (fact, finv)",
"combmod_pre",
"'''\n sample usage:\n p = 10**9+7\n N = 10**6\n fact, finv = combmod_pre(N, p)\n combmod(n, r, p)\n '''",
"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)\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",
"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",
"return (fact, finv)",
"(fact, finv)",
"fact",
"finv",
"N",
"N",
"p",
"p",
"def combmod(n, r, fact, finv, p):\n '''\n sample usage:\n combmod(3000, 1000, fact, finv, p)\n p is a same value of combmod_pre's argument\n fact, finv is return value of combmod_pre\n '''\n if r < 0 or n < r:\n return 0\n return fact[n] * finv[r] * finv[n-r] % p",
"combmod",
"'''\n sample usage:\n combmod(3000, 1000, fact, finv, p)\n p is a same value of combmod_pre's argument\n fact, finv is return value of combmod_pre\n '''",
"if r < 0 or n < r:\n return 0\n ",
"r < 0 or n < r",
"r < 0",
"r",
"0",
"n < r",
"n",
"r",
"return 0",
"0",
"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",
"fact",
"fact",
"finv",
"finv",
"p",
"p",
"p = 10**9+7",
"p",
"10**9+7",
"10**9",
"10",
"9",
"7",
"N = 10**6",
"N",
"10**6",
"10",
"6",
"fact, finv = combmod_pre(N, p)",
"fact",
"combmod_pre(N, p)",
"combmod_pre",
"N",
"p",
"finv",
"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 x = combmod(h - a - 1 + j, j, fact, finv, p)\n y = combmod(a + w - 2 - j, w-1 - j, fact, finv, p)\n ans += x * y",
"j",
"range(b, w)",
"range",
"b",
"w",
"x = combmod(h - a - 1 + j, j, fact, finv, p)",
"x",
"combmod(h - a - 1 + j, j, fact, finv, p)",
"combmod",
"h - a - 1 + j",
"h - a - 1",
"h - a",
"h",
"a",
"1",
"j",
"j",
"fact",
"finv",
"p",
"y = combmod(a + w - 2 - j, w-1 - j, fact, finv, p)",
"y",
"combmod(a + w - 2 - j, w-1 - j, fact, finv, p)",
"combmod",
"a + w - 2 - j",
"a + w - 2",
"a + w",
"a",
"w",
"2",
"j",
"w-1 - j",
"w-1",
"w",
"1",
"j",
"fact",
"finv",
"p",
"ans += x * y",
"ans",
"x * y",
"x",
"y",
"print(ans % p)",
"print",
"ans % p",
"ans",
"p",
"x = combmod(h - a - 1 + j, j, fact, finv, p)",
"combmod(h - a - 1 + j, j, fact, finv, p)",
"x",
"N = 10**6",
"10**6",
"N",
"w, a, b = (int(x) for x in input().split())",
"(int(x) for x in input().split())",
"w",
"y = combmod(a + w - 2 - j, w-1 - j, fact, finv, p)",
"combmod(a + w - 2 - j, w-1 - j, fact, finv, p)",
"y",
"def combmod(n, r, fact, finv, p):\n '''\n sample usage:\n combmod(3000, 1000, fact, finv, p)\n p is a same value of combmod_pre's argument\n fact, finv is return value of combmod_pre\n '''\n if r < 0 or n < r:\n return 0\n return fact[n] * finv[r] * finv[n-r] % p",
"def combmod(n, r, fact, finv, p):\n '''\n sample usage:\n combmod(3000, 1000, fact, finv, p)\n p is a same value of combmod_pre's argument\n fact, finv is return value of combmod_pre\n '''\n if r < 0 or n < r:\n return 0\n return fact[n] * finv[r] * finv[n-r] % p",
"combmod",
"fact, finv = combmod_pre(N, p)",
"combmod_pre(N, p)",
"fact",
"def combmod_pre(N, p):\n '''\n sample usage:\n p = 10**9+7\n N = 10**6\n fact, finv = combmod_pre(N, p)\n combmod(n, r, p)\n '''\n fact = [1, 1]\n finv = [1, 1]\n inv = [0, 1]\n 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)\n return (fact, finv)",
"def combmod_pre(N, p):\n '''\n sample usage:\n p = 10**9+7\n N = 10**6\n fact, finv = combmod_pre(N, p)\n combmod(n, r, p)\n '''\n fact = [1, 1]\n finv = [1, 1]\n inv = [0, 1]\n 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)\n return (fact, finv)",
"combmod_pre",
"b = (int(x) for x in input().split())",
"(int(x) for x in input().split())",
"b",
"ans += x * y",
"x * y",
"ans",
"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",
"a, b = (int(x) for x in input().split())",
"(int(x) for x in input().split())",
"a",
"ans = 0",
"0",
"ans",
"finv = combmod_pre(N, p)",
"combmod_pre(N, p)",
"finv"
] | def combmod_pre(N, p):
'''
sample usage:
p = 10**9+7
N = 10**6
fact, finv = combmod_pre(N, p)
combmod(n, r, p)
'''
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)
return (fact, finv)
def combmod(n, r, fact, finv, p):
'''
sample usage:
combmod(3000, 1000, fact, finv, p)
p is a same value of combmod_pre's argument
fact, finv is return value of combmod_pre
'''
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, finv = combmod_pre(N, p)
h, w, a, b = (int(x) for x in input().split())
ans = 0
for j in range(b, w):
x = combmod(h - a - 1 + j, j, fact, finv, p)
y = combmod(a + w - 2 - j, w-1 - j, fact, finv, p)
ans += x * y
print(ans % p)
|
[
7,
6,
13,
12,
13,
0,
18,
13,
13,
13,
0,
18,
13,
13,
13,
23,
13,
23,
13,
23,
13,
12,
13,
29,
4,
13,
18,
13,
13,
23,
13,
12,
13,
29,
4,
18,
17,
13,
18,
13,
13,
18,
13,
13,
23,
13,
12,
13,
0,
13,
2,
18,
13,
13,
18,
13,
13,
0,
13,
18,
13,
13,
29,
4,
13,
13,
18,
13,
13,
23,
13,
23,
13,
12,
13,
0,
13,
2,
18,
13,
13,
18,
13,
13,
0,
13,
18,
13,
13,
29,
4,
13,
13,
18,
13,
13,
23,
13,
23,
13,
12,
13,
0,
13,
2,
18,
13,
13,
18,
13,
13,
0,
13,
18,
13,
13,
29,
4,
13,
13,
18,
13,
13,
23,
13,
23,
13,
12,
13,
0,
13,
4,
13,
18,
13,
13,
13,
18,
13,
13,
29,
4,
13,
13,
18,
13,
13,
23,
13,
23,
13,
12,
13,
29,
4,
18,
13,
13,
2,
18,
13,
13,
17,
23,
13,
12,
13,
0,
13,
2,
13,
4,
18,
13,
13,
29,
4,
13,
13,
18,
13,
13,
23,
13,
23,
13,
0,
13,
4,
13,
13,
4,
18,
4,
13,
13,
13,
13,
13,
0,
13,
2,
2,
17,
17,
17,
0,
13,
39,
4,
13,
17,
13,
0,
13,
2,
39,
4,
18,
4,
13,
17,
13,
13,
2,
2,
13,
13,
17,
12,
13,
29,
2,
2,
18,
13,
13,
18,
13,
13,
18,
13,
2,
13,
13,
23,
13,
23,
13,
28,
13,
4,
13,
17,
2,
2,
13,
13,
17,
4,
18,
13,
13,
2,
18,
13,
17,
4,
13,
13,
13,
0,
18,
13,
2,
2,
13,
13,
17,
4,
18,
18,
13,
17,
13,
28,
13,
4,
13,
2,
2,
13,
13,
17,
17,
17,
0,
18,
13,
2,
13,
17,
2,
18,
13,
13,
4,
13,
13,
13,
0,
13,
4,
13,
17,
13,
28,
13,
4,
13,
2,
13,
13,
0,
13,
2,
4,
13,
2,
2,
13,
13,
17,
13,
4,
13,
2,
2,
2,
2,
2,
13,
13,
17,
13,
13,
17,
2,
2,
13,
13,
17,
4,
13,
13,
10,
2,
13,
10,
2,
13,
10,
4,
13,
10,
4,
13,
10,
4,
13,
10,
12,
13,
10,
6,
13,
10,
2,
13,
10,
4,
13,
10,
4,
13,
10,
39,
13
] | [
[
9,
6
],
[
16,
7
],
[
18,
8
],
[
18,
9
],
[
14,
11
],
[
16,
12
],
[
20,
13
],
[
20,
14
],
[
16,
16
],
[
18,
18
],
[
20,
20
],
[
30,
27
],
[
30,
30
],
[
45,
39
],
[
45,
42
],
[
45,
45
],
[
50,
49
],
[
70,
52
],
[
72,
55
],
[
59,
58
],
[
70,
60
],
[
58,
65
],
[
49,
65
],
[
70,
67
],
[
70,
70
],
[
72,
72
],
[
77,
76
],
[
97,
79
],
[
99,
82
],
[
86,
85
],
[
97,
87
],
[
85,
92
],
[
76,
92
],
[
97,
94
],
[
97,
97
],
[
99,
99
],
[
104,
103
],
[
124,
106
],
[
126,
109
],
[
113,
112
],
[
124,
114
],
[
112,
119
],
[
103,
119
],
[
124,
121
],
[
124,
124
],
[
126,
126
],
[
131,
130
],
[
148,
134
],
[
150,
136
],
[
148,
138
],
[
130,
143
],
[
148,
145
],
[
148,
148
],
[
150,
150
],
[
164,
156
],
[
128,
157
],
[
164,
160
],
[
164,
164
],
[
169,
168
],
[
183,
170
],
[
185,
173
],
[
152,
174
],
[
168,
178
],
[
183,
180
],
[
183,
183
],
[
185,
185
],
[
383,
187
],
[
383,
196
],
[
383,
197
],
[
383,
198
],
[
356,
200
],
[
386,
207
],
[
357,
212
],
[
359,
214
],
[
357,
222
],
[
152,
223
],
[
363,
226
],
[
381,
227
],
[
387,
235
],
[
246,
236
],
[
360,
238
],
[
248,
239
],
[
360,
241
],
[
246,
243
],
[
248,
244
],
[
246,
246
],
[
248,
248
],
[
251,
250
],
[
363,
256
],
[
381,
257
],
[
387,
261
],
[
387,
265
],
[
250,
269
],
[
357,
270
],
[
279,
272
],
[
360,
273
],
[
363,
276
],
[
381,
277
],
[
387,
282
],
[
152,
284
],
[
287,
286
],
[
363,
291
],
[
381,
292
],
[
302,
297
],
[
360,
298
],
[
286,
300
],
[
360,
304
],
[
286,
305
],
[
286,
308
],
[
357,
309
],
[
368,
311
],
[
357,
315
],
[
318,
317
],
[
363,
321
],
[
366,
322
],
[
377,
324
],
[
372,
327
],
[
317,
330
],
[
384,
331
],
[
317,
333
],
[
372,
335
],
[
363,
341
],
[
317,
342
],
[
381,
344
],
[
384,
345
],
[
381,
349
],
[
384,
350
],
[
378,
354
],
[
369,
354
],
[
356,
357
],
[
359,
360
],
[
383,
363
],
[
383,
366
],
[
368,
369
],
[
377,
378
],
[
383,
381
],
[
383,
384
],
[
386,
387
]
] | [
"class ModInt:\n def __init__(self, num, mod):\n self.num = num\n self.mod = mod\n\n def __str__(self):\n return str(self.num)\n\n def __repr__(self):\n return \"ModInt(num: {}, mod: {}\".format(self.num, self.mod)\n\n def __add__(self, other):\n ret = self.num + other.num\n ret %= self.mod\n return ModInt(ret, self.mod)\n\n def __sub__(self, other):\n ret = self.num - other.num\n ret %= self.mod\n return ModInt(ret, self.mod)\n\n def __mul__(self, other):\n ret = self.num * other.num\n ret %= self.mod\n return ModInt(ret, self.mod)\n\n def pow(self, times):\n pw = pow(self.num, times, self.mod)\n return ModInt(pw, self.mod)\n\n def inverse(self):\n return self.pow(self.mod - 2)\n\n def __truediv__(self, other):\n num = self * other.inverse()\n return ModInt(num, self.mod)\n\n\nh, w, a, b = map(int, input().split())\nmod = 10 ** 9 + 7\n\nfact = [ModInt(1, mod)]\ninv = [ModInt(1, mod).inverse()] * (h + w - 1)\n\n\ndef comb(n, r):\n return fact[n] * inv[r] * inv[n-r]\n\n\nfor i in range(1, h + w - 1):\n fact.append(fact[-1] * ModInt(i, mod))\n\ninv[h+w-2] = fact[-1].inverse()\nfor i in range(h + w - 2, 0, -1):\n inv[i-1] = inv[i] * ModInt(i, mod)\n\nans = ModInt(0, mod)\nfor hi in range(h - a):\n ans += comb(hi + b - 1, hi) * comb(h - hi - 1 + w - b - 1, w - b - 1)\n\nprint(ans)",
"class ModInt:\n def __init__(self, num, mod):\n self.num = num\n self.mod = mod\n\n def __str__(self):\n return str(self.num)\n\n def __repr__(self):\n return \"ModInt(num: {}, mod: {}\".format(self.num, self.mod)\n\n def __add__(self, other):\n ret = self.num + other.num\n ret %= self.mod\n return ModInt(ret, self.mod)\n\n def __sub__(self, other):\n ret = self.num - other.num\n ret %= self.mod\n return ModInt(ret, self.mod)\n\n def __mul__(self, other):\n ret = self.num * other.num\n ret %= self.mod\n return ModInt(ret, self.mod)\n\n def pow(self, times):\n pw = pow(self.num, times, self.mod)\n return ModInt(pw, self.mod)\n\n def inverse(self):\n return self.pow(self.mod - 2)\n\n def __truediv__(self, other):\n num = self * other.inverse()\n return ModInt(num, self.mod)",
"ModInt",
"def __init__(self, num, mod):\n self.num = num\n self.mod = mod\n\n ",
"__init__",
"self.num = num",
"self.num",
"self",
"num",
"num",
"self.mod = mod",
"self.mod",
"self",
"mod",
"mod",
"self",
"self",
"num",
"num",
"mod",
"mod",
"def __str__(self):\n return str(self.num)\n\n ",
"__str__",
"return str(self.num)",
"str(self.num)",
"str",
"self.num",
"self",
"num",
"self",
"self",
"def __repr__(self):\n return \"ModInt(num: {}, mod: {}\".format(self.num, self.mod)\n\n ",
"__repr__",
"return \"ModInt(num: {}, mod: {}\".format(self.num, self.mod)",
"\"ModInt(num: {}, mod: {}\".format(self.num, self.mod)",
"\"ModInt(num: {}, mod: {}\".format",
"\"ModInt(num: {}, mod: {}\"",
"format",
"self.num",
"self",
"num",
"self.mod",
"self",
"mod",
"self",
"self",
"def __add__(self, other):\n ret = self.num + other.num\n ret %= self.mod\n return ModInt(ret, self.mod)\n\n ",
"__add__",
"ret = self.num + other.num",
"ret",
"self.num + other.num",
"self.num",
"self",
"num",
"other.num",
"other",
"num",
"ret %= self.mod",
"ret",
"self.mod",
"self",
"mod",
"return ModInt(ret, self.mod)",
"ModInt(ret, self.mod)",
"ModInt",
"ret",
"self.mod",
"self",
"mod",
"self",
"self",
"other",
"other",
"def __sub__(self, other):\n ret = self.num - other.num\n ret %= self.mod\n return ModInt(ret, self.mod)\n\n ",
"__sub__",
"ret = self.num - other.num",
"ret",
"self.num - other.num",
"self.num",
"self",
"num",
"other.num",
"other",
"num",
"ret %= self.mod",
"ret",
"self.mod",
"self",
"mod",
"return ModInt(ret, self.mod)",
"ModInt(ret, self.mod)",
"ModInt",
"ret",
"self.mod",
"self",
"mod",
"self",
"self",
"other",
"other",
"def __mul__(self, other):\n ret = self.num * other.num\n ret %= self.mod\n return ModInt(ret, self.mod)\n\n ",
"__mul__",
"ret = self.num * other.num",
"ret",
"self.num * other.num",
"self.num",
"self",
"num",
"other.num",
"other",
"num",
"ret %= self.mod",
"ret",
"self.mod",
"self",
"mod",
"return ModInt(ret, self.mod)",
"ModInt(ret, self.mod)",
"ModInt",
"ret",
"self.mod",
"self",
"mod",
"self",
"self",
"other",
"other",
"def pow(self, times):\n pw = pow(self.num, times, self.mod)\n return ModInt(pw, self.mod)\n\n ",
"pow",
"pw = pow(self.num, times, self.mod)",
"pw",
"pow(self.num, times, self.mod)",
"pow",
"self.num",
"self",
"num",
"times",
"self.mod",
"self",
"mod",
"return ModInt(pw, self.mod)",
"ModInt(pw, self.mod)",
"ModInt",
"pw",
"self.mod",
"self",
"mod",
"self",
"self",
"times",
"times",
"def inverse(self):\n return self.pow(self.mod - 2)\n\n ",
"inverse",
"return self.pow(self.mod - 2)",
"self.pow(self.mod - 2)",
"self.pow",
"self",
"pow",
"self.mod - 2",
"self.mod",
"self",
"mod",
"2",
"self",
"self",
"def __truediv__(self, other):\n num = self * other.inverse()\n return ModInt(num, self.mod)",
"__truediv__",
"num = self * other.inverse()",
"num",
"self * other.inverse()",
"self",
"other.inverse()",
"other.inverse",
"other",
"inverse",
"return ModInt(num, self.mod)",
"ModInt(num, self.mod)",
"ModInt",
"num",
"self.mod",
"self",
"mod",
"self",
"self",
"other",
"other",
"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 = [ModInt(1, mod)]",
"fact",
"[ModInt(1, mod)]",
"ModInt(1, mod)",
"ModInt",
"1",
"mod",
"inv = [ModInt(1, mod).inverse()] * (h + w - 1)",
"inv",
"[ModInt(1, mod).inverse()] * (h + w - 1)",
"[ModInt(1, mod).inverse()]",
"ModInt(1, mod).inverse()",
"(1, mod).inverse",
"(1, mod)",
"ModInt",
"1",
"mod",
"inverse",
"h + w - 1",
"h + w",
"h",
"w",
"1",
"def comb(n, r):\n return fact[n] * inv[r] * inv[n-r]",
"comb",
"return fact[n] * inv[r] * inv[n-r]",
"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",
"n",
"n",
"r",
"r",
"for i in range(1, h + w - 1):\n fact.append(fact[-1] * ModInt(i, mod))",
"i",
"range(1, h + w - 1)",
"range",
"1",
"h + w - 1",
"h + w",
"h",
"w",
"1",
"fact.append(fact[-1] * ModInt(i, mod))",
"fact.append",
"fact",
"append",
"fact[-1] * ModInt(i, mod)",
"fact[-1]",
"fact",
"-1",
"ModInt(i, mod)",
"ModInt",
"i",
"mod",
"inv[h+w-2] = fact[-1].inverse()",
"inv[h+w-2]",
"inv",
"h+w-2",
"h+w",
"h",
"w",
"2",
"fact[-1].inverse()",
"[-1].inverse",
"[-1]",
"fact",
"-1",
"inverse",
"for i in range(h + w - 2, 0, -1):\n inv[i-1] = inv[i] * ModInt(i, mod)",
"i",
"range(h + w - 2, 0, -1)",
"range",
"h + w - 2",
"h + w",
"h",
"w",
"2",
"0",
"-1",
"inv[i-1] = inv[i] * ModInt(i, mod)",
"inv[i-1]",
"inv",
"i-1",
"i",
"1",
"inv[i] * ModInt(i, mod)",
"inv[i]",
"inv",
"i",
"ModInt(i, mod)",
"ModInt",
"i",
"mod",
"ans = ModInt(0, mod)",
"ans",
"ModInt(0, mod)",
"ModInt",
"0",
"mod",
"for hi in range(h - a):\n ans += comb(hi + b - 1, hi) * comb(h - hi - 1 + w - b - 1, w - b - 1)",
"hi",
"range(h - a)",
"range",
"h - a",
"h",
"a",
"ans += comb(hi + b - 1, hi) * comb(h - hi - 1 + w - b - 1, w - b - 1)",
"ans",
"comb(hi + b - 1, hi) * comb(h - hi - 1 + w - b - 1, w - b - 1)",
"comb(hi + b - 1, hi)",
"comb",
"hi + b - 1",
"hi + b",
"hi",
"b",
"1",
"hi",
"comb(h - hi - 1 + w - b - 1, w - b - 1)",
"comb",
"h - hi - 1 + w - b - 1",
"h - hi - 1 + w - b",
"h - hi - 1 + w",
"h - hi - 1",
"h - hi",
"h",
"hi",
"1",
"w",
"b",
"1",
"w - b - 1",
"w - b",
"w",
"b",
"1",
"print(ans)",
"print",
"ans",
"mod = 10 ** 9 + 7",
"10 ** 9 + 7",
"mod",
"inv = [ModInt(1, mod).inverse()] * (h + w - 1)",
"[ModInt(1, mod).inverse()] * (h + w - 1)",
"inv",
"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 = ModInt(0, mod)",
"ModInt(0, mod)",
"ans",
"def comb(n, r):\n return fact[n] * inv[r] * inv[n-r]",
"def comb(n, r):\n return fact[n] * inv[r] * inv[n-r]",
"comb",
"class ModInt:\n def __init__(self, num, mod):\n self.num = num\n self.mod = mod\n\n def __str__(self):\n return str(self.num)\n\n def __repr__(self):\n return \"ModInt(num: {}, mod: {}\".format(self.num, self.mod)\n\n def __add__(self, other):\n ret = self.num + other.num\n ret %= self.mod\n return ModInt(ret, self.mod)\n\n def __sub__(self, other):\n ret = self.num - other.num\n ret %= self.mod\n return ModInt(ret, self.mod)\n\n def __mul__(self, other):\n ret = self.num * other.num\n ret %= self.mod\n return ModInt(ret, self.mod)\n\n def pow(self, times):\n pw = pow(self.num, times, self.mod)\n return ModInt(pw, self.mod)\n\n def inverse(self):\n return self.pow(self.mod - 2)\n\n def __truediv__(self, other):\n num = self * other.inverse()\n return ModInt(num, self.mod)",
"class ModInt:\n def __init__(self, num, mod):\n self.num = num\n self.mod = mod\n\n def __str__(self):\n return str(self.num)\n\n def __repr__(self):\n return \"ModInt(num: {}, mod: {}\".format(self.num, self.mod)\n\n def __add__(self, other):\n ret = self.num + other.num\n ret %= self.mod\n return ModInt(ret, self.mod)\n\n def __sub__(self, other):\n ret = self.num - other.num\n ret %= self.mod\n return ModInt(ret, self.mod)\n\n def __mul__(self, other):\n ret = self.num * other.num\n ret %= self.mod\n return ModInt(ret, self.mod)\n\n def pow(self, times):\n pw = pow(self.num, times, self.mod)\n return ModInt(pw, self.mod)\n\n def inverse(self):\n return self.pow(self.mod - 2)\n\n def __truediv__(self, other):\n num = self * other.inverse()\n return ModInt(num, self.mod)",
"ModInt",
"ans += comb(hi + b - 1, hi) * comb(h - hi - 1 + w - b - 1, w - b - 1)",
"comb(hi + b - 1, hi) * comb(h - hi - 1 + w - b - 1, w - b - 1)",
"ans",
"w, a, b = map(int, input().split())",
"map(int, input().split())",
"w",
"b = map(int, input().split())",
"map(int, input().split())",
"b",
"fact = [ModInt(1, mod)]",
"[ModInt(1, mod)]",
"fact"
] | class ModInt:
def __init__(self, num, mod):
self.num = num
self.mod = mod
def __str__(self):
return str(self.num)
def __repr__(self):
return "ModInt(num: {}, mod: {}".format(self.num, self.mod)
def __add__(self, other):
ret = self.num + other.num
ret %= self.mod
return ModInt(ret, self.mod)
def __sub__(self, other):
ret = self.num - other.num
ret %= self.mod
return ModInt(ret, self.mod)
def __mul__(self, other):
ret = self.num * other.num
ret %= self.mod
return ModInt(ret, self.mod)
def pow(self, times):
pw = pow(self.num, times, self.mod)
return ModInt(pw, self.mod)
def inverse(self):
return self.pow(self.mod - 2)
def __truediv__(self, other):
num = self * other.inverse()
return ModInt(num, self.mod)
h, w, a, b = map(int, input().split())
mod = 10 ** 9 + 7
fact = [ModInt(1, mod)]
inv = [ModInt(1, mod).inverse()] * (h + w - 1)
def comb(n, r):
return fact[n] * inv[r] * inv[n-r]
for i in range(1, h + w - 1):
fact.append(fact[-1] * ModInt(i, mod))
inv[h+w-2] = fact[-1].inverse()
for i in range(h + w - 2, 0, -1):
inv[i-1] = inv[i] * ModInt(i, mod)
ans = ModInt(0, mod)
for hi in range(h - a):
ans += comb(hi + b - 1, hi) * comb(h - hi - 1 + w - b - 1, w - b - 1)
print(ans)
|
[
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,
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,
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,
0,
13,
17,
28,
13,
4,
13,
4,
13,
2,
13,
13,
2,
13,
13,
0,
13,
2,
2,
2,
2,
2,
18,
13,
2,
2,
2,
13,
13,
13,
17,
18,
13,
2,
2,
2,
13,
13,
13,
17,
18,
13,
2,
13,
13,
18,
13,
2,
2,
2,
13,
13,
13,
17,
18,
13,
2,
13,
13,
18,
13,
2,
2,
2,
13,
13,
13,
17,
0,
13,
13,
4,
13,
13,
10,
4,
13,
10,
4,
13,
10,
4,
13,
10,
13,
13,
10,
2,
13,
10,
17,
13,
10,
2,
13,
10,
2,
13,
10,
2,
13,
10,
2,
13,
10,
4,
13
] | [
[
192,
2
],
[
210,
9
],
[
210,
18
],
[
210,
19
],
[
210,
20
],
[
204,
22
],
[
184,
28
],
[
187,
29
],
[
201,
32
],
[
184,
38
],
[
187,
39
],
[
207,
42
],
[
184,
48
],
[
187,
49
],
[
53,
52
],
[
184,
58
],
[
187,
59
],
[
65,
62
],
[
205,
63
],
[
52,
64
],
[
205,
68
],
[
52,
70
],
[
52,
72
],
[
193,
73
],
[
78,
75
],
[
208,
76
],
[
52,
77
],
[
208,
82
],
[
193,
84
],
[
52,
85
],
[
193,
87
],
[
52,
88
],
[
193,
89
],
[
94,
91
],
[
202,
92
],
[
52,
93
],
[
202,
97
],
[
52,
99
],
[
75,
101
],
[
208,
102
],
[
52,
103
],
[
193,
104
],
[
195,
106
],
[
110,
109
],
[
184,
115
],
[
211,
116
],
[
187,
118
],
[
181,
119
],
[
198,
121
],
[
205,
128
],
[
184,
132
],
[
181,
133
],
[
211,
134
],
[
202,
137
],
[
184,
141
],
[
211,
142
],
[
109,
143
],
[
202,
146
],
[
181,
148
],
[
109,
149
],
[
205,
151
],
[
187,
155
],
[
211,
156
],
[
181,
157
],
[
202,
160
],
[
211,
162
],
[
109,
163
],
[
202,
165
],
[
187,
169
],
[
181,
170
],
[
109,
171
],
[
189,
174
],
[
193,
175
],
[
190,
178
],
[
199,
178
],
[
196,
178
],
[
210,
181
],
[
210,
184
],
[
210,
187
],
[
193,
189
],
[
189,
190
],
[
192,
193
],
[
195,
196
],
[
198,
199
],
[
201,
202
],
[
204,
205
],
[
207,
208
],
[
210,
211
]
] | [
"mod = 10**9 + 7\nh, w, a, b = map(int, input().split())\n\nfact = [1] * (h + w + 1)\ninvf = [1] * (h + w + 1)\ninvn = [1] * (h + w + 1)\nfor i in range(2, h + w + 1):\n fact[i] = fact[i-1] * i % mod\n invn[i] = (-invn[mod % i]) * (mod // i) % mod\n invf[i] = invf[i-1] * invn[i] % mod\n\ncount = 0\nfor i in range(min(h-a, w-b)):\n count += fact[h+b-a-1] * invf[h-a-i-1] * invf[b+i] * fact[w+a-b-1] * invf[a+i] * invf[w-b-i-1]\n count %= mod\nprint(count)",
"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",
"invf = [1] * (h + w + 1)",
"invf",
"[1] * (h + w + 1)",
"[1]",
"1",
"h + w + 1",
"h + w",
"h",
"w",
"1",
"invn = [1] * (h + w + 1)",
"invn",
"[1] * (h + w + 1)",
"[1]",
"1",
"h + w + 1",
"h + w",
"h",
"w",
"1",
"for i in range(2, h + w + 1):\n fact[i] = fact[i-1] * i % mod\n invn[i] = (-invn[mod % i]) * (mod // i) % mod\n invf[i] = invf[i-1] * invn[i] % mod",
"i",
"range(2, h + w + 1)",
"range",
"2",
"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",
"invn[i] = (-invn[mod % i]) * (mod // i) % mod",
"invn[i]",
"invn",
"i",
"(-invn[mod % i]) * (mod // i) % mod",
"(-invn[mod % i]) * (mod // i)",
"-invn[mod % i]",
"invn[mod % i]",
"invn",
"mod % i",
"mod",
"i",
"mod // i",
"mod",
"i",
"mod",
"invf[i] = invf[i-1] * invn[i] % mod",
"invf[i]",
"invf",
"i",
"invf[i-1] * invn[i] % mod",
"invf[i-1] * invn[i]",
"invf[i-1]",
"invf",
"i-1",
"i",
"1",
"invn[i]",
"invn",
"i",
"mod",
"count = 0",
"count",
"0",
"for i in range(min(h-a, w-b)):\n count += fact[h+b-a-1] * invf[h-a-i-1] * invf[b+i] * fact[w+a-b-1] * invf[a+i] * invf[w-b-i-1]\n count %= mod",
"i",
"range(min(h-a, w-b))",
"range",
"min(h-a, w-b)",
"min",
"h-a",
"h",
"a",
"w-b",
"w",
"b",
"count += fact[h+b-a-1] * invf[h-a-i-1] * invf[b+i] * fact[w+a-b-1] * invf[a+i] * invf[w-b-i-1]",
"count",
"fact[h+b-a-1] * invf[h-a-i-1] * invf[b+i] * fact[w+a-b-1] * invf[a+i] * invf[w-b-i-1]",
"fact[h+b-a-1] * invf[h-a-i-1] * invf[b+i] * fact[w+a-b-1] * invf[a+i]",
"fact[h+b-a-1] * invf[h-a-i-1] * invf[b+i] * fact[w+a-b-1]",
"fact[h+b-a-1] * invf[h-a-i-1] * invf[b+i]",
"fact[h+b-a-1] * invf[h-a-i-1]",
"fact[h+b-a-1]",
"fact",
"h+b-a-1",
"h+b-a",
"h+b",
"h",
"b",
"a",
"1",
"invf[h-a-i-1]",
"invf",
"h-a-i-1",
"h-a-i",
"h-a",
"h",
"a",
"i",
"1",
"invf[b+i]",
"invf",
"b+i",
"b",
"i",
"fact[w+a-b-1]",
"fact",
"w+a-b-1",
"w+a-b",
"w+a",
"w",
"a",
"b",
"1",
"invf[a+i]",
"invf",
"a+i",
"a",
"i",
"invf[w-b-i-1]",
"invf",
"w-b-i-1",
"w-b-i",
"w-b",
"w",
"b",
"i",
"1",
"count %= mod",
"count",
"mod",
"print(count)",
"print",
"count",
"b = map(int, input().split())",
"map(int, input().split())",
"b",
"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",
"count %= mod",
"mod",
"count",
"mod = 10**9 + 7",
"10**9 + 7",
"mod",
"count = 0",
"0",
"count",
"count += fact[h+b-a-1] * invf[h-a-i-1] * invf[b+i] * fact[w+a-b-1] * invf[a+i] * invf[w-b-i-1]",
"fact[h+b-a-1] * invf[h-a-i-1] * invf[b+i] * fact[w+a-b-1] * invf[a+i] * invf[w-b-i-1]",
"count",
"invf = [1] * (h + w + 1)",
"[1] * (h + w + 1)",
"invf",
"fact = [1] * (h + w + 1)",
"[1] * (h + w + 1)",
"fact",
"invn = [1] * (h + w + 1)",
"[1] * (h + w + 1)",
"invn",
"a, b = map(int, input().split())",
"map(int, input().split())",
"a"
] | mod = 10**9 + 7
h, w, a, b = map(int, input().split())
fact = [1] * (h + w + 1)
invf = [1] * (h + w + 1)
invn = [1] * (h + w + 1)
for i in range(2, h + w + 1):
fact[i] = fact[i-1] * i % mod
invn[i] = (-invn[mod % i]) * (mod // i) % mod
invf[i] = invf[i-1] * invn[i] % mod
count = 0
for i in range(min(h-a, w-b)):
count += fact[h+b-a-1] * invf[h-a-i-1] * invf[b+i] * fact[w+a-b-1] * invf[a+i] * invf[w-b-i-1]
count %= mod
print(count) |
[
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,
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,
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,
0,
13,
18,
13,
17,
13,
18,
13,
17,
29,
2,
2,
13,
2,
13,
13,
13,
23,
13,
23,
13,
0,
13,
2,
2,
17,
2,
17,
17,
17,
41,
28,
13,
4,
13,
13,
4,
17,
0,
13,
13,
41,
28,
13,
4,
13,
13,
4,
17,
0,
13,
13,
0,
18,
13,
17,
17,
0,
18,
13,
17,
17,
0,
18,
13,
17,
17,
0,
18,
13,
17,
17,
28,
13,
4,
13,
17,
13,
0,
18,
13,
13,
2,
2,
18,
13,
2,
13,
17,
13,
13,
0,
18,
13,
13,
2,
2,
18,
13,
2,
13,
17,
4,
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,
17,
0,
13,
17,
42,
2,
13,
4,
13,
2,
13,
13,
2,
13,
13,
0,
13,
2,
4,
13,
2,
2,
2,
13,
13,
13,
17,
2,
13,
13,
4,
13,
2,
2,
2,
13,
13,
13,
17,
2,
13,
13,
0,
13,
13,
0,
13,
17,
4,
13,
13,
10,
2,
13,
10,
4,
13,
10,
13,
13,
10,
17,
13,
10,
17,
13,
10,
17,
13,
10,
13,
13,
10,
12,
13,
10,
2,
13,
10,
4,
13,
10,
13,
13,
10,
12,
13,
10,
2,
13,
10,
4,
13,
10,
4,
13
] | [
[
311,
2
],
[
311,
11
],
[
311,
12
],
[
311,
13
],
[
305,
15
],
[
25,
24
],
[
31,
30
],
[
30,
38
],
[
297,
38
],
[
84,
38
],
[
43,
42
],
[
24,
45
],
[
81,
45
],
[
30,
48
],
[
297,
48
],
[
84,
48
],
[
52,
51
],
[
24,
55
],
[
81,
55
],
[
42,
58
],
[
30,
60
],
[
297,
60
],
[
84,
60
],
[
24,
64
],
[
81,
64
],
[
42,
67
],
[
30,
69
],
[
297,
69
],
[
84,
69
],
[
24,
73
],
[
81,
73
],
[
42,
76
],
[
30,
78
],
[
297,
78
],
[
84,
78
],
[
82,
81
],
[
30,
82
],
[
297,
82
],
[
84,
82
],
[
85,
84
],
[
51,
85
],
[
88,
87
],
[
84,
89
],
[
30,
89
],
[
297,
89
],
[
92,
91
],
[
84,
93
],
[
30,
93
],
[
297,
93
],
[
106,
98
],
[
87,
100
],
[
106,
101
],
[
106,
102
],
[
104,
104
],
[
106,
106
],
[
269,
108
],
[
119,
118
],
[
270,
121
],
[
275,
125
],
[
130,
129
],
[
270,
132
],
[
299,
136
],
[
147,
139
],
[
276,
140
],
[
147,
144
],
[
276,
145
],
[
157,
149
],
[
300,
150
],
[
157,
154
],
[
300,
155
],
[
160,
159
],
[
270,
163
],
[
168,
165
],
[
276,
166
],
[
159,
167
],
[
276,
171
],
[
159,
173
],
[
159,
175
],
[
306,
176
],
[
181,
178
],
[
300,
179
],
[
159,
180
],
[
300,
184
],
[
159,
186
],
[
303,
189
],
[
159,
190
],
[
306,
191
],
[
306,
192
],
[
276,
200
],
[
212,
201
],
[
300,
203
],
[
214,
204
],
[
300,
206
],
[
212,
208
],
[
214,
209
],
[
306,
210
],
[
212,
212
],
[
214,
214
],
[
284,
216
],
[
281,
219
],
[
282,
223
],
[
279,
223
],
[
297,
227
],
[
273,
228
],
[
312,
230
],
[
309,
231
],
[
293,
233
],
[
291,
236
],
[
273,
240
],
[
312,
241
],
[
309,
242
],
[
273,
245
],
[
282,
246
],
[
279,
246
],
[
291,
248
],
[
309,
252
],
[
297,
253
],
[
273,
254
],
[
309,
257
],
[
282,
258
],
[
279,
258
],
[
287,
260
],
[
306,
261
],
[
278,
263
],
[
288,
267
],
[
294,
267
],
[
285,
267
],
[
269,
270
],
[
311,
273
],
[
275,
276
],
[
278,
279
],
[
281,
282
],
[
284,
285
],
[
306,
287
],
[
287,
288
],
[
293,
294
],
[
311,
297
],
[
299,
300
],
[
305,
306
],
[
311,
309
],
[
311,
312
]
] | [
"h,w,a,b = map(int,input().split())\nmod = 10 ** 9 + 7\n\ndef inv(a,mod):\n r = [1,0,a]\n w = [0,1,mod]\n while w[2]!=1:\n q = r[2]//w[2]\n r_new = [r[0]-q*w[0],r[1]-q*w[1],r[2]-q*w[2]]\n r = w\n w = r_new\n x,y = w[0],w[1] # a*x+y*mod = 1\n return (mod+x%mod)%mod\n\nmax_num = 2*10**5+1\nfact = [0 for _ in range(max_num)]\nifact = [0 for _ in range(max_num)]\n\nfact[0] = fact[1] = 1\nifact[0] = ifact[1] = 1\n\nfor i in range(2,max_num):\n fact[i] = fact[i-1] * i % mod\n ifact[i] = ifact[i-1] * inv(i,mod) % mod\n\ndef cmb(x,y):\n return fact[x] * ifact[y] * ifact[x-y] % mod\n\nans = 0\n\nj = 0\nwhile j < min(w-b,h-a):\n ans += cmb(b+h-a-1,b+j)*cmb(a+w-b-1,a+j)\n ans %= mod\n j += 1\n\nprint(ans)",
"h,w,a,b = map(int,input().split())",
"h",
"map(int,input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"w",
"a",
"b",
"mod = 10 ** 9 + 7",
"mod",
"10 ** 9 + 7",
"10 ** 9",
"10",
"9",
"7",
"def inv(a,mod):\n r = [1,0,a]\n w = [0,1,mod]\n while w[2]!=1:\n q = r[2]//w[2]\n r_new = [r[0]-q*w[0],r[1]-q*w[1],r[2]-q*w[2]]\n r = w\n w = r_new\n x,y = w[0],w[1] # a*x+y*mod = 1\n return (mod+x%mod)%mod",
"inv",
"r = [1,0,a]",
"r",
"[1,0,a]",
"1",
"0",
"a",
"w = [0,1,mod]",
"w",
"[0,1,mod]",
"0",
"1",
"mod",
"while w[2]!=1:\n q = r[2]//w[2]\n r_new = [r[0]-q*w[0],r[1]-q*w[1],r[2]-q*w[2]]\n r = w\n w = r_new\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",
"r_new = [r[0]-q*w[0],r[1]-q*w[1],r[2]-q*w[2]]",
"r_new",
"[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 = w",
"r",
"w",
"w = r_new",
"w",
"r_new",
"x,y = w[0],w[1]",
"x",
"w[0]",
"w",
"0",
"y",
"w[1]",
"w",
"1",
"return (mod+x%mod)%mod",
"(mod+x%mod)%mod",
"mod+x%mod",
"mod",
"x%mod",
"x",
"mod",
"mod",
"a",
"a",
"mod",
"mod",
"max_num = 2*10**5+1",
"max_num",
"2*10**5+1",
"2*10**5",
"2",
"10**5",
"10",
"5",
"1",
"0 for _ in range(max_num)",
"for _ in range(max_num)",
"_",
"range(max_num)",
"range",
"max_num",
"for _ in range(max_num)",
"0",
"fact = [0 for _ in range(max_num)]",
"fact",
"[0 for _ in range(max_num)]",
"0 for _ in range(max_num)",
"for _ in range(max_num)",
"_",
"range(max_num)",
"range",
"max_num",
"for _ in range(max_num)",
"0",
"ifact = [0 for _ in range(max_num)]",
"ifact",
"[0 for _ in range(max_num)]",
"fact[0] = fact[1] = 1",
"fact[0]",
"fact",
"0",
"1",
"= fact[1] = 1",
"fact[1]",
"fact",
"1",
"1",
"ifact[0] = ifact[1] = 1",
"ifact[0]",
"ifact",
"0",
"1",
"= ifact[1] = 1",
"ifact[1]",
"ifact",
"1",
"1",
"for i in range(2,max_num):\n fact[i] = fact[i-1] * i % mod\n ifact[i] = ifact[i-1] * inv(i,mod) % mod",
"i",
"range(2,max_num)",
"range",
"2",
"max_num",
"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[i] = ifact[i-1] * inv(i,mod) % mod",
"ifact[i]",
"ifact",
"i",
"ifact[i-1] * inv(i,mod) % mod",
"ifact[i-1] * inv(i,mod)",
"ifact[i-1]",
"ifact",
"i-1",
"i",
"1",
"inv(i,mod)",
"inv",
"i",
"mod",
"mod",
"def cmb(x,y):\n return fact[x] * ifact[y] * ifact[x-y] % mod",
"cmb",
"return fact[x] * ifact[y] * ifact[x-y] % mod",
"fact[x] * ifact[y] * ifact[x-y] % mod",
"fact[x] * ifact[y] * ifact[x-y]",
"fact[x] * ifact[y]",
"fact[x]",
"fact",
"x",
"ifact[y]",
"ifact",
"y",
"ifact[x-y]",
"ifact",
"x-y",
"x",
"y",
"mod",
"x",
"x",
"y",
"y",
"ans = 0",
"ans",
"0",
"j = 0",
"j",
"0",
"while j < min(w-b,h-a):\n ans += cmb(b+h-a-1,b+j)*cmb(a+w-b-1,a+j)\n ans %= mod\n j += 1",
"j < min(w-b,h-a)",
"j",
"min(w-b,h-a)",
"min",
"w-b",
"w",
"b",
"h-a",
"h",
"a",
"ans += cmb(b+h-a-1,b+j)*cmb(a+w-b-1,a+j)",
"ans",
"cmb(b+h-a-1,b+j)*cmb(a+w-b-1,a+j)",
"cmb(b+h-a-1,b+j)",
"cmb",
"b+h-a-1",
"b+h-a",
"b+h",
"b",
"h",
"a",
"1",
"b+j",
"b",
"j",
"cmb(a+w-b-1,a+j)",
"cmb",
"a+w-b-1",
"a+w-b",
"a+w",
"a",
"w",
"b",
"1",
"a+j",
"a",
"j",
"ans %= mod",
"ans",
"mod",
"j += 1",
"j",
"1",
"print(ans)",
"print",
"ans",
"max_num = 2*10**5+1",
"2*10**5+1",
"max_num",
"b = map(int,input().split())",
"map(int,input().split())",
"b",
"fact = [0 for _ in range(max_num)]",
"[0 for _ in range(max_num)]",
"fact",
"j += 1",
"1",
"j",
"j = 0",
"0",
"j",
"ans = 0",
"0",
"ans",
"ans %= mod",
"mod",
"ans",
"def cmb(x,y):\n return fact[x] * ifact[y] * ifact[x-y] % mod",
"def cmb(x,y):\n return fact[x] * ifact[y] * ifact[x-y] % mod",
"cmb",
"ans += cmb(b+h-a-1,b+j)*cmb(a+w-b-1,a+j)",
"cmb(b+h-a-1,b+j)*cmb(a+w-b-1,a+j)",
"ans",
"w,a,b = map(int,input().split())",
"map(int,input().split())",
"w",
"ifact = [0 for _ in range(max_num)]",
"[0 for _ in range(max_num)]",
"ifact",
"def inv(a,mod):\n r = [1,0,a]\n w = [0,1,mod]\n while w[2]!=1:\n q = r[2]//w[2]\n r_new = [r[0]-q*w[0],r[1]-q*w[1],r[2]-q*w[2]]\n r = w\n w = r_new\n x,y = w[0],w[1] # a*x+y*mod = 1\n return (mod+x%mod)%mod",
"def inv(a,mod):\n r = [1,0,a]\n w = [0,1,mod]\n while w[2]!=1:\n q = r[2]//w[2]\n r_new = [r[0]-q*w[0],r[1]-q*w[1],r[2]-q*w[2]]\n r = w\n w = r_new\n x,y = w[0],w[1] # a*x+y*mod = 1\n return (mod+x%mod)%mod",
"inv",
"mod = 10 ** 9 + 7",
"10 ** 9 + 7",
"mod",
"a,b = map(int,input().split())",
"map(int,input().split())",
"a",
"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
def inv(a,mod):
r = [1,0,a]
w = [0,1,mod]
while w[2]!=1:
q = r[2]//w[2]
r_new = [r[0]-q*w[0],r[1]-q*w[1],r[2]-q*w[2]]
r = w
w = r_new
x,y = w[0],w[1] # a*x+y*mod = 1
return (mod+x%mod)%mod
max_num = 2*10**5+1
fact = [0 for _ in range(max_num)]
ifact = [0 for _ in range(max_num)]
fact[0] = fact[1] = 1
ifact[0] = ifact[1] = 1
for i in range(2,max_num):
fact[i] = fact[i-1] * i % mod
ifact[i] = ifact[i-1] * inv(i,mod) % mod
def cmb(x,y):
return fact[x] * ifact[y] * ifact[x-y] % mod
ans = 0
j = 0
while j < min(w-b,h-a):
ans += cmb(b+h-a-1,b+j)*cmb(a+w-b-1,a+j)
ans %= mod
j += 1
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,
2,
13,
13,
17,
41,
28,
13,
4,
13,
13,
4,
17,
0,
13,
13,
41,
28,
13,
4,
13,
13,
4,
17,
0,
13,
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,
13,
12,
13,
14,
2,
2,
2,
13,
13,
2,
13,
17,
2,
13,
17,
29,
17,
29,
2,
2,
2,
2,
18,
13,
13,
18,
13,
13,
13,
18,
13,
2,
13,
13,
13,
23,
13,
23,
13,
12,
13,
29,
4,
13,
2,
2,
13,
13,
17,
2,
13,
17,
23,
13,
23,
13,
0,
13,
17,
28,
13,
4,
13,
2,
13,
17,
2,
13,
17,
0,
13,
2,
2,
4,
13,
2,
13,
13,
13,
4,
13,
13,
2,
2,
13,
13,
17,
13,
0,
13,
13,
4,
13,
13,
10,
4,
13,
10,
4,
13,
10,
12,
13,
10,
2,
13,
10,
12,
13,
10,
13,
13,
10,
17,
13,
10,
4,
13,
10,
13,
13,
10,
13,
13,
10,
4,
13,
10,
2,
13,
10,
2,
13
] | [
[
206,
2
],
[
206,
11
],
[
206,
12
],
[
206,
13
],
[
209,
15
],
[
185,
22
],
[
198,
25
],
[
177,
26
],
[
31,
30
],
[
186,
33
],
[
203,
37
],
[
42,
41
],
[
186,
44
],
[
191,
48
],
[
52,
51
],
[
186,
55
],
[
60,
57
],
[
204,
58
],
[
51,
59
],
[
204,
63
],
[
51,
65
],
[
51,
67
],
[
210,
68
],
[
73,
70
],
[
192,
71
],
[
51,
72
],
[
57,
75
],
[
204,
76
],
[
51,
77
],
[
210,
79
],
[
210,
81
],
[
117,
88
],
[
119,
89
],
[
117,
91
],
[
119,
94
],
[
204,
104
],
[
117,
105
],
[
192,
107
],
[
119,
108
],
[
210,
109
],
[
192,
111
],
[
117,
113
],
[
119,
114
],
[
210,
115
],
[
117,
117
],
[
119,
119
],
[
189,
124
],
[
134,
127
],
[
136,
128
],
[
134,
131
],
[
134,
134
],
[
136,
136
],
[
194,
138
],
[
142,
141
],
[
180,
145
],
[
177,
148
],
[
212,
151
],
[
183,
155
],
[
198,
157
],
[
207,
158
],
[
141,
159
],
[
183,
161
],
[
207,
162
],
[
177,
165
],
[
141,
166
],
[
210,
168
],
[
200,
170
],
[
210,
171
],
[
201,
174
],
[
213,
174
],
[
195,
174
],
[
206,
177
],
[
206,
180
],
[
185,
186
],
[
191,
192
],
[
194,
195
],
[
206,
198
],
[
210,
200
],
[
200,
201
],
[
203,
204
],
[
206,
207
],
[
209,
210
],
[
212,
213
]
] | [
"h, w, a, b = map(int, input().split())\n\nMOD = 10**9 + 7\nMAX = h+w + 5\nfact = [1 for _ in range(MAX)]\nfinv = [1 for _ in range(MAX)]\nfor i in range(2, MAX):\n fact[i] = fact[i - 1] * i % MOD\n finv[i] = pow(fact[i], MOD-2, MOD)\n\ndef comb(n: int, k: int) -> int:\n if n < k or n < 0 or k < 0:\n return 0\n return (fact[n] * finv[k] % MOD) * finv[n-k] % MOD\n\ndef path(x, y):\n return comb(x+y-2, x-1)\n\nans = 0\nfor j in range(b+1, w+1):\n # print((h-a, j), (a, w-j+1))\n ans += (path(h-a, j) * path(a, w-j+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",
"MOD = 10**9 + 7",
"MOD",
"10**9 + 7",
"10**9",
"10",
"9",
"7",
"MAX = h+w + 5",
"MAX",
"h+w + 5",
"h+w",
"h",
"w",
"5",
"1 for _ in range(MAX)",
"for _ in range(MAX)",
"_",
"range(MAX)",
"range",
"MAX",
"for _ in range(MAX)",
"1",
"fact = [1 for _ in range(MAX)]",
"fact",
"[1 for _ in range(MAX)]",
"1 for _ in range(MAX)",
"for _ in range(MAX)",
"_",
"range(MAX)",
"range",
"MAX",
"for _ in range(MAX)",
"1",
"finv = [1 for _ in range(MAX)]",
"finv",
"[1 for _ in range(MAX)]",
"for i in range(2, MAX):\n fact[i] = fact[i - 1] * i % MOD\n finv[i] = pow(fact[i], MOD-2, MOD)",
"i",
"range(2, MAX)",
"range",
"2",
"MAX",
"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",
"finv[i] = pow(fact[i], MOD-2, MOD)",
"finv[i]",
"finv",
"i",
"pow(fact[i], MOD-2, MOD)",
"pow",
"fact[i]",
"fact",
"i",
"MOD-2",
"MOD",
"2",
"MOD",
"def comb(n: int, k: int) -> int:\n if n < k or n < 0 or k < 0:\n return 0\n return (fact[n] * finv[k] % MOD) * finv[n-k] % MOD",
"comb",
"if n < k or n < 0 or k < 0:\n return 0\n ",
"n < k or n < 0 or k < 0",
"n < k or n < 0",
"n < k",
"n",
"k",
"n < 0",
"n",
"0",
"k < 0",
"k",
"0",
"return 0",
"0",
"return (fact[n] * finv[k] % MOD) * finv[n-k] % MOD",
"(fact[n] * finv[k] % MOD) * finv[n-k] % MOD",
"(fact[n] * finv[k] % MOD) * finv[n-k]",
"fact[n] * finv[k] % MOD",
"fact[n] * finv[k]",
"fact[n]",
"fact",
"n",
"finv[k]",
"finv",
"k",
"MOD",
"finv[n-k]",
"finv",
"n-k",
"n",
"k",
"MOD",
"n: int",
"n",
"k: int",
"k",
"def path(x, y):\n return comb(x+y-2, x-1)",
"path",
"return comb(x+y-2, x-1)",
"comb(x+y-2, x-1)",
"comb",
"x+y-2",
"x+y",
"x",
"y",
"2",
"x-1",
"x",
"1",
"x",
"x",
"y",
"y",
"ans = 0",
"ans",
"0",
"for j in range(b+1, w+1):\n # print((h-a, j), (a, w-j+1))\n ans += (path(h-a, j) * path(a, w-j+1)) % MOD\n ans %= MOD",
"j",
"range(b+1, w+1)",
"range",
"b+1",
"b",
"1",
"w+1",
"w",
"1",
"ans += (path(h-a, j) * path(a, w-j+1)) % MOD",
"ans",
"(path(h-a, j) * path(a, w-j+1)) % MOD",
"path(h-a, j) * path(a, w-j+1)",
"path(h-a, j)",
"path",
"h-a",
"h",
"a",
"j",
"path(a, w-j+1)",
"path",
"a",
"w-j+1",
"w-j",
"w",
"j",
"1",
"MOD",
"ans %= MOD",
"ans",
"MOD",
"print(ans)",
"print",
"ans",
"w, a, b = map(int, input().split())",
"map(int, input().split())",
"w",
"b = map(int, input().split())",
"map(int, input().split())",
"b",
"def path(x, y):\n return comb(x+y-2, x-1)",
"def path(x, y):\n return comb(x+y-2, x-1)",
"path",
"MAX = h+w + 5",
"h+w + 5",
"MAX",
"def comb(n: int, k: int) -> int:\n if n < k or n < 0 or k < 0:\n return 0\n return (fact[n] * finv[k] % MOD) * finv[n-k] % MOD",
"def comb(n: int, k: int) -> int:\n if n < k or n < 0 or k < 0:\n return 0\n return (fact[n] * finv[k] % MOD) * finv[n-k] % MOD",
"comb",
"finv = [1 for _ in range(MAX)]",
"[1 for _ in range(MAX)]",
"finv",
"ans = 0",
"0",
"ans",
"h, w, a, b = map(int, input().split())",
"map(int, input().split())",
"h",
"ans %= MOD",
"MOD",
"ans",
"fact = [1 for _ in range(MAX)]",
"[1 for _ in range(MAX)]",
"fact",
"a, b = map(int, input().split())",
"map(int, input().split())",
"a",
"MOD = 10**9 + 7",
"10**9 + 7",
"MOD",
"ans += (path(h-a, j) * path(a, w-j+1)) % MOD",
"(path(h-a, j) * path(a, w-j+1)) % MOD",
"ans"
] | h, w, a, b = map(int, input().split())
MOD = 10**9 + 7
MAX = h+w + 5
fact = [1 for _ in range(MAX)]
finv = [1 for _ in range(MAX)]
for i in range(2, MAX):
fact[i] = fact[i - 1] * i % MOD
finv[i] = pow(fact[i], MOD-2, MOD)
def comb(n: int, k: int) -> int:
if n < k or n < 0 or k < 0:
return 0
return (fact[n] * finv[k] % MOD) * finv[n-k] % MOD
def path(x, y):
return comb(x+y-2, x-1)
ans = 0
for j in range(b+1, w+1):
# print((h-a, j), (a, w-j+1))
ans += (path(h-a, j) * path(a, w-j+1)) % MOD
ans %= MOD
print(ans)
|
[
7,
0,
13,
4,
13,
4,
13,
13,
4,
18,
4,
13,
13,
13,
13,
13,
12,
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,
0,
18,
13,
17,
17,
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,
18,
13,
13,
4,
13,
18,
13,
13,
2,
13,
17,
13,
12,
13,
14,
2,
2,
2,
13,
13,
2,
13,
17,
2,
13,
17,
29,
17,
29,
2,
2,
18,
13,
13,
2,
18,
13,
13,
18,
13,
2,
13,
13,
13,
23,
13,
23,
13,
0,
13,
39,
2,
13,
17,
2,
13,
17,
0,
13,
2,
13,
17,
0,
13,
2,
13,
13,
0,
13,
39,
2,
13,
17,
2,
13,
17,
0,
13,
39,
28,
13,
4,
13,
13,
13,
4,
18,
13,
13,
39,
13,
18,
13,
17,
0,
13,
17,
28,
13,
13,
0,
13,
13,
13,
0,
13,
4,
13,
2,
13,
13,
13,
0,
13,
17,
0,
13,
2,
18,
13,
17,
13,
13,
2,
18,
13,
17,
13,
0,
13,
4,
13,
2,
13,
13,
13,
0,
13,
2,
2,
13,
13,
2,
2,
2,
13,
13,
13,
13,
29,
2,
13,
13,
0,
13,
4,
13,
4,
13,
13,
10,
12,
13,
10,
4,
13,
10,
4,
13,
10,
4,
13,
10,
4,
13,
10,
4,
13
] | [
[
254,
2
],
[
254,
13
],
[
254,
14
],
[
254,
15
],
[
20,
19
],
[
27,
26
],
[
246,
32
],
[
252,
33
],
[
37,
36
],
[
246,
42
],
[
252,
43
],
[
49,
46
],
[
26,
47
],
[
53,
50
],
[
36,
51
],
[
56,
55
],
[
246,
61
],
[
252,
62
],
[
68,
65
],
[
26,
66
],
[
55,
67
],
[
26,
71
],
[
55,
73
],
[
55,
75
],
[
19,
76
],
[
81,
78
],
[
36,
79
],
[
55,
80
],
[
65,
83
],
[
26,
84
],
[
55,
85
],
[
19,
87
],
[
19,
89
],
[
123,
96
],
[
125,
97
],
[
123,
99
],
[
125,
102
],
[
26,
110
],
[
123,
111
],
[
36,
114
],
[
125,
115
],
[
36,
117
],
[
123,
119
],
[
125,
120
],
[
19,
121
],
[
123,
123
],
[
125,
125
],
[
128,
127
],
[
252,
130
],
[
246,
133
],
[
137,
136
],
[
243,
138
],
[
142,
141
],
[
246,
143
],
[
255,
144
],
[
147,
146
],
[
136,
149
],
[
141,
152
],
[
156,
155
],
[
159,
158
],
[
243,
161
],
[
252,
162
],
[
155,
165
],
[
146,
170
],
[
174,
173
],
[
177,
176
],
[
155,
176
],
[
180,
179
],
[
176,
180
],
[
180,
181
],
[
184,
183
],
[
91,
185
],
[
179,
187
],
[
181,
188
],
[
191,
188
],
[
179,
189
],
[
192,
191
],
[
195,
194
],
[
127,
197
],
[
179,
199
],
[
201,
200
],
[
127,
203
],
[
191,
205
],
[
181,
205
],
[
208,
207
],
[
91,
209
],
[
194,
211
],
[
200,
212
],
[
194,
213
],
[
216,
215
],
[
173,
218
],
[
215,
218
],
[
19,
219
],
[
183,
223
],
[
207,
224
],
[
19,
225
],
[
19,
226
],
[
215,
229
],
[
173,
229
],
[
19,
230
],
[
248,
232
],
[
240,
234
],
[
249,
237
],
[
254,
243
],
[
254,
246
],
[
248,
249
],
[
254,
252
],
[
254,
255
]
] | [
"H, W, A, B = list(map(int, input().split()))\n \n# 事前計算 + 演算ごとに mod する\ndef solve():\n # 組合せの計算用に階乗を事前計算しておく\n MOD = 10 ** 9 + 7\n FACT = [0] * (H + W + 1)\n INV_FACT = [0] * (H + W + 1) # 逆元. 組合せの計算ごとにMODを取るため\n \n FACT[0], INV_FACT[0] = 1, 1\n for i in range(1, (H + W + 1)):\n FACT[i] = (FACT[i - 1] * i) % MOD\n INV_FACT[i] = pow(FACT[i], MOD - 2, MOD) # フェルマーの小定理を使う\n \n def mod_nCr(n, r):\n if n < r or n == 0 or r == 0:\n return 1\n \n return FACT[n] * (INV_FACT[r] * INV_FACT[n - r]) % MOD\n \n # print(H, W, A, B)\n \n # 座標は(x, y). startは(0, 0)\n goal = W - 1, H - 1\n \n # 境界点: 移動できないエリアの右上の点\n nx = B - 1\n ny = H - A\n \n # 境界点から右斜め上に1つ移動した点(choke_left)から, 右端へ伸びる線がchoke points\n choke_left = nx + 1, ny - 1\n \n choke_points = []\n for i in range(B, W):\n choke_points.append((i, choke_left[1]))\n \n # 組合せを計算する: startからcp1, cp2からgoalまで組合せを掛ける\n ans = 0\n for cp1 in choke_points:\n x, y = cp1\n from_start_to_cp1 = mod_nCr(x + y, x)\n \n # cp1から1つ下の点がcp2\n y += 1\n dx, dy = goal[0] - x, goal[1] - y\n from_cp2_to_goal = mod_nCr(dx + dy, dx)\n \n ans = ans % MOD + (from_start_to_cp1 * from_cp2_to_goal % MOD) % MOD\n \n return ans % MOD\n \nres = solve()\nprint(res)",
"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",
"def solve():\n # 組合せの計算用に階乗を事前計算しておく\n MOD = 10 ** 9 + 7\n FACT = [0] * (H + W + 1)\n INV_FACT = [0] * (H + W + 1) # 逆元. 組合せの計算ごとにMODを取るため\n \n FACT[0], INV_FACT[0] = 1, 1\n for i in range(1, (H + W + 1)):\n FACT[i] = (FACT[i - 1] * i) % MOD\n INV_FACT[i] = pow(FACT[i], MOD - 2, MOD) # フェルマーの小定理を使う\n \n def mod_nCr(n, r):\n if n < r or n == 0 or r == 0:\n return 1\n \n return FACT[n] * (INV_FACT[r] * INV_FACT[n - r]) % MOD\n \n # print(H, W, A, B)\n \n # 座標は(x, y). startは(0, 0)\n goal = W - 1, H - 1\n \n # 境界点: 移動できないエリアの右上の点\n nx = B - 1\n ny = H - A\n \n # 境界点から右斜め上に1つ移動した点(choke_left)から, 右端へ伸びる線がchoke points\n choke_left = nx + 1, ny - 1\n \n choke_points = []\n for i in range(B, W):\n choke_points.append((i, choke_left[1]))\n \n # 組合せを計算する: startからcp1, cp2からgoalまで組合せを掛ける\n ans = 0\n for cp1 in choke_points:\n x, y = cp1\n from_start_to_cp1 = mod_nCr(x + y, x)\n \n # cp1から1つ下の点がcp2\n y += 1\n dx, dy = goal[0] - x, goal[1] - y\n from_cp2_to_goal = mod_nCr(dx + dy, dx)\n \n ans = ans % MOD + (from_start_to_cp1 * from_cp2_to_goal % MOD) % MOD\n \n return ans % MOD\n ",
"solve",
"MOD = 10 ** 9 + 7",
"MOD",
"10 ** 9 + 7",
"10 ** 9",
"10",
"9",
"7",
"FACT = [0] * (H + W + 1)",
"FACT",
"[0] * (H + W + 1)",
"[0]",
"0",
"H + W + 1",
"H + W",
"H",
"W",
"1",
"INV_FACT = [0] * (H + W + 1)",
"INV_FACT",
"[0] * (H + W + 1)",
"[0]",
"0",
"H + W + 1",
"H + W",
"H",
"W",
"1",
"FACT[0], INV_FACT[0] = 1, 1",
"FACT[0]",
"FACT",
"0",
"1",
"INV_FACT[0]",
"INV_FACT",
"0",
"1",
"for i in range(1, (H + W + 1)):\n FACT[i] = (FACT[i - 1] * i) % MOD\n INV_FACT[i] = pow(FACT[i], MOD - 2, MOD) # フェルマーの小定理を使う\n \n ",
"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",
"INV_FACT[i] = pow(FACT[i], MOD - 2, MOD)",
"INV_FACT[i]",
"INV_FACT",
"i",
"pow(FACT[i], MOD - 2, MOD)",
"pow",
"FACT[i]",
"FACT",
"i",
"MOD - 2",
"MOD",
"2",
"MOD",
"def mod_nCr(n, r):\n if n < r or n == 0 or r == 0:\n return 1\n \n return FACT[n] * (INV_FACT[r] * INV_FACT[n - r]) % MOD\n \n # print(H, W, A, B)\n \n # 座標は(x, y). startは(0, 0)\n ",
"mod_nCr",
"if n < r or n == 0 or r == 0:\n return 1\n \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 1",
"1",
"return FACT[n] * (INV_FACT[r] * INV_FACT[n - r]) % MOD",
"FACT[n] * (INV_FACT[r] * INV_FACT[n - r]) % MOD",
"FACT[n] * (INV_FACT[r] * INV_FACT[n - r])",
"FACT[n]",
"FACT",
"n",
"INV_FACT[r] * INV_FACT[n - r]",
"INV_FACT[r]",
"INV_FACT",
"r",
"INV_FACT[n - r]",
"INV_FACT",
"n - r",
"n",
"r",
"MOD",
"n",
"n",
"r",
"r",
"goal = W - 1, H - 1",
"goal",
"goal = W - 1, H - 1",
"W - 1",
"W",
"1",
"H - 1",
"H",
"1",
"nx = B - 1",
"nx",
"B - 1",
"B",
"1",
"ny = H - A",
"ny",
"H - A",
"H",
"A",
"choke_left = nx + 1, ny - 1",
"choke_left",
"choke_left = nx + 1, ny - 1",
"nx + 1",
"nx",
"1",
"ny - 1",
"ny",
"1",
"choke_points = []",
"choke_points",
"[]",
"for i in range(B, W):\n choke_points.append((i, choke_left[1]))\n \n # 組合せを計算する: startからcp1, cp2からgoalまで組合せを掛ける\n ",
"i",
"range(B, W)",
"range",
"B",
"W",
"choke_points.append((i, choke_left[1]))",
"choke_points.append",
"choke_points",
"append",
"(i, choke_left[1])",
"i",
"choke_left[1]",
"choke_left",
"1",
"ans = 0",
"ans",
"0",
"for cp1 in choke_points:\n x, y = cp1\n from_start_to_cp1 = mod_nCr(x + y, x)\n \n # cp1から1つ下の点がcp2\n y += 1\n dx, dy = goal[0] - x, goal[1] - y\n from_cp2_to_goal = mod_nCr(dx + dy, dx)\n \n ans = ans % MOD + (from_start_to_cp1 * from_cp2_to_goal % MOD) % MOD\n \n ",
"cp1",
"choke_points",
"x, y = cp1",
"x",
"cp1",
"y",
"from_start_to_cp1 = mod_nCr(x + y, x)",
"from_start_to_cp1",
"mod_nCr(x + y, x)",
"mod_nCr",
"x + y",
"x",
"y",
"x",
"y += 1",
"y",
"1",
"dx, dy = goal[0] - x, goal[1] - y",
"dx",
"goal[0] - x",
"goal[0]",
"goal",
"0",
"x",
"dy",
"goal[1] - y",
"goal[1]",
"goal",
"1",
"y",
"from_cp2_to_goal = mod_nCr(dx + dy, dx)",
"from_cp2_to_goal",
"mod_nCr(dx + dy, dx)",
"mod_nCr",
"dx + dy",
"dx",
"dy",
"dx",
"ans = ans % MOD + (from_start_to_cp1 * from_cp2_to_goal % MOD) % MOD",
"ans",
"ans % MOD + (from_start_to_cp1 * from_cp2_to_goal % MOD) % MOD",
"ans % MOD",
"ans",
"MOD",
"(from_start_to_cp1 * from_cp2_to_goal % MOD) % MOD",
"from_start_to_cp1 * from_cp2_to_goal % MOD",
"from_start_to_cp1 * from_cp2_to_goal",
"from_start_to_cp1",
"from_cp2_to_goal",
"MOD",
"MOD",
"return ans % MOD",
"ans % MOD",
"ans",
"MOD",
"res = solve()",
"res",
"solve()",
"solve",
"print(res)",
"print",
"res",
"def solve():\n # 組合せの計算用に階乗を事前計算しておく\n MOD = 10 ** 9 + 7\n FACT = [0] * (H + W + 1)\n INV_FACT = [0] * (H + W + 1) # 逆元. 組合せの計算ごとにMODを取るため\n \n FACT[0], INV_FACT[0] = 1, 1\n for i in range(1, (H + W + 1)):\n FACT[i] = (FACT[i - 1] * i) % MOD\n INV_FACT[i] = pow(FACT[i], MOD - 2, MOD) # フェルマーの小定理を使う\n \n def mod_nCr(n, r):\n if n < r or n == 0 or r == 0:\n return 1\n \n return FACT[n] * (INV_FACT[r] * INV_FACT[n - r]) % MOD\n \n # print(H, W, A, B)\n \n # 座標は(x, y). startは(0, 0)\n goal = W - 1, H - 1\n \n # 境界点: 移動できないエリアの右上の点\n nx = B - 1\n ny = H - A\n \n # 境界点から右斜め上に1つ移動した点(choke_left)から, 右端へ伸びる線がchoke points\n choke_left = nx + 1, ny - 1\n \n choke_points = []\n for i in range(B, W):\n choke_points.append((i, choke_left[1]))\n \n # 組合せを計算する: startからcp1, cp2からgoalまで組合せを掛ける\n ans = 0\n for cp1 in choke_points:\n x, y = cp1\n from_start_to_cp1 = mod_nCr(x + y, x)\n \n # cp1から1つ下の点がcp2\n y += 1\n dx, dy = goal[0] - x, goal[1] - y\n from_cp2_to_goal = mod_nCr(dx + dy, dx)\n \n ans = ans % MOD + (from_start_to_cp1 * from_cp2_to_goal % MOD) % MOD\n \n return ans % MOD\n ",
"def solve():\n # 組合せの計算用に階乗を事前計算しておく\n MOD = 10 ** 9 + 7\n FACT = [0] * (H + W + 1)\n INV_FACT = [0] * (H + W + 1) # 逆元. 組合せの計算ごとにMODを取るため\n \n FACT[0], INV_FACT[0] = 1, 1\n for i in range(1, (H + W + 1)):\n FACT[i] = (FACT[i - 1] * i) % MOD\n INV_FACT[i] = pow(FACT[i], MOD - 2, MOD) # フェルマーの小定理を使う\n \n def mod_nCr(n, r):\n if n < r or n == 0 or r == 0:\n return 1\n \n return FACT[n] * (INV_FACT[r] * INV_FACT[n - r]) % MOD\n \n # print(H, W, A, B)\n \n # 座標は(x, y). startは(0, 0)\n goal = W - 1, H - 1\n \n # 境界点: 移動できないエリアの右上の点\n nx = B - 1\n ny = H - A\n \n # 境界点から右斜め上に1つ移動した点(choke_left)から, 右端へ伸びる線がchoke points\n choke_left = nx + 1, ny - 1\n \n choke_points = []\n for i in range(B, W):\n choke_points.append((i, choke_left[1]))\n \n # 組合せを計算する: startからcp1, cp2からgoalまで組合せを掛ける\n ans = 0\n for cp1 in choke_points:\n x, y = cp1\n from_start_to_cp1 = mod_nCr(x + y, x)\n \n # cp1から1つ下の点がcp2\n y += 1\n dx, dy = goal[0] - x, goal[1] - y\n from_cp2_to_goal = mod_nCr(dx + dy, dx)\n \n ans = ans % MOD + (from_start_to_cp1 * from_cp2_to_goal % MOD) % MOD\n \n return ans % MOD\n ",
"solve",
"B = list(map(int, input().split()))",
"list(map(int, input().split()))",
"B",
"H, W, A, B = list(map(int, input().split()))",
"list(map(int, input().split()))",
"H",
"res = solve()",
"solve()",
"res",
"W, A, B = list(map(int, input().split()))",
"list(map(int, input().split()))",
"W",
"A, B = list(map(int, input().split()))",
"list(map(int, input().split()))",
"A"
] | H, W, A, B = list(map(int, input().split()))
# 事前計算 + 演算ごとに mod する
def solve():
# 組合せの計算用に階乗を事前計算しておく
MOD = 10 ** 9 + 7
FACT = [0] * (H + W + 1)
INV_FACT = [0] * (H + W + 1) # 逆元. 組合せの計算ごとにMODを取るため
FACT[0], INV_FACT[0] = 1, 1
for i in range(1, (H + W + 1)):
FACT[i] = (FACT[i - 1] * i) % MOD
INV_FACT[i] = pow(FACT[i], MOD - 2, MOD) # フェルマーの小定理を使う
def mod_nCr(n, r):
if n < r or n == 0 or r == 0:
return 1
return FACT[n] * (INV_FACT[r] * INV_FACT[n - r]) % MOD
# print(H, W, A, B)
# 座標は(x, y). startは(0, 0)
goal = W - 1, H - 1
# 境界点: 移動できないエリアの右上の点
nx = B - 1
ny = H - A
# 境界点から右斜め上に1つ移動した点(choke_left)から, 右端へ伸びる線がchoke points
choke_left = nx + 1, ny - 1
choke_points = []
for i in range(B, W):
choke_points.append((i, choke_left[1]))
# 組合せを計算する: startからcp1, cp2からgoalまで組合せを掛ける
ans = 0
for cp1 in choke_points:
x, y = cp1
from_start_to_cp1 = mod_nCr(x + y, x)
# cp1から1つ下の点がcp2
y += 1
dx, dy = goal[0] - x, goal[1] - y
from_cp2_to_goal = mod_nCr(dx + dy, dx)
ans = ans % MOD + (from_start_to_cp1 * from_cp2_to_goal % MOD) % MOD
return ans % MOD
res = solve()
print(res) |
[
7,
15,
13,
15,
4,
18,
13,
13,
2,
17,
17,
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,
0,
13,
4,
4,
13,
0,
13,
17,
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,
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,
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,
10,
4,
13,
10,
4,
13,
10,
2,
13,
10,
4,
13,
10,
4,
13,
10,
13,
13,
10,
12,
13,
10,
12,
13,
10,
12,
13,
10,
4,
13,
10,
12,
13,
10,
12,
13,
10,
17,
13,
10,
2,
13,
10,
12,
13,
10,
4,
13,
10,
4,
13,
10,
4,
13
] | [
[
15,
14
],
[
30,
15
],
[
18,
17
],
[
30,
18
],
[
14,
22
],
[
26,
22
],
[
17,
23
],
[
28,
23
],
[
30,
24
],
[
26,
26
],
[
28,
28
],
[
30,
30
],
[
35,
34
],
[
56,
35
],
[
38,
37
],
[
56,
38
],
[
34,
42
],
[
52,
42
],
[
37,
45
],
[
54,
45
],
[
56,
47
],
[
56,
49
],
[
56,
50
],
[
52,
52
],
[
54,
54
],
[
56,
56
],
[
380,
58
],
[
106,
58
],
[
101,
61
],
[
101,
68
],
[
73,
72
],
[
99,
75
],
[
101,
77
],
[
103,
79
],
[
72,
83
],
[
72,
84
],
[
103,
85
],
[
99,
89
],
[
99,
92
],
[
101,
94
],
[
103,
96
],
[
103,
97
],
[
99,
99
],
[
101,
101
],
[
103,
103
],
[
380,
105
],
[
106,
105
],
[
111,
110
],
[
380,
112
],
[
106,
112
],
[
117,
116
],
[
157,
121
],
[
127,
124
],
[
116,
125
],
[
157,
126
],
[
401,
128
],
[
161,
130
],
[
159,
131
],
[
134,
133
],
[
157,
138
],
[
143,
140
],
[
116,
141
],
[
133,
142
],
[
389,
144
],
[
116,
146
],
[
133,
148
],
[
133,
151
],
[
159,
153
],
[
116,
155
],
[
157,
157
],
[
159,
159
],
[
161,
161
],
[
166,
165
],
[
200,
170
],
[
176,
173
],
[
165,
174
],
[
179,
178
],
[
200,
181
],
[
188,
183
],
[
165,
184
],
[
178,
186
],
[
178,
191
],
[
165,
194
],
[
178,
195
],
[
202,
196
],
[
165,
198
],
[
200,
200
],
[
202,
202
],
[
246,
209
],
[
214,
213
],
[
246,
215
],
[
240,
216
],
[
219,
218
],
[
248,
220
],
[
242,
221
],
[
224,
223
],
[
248,
225
],
[
240,
227
],
[
242,
228
],
[
389,
231
],
[
389,
233
],
[
213,
234
],
[
218,
235
],
[
244,
236
],
[
223,
237
],
[
244,
238
],
[
240,
240
],
[
242,
242
],
[
244,
244
],
[
246,
246
],
[
248,
248
],
[
397,
250
],
[
409,
257
],
[
409,
266
],
[
409,
267
],
[
409,
268
],
[
394,
270
],
[
358,
273
],
[
383,
275
],
[
371,
278
],
[
410,
279
],
[
398,
281
],
[
406,
283
],
[
392,
285
],
[
371,
288
],
[
410,
289
],
[
398,
291
],
[
359,
293
],
[
371,
296
],
[
410,
297
],
[
301,
300
],
[
371,
304
],
[
404,
305
],
[
367,
307
],
[
377,
309
],
[
386,
312
],
[
300,
314
],
[
386,
316
],
[
398,
318
],
[
359,
319
],
[
407,
320
],
[
361,
322
],
[
377,
324
],
[
371,
328
],
[
410,
329
],
[
386,
333
],
[
300,
335
],
[
410,
338
],
[
386,
339
],
[
398,
341
],
[
359,
342
],
[
407,
343
],
[
364,
345
],
[
368,
348
],
[
362,
349
],
[
398,
350
],
[
373,
352
],
[
398,
353
],
[
374,
356
],
[
365,
356
],
[
395,
356
],
[
358,
359
],
[
361,
362
],
[
364,
365
],
[
367,
368
],
[
409,
371
],
[
398,
373
],
[
373,
374
],
[
380,
380
],
[
106,
380
],
[
409,
386
],
[
394,
395
],
[
397,
398
],
[
409,
404
],
[
406,
407
],
[
409,
410
]
] | [
"import sys\nfrom functools import lru_cache\nsys.setrecursionlimit(10**9)\n \ndef mul(x, y, mod):\n x %= mod\n y %= mod\n return x * y % mod\n \ndef div(x, y, mod):\n x %= mod\n y %= mod\n return x * mod_pow(y, mod - 2, mod) % mod\n \n@lru_cache(maxsize=None)\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 \ndef dnm(n, mod, factorials):\n denominators = [0] * (n + 1)\n denominators[n] = div(1, factorials, mod)\n for i in reversed(range(n)):\n denominators[i] = mul(denominators[i+1], i+1, mod)\n return denominators\n \ndef nmr(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 \ndef cmb(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 \nMOD=10**9+7\nH,W,A,B=map(int,input().split())\nans = 0\n \nn = nmr(H+W-2, MOD)\nd = dnm(H+W-2, MOD, n[H+W-2])\n \nfor i in range(H-A):\n x = cmb(B-1+i, B-1, MOD, n, d)\n y = cmb(H+W-3-(B-1+i), W-B-1, MOD, n, d)\n ans += x * y % MOD\n ans %= MOD\n \nprint(ans)",
"import sys",
"sys",
"from functools import lru_cache",
"sys.setrecursionlimit(10**9)",
"sys.setrecursionlimit",
"sys",
"setrecursionlimit",
"10**9",
"10",
"9",
"def mul(x, y, mod):\n x %= mod\n y %= mod\n return x * y % mod\n ",
"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\n ",
"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\n ",
"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\n ",
"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",
"@lru_cache(maxsize=None)",
"mod_pow",
"maxsize=None",
"@lru_cache(maxsize=None)",
"lru_cache",
"maxsize=None",
"maxsize",
"None",
"mod_pow",
"def dnm(n, mod, factorials):\n denominators = [0] * (n + 1)\n denominators[n] = div(1, factorials, mod)\n for i in reversed(range(n)):\n denominators[i] = mul(denominators[i+1], i+1, mod)\n return denominators\n ",
"dnm",
"denominators = [0] * (n + 1)",
"denominators",
"[0] * (n + 1)",
"[0]",
"0",
"n + 1",
"n",
"1",
"denominators[n] = div(1, factorials, mod)",
"denominators[n]",
"denominators",
"n",
"div(1, factorials, mod)",
"div",
"1",
"factorials",
"mod",
"for i in reversed(range(n)):\n denominators[i] = mul(denominators[i+1], i+1, mod)\n ",
"i",
"reversed(range(n))",
"reversed",
"range(n)",
"range",
"n",
"denominators[i] = mul(denominators[i+1], i+1, mod)",
"denominators[i]",
"denominators",
"i",
"mul(denominators[i+1], i+1, mod)",
"mul",
"denominators[i+1]",
"denominators",
"i+1",
"i",
"1",
"i+1",
"i",
"1",
"mod",
"return denominators",
"denominators",
"n",
"n",
"mod",
"mod",
"factorials",
"factorials",
"def nmr(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 ",
"nmr",
"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 cmb(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 ",
"cmb",
"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",
"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",
"ans = 0",
"ans",
"0",
"n = nmr(H+W-2, MOD)",
"n",
"nmr(H+W-2, MOD)",
"nmr",
"H+W-2",
"H+W",
"H",
"W",
"2",
"MOD",
"d = dnm(H+W-2, MOD, n[H+W-2])",
"d",
"dnm(H+W-2, MOD, n[H+W-2])",
"dnm",
"H+W-2",
"H+W",
"H",
"W",
"2",
"MOD",
"n[H+W-2]",
"n",
"H+W-2",
"H+W",
"H",
"W",
"2",
"for i in range(H-A):\n x = cmb(B-1+i, B-1, MOD, n, d)\n y = cmb(H+W-3-(B-1+i), W-B-1, MOD, n, d)\n ans += x * y % MOD\n ans %= MOD\n ",
"i",
"range(H-A)",
"range",
"H-A",
"H",
"A",
"x = cmb(B-1+i, B-1, MOD, n, d)",
"x",
"cmb(B-1+i, B-1, MOD, n, d)",
"cmb",
"B-1+i",
"B-1",
"B",
"1",
"i",
"B-1",
"B",
"1",
"MOD",
"n",
"d",
"y = cmb(H+W-3-(B-1+i), W-B-1, MOD, n, d)",
"y",
"cmb(H+W-3-(B-1+i), W-B-1, MOD, n, d)",
"cmb",
"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",
"n",
"d",
"ans += x * y % MOD",
"ans",
"x * y % MOD",
"x * y",
"x",
"y",
"MOD",
"ans %= MOD",
"ans",
"MOD",
"print(ans)",
"print",
"ans",
"n = nmr(H+W-2, MOD)",
"nmr(H+W-2, MOD)",
"n",
"y = cmb(H+W-3-(B-1+i), W-B-1, MOD, n, d)",
"cmb(H+W-3-(B-1+i), W-B-1, MOD, n, d)",
"y",
"ans += x * y % MOD",
"x * y % MOD",
"ans",
"x = cmb(B-1+i, B-1, MOD, n, d)",
"cmb(B-1+i, B-1, MOD, n, d)",
"x",
"H,W,A,B=map(int,input().split())",
"map(int,input().split())",
"H",
"ans %= MOD",
"MOD",
"ans",
"def cmb(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 ",
"def cmb(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 ",
"cmb",
"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\n ",
"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\n ",
"mod_pow",
"def nmr(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 ",
"def nmr(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 ",
"nmr",
"B=map(int,input().split())",
"map(int,input().split())",
"B",
"def mul(x, y, mod):\n x %= mod\n y %= mod\n return x * y % mod\n ",
"def mul(x, y, mod):\n x %= mod\n y %= mod\n return x * y % mod\n ",
"mul",
"def dnm(n, mod, factorials):\n denominators = [0] * (n + 1)\n denominators[n] = div(1, factorials, mod)\n for i in reversed(range(n)):\n denominators[i] = mul(denominators[i+1], i+1, mod)\n return denominators\n ",
"def dnm(n, mod, factorials):\n denominators = [0] * (n + 1)\n denominators[n] = div(1, factorials, mod)\n for i in reversed(range(n)):\n denominators[i] = mul(denominators[i+1], i+1, mod)\n return denominators\n ",
"dnm",
"ans = 0",
"0",
"ans",
"MOD=10**9+7",
"10**9+7",
"MOD",
"def div(x, y, mod):\n x %= mod\n y %= mod\n return x * mod_pow(y, mod - 2, mod) % mod\n ",
"def div(x, y, mod):\n x %= mod\n y %= mod\n return x * mod_pow(y, mod - 2, mod) % mod\n ",
"div",
"A,B=map(int,input().split())",
"map(int,input().split())",
"A",
"d = dnm(H+W-2, MOD, n[H+W-2])",
"dnm(H+W-2, MOD, n[H+W-2])",
"d",
"W,A,B=map(int,input().split())",
"map(int,input().split())",
"W"
] | import sys
from functools import lru_cache
sys.setrecursionlimit(10**9)
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
@lru_cache(maxsize=None)
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 dnm(n, mod, factorials):
denominators = [0] * (n + 1)
denominators[n] = div(1, factorials, mod)
for i in reversed(range(n)):
denominators[i] = mul(denominators[i+1], i+1, mod)
return denominators
def nmr(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 cmb(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)
MOD=10**9+7
H,W,A,B=map(int,input().split())
ans = 0
n = nmr(H+W-2, MOD)
d = dnm(H+W-2, MOD, n[H+W-2])
for i in range(H-A):
x = cmb(B-1+i, B-1, MOD, n, d)
y = cmb(H+W-3-(B-1+i), W-B-1, MOD, n, d)
ans += x * y % MOD
ans %= MOD
print(ans) |
[
7,
15,
13,
4,
18,
13,
13,
17,
0,
13,
4,
13,
17,
0,
13,
2,
2,
17,
17,
17,
0,
13,
12,
4,
18,
4,
18,
18,
13,
13,
13,
13,
6,
13,
12,
13,
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,
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,
0,
18,
13,
13,
13,
0,
18,
13,
13,
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,
14,
2,
2,
13,
17,
2,
2,
13,
13,
17,
29,
2,
2,
2,
4,
18,
13,
13,
13,
4,
18,
13,
13,
13,
4,
18,
13,
13,
2,
13,
13,
13,
23,
13,
23,
13,
23,
13,
13,
12,
13,
0,
13,
4,
13,
12,
2,
4,
13,
13,
17,
23,
4,
18,
4,
13,
13,
13,
13,
13,
0,
13,
4,
13,
2,
13,
13,
0,
13,
4,
18,
13,
13,
2,
13,
13,
13,
28,
13,
4,
13,
2,
13,
17,
0,
13,
2,
2,
2,
13,
13,
13,
13,
0,
13,
2,
2,
4,
18,
13,
13,
2,
13,
13,
13,
4,
18,
13,
13,
2,
2,
2,
13,
13,
13,
13,
2,
13,
13,
13,
4,
13,
2,
13,
13,
4,
13,
10,
6,
13,
10,
4,
13,
10,
2,
13,
10,
12,
13,
10,
12,
13
] | [
[
281,
9
],
[
284,
14
],
[
287,
21
],
[
38,
37
],
[
123,
42
],
[
46,
45
],
[
123,
50
],
[
54,
53
],
[
123,
58
],
[
64,
61
],
[
37,
62
],
[
53,
63
],
[
53,
66
],
[
37,
68
],
[
53,
70
],
[
285,
72
],
[
77,
74
],
[
45,
75
],
[
123,
76
],
[
37,
80
],
[
123,
81
],
[
285,
83
],
[
285,
85
],
[
88,
87
],
[
123,
91
],
[
99,
96
],
[
45,
97
],
[
87,
98
],
[
45,
102
],
[
87,
104
],
[
87,
107
],
[
285,
109
],
[
114,
111
],
[
121,
112
],
[
37,
114
],
[
119,
116
],
[
121,
117
],
[
45,
119
],
[
121,
121
],
[
123,
123
],
[
133,
129
],
[
135,
131
],
[
133,
133
],
[
135,
135
],
[
145,
141
],
[
147,
143
],
[
145,
145
],
[
147,
147
],
[
187,
153
],
[
185,
157
],
[
187,
158
],
[
183,
166
],
[
125,
167
],
[
185,
168
],
[
183,
171
],
[
137,
172
],
[
187,
173
],
[
183,
176
],
[
137,
177
],
[
185,
179
],
[
187,
180
],
[
285,
181
],
[
183,
183
],
[
185,
185
],
[
187,
187
],
[
193,
192
],
[
288,
205
],
[
193,
207
],
[
193,
208
],
[
193,
209
],
[
212,
211
],
[
192,
215
],
[
207,
216
],
[
219,
218
],
[
211,
221
],
[
149,
222
],
[
192,
224
],
[
207,
225
],
[
192,
226
],
[
229,
228
],
[
209,
232
],
[
236,
235
],
[
192,
239
],
[
208,
240
],
[
209,
241
],
[
228,
242
],
[
245,
244
],
[
211,
249
],
[
149,
250
],
[
235,
252
],
[
228,
253
],
[
235,
254
],
[
211,
257
],
[
149,
258
],
[
192,
262
],
[
235,
263
],
[
207,
264
],
[
228,
265
],
[
192,
267
],
[
235,
268
],
[
285,
269
],
[
244,
273
],
[
218,
273
],
[
285,
274
],
[
291,
276
],
[
281,
282
],
[
284,
285
],
[
287,
288
]
] | [
"import sys\nsys.setrecursionlimit(2147483647)\nINF=float(\"inf\")\nMOD=10**9+7\ninput=lambda :sys.stdin.readline().rstrip()\n\nclass modfact(object):\n def __init__(self,n):\n fact=[1]*(n+1)\n invfact=[1]*(n+1)\n for i in range(1,n+1):\n fact[i]=i*fact[i-1]%MOD\n invfact[n]=pow(fact[n],MOD-2,MOD)\n for i in range(n-1,-1,-1):\n invfact[i]=invfact[i+1]*(i+1)%MOD\n self.__fact=fact\n self.__invfact=invfact\n\n def fact(self,n):\n return self.__fact[n]\n\n def invfact(self,n):\n return self.__invfact[n]\n\n def comb(self,n,k):\n if(k<0 or n-k<0): return 0\n return (self.fact(n)*self.invfact(k)*self.invfact(n-k))%MOD\n\ndef resolve():\n h,w,a,b=map(lambda x:int(x)-1,input().split())\n mf=modfact(h+w)\n ans=mf.comb(h+w,h)\n for j in range(b+1):\n i=(h-a)+b-j\n ans-=mf.comb(i+j,i)*mf.comb(h-i+w-j,h-i)%MOD\n print(ans%MOD)\nresolve()",
"import sys",
"sys",
"sys.setrecursionlimit(2147483647)",
"sys.setrecursionlimit",
"sys",
"setrecursionlimit",
"2147483647",
"INF=float(\"inf\")",
"INF",
"float(\"inf\")",
"float",
"\"inf\"",
"MOD=10**9+7",
"MOD",
"10**9+7",
"10**9",
"10",
"9",
"7",
"input=lambda :sys.stdin.readline().rstrip()",
"input",
"lambda :sys.stdin.readline().rstrip()",
"sys.stdin.readline().rstrip()",
"sys.stdin.readline().rstrip",
"sys.stdin.readline()",
"sys.stdin.readline",
"sys.stdin",
"sys",
"stdin",
"readline",
"rstrip",
"class modfact(object):\n def __init__(self,n):\n fact=[1]*(n+1)\n invfact=[1]*(n+1)\n for i in range(1,n+1):\n fact[i]=i*fact[i-1]%MOD\n invfact[n]=pow(fact[n],MOD-2,MOD)\n for i in range(n-1,-1,-1):\n invfact[i]=invfact[i+1]*(i+1)%MOD\n self.__fact=fact\n self.__invfact=invfact\n\n def fact(self,n):\n return self.__fact[n]\n\n def invfact(self,n):\n return self.__invfact[n]\n\n def comb(self,n,k):\n if(k<0 or n-k<0): return 0\n return (self.fact(n)*self.invfact(k)*self.invfact(n-k))%MOD",
"modfact",
"def __init__(self,n):\n fact=[1]*(n+1)\n invfact=[1]*(n+1)\n for i in range(1,n+1):\n fact[i]=i*fact[i-1]%MOD\n invfact[n]=pow(fact[n],MOD-2,MOD)\n for i in range(n-1,-1,-1):\n invfact[i]=invfact[i+1]*(i+1)%MOD\n self.__fact=fact\n self.__invfact=invfact\n\n ",
"__init__",
"fact=[1]*(n+1)",
"fact",
"[1]*(n+1)",
"[1]",
"1",
"n+1",
"n",
"1",
"invfact=[1]*(n+1)",
"invfact",
"[1]*(n+1)",
"[1]",
"1",
"n+1",
"n",
"1",
"for i in range(1,n+1):\n fact[i]=i*fact[i-1]%MOD\n ",
"i",
"range(1,n+1)",
"range",
"1",
"n+1",
"n",
"1",
"fact[i]=i*fact[i-1]%MOD",
"fact[i]",
"fact",
"i",
"i*fact[i-1]%MOD",
"i*fact[i-1]",
"i",
"fact[i-1]",
"fact",
"i-1",
"i",
"1",
"MOD",
"invfact[n]=pow(fact[n],MOD-2,MOD)",
"invfact[n]",
"invfact",
"n",
"pow(fact[n],MOD-2,MOD)",
"pow",
"fact[n]",
"fact",
"n",
"MOD-2",
"MOD",
"2",
"MOD",
"for i in range(n-1,-1,-1):\n invfact[i]=invfact[i+1]*(i+1)%MOD\n ",
"i",
"range(n-1,-1,-1)",
"range",
"n-1",
"n",
"1",
"-1",
"-1",
"invfact[i]=invfact[i+1]*(i+1)%MOD",
"invfact[i]",
"invfact",
"i",
"invfact[i+1]*(i+1)%MOD",
"invfact[i+1]*(i+1)",
"invfact[i+1]",
"invfact",
"i+1",
"i",
"1",
"i+1",
"i",
"1",
"MOD",
"self.__fact=fact",
"self.__fact",
"self",
"__fact",
"fact",
"self.__invfact=invfact",
"self.__invfact",
"self",
"__invfact",
"invfact",
"self",
"self",
"n",
"n",
"def fact(self,n):\n return self.__fact[n]\n\n ",
"fact",
"return self.__fact[n]",
"self.__fact[n]",
"self.__fact",
"self",
"__fact",
"n",
"self",
"self",
"n",
"n",
"def invfact(self,n):\n return self.__invfact[n]\n\n ",
"invfact",
"return self.__invfact[n]",
"self.__invfact[n]",
"self.__invfact",
"self",
"__invfact",
"n",
"self",
"self",
"n",
"n",
"def comb(self,n,k):\n if(k<0 or n-k<0): return 0\n return (self.fact(n)*self.invfact(k)*self.invfact(n-k))%MOD",
"comb",
"if(k<0 or n-k<0): return 0\n ",
"k<0 or n-k<0",
"k<0",
"k",
"0",
"n-k<0",
"n-k",
"n",
"k",
"0",
"return (self.fact(n)*self.invfact(k)*self.invfact(n-k))%MOD",
"(self.fact(n)*self.invfact(k)*self.invfact(n-k))%MOD",
"self.fact(n)*self.invfact(k)*self.invfact(n-k)",
"self.fact(n)*self.invfact(k)",
"self.fact(n)",
"self.fact",
"self",
"fact",
"n",
"self.invfact(k)",
"self.invfact",
"self",
"invfact",
"k",
"self.invfact(n-k)",
"self.invfact",
"self",
"invfact",
"n-k",
"n",
"k",
"MOD",
"self",
"self",
"n",
"n",
"k",
"k",
"object",
"def resolve():\n h,w,a,b=map(lambda x:int(x)-1,input().split())\n mf=modfact(h+w)\n ans=mf.comb(h+w,h)\n for j in range(b+1):\n i=(h-a)+b-j\n ans-=mf.comb(i+j,i)*mf.comb(h-i+w-j,h-i)%MOD\n print(ans%MOD)",
"resolve",
"h,w,a,b=map(lambda x:int(x)-1,input().split())",
"h",
"map(lambda x:int(x)-1,input().split())",
"map",
"lambda x:int(x)-1",
"int(x)-1",
"int(x)",
"int",
"x",
"1",
"x",
"input().split()",
"().split",
"()",
"input",
"split",
"w",
"a",
"b",
"mf=modfact(h+w)",
"mf",
"modfact(h+w)",
"modfact",
"h+w",
"h",
"w",
"ans=mf.comb(h+w,h)",
"ans",
"mf.comb(h+w,h)",
"mf.comb",
"mf",
"comb",
"h+w",
"h",
"w",
"h",
"for j in range(b+1):\n i=(h-a)+b-j\n ans-=mf.comb(i+j,i)*mf.comb(h-i+w-j,h-i)%MOD\n ",
"j",
"range(b+1)",
"range",
"b+1",
"b",
"1",
"i=(h-a)+b-j",
"i",
"(h-a)+b-j",
"(h-a)+b",
"h-a",
"h",
"a",
"b",
"j",
"ans-=mf.comb(i+j,i)*mf.comb(h-i+w-j,h-i)%MOD",
"ans",
"mf.comb(i+j,i)*mf.comb(h-i+w-j,h-i)%MOD",
"mf.comb(i+j,i)*mf.comb(h-i+w-j,h-i)",
"mf.comb(i+j,i)",
"mf.comb",
"mf",
"comb",
"i+j",
"i",
"j",
"i",
"mf.comb(h-i+w-j,h-i)",
"mf.comb",
"mf",
"comb",
"h-i+w-j",
"h-i+w",
"h-i",
"h",
"i",
"w",
"j",
"h-i",
"h",
"i",
"MOD",
"print(ans%MOD)",
"print",
"ans%MOD",
"ans",
"MOD",
"resolve()",
"resolve",
"class modfact(object):\n def __init__(self,n):\n fact=[1]*(n+1)\n invfact=[1]*(n+1)\n for i in range(1,n+1):\n fact[i]=i*fact[i-1]%MOD\n invfact[n]=pow(fact[n],MOD-2,MOD)\n for i in range(n-1,-1,-1):\n invfact[i]=invfact[i+1]*(i+1)%MOD\n self.__fact=fact\n self.__invfact=invfact\n\n def fact(self,n):\n return self.__fact[n]\n\n def invfact(self,n):\n return self.__invfact[n]\n\n def comb(self,n,k):\n if(k<0 or n-k<0): return 0\n return (self.fact(n)*self.invfact(k)*self.invfact(n-k))%MOD",
"class modfact(object):\n def __init__(self,n):\n fact=[1]*(n+1)\n invfact=[1]*(n+1)\n for i in range(1,n+1):\n fact[i]=i*fact[i-1]%MOD\n invfact[n]=pow(fact[n],MOD-2,MOD)\n for i in range(n-1,-1,-1):\n invfact[i]=invfact[i+1]*(i+1)%MOD\n self.__fact=fact\n self.__invfact=invfact\n\n def fact(self,n):\n return self.__fact[n]\n\n def invfact(self,n):\n return self.__invfact[n]\n\n def comb(self,n,k):\n if(k<0 or n-k<0): return 0\n return (self.fact(n)*self.invfact(k)*self.invfact(n-k))%MOD",
"modfact",
"INF=float(\"inf\")",
"float(\"inf\")",
"INF",
"MOD=10**9+7",
"10**9+7",
"MOD",
"input=lambda :sys.stdin.readline().rstrip()",
"lambda :sys.stdin.readline().rstrip()",
"input",
"def resolve():\n h,w,a,b=map(lambda x:int(x)-1,input().split())\n mf=modfact(h+w)\n ans=mf.comb(h+w,h)\n for j in range(b+1):\n i=(h-a)+b-j\n ans-=mf.comb(i+j,i)*mf.comb(h-i+w-j,h-i)%MOD\n print(ans%MOD)",
"def resolve():\n h,w,a,b=map(lambda x:int(x)-1,input().split())\n mf=modfact(h+w)\n ans=mf.comb(h+w,h)\n for j in range(b+1):\n i=(h-a)+b-j\n ans-=mf.comb(i+j,i)*mf.comb(h-i+w-j,h-i)%MOD\n print(ans%MOD)",
"resolve"
] | import sys
sys.setrecursionlimit(2147483647)
INF=float("inf")
MOD=10**9+7
input=lambda :sys.stdin.readline().rstrip()
class modfact(object):
def __init__(self,n):
fact=[1]*(n+1)
invfact=[1]*(n+1)
for i in range(1,n+1):
fact[i]=i*fact[i-1]%MOD
invfact[n]=pow(fact[n],MOD-2,MOD)
for i in range(n-1,-1,-1):
invfact[i]=invfact[i+1]*(i+1)%MOD
self.__fact=fact
self.__invfact=invfact
def fact(self,n):
return self.__fact[n]
def invfact(self,n):
return self.__invfact[n]
def comb(self,n,k):
if(k<0 or n-k<0): return 0
return (self.fact(n)*self.invfact(k)*self.invfact(n-k))%MOD
def resolve():
h,w,a,b=map(lambda x:int(x)-1,input().split())
mf=modfact(h+w)
ans=mf.comb(h+w,h)
for j in range(b+1):
i=(h-a)+b-j
ans-=mf.comb(i+j,i)*mf.comb(h-i+w-j,h-i)%MOD
print(ans%MOD)
resolve() |
[
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,
28,
13,
4,
13,
17,
2,
13,
17,
0,
13,
2,
2,
13,
13,
13,
29,
13,
23,
13,
12,
13,
0,
13,
17,
28,
13,
13,
0,
13,
2,
2,
13,
13,
13,
29,
13,
23,
13,
12,
13,
0,
13,
17,
0,
13,
2,
13,
17,
42,
2,
13,
17,
14,
2,
13,
17,
0,
13,
2,
2,
13,
13,
13,
0,
13,
2,
2,
13,
13,
13,
0,
13,
17,
29,
13,
23,
13,
0,
13,
39,
17,
0,
13,
17,
28,
13,
4,
13,
17,
2,
13,
13,
0,
13,
2,
2,
13,
13,
13,
4,
18,
13,
13,
13,
0,
13,
39,
4,
13,
18,
13,
17,
28,
13,
4,
13,
2,
2,
13,
13,
17,
17,
17,
4,
18,
13,
13,
2,
2,
18,
13,
17,
13,
13,
4,
18,
13,
13,
17,
4,
18,
13,
13,
0,
13,
17,
28,
13,
4,
13,
17,
2,
2,
13,
13,
17,
0,
13,
2,
2,
13,
4,
13,
39,
18,
13,
2,
2,
13,
13,
17,
18,
13,
2,
13,
17,
18,
13,
2,
13,
17,
18,
13,
2,
2,
2,
2,
13,
13,
13,
13,
17,
18,
13,
2,
13,
13,
18,
13,
2,
2,
13,
13,
17,
13,
4,
13,
13,
10,
2,
13,
10,
17,
13,
10,
4,
13,
10,
4,
13,
10,
2,
13,
10,
4,
13,
10,
2,
13,
10,
12,
13,
10,
39,
13,
10,
12,
13,
10,
17,
13,
10,
4,
13,
10,
39,
13,
10,
12,
13
] | [
[
268,
2
],
[
268,
11
],
[
268,
12
],
[
268,
13
],
[
253,
15
],
[
25,
24
],
[
28,
27
],
[
251,
32
],
[
36,
35
],
[
24,
38
],
[
35,
38
],
[
27,
39
],
[
254,
40
],
[
35,
42
],
[
24,
42
],
[
44,
44
],
[
49,
48
],
[
52,
51
],
[
63,
51
],
[
55,
54
],
[
48,
57
],
[
54,
57
],
[
51,
58
],
[
254,
59
],
[
54,
61
],
[
48,
61
],
[
63,
63
],
[
68,
67
],
[
71,
70
],
[
254,
72
],
[
70,
76
],
[
97,
76
],
[
70,
80
],
[
97,
80
],
[
84,
83
],
[
67,
86
],
[
83,
86
],
[
102,
87
],
[
90,
87
],
[
254,
88
],
[
91,
90
],
[
102,
93
],
[
90,
93
],
[
102,
94
],
[
90,
94
],
[
254,
95
],
[
98,
97
],
[
83,
100
],
[
67,
100
],
[
102,
102
],
[
271,
104
],
[
265,
108
],
[
112,
111
],
[
251,
116
],
[
242,
117
],
[
247,
119
],
[
266,
122
],
[
248,
122
],
[
111,
123
],
[
254,
124
],
[
272,
127
],
[
248,
129
],
[
266,
129
],
[
259,
131
],
[
275,
134
],
[
272,
136
],
[
140,
139
],
[
251,
144
],
[
242,
145
],
[
260,
151
],
[
260,
156
],
[
139,
158
],
[
254,
159
],
[
260,
162
],
[
260,
167
],
[
238,
170
],
[
174,
173
],
[
251,
179
],
[
245,
180
],
[
235,
183
],
[
239,
186
],
[
236,
186
],
[
263,
188
],
[
272,
191
],
[
173,
194
],
[
269,
195
],
[
260,
198
],
[
173,
200
],
[
260,
203
],
[
269,
205
],
[
272,
208
],
[
242,
213
],
[
269,
214
],
[
251,
215
],
[
173,
216
],
[
260,
219
],
[
251,
221
],
[
173,
222
],
[
260,
224
],
[
242,
227
],
[
269,
228
],
[
254,
230
],
[
236,
233
],
[
239,
233
],
[
235,
236
],
[
238,
239
],
[
268,
242
],
[
268,
245
],
[
247,
248
],
[
268,
251
],
[
253,
254
],
[
259,
260
],
[
265,
266
],
[
268,
269
],
[
271,
272
]
] | [
"h,w,a,b=map(int,input().split())\n\np=10**9+7\n#p=127\n\ndef modp_factorial(n):\n s=1\n for x in range(1,h+1):\n s=(s*x) % p\n return s\ndef modp_prod(lst):\n s=1\n for x in lst:\n s=(s*x)%p\n return s\ndef inv(n):\n s=1\n q=p-2\n while q>0:\n if q&1:\n s=(s*n) % p\n n=(n*n) % p\n q>>=1\n return s\n\nl=[1]\nf=1\nfor x in range(1,h+w):\n f=(f*x) % p\n l.append(f)\ninvl=[inv(l[-1])]\nfor n in range(h+w-1,1,-1):\n invl.append((invl[-1]*n) % p)\n\ninvl.append(1)\ninvl.reverse()\n\n\ns=0\nfor x in range(1,h-a+1):\n s=(s+modp_prod([l[x+b-2],invl[x-1],invl[b-1]\\\n ,l[w-b+h-x-1],invl[h-x],invl[w-b-1]])) % p\nprint(s)",
"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",
"def modp_factorial(n):\n s=1\n for x in range(1,h+1):\n s=(s*x) % p\n return s",
"modp_factorial",
"s=1",
"s",
"1",
"for x in range(1,h+1):\n s=(s*x) % p\n ",
"x",
"range(1,h+1)",
"range",
"1",
"h+1",
"h",
"1",
"s=(s*x) % p",
"s",
"(s*x) % p",
"s*x",
"s",
"x",
"p",
"return s",
"s",
"n",
"n",
"def modp_prod(lst):\n s=1\n for x in lst:\n s=(s*x)%p\n return s",
"modp_prod",
"s=1",
"s",
"1",
"for x in lst:\n s=(s*x)%p\n ",
"x",
"lst",
"s=(s*x)%p",
"s",
"(s*x)%p",
"s*x",
"s",
"x",
"p",
"return s",
"s",
"lst",
"lst",
"def inv(n):\n s=1\n q=p-2\n while q>0:\n if q&1:\n s=(s*n) % p\n n=(n*n) % p\n q>>=1\n return s",
"inv",
"s=1",
"s",
"1",
"q=p-2",
"q",
"p-2",
"p",
"2",
"while q>0:\n if q&1:\n s=(s*n) % p\n n=(n*n) % p\n q>>=1\n ",
"q>0",
"q",
"0",
"if q&1:\n s=(s*n) % p\n ",
"q&1",
"q",
"1",
"s=(s*n) % p",
"s",
"(s*n) % p",
"s*n",
"s",
"n",
"p",
"n=(n*n) % p",
"n",
"(n*n) % p",
"n*n",
"n",
"n",
"p",
"q>>=1",
"q",
"1",
"return s",
"s",
"n",
"n",
"l=[1]",
"l",
"[1]",
"1",
"f=1",
"f",
"1",
"for x in range(1,h+w):\n f=(f*x) % p\n l.append(f)",
"x",
"range(1,h+w)",
"range",
"1",
"h+w",
"h",
"w",
"f=(f*x) % p",
"f",
"(f*x) % p",
"f*x",
"f",
"x",
"p",
"l.append(f)",
"l.append",
"l",
"append",
"f",
"invl=[inv(l[-1])]",
"invl",
"[inv(l[-1])]",
"inv(l[-1])",
"inv",
"l[-1]",
"l",
"-1",
"for n in range(h+w-1,1,-1):\n invl.append((invl[-1]*n) % p)",
"n",
"range(h+w-1,1,-1)",
"range",
"h+w-1",
"h+w",
"h",
"w",
"1",
"1",
"-1",
"invl.append((invl[-1]*n) % p)",
"invl.append",
"invl",
"append",
"(invl[-1]*n) % p",
"invl[-1]*n",
"invl[-1]",
"invl",
"-1",
"n",
"p",
"invl.append(1)",
"invl.append",
"invl",
"append",
"1",
"invl.reverse()",
"invl.reverse",
"invl",
"reverse",
"s=0",
"s",
"0",
"for x in range(1,h-a+1):\n s=(s+modp_prod([l[x+b-2],invl[x-1],invl[b-1]\\\n ,l[w-b+h-x-1],invl[h-x],invl[w-b-1]])) % p",
"x",
"range(1,h-a+1)",
"range",
"1",
"h-a+1",
"h-a",
"h",
"a",
"1",
"s=(s+modp_prod([l[x+b-2],invl[x-1],invl[b-1]\\\n ,l[w-b+h-x-1],invl[h-x],invl[w-b-1]])) % p",
"s",
"(s+modp_prod([l[x+b-2],invl[x-1],invl[b-1]\\\n ,l[w-b+h-x-1],invl[h-x],invl[w-b-1]])) % p",
"s+modp_prod([l[x+b-2],invl[x-1],invl[b-1]\\\n ,l[w-b+h-x-1],invl[h-x],invl[w-b-1]])",
"s",
"modp_prod([l[x+b-2],invl[x-1],invl[b-1]\\\n ,l[w-b+h-x-1],invl[h-x],invl[w-b-1]])",
"modp_prod",
"[l[x+b-2],invl[x-1],invl[b-1]\\\n ,l[w-b+h-x-1],invl[h-x],invl[w-b-1]]",
"l[x+b-2]",
"l",
"x+b-2",
"x+b",
"x",
"b",
"2",
"invl[x-1]",
"invl",
"x-1",
"x",
"1",
"invl[b-1]",
"invl",
"b-1",
"b",
"1",
"l[w-b+h-x-1]",
"l",
"w-b+h-x-1",
"w-b+h-x",
"w-b+h",
"w-b",
"w",
"b",
"h",
"x",
"1",
"invl[h-x]",
"invl",
"h-x",
"h",
"x",
"invl[w-b-1]",
"invl",
"w-b-1",
"w-b",
"w",
"b",
"1",
"p",
"print(s)",
"print",
"s",
"s=(s+modp_prod([l[x+b-2],invl[x-1],invl[b-1]\\\n ,l[w-b+h-x-1],invl[h-x],invl[w-b-1]])) % p",
"(s+modp_prod([l[x+b-2],invl[x-1],invl[b-1]\\\n ,l[w-b+h-x-1],invl[h-x],invl[w-b-1]])) % p",
"s",
"s=0",
"0",
"s",
"w,a,b=map(int,input().split())",
"map(int,input().split())",
"w",
"a,b=map(int,input().split())",
"map(int,input().split())",
"a",
"f=(f*x) % p",
"(f*x) % p",
"f",
"h,w,a,b=map(int,input().split())",
"map(int,input().split())",
"h",
"p=10**9+7",
"10**9+7",
"p",
"def modp_factorial(n):\n s=1\n for x in range(1,h+1):\n s=(s*x) % p\n return s",
"def modp_factorial(n):\n s=1\n for x in range(1,h+1):\n s=(s*x) % p\n return s",
"modp_factorial",
"invl=[inv(l[-1])]",
"[inv(l[-1])]",
"invl",
"def modp_prod(lst):\n s=1\n for x in lst:\n s=(s*x)%p\n return s",
"def modp_prod(lst):\n s=1\n for x in lst:\n s=(s*x)%p\n return s",
"modp_prod",
"f=1",
"1",
"f",
"b=map(int,input().split())",
"map(int,input().split())",
"b",
"l=[1]",
"[1]",
"l",
"def inv(n):\n s=1\n q=p-2\n while q>0:\n if q&1:\n s=(s*n) % p\n n=(n*n) % p\n q>>=1\n return s",
"def inv(n):\n s=1\n q=p-2\n while q>0:\n if q&1:\n s=(s*n) % p\n n=(n*n) % p\n q>>=1\n return s",
"inv"
] | h,w,a,b=map(int,input().split())
p=10**9+7
#p=127
def modp_factorial(n):
s=1
for x in range(1,h+1):
s=(s*x) % p
return s
def modp_prod(lst):
s=1
for x in lst:
s=(s*x)%p
return s
def inv(n):
s=1
q=p-2
while q>0:
if q&1:
s=(s*n) % p
n=(n*n) % p
q>>=1
return s
l=[1]
f=1
for x in range(1,h+w):
f=(f*x) % p
l.append(f)
invl=[inv(l[-1])]
for n in range(h+w-1,1,-1):
invl.append((invl[-1]*n) % p)
invl.append(1)
invl.reverse()
s=0
for x in range(1,h-a+1):
s=(s+modp_prod([l[x+b-2],invl[x-1],invl[b-1]\
,l[w-b+h-x-1],invl[h-x],invl[w-b-1]])) % p
print(s)
|
[
7,
15,
13,
13,
13,
13,
13,
13,
13,
13,
13,
13,
13,
13,
13,
13,
15,
4,
18,
13,
13,
2,
17,
17,
0,
13,
2,
17,
17,
0,
13,
2,
2,
17,
17,
17,
0,
13,
39,
17,
17,
17,
17,
0,
13,
39,
17,
17,
17,
17,
41,
28,
13,
4,
18,
4,
18,
18,
13,
13,
13,
13,
4,
4,
13,
13,
12,
13,
41,
28,
13,
4,
18,
4,
18,
18,
13,
13,
13,
13,
4,
2,
4,
13,
13,
17,
12,
13,
41,
28,
13,
4,
18,
4,
18,
18,
13,
13,
13,
13,
4,
4,
13,
13,
12,
13,
12,
13,
12,
13,
12,
13,
12,
13,
0,
13,
2,
39,
17,
2,
2,
17,
2,
17,
17,
17,
0,
13,
2,
39,
17,
2,
2,
17,
2,
17,
17,
17,
0,
13,
2,
39,
17,
2,
2,
17,
2,
17,
17,
17,
0,
18,
13,
17,
17,
0,
18,
13,
17,
17,
0,
18,
13,
17,
17,
0,
18,
13,
17,
17,
0,
18,
13,
17,
17,
12,
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,
23,
13,
12,
13,
14,
2,
13,
13,
29,
17,
14,
2,
2,
13,
17,
2,
13,
17,
29,
17,
29,
2,
2,
18,
13,
13,
2,
2,
18,
13,
13,
18,
13,
2,
13,
13,
13,
13,
23,
13,
23,
13,
4,
13,
2,
2,
17,
2,
17,
17,
17,
12,
13,
0,
13,
4,
13,
13,
13,
13,
0,
13,
17,
28,
13,
4,
13,
2,
13,
13,
0,
13,
2,
4,
13,
2,
2,
13,
13,
17,
13,
4,
13,
2,
2,
2,
2,
13,
13,
13,
13,
17,
2,
2,
13,
17,
13,
0,
13,
13,
0,
13,
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,
2,
13,
10,
39,
13,
10,
2,
13,
10,
12,
13,
10,
12,
13,
10,
2,
13,
10,
2,
13,
10,
12,
13,
10,
2,
13,
10,
12,
13,
10,
39,
13
] | [
[
358,
25
],
[
364,
30
],
[
388,
37
],
[
361,
44
],
[
53,
52
],
[
52,
65
],
[
71,
70
],
[
70,
84
],
[
91,
90
],
[
90,
103
],
[
382,
115
],
[
376,
127
],
[
373,
139
],
[
159,
151
],
[
383,
152
],
[
159,
156
],
[
383,
157
],
[
164,
161
],
[
377,
162
],
[
174,
166
],
[
374,
167
],
[
174,
171
],
[
374,
172
],
[
179,
178
],
[
229,
182
],
[
187,
184
],
[
383,
185
],
[
178,
186
],
[
383,
190
],
[
178,
192
],
[
178,
194
],
[
365,
195
],
[
200,
197
],
[
377,
198
],
[
178,
199
],
[
365,
201
],
[
377,
205
],
[
365,
207
],
[
178,
208
],
[
365,
210
],
[
178,
211
],
[
365,
212
],
[
217,
214
],
[
374,
215
],
[
178,
216
],
[
374,
220
],
[
178,
222
],
[
197,
224
],
[
377,
225
],
[
178,
226
],
[
365,
227
],
[
229,
229
],
[
267,
234
],
[
269,
235
],
[
267,
241
],
[
269,
244
],
[
383,
252
],
[
267,
253
],
[
374,
257
],
[
269,
258
],
[
374,
260
],
[
267,
262
],
[
269,
263
],
[
365,
264
],
[
365,
265
],
[
267,
267
],
[
269,
269
],
[
344,
271
],
[
283,
282
],
[
353,
284
],
[
283,
285
],
[
283,
286
],
[
283,
287
],
[
290,
289
],
[
293,
292
],
[
282,
296
],
[
286,
297
],
[
300,
299
],
[
341,
302
],
[
287,
305
],
[
292,
306
],
[
292,
308
],
[
341,
310
],
[
285,
315
],
[
282,
316
],
[
287,
317
],
[
292,
318
],
[
285,
322
],
[
287,
324
],
[
327,
326
],
[
365,
327
],
[
330,
329
],
[
326,
330
],
[
299,
330
],
[
333,
332
],
[
365,
333
],
[
332,
336
],
[
329,
336
],
[
289,
336
],
[
371,
338
],
[
358,
359
],
[
361,
362
],
[
364,
365
],
[
373,
374
],
[
376,
377
],
[
382,
383
],
[
388,
389
]
] | [
"import math,string,itertools,fractions,heapq,collections,re,array,bisect,sys,random,time,copy,functools\nfrom collections import deque\n\nsys.setrecursionlimit(10**7)\ninf = 10**20\nmod = 10**9 + 7\n\nDR = [1, -1, 0, 0]\nDC = [0, 0, 1, -1]\n\ndef LI(): return [int(x) for x in sys.stdin.readline().split()]\ndef LI_(): return [int(x)-1 for x in sys.stdin.readline().split()]\ndef LF(): return [float(x) for x in sys.stdin.readline().split()]\ndef LS(): return sys.stdin.readline().split()\ndef I(): return int(sys.stdin.readline())\ndef F(): return float(sys.stdin.readline())\ndef S(): return input()\n \n\nfac = [-1] * (2 * 10**6+1)\ninv = [-1] * (2 * 10**6+1)\nfinv = [-1] * (2 * 10**6+1)\n\nfac[0] = fac[1] = 1\ninv[1] = 1\nfinv[0] = finv[1] = 1\n\ndef initNCMMod(limit):\n for i in range(2, limit):\n fac[i] = fac[i-1] * i % mod\n inv[i] = mod - inv[mod%i] * (mod // i) % mod\n finv[i] = finv[i-1] * inv[i] % mod\n\ndef NCMMod(n, k):\n if n < k:\n return 0\n if (n < 0 or k < 0):\n return 0\n return fac[n] * (finv[k] * finv[n-k] % mod) % mod\n\ninitNCMMod(2 * 10**6 + 1)\ndef main():\n H, W, A, B = LI()\n cnt = 0\n for i in range(H-A):\n way = NCMMod(B + i - 1, i) * NCMMod(W + H - B - i - 2, W - 1 - B)\n way %= mod\n cnt += way\n cnt %= mod\n print(cnt)\n\n\nmain()\n",
"import math,string,itertools,fractions,heapq,collections,re,array,bisect,sys,random,time,copy,functools",
"math",
"string",
"itertools",
"fractions",
"heapq",
"collections",
"re",
"array",
"bisect",
"sys",
"random",
"time",
"copy",
"functools",
"from collections import deque",
"sys.setrecursionlimit(10**7)",
"sys.setrecursionlimit",
"sys",
"setrecursionlimit",
"10**7",
"10",
"7",
"inf = 10**20",
"inf",
"10**20",
"10",
"20",
"mod = 10**9 + 7",
"mod",
"10**9 + 7",
"10**9",
"10",
"9",
"7",
"DR = [1, -1, 0, 0]",
"DR",
"[1, -1, 0, 0]",
"1",
"-1",
"0",
"0",
"DC = [0, 0, 1, -1]",
"DC",
"[0, 0, 1, -1]",
"0",
"0",
"1",
"-1",
"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",
"int(x)-1 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)-1",
"int(x)",
"int",
"x",
"1",
"def LI_(): return [int(x)-1 for x in sys.stdin.readline().split()]",
"LI_",
"float(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()",
"float(x)",
"float",
"x",
"def LF(): return [float(x) for x in sys.stdin.readline().split()]",
"LF",
"def LS(): return sys.stdin.readline().split()",
"LS",
"def I(): return int(sys.stdin.readline())",
"I",
"def F(): return float(sys.stdin.readline())",
"F",
"def S(): return input()\n ",
"S",
"fac = [-1] * (2 * 10**6+1)",
"fac",
"[-1] * (2 * 10**6+1)",
"[-1]",
"-1",
"2 * 10**6+1",
"2 * 10**6",
"2",
"10**6",
"10",
"6",
"1",
"inv = [-1] * (2 * 10**6+1)",
"inv",
"[-1] * (2 * 10**6+1)",
"[-1]",
"-1",
"2 * 10**6+1",
"2 * 10**6",
"2",
"10**6",
"10",
"6",
"1",
"finv = [-1] * (2 * 10**6+1)",
"finv",
"[-1] * (2 * 10**6+1)",
"[-1]",
"-1",
"2 * 10**6+1",
"2 * 10**6",
"2",
"10**6",
"10",
"6",
"1",
"fac[0] = fac[1] = 1",
"fac[0]",
"fac",
"0",
"1",
"= fac[1] = 1",
"fac[1]",
"fac",
"1",
"1",
"inv[1] = 1",
"inv[1]",
"inv",
"1",
"1",
"finv[0] = finv[1] = 1",
"finv[0]",
"finv",
"0",
"1",
"= finv[1] = 1",
"finv[1]",
"finv",
"1",
"1",
"def initNCMMod(limit):\n for i in range(2, limit):\n fac[i] = fac[i-1] * i % mod\n inv[i] = mod - inv[mod%i] * (mod // i) % mod\n finv[i] = finv[i-1] * inv[i] % mod",
"initNCMMod",
"for i in range(2, limit):\n fac[i] = fac[i-1] * i % mod\n inv[i] = mod - inv[mod%i] * (mod // i) % mod\n finv[i] = finv[i-1] * inv[i] % mod",
"i",
"range(2, limit)",
"range",
"2",
"limit",
"fac[i] = fac[i-1] * i % mod",
"fac[i]",
"fac",
"i",
"fac[i-1] * i % mod",
"fac[i-1] * i",
"fac[i-1]",
"fac",
"i-1",
"i",
"1",
"i",
"mod",
"inv[i] = mod - inv[mod%i] * (mod // i) % mod",
"inv[i]",
"inv",
"i",
"mod - inv[mod%i] * (mod // i) % mod",
"mod",
"inv[mod%i] * (mod // i) % mod",
"inv[mod%i] * (mod // i)",
"inv[mod%i]",
"inv",
"mod%i",
"mod",
"i",
"mod // i",
"mod",
"i",
"mod",
"finv[i] = finv[i-1] * inv[i] % mod",
"finv[i]",
"finv",
"i",
"finv[i-1] * inv[i] % mod",
"finv[i-1] * inv[i]",
"finv[i-1]",
"finv",
"i-1",
"i",
"1",
"inv[i]",
"inv",
"i",
"mod",
"limit",
"limit",
"def NCMMod(n, k):\n if n < k:\n return 0\n if (n < 0 or k < 0):\n return 0\n return fac[n] * (finv[k] * finv[n-k] % mod) % mod",
"NCMMod",
"if n < k:\n return 0\n ",
"n < k",
"n",
"k",
"return 0",
"0",
"if (n < 0 or k < 0):\n return 0\n ",
"n < 0 or k < 0",
"n < 0",
"n",
"0",
"k < 0",
"k",
"0",
"return 0",
"0",
"return fac[n] * (finv[k] * finv[n-k] % mod) % mod",
"fac[n] * (finv[k] * finv[n-k] % mod) % mod",
"fac[n] * (finv[k] * finv[n-k] % mod)",
"fac[n]",
"fac",
"n",
"finv[k] * finv[n-k] % mod",
"finv[k] * finv[n-k]",
"finv[k]",
"finv",
"k",
"finv[n-k]",
"finv",
"n-k",
"n",
"k",
"mod",
"mod",
"n",
"n",
"k",
"k",
"initNCMMod(2 * 10**6 + 1)",
"initNCMMod",
"2 * 10**6 + 1",
"2 * 10**6",
"2",
"10**6",
"10",
"6",
"1",
"def main():\n H, W, A, B = LI()\n cnt = 0\n for i in range(H-A):\n way = NCMMod(B + i - 1, i) * NCMMod(W + H - B - i - 2, W - 1 - B)\n way %= mod\n cnt += way\n cnt %= mod\n print(cnt)",
"main",
"H, W, A, B = LI()",
"H",
"LI()",
"LI",
"W",
"A",
"B",
"cnt = 0",
"cnt",
"0",
"for i in range(H-A):\n way = NCMMod(B + i - 1, i) * NCMMod(W + H - B - i - 2, W - 1 - B)\n way %= mod\n cnt += way\n cnt %= mod\n ",
"i",
"range(H-A)",
"range",
"H-A",
"H",
"A",
"way = NCMMod(B + i - 1, i) * NCMMod(W + H - B - i - 2, W - 1 - B)",
"way",
"NCMMod(B + i - 1, i) * NCMMod(W + H - B - i - 2, W - 1 - B)",
"NCMMod(B + i - 1, i)",
"NCMMod",
"B + i - 1",
"B + i",
"B",
"i",
"1",
"i",
"NCMMod(W + H - B - i - 2, W - 1 - B)",
"NCMMod",
"W + H - B - i - 2",
"W + H - B - i",
"W + H - B",
"W + H",
"W",
"H",
"B",
"i",
"2",
"W - 1 - B",
"W - 1",
"W",
"1",
"B",
"way %= mod",
"way",
"mod",
"cnt += way",
"cnt",
"way",
"cnt %= mod",
"cnt",
"mod",
"print(cnt)",
"print",
"cnt",
"main()",
"main",
"def NCMMod(n, k):\n if n < k:\n return 0\n if (n < 0 or k < 0):\n return 0\n return fac[n] * (finv[k] * finv[n-k] % mod) % mod",
"def NCMMod(n, k):\n if n < k:\n return 0\n if (n < 0 or k < 0):\n return 0\n return fac[n] * (finv[k] * finv[n-k] % mod) % mod",
"NCMMod",
"def initNCMMod(limit):\n for i in range(2, limit):\n fac[i] = fac[i-1] * i % mod\n inv[i] = mod - inv[mod%i] * (mod // i) % mod\n finv[i] = finv[i-1] * inv[i] % mod",
"def initNCMMod(limit):\n for i in range(2, limit):\n fac[i] = fac[i-1] * i % mod\n inv[i] = mod - inv[mod%i] * (mod // i) % mod\n finv[i] = finv[i-1] * inv[i] % mod",
"initNCMMod",
"def I(): return int(sys.stdin.readline())",
"def I(): return int(sys.stdin.readline())",
"I",
"def S(): return input()\n ",
"def S(): return input()\n ",
"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 F(): return float(sys.stdin.readline())",
"def F(): return float(sys.stdin.readline())",
"F",
"inf = 10**20",
"10**20",
"inf",
"DC = [0, 0, 1, -1]",
"[0, 0, 1, -1]",
"DC",
"mod = 10**9 + 7",
"10**9 + 7",
"mod",
"def LI_(): return [int(x)-1 for x in sys.stdin.readline().split()]",
"def LI_(): return [int(x)-1 for x in sys.stdin.readline().split()]",
"LI_",
"def main():\n H, W, A, B = LI()\n cnt = 0\n for i in range(H-A):\n way = NCMMod(B + i - 1, i) * NCMMod(W + H - B - i - 2, W - 1 - B)\n way %= mod\n cnt += way\n cnt %= mod\n print(cnt)",
"def main():\n H, W, A, B = LI()\n cnt = 0\n for i in range(H-A):\n way = NCMMod(B + i - 1, i) * NCMMod(W + H - B - i - 2, W - 1 - B)\n way %= mod\n cnt += way\n cnt %= mod\n print(cnt)",
"main",
"finv = [-1] * (2 * 10**6+1)",
"[-1] * (2 * 10**6+1)",
"finv",
"inv = [-1] * (2 * 10**6+1)",
"[-1] * (2 * 10**6+1)",
"inv",
"def LF(): return [float(x) for x in sys.stdin.readline().split()]",
"def LF(): return [float(x) for x in sys.stdin.readline().split()]",
"LF",
"fac = [-1] * (2 * 10**6+1)",
"[-1] * (2 * 10**6+1)",
"fac",
"def LS(): return sys.stdin.readline().split()",
"def LS(): return sys.stdin.readline().split()",
"LS",
"DR = [1, -1, 0, 0]",
"[1, -1, 0, 0]",
"DR"
] | import math,string,itertools,fractions,heapq,collections,re,array,bisect,sys,random,time,copy,functools
from collections import deque
sys.setrecursionlimit(10**7)
inf = 10**20
mod = 10**9 + 7
DR = [1, -1, 0, 0]
DC = [0, 0, 1, -1]
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def LI_(): return [int(x)-1 for x in sys.stdin.readline().split()]
def LF(): return [float(x) for x in sys.stdin.readline().split()]
def LS(): return sys.stdin.readline().split()
def I(): return int(sys.stdin.readline())
def F(): return float(sys.stdin.readline())
def S(): return input()
fac = [-1] * (2 * 10**6+1)
inv = [-1] * (2 * 10**6+1)
finv = [-1] * (2 * 10**6+1)
fac[0] = fac[1] = 1
inv[1] = 1
finv[0] = finv[1] = 1
def initNCMMod(limit):
for i in range(2, limit):
fac[i] = fac[i-1] * i % mod
inv[i] = mod - inv[mod%i] * (mod // i) % mod
finv[i] = finv[i-1] * inv[i] % mod
def NCMMod(n, k):
if n < k:
return 0
if (n < 0 or k < 0):
return 0
return fac[n] * (finv[k] * finv[n-k] % mod) % mod
initNCMMod(2 * 10**6 + 1)
def main():
H, W, A, B = LI()
cnt = 0
for i in range(H-A):
way = NCMMod(B + i - 1, i) * NCMMod(W + H - B - i - 2, W - 1 - B)
way %= mod
cnt += way
cnt %= mod
print(cnt)
main()
|
[
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,
2,
17,
17,
17,
0,
13,
2,
39,
17,
13,
0,
13,
2,
39,
17,
13,
0,
13,
2,
39,
17,
13,
0,
18,
13,
17,
17,
0,
18,
13,
17,
17,
0,
18,
13,
17,
17,
0,
18,
13,
17,
17,
0,
18,
13,
17,
17,
0,
18,
13,
17,
17,
28,
13,
4,
13,
17,
13,
0,
18,
13,
13,
2,
13,
2,
2,
2,
13,
13,
18,
13,
2,
13,
13,
13,
0,
18,
13,
13,
2,
2,
18,
13,
2,
13,
17,
13,
13,
0,
18,
13,
13,
2,
2,
18,
13,
2,
13,
17,
18,
13,
13,
13,
12,
13,
14,
2,
40,
13,
17,
40,
13,
17,
29,
2,
2,
2,
2,
18,
13,
13,
18,
13,
2,
13,
13,
13,
18,
13,
13,
13,
29,
17,
23,
13,
23,
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,
2,
13,
13,
17,
13,
13,
17,
2,
2,
13,
13,
17,
0,
13,
13,
4,
13,
13,
10,
2,
13,
10,
13,
13,
10,
2,
13,
10,
12,
13,
10,
2,
13,
10,
2,
13,
10,
2,
13,
10,
4,
13,
10,
2,
13,
10,
17,
13,
10,
4,
13,
10,
4,
13,
10,
4,
13,
10,
2,
13
] | [
[
252,
2
],
[
252,
11
],
[
252,
12
],
[
252,
13
],
[
255,
15
],
[
247,
18
],
[
250,
19
],
[
240,
22
],
[
216,
29
],
[
222,
36
],
[
256,
40
],
[
231,
42
],
[
256,
46
],
[
228,
48
],
[
256,
52
],
[
57,
54
],
[
232,
55
],
[
62,
59
],
[
232,
60
],
[
72,
64
],
[
223,
65
],
[
72,
69
],
[
223,
70
],
[
82,
74
],
[
229,
75
],
[
82,
79
],
[
229,
80
],
[
85,
84
],
[
256,
88
],
[
93,
90
],
[
232,
91
],
[
84,
92
],
[
241,
94
],
[
241,
98
],
[
84,
99
],
[
232,
101
],
[
241,
103
],
[
84,
104
],
[
241,
105
],
[
110,
107
],
[
223,
108
],
[
84,
109
],
[
223,
113
],
[
84,
115
],
[
84,
117
],
[
241,
118
],
[
123,
120
],
[
229,
121
],
[
84,
122
],
[
229,
126
],
[
84,
128
],
[
90,
130
],
[
232,
131
],
[
84,
132
],
[
241,
133
],
[
167,
139
],
[
165,
142
],
[
223,
150
],
[
165,
151
],
[
229,
153
],
[
165,
155
],
[
167,
156
],
[
241,
157
],
[
229,
159
],
[
167,
160
],
[
241,
161
],
[
165,
165
],
[
167,
167
],
[
243,
169
],
[
173,
172
],
[
247,
176
],
[
238,
177
],
[
234,
179
],
[
226,
182
],
[
172,
185
],
[
253,
186
],
[
253,
189
],
[
226,
192
],
[
247,
198
],
[
172,
199
],
[
250,
201
],
[
253,
202
],
[
250,
206
],
[
253,
207
],
[
219,
210
],
[
241,
211
],
[
220,
214
],
[
235,
214
],
[
244,
214
],
[
216,
217
],
[
241,
219
],
[
219,
220
],
[
222,
223
],
[
228,
229
],
[
231,
232
],
[
234,
235
],
[
252,
238
],
[
240,
241
],
[
243,
244
],
[
252,
247
],
[
252,
250
],
[
252,
253
],
[
255,
256
]
] | [
"h, w, a, b = map( int, input().split() )\n\nSIZE = h+w+2\nMOD = 10**9 + 7\nMOD_Farmer = 10**9+5\n\nfact = [0] * SIZE\ninv = [0] * SIZE\nfact_inv = [0] * SIZE\n\n# prepare --------------------------------\ninv[0] = 0\ninv[1] = 1\nfact[0] = fact[1] = 1\nfact_inv[0] = fact_inv[1] = 1\nfor i in range( 2, SIZE ):\n inv[i] = MOD - (MOD//i)*inv[MOD%i]%MOD\n fact[i] = fact[i-1] * i % MOD\n fact_inv[i] = fact_inv[i-1] * inv[i] % MOD\n# fact_inv[i] = fact[i] **( 10**4 ) \\\n# * fact[i] **( 10**5 ) \\\n# * fact[i] ** 5 % MOD % MOD\n# ----------------------------------------\ndef comb( n, r ):\n if r >= 0 and n >= 0:\n return fact[n] * fact_inv[n-r]%MOD * fact_inv[r]%MOD\n else :\n return 0.0\n# ----------------------------------------\n\n#print( fact_inv )\n\nans = 0\nfor i in range( h-a ):\n ans += comb(i+b-1, b-1) * comb(h-i-1+w-b-1,w-b-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",
"SIZE = h+w+2",
"SIZE",
"h+w+2",
"h+w",
"h",
"w",
"2",
"MOD = 10**9 + 7",
"MOD",
"10**9 + 7",
"10**9",
"10",
"9",
"7",
"MOD_Farmer = 10**9+5",
"MOD_Farmer",
"10**9+5",
"10**9",
"10",
"9",
"5",
"fact = [0] * SIZE",
"fact",
"[0] * SIZE",
"[0]",
"0",
"SIZE",
"inv = [0] * SIZE",
"inv",
"[0] * SIZE",
"[0]",
"0",
"SIZE",
"fact_inv = [0] * SIZE",
"fact_inv",
"[0] * SIZE",
"[0]",
"0",
"SIZE",
"inv[0] = 0",
"inv[0]",
"inv",
"0",
"0",
"inv[1] = 1",
"inv[1]",
"inv",
"1",
"1",
"fact[0] = fact[1] = 1",
"fact[0]",
"fact",
"0",
"1",
"= fact[1] = 1",
"fact[1]",
"fact",
"1",
"1",
"fact_inv[0] = fact_inv[1] = 1",
"fact_inv[0]",
"fact_inv",
"0",
"1",
"= fact_inv[1] = 1",
"fact_inv[1]",
"fact_inv",
"1",
"1",
"for i in range( 2, SIZE ):\n inv[i] = MOD - (MOD//i)*inv[MOD%i]%MOD\n fact[i] = fact[i-1] * i % MOD\n fact_inv[i] = fact_inv[i-1] * inv[i] % MOD\n# fact_inv[i] = fact[i] **( 10**4 ) \\\n# * fact[i] **( 10**5 ) \\\n# * fact[i] ** 5 % MOD % MOD\n# ----------------------------------------",
"i",
"range( 2, SIZE )",
"range",
"2",
"SIZE",
"inv[i] = MOD - (MOD//i)*inv[MOD%i]%MOD",
"inv[i]",
"inv",
"i",
"MOD - (MOD//i)*inv[MOD%i]%MOD",
"MOD",
"(MOD//i)*inv[MOD%i]%MOD",
"(MOD//i)*inv[MOD%i]",
"MOD//i",
"MOD",
"i",
"inv[MOD%i]",
"inv",
"MOD%i",
"MOD",
"i",
"MOD",
"fact[i] = fact[i-1] * i % MOD",
"fact[i]",
"fact",
"i",
"fact[i-1] * i % MOD",
"fact[i-1] * i",
"fact[i-1]",
"fact",
"i-1",
"i",
"1",
"i",
"MOD",
"fact_inv[i] = fact_inv[i-1] * inv[i] % MOD",
"fact_inv[i]",
"fact_inv",
"i",
"fact_inv[i-1] * inv[i] % MOD",
"fact_inv[i-1] * inv[i]",
"fact_inv[i-1]",
"fact_inv",
"i-1",
"i",
"1",
"inv[i]",
"inv",
"i",
"MOD",
"def comb( n, r ):\n if r >= 0 and n >= 0:\n return fact[n] * fact_inv[n-r]%MOD * fact_inv[r]%MOD\n else :\n return 0.0\n# ----------------------------------------\n\n#print( fact_inv )",
"comb",
"if r >= 0 and n >= 0:\n return fact[n] * fact_inv[n-r]%MOD * fact_inv[r]%MOD\n else :\n return 0.0\n# ----------------------------------------\n\n#print( fact_inv )",
"r >= 0 and n >= 0",
"r >= 0",
"r",
"0",
"n >= 0",
"n",
"0",
"return fact[n] * fact_inv[n-r]%MOD * fact_inv[r]%MOD",
"fact[n] * fact_inv[n-r]%MOD * fact_inv[r]%MOD",
"fact[n] * fact_inv[n-r]%MOD * fact_inv[r]",
"fact[n] * fact_inv[n-r]%MOD",
"fact[n] * fact_inv[n-r]",
"fact[n]",
"fact",
"n",
"fact_inv[n-r]",
"fact_inv",
"n-r",
"n",
"r",
"MOD",
"fact_inv[r]",
"fact_inv",
"r",
"MOD",
"return 0.0",
"0.0",
"n",
"n",
"r",
"r",
"ans = 0",
"ans",
"0",
"for i in range( h-a ):\n ans += comb(i+b-1, b-1) * comb(h-i-1+w-b-1,w-b-1)\n ans %= MOD",
"i",
"range( h-a )",
"range",
"h-a",
"h",
"a",
"ans += comb(i+b-1, b-1) * comb(h-i-1+w-b-1,w-b-1)",
"ans",
"comb(i+b-1, b-1) * comb(h-i-1+w-b-1,w-b-1)",
"comb(i+b-1, b-1)",
"comb",
"i+b-1",
"i+b",
"i",
"b",
"1",
"b-1",
"b",
"1",
"comb(h-i-1+w-b-1,w-b-1)",
"comb",
"h-i-1+w-b-1",
"h-i-1+w-b",
"h-i-1+w",
"h-i-1",
"h-i",
"h",
"i",
"1",
"w",
"b",
"1",
"w-b-1",
"w-b",
"w",
"b",
"1",
"ans %= MOD",
"ans",
"MOD",
"print( ans )",
"print",
"ans",
"MOD_Farmer = 10**9+5",
"10**9+5",
"MOD_Farmer",
"ans %= MOD",
"MOD",
"ans",
"fact = [0] * SIZE",
"[0] * SIZE",
"fact",
"def comb( n, r ):\n if r >= 0 and n >= 0:\n return fact[n] * fact_inv[n-r]%MOD * fact_inv[r]%MOD\n else :\n return 0.0\n# ----------------------------------------\n\n#print( fact_inv )",
"def comb( n, r ):\n if r >= 0 and n >= 0:\n return fact[n] * fact_inv[n-r]%MOD * fact_inv[r]%MOD\n else :\n return 0.0\n# ----------------------------------------\n\n#print( fact_inv )",
"comb",
"fact_inv = [0] * SIZE",
"[0] * SIZE",
"fact_inv",
"inv = [0] * SIZE",
"[0] * SIZE",
"inv",
"ans += comb(i+b-1, b-1) * comb(h-i-1+w-b-1,w-b-1)",
"comb(i+b-1, b-1) * comb(h-i-1+w-b-1,w-b-1)",
"ans",
"a, b = map( int, input().split() )",
"map( int, input().split() )",
"a",
"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",
"w, a, b = map( int, input().split() )",
"map( int, input().split() )",
"w",
"b = map( int, input().split() )",
"map( int, input().split() )",
"b",
"SIZE = h+w+2",
"h+w+2",
"SIZE"
] | h, w, a, b = map( int, input().split() )
SIZE = h+w+2
MOD = 10**9 + 7
MOD_Farmer = 10**9+5
fact = [0] * SIZE
inv = [0] * SIZE
fact_inv = [0] * SIZE
# prepare --------------------------------
inv[0] = 0
inv[1] = 1
fact[0] = fact[1] = 1
fact_inv[0] = fact_inv[1] = 1
for i in range( 2, SIZE ):
inv[i] = MOD - (MOD//i)*inv[MOD%i]%MOD
fact[i] = fact[i-1] * i % MOD
fact_inv[i] = fact_inv[i-1] * inv[i] % MOD
# fact_inv[i] = fact[i] **( 10**4 ) \
# * fact[i] **( 10**5 ) \
# * fact[i] ** 5 % MOD % MOD
# ----------------------------------------
def comb( n, r ):
if r >= 0 and n >= 0:
return fact[n] * fact_inv[n-r]%MOD * fact_inv[r]%MOD
else :
return 0.0
# ----------------------------------------
#print( fact_inv )
ans = 0
for i in range( h-a ):
ans += comb(i+b-1, b-1) * comb(h-i-1+w-b-1,w-b-1)
ans %= MOD
print( ans ) |
[
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,
41,
28,
13,
4,
13,
2,
13,
17,
4,
4,
13,
18,
18,
13,
13,
13,
2,
13,
17,
13,
0,
18,
13,
13,
13,
0,
18,
13,
13,
13,
23,
13,
23,
13,
23,
13,
12,
13,
17,
29,
18,
18,
13,
13,
13,
23,
13,
23,
13,
12,
13,
17,
29,
18,
18,
13,
13,
13,
23,
13,
23,
13,
12,
13,
17,
29,
2,
2,
2,
18,
18,
13,
13,
13,
18,
18,
13,
13,
2,
13,
13,
18,
18,
13,
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,
13,
13,
13,
0,
13,
17,
28,
13,
4,
13,
17,
2,
13,
13,
0,
13,
2,
4,
18,
13,
13,
2,
2,
13,
17,
13,
13,
4,
18,
13,
13,
2,
2,
2,
13,
13,
17,
2,
2,
13,
13,
17,
2,
2,
13,
13,
17,
0,
13,
2,
13,
13,
4,
13,
13,
10,
4,
13,
10,
17,
13,
10,
4,
13,
10,
4,
13,
10,
4,
13,
10,
2,
13,
10,
2,
13,
10,
6,
13,
10,
4,
13,
10,
2,
13
] | [
[
9,
6
],
[
65,
7
],
[
13,
12
],
[
67,
17
],
[
6,
21
],
[
65,
22
],
[
6,
28
],
[
65,
29
],
[
12,
32
],
[
69,
33
],
[
37,
36
],
[
67,
40
],
[
6,
46
],
[
65,
47
],
[
36,
49
],
[
69,
51
],
[
69,
53
],
[
58,
55
],
[
65,
56
],
[
63,
60
],
[
65,
61
],
[
69,
62
],
[
69,
63
],
[
65,
65
],
[
67,
67
],
[
69,
69
],
[
80,
76
],
[
82,
78
],
[
80,
80
],
[
82,
82
],
[
93,
89
],
[
95,
91
],
[
93,
93
],
[
95,
95
],
[
124,
105
],
[
126,
107
],
[
124,
110
],
[
126,
113
],
[
128,
114
],
[
124,
117
],
[
128,
119
],
[
124,
121
],
[
124,
124
],
[
126,
126
],
[
128,
128
],
[
234,
130
],
[
234,
139
],
[
234,
140
],
[
234,
141
],
[
237,
143
],
[
210,
150
],
[
223,
154
],
[
220,
155
],
[
238,
156
],
[
213,
158
],
[
162,
161
],
[
223,
166
],
[
235,
167
],
[
225,
169
],
[
211,
173
],
[
97,
174
],
[
217,
177
],
[
161,
179
],
[
161,
180
],
[
211,
183
],
[
97,
184
],
[
220,
188
],
[
217,
189
],
[
223,
193
],
[
161,
194
],
[
220,
198
],
[
217,
199
],
[
228,
202
],
[
226,
204
],
[
214,
204
],
[
229,
204
],
[
238,
205
],
[
229,
208
],
[
226,
208
],
[
214,
208
],
[
210,
211
],
[
213,
214
],
[
234,
217
],
[
234,
220
],
[
234,
223
],
[
225,
226
],
[
228,
229
],
[
234,
235
],
[
237,
238
]
] | [
"#Combinationクラス\nclass Combination:\n\n def __init__(self, n, MOD):\n self.fact = [1]\n for i in range(1, n + 1):\n self.fact.append(self.fact[-1] * i % MOD)\n self.inv_fact = [pow(self.fact[i] ,MOD - 2 ,MOD) for i in range(n + 1)]\n self.MOD = MOD\n\n def factorial(self, k):\n '''k!を求める'''\n return self.fact[k]\n\n def inverse_factorial(self, k):\n '''k!の逆元を求める'''\n return self.inv_fact[k]\n\n def combination(self, k, r):\n '''kCrを求める'''\n return (self.fact[k] * self.inv_fact[k - r] * self.inv_fact[r]) % self.MOD\n\n\nh, w, a, b = map(int,input().split())\nMOD = 10**9 + 7\ncomb = Combination(h+w, MOD)\nans = 0\nfor i in range(0, h-a):\n ans += comb.combination((b-1)+i,i) * comb.combination((w-b-1)+(h-i-1), w-b-1)\n ans = ans % MOD\nprint(ans)",
"class Combination:\n\n def __init__(self, n, MOD):\n self.fact = [1]\n for i in range(1, n + 1):\n self.fact.append(self.fact[-1] * i % MOD)\n self.inv_fact = [pow(self.fact[i] ,MOD - 2 ,MOD) for i in range(n + 1)]\n self.MOD = MOD\n\n def factorial(self, k):\n '''k!を求める'''\n return self.fact[k]\n\n def inverse_factorial(self, k):\n '''k!の逆元を求める'''\n return self.inv_fact[k]\n\n def combination(self, k, r):\n '''kCrを求める'''\n return (self.fact[k] * self.inv_fact[k - r] * self.inv_fact[r]) % self.MOD",
"Combination",
"def __init__(self, n, MOD):\n self.fact = [1]\n for i in range(1, n + 1):\n self.fact.append(self.fact[-1] * i % MOD)\n self.inv_fact = [pow(self.fact[i] ,MOD - 2 ,MOD) for i in range(n + 1)]\n self.MOD = MOD\n\n ",
"__init__",
"self.fact = [1]",
"self.fact",
"self",
"fact",
"[1]",
"1",
"for i in range(1, n + 1):\n self.fact.append(self.fact[-1] * i % MOD)\n ",
"i",
"range(1, n + 1)",
"range",
"1",
"n + 1",
"n",
"1",
"self.fact.append(self.fact[-1] * i % MOD)",
"self.fact.append",
"self.fact",
"self",
"fact",
"append",
"self.fact[-1] * i % MOD",
"self.fact[-1] * i",
"self.fact[-1]",
"self.fact",
"self",
"fact",
"-1",
"i",
"MOD",
"pow(self.fact[i] ,MOD - 2 ,MOD) for i in range(n + 1)",
"for i in range(n + 1)",
"i",
"range(n + 1)",
"range",
"n + 1",
"n",
"1",
"for i in range(n + 1)",
"pow(self.fact[i] ,MOD - 2 ,MOD)",
"pow",
"self.fact[i]",
"self.fact",
"self",
"fact",
"i",
"MOD - 2",
"MOD",
"2",
"MOD",
"self.inv_fact = [pow(self.fact[i] ,MOD - 2 ,MOD) for i in range(n + 1)]",
"self.inv_fact",
"self",
"inv_fact",
"[pow(self.fact[i] ,MOD - 2 ,MOD) for i in range(n + 1)]",
"self.MOD = MOD",
"self.MOD",
"self",
"MOD",
"MOD",
"self",
"self",
"n",
"n",
"MOD",
"MOD",
"def factorial(self, k):\n '''k!を求める'''\n return self.fact[k]\n\n ",
"factorial",
"'''k!を求める'''",
"return self.fact[k]",
"self.fact[k]",
"self.fact",
"self",
"fact",
"k",
"self",
"self",
"k",
"k",
"def inverse_factorial(self, k):\n '''k!の逆元を求める'''\n return self.inv_fact[k]\n\n ",
"inverse_factorial",
"'''k!の逆元を求める'''",
"return self.inv_fact[k]",
"self.inv_fact[k]",
"self.inv_fact",
"self",
"inv_fact",
"k",
"self",
"self",
"k",
"k",
"def combination(self, k, r):\n '''kCrを求める'''\n return (self.fact[k] * self.inv_fact[k - r] * self.inv_fact[r]) % self.MOD",
"combination",
"'''kCrを求める'''",
"return (self.fact[k] * self.inv_fact[k - r] * self.inv_fact[r]) % self.MOD",
"(self.fact[k] * self.inv_fact[k - r] * self.inv_fact[r]) % self.MOD",
"self.fact[k] * self.inv_fact[k - r] * self.inv_fact[r]",
"self.fact[k] * self.inv_fact[k - r]",
"self.fact[k]",
"self.fact",
"self",
"fact",
"k",
"self.inv_fact[k - r]",
"self.inv_fact",
"self",
"inv_fact",
"k - r",
"k",
"r",
"self.inv_fact[r]",
"self.inv_fact",
"self",
"inv_fact",
"r",
"self.MOD",
"self",
"MOD",
"self",
"self",
"k",
"k",
"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",
"comb = Combination(h+w, MOD)",
"comb",
"Combination(h+w, MOD)",
"Combination",
"h+w",
"h",
"w",
"MOD",
"ans = 0",
"ans",
"0",
"for i in range(0, h-a):\n ans += comb.combination((b-1)+i,i) * comb.combination((w-b-1)+(h-i-1), w-b-1)\n ans = ans % MOD",
"i",
"range(0, h-a)",
"range",
"0",
"h-a",
"h",
"a",
"ans += comb.combination((b-1)+i,i) * comb.combination((w-b-1)+(h-i-1), w-b-1)",
"ans",
"comb.combination((b-1)+i,i) * comb.combination((w-b-1)+(h-i-1), w-b-1)",
"comb.combination((b-1)+i,i)",
"comb.combination",
"comb",
"combination",
"(b-1)+i",
"b-1",
"b",
"1",
"i",
"i",
"comb.combination((w-b-1)+(h-i-1), w-b-1)",
"comb.combination",
"comb",
"combination",
"(w-b-1)+(h-i-1)",
"w-b-1",
"w-b",
"w",
"b",
"1",
"h-i-1",
"h-i",
"h",
"i",
"1",
"w-b-1",
"w-b",
"w",
"b",
"1",
"ans = ans % MOD",
"ans",
"ans % MOD",
"ans",
"MOD",
"print(ans)",
"print",
"ans",
"comb = Combination(h+w, MOD)",
"Combination(h+w, MOD)",
"comb",
"ans = 0",
"0",
"ans",
"b = map(int,input().split())",
"map(int,input().split())",
"b",
"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",
"ans += comb.combination((b-1)+i,i) * comb.combination((w-b-1)+(h-i-1), w-b-1)",
"comb.combination((b-1)+i,i) * comb.combination((w-b-1)+(h-i-1), w-b-1)",
"ans",
"ans = ans % MOD",
"ans % MOD",
"ans",
"class Combination:\n\n def __init__(self, n, MOD):\n self.fact = [1]\n for i in range(1, n + 1):\n self.fact.append(self.fact[-1] * i % MOD)\n self.inv_fact = [pow(self.fact[i] ,MOD - 2 ,MOD) for i in range(n + 1)]\n self.MOD = MOD\n\n def factorial(self, k):\n '''k!を求める'''\n return self.fact[k]\n\n def inverse_factorial(self, k):\n '''k!の逆元を求める'''\n return self.inv_fact[k]\n\n def combination(self, k, r):\n '''kCrを求める'''\n return (self.fact[k] * self.inv_fact[k - r] * self.inv_fact[r]) % self.MOD",
"class Combination:\n\n def __init__(self, n, MOD):\n self.fact = [1]\n for i in range(1, n + 1):\n self.fact.append(self.fact[-1] * i % MOD)\n self.inv_fact = [pow(self.fact[i] ,MOD - 2 ,MOD) for i in range(n + 1)]\n self.MOD = MOD\n\n def factorial(self, k):\n '''k!を求める'''\n return self.fact[k]\n\n def inverse_factorial(self, k):\n '''k!の逆元を求める'''\n return self.inv_fact[k]\n\n def combination(self, k, r):\n '''kCrを求める'''\n return (self.fact[k] * self.inv_fact[k - r] * self.inv_fact[r]) % self.MOD",
"Combination",
"a, b = map(int,input().split())",
"map(int,input().split())",
"a",
"MOD = 10**9 + 7",
"10**9 + 7",
"MOD"
] | #Combinationクラス
class Combination:
def __init__(self, n, MOD):
self.fact = [1]
for i in range(1, n + 1):
self.fact.append(self.fact[-1] * i % MOD)
self.inv_fact = [pow(self.fact[i] ,MOD - 2 ,MOD) for i in range(n + 1)]
self.MOD = MOD
def factorial(self, k):
'''k!を求める'''
return self.fact[k]
def inverse_factorial(self, k):
'''k!の逆元を求める'''
return self.inv_fact[k]
def combination(self, k, r):
'''kCrを求める'''
return (self.fact[k] * self.inv_fact[k - r] * self.inv_fact[r]) % self.MOD
h, w, a, b = map(int,input().split())
MOD = 10**9 + 7
comb = Combination(h+w, MOD)
ans = 0
for i in range(0, h-a):
ans += comb.combination((b-1)+i,i) * comb.combination((w-b-1)+(h-i-1), w-b-1)
ans = ans % MOD
print(ans) |
[
7,
0,
13,
2,
2,
17,
17,
17,
0,
13,
39,
17,
0,
13,
17,
28,
13,
4,
13,
17,
2,
2,
17,
2,
17,
17,
17,
0,
13,
13,
0,
13,
13,
0,
13,
39,
13,
12,
13,
14,
2,
13,
13,
29,
17,
0,
13,
18,
13,
13,
0,
13,
2,
18,
13,
2,
13,
13,
18,
13,
13,
29,
2,
2,
13,
4,
13,
13,
2,
13,
17,
13,
13,
23,
13,
23,
13,
12,
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,
17,
13,
13,
2,
13,
13,
0,
13,
13,
29,
13,
23,
13,
23,
13,
23,
13,
23,
13,
0,
13,
4,
13,
4,
13,
13,
4,
18,
4,
18,
4,
13,
13,
13,
17,
13,
13,
13,
4,
13,
4,
13,
13,
13,
13,
13,
10,
39,
13,
10,
2,
13,
10,
4,
13,
10,
4,
13,
10,
17,
13,
10,
13,
13,
10,
12,
13,
10,
4,
13,
10,
4,
13,
10,
39,
13,
10,
13,
13,
10,
12,
13
] | [
[
163,
2
],
[
187,
9
],
[
172,
13
],
[
17,
16
],
[
175,
28
],
[
16,
29
],
[
190,
31
],
[
164,
32
],
[
160,
34
],
[
74,
41
],
[
76,
42
],
[
47,
46
],
[
161,
48
],
[
188,
48
],
[
74,
49
],
[
52,
51
],
[
161,
54
],
[
188,
54
],
[
74,
56
],
[
76,
57
],
[
161,
59
],
[
188,
59
],
[
76,
60
],
[
46,
64
],
[
51,
67
],
[
164,
69
],
[
164,
71
],
[
164,
72
],
[
74,
74
],
[
76,
76
],
[
81,
80
],
[
84,
83
],
[
125,
89
],
[
129,
90
],
[
94,
93
],
[
194,
96
],
[
83,
99
],
[
131,
100
],
[
83,
103
],
[
194,
106
],
[
127,
111
],
[
131,
112
],
[
125,
114
],
[
83,
115
],
[
125,
117
],
[
83,
118
],
[
121,
120
],
[
164,
121
],
[
120,
123
],
[
93,
123
],
[
80,
123
],
[
191,
123
],
[
176,
123
],
[
173,
123
],
[
125,
125
],
[
127,
127
],
[
129,
129
],
[
131,
131
],
[
184,
133
],
[
184,
148
],
[
184,
149
],
[
184,
150
],
[
179,
154
],
[
167,
155
],
[
170,
156
],
[
182,
157
],
[
185,
158
],
[
160,
161
],
[
163,
164
],
[
184,
167
],
[
184,
170
],
[
172,
173
],
[
16,
175
],
[
175,
176
],
[
184,
182
],
[
184,
185
],
[
187,
188
],
[
164,
190
],
[
190,
191
]
] | [
"MOD=10**9+7\nfact=[1]\ntemp=1\nfor i in range(1,3*10**5+1):\n temp*=i\n temp%=MOD\n fact+=[temp]\n\ndef bino(a,b):\n if a<b:\n return 0\n up=fact[a]\n down=fact[a-b]*fact[b]\n return (up*pow(down,MOD-2,MOD))%MOD\n\ndef find(H,W,A,B):\n temp=0\n for x in range(1,H-A+1):\n temp+=bino(x+B-2,x-1)*bino(W-B-1+H-x,H-x)\n temp%=MOD\n return temp\n\nH,W,A,B=list(map(int,input().strip().split(\" \")))\nprint(find(H,W,A,B))\n",
"MOD=10**9+7",
"MOD",
"10**9+7",
"10**9",
"10",
"9",
"7",
"fact=[1]",
"fact",
"[1]",
"1",
"temp=1",
"temp",
"1",
"for i in range(1,3*10**5+1):\n temp*=i\n temp%=MOD\n fact+=[temp]",
"i",
"range(1,3*10**5+1)",
"range",
"1",
"3*10**5+1",
"3*10**5",
"3",
"10**5",
"10",
"5",
"1",
"temp*=i",
"temp",
"i",
"temp%=MOD",
"temp",
"MOD",
"fact+=[temp]",
"fact",
"[temp]",
"temp",
"def bino(a,b):\n if a<b:\n return 0\n up=fact[a]\n down=fact[a-b]*fact[b]\n return (up*pow(down,MOD-2,MOD))%MOD",
"bino",
"if a<b:\n return 0\n ",
"a<b",
"a",
"b",
"return 0",
"0",
"up=fact[a]",
"up",
"fact[a]",
"fact",
"a",
"down=fact[a-b]*fact[b]",
"down",
"fact[a-b]*fact[b]",
"fact[a-b]",
"fact",
"a-b",
"a",
"b",
"fact[b]",
"fact",
"b",
"return (up*pow(down,MOD-2,MOD))%MOD",
"(up*pow(down,MOD-2,MOD))%MOD",
"up*pow(down,MOD-2,MOD)",
"up",
"pow(down,MOD-2,MOD)",
"pow",
"down",
"MOD-2",
"MOD",
"2",
"MOD",
"MOD",
"a",
"a",
"b",
"b",
"def find(H,W,A,B):\n temp=0\n for x in range(1,H-A+1):\n temp+=bino(x+B-2,x-1)*bino(W-B-1+H-x,H-x)\n temp%=MOD\n return temp",
"find",
"temp=0",
"temp",
"0",
"for x in range(1,H-A+1):\n temp+=bino(x+B-2,x-1)*bino(W-B-1+H-x,H-x)\n temp%=MOD\n ",
"x",
"range(1,H-A+1)",
"range",
"1",
"H-A+1",
"H-A",
"H",
"A",
"1",
"temp+=bino(x+B-2,x-1)*bino(W-B-1+H-x,H-x)",
"temp",
"bino(x+B-2,x-1)*bino(W-B-1+H-x,H-x)",
"bino(x+B-2,x-1)",
"bino",
"x+B-2",
"x+B",
"x",
"B",
"2",
"x-1",
"x",
"1",
"bino(W-B-1+H-x,H-x)",
"bino",
"W-B-1+H-x",
"W-B-1+H",
"W-B-1",
"W-B",
"W",
"B",
"1",
"H",
"x",
"H-x",
"H",
"x",
"temp%=MOD",
"temp",
"MOD",
"return temp",
"temp",
"H",
"H",
"W",
"W",
"A",
"A",
"B",
"B",
"H,W,A,B=list(map(int,input().strip().split(\" \")))",
"H",
"list(map(int,input().strip().split(\" \")))",
"list",
"map(int,input().strip().split(\" \"))",
"map",
"int",
"input().strip().split(\" \")",
"().strip().split",
"().strip()",
"().strip",
"()",
"input",
"strip",
"split",
"\" \"",
"W",
"A",
"B",
"print(find(H,W,A,B))",
"print",
"find(H,W,A,B)",
"find",
"H",
"W",
"A",
"B",
"fact+=[temp]",
"[temp]",
"fact",
"MOD=10**9+7",
"10**9+7",
"MOD",
"H,W,A,B=list(map(int,input().strip().split(\" \")))",
"list(map(int,input().strip().split(\" \")))",
"H",
"W,A,B=list(map(int,input().strip().split(\" \")))",
"list(map(int,input().strip().split(\" \")))",
"W",
"temp=1",
"1",
"temp",
"temp*=i",
"i",
"temp",
"def find(H,W,A,B):\n temp=0\n for x in range(1,H-A+1):\n temp+=bino(x+B-2,x-1)*bino(W-B-1+H-x,H-x)\n temp%=MOD\n return temp",
"def find(H,W,A,B):\n temp=0\n for x in range(1,H-A+1):\n temp+=bino(x+B-2,x-1)*bino(W-B-1+H-x,H-x)\n temp%=MOD\n return temp",
"find",
"A,B=list(map(int,input().strip().split(\" \")))",
"list(map(int,input().strip().split(\" \")))",
"A",
"B=list(map(int,input().strip().split(\" \")))",
"list(map(int,input().strip().split(\" \")))",
"B",
"fact=[1]",
"[1]",
"fact",
"temp%=MOD",
"MOD",
"temp",
"def bino(a,b):\n if a<b:\n return 0\n up=fact[a]\n down=fact[a-b]*fact[b]\n return (up*pow(down,MOD-2,MOD))%MOD",
"def bino(a,b):\n if a<b:\n return 0\n up=fact[a]\n down=fact[a-b]*fact[b]\n return (up*pow(down,MOD-2,MOD))%MOD",
"bino"
] | MOD=10**9+7
fact=[1]
temp=1
for i in range(1,3*10**5+1):
temp*=i
temp%=MOD
fact+=[temp]
def bino(a,b):
if a<b:
return 0
up=fact[a]
down=fact[a-b]*fact[b]
return (up*pow(down,MOD-2,MOD))%MOD
def find(H,W,A,B):
temp=0
for x in range(1,H-A+1):
temp+=bino(x+B-2,x-1)*bino(W-B-1+H-x,H-x)
temp%=MOD
return temp
H,W,A,B=list(map(int,input().strip().split(" ")))
print(find(H,W,A,B))
|
[
7,
12,
13,
0,
13,
4,
13,
13,
13,
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,
0,
13,
2,
2,
13,
13,
17,
0,
13,
2,
39,
17,
13,
13,
2,
39,
17,
13,
13,
2,
39,
17,
13,
0,
18,
13,
39,
17,
39,
17,
17,
0,
18,
13,
39,
17,
39,
17,
17,
0,
18,
13,
39,
17,
39,
17,
17,
28,
13,
4,
13,
17,
13,
0,
18,
13,
13,
2,
2,
18,
13,
2,
13,
17,
13,
13,
0,
18,
13,
13,
2,
2,
40,
18,
13,
2,
13,
13,
2,
13,
13,
13,
0,
18,
13,
13,
2,
2,
18,
13,
2,
13,
17,
18,
13,
13,
13,
0,
13,
17,
28,
13,
4,
13,
2,
13,
13,
0,
13,
2,
2,
13,
13,
17,
0,
13,
2,
2,
13,
13,
17,
0,
13,
2,
2,
13,
2,
4,
13,
2,
2,
13,
13,
17,
13,
13,
4,
13,
2,
13,
13,
13,
13,
13,
4,
13,
13,
10,
2,
13,
10,
2,
13,
10,
4,
13,
10,
4,
13,
10,
2,
13,
10,
2,
13,
10,
2,
13,
10,
2,
13,
10,
2,
13,
10,
12,
13,
10,
12,
13,
10,
4,
13,
10,
4,
13,
10,
17,
13,
10,
2,
13
] | [
[
243,
4
],
[
235,
6
],
[
243,
7
],
[
243,
8
],
[
243,
9
],
[
249,
11
],
[
56,
22
],
[
56,
25
],
[
54,
26
],
[
31,
30
],
[
56,
33
],
[
54,
35
],
[
56,
36
],
[
54,
43
],
[
30,
46
],
[
56,
46
],
[
54,
50
],
[
30,
51
],
[
56,
51
],
[
58,
52
],
[
54,
54
],
[
56,
56
],
[
58,
58
],
[
228,
60
],
[
244,
63
],
[
217,
64
],
[
219,
67
],
[
229,
71
],
[
222,
72
],
[
229,
76
],
[
210,
77
],
[
229,
81
],
[
87,
83
],
[
220,
84
],
[
95,
91
],
[
223,
92
],
[
103,
99
],
[
211,
100
],
[
108,
107
],
[
229,
111
],
[
116,
113
],
[
220,
114
],
[
107,
115
],
[
220,
119
],
[
107,
121
],
[
107,
123
],
[
250,
124
],
[
129,
126
],
[
211,
127
],
[
107,
128
],
[
211,
133
],
[
250,
135
],
[
107,
136
],
[
250,
138
],
[
107,
139
],
[
250,
140
],
[
145,
142
],
[
223,
143
],
[
107,
144
],
[
223,
148
],
[
107,
150
],
[
126,
152
],
[
211,
153
],
[
107,
154
],
[
250,
155
],
[
246,
157
],
[
161,
160
],
[
244,
164
],
[
214,
165
],
[
207,
167
],
[
244,
170
],
[
160,
171
],
[
231,
174
],
[
217,
177
],
[
241,
178
],
[
225,
181
],
[
247,
184
],
[
226,
184
],
[
238,
187
],
[
160,
190
],
[
241,
191
],
[
160,
193
],
[
250,
194
],
[
238,
196
],
[
208,
198
],
[
232,
199
],
[
208,
200
],
[
250,
201
],
[
250,
202
],
[
226,
205
],
[
247,
205
],
[
207,
208
],
[
210,
211
],
[
243,
214
],
[
243,
217
],
[
219,
220
],
[
222,
223
],
[
225,
226
],
[
228,
229
],
[
231,
232
],
[
243,
241
],
[
243,
244
],
[
246,
247
],
[
249,
250
]
] | [
"def inpl(): return list(map(int, input().split()))\nH, W, A, B = inpl()\n\nMOD = 10**9 + 7\ndef cmb(n, r, mod):\n if ( r<0 or r>n ):\n return 0\n \n r = min(r, n-r)\n return g1[n] * g2[r] * g2[n-r] % mod\n \nsize = H+ W + 1\ng1, g2, inverse = [0]*size, [0]*size, [0]*size\n \ng1[:2] = [1, 1] # 元テーブル\ng2[:2] = [1, 1] #逆元テーブル\ninverse[:2] = [0, 1] #逆元テーブル計算用テーブル\n \nfor i in range(2, size):\n g1[i] = ( g1[i-1] * i ) % MOD \n inverse[i] = (-inverse[MOD % i] * (MOD//i) ) % MOD \n g2[i] = (g2[i-1] * inverse[i]) % MOD\n\nans = 0\nfor a in range(H-A):\n h = H - a - 1\n w = W - B - 1\n ans = (ans + cmb(a+B-1, a, MOD)*cmb(h+w, h, MOD))%MOD\nprint(ans)",
"def inpl(): return list(map(int, input().split()))",
"inpl",
"H, W, A, B = inpl()",
"H",
"inpl()",
"inpl",
"W",
"A",
"B",
"MOD = 10**9 + 7",
"MOD",
"10**9 + 7",
"10**9",
"10",
"9",
"7",
"def cmb(n, r, mod):\n if ( r<0 or r>n ):\n return 0\n \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 \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",
"size = H+ W + 1",
"size",
"H+ W + 1",
"H+ W",
"H",
"W",
"1",
"g1, g2, inverse = [0]*size, [0]*size, [0]*size",
"g1",
"[0]*size",
"[0]",
"0",
"size",
"g2",
"[0]*size",
"[0]",
"0",
"size",
"inverse",
"[0]*size",
"[0]",
"0",
"size",
"g1[:2] = [1, 1]",
"g1[:2]",
"g1",
":2",
"2",
"[1, 1]",
"1",
"1",
"g2[:2] = [1, 1]",
"g2[:2]",
"g2",
":2",
"2",
"[1, 1]",
"1",
"1",
"inverse[:2] = [0, 1]",
"inverse[:2]",
"inverse",
":2",
"2",
"[0, 1]",
"0",
"1",
"for i in range(2, size):\n g1[i] = ( g1[i-1] * i ) % MOD \n inverse[i] = (-inverse[MOD % i] * (MOD//i) ) % MOD \n g2[i] = (g2[i-1] * inverse[i]) % MOD",
"i",
"range(2, size)",
"range",
"2",
"size",
"g1[i] = ( g1[i-1] * i ) % MOD",
"g1[i]",
"g1",
"i",
"( g1[i-1] * i ) % MOD",
"g1[i-1] * i",
"g1[i-1]",
"g1",
"i-1",
"i",
"1",
"i",
"MOD",
"inverse[i] = (-inverse[MOD % i] * (MOD//i) ) % MOD",
"inverse[i]",
"inverse",
"i",
"(-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[i] = (g2[i-1] * inverse[i]) % MOD",
"g2[i]",
"g2",
"i",
"(g2[i-1] * inverse[i]) % MOD",
"g2[i-1] * inverse[i]",
"g2[i-1]",
"g2",
"i-1",
"i",
"1",
"inverse[i]",
"inverse",
"i",
"MOD",
"ans = 0",
"ans",
"0",
"for a in range(H-A):\n h = H - a - 1\n w = W - B - 1\n ans = (ans + cmb(a+B-1, a, MOD)*cmb(h+w, h, MOD))%MOD",
"a",
"range(H-A)",
"range",
"H-A",
"H",
"A",
"h = H - a - 1",
"h",
"H - a - 1",
"H - a",
"H",
"a",
"1",
"w = W - B - 1",
"w",
"W - B - 1",
"W - B",
"W",
"B",
"1",
"ans = (ans + cmb(a+B-1, a, MOD)*cmb(h+w, h, MOD))%MOD",
"ans",
"(ans + cmb(a+B-1, a, MOD)*cmb(h+w, h, MOD))%MOD",
"ans + cmb(a+B-1, a, MOD)*cmb(h+w, h, MOD)",
"ans",
"cmb(a+B-1, a, MOD)*cmb(h+w, h, MOD)",
"cmb(a+B-1, a, MOD)",
"cmb",
"a+B-1",
"a+B",
"a",
"B",
"1",
"a",
"MOD",
"cmb(h+w, h, MOD)",
"cmb",
"h+w",
"h",
"w",
"h",
"MOD",
"MOD",
"print(ans)",
"print",
"ans",
"h = H - a - 1",
"H - a - 1",
"h",
"inverse = [0]*size, [0]*size, [0]*size",
"[0]*size",
"inverse",
"A, B = inpl()",
"inpl()",
"A",
"W, A, B = inpl()",
"inpl()",
"W",
"g1, g2, inverse = [0]*size, [0]*size, [0]*size",
"[0]*size",
"g1",
"g2, inverse = [0]*size, [0]*size, [0]*size",
"[0]*size",
"g2",
"ans = (ans + cmb(a+B-1, a, MOD)*cmb(h+w, h, MOD))%MOD",
"(ans + cmb(a+B-1, a, MOD)*cmb(h+w, h, MOD))%MOD",
"ans",
"size = H+ W + 1",
"H+ W + 1",
"size",
"w = W - B - 1",
"W - B - 1",
"w",
"def inpl(): return list(map(int, input().split()))",
"def inpl(): return list(map(int, input().split()))",
"inpl",
"def cmb(n, r, mod):\n if ( r<0 or r>n ):\n return 0\n \n r = min(r, n-r)\n return g1[n] * g2[r] * g2[n-r] % mod\n ",
"def cmb(n, r, mod):\n if ( r<0 or r>n ):\n return 0\n \n r = min(r, n-r)\n return g1[n] * g2[r] * g2[n-r] % mod\n ",
"cmb",
"B = inpl()",
"inpl()",
"B",
"H, W, A, B = inpl()",
"inpl()",
"H",
"ans = 0",
"0",
"ans",
"MOD = 10**9 + 7",
"10**9 + 7",
"MOD"
] | def inpl(): return list(map(int, input().split()))
H, W, A, B = inpl()
MOD = 10**9 + 7
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
size = H+ W + 1
g1, g2, inverse = [0]*size, [0]*size, [0]*size
g1[:2] = [1, 1] # 元テーブル
g2[:2] = [1, 1] #逆元テーブル
inverse[:2] = [0, 1] #逆元テーブル計算用テーブル
for i in range(2, size):
g1[i] = ( g1[i-1] * i ) % MOD
inverse[i] = (-inverse[MOD % i] * (MOD//i) ) % MOD
g2[i] = (g2[i-1] * inverse[i]) % MOD
ans = 0
for a in range(H-A):
h = H - a - 1
w = W - B - 1
ans = (ans + cmb(a+B-1, a, MOD)*cmb(h+w, h, MOD))%MOD
print(ans) |
[
7,
15,
13,
0,
13,
18,
18,
18,
13,
13,
13,
13,
15,
13,
12,
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,
0,
18,
13,
17,
17,
18,
13,
17,
17,
0,
13,
4,
18,
13,
13,
13,
0,
13,
4,
18,
13,
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,
0,
18,
13,
13,
2,
13,
2,
2,
2,
13,
13,
18,
13,
2,
13,
13,
13,
0,
18,
13,
13,
2,
2,
18,
13,
2,
13,
17,
18,
13,
13,
13,
12,
13,
0,
13,
2,
2,
2,
2,
18,
13,
2,
13,
13,
18,
13,
13,
13,
18,
13,
13,
13,
29,
13,
23,
13,
23,
13,
0,
13,
17,
28,
13,
4,
13,
2,
13,
13,
0,
13,
2,
4,
13,
13,
2,
13,
17,
4,
13,
2,
2,
13,
13,
17,
2,
2,
13,
13,
17,
0,
13,
13,
0,
13,
13,
4,
13,
13,
14,
2,
13,
17,
4,
13,
10,
12,
13,
10,
18,
13
] | [
[
206,
4
],
[
18,
17
],
[
207,
24
],
[
18,
26
],
[
18,
27
],
[
18,
28
],
[
31,
30
],
[
39,
38
],
[
17,
43
],
[
26,
44
],
[
50,
49
],
[
55,
52
],
[
49,
53
],
[
59,
56
],
[
49,
57
],
[
62,
61
],
[
49,
66
],
[
69,
68
],
[
49,
73
],
[
76,
75
],
[
17,
81
],
[
26,
82
],
[
88,
85
],
[
49,
86
],
[
75,
87
],
[
49,
91
],
[
75,
93
],
[
75,
95
],
[
30,
96
],
[
101,
98
],
[
61,
99
],
[
75,
100
],
[
30,
102
],
[
30,
106
],
[
75,
107
],
[
61,
109
],
[
30,
111
],
[
75,
112
],
[
30,
113
],
[
118,
115
],
[
68,
116
],
[
75,
117
],
[
68,
121
],
[
75,
123
],
[
98,
125
],
[
61,
126
],
[
75,
127
],
[
30,
128
],
[
133,
132
],
[
49,
138
],
[
153,
140
],
[
155,
141
],
[
68,
143
],
[
153,
144
],
[
30,
145
],
[
68,
147
],
[
155,
148
],
[
30,
149
],
[
132,
151
],
[
153,
153
],
[
155,
155
],
[
158,
157
],
[
161,
160
],
[
17,
164
],
[
27,
165
],
[
168,
167
],
[
130,
170
],
[
160,
171
],
[
28,
173
],
[
130,
176
],
[
17,
179
],
[
160,
180
],
[
26,
184
],
[
28,
185
],
[
189,
188
],
[
167,
189
],
[
192,
191
],
[
30,
192
],
[
191,
195
],
[
188,
195
],
[
157,
195
],
[
204,
201
],
[
206,
207
]
] | [
"import sys\ninput = sys.stdin.buffer.readline\nimport copy\n\ndef main():\n H,W,A,B = map(int,input().split())\n MOD = 10**9+7\n fac = [0 for _ in range(H+W+1)]\n fac[0],fac[1] = 1,1\n inv = copy.deepcopy(fac)\n invfac = copy.deepcopy(fac)\n \n for i in range(2,H+W+1):\n fac[i] = (fac[i-1]*i)%MOD\n inv[i] = MOD-(MOD//i)*inv[MOD%i]%MOD\n invfac[i] = (invfac[i-1]*inv[i])%MOD\n \n def coef(x,y):\n num = (((fac[x+y]*invfac[x])%MOD)*invfac[y]%MOD)\n return num\n\n ans = 0\n for i in range(H-A):\n able = coef(i,B-1)*coef(H-i-1,W-B-1)\n ans += able\n ans %= MOD\n \n print(ans) \n\nif __name__ == \"__main__\":\n main()",
"import sys",
"sys",
"input = sys.stdin.buffer.readline",
"input",
"sys.stdin.buffer.readline",
"sys.stdin.buffer",
"sys.stdin",
"sys",
"stdin",
"buffer",
"readline",
"import copy",
"copy",
"def main():\n H,W,A,B = map(int,input().split())\n MOD = 10**9+7\n fac = [0 for _ in range(H+W+1)]\n fac[0],fac[1] = 1,1\n inv = copy.deepcopy(fac)\n invfac = copy.deepcopy(fac)\n \n for i in range(2,H+W+1):\n fac[i] = (fac[i-1]*i)%MOD\n inv[i] = MOD-(MOD//i)*inv[MOD%i]%MOD\n invfac[i] = (invfac[i-1]*inv[i])%MOD\n \n def coef(x,y):\n num = (((fac[x+y]*invfac[x])%MOD)*invfac[y]%MOD)\n return num\n\n ans = 0\n for i in range(H-A):\n able = coef(i,B-1)*coef(H-i-1,W-B-1)\n ans += able\n ans %= 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",
"0 for _ in range(H+W+1)",
"for _ in range(H+W+1)",
"_",
"range(H+W+1)",
"range",
"H+W+1",
"H+W",
"H",
"W",
"1",
"for _ in range(H+W+1)",
"0",
"fac = [0 for _ in range(H+W+1)]",
"fac",
"[0 for _ in range(H+W+1)]",
"fac[0],fac[1] = 1,1",
"fac[0]",
"fac",
"0",
"1",
"fac[1]",
"fac",
"1",
"1",
"inv = copy.deepcopy(fac)",
"inv",
"copy.deepcopy(fac)",
"copy.deepcopy",
"copy",
"deepcopy",
"fac",
"invfac = copy.deepcopy(fac)",
"invfac",
"copy.deepcopy(fac)",
"copy.deepcopy",
"copy",
"deepcopy",
"fac",
"for i in range(2,H+W+1):\n fac[i] = (fac[i-1]*i)%MOD\n inv[i] = MOD-(MOD//i)*inv[MOD%i]%MOD\n invfac[i] = (invfac[i-1]*inv[i])%MOD\n \n ",
"i",
"range(2,H+W+1)",
"range",
"2",
"H+W+1",
"H+W",
"H",
"W",
"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[i] = MOD-(MOD//i)*inv[MOD%i]%MOD",
"inv[i]",
"inv",
"i",
"MOD-(MOD//i)*inv[MOD%i]%MOD",
"MOD",
"(MOD//i)*inv[MOD%i]%MOD",
"(MOD//i)*inv[MOD%i]",
"MOD//i",
"MOD",
"i",
"inv[MOD%i]",
"inv",
"MOD%i",
"MOD",
"i",
"MOD",
"invfac[i] = (invfac[i-1]*inv[i])%MOD",
"invfac[i]",
"invfac",
"i",
"(invfac[i-1]*inv[i])%MOD",
"invfac[i-1]*inv[i]",
"invfac[i-1]",
"invfac",
"i-1",
"i",
"1",
"inv[i]",
"inv",
"i",
"MOD",
"def coef(x,y):\n num = (((fac[x+y]*invfac[x])%MOD)*invfac[y]%MOD)\n return num\n\n ",
"coef",
"num = (((fac[x+y]*invfac[x])%MOD)*invfac[y]%MOD)",
"num",
"((fac[x+y]*invfac[x])%MOD)*invfac[y]%MOD",
"((fac[x+y]*invfac[x])%MOD)*invfac[y]",
"(fac[x+y]*invfac[x])%MOD",
"fac[x+y]*invfac[x]",
"fac[x+y]",
"fac",
"x+y",
"x",
"y",
"invfac[x]",
"invfac",
"x",
"MOD",
"invfac[y]",
"invfac",
"y",
"MOD",
"return num",
"num",
"x",
"x",
"y",
"y",
"ans = 0",
"ans",
"0",
"for i in range(H-A):\n able = coef(i,B-1)*coef(H-i-1,W-B-1)\n ans += able\n ans %= MOD\n \n ",
"i",
"range(H-A)",
"range",
"H-A",
"H",
"A",
"able = coef(i,B-1)*coef(H-i-1,W-B-1)",
"able",
"coef(i,B-1)*coef(H-i-1,W-B-1)",
"coef(i,B-1)",
"coef",
"i",
"B-1",
"B",
"1",
"coef(H-i-1,W-B-1)",
"coef",
"H-i-1",
"H-i",
"H",
"i",
"1",
"W-B-1",
"W-B",
"W",
"B",
"1",
"ans += able",
"ans",
"able",
"ans %= MOD",
"ans",
"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 fac = [0 for _ in range(H+W+1)]\n fac[0],fac[1] = 1,1\n inv = copy.deepcopy(fac)\n invfac = copy.deepcopy(fac)\n \n for i in range(2,H+W+1):\n fac[i] = (fac[i-1]*i)%MOD\n inv[i] = MOD-(MOD//i)*inv[MOD%i]%MOD\n invfac[i] = (invfac[i-1]*inv[i])%MOD\n \n def coef(x,y):\n num = (((fac[x+y]*invfac[x])%MOD)*invfac[y]%MOD)\n return num\n\n ans = 0\n for i in range(H-A):\n able = coef(i,B-1)*coef(H-i-1,W-B-1)\n ans += able\n ans %= MOD\n \n print(ans) ",
"def main():\n H,W,A,B = map(int,input().split())\n MOD = 10**9+7\n fac = [0 for _ in range(H+W+1)]\n fac[0],fac[1] = 1,1\n inv = copy.deepcopy(fac)\n invfac = copy.deepcopy(fac)\n \n for i in range(2,H+W+1):\n fac[i] = (fac[i-1]*i)%MOD\n inv[i] = MOD-(MOD//i)*inv[MOD%i]%MOD\n invfac[i] = (invfac[i-1]*inv[i])%MOD\n \n def coef(x,y):\n num = (((fac[x+y]*invfac[x])%MOD)*invfac[y]%MOD)\n return num\n\n ans = 0\n for i in range(H-A):\n able = coef(i,B-1)*coef(H-i-1,W-B-1)\n ans += able\n ans %= MOD\n \n print(ans) ",
"main",
"input = sys.stdin.buffer.readline",
"sys.stdin.buffer.readline",
"input"
] | import sys
input = sys.stdin.buffer.readline
import copy
def main():
H,W,A,B = map(int,input().split())
MOD = 10**9+7
fac = [0 for _ in range(H+W+1)]
fac[0],fac[1] = 1,1
inv = copy.deepcopy(fac)
invfac = copy.deepcopy(fac)
for i in range(2,H+W+1):
fac[i] = (fac[i-1]*i)%MOD
inv[i] = MOD-(MOD//i)*inv[MOD%i]%MOD
invfac[i] = (invfac[i-1]*inv[i])%MOD
def coef(x,y):
num = (((fac[x+y]*invfac[x])%MOD)*invfac[y]%MOD)
return num
ans = 0
for i in range(H-A):
able = coef(i,B-1)*coef(H-i-1,W-B-1)
ans += able
ans %= MOD
print(ans)
if __name__ == "__main__":
main()
|
[
7,
0,
13,
2,
2,
17,
17,
17,
0,
13,
2,
2,
17,
2,
17,
17,
17,
0,
13,
2,
39,
17,
17,
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,
2,
39,
17,
13,
39,
4,
13,
18,
13,
17,
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,
4,
13,
13,
4,
18,
4,
13,
13,
13,
13,
13,
0,
13,
2,
2,
2,
2,
18,
13,
2,
2,
13,
13,
17,
18,
13,
2,
13,
17,
13,
18,
13,
2,
13,
17,
13,
41,
28,
13,
4,
13,
13,
4,
2,
2,
2,
18,
13,
2,
2,
2,
2,
13,
13,
13,
13,
17,
18,
13,
2,
13,
17,
18,
13,
2,
2,
13,
13,
13,
13,
0,
13,
13,
41,
28,
13,
4,
13,
13,
4,
2,
2,
2,
18,
13,
2,
2,
2,
2,
13,
13,
13,
13,
17,
18,
13,
2,
13,
13,
18,
13,
2,
2,
13,
13,
17,
13,
0,
13,
13,
28,
13,
4,
13,
2,
13,
17,
17,
17,
0,
18,
13,
13,
18,
13,
2,
13,
17,
28,
13,
4,
13,
13,
0,
13,
2,
2,
18,
13,
13,
18,
13,
13,
13,
0,
13,
13,
4,
13,
13,
10,
13,
13,
10,
4,
13,
10,
4,
13,
10,
4,
13,
10,
13,
13,
10,
2,
13,
10,
2,
13,
10,
2,
13,
10,
2,
13,
10,
2,
13,
10,
4,
13,
10,
13,
13,
10,
2,
13
] | [
[
264,
2
],
[
267,
9
],
[
258,
18
],
[
268,
27
],
[
31,
30
],
[
268,
35
],
[
41,
38
],
[
259,
39
],
[
30,
40
],
[
259,
44
],
[
30,
46
],
[
30,
48
],
[
265,
49
],
[
276,
51
],
[
268,
56
],
[
259,
61
],
[
265,
64
],
[
265,
66
],
[
69,
68
],
[
268,
71
],
[
80,
75
],
[
277,
76
],
[
68,
78
],
[
277,
83
],
[
68,
84
],
[
68,
85
],
[
265,
86
],
[
270,
88
],
[
270,
97
],
[
270,
98
],
[
270,
99
],
[
261,
101
],
[
259,
107
],
[
271,
110
],
[
247,
111
],
[
277,
114
],
[
271,
116
],
[
265,
118
],
[
277,
120
],
[
247,
122
],
[
265,
124
],
[
128,
127
],
[
250,
130
],
[
259,
136
],
[
271,
141
],
[
250,
142
],
[
244,
143
],
[
127,
144
],
[
277,
147
],
[
244,
149
],
[
277,
152
],
[
271,
155
],
[
250,
156
],
[
127,
157
],
[
265,
158
],
[
273,
160
],
[
165,
164
],
[
250,
167
],
[
259,
173
],
[
247,
178
],
[
250,
179
],
[
244,
180
],
[
164,
181
],
[
277,
184
],
[
247,
186
],
[
244,
187
],
[
277,
189
],
[
250,
192
],
[
164,
193
],
[
265,
195
],
[
252,
197
],
[
201,
200
],
[
250,
204
],
[
212,
209
],
[
274,
210
],
[
200,
211
],
[
274,
213
],
[
200,
215
],
[
219,
218
],
[
250,
221
],
[
255,
223
],
[
209,
226
],
[
274,
227
],
[
218,
228
],
[
253,
230
],
[
218,
231
],
[
265,
232
],
[
240,
234
],
[
265,
235
],
[
241,
238
],
[
256,
238
],
[
262,
238
],
[
265,
240
],
[
240,
241
],
[
270,
244
],
[
270,
247
],
[
270,
250
],
[
252,
253
],
[
255,
256
],
[
258,
259
],
[
261,
262
],
[
264,
265
],
[
267,
268
],
[
270,
271
],
[
273,
274
],
[
276,
277
]
] | [
"MOD=10**9+7\nUPPERLIMIT=2*(10**5)+1\nMODMUL=[1, 1]+[0]*(UPPERLIMIT-1)\nfor i in range(2, UPPERLIMIT+1):\n MODMUL[i]=MODMUL[i-1]*i%MOD\nMODDIV=[1]*UPPERLIMIT+[pow(MODMUL[-1], MOD-2, MOD)]\nfor i in range(UPPERLIMIT, 0, -1):\n MODDIV[i-1]=MODDIV[i]*i%MOD\n\nH, W, A, B=map(int, input().split())\n\nans=(((MODMUL[H+W-2]*MODDIV[H-1])%MOD)*MODDIV[W-1])%MOD\n\nx=[MODMUL[H-A+B+i-1]*MODDIV[B-1]*MODDIV[H-A+i]%MOD for i in range(A)]\ny=[MODMUL[W+A-B-i-1]*MODDIV[W-B]*MODDIV[A-i-1]%MOD for i in range(A)]\nfor i in range(A-1, 0, -1):\n x[i]-=x[i-1]\n\nfor i in range(A):\n ans-=(x[i]*y[i]%MOD)\n ans%=MOD\n \nprint(ans)",
"MOD=10**9+7",
"MOD",
"10**9+7",
"10**9",
"10",
"9",
"7",
"UPPERLIMIT=2*(10**5)+1",
"UPPERLIMIT",
"2*(10**5)+1",
"2*(10**5)",
"2",
"10**5",
"10",
"5",
"1",
"MODMUL=[1, 1]+[0]*(UPPERLIMIT-1)",
"MODMUL",
"[1, 1]+[0]*(UPPERLIMIT-1)",
"[1, 1]",
"1",
"1",
"[0]*(UPPERLIMIT-1)",
"[0]",
"0",
"UPPERLIMIT-1",
"UPPERLIMIT",
"1",
"for i in range(2, UPPERLIMIT+1):\n MODMUL[i]=MODMUL[i-1]*i%MOD",
"i",
"range(2, UPPERLIMIT+1)",
"range",
"2",
"UPPERLIMIT+1",
"UPPERLIMIT",
"1",
"MODMUL[i]=MODMUL[i-1]*i%MOD",
"MODMUL[i]",
"MODMUL",
"i",
"MODMUL[i-1]*i%MOD",
"MODMUL[i-1]*i",
"MODMUL[i-1]",
"MODMUL",
"i-1",
"i",
"1",
"i",
"MOD",
"MODDIV=[1]*UPPERLIMIT+[pow(MODMUL[-1], MOD-2, MOD)]",
"MODDIV",
"[1]*UPPERLIMIT+[pow(MODMUL[-1], MOD-2, MOD)]",
"[1]*UPPERLIMIT",
"[1]",
"1",
"UPPERLIMIT",
"[pow(MODMUL[-1], MOD-2, MOD)]",
"pow(MODMUL[-1], MOD-2, MOD)",
"pow",
"MODMUL[-1]",
"MODMUL",
"-1",
"MOD-2",
"MOD",
"2",
"MOD",
"for i in range(UPPERLIMIT, 0, -1):\n MODDIV[i-1]=MODDIV[i]*i%MOD",
"i",
"range(UPPERLIMIT, 0, -1)",
"range",
"UPPERLIMIT",
"0",
"-1",
"MODDIV[i-1]=MODDIV[i]*i%MOD",
"MODDIV[i-1]",
"MODDIV",
"i-1",
"i",
"1",
"MODDIV[i]*i%MOD",
"MODDIV[i]*i",
"MODDIV[i]",
"MODDIV",
"i",
"i",
"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=(((MODMUL[H+W-2]*MODDIV[H-1])%MOD)*MODDIV[W-1])%MOD",
"ans",
"(((MODMUL[H+W-2]*MODDIV[H-1])%MOD)*MODDIV[W-1])%MOD",
"((MODMUL[H+W-2]*MODDIV[H-1])%MOD)*MODDIV[W-1]",
"(MODMUL[H+W-2]*MODDIV[H-1])%MOD",
"MODMUL[H+W-2]*MODDIV[H-1]",
"MODMUL[H+W-2]",
"MODMUL",
"H+W-2",
"H+W",
"H",
"W",
"2",
"MODDIV[H-1]",
"MODDIV",
"H-1",
"H",
"1",
"MOD",
"MODDIV[W-1]",
"MODDIV",
"W-1",
"W",
"1",
"MOD",
"MODMUL[H-A+B+i-1]*MODDIV[B-1]*MODDIV[H-A+i]%MOD for i in range(A)",
"for i in range(A)",
"i",
"range(A)",
"range",
"A",
"for i in range(A)",
"MODMUL[H-A+B+i-1]*MODDIV[B-1]*MODDIV[H-A+i]%MOD",
"MODMUL[H-A+B+i-1]*MODDIV[B-1]*MODDIV[H-A+i]",
"MODMUL[H-A+B+i-1]*MODDIV[B-1]",
"MODMUL[H-A+B+i-1]",
"MODMUL",
"H-A+B+i-1",
"H-A+B+i",
"H-A+B",
"H-A",
"H",
"A",
"B",
"i",
"1",
"MODDIV[B-1]",
"MODDIV",
"B-1",
"B",
"1",
"MODDIV[H-A+i]",
"MODDIV",
"H-A+i",
"H-A",
"H",
"A",
"i",
"MOD",
"x=[MODMUL[H-A+B+i-1]*MODDIV[B-1]*MODDIV[H-A+i]%MOD for i in range(A)]",
"x",
"[MODMUL[H-A+B+i-1]*MODDIV[B-1]*MODDIV[H-A+i]%MOD for i in range(A)]",
"MODMUL[W+A-B-i-1]*MODDIV[W-B]*MODDIV[A-i-1]%MOD for i in range(A)",
"for i in range(A)",
"i",
"range(A)",
"range",
"A",
"for i in range(A)",
"MODMUL[W+A-B-i-1]*MODDIV[W-B]*MODDIV[A-i-1]%MOD",
"MODMUL[W+A-B-i-1]*MODDIV[W-B]*MODDIV[A-i-1]",
"MODMUL[W+A-B-i-1]*MODDIV[W-B]",
"MODMUL[W+A-B-i-1]",
"MODMUL",
"W+A-B-i-1",
"W+A-B-i",
"W+A-B",
"W+A",
"W",
"A",
"B",
"i",
"1",
"MODDIV[W-B]",
"MODDIV",
"W-B",
"W",
"B",
"MODDIV[A-i-1]",
"MODDIV",
"A-i-1",
"A-i",
"A",
"i",
"1",
"MOD",
"y=[MODMUL[W+A-B-i-1]*MODDIV[W-B]*MODDIV[A-i-1]%MOD for i in range(A)]",
"y",
"[MODMUL[W+A-B-i-1]*MODDIV[W-B]*MODDIV[A-i-1]%MOD for i in range(A)]",
"for i in range(A-1, 0, -1):\n x[i]-=x[i-1]",
"i",
"range(A-1, 0, -1)",
"range",
"A-1",
"A",
"1",
"0",
"-1",
"x[i]-=x[i-1]",
"x[i]",
"x",
"i",
"x[i-1]",
"x",
"i-1",
"i",
"1",
"for i in range(A):\n ans-=(x[i]*y[i]%MOD)\n ans%=MOD\n ",
"i",
"range(A)",
"range",
"A",
"ans-=(x[i]*y[i]%MOD)",
"ans",
"x[i]*y[i]%MOD",
"x[i]*y[i]",
"x[i]",
"x",
"i",
"y[i]",
"y",
"i",
"MOD",
"ans%=MOD",
"ans",
"MOD",
"print(ans)",
"print",
"ans",
"ans%=MOD",
"MOD",
"ans",
"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",
"y=[MODMUL[W+A-B-i-1]*MODDIV[W-B]*MODDIV[A-i-1]%MOD for i in range(A)]",
"[MODMUL[W+A-B-i-1]*MODDIV[W-B]*MODDIV[A-i-1]%MOD for i in range(A)]",
"y",
"ans-=(x[i]*y[i]%MOD)",
"x[i]*y[i]%MOD",
"ans",
"MODMUL=[1, 1]+[0]*(UPPERLIMIT-1)",
"[1, 1]+[0]*(UPPERLIMIT-1)",
"MODMUL",
"ans=(((MODMUL[H+W-2]*MODDIV[H-1])%MOD)*MODDIV[W-1])%MOD",
"(((MODMUL[H+W-2]*MODDIV[H-1])%MOD)*MODDIV[W-1])%MOD",
"ans",
"MOD=10**9+7",
"10**9+7",
"MOD",
"UPPERLIMIT=2*(10**5)+1",
"2*(10**5)+1",
"UPPERLIMIT",
"H, W, A, B=map(int, input().split())",
"map(int, input().split())",
"H",
"x=[MODMUL[H-A+B+i-1]*MODDIV[B-1]*MODDIV[H-A+i]%MOD for i in range(A)]",
"[MODMUL[H-A+B+i-1]*MODDIV[B-1]*MODDIV[H-A+i]%MOD for i in range(A)]",
"x",
"MODDIV=[1]*UPPERLIMIT+[pow(MODMUL[-1], MOD-2, MOD)]",
"[1]*UPPERLIMIT+[pow(MODMUL[-1], MOD-2, MOD)]",
"MODDIV"
] | MOD=10**9+7
UPPERLIMIT=2*(10**5)+1
MODMUL=[1, 1]+[0]*(UPPERLIMIT-1)
for i in range(2, UPPERLIMIT+1):
MODMUL[i]=MODMUL[i-1]*i%MOD
MODDIV=[1]*UPPERLIMIT+[pow(MODMUL[-1], MOD-2, MOD)]
for i in range(UPPERLIMIT, 0, -1):
MODDIV[i-1]=MODDIV[i]*i%MOD
H, W, A, B=map(int, input().split())
ans=(((MODMUL[H+W-2]*MODDIV[H-1])%MOD)*MODDIV[W-1])%MOD
x=[MODMUL[H-A+B+i-1]*MODDIV[B-1]*MODDIV[H-A+i]%MOD for i in range(A)]
y=[MODMUL[W+A-B-i-1]*MODDIV[W-B]*MODDIV[A-i-1]%MOD for i in range(A)]
for i in range(A-1, 0, -1):
x[i]-=x[i-1]
for i in range(A):
ans-=(x[i]*y[i]%MOD)
ans%=MOD
print(ans) |
[
7,
6,
13,
12,
13,
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,
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,
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,
0,
18,
13,
13,
13,
23,
13,
23,
13,
23,
13,
12,
13,
14,
2,
2,
13,
13,
13,
29,
4,
18,
13,
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,
18,
13,
13,
13,
18,
18,
13,
13,
13,
18,
18,
13,
13,
2,
13,
13,
18,
13,
13,
23,
13,
23,
13,
23,
13,
12,
13,
0,
13,
2,
2,
17,
17,
17,
0,
13,
4,
13,
13,
4,
18,
4,
13,
13,
13,
13,
13,
0,
13,
4,
13,
0,
13,
2,
13,
13,
0,
13,
13,
0,
13,
17,
28,
13,
4,
13,
13,
13,
0,
13,
4,
18,
13,
13,
0,
13,
2,
2,
2,
13,
13,
17,
13,
0,
13,
13,
0,
13,
4,
18,
13,
13,
0,
13,
2,
2,
13,
17,
2,
2,
13,
17,
13,
0,
13,
2,
13,
17,
0,
13,
2,
2,
13,
2,
13,
13,
13,
4,
13,
13,
14,
2,
13,
17,
4,
13,
10,
12,
13,
10,
6,
13
] | [
[
8,
7
],
[
108,
12
],
[
18,
15
],
[
7,
16
],
[
23,
20
],
[
7,
21
],
[
26,
25
],
[
108,
30
],
[
36,
33
],
[
7,
34
],
[
25,
35
],
[
25,
38
],
[
7,
40
],
[
25,
42
],
[
110,
44
],
[
47,
46
],
[
108,
51
],
[
57,
54
],
[
46,
55
],
[
108,
56
],
[
7,
60
],
[
108,
61
],
[
110,
63
],
[
110,
65
],
[
68,
67
],
[
108,
71
],
[
79,
76
],
[
46,
77
],
[
67,
78
],
[
46,
82
],
[
67,
84
],
[
67,
87
],
[
110,
89
],
[
94,
91
],
[
106,
92
],
[
7,
93
],
[
7,
94
],
[
99,
96
],
[
106,
97
],
[
46,
98
],
[
46,
99
],
[
104,
101
],
[
106,
102
],
[
110,
103
],
[
110,
104
],
[
106,
106
],
[
108,
108
],
[
110,
110
],
[
173,
116
],
[
175,
117
],
[
175,
118
],
[
171,
122
],
[
173,
124
],
[
173,
126
],
[
175,
127
],
[
175,
130
],
[
175,
136
],
[
175,
142
],
[
173,
145
],
[
171,
152
],
[
173,
154
],
[
171,
157
],
[
175,
159
],
[
171,
162
],
[
173,
165
],
[
175,
166
],
[
171,
168
],
[
171,
171
],
[
173,
173
],
[
175,
175
],
[
180,
179
],
[
187,
186
],
[
187,
195
],
[
187,
196
],
[
187,
197
],
[
200,
199
],
[
204,
203
],
[
186,
205
],
[
195,
206
],
[
209,
208
],
[
179,
209
],
[
212,
211
],
[
215,
214
],
[
197,
217
],
[
195,
218
],
[
221,
220
],
[
199,
223
],
[
112,
224
],
[
227,
226
],
[
186,
230
],
[
196,
231
],
[
214,
233
],
[
236,
235
],
[
214,
236
],
[
239,
238
],
[
199,
241
],
[
112,
242
],
[
245,
244
],
[
196,
247
],
[
195,
251
],
[
214,
253
],
[
256,
255
],
[
196,
257
],
[
261,
260
],
[
211,
263
],
[
260,
263
],
[
220,
265
],
[
238,
266
],
[
179,
267
],
[
260,
270
],
[
211,
270
],
[
279,
276
]
] | [
"class Calc:\n def __init__(self, max_value, mod):\n \"\"\"combination(max_value, all)\"\"\"\n fact = [-1] * (max_value + 1)\n fact[0] = 1\n fact[1] = 1\n for x in range(2, max_value + 1):\n fact[x] = x * fact[x - 1] % mod\n\n invs = [1] * (max_value + 1)\n invs[max_value] = pow(fact[max_value], mod - 2, mod)\n for x in range(max_value - 1, 0, -1):\n invs[x] = invs[x + 1] * (x + 1) % mod\n\n self.fact = fact\n self.invs = invs\n self.mod = mod\n\n def combination(self, n, r):\n if n - r < r:\n return self.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 self.fact[n] * self.invs[r] * self.invs[n - r] % self.mod\n\n\ndef main():\n MOD = 10 ** 9 + 7\n H, W, A, B = map(int, input().split())\n\n calc = Calc(max_value=H + W, mod=MOD)\n\n ans = 0\n for x in range(B, W):\n v = calc.combination(n=(H - A - 1) + x, r=x)\n u = calc.combination(n=(A - 1) + (W - 1 - x), r=A - 1)\n # (H-1)-(H-A)+(W-1)-x\n ans = (ans + v * u) % MOD\n print(ans)\n\n\nif __name__ == '__main__':\n main()\n\n# import sys\n#\n# sys.setrecursionlimit(10 ** 7)\n#\n# input = sys.stdin.readline\n# rstrip()\n# int(input())\n# map(int, input().split())",
"class Calc:\n def __init__(self, max_value, mod):\n \"\"\"combination(max_value, all)\"\"\"\n fact = [-1] * (max_value + 1)\n fact[0] = 1\n fact[1] = 1\n for x in range(2, max_value + 1):\n fact[x] = x * fact[x - 1] % mod\n\n invs = [1] * (max_value + 1)\n invs[max_value] = pow(fact[max_value], mod - 2, mod)\n for x in range(max_value - 1, 0, -1):\n invs[x] = invs[x + 1] * (x + 1) % mod\n\n self.fact = fact\n self.invs = invs\n self.mod = mod\n\n def combination(self, n, r):\n if n - r < r:\n return self.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 self.fact[n] * self.invs[r] * self.invs[n - r] % self.mod",
"Calc",
"def __init__(self, max_value, mod):\n \"\"\"combination(max_value, all)\"\"\"\n fact = [-1] * (max_value + 1)\n fact[0] = 1\n fact[1] = 1\n for x in range(2, max_value + 1):\n fact[x] = x * fact[x - 1] % mod\n\n invs = [1] * (max_value + 1)\n invs[max_value] = pow(fact[max_value], mod - 2, mod)\n for x in range(max_value - 1, 0, -1):\n invs[x] = invs[x + 1] * (x + 1) % mod\n\n self.fact = fact\n self.invs = invs\n self.mod = mod\n\n ",
"__init__",
"\"\"\"combination(max_value, all)\"\"\"",
"fact = [-1] * (max_value + 1)",
"fact",
"[-1] * (max_value + 1)",
"[-1]",
"-1",
"max_value + 1",
"max_value",
"1",
"fact[0] = 1",
"fact[0]",
"fact",
"0",
"1",
"fact[1] = 1",
"fact[1]",
"fact",
"1",
"1",
"for x in range(2, max_value + 1):\n fact[x] = x * fact[x - 1] % mod\n\n ",
"x",
"range(2, max_value + 1)",
"range",
"2",
"max_value + 1",
"max_value",
"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] * (max_value + 1)",
"invs",
"[1] * (max_value + 1)",
"[1]",
"1",
"max_value + 1",
"max_value",
"1",
"invs[max_value] = pow(fact[max_value], mod - 2, mod)",
"invs[max_value]",
"invs",
"max_value",
"pow(fact[max_value], mod - 2, mod)",
"pow",
"fact[max_value]",
"fact",
"max_value",
"mod - 2",
"mod",
"2",
"mod",
"for x in range(max_value - 1, 0, -1):\n invs[x] = invs[x + 1] * (x + 1) % mod\n\n ",
"x",
"range(max_value - 1, 0, -1)",
"range",
"max_value - 1",
"max_value",
"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",
"self.fact = fact",
"self.fact",
"self",
"fact",
"fact",
"self.invs = invs",
"self.invs",
"self",
"invs",
"invs",
"self.mod = mod",
"self.mod",
"self",
"mod",
"mod",
"self",
"self",
"max_value",
"max_value",
"mod",
"mod",
"def combination(self, n, r):\n if n - r < r:\n return self.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 self.fact[n] * self.invs[r] * self.invs[n - r] % self.mod",
"combination",
"if n - r < r:\n return self.combination(n, n - r)\n ",
"n - r < r",
"n - r",
"n",
"r",
"r",
"return self.combination(n, n - r)",
"self.combination(n, n - r)",
"self.combination",
"self",
"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 self.fact[n] * self.invs[r] * self.invs[n - r] % self.mod",
"self.fact[n] * self.invs[r] * self.invs[n - r] % self.mod",
"self.fact[n] * self.invs[r] * self.invs[n - r]",
"self.fact[n] * self.invs[r]",
"self.fact[n]",
"self.fact",
"self",
"fact",
"n",
"self.invs[r]",
"self.invs",
"self",
"invs",
"r",
"self.invs[n - r]",
"self.invs",
"self",
"invs",
"n - r",
"n",
"r",
"self.mod",
"self",
"mod",
"self",
"self",
"n",
"n",
"r",
"r",
"def main():\n MOD = 10 ** 9 + 7\n H, W, A, B = map(int, input().split())\n\n calc = Calc(max_value=H + W, mod=MOD)\n\n ans = 0\n for x in range(B, W):\n v = calc.combination(n=(H - A - 1) + x, r=x)\n u = calc.combination(n=(A - 1) + (W - 1 - x), r=A - 1)\n # (H-1)-(H-A)+(W-1)-x\n ans = (ans + v * u) % MOD\n print(ans)",
"main",
"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",
"calc = Calc(max_value=H + W, mod=MOD)",
"calc",
"Calc(max_value=H + W, mod=MOD)",
"Calc",
"max_value=H + W",
"max_value",
"H + W",
"H",
"W",
"mod=MOD",
"mod",
"MOD",
"ans = 0",
"ans",
"0",
"for x in range(B, W):\n v = calc.combination(n=(H - A - 1) + x, r=x)\n u = calc.combination(n=(A - 1) + (W - 1 - x), r=A - 1)\n # (H-1)-(H-A)+(W-1)-x\n ans = (ans + v * u) % MOD\n ",
"x",
"range(B, W)",
"range",
"B",
"W",
"v = calc.combination(n=(H - A - 1) + x, r=x)",
"v",
"calc.combination(n=(H - A - 1) + x, r=x)",
"calc.combination",
"calc",
"combination",
"n=(H - A - 1) + x",
"n",
"(H - A - 1) + x",
"H - A - 1",
"H - A",
"H",
"A",
"1",
"x",
"r=x",
"r",
"x",
"u = calc.combination(n=(A - 1) + (W - 1 - x), r=A - 1)",
"u",
"calc.combination(n=(A - 1) + (W - 1 - x), r=A - 1)",
"calc.combination",
"calc",
"combination",
"n=(A - 1) + (W - 1 - x)",
"n",
"(A - 1) + (W - 1 - x)",
"A - 1",
"A",
"1",
"W - 1 - x",
"W - 1",
"W",
"1",
"x",
"r=A - 1",
"r",
"A - 1",
"A",
"1",
"ans = (ans + v * u) % MOD",
"ans",
"(ans + v * u) % MOD",
"ans + v * u",
"ans",
"v * u",
"v",
"u",
"MOD",
"print(ans)",
"print",
"ans",
"if __name__ == '__main__':\n main()\n\n# import sys\n#\n# sys.setrecursionlimit(10 ** 7)\n#\n# input = sys.stdin.readline\n# rstrip()\n# int(input())\n# map(int, input().split())",
"__name__ == '__main__'",
"__name__",
"'__main__'",
"main()",
"main",
"def main():\n MOD = 10 ** 9 + 7\n H, W, A, B = map(int, input().split())\n\n calc = Calc(max_value=H + W, mod=MOD)\n\n ans = 0\n for x in range(B, W):\n v = calc.combination(n=(H - A - 1) + x, r=x)\n u = calc.combination(n=(A - 1) + (W - 1 - x), r=A - 1)\n # (H-1)-(H-A)+(W-1)-x\n ans = (ans + v * u) % MOD\n print(ans)",
"def main():\n MOD = 10 ** 9 + 7\n H, W, A, B = map(int, input().split())\n\n calc = Calc(max_value=H + W, mod=MOD)\n\n ans = 0\n for x in range(B, W):\n v = calc.combination(n=(H - A - 1) + x, r=x)\n u = calc.combination(n=(A - 1) + (W - 1 - x), r=A - 1)\n # (H-1)-(H-A)+(W-1)-x\n ans = (ans + v * u) % MOD\n print(ans)",
"main",
"class Calc:\n def __init__(self, max_value, mod):\n \"\"\"combination(max_value, all)\"\"\"\n fact = [-1] * (max_value + 1)\n fact[0] = 1\n fact[1] = 1\n for x in range(2, max_value + 1):\n fact[x] = x * fact[x - 1] % mod\n\n invs = [1] * (max_value + 1)\n invs[max_value] = pow(fact[max_value], mod - 2, mod)\n for x in range(max_value - 1, 0, -1):\n invs[x] = invs[x + 1] * (x + 1) % mod\n\n self.fact = fact\n self.invs = invs\n self.mod = mod\n\n def combination(self, n, r):\n if n - r < r:\n return self.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 self.fact[n] * self.invs[r] * self.invs[n - r] % self.mod",
"class Calc:\n def __init__(self, max_value, mod):\n \"\"\"combination(max_value, all)\"\"\"\n fact = [-1] * (max_value + 1)\n fact[0] = 1\n fact[1] = 1\n for x in range(2, max_value + 1):\n fact[x] = x * fact[x - 1] % mod\n\n invs = [1] * (max_value + 1)\n invs[max_value] = pow(fact[max_value], mod - 2, mod)\n for x in range(max_value - 1, 0, -1):\n invs[x] = invs[x + 1] * (x + 1) % mod\n\n self.fact = fact\n self.invs = invs\n self.mod = mod\n\n def combination(self, n, r):\n if n - r < r:\n return self.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 self.fact[n] * self.invs[r] * self.invs[n - r] % self.mod",
"Calc"
] | class Calc:
def __init__(self, max_value, mod):
"""combination(max_value, all)"""
fact = [-1] * (max_value + 1)
fact[0] = 1
fact[1] = 1
for x in range(2, max_value + 1):
fact[x] = x * fact[x - 1] % mod
invs = [1] * (max_value + 1)
invs[max_value] = pow(fact[max_value], mod - 2, mod)
for x in range(max_value - 1, 0, -1):
invs[x] = invs[x + 1] * (x + 1) % mod
self.fact = fact
self.invs = invs
self.mod = mod
def combination(self, n, r):
if n - r < r:
return self.combination(n, n - r)
if r < 0:
return 0
if r == 0:
return 1
if r == 1:
return n
return self.fact[n] * self.invs[r] * self.invs[n - r] % self.mod
def main():
MOD = 10 ** 9 + 7
H, W, A, B = map(int, input().split())
calc = Calc(max_value=H + W, mod=MOD)
ans = 0
for x in range(B, W):
v = calc.combination(n=(H - A - 1) + x, r=x)
u = calc.combination(n=(A - 1) + (W - 1 - x), r=A - 1)
# (H-1)-(H-A)+(W-1)-x
ans = (ans + v * u) % MOD
print(ans)
if __name__ == '__main__':
main()
# import sys
#
# sys.setrecursionlimit(10 ** 7)
#
# input = sys.stdin.readline
# rstrip()
# int(input())
# map(int, input().split())
|
[
7,
6,
13,
12,
13,
0,
13,
39,
17,
17,
0,
13,
39,
17,
17,
0,
13,
39,
17,
17,
28,
13,
4,
13,
17,
13,
4,
18,
13,
13,
2,
2,
18,
13,
2,
13,
17,
13,
13,
4,
18,
13,
13,
2,
13,
2,
2,
18,
13,
2,
13,
13,
2,
13,
13,
13,
4,
18,
13,
13,
2,
2,
18,
13,
2,
13,
17,
18,
13,
13,
13,
0,
18,
13,
13,
13,
18,
13,
13,
13,
18,
13,
13,
13,
23,
13,
23,
13,
23,
13,
2,
2,
17,
17,
17,
12,
13,
14,
2,
2,
2,
13,
13,
2,
13,
17,
2,
13,
17,
29,
17,
0,
13,
18,
13,
13,
13,
18,
13,
13,
13,
18,
13,
13,
29,
2,
2,
18,
13,
13,
2,
2,
18,
13,
13,
18,
13,
2,
13,
13,
13,
13,
23,
13,
23,
13,
23,
13,
0,
13,
2,
2,
17,
17,
17,
0,
13,
4,
13,
17,
0,
13,
13,
0,
13,
4,
13,
13,
4,
18,
4,
13,
13,
13,
13,
13,
0,
13,
2,
2,
13,
13,
17,
13,
2,
2,
13,
13,
17,
13,
2,
13,
17,
4,
13,
2,
4,
13,
2,
4,
18,
13,
13,
2,
13,
13,
13,
4,
18,
13,
13,
2,
13,
13,
13,
13,
10,
4,
13,
10,
2,
13,
10,
4,
13,
10,
2,
13,
10,
4,
13,
10,
2,
13,
10,
4,
13,
10,
4,
13,
10,
2,
13,
10,
6,
13
] | [
[
7,
6
],
[
12,
11
],
[
17,
16
],
[
22,
21
],
[
87,
25
],
[
6,
28
],
[
6,
33
],
[
21,
35
],
[
21,
37
],
[
89,
38
],
[
16,
41
],
[
89,
44
],
[
16,
48
],
[
89,
50
],
[
21,
51
],
[
89,
53
],
[
21,
54
],
[
89,
55
],
[
11,
58
],
[
11,
63
],
[
21,
65
],
[
16,
68
],
[
21,
69
],
[
89,
70
],
[
75,
72
],
[
85,
73
],
[
6,
74
],
[
6,
75
],
[
79,
76
],
[
85,
77
],
[
11,
78
],
[
11,
79
],
[
83,
80
],
[
85,
81
],
[
89,
82
],
[
89,
83
],
[
85,
85
],
[
87,
87
],
[
90,
89
],
[
145,
101
],
[
147,
102
],
[
145,
104
],
[
147,
107
],
[
113,
112
],
[
143,
114
],
[
117,
116
],
[
143,
118
],
[
121,
120
],
[
143,
122
],
[
112,
128
],
[
145,
129
],
[
116,
133
],
[
147,
134
],
[
116,
136
],
[
145,
138
],
[
147,
139
],
[
120,
140
],
[
120,
141
],
[
143,
143
],
[
145,
145
],
[
147,
147
],
[
232,
149
],
[
229,
156
],
[
162,
161
],
[
161,
162
],
[
233,
162
],
[
238,
164
],
[
238,
173
],
[
238,
174
],
[
238,
175
],
[
241,
177
],
[
236,
180
],
[
224,
181
],
[
226,
183
],
[
239,
186
],
[
224,
187
],
[
220,
189
],
[
224,
191
],
[
230,
201
],
[
96,
202
],
[
242,
204
],
[
230,
209
],
[
96,
210
],
[
227,
212
],
[
221,
214
],
[
161,
215
],
[
233,
215
],
[
238,
218
],
[
220,
221
],
[
238,
224
],
[
226,
227
],
[
229,
230
],
[
232,
233
],
[
238,
236
],
[
238,
239
],
[
241,
242
]
] | [
"class ModComb:\n def __init__(self, MAX, mod=10 ** 9 + 7):\n fac = [1, 1]\n finv = [1, 1]\n inv = [0, 1]\n for i in range(2, MAX):\n fac.append(fac[i - 1] * i % mod)\n inv.append(mod - inv[mod % i] * (mod // i) % mod)\n finv.append(finv[i - 1] * inv[i] % mod)\n self.fac, self.finv, self.mod = fac, finv, mod\n\n def nCk(self, n, k):\n if n < k or n < 0 or k < 0:\n return 0\n fac, finv, mod = self.fac, self.finv, self.mod\n return fac[n] * (finv[k] * finv[n - k] % mod) % mod\n\nmod = 10 ** 9 + 7\nmc = ModComb(200010, mod=mod)\n\nH, W, A, B = map(int, input().split())\n\nx, y, a = H - A - 1, W + A - 2, A - 1\nprint(sum(mc.nCk(x + i, i) * mc.nCk(y - i, a) for i in range(B, W)) % mod)",
"class ModComb:\n def __init__(self, MAX, mod=10 ** 9 + 7):\n fac = [1, 1]\n finv = [1, 1]\n inv = [0, 1]\n for i in range(2, MAX):\n fac.append(fac[i - 1] * i % mod)\n inv.append(mod - inv[mod % i] * (mod // i) % mod)\n finv.append(finv[i - 1] * inv[i] % mod)\n self.fac, self.finv, self.mod = fac, finv, mod\n\n def nCk(self, n, k):\n if n < k or n < 0 or k < 0:\n return 0\n fac, finv, mod = self.fac, self.finv, self.mod\n return fac[n] * (finv[k] * finv[n - k] % mod) % mod",
"ModComb",
"def __init__(self, MAX, mod=10 ** 9 + 7):\n fac = [1, 1]\n finv = [1, 1]\n inv = [0, 1]\n for i in range(2, MAX):\n fac.append(fac[i - 1] * i % mod)\n inv.append(mod - inv[mod % i] * (mod // i) % mod)\n finv.append(finv[i - 1] * inv[i] % mod)\n self.fac, self.finv, self.mod = fac, finv, mod\n\n ",
"__init__",
"fac = [1, 1]",
"fac",
"[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, MAX):\n fac.append(fac[i - 1] * i % mod)\n inv.append(mod - inv[mod % i] * (mod // i) % mod)\n finv.append(finv[i - 1] * inv[i] % mod)\n ",
"i",
"range(2, MAX)",
"range",
"2",
"MAX",
"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(mod - inv[mod % i] * (mod // i) % mod)",
"inv.append",
"inv",
"append",
"mod - inv[mod % i] * (mod // i) % mod",
"mod",
"inv[mod % i] * (mod // i) % mod",
"inv[mod % i] * (mod // i)",
"inv[mod % i]",
"inv",
"mod % i",
"mod",
"i",
"mod // i",
"mod",
"i",
"mod",
"finv.append(finv[i - 1] * inv[i] % mod)",
"finv.append",
"finv",
"append",
"finv[i - 1] * inv[i] % mod",
"finv[i - 1] * inv[i]",
"finv[i - 1]",
"finv",
"i - 1",
"i",
"1",
"inv[i]",
"inv",
"i",
"mod",
"self.fac, self.finv, self.mod = fac, finv, mod",
"self.fac",
"self",
"fac",
"fac",
"self.finv",
"self",
"finv",
"finv",
"self.mod",
"self",
"mod",
"mod",
"self",
"self",
"MAX",
"MAX",
"mod=10 ** 9 + 7",
"mod",
"10 ** 9 + 7",
"10 ** 9",
"10",
"9",
"7",
"def nCk(self, n, k):\n if n < k or n < 0 or k < 0:\n return 0\n fac, finv, mod = self.fac, self.finv, self.mod\n return fac[n] * (finv[k] * finv[n - k] % mod) % mod",
"nCk",
"if n < k or n < 0 or k < 0:\n return 0\n ",
"n < k or n < 0 or k < 0",
"n < k or n < 0",
"n < k",
"n",
"k",
"n < 0",
"n",
"0",
"k < 0",
"k",
"0",
"return 0",
"0",
"fac, finv, mod = self.fac, self.finv, self.mod",
"fac",
"self.fac",
"self",
"fac",
"finv",
"self.finv",
"self",
"finv",
"mod",
"self.mod",
"self",
"mod",
"return fac[n] * (finv[k] * finv[n - k] % mod) % mod",
"fac[n] * (finv[k] * finv[n - k] % mod) % mod",
"fac[n] * (finv[k] * finv[n - k] % mod)",
"fac[n]",
"fac",
"n",
"finv[k] * finv[n - k] % mod",
"finv[k] * finv[n - k]",
"finv[k]",
"finv",
"k",
"finv[n - k]",
"finv",
"n - k",
"n",
"k",
"mod",
"mod",
"self",
"self",
"n",
"n",
"k",
"k",
"mod = 10 ** 9 + 7",
"mod",
"10 ** 9 + 7",
"10 ** 9",
"10",
"9",
"7",
"mc = ModComb(200010, mod=mod)",
"mc",
"ModComb(200010, mod=mod)",
"ModComb",
"200010",
"mod=mod",
"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",
"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",
"print(sum(mc.nCk(x + i, i) * mc.nCk(y - i, a) for i in range(B, W)) % mod)",
"print",
"sum(mc.nCk(x + i, i) * mc.nCk(y - i, a) for i in range(B, W)) % mod",
"sum(mc.nCk(x + i, i) * mc.nCk(y - i, a) for i in range(B, W))",
"sum",
"mc.nCk(x + i, i) * mc.nCk(y - i, a)",
"mc.nCk(x + i, i)",
"mc.nCk",
"mc",
"nCk",
"x + i",
"x",
"i",
"i",
"mc.nCk(y - i, a)",
"mc.nCk",
"mc",
"nCk",
"y - i",
"y",
"i",
"a",
"mod",
"B = map(int, input().split())",
"map(int, input().split())",
"B",
"a = H - A - 1, W + A - 2, A - 1",
"A - 1",
"a",
"A, B = map(int, input().split())",
"map(int, input().split())",
"A",
"y, a = H - A - 1, W + A - 2, A - 1",
"W + A - 2",
"y",
"mc = ModComb(200010, mod=mod)",
"ModComb(200010, mod=mod)",
"mc",
"mod = 10 ** 9 + 7",
"10 ** 9 + 7",
"mod",
"H, W, A, B = map(int, input().split())",
"map(int, input().split())",
"H",
"W, A, B = map(int, input().split())",
"map(int, input().split())",
"W",
"x, y, a = H - A - 1, W + A - 2, A - 1",
"H - A - 1",
"x",
"class ModComb:\n def __init__(self, MAX, mod=10 ** 9 + 7):\n fac = [1, 1]\n finv = [1, 1]\n inv = [0, 1]\n for i in range(2, MAX):\n fac.append(fac[i - 1] * i % mod)\n inv.append(mod - inv[mod % i] * (mod // i) % mod)\n finv.append(finv[i - 1] * inv[i] % mod)\n self.fac, self.finv, self.mod = fac, finv, mod\n\n def nCk(self, n, k):\n if n < k or n < 0 or k < 0:\n return 0\n fac, finv, mod = self.fac, self.finv, self.mod\n return fac[n] * (finv[k] * finv[n - k] % mod) % mod",
"class ModComb:\n def __init__(self, MAX, mod=10 ** 9 + 7):\n fac = [1, 1]\n finv = [1, 1]\n inv = [0, 1]\n for i in range(2, MAX):\n fac.append(fac[i - 1] * i % mod)\n inv.append(mod - inv[mod % i] * (mod // i) % mod)\n finv.append(finv[i - 1] * inv[i] % mod)\n self.fac, self.finv, self.mod = fac, finv, mod\n\n def nCk(self, n, k):\n if n < k or n < 0 or k < 0:\n return 0\n fac, finv, mod = self.fac, self.finv, self.mod\n return fac[n] * (finv[k] * finv[n - k] % mod) % mod",
"ModComb"
] | class ModComb:
def __init__(self, MAX, mod=10 ** 9 + 7):
fac = [1, 1]
finv = [1, 1]
inv = [0, 1]
for i in range(2, MAX):
fac.append(fac[i - 1] * i % mod)
inv.append(mod - inv[mod % i] * (mod // i) % mod)
finv.append(finv[i - 1] * inv[i] % mod)
self.fac, self.finv, self.mod = fac, finv, mod
def nCk(self, n, k):
if n < k or n < 0 or k < 0:
return 0
fac, finv, mod = self.fac, self.finv, self.mod
return fac[n] * (finv[k] * finv[n - k] % mod) % mod
mod = 10 ** 9 + 7
mc = ModComb(200010, mod=mod)
H, W, A, B = map(int, input().split())
x, y, a = H - A - 1, W + A - 2, A - 1
print(sum(mc.nCk(x + i, i) * mc.nCk(y - i, a) for i in range(B, W)) % mod)
|
[
7,
15,
15,
15,
13,
15,
13,
15,
13,
15,
13,
12,
13,
12,
13,
12,
13,
12,
13,
41,
28,
13,
4,
13,
13,
4,
4,
13,
12,
13,
23,
13,
41,
28,
13,
4,
13,
13,
4,
4,
13,
12,
13,
23,
13,
41,
28,
13,
4,
13,
13,
4,
4,
13,
12,
13,
23,
13,
41,
28,
13,
4,
13,
13,
4,
4,
13,
12,
13,
23,
13,
0,
13,
17,
17,
12,
13,
29,
2,
2,
2,
2,
2,
2,
18,
13,
2,
2,
2,
13,
17,
13,
13,
18,
13,
2,
2,
2,
13,
17,
13,
13,
18,
13,
2,
13,
17,
18,
13,
2,
13,
17,
18,
13,
2,
13,
13,
18,
13,
2,
13,
13,
13,
23,
13,
23,
13,
0,
13,
4,
13,
13,
13,
13,
0,
13,
2,
39,
17,
2,
2,
13,
13,
17,
28,
13,
4,
13,
2,
13,
13,
0,
18,
13,
2,
13,
17,
2,
2,
18,
13,
13,
2,
13,
17,
13,
0,
13,
2,
39,
17,
2,
2,
13,
13,
17,
0,
18,
13,
2,
13,
13,
4,
13,
18,
13,
17,
2,
13,
17,
13,
28,
13,
18,
4,
13,
2,
13,
13,
39,
17,
0,
18,
13,
13,
2,
2,
18,
13,
2,
13,
17,
2,
13,
17,
13,
0,
13,
17,
28,
13,
4,
13,
17,
2,
4,
13,
2,
13,
13,
2,
13,
13,
17,
0,
13,
4,
13,
2,
13,
13,
2,
13,
13,
0,
13,
13,
4,
13,
13,
10,
2,
13,
10,
17,
13,
10,
12,
13,
10,
12,
13,
10,
12,
13,
10,
4,
13,
10,
12,
13,
10,
4,
13,
10,
4,
13,
10,
13,
13,
10,
4,
13,
10,
17,
13,
10,
12,
13,
10,
12,
13,
10,
12,
13,
10,
2,
13,
10,
12,
13,
10,
4,
13,
10,
12,
13
] | [
[
22,
21
],
[
264,
27
],
[
31,
31
],
[
35,
34
],
[
258,
40
],
[
44,
44
],
[
48,
47
],
[
261,
53
],
[
57,
57
],
[
61,
60
],
[
270,
66
],
[
70,
70
],
[
254,
72
],
[
124,
89
],
[
126,
92
],
[
126,
98
],
[
124,
101
],
[
124,
105
],
[
126,
110
],
[
124,
116
],
[
126,
121
],
[
255,
122
],
[
124,
124
],
[
126,
126
],
[
302,
128
],
[
258,
130
],
[
302,
131
],
[
302,
132
],
[
302,
133
],
[
296,
135
],
[
267,
141
],
[
276,
142
],
[
146,
145
],
[
267,
149
],
[
276,
150
],
[
157,
152
],
[
297,
153
],
[
145,
155
],
[
297,
160
],
[
145,
161
],
[
145,
163
],
[
255,
165
],
[
251,
167
],
[
267,
173
],
[
276,
174
],
[
182,
177
],
[
252,
178
],
[
267,
180
],
[
276,
181
],
[
297,
185
],
[
255,
188
],
[
255,
190
],
[
193,
192
],
[
267,
197
],
[
276,
198
],
[
205,
202
],
[
252,
203
],
[
192,
204
],
[
252,
208
],
[
192,
210
],
[
192,
213
],
[
255,
215
],
[
284,
217
],
[
221,
220
],
[
276,
228
],
[
282,
229
],
[
267,
231
],
[
303,
232
],
[
272,
235
],
[
294,
237
],
[
282,
239
],
[
220,
240
],
[
303,
242
],
[
220,
243
],
[
278,
245
],
[
255,
246
],
[
279,
249
],
[
273,
249
],
[
285,
249
],
[
251,
252
],
[
254,
255
],
[
302,
267
],
[
272,
273
],
[
302,
276
],
[
255,
278
],
[
278,
279
],
[
302,
282
],
[
284,
285
],
[
296,
297
],
[
302,
303
]
] | [
"#!usr/bin/env python3\nfrom collections import defaultdict\nfrom heapq import heappush, heappop\nimport sys\nimport math\nimport bisect\nimport random\ndef LI(): return list(map(int, sys.stdin.readline().split()))\ndef I(): return int(sys.stdin.readline())\ndef LS(): return list(map(list, sys.stdin.readline().split()))\ndef S(): return list(sys.stdin.readline())[:-1]\ndef IR(n): return [I() for i in range(n)]\ndef LIR(n): return [LI() for i in range(n)]\ndef SR(n): return [S() for i in range(n)]\ndef LSR(n): return [LS() for i in range(n)]\nmod = 1000000007\n\n\n#A\n\"\"\"\ndef check(n):\n n = list(map(int,list(str(n))))\n s = 0\n for i in n:\n s += f[i]\n return s == 0\nn,k = LI()\nd = LI()\nf = [0 for i in range(10)]\nfor i in d:\n f[i] = 1\nwhile 1:\n if check(n):\n print(n)\n quit()\n n += 1\n\"\"\"\n#B\ndef f(x,y):\n return fact[x-1+h-y]*fact[y-1+w-x]*inv_fact[x-1]*inv_fact[y-1]*inv_fact[w-x]*inv_fact[h-y]%mod\nh,w,a,b = LI()\nfact = [1]*(h+w+1)\nfor i in range(h+w):\n fact[i+1] = fact[i]*(i+1)%mod\ninv_fact = [0]*(h+w+1)\ninv_fact[h+w] = pow(fact[-1],mod-2,mod)\nfor i in range(h+w)[::-1]:\n inv_fact[i] = inv_fact[i+1]*(i+1)%mod\nans = 0\nfor i in range(1,min(w-b,h-a)+1):\n ans += f(b+i,a+i)\n ans %= mod\nprint(ans)\n\n#C\n\n#D\n\n#E\n\n#F\n\n#G\n\n#H\n\n#I\n\n#J\n\n#K\n\n#L\n\n#M\n\n#N\n\n#O\n\n#P\n\n#Q\n\n#R\n\n#S\n\n#T",
"from collections import defaultdict",
"from heapq import heappush, heappop",
"import sys",
"sys",
"import math",
"math",
"import bisect",
"bisect",
"import random",
"random",
"def LI(): return list(map(int, sys.stdin.readline().split()))",
"LI",
"def I(): return int(sys.stdin.readline())",
"I",
"def LS(): return list(map(list, sys.stdin.readline().split()))",
"LS",
"def S(): return list(sys.stdin.readline())[:-1]",
"S",
"I() for i in range(n)",
"for i in range(n)",
"i",
"range(n)",
"range",
"n",
"for i in range(n)",
"I()",
"I",
"def IR(n): return [I() for i in range(n)]",
"IR",
"n",
"n",
"LI() for i in range(n)",
"for i in range(n)",
"i",
"range(n)",
"range",
"n",
"for i in range(n)",
"LI()",
"LI",
"def LIR(n): return [LI() for i in range(n)]",
"LIR",
"n",
"n",
"S() for i in range(n)",
"for i in range(n)",
"i",
"range(n)",
"range",
"n",
"for i in range(n)",
"S()",
"S",
"def SR(n): return [S() for i in range(n)]",
"SR",
"n",
"n",
"LS() for i in range(n)",
"for i in range(n)",
"i",
"range(n)",
"range",
"n",
"for i in range(n)",
"LS()",
"LS",
"def LSR(n): return [LS() for i in range(n)]",
"LSR",
"n",
"n",
"mod = 1000000007",
"mod",
"1000000007",
"\"\"\"\ndef check(n):\n n = list(map(int,list(str(n))))\n s = 0\n for i in n:\n s += f[i]\n return s == 0\nn,k = LI()\nd = LI()\nf = [0 for i in range(10)]\nfor i in d:\n f[i] = 1\nwhile 1:\n if check(n):\n print(n)\n quit()\n n += 1\n\"\"\"",
"def f(x,y):\n return fact[x-1+h-y]*fact[y-1+w-x]*inv_fact[x-1]*inv_fact[y-1]*inv_fact[w-x]*inv_fact[h-y]%mod",
"f",
"return fact[x-1+h-y]*fact[y-1+w-x]*inv_fact[x-1]*inv_fact[y-1]*inv_fact[w-x]*inv_fact[h-y]%mod",
"fact[x-1+h-y]*fact[y-1+w-x]*inv_fact[x-1]*inv_fact[y-1]*inv_fact[w-x]*inv_fact[h-y]%mod",
"fact[x-1+h-y]*fact[y-1+w-x]*inv_fact[x-1]*inv_fact[y-1]*inv_fact[w-x]*inv_fact[h-y]",
"fact[x-1+h-y]*fact[y-1+w-x]*inv_fact[x-1]*inv_fact[y-1]*inv_fact[w-x]",
"fact[x-1+h-y]*fact[y-1+w-x]*inv_fact[x-1]*inv_fact[y-1]",
"fact[x-1+h-y]*fact[y-1+w-x]*inv_fact[x-1]",
"fact[x-1+h-y]*fact[y-1+w-x]",
"fact[x-1+h-y]",
"fact",
"x-1+h-y",
"x-1+h",
"x-1",
"x",
"1",
"h",
"y",
"fact[y-1+w-x]",
"fact",
"y-1+w-x",
"y-1+w",
"y-1",
"y",
"1",
"w",
"x",
"inv_fact[x-1]",
"inv_fact",
"x-1",
"x",
"1",
"inv_fact[y-1]",
"inv_fact",
"y-1",
"y",
"1",
"inv_fact[w-x]",
"inv_fact",
"w-x",
"w",
"x",
"inv_fact[h-y]",
"inv_fact",
"h-y",
"h",
"y",
"mod",
"x",
"x",
"y",
"y",
"h,w,a,b = LI()",
"h",
"LI()",
"LI",
"w",
"a",
"b",
"fact = [1]*(h+w+1)",
"fact",
"[1]*(h+w+1)",
"[1]",
"1",
"h+w+1",
"h+w",
"h",
"w",
"1",
"for i in range(h+w):\n fact[i+1] = fact[i]*(i+1)%mod",
"i",
"range(h+w)",
"range",
"h+w",
"h",
"w",
"fact[i+1] = fact[i]*(i+1)%mod",
"fact[i+1]",
"fact",
"i+1",
"i",
"1",
"fact[i]*(i+1)%mod",
"fact[i]*(i+1)",
"fact[i]",
"fact",
"i",
"i+1",
"i",
"1",
"mod",
"inv_fact = [0]*(h+w+1)",
"inv_fact",
"[0]*(h+w+1)",
"[0]",
"0",
"h+w+1",
"h+w",
"h",
"w",
"1",
"inv_fact[h+w] = pow(fact[-1],mod-2,mod)",
"inv_fact[h+w]",
"inv_fact",
"h+w",
"h",
"w",
"pow(fact[-1],mod-2,mod)",
"pow",
"fact[-1]",
"fact",
"-1",
"mod-2",
"mod",
"2",
"mod",
"for i in range(h+w)[::-1]:\n inv_fact[i] = inv_fact[i+1]*(i+1)%mod",
"i",
"range(h+w)[::-1]",
"(h+w)",
"range",
"h+w",
"h",
"w",
"::-1",
"-1",
"inv_fact[i] = inv_fact[i+1]*(i+1)%mod",
"inv_fact[i]",
"inv_fact",
"i",
"inv_fact[i+1]*(i+1)%mod",
"inv_fact[i+1]*(i+1)",
"inv_fact[i+1]",
"inv_fact",
"i+1",
"i",
"1",
"i+1",
"i",
"1",
"mod",
"ans = 0",
"ans",
"0",
"for i in range(1,min(w-b,h-a)+1):\n ans += f(b+i,a+i)\n ans %= mod",
"i",
"range(1,min(w-b,h-a)+1)",
"range",
"1",
"min(w-b,h-a)+1",
"min(w-b,h-a)",
"min",
"w-b",
"w",
"b",
"h-a",
"h",
"a",
"1",
"ans += f(b+i,a+i)",
"ans",
"f(b+i,a+i)",
"f",
"b+i",
"b",
"i",
"a+i",
"a",
"i",
"ans %= mod",
"ans",
"mod",
"print(ans)",
"print",
"ans",
"inv_fact = [0]*(h+w+1)",
"[0]*(h+w+1)",
"inv_fact",
"mod = 1000000007",
"1000000007",
"mod",
"def LI(): return list(map(int, sys.stdin.readline().split()))",
"def LI(): return list(map(int, sys.stdin.readline().split()))",
"LI",
"def S(): return list(sys.stdin.readline())[:-1]",
"def S(): return list(sys.stdin.readline())[:-1]",
"S",
"def I(): return int(sys.stdin.readline())",
"def I(): return int(sys.stdin.readline())",
"I",
"h,w,a,b = LI()",
"LI()",
"h",
"def LS(): return list(map(list, sys.stdin.readline().split()))",
"def LS(): return list(map(list, sys.stdin.readline().split()))",
"LS",
"ans += f(b+i,a+i)",
"f(b+i,a+i)",
"ans",
"w,a,b = LI()",
"LI()",
"w",
"ans %= mod",
"mod",
"ans",
"b = LI()",
"LI()",
"b",
"ans = 0",
"0",
"ans",
"def SR(n): return [S() for i in range(n)]",
"def SR(n): return [S() for i in range(n)]",
"SR",
"def LSR(n): return [LS() for i in range(n)]",
"def LSR(n): return [LS() for i in range(n)]",
"LSR",
"def f(x,y):\n return fact[x-1+h-y]*fact[y-1+w-x]*inv_fact[x-1]*inv_fact[y-1]*inv_fact[w-x]*inv_fact[h-y]%mod",
"def f(x,y):\n return fact[x-1+h-y]*fact[y-1+w-x]*inv_fact[x-1]*inv_fact[y-1]*inv_fact[w-x]*inv_fact[h-y]%mod",
"f",
"fact = [1]*(h+w+1)",
"[1]*(h+w+1)",
"fact",
"def LIR(n): return [LI() for i in range(n)]",
"def LIR(n): return [LI() for i in range(n)]",
"LIR",
"a,b = LI()",
"LI()",
"a",
"def IR(n): return [I() for i in range(n)]",
"def IR(n): return [I() for i in range(n)]",
"IR"
] | #!usr/bin/env python3
from collections import defaultdict
from heapq import heappush, heappop
import sys
import math
import bisect
import random
def LI(): return list(map(int, sys.stdin.readline().split()))
def I(): return int(sys.stdin.readline())
def LS(): return list(map(list, sys.stdin.readline().split()))
def S(): return list(sys.stdin.readline())[:-1]
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)]
mod = 1000000007
#A
"""
def check(n):
n = list(map(int,list(str(n))))
s = 0
for i in n:
s += f[i]
return s == 0
n,k = LI()
d = LI()
f = [0 for i in range(10)]
for i in d:
f[i] = 1
while 1:
if check(n):
print(n)
quit()
n += 1
"""
#B
def f(x,y):
return fact[x-1+h-y]*fact[y-1+w-x]*inv_fact[x-1]*inv_fact[y-1]*inv_fact[w-x]*inv_fact[h-y]%mod
h,w,a,b = LI()
fact = [1]*(h+w+1)
for i in range(h+w):
fact[i+1] = fact[i]*(i+1)%mod
inv_fact = [0]*(h+w+1)
inv_fact[h+w] = pow(fact[-1],mod-2,mod)
for i in range(h+w)[::-1]:
inv_fact[i] = inv_fact[i+1]*(i+1)%mod
ans = 0
for i in range(1,min(w-b,h-a)+1):
ans += f(b+i,a+i)
ans %= mod
print(ans)
#C
#D
#E
#F
#G
#H
#I
#J
#K
#L
#M
#N
#O
#P
#Q
#R
#S
#T
|
[
7,
12,
13,
0,
13,
17,
28,
13,
4,
13,
17,
2,
13,
17,
0,
13,
2,
2,
13,
13,
13,
29,
13,
23,
13,
23,
13,
12,
13,
0,
13,
17,
42,
2,
13,
17,
14,
40,
2,
13,
17,
17,
0,
13,
2,
2,
13,
13,
13,
0,
13,
2,
13,
17,
0,
13,
2,
2,
13,
13,
13,
29,
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,
39,
0,
13,
17,
0,
13,
4,
13,
4,
13,
13,
13,
2,
13,
17,
13,
0,
13,
4,
13,
2,
13,
17,
13,
0,
13,
39,
4,
13,
4,
13,
2,
2,
13,
13,
17,
13,
2,
13,
17,
13,
28,
13,
4,
13,
2,
2,
13,
13,
17,
17,
17,
4,
18,
13,
13,
2,
2,
18,
13,
2,
2,
2,
13,
13,
17,
13,
13,
13,
0,
13,
18,
13,
39,
17,
28,
13,
4,
13,
2,
13,
13,
0,
13,
2,
2,
13,
2,
13,
13,
13,
4,
18,
13,
13,
2,
2,
2,
13,
13,
18,
13,
13,
13,
0,
18,
13,
13,
2,
2,
18,
13,
13,
13,
13,
0,
13,
18,
13,
13,
0,
13,
4,
13,
4,
13,
2,
2,
13,
13,
17,
13,
2,
13,
17,
13,
0,
13,
4,
13,
2,
2,
2,
13,
13,
13,
17,
13,
0,
13,
39,
4,
13,
4,
13,
2,
13,
17,
13,
2,
13,
17,
13,
28,
13,
4,
13,
2,
13,
17,
17,
17,
4,
18,
13,
13,
2,
2,
18,
13,
2,
2,
13,
17,
13,
13,
13,
28,
13,
4,
13,
2,
2,
13,
13,
17,
17,
17,
0,
13,
2,
2,
13,
2,
2,
2,
2,
2,
13,
13,
17,
13,
13,
17,
13,
0,
18,
13,
13,
2,
2,
18,
13,
13,
2,
2,
13,
13,
18,
13,
13,
13,
0,
13,
17,
28,
13,
4,
13,
2,
13,
13,
0,
13,
18,
13,
13,
0,
13,
2,
13,
13,
4,
13,
13,
10,
2,
13,
10,
18,
13,
10,
4,
13,
10,
4,
13,
10,
4,
13,
10,
4,
13,
10,
12,
13,
10,
4,
13,
10,
4,
13,
10,
18,
13,
10,
18,
13,
10,
39,
13,
10,
12,
13,
10,
39,
13,
10,
2,
13,
10,
2,
13,
10,
17,
13,
10,
4,
13,
10,
4,
13,
10,
17,
13,
10,
39,
13,
10,
2,
13
] | [
[
5,
4
],
[
8,
7
],
[
24,
12
],
[
16,
15
],
[
4,
18
],
[
15,
18
],
[
7,
19
],
[
26,
20
],
[
15,
22
],
[
4,
22
],
[
24,
24
],
[
26,
26
],
[
31,
30
],
[
66,
34
],
[
50,
34
],
[
66,
39
],
[
50,
39
],
[
44,
43
],
[
30,
46
],
[
43,
46
],
[
64,
47
],
[
55,
47
],
[
68,
48
],
[
51,
50
],
[
66,
52
],
[
50,
52
],
[
56,
55
],
[
64,
58
],
[
55,
58
],
[
64,
59
],
[
55,
59
],
[
68,
60
],
[
43,
62
],
[
30,
62
],
[
64,
64
],
[
66,
66
],
[
68,
68
],
[
371,
70
],
[
371,
79
],
[
371,
80
],
[
371,
81
],
[
389,
83
],
[
386,
90
],
[
395,
93
],
[
356,
96
],
[
384,
98
],
[
366,
100
],
[
369,
101
],
[
390,
102
],
[
390,
104
],
[
390,
106
],
[
401,
108
],
[
366,
110
],
[
369,
112
],
[
390,
114
],
[
380,
116
],
[
384,
119
],
[
366,
121
],
[
372,
124
],
[
354,
125
],
[
390,
127
],
[
390,
129
],
[
390,
131
],
[
134,
133
],
[
372,
138
],
[
354,
139
],
[
381,
145
],
[
381,
150
],
[
372,
154
],
[
354,
155
],
[
133,
157
],
[
133,
158
],
[
390,
159
],
[
374,
161
],
[
381,
163
],
[
168,
167
],
[
372,
171
],
[
354,
172
],
[
347,
174
],
[
402,
177
],
[
348,
177
],
[
369,
179
],
[
167,
180
],
[
390,
181
],
[
387,
184
],
[
348,
189
],
[
402,
189
],
[
357,
190
],
[
375,
192
],
[
381,
192
],
[
167,
193
],
[
390,
194
],
[
199,
196
],
[
387,
197
],
[
167,
198
],
[
196,
201
],
[
387,
202
],
[
167,
203
],
[
396,
204
],
[
378,
204
],
[
390,
205
],
[
377,
207
],
[
196,
208
],
[
387,
209
],
[
167,
210
],
[
398,
212
],
[
384,
214
],
[
366,
216
],
[
363,
219
],
[
369,
220
],
[
390,
222
],
[
390,
224
],
[
390,
226
],
[
359,
228
],
[
366,
230
],
[
363,
234
],
[
354,
235
],
[
369,
236
],
[
390,
238
],
[
407,
240
],
[
384,
243
],
[
366,
245
],
[
372,
247
],
[
390,
249
],
[
390,
251
],
[
390,
253
],
[
256,
255
],
[
372,
259
],
[
408,
265
],
[
375,
265
],
[
381,
265
],
[
408,
270
],
[
375,
270
],
[
381,
270
],
[
372,
273
],
[
255,
275
],
[
255,
276
],
[
390,
277
],
[
280,
279
],
[
372,
284
],
[
354,
285
],
[
410,
290
],
[
360,
293
],
[
348,
293
],
[
402,
293
],
[
411,
293
],
[
363,
299
],
[
369,
300
],
[
372,
302
],
[
279,
303
],
[
390,
305
],
[
310,
307
],
[
387,
308
],
[
279,
309
],
[
196,
312
],
[
307,
312
],
[
387,
313
],
[
279,
314
],
[
411,
317
],
[
360,
317
],
[
348,
317
],
[
402,
317
],
[
399,
318
],
[
357,
318
],
[
408,
320
],
[
375,
320
],
[
381,
320
],
[
279,
321
],
[
390,
322
],
[
404,
324
],
[
328,
327
],
[
372,
331
],
[
354,
332
],
[
350,
334
],
[
307,
335
],
[
196,
335
],
[
387,
336
],
[
327,
337
],
[
392,
339
],
[
351,
341
],
[
405,
341
],
[
393,
341
],
[
390,
342
],
[
393,
345
],
[
351,
345
],
[
405,
345
],
[
347,
348
],
[
307,
350
],
[
196,
350
],
[
350,
351
],
[
371,
354
],
[
356,
357
],
[
359,
360
],
[
371,
363
],
[
371,
369
],
[
371,
372
],
[
374,
375
],
[
196,
377
],
[
377,
378
],
[
380,
381
],
[
386,
387
],
[
389,
390
],
[
392,
393
],
[
395,
396
],
[
398,
399
],
[
401,
402
],
[
404,
405
],
[
407,
408
],
[
410,
411
]
] | [
"def mf(num,mod):\n ret=1\n for i in range(1,num+1):\n ret=(ret*i)%mod\n return ret\n\ndef rev(num,pow,mod):\n ret=1\n while pow>0:\n if pow&1!=0:\n ret=(ret*num)%mod\n pow=pow>>1\n num=(num*num)%mod\n return ret\n\nh,w,a,b=map(int,input().split())\nmod=10**9+7\nans=[]\ns=0\ntb=rev(mf(b,mod),mod-2,mod)\ntf=mf(b-1,mod)\ntrev=[rev(mf(h-a-1,mod),mod-2,mod)]\nfor i in range(h-a-1,0,-1):\n trev.append((trev[h-a-1-i]*i)%mod)\ntrev=trev[::-1]\nfor i in range(h-a):\n tf=(tf*(b+i))%mod\n ans.append((tf*tb*trev[i])%mod)\n ans[i]=(ans[i]-s)%mod\n s+=ans[i]\ntb=rev(mf(w-b-1,mod),mod-2,mod)\ntf=mf(w+a-b-2,mod)\ntrev=[rev(mf(h-1,mod),mod-2,mod)]\nfor i in range(h-1,0,-1):\n trev.append((trev[h-1-i]*i)%mod)\nfor i in range(h-a-1,-1,-1):\n tf=(tf*(w-b-1+h-i-1))%mod\n ans[i]=(ans[i]*(tf*tb*trev[i])%mod)\nret=0\nfor i in range(h-a):\n ret+=ans[i]\n ret=ret%mod\nprint(ret)",
"def mf(num,mod):\n ret=1\n for i in range(1,num+1):\n ret=(ret*i)%mod\n return ret",
"mf",
"ret=1",
"ret",
"1",
"for i in range(1,num+1):\n ret=(ret*i)%mod\n ",
"i",
"range(1,num+1)",
"range",
"1",
"num+1",
"num",
"1",
"ret=(ret*i)%mod",
"ret",
"(ret*i)%mod",
"ret*i",
"ret",
"i",
"mod",
"return ret",
"ret",
"num",
"num",
"mod",
"mod",
"def rev(num,pow,mod):\n ret=1\n while pow>0:\n if pow&1!=0:\n ret=(ret*num)%mod\n pow=pow>>1\n num=(num*num)%mod\n return ret",
"rev",
"ret=1",
"ret",
"1",
"while pow>0:\n if pow&1!=0:\n ret=(ret*num)%mod\n pow=pow>>1\n num=(num*num)%mod\n ",
"pow>0",
"pow",
"0",
"if pow&1!=0:\n ret=(ret*num)%mod\n ",
"pow&1!=0",
"pow&1",
"pow",
"1",
"0",
"ret=(ret*num)%mod",
"ret",
"(ret*num)%mod",
"ret*num",
"ret",
"num",
"mod",
"pow=pow>>1",
"pow",
"pow>>1",
"pow",
"1",
"num=(num*num)%mod",
"num",
"(num*num)%mod",
"num*num",
"num",
"num",
"mod",
"return ret",
"ret",
"num",
"num",
"pow",
"pow",
"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=10**9+7",
"mod",
"10**9+7",
"10**9",
"10",
"9",
"7",
"ans=[]",
"ans",
"[]",
"s=0",
"s",
"0",
"tb=rev(mf(b,mod),mod-2,mod)",
"tb",
"rev(mf(b,mod),mod-2,mod)",
"rev",
"mf(b,mod)",
"mf",
"b",
"mod",
"mod-2",
"mod",
"2",
"mod",
"tf=mf(b-1,mod)",
"tf",
"mf(b-1,mod)",
"mf",
"b-1",
"b",
"1",
"mod",
"trev=[rev(mf(h-a-1,mod),mod-2,mod)]",
"trev",
"[rev(mf(h-a-1,mod),mod-2,mod)]",
"rev(mf(h-a-1,mod),mod-2,mod)",
"rev",
"mf(h-a-1,mod)",
"mf",
"h-a-1",
"h-a",
"h",
"a",
"1",
"mod",
"mod-2",
"mod",
"2",
"mod",
"for i in range(h-a-1,0,-1):\n trev.append((trev[h-a-1-i]*i)%mod)",
"i",
"range(h-a-1,0,-1)",
"range",
"h-a-1",
"h-a",
"h",
"a",
"1",
"0",
"-1",
"trev.append((trev[h-a-1-i]*i)%mod)",
"trev.append",
"trev",
"append",
"(trev[h-a-1-i]*i)%mod",
"trev[h-a-1-i]*i",
"trev[h-a-1-i]",
"trev",
"h-a-1-i",
"h-a-1",
"h-a",
"h",
"a",
"1",
"i",
"i",
"mod",
"trev=trev[::-1]",
"trev",
"trev[::-1]",
"trev",
"::-1",
"-1",
"for i in range(h-a):\n tf=(tf*(b+i))%mod\n ans.append((tf*tb*trev[i])%mod)\n ans[i]=(ans[i]-s)%mod\n s+=ans[i]",
"i",
"range(h-a)",
"range",
"h-a",
"h",
"a",
"tf=(tf*(b+i))%mod",
"tf",
"(tf*(b+i))%mod",
"tf*(b+i)",
"tf",
"b+i",
"b",
"i",
"mod",
"ans.append((tf*tb*trev[i])%mod)",
"ans.append",
"ans",
"append",
"(tf*tb*trev[i])%mod",
"tf*tb*trev[i]",
"tf*tb",
"tf",
"tb",
"trev[i]",
"trev",
"i",
"mod",
"ans[i]=(ans[i]-s)%mod",
"ans[i]",
"ans",
"i",
"(ans[i]-s)%mod",
"ans[i]-s",
"ans[i]",
"ans",
"i",
"s",
"mod",
"s+=ans[i]",
"s",
"ans[i]",
"ans",
"i",
"tb=rev(mf(w-b-1,mod),mod-2,mod)",
"tb",
"rev(mf(w-b-1,mod),mod-2,mod)",
"rev",
"mf(w-b-1,mod)",
"mf",
"w-b-1",
"w-b",
"w",
"b",
"1",
"mod",
"mod-2",
"mod",
"2",
"mod",
"tf=mf(w+a-b-2,mod)",
"tf",
"mf(w+a-b-2,mod)",
"mf",
"w+a-b-2",
"w+a-b",
"w+a",
"w",
"a",
"b",
"2",
"mod",
"trev=[rev(mf(h-1,mod),mod-2,mod)]",
"trev",
"[rev(mf(h-1,mod),mod-2,mod)]",
"rev(mf(h-1,mod),mod-2,mod)",
"rev",
"mf(h-1,mod)",
"mf",
"h-1",
"h",
"1",
"mod",
"mod-2",
"mod",
"2",
"mod",
"for i in range(h-1,0,-1):\n trev.append((trev[h-1-i]*i)%mod)",
"i",
"range(h-1,0,-1)",
"range",
"h-1",
"h",
"1",
"0",
"-1",
"trev.append((trev[h-1-i]*i)%mod)",
"trev.append",
"trev",
"append",
"(trev[h-1-i]*i)%mod",
"trev[h-1-i]*i",
"trev[h-1-i]",
"trev",
"h-1-i",
"h-1",
"h",
"1",
"i",
"i",
"mod",
"for i in range(h-a-1,-1,-1):\n tf=(tf*(w-b-1+h-i-1))%mod\n ans[i]=(ans[i]*(tf*tb*trev[i])%mod)",
"i",
"range(h-a-1,-1,-1)",
"range",
"h-a-1",
"h-a",
"h",
"a",
"1",
"-1",
"-1",
"tf=(tf*(w-b-1+h-i-1))%mod",
"tf",
"(tf*(w-b-1+h-i-1))%mod",
"tf*(w-b-1+h-i-1)",
"tf",
"w-b-1+h-i-1",
"w-b-1+h-i",
"w-b-1+h",
"w-b-1",
"w-b",
"w",
"b",
"1",
"h",
"i",
"1",
"mod",
"ans[i]=(ans[i]*(tf*tb*trev[i])%mod)",
"ans[i]",
"ans",
"i",
"ans[i]*(tf*tb*trev[i])%mod",
"ans[i]*(tf*tb*trev[i])",
"ans[i]",
"ans",
"i",
"tf*tb*trev[i]",
"tf*tb",
"tf",
"tb",
"trev[i]",
"trev",
"i",
"mod",
"ret=0",
"ret",
"0",
"for i in range(h-a):\n ret+=ans[i]\n ret=ret%mod",
"i",
"range(h-a)",
"range",
"h-a",
"h",
"a",
"ret+=ans[i]",
"ret",
"ans[i]",
"ans",
"i",
"ret=ret%mod",
"ret",
"ret%mod",
"ret",
"mod",
"print(ret)",
"print",
"ret",
"tf=(tf*(b+i))%mod",
"(tf*(b+i))%mod",
"tf",
"ret+=ans[i]",
"ans[i]",
"ret",
"a,b=map(int,input().split())",
"map(int,input().split())",
"a",
"tb=rev(mf(b,mod),mod-2,mod)",
"rev(mf(b,mod),mod-2,mod)",
"tb",
"tf=mf(w+a-b-2,mod)",
"mf(w+a-b-2,mod)",
"tf",
"w,a,b=map(int,input().split())",
"map(int,input().split())",
"w",
"def mf(num,mod):\n ret=1\n for i in range(1,num+1):\n ret=(ret*i)%mod\n return ret",
"def mf(num,mod):\n ret=1\n for i in range(1,num+1):\n ret=(ret*i)%mod\n return ret",
"mf",
"b=map(int,input().split())",
"map(int,input().split())",
"b",
"h,w,a,b=map(int,input().split())",
"map(int,input().split())",
"h",
"trev=trev[::-1]",
"trev[::-1]",
"trev",
"s+=ans[i]",
"ans[i]",
"s",
"trev=[rev(mf(h-a-1,mod),mod-2,mod)]",
"[rev(mf(h-a-1,mod),mod-2,mod)]",
"trev",
"def rev(num,pow,mod):\n ret=1\n while pow>0:\n if pow&1!=0:\n ret=(ret*num)%mod\n pow=pow>>1\n num=(num*num)%mod\n return ret",
"def rev(num,pow,mod):\n ret=1\n while pow>0:\n if pow&1!=0:\n ret=(ret*num)%mod\n pow=pow>>1\n num=(num*num)%mod\n return ret",
"rev",
"ans=[]",
"[]",
"ans",
"mod=10**9+7",
"10**9+7",
"mod",
"ret=ret%mod",
"ret%mod",
"ret",
"s=0",
"0",
"s",
"tb=rev(mf(w-b-1,mod),mod-2,mod)",
"rev(mf(w-b-1,mod),mod-2,mod)",
"tb",
"tf=mf(b-1,mod)",
"mf(b-1,mod)",
"tf",
"ret=0",
"0",
"ret",
"trev=[rev(mf(h-1,mod),mod-2,mod)]",
"[rev(mf(h-1,mod),mod-2,mod)]",
"trev",
"tf=(tf*(w-b-1+h-i-1))%mod",
"(tf*(w-b-1+h-i-1))%mod",
"tf"
] | def mf(num,mod):
ret=1
for i in range(1,num+1):
ret=(ret*i)%mod
return ret
def rev(num,pow,mod):
ret=1
while pow>0:
if pow&1!=0:
ret=(ret*num)%mod
pow=pow>>1
num=(num*num)%mod
return ret
h,w,a,b=map(int,input().split())
mod=10**9+7
ans=[]
s=0
tb=rev(mf(b,mod),mod-2,mod)
tf=mf(b-1,mod)
trev=[rev(mf(h-a-1,mod),mod-2,mod)]
for i in range(h-a-1,0,-1):
trev.append((trev[h-a-1-i]*i)%mod)
trev=trev[::-1]
for i in range(h-a):
tf=(tf*(b+i))%mod
ans.append((tf*tb*trev[i])%mod)
ans[i]=(ans[i]-s)%mod
s+=ans[i]
tb=rev(mf(w-b-1,mod),mod-2,mod)
tf=mf(w+a-b-2,mod)
trev=[rev(mf(h-1,mod),mod-2,mod)]
for i in range(h-1,0,-1):
trev.append((trev[h-1-i]*i)%mod)
for i in range(h-a-1,-1,-1):
tf=(tf*(w-b-1+h-i-1))%mod
ans[i]=(ans[i]*(tf*tb*trev[i])%mod)
ret=0
for i in range(h-a):
ret+=ans[i]
ret=ret%mod
print(ret) |
[
7,
6,
13,
12,
13,
0,
18,
13,
13,
13,
41,
28,
13,
4,
13,
2,
13,
17,
4,
17,
0,
18,
13,
13,
13,
41,
28,
13,
4,
13,
2,
13,
17,
4,
17,
0,
18,
13,
13,
13,
0,
18,
18,
13,
13,
17,
17,
0,
18,
18,
13,
13,
17,
17,
28,
13,
4,
13,
13,
0,
18,
18,
13,
13,
2,
13,
17,
2,
2,
18,
18,
13,
13,
13,
2,
13,
17,
13,
0,
18,
18,
13,
13,
2,
13,
17,
2,
2,
18,
18,
13,
13,
13,
4,
13,
2,
13,
17,
2,
13,
17,
13,
13,
23,
13,
23,
13,
23,
13,
12,
13,
29,
2,
2,
2,
18,
18,
13,
13,
13,
18,
18,
13,
13,
13,
18,
18,
13,
13,
2,
13,
13,
18,
13,
13,
23,
13,
23,
13,
23,
13,
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,
2,
13,
13,
0,
13,
2,
4,
18,
13,
13,
2,
2,
13,
17,
13,
13,
4,
18,
13,
13,
2,
2,
2,
2,
2,
13,
13,
17,
13,
13,
17,
2,
2,
13,
13,
17,
0,
13,
13,
4,
13,
13,
10,
2,
13,
10,
4,
13,
10,
4,
13,
10,
17,
13,
10,
2,
13,
10,
4,
13,
10,
13,
13,
10,
4,
13,
10,
6,
13,
10,
4,
13
] | [
[
9,
6
],
[
104,
7
],
[
108,
8
],
[
108,
9
],
[
13,
12
],
[
106,
16
],
[
24,
21
],
[
104,
22
],
[
28,
27
],
[
106,
31
],
[
39,
36
],
[
104,
37
],
[
46,
41
],
[
21,
42
],
[
104,
43
],
[
53,
48
],
[
36,
49
],
[
104,
50
],
[
56,
55
],
[
106,
58
],
[
67,
60
],
[
21,
61
],
[
104,
62
],
[
55,
65
],
[
21,
70
],
[
104,
71
],
[
55,
73
],
[
55,
75
],
[
108,
77
],
[
86,
79
],
[
36,
80
],
[
104,
81
],
[
55,
84
],
[
36,
89
],
[
104,
90
],
[
55,
92
],
[
55,
96
],
[
108,
99
],
[
108,
101
],
[
108,
102
],
[
104,
104
],
[
106,
106
],
[
108,
108
],
[
136,
117
],
[
138,
119
],
[
136,
122
],
[
140,
124
],
[
136,
127
],
[
138,
130
],
[
140,
131
],
[
136,
133
],
[
136,
136
],
[
138,
138
],
[
140,
140
],
[
231,
142
],
[
246,
149
],
[
246,
158
],
[
246,
159
],
[
246,
160
],
[
240,
162
],
[
247,
166
],
[
223,
167
],
[
232,
168
],
[
228,
170
],
[
174,
173
],
[
247,
177
],
[
235,
178
],
[
219,
180
],
[
241,
184
],
[
110,
185
],
[
226,
188
],
[
173,
190
],
[
173,
191
],
[
241,
194
],
[
110,
195
],
[
223,
201
],
[
226,
202
],
[
247,
204
],
[
173,
205
],
[
247,
209
],
[
173,
210
],
[
237,
213
],
[
232,
214
],
[
238,
217
],
[
220,
217
],
[
229,
217
],
[
219,
220
],
[
246,
223
],
[
246,
226
],
[
228,
229
],
[
231,
232
],
[
246,
235
],
[
232,
237
],
[
237,
238
],
[
240,
241
],
[
246,
247
]
] | [
"class Combination():\n def __init__(self,n,mod):\n self.mod = mod\n self.factorial = [0 for _ in range(n+1)]\n self.inv = [0 for _ in range(n+1)]\n self.factorial[0] = 1\n self.inv[0] = 1\n for i in range(n):\n self.factorial[i+1] = self.factorial[i]*(i+1)%mod\n self.inv[i+1] = self.inv[i]*pow(i+1,mod-2,mod)%mod\n def comb(self,m,k):\n return self.factorial[m]*self.inv[k]*self.inv[m-k]%self.mod\n \nMOD = 10**9+7\nH,W,A,B = map(int,input().split())\n\ncb = Combination(H+W,MOD)\n\nans = 0\n\nfor i in range(H-A):\n ans += cb.comb(B-1+i,i)*cb.comb(W-B-1+H-i-1,H-i-1)\n ans %= MOD\n \nprint(ans)",
"class Combination():\n def __init__(self,n,mod):\n self.mod = mod\n self.factorial = [0 for _ in range(n+1)]\n self.inv = [0 for _ in range(n+1)]\n self.factorial[0] = 1\n self.inv[0] = 1\n for i in range(n):\n self.factorial[i+1] = self.factorial[i]*(i+1)%mod\n self.inv[i+1] = self.inv[i]*pow(i+1,mod-2,mod)%mod\n def comb(self,m,k):\n return self.factorial[m]*self.inv[k]*self.inv[m-k]%self.mod\n ",
"Combination",
"def __init__(self,n,mod):\n self.mod = mod\n self.factorial = [0 for _ in range(n+1)]\n self.inv = [0 for _ in range(n+1)]\n self.factorial[0] = 1\n self.inv[0] = 1\n for i in range(n):\n self.factorial[i+1] = self.factorial[i]*(i+1)%mod\n self.inv[i+1] = self.inv[i]*pow(i+1,mod-2,mod)%mod\n ",
"__init__",
"self.mod = mod",
"self.mod",
"self",
"mod",
"mod",
"0 for _ in range(n+1)",
"for _ in range(n+1)",
"_",
"range(n+1)",
"range",
"n+1",
"n",
"1",
"for _ in range(n+1)",
"0",
"self.factorial = [0 for _ in range(n+1)]",
"self.factorial",
"self",
"factorial",
"[0 for _ in range(n+1)]",
"0 for _ in range(n+1)",
"for _ in range(n+1)",
"_",
"range(n+1)",
"range",
"n+1",
"n",
"1",
"for _ in range(n+1)",
"0",
"self.inv = [0 for _ in range(n+1)]",
"self.inv",
"self",
"inv",
"[0 for _ in range(n+1)]",
"self.factorial[0] = 1",
"self.factorial[0]",
"self.factorial",
"self",
"factorial",
"0",
"1",
"self.inv[0] = 1",
"self.inv[0]",
"self.inv",
"self",
"inv",
"0",
"1",
"for i in range(n):\n self.factorial[i+1] = self.factorial[i]*(i+1)%mod\n self.inv[i+1] = self.inv[i]*pow(i+1,mod-2,mod)%mod\n ",
"i",
"range(n)",
"range",
"n",
"self.factorial[i+1] = self.factorial[i]*(i+1)%mod",
"self.factorial[i+1]",
"self.factorial",
"self",
"factorial",
"i+1",
"i",
"1",
"self.factorial[i]*(i+1)%mod",
"self.factorial[i]*(i+1)",
"self.factorial[i]",
"self.factorial",
"self",
"factorial",
"i",
"i+1",
"i",
"1",
"mod",
"self.inv[i+1] = self.inv[i]*pow(i+1,mod-2,mod)%mod",
"self.inv[i+1]",
"self.inv",
"self",
"inv",
"i+1",
"i",
"1",
"self.inv[i]*pow(i+1,mod-2,mod)%mod",
"self.inv[i]*pow(i+1,mod-2,mod)",
"self.inv[i]",
"self.inv",
"self",
"inv",
"i",
"pow(i+1,mod-2,mod)",
"pow",
"i+1",
"i",
"1",
"mod-2",
"mod",
"2",
"mod",
"mod",
"self",
"self",
"n",
"n",
"mod",
"mod",
"def comb(self,m,k):\n return self.factorial[m]*self.inv[k]*self.inv[m-k]%self.mod\n ",
"comb",
"return self.factorial[m]*self.inv[k]*self.inv[m-k]%self.mod",
"self.factorial[m]*self.inv[k]*self.inv[m-k]%self.mod",
"self.factorial[m]*self.inv[k]*self.inv[m-k]",
"self.factorial[m]*self.inv[k]",
"self.factorial[m]",
"self.factorial",
"self",
"factorial",
"m",
"self.inv[k]",
"self.inv",
"self",
"inv",
"k",
"self.inv[m-k]",
"self.inv",
"self",
"inv",
"m-k",
"m",
"k",
"self.mod",
"self",
"mod",
"self",
"self",
"m",
"m",
"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",
"cb = Combination(H+W,MOD)",
"cb",
"Combination(H+W,MOD)",
"Combination",
"H+W",
"H",
"W",
"MOD",
"ans = 0",
"ans",
"0",
"for i in range(H-A):\n ans += cb.comb(B-1+i,i)*cb.comb(W-B-1+H-i-1,H-i-1)\n ans %= MOD\n ",
"i",
"range(H-A)",
"range",
"H-A",
"H",
"A",
"ans += cb.comb(B-1+i,i)*cb.comb(W-B-1+H-i-1,H-i-1)",
"ans",
"cb.comb(B-1+i,i)*cb.comb(W-B-1+H-i-1,H-i-1)",
"cb.comb(B-1+i,i)",
"cb.comb",
"cb",
"comb",
"B-1+i",
"B-1",
"B",
"1",
"i",
"i",
"cb.comb(W-B-1+H-i-1,H-i-1)",
"cb.comb",
"cb",
"comb",
"W-B-1+H-i-1",
"W-B-1+H-i",
"W-B-1+H",
"W-B-1",
"W-B",
"W",
"B",
"1",
"H",
"i",
"1",
"H-i-1",
"H-i",
"H",
"i",
"1",
"ans %= MOD",
"ans",
"MOD",
"print(ans)",
"print",
"ans",
"ans += cb.comb(B-1+i,i)*cb.comb(W-B-1+H-i-1,H-i-1)",
"cb.comb(B-1+i,i)*cb.comb(W-B-1+H-i-1,H-i-1)",
"ans",
"W,A,B = map(int,input().split())",
"map(int,input().split())",
"W",
"B = map(int,input().split())",
"map(int,input().split())",
"B",
"ans = 0",
"0",
"ans",
"MOD = 10**9+7",
"10**9+7",
"MOD",
"A,B = map(int,input().split())",
"map(int,input().split())",
"A",
"ans %= MOD",
"MOD",
"ans",
"cb = Combination(H+W,MOD)",
"Combination(H+W,MOD)",
"cb",
"class Combination():\n def __init__(self,n,mod):\n self.mod = mod\n self.factorial = [0 for _ in range(n+1)]\n self.inv = [0 for _ in range(n+1)]\n self.factorial[0] = 1\n self.inv[0] = 1\n for i in range(n):\n self.factorial[i+1] = self.factorial[i]*(i+1)%mod\n self.inv[i+1] = self.inv[i]*pow(i+1,mod-2,mod)%mod\n def comb(self,m,k):\n return self.factorial[m]*self.inv[k]*self.inv[m-k]%self.mod\n ",
"class Combination():\n def __init__(self,n,mod):\n self.mod = mod\n self.factorial = [0 for _ in range(n+1)]\n self.inv = [0 for _ in range(n+1)]\n self.factorial[0] = 1\n self.inv[0] = 1\n for i in range(n):\n self.factorial[i+1] = self.factorial[i]*(i+1)%mod\n self.inv[i+1] = self.inv[i]*pow(i+1,mod-2,mod)%mod\n def comb(self,m,k):\n return self.factorial[m]*self.inv[k]*self.inv[m-k]%self.mod\n ",
"Combination",
"H,W,A,B = map(int,input().split())",
"map(int,input().split())",
"H"
] | class Combination():
def __init__(self,n,mod):
self.mod = mod
self.factorial = [0 for _ in range(n+1)]
self.inv = [0 for _ in range(n+1)]
self.factorial[0] = 1
self.inv[0] = 1
for i in range(n):
self.factorial[i+1] = self.factorial[i]*(i+1)%mod
self.inv[i+1] = self.inv[i]*pow(i+1,mod-2,mod)%mod
def comb(self,m,k):
return self.factorial[m]*self.inv[k]*self.inv[m-k]%self.mod
MOD = 10**9+7
H,W,A,B = map(int,input().split())
cb = Combination(H+W,MOD)
ans = 0
for i in range(H-A):
ans += cb.comb(B-1+i,i)*cb.comb(W-B-1+H-i-1,H-i-1)
ans %= MOD
print(ans) |
[
7,
0,
13,
4,
13,
13,
4,
18,
4,
13,
13,
13,
13,
13,
12,
13,
29,
2,
13,
2,
2,
17,
17,
17,
23,
13,
0,
13,
2,
2,
13,
13,
17,
0,
13,
2,
39,
17,
13,
0,
13,
2,
39,
17,
13,
0,
18,
13,
17,
17,
28,
13,
4,
13,
17,
13,
0,
18,
13,
13,
4,
13,
2,
18,
13,
2,
13,
17,
13,
0,
18,
13,
2,
13,
17,
4,
13,
18,
13,
2,
13,
17,
2,
2,
17,
17,
17,
2,
2,
17,
17,
17,
28,
13,
4,
13,
2,
13,
17,
17,
17,
0,
18,
13,
13,
4,
13,
2,
18,
13,
2,
13,
17,
2,
13,
17,
0,
18,
13,
17,
17,
0,
13,
2,
39,
17,
2,
13,
13,
28,
13,
4,
13,
2,
13,
13,
0,
18,
13,
13,
4,
13,
2,
18,
13,
2,
2,
2,
2,
13,
13,
17,
13,
13,
4,
13,
2,
18,
13,
2,
13,
13,
18,
13,
2,
2,
13,
13,
17,
0,
13,
17,
28,
13,
4,
13,
2,
13,
13,
0,
13,
2,
18,
13,
13,
4,
13,
2,
18,
13,
2,
2,
2,
2,
2,
13,
17,
13,
13,
17,
13,
4,
13,
2,
18,
13,
2,
13,
17,
18,
13,
2,
2,
2,
13,
13,
17,
13,
0,
13,
4,
13,
2,
13,
13,
4,
13,
13,
10,
2,
13,
10,
2,
13,
10,
17,
13,
10,
4,
13,
10,
4,
13,
10,
12,
13,
10,
2,
13,
10,
4,
13,
10,
4,
13,
10,
4,
13,
10,
2,
13,
10,
2,
13
] | [
[
256,
2
],
[
256,
11
],
[
256,
12
],
[
256,
13
],
[
25,
18
],
[
25,
25
],
[
247,
27
],
[
251,
30
],
[
254,
31
],
[
229,
34
],
[
248,
38
],
[
232,
40
],
[
248,
44
],
[
49,
46
],
[
230,
47
],
[
52,
51
],
[
248,
55
],
[
60,
57
],
[
230,
58
],
[
51,
59
],
[
245,
61
],
[
230,
64
],
[
51,
66
],
[
51,
68
],
[
75,
70
],
[
233,
71
],
[
248,
73
],
[
230,
78
],
[
248,
80
],
[
94,
93
],
[
248,
97
],
[
105,
102
],
[
233,
103
],
[
93,
104
],
[
245,
106
],
[
233,
109
],
[
93,
111
],
[
93,
114
],
[
120,
117
],
[
233,
118
],
[
259,
122
],
[
254,
127
],
[
239,
128
],
[
131,
130
],
[
254,
134
],
[
239,
135
],
[
140,
137
],
[
260,
138
],
[
130,
139
],
[
245,
141
],
[
230,
144
],
[
251,
149
],
[
257,
150
],
[
130,
152
],
[
239,
153
],
[
245,
155
],
[
233,
158
],
[
239,
160
],
[
130,
161
],
[
233,
163
],
[
251,
166
],
[
257,
167
],
[
235,
170
],
[
174,
173
],
[
254,
177
],
[
239,
178
],
[
262,
180
],
[
137,
182
],
[
260,
183
],
[
173,
184
],
[
245,
186
],
[
230,
189
],
[
257,
195
],
[
254,
197
],
[
239,
198
],
[
173,
200
],
[
245,
202
],
[
233,
205
],
[
257,
207
],
[
233,
210
],
[
254,
214
],
[
239,
215
],
[
173,
217
],
[
241,
219
],
[
245,
221
],
[
236,
223
],
[
242,
223
],
[
263,
224
],
[
242,
227
],
[
236,
227
],
[
229,
230
],
[
232,
233
],
[
235,
236
],
[
256,
239
],
[
241,
242
],
[
247,
248
],
[
256,
251
],
[
256,
254
],
[
256,
257
],
[
259,
260
],
[
262,
263
]
] | [
"H, W, A, B = map(int, input().split())\n\n# H行W列 左下から縦A横B\n\ndef mod(num):\n return num % (10 ** 9 + 7)\n \nn = H + W + 1\n\nfac = [0] * n\nrev = [0] * n\n\nfac[0] = 1\n\nfor i in range(1, n):\n fac[i] = mod(fac[i-1] * i)\n\n\n# 逆元の計算 x**(-1) ≡ x**(10**9 + 5) (mod 10**9 + 7)\nrev[n-1] = pow(fac[n-1], 10**9 + 5, 10**9 + 7)\n\nfor i in range(n - 2, 0, -1):\n rev[i] = mod(rev[i + 1] * (i + 1))\n\nrev[0] = 1\n\nt1 = [0] * (W - B)\n\nfor i in range(W - B):\n t1[i] = mod(fac[H - A - 1 + i + B] * mod(rev[B + i] * rev[H - A - 1]))\n \nres = 0\n\nfor i in range(W - B):\n r = t1[i] * mod(fac[A - 1 + W - B - 1 - i] * mod(rev[A - 1] * rev[W - B - 1 - i]))\n res = mod(res + r)\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",
"def mod(num):\n return num % (10 ** 9 + 7)\n ",
"mod",
"return num % (10 ** 9 + 7)",
"num % (10 ** 9 + 7)",
"num",
"10 ** 9 + 7",
"10 ** 9",
"10",
"9",
"7",
"num",
"num",
"n = H + W + 1",
"n",
"H + W + 1",
"H + W",
"H",
"W",
"1",
"fac = [0] * n",
"fac",
"[0] * n",
"[0]",
"0",
"n",
"rev = [0] * n",
"rev",
"[0] * n",
"[0]",
"0",
"n",
"fac[0] = 1",
"fac[0]",
"fac",
"0",
"1",
"for i in range(1, n):\n fac[i] = mod(fac[i-1] * i)\n\n\n# 逆元の計算 x**(-1) ≡ x**(10**9 + 5) (mod 10**9 + 7)",
"i",
"range(1, n)",
"range",
"1",
"n",
"fac[i] = mod(fac[i-1] * i)",
"fac[i]",
"fac",
"i",
"mod(fac[i-1] * i)",
"mod",
"fac[i-1] * i",
"fac[i-1]",
"fac",
"i-1",
"i",
"1",
"i",
"rev[n-1] = pow(fac[n-1], 10**9 + 5, 10**9 + 7)",
"rev[n-1]",
"rev",
"n-1",
"n",
"1",
"pow(fac[n-1], 10**9 + 5, 10**9 + 7)",
"pow",
"fac[n-1]",
"fac",
"n-1",
"n",
"1",
"10**9 + 5",
"10**9",
"10",
"9",
"5",
"10**9 + 7",
"10**9",
"10",
"9",
"7",
"for i in range(n - 2, 0, -1):\n rev[i] = mod(rev[i + 1] * (i + 1))",
"i",
"range(n - 2, 0, -1)",
"range",
"n - 2",
"n",
"2",
"0",
"-1",
"rev[i] = mod(rev[i + 1] * (i + 1))",
"rev[i]",
"rev",
"i",
"mod(rev[i + 1] * (i + 1))",
"mod",
"rev[i + 1] * (i + 1)",
"rev[i + 1]",
"rev",
"i + 1",
"i",
"1",
"i + 1",
"i",
"1",
"rev[0] = 1",
"rev[0]",
"rev",
"0",
"1",
"t1 = [0] * (W - B)",
"t1",
"[0] * (W - B)",
"[0]",
"0",
"W - B",
"W",
"B",
"for i in range(W - B):\n t1[i] = mod(fac[H - A - 1 + i + B] * mod(rev[B + i] * rev[H - A - 1]))\n ",
"i",
"range(W - B)",
"range",
"W - B",
"W",
"B",
"t1[i] = mod(fac[H - A - 1 + i + B] * mod(rev[B + i] * rev[H - A - 1]))",
"t1[i]",
"t1",
"i",
"mod(fac[H - A - 1 + i + B] * mod(rev[B + i] * rev[H - A - 1]))",
"mod",
"fac[H - A - 1 + i + B] * mod(rev[B + i] * rev[H - A - 1])",
"fac[H - A - 1 + i + B]",
"fac",
"H - A - 1 + i + B",
"H - A - 1 + i",
"H - A - 1",
"H - A",
"H",
"A",
"1",
"i",
"B",
"mod(rev[B + i] * rev[H - A - 1])",
"mod",
"rev[B + i] * rev[H - A - 1]",
"rev[B + i]",
"rev",
"B + i",
"B",
"i",
"rev[H - A - 1]",
"rev",
"H - A - 1",
"H - A",
"H",
"A",
"1",
"res = 0",
"res",
"0",
"for i in range(W - B):\n r = t1[i] * mod(fac[A - 1 + W - B - 1 - i] * mod(rev[A - 1] * rev[W - B - 1 - i]))\n res = mod(res + r)\n ",
"i",
"range(W - B)",
"range",
"W - B",
"W",
"B",
"r = t1[i] * mod(fac[A - 1 + W - B - 1 - i] * mod(rev[A - 1] * rev[W - B - 1 - i]))",
"r",
"t1[i] * mod(fac[A - 1 + W - B - 1 - i] * mod(rev[A - 1] * rev[W - B - 1 - i]))",
"t1[i]",
"t1",
"i",
"mod(fac[A - 1 + W - B - 1 - i] * mod(rev[A - 1] * rev[W - B - 1 - i]))",
"mod",
"fac[A - 1 + W - B - 1 - i] * mod(rev[A - 1] * rev[W - B - 1 - i])",
"fac[A - 1 + W - B - 1 - i]",
"fac",
"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",
"mod(rev[A - 1] * rev[W - B - 1 - i])",
"mod",
"rev[A - 1] * rev[W - B - 1 - i]",
"rev[A - 1]",
"rev",
"A - 1",
"A",
"1",
"rev[W - B - 1 - i]",
"rev",
"W - B - 1 - i",
"W - B - 1",
"W - B",
"W",
"B",
"1",
"i",
"res = mod(res + r)",
"res",
"mod(res + r)",
"mod",
"res + r",
"res",
"r",
"print(res)",
"print",
"res",
"fac = [0] * n",
"[0] * n",
"fac",
"rev = [0] * n",
"[0] * n",
"rev",
"res = 0",
"0",
"res",
"B = map(int, input().split())",
"map(int, input().split())",
"B",
"res = mod(res + r)",
"mod(res + r)",
"res",
"def mod(num):\n return num % (10 ** 9 + 7)\n ",
"def mod(num):\n return num % (10 ** 9 + 7)\n ",
"mod",
"n = H + W + 1",
"H + W + 1",
"n",
"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",
"A, B = map(int, input().split())",
"map(int, input().split())",
"A",
"t1 = [0] * (W - B)",
"[0] * (W - B)",
"t1",
"r = t1[i] * mod(fac[A - 1 + W - B - 1 - i] * mod(rev[A - 1] * rev[W - B - 1 - i]))",
"t1[i] * mod(fac[A - 1 + W - B - 1 - i] * mod(rev[A - 1] * rev[W - B - 1 - i]))",
"r"
] | H, W, A, B = map(int, input().split())
# H行W列 左下から縦A横B
def mod(num):
return num % (10 ** 9 + 7)
n = H + W + 1
fac = [0] * n
rev = [0] * n
fac[0] = 1
for i in range(1, n):
fac[i] = mod(fac[i-1] * i)
# 逆元の計算 x**(-1) ≡ x**(10**9 + 5) (mod 10**9 + 7)
rev[n-1] = pow(fac[n-1], 10**9 + 5, 10**9 + 7)
for i in range(n - 2, 0, -1):
rev[i] = mod(rev[i + 1] * (i + 1))
rev[0] = 1
t1 = [0] * (W - B)
for i in range(W - B):
t1[i] = mod(fac[H - A - 1 + i + B] * mod(rev[B + i] * rev[H - A - 1]))
res = 0
for i in range(W - B):
r = t1[i] * mod(fac[A - 1 + W - B - 1 - i] * mod(rev[A - 1] * rev[W - B - 1 - i]))
res = mod(res + r)
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,
17,
0,
13,
2,
39,
17,
13,
0,
13,
2,
39,
17,
13,
0,
18,
13,
17,
17,
0,
13,
2,
2,
17,
17,
17,
28,
13,
4,
13,
17,
13,
0,
18,
13,
13,
2,
2,
18,
13,
2,
13,
17,
13,
13,
0,
18,
13,
2,
13,
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,
12,
13,
29,
2,
2,
2,
18,
13,
13,
18,
13,
2,
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,
4,
13,
2,
2,
2,
13,
2,
13,
17,
13,
17,
2,
13,
17,
4,
13,
2,
2,
2,
13,
13,
13,
17,
2,
13,
17,
0,
13,
13,
4,
13,
13,
10,
13,
13,
10,
12,
13,
10,
2,
13,
10,
4,
13,
10,
4,
13,
10,
4,
13,
10,
17,
13,
10,
2,
13,
10,
4,
13,
10,
17,
13,
10,
2,
13,
10,
2,
13,
10,
2,
13
] | [
[
203,
2
],
[
203,
11
],
[
203,
12
],
[
203,
13
],
[
185,
15
],
[
206,
22
],
[
215,
25
],
[
207,
29
],
[
186,
29
],
[
200,
31
],
[
207,
35
],
[
186,
35
],
[
40,
37
],
[
216,
38
],
[
212,
42
],
[
50,
49
],
[
207,
53
],
[
186,
53
],
[
58,
55
],
[
216,
56
],
[
49,
57
],
[
216,
61
],
[
49,
63
],
[
49,
65
],
[
213,
66
],
[
73,
68
],
[
201,
69
],
[
207,
71
],
[
186,
71
],
[
216,
76
],
[
207,
78
],
[
186,
78
],
[
213,
81
],
[
213,
83
],
[
86,
85
],
[
207,
89
],
[
186,
89
],
[
97,
94
],
[
201,
95
],
[
85,
96
],
[
201,
100
],
[
85,
102
],
[
85,
105
],
[
213,
107
],
[
216,
115
],
[
127,
116
],
[
201,
118
],
[
127,
120
],
[
129,
121
],
[
201,
123
],
[
129,
124
],
[
213,
125
],
[
127,
127
],
[
129,
129
],
[
197,
131
],
[
135,
134
],
[
192,
138
],
[
195,
141
],
[
209,
144
],
[
183,
147
],
[
204,
151
],
[
189,
153
],
[
134,
155
],
[
134,
158
],
[
183,
161
],
[
195,
165
],
[
134,
166
],
[
189,
167
],
[
189,
170
],
[
179,
173
],
[
213,
174
],
[
180,
177
],
[
210,
177
],
[
198,
177
],
[
213,
179
],
[
179,
180
],
[
185,
186
],
[
203,
189
],
[
203,
192
],
[
203,
195
],
[
197,
198
],
[
200,
201
],
[
203,
204
],
[
206,
207
],
[
209,
210
],
[
212,
213
],
[
215,
216
]
] | [
"H, W, A, B = map(int, input().split())\nM = 10 ** 5 + 5\nM *= 2\nfact = [0] * M\nrfact = [0] * M\nfact[0] = 1\nMOD = 10 ** 9 + 7\nfor i in range(1, M):\n fact[i] = fact[i - 1] * i % MOD\n\nrfact[M - 1] = pow(fact[M - 1], MOD - 2, MOD)\nfor i in range(M - 2, -1, -1):\n rfact[i] = rfact[i + 1] * (i + 1) % MOD\n\n\ndef comb(n, k):\n return fact[n] * rfact[n - k] * rfact[k] % MOD\n\n\nnum = 0\nfor i in range(B + 1, W + 1):\n num += comb(H - (A + 1) + i - 1, i - 1) * comb(W - i + A - 1, A - 1)\n num %= MOD\n\nprint(num)",
"H, W, A, B = map(int, input().split())",
"H",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"W",
"A",
"B",
"M = 10 ** 5 + 5",
"M",
"10 ** 5 + 5",
"10 ** 5",
"10",
"5",
"5",
"M *= 2",
"M",
"2",
"fact = [0] * M",
"fact",
"[0] * M",
"[0]",
"0",
"M",
"rfact = [0] * M",
"rfact",
"[0] * M",
"[0]",
"0",
"M",
"fact[0] = 1",
"fact[0]",
"fact",
"0",
"1",
"MOD = 10 ** 9 + 7",
"MOD",
"10 ** 9 + 7",
"10 ** 9",
"10",
"9",
"7",
"for i in range(1, M):\n fact[i] = fact[i - 1] * i % MOD",
"i",
"range(1, M)",
"range",
"1",
"M",
"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",
"rfact[M - 1] = pow(fact[M - 1], MOD - 2, MOD)",
"rfact[M - 1]",
"rfact",
"M - 1",
"M",
"1",
"pow(fact[M - 1], MOD - 2, MOD)",
"pow",
"fact[M - 1]",
"fact",
"M - 1",
"M",
"1",
"MOD - 2",
"MOD",
"2",
"MOD",
"for i in range(M - 2, -1, -1):\n rfact[i] = rfact[i + 1] * (i + 1) % MOD",
"i",
"range(M - 2, -1, -1)",
"range",
"M - 2",
"M",
"2",
"-1",
"-1",
"rfact[i] = rfact[i + 1] * (i + 1) % MOD",
"rfact[i]",
"rfact",
"i",
"rfact[i + 1] * (i + 1) % MOD",
"rfact[i + 1] * (i + 1)",
"rfact[i + 1]",
"rfact",
"i + 1",
"i",
"1",
"i + 1",
"i",
"1",
"MOD",
"def comb(n, k):\n return fact[n] * rfact[n - k] * rfact[k] % MOD",
"comb",
"return fact[n] * rfact[n - k] * rfact[k] % MOD",
"fact[n] * rfact[n - k] * rfact[k] % MOD",
"fact[n] * rfact[n - k] * rfact[k]",
"fact[n] * rfact[n - k]",
"fact[n]",
"fact",
"n",
"rfact[n - k]",
"rfact",
"n - k",
"n",
"k",
"rfact[k]",
"rfact",
"k",
"MOD",
"n",
"n",
"k",
"k",
"num = 0",
"num",
"0",
"for i in range(B + 1, W + 1):\n num += comb(H - (A + 1) + i - 1, i - 1) * comb(W - i + A - 1, A - 1)\n num %= MOD",
"i",
"range(B + 1, W + 1)",
"range",
"B + 1",
"B",
"1",
"W + 1",
"W",
"1",
"num += comb(H - (A + 1) + i - 1, i - 1) * comb(W - i + A - 1, A - 1)",
"num",
"comb(H - (A + 1) + i - 1, i - 1) * comb(W - i + A - 1, A - 1)",
"comb(H - (A + 1) + i - 1, i - 1)",
"comb",
"H - (A + 1) + i - 1",
"H - (A + 1) + i",
"H - (A + 1)",
"H",
"A + 1",
"A",
"1",
"i",
"1",
"i - 1",
"i",
"1",
"comb(W - i + A - 1, A - 1)",
"comb",
"W - i + A - 1",
"W - i + A",
"W - i",
"W",
"i",
"A",
"1",
"A - 1",
"A",
"1",
"num %= MOD",
"num",
"MOD",
"print(num)",
"print",
"num",
"num %= MOD",
"MOD",
"num",
"def comb(n, k):\n return fact[n] * rfact[n - k] * rfact[k] % MOD",
"def comb(n, k):\n return fact[n] * rfact[n - k] * rfact[k] % MOD",
"comb",
"M = 10 ** 5 + 5",
"10 ** 5 + 5",
"M",
"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",
"num = 0",
"0",
"num",
"rfact = [0] * M",
"[0] * M",
"rfact",
"H, W, A, B = map(int, input().split())",
"map(int, input().split())",
"H",
"M *= 2",
"2",
"M",
"num += comb(H - (A + 1) + i - 1, i - 1) * comb(W - i + A - 1, A - 1)",
"comb(H - (A + 1) + i - 1, i - 1) * comb(W - i + A - 1, A - 1)",
"num",
"MOD = 10 ** 9 + 7",
"10 ** 9 + 7",
"MOD",
"fact = [0] * M",
"[0] * M",
"fact"
] | H, W, A, B = map(int, input().split())
M = 10 ** 5 + 5
M *= 2
fact = [0] * M
rfact = [0] * M
fact[0] = 1
MOD = 10 ** 9 + 7
for i in range(1, M):
fact[i] = fact[i - 1] * i % MOD
rfact[M - 1] = pow(fact[M - 1], MOD - 2, MOD)
for i in range(M - 2, -1, -1):
rfact[i] = rfact[i + 1] * (i + 1) % MOD
def comb(n, k):
return fact[n] * rfact[n - k] * rfact[k] % MOD
num = 0
for i in range(B + 1, W + 1):
num += comb(H - (A + 1) + i - 1, i - 1) * comb(W - i + A - 1, A - 1)
num %= MOD
print(num) |
[
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,
14,
40,
40,
17,
13,
13,
29,
2,
2,
18,
13,
13,
18,
13,
13,
18,
13,
2,
13,
13,
29,
17,
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,
28,
13,
4,
13,
13,
13,
0,
13,
2,
4,
13,
2,
2,
2,
13,
13,
17,
13,
13,
4,
13,
2,
2,
2,
2,
13,
17,
13,
17,
13,
2,
2,
13,
17,
13,
0,
13,
13,
4,
13,
13,
10,
17,
13,
10,
2,
13,
10,
4,
13,
10,
2,
13,
10,
12,
13,
10,
17,
13,
10,
21,
13,
10,
21,
13,
10,
2,
13,
10,
4,
13,
10,
12,
13,
10,
4,
13,
10,
13,
13,
10,
4,
13
] | [
[
174,
2
],
[
189,
9
],
[
189,
18
],
[
189,
19
],
[
189,
20
],
[
32,
26
],
[
175,
28
],
[
175,
30
],
[
32,
32
],
[
60,
39
],
[
58,
40
],
[
58,
46
],
[
60,
49
],
[
58,
53
],
[
60,
54
],
[
58,
58
],
[
60,
60
],
[
168,
62
],
[
171,
68
],
[
165,
74
],
[
78,
77
],
[
178,
83
],
[
190,
84
],
[
159,
87
],
[
166,
90
],
[
160,
90
],
[
77,
91
],
[
175,
92
],
[
97,
94
],
[
169,
95
],
[
77,
96
],
[
160,
97
],
[
166,
97
],
[
102,
99
],
[
172,
100
],
[
77,
101
],
[
163,
103
],
[
160,
104
],
[
166,
104
],
[
150,
106
],
[
110,
109
],
[
157,
112
],
[
190,
113
],
[
153,
115
],
[
181,
118
],
[
178,
122
],
[
184,
123
],
[
109,
125
],
[
109,
126
],
[
181,
128
],
[
184,
133
],
[
190,
135
],
[
109,
137
],
[
190,
140
],
[
109,
142
],
[
186,
144
],
[
175,
145
],
[
187,
148
],
[
154,
148
],
[
151,
148
],
[
150,
151
],
[
153,
154
],
[
189,
157
],
[
159,
160
],
[
165,
166
],
[
168,
169
],
[
171,
172
],
[
174,
175
],
[
189,
178
],
[
189,
184
],
[
175,
186
],
[
186,
187
],
[
189,
190
]
] | [
"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 if 0<=r<=n:\n return fact_dic[n]*fact_inv_dic[r]*fact_inv_dic[n-r]\n else:\n return 0\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\nfor i in range(B,W):\n answer+=comb_mod(H-A-1+i,i)*comb_mod(A-1+W-1-i,W-1-i)\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 if 0<=r<=n:\n return fact_dic[n]*fact_inv_dic[r]*fact_inv_dic[n-r]\n else:\n return 0",
"comb_mod",
"if 0<=r<=n:\n return fact_dic[n]*fact_inv_dic[r]*fact_inv_dic[n-r]\n else:\n return 0",
"0<=r<=n",
"0<=r",
"0",
"r",
"n",
"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",
"return 0",
"0",
"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",
"for i in range(B,W):\n answer+=comb_mod(H-A-1+i,i)*comb_mod(A-1+W-1-i,W-1-i)\n answer%=MOD\n ",
"i",
"range(B,W)",
"range",
"B",
"W",
"answer+=comb_mod(H-A-1+i,i)*comb_mod(A-1+W-1-i,W-1-i)",
"answer",
"comb_mod(H-A-1+i,i)*comb_mod(A-1+W-1-i,W-1-i)",
"comb_mod(H-A-1+i,i)",
"comb_mod",
"H-A-1+i",
"H-A-1",
"H-A",
"H",
"A",
"1",
"i",
"i",
"comb_mod(A-1+W-1-i,W-1-i)",
"comb_mod",
"A-1+W-1-i",
"A-1+W-1",
"A-1+W",
"A-1",
"A",
"1",
"W",
"1",
"i",
"W-1-i",
"W-1",
"W",
"1",
"i",
"answer%=MOD",
"answer",
"MOD",
"print(answer)",
"print",
"answer",
"answer=0",
"0",
"answer",
"answer+=comb_mod(H-A-1+i,i)*comb_mod(A-1+W-1-i,W-1-i)",
"comb_mod(H-A-1+i,i)*comb_mod(A-1+W-1-i,W-1-i)",
"answer",
"B=map(int,input().split())",
"map(int,input().split())",
"B",
"fact_mod=(fact_mod*i)%MOD",
"(fact_mod*i)%MOD",
"fact_mod",
"def invmod(a):\n return pow(a,MOD-2,MOD)",
"def invmod(a):\n return pow(a,MOD-2,MOD)",
"invmod",
"fact_mod=1",
"1",
"fact_mod",
"fact_dic={0:1}",
"{0:1}",
"fact_dic",
"fact_inv_dic={0:1}",
"{0:1}",
"fact_inv_dic",
"MOD=10**9+7",
"10**9+7",
"MOD",
"H,W,A,B=map(int,input().split())",
"map(int,input().split())",
"H",
"def comb_mod(n,r):\n if 0<=r<=n:\n return fact_dic[n]*fact_inv_dic[r]*fact_inv_dic[n-r]\n else:\n return 0",
"def comb_mod(n,r):\n if 0<=r<=n:\n return fact_dic[n]*fact_inv_dic[r]*fact_inv_dic[n-r]\n else:\n return 0",
"comb_mod",
"A,B=map(int,input().split())",
"map(int,input().split())",
"A",
"answer%=MOD",
"MOD",
"answer",
"W,A,B=map(int,input().split())",
"map(int,input().split())",
"W"
] | 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):
if 0<=r<=n:
return fact_dic[n]*fact_inv_dic[r]*fact_inv_dic[n-r]
else:
return 0
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
for i in range(B,W):
answer+=comb_mod(H-A-1+i,i)*comb_mod(A-1+W-1-i,W-1-i)
answer%=MOD
print(answer) |
[
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,
41,
28,
13,
4,
13,
13,
4,
17,
0,
13,
13,
41,
28,
13,
4,
13,
13,
4,
17,
0,
13,
13,
0,
18,
13,
17,
17,
28,
13,
4,
13,
17,
13,
0,
18,
13,
13,
2,
2,
18,
13,
2,
13,
17,
13,
13,
0,
18,
13,
2,
13,
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,
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,
0,
13,
17,
0,
13,
17,
0,
13,
17,
0,
13,
2,
2,
2,
13,
13,
13,
17,
0,
13,
2,
2,
2,
13,
13,
13,
17,
42,
2,
40,
13,
13,
40,
13,
13,
0,
13,
2,
4,
13,
13,
2,
13,
17,
4,
13,
13,
2,
13,
13,
0,
13,
13,
0,
13,
17,
0,
13,
17,
4,
13,
13,
10,
4,
13,
10,
2,
13,
10,
2,
13,
10,
4,
13,
10,
4,
13,
10,
13,
13,
10,
17,
13,
10,
2,
13,
10,
13,
13,
10,
2,
13,
10,
17,
13,
10,
17,
13,
10,
4,
13,
10,
2,
13,
10,
17,
13,
10,
17,
13,
10,
12,
13,
10,
13,
13
] | [
[
246,
2
],
[
246,
11
],
[
246,
12
],
[
246,
13
],
[
249,
15
],
[
213,
22
],
[
211,
25
],
[
223,
26
],
[
31,
30
],
[
214,
33
],
[
234,
37
],
[
42,
41
],
[
214,
44
],
[
225,
48
],
[
54,
51
],
[
235,
52
],
[
57,
56
],
[
214,
60
],
[
65,
62
],
[
235,
63
],
[
56,
64
],
[
235,
68
],
[
56,
70
],
[
56,
72
],
[
250,
73
],
[
80,
75
],
[
226,
76
],
[
214,
78
],
[
235,
83
],
[
214,
85
],
[
250,
88
],
[
250,
90
],
[
93,
92
],
[
214,
96
],
[
104,
101
],
[
226,
102
],
[
92,
103
],
[
226,
107
],
[
92,
109
],
[
92,
112
],
[
250,
114
],
[
146,
120
],
[
144,
123
],
[
146,
124
],
[
235,
132
],
[
144,
133
],
[
226,
135
],
[
146,
136
],
[
226,
138
],
[
144,
140
],
[
146,
141
],
[
250,
142
],
[
144,
144
],
[
146,
146
],
[
243,
148
],
[
240,
151
],
[
252,
154
],
[
216,
157
],
[
211,
161
],
[
241,
162
],
[
220,
162
],
[
253,
163
],
[
247,
163
],
[
231,
166
],
[
223,
170
],
[
253,
171
],
[
247,
171
],
[
241,
172
],
[
220,
172
],
[
241,
177
],
[
220,
177
],
[
256,
177
],
[
211,
178
],
[
253,
180
],
[
247,
180
],
[
229,
180
],
[
223,
181
],
[
237,
183
],
[
259,
186
],
[
217,
187
],
[
253,
189
],
[
247,
189
],
[
229,
189
],
[
259,
192
],
[
232,
193
],
[
223,
195
],
[
253,
196
],
[
247,
196
],
[
229,
196
],
[
261,
198
],
[
250,
199
],
[
255,
201
],
[
228,
204
],
[
262,
208
],
[
238,
208
],
[
244,
208
],
[
246,
211
],
[
213,
214
],
[
216,
217
],
[
246,
220
],
[
246,
223
],
[
225,
226
],
[
228,
229
],
[
231,
232
],
[
234,
235
],
[
237,
238
],
[
240,
241
],
[
243,
244
],
[
246,
247
],
[
249,
250
],
[
252,
253
],
[
255,
256
],
[
250,
261
],
[
261,
262
]
] | [
"h, w, a, b = map(int, input().split())\n\nMOD = 10 ** 9 + 7\nN = h + w + 10\nfact = [0 for _ in range(N)]\ninvfact = [0 for _ in range(N)]\nfact[0] = 1\nfor i in range(1, N):\n fact[i] = fact[i - 1] * i % MOD\n\ninvfact[N - 1] = pow(fact[N - 1], MOD - 2, MOD)\n\nfor i in range(N - 2, -1, -1):\n invfact[i] = invfact[i + 1] * (i + 1) % MOD\ndef nCk(n, k):\n if k < 0 or n < k:\n return 0\n else:\n return fact[n] * invfact[k] * invfact[n - k] % MOD\n \nans = 0\na += 1\nb += 1\nn = h - a + b - 1\nn2 = w - b + a - 1\nwhile a <= h and b <= w:\n ans += nCk(n, b - 1) * nCk(n2, w - b)\n ans %= MOD\n a += 1\n b += 1\nprint(ans)",
"h, w, a, b = map(int, input().split())",
"h",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"w",
"a",
"b",
"MOD = 10 ** 9 + 7",
"MOD",
"10 ** 9 + 7",
"10 ** 9",
"10",
"9",
"7",
"N = h + w + 10",
"N",
"h + w + 10",
"h + w",
"h",
"w",
"10",
"0 for _ in range(N)",
"for _ in range(N)",
"_",
"range(N)",
"range",
"N",
"for _ in range(N)",
"0",
"fact = [0 for _ in range(N)]",
"fact",
"[0 for _ in range(N)]",
"0 for _ in range(N)",
"for _ in range(N)",
"_",
"range(N)",
"range",
"N",
"for _ in range(N)",
"0",
"invfact = [0 for _ in range(N)]",
"invfact",
"[0 for _ in range(N)]",
"fact[0] = 1",
"fact[0]",
"fact",
"0",
"1",
"for i in range(1, N):\n fact[i] = fact[i - 1] * i % MOD",
"i",
"range(1, N)",
"range",
"1",
"N",
"fact[i] = fact[i - 1] * i % MOD",
"fact[i]",
"fact",
"i",
"fact[i - 1] * i % MOD",
"fact[i - 1] * i",
"fact[i - 1]",
"fact",
"i - 1",
"i",
"1",
"i",
"MOD",
"invfact[N - 1] = pow(fact[N - 1], MOD - 2, MOD)",
"invfact[N - 1]",
"invfact",
"N - 1",
"N",
"1",
"pow(fact[N - 1], MOD - 2, MOD)",
"pow",
"fact[N - 1]",
"fact",
"N - 1",
"N",
"1",
"MOD - 2",
"MOD",
"2",
"MOD",
"for i in range(N - 2, -1, -1):\n invfact[i] = invfact[i + 1] * (i + 1) % MOD",
"i",
"range(N - 2, -1, -1)",
"range",
"N - 2",
"N",
"2",
"-1",
"-1",
"invfact[i] = invfact[i + 1] * (i + 1) % MOD",
"invfact[i]",
"invfact",
"i",
"invfact[i + 1] * (i + 1) % MOD",
"invfact[i + 1] * (i + 1)",
"invfact[i + 1]",
"invfact",
"i + 1",
"i",
"1",
"i + 1",
"i",
"1",
"MOD",
"def nCk(n, k):\n if k < 0 or n < k:\n return 0\n else:\n return fact[n] * invfact[k] * invfact[n - k] % MOD\n ",
"nCk",
"if k < 0 or n < k:\n return 0\n else:\n return fact[n] * invfact[k] * invfact[n - k] % MOD\n ",
"k < 0 or n < k",
"k < 0",
"k",
"0",
"n < k",
"n",
"k",
"return 0",
"0",
"return fact[n] * invfact[k] * invfact[n - k] % MOD",
"fact[n] * invfact[k] * invfact[n - k] % MOD",
"fact[n] * invfact[k] * invfact[n - k]",
"fact[n] * invfact[k]",
"fact[n]",
"fact",
"n",
"invfact[k]",
"invfact",
"k",
"invfact[n - k]",
"invfact",
"n - k",
"n",
"k",
"MOD",
"n",
"n",
"k",
"k",
"ans = 0",
"ans",
"0",
"a += 1",
"a",
"1",
"b += 1",
"b",
"1",
"n = h - a + b - 1",
"n",
"h - a + b - 1",
"h - a + b",
"h - a",
"h",
"a",
"b",
"1",
"n2 = w - b + a - 1",
"n2",
"w - b + a - 1",
"w - b + a",
"w - b",
"w",
"b",
"a",
"1",
"while a <= h and b <= w:\n ans += nCk(n, b - 1) * nCk(n2, w - b)\n ans %= MOD\n a += 1\n b += 1",
"a <= h and b <= w",
"a <= h",
"a",
"h",
"b <= w",
"b",
"w",
"ans += nCk(n, b - 1) * nCk(n2, w - b)",
"ans",
"nCk(n, b - 1) * nCk(n2, w - b)",
"nCk(n, b - 1)",
"nCk",
"n",
"b - 1",
"b",
"1",
"nCk(n2, w - b)",
"nCk",
"n2",
"w - b",
"w",
"b",
"ans %= MOD",
"ans",
"MOD",
"a += 1",
"a",
"1",
"b += 1",
"b",
"1",
"print(ans)",
"print",
"ans",
"h, w, a, b = map(int, input().split())",
"map(int, input().split())",
"h",
"N = h + w + 10",
"h + w + 10",
"N",
"n = h - a + b - 1",
"h - a + b - 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",
"invfact = [0 for _ in range(N)]",
"[0 for _ in range(N)]",
"invfact",
"b += 1",
"1",
"b",
"n2 = w - b + a - 1",
"w - b + a - 1",
"n2",
"fact = [0 for _ in range(N)]",
"[0 for _ in range(N)]",
"fact",
"ans += nCk(n, b - 1) * nCk(n2, w - b)",
"nCk(n, b - 1) * nCk(n2, w - b)",
"ans",
"a += 1",
"1",
"a",
"ans = 0",
"0",
"ans",
"b = map(int, input().split())",
"map(int, input().split())",
"b",
"MOD = 10 ** 9 + 7",
"10 ** 9 + 7",
"MOD",
"b += 1",
"1",
"b",
"a += 1",
"1",
"a",
"def nCk(n, k):\n if k < 0 or n < k:\n return 0\n else:\n return fact[n] * invfact[k] * invfact[n - k] % MOD\n ",
"def nCk(n, k):\n if k < 0 or n < k:\n return 0\n else:\n return fact[n] * invfact[k] * invfact[n - k] % MOD\n ",
"nCk",
"ans %= MOD",
"MOD",
"ans"
] | h, w, a, b = map(int, input().split())
MOD = 10 ** 9 + 7
N = h + w + 10
fact = [0 for _ in range(N)]
invfact = [0 for _ in range(N)]
fact[0] = 1
for i in range(1, N):
fact[i] = fact[i - 1] * i % MOD
invfact[N - 1] = pow(fact[N - 1], MOD - 2, MOD)
for i in range(N - 2, -1, -1):
invfact[i] = invfact[i + 1] * (i + 1) % MOD
def nCk(n, k):
if k < 0 or n < k:
return 0
else:
return fact[n] * invfact[k] * invfact[n - k] % MOD
ans = 0
a += 1
b += 1
n = h - a + b - 1
n2 = w - b + a - 1
while a <= h and b <= w:
ans += nCk(n, b - 1) * nCk(n2, w - b)
ans %= MOD
a += 1
b += 1
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,
28,
13,
4,
13,
13,
13,
14,
2,
13,
13,
0,
13,
2,
4,
13,
2,
2,
2,
13,
13,
17,
13,
13,
4,
13,
2,
2,
2,
13,
13,
17,
13,
2,
2,
13,
17,
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,
4,
13,
2,
2,
2,
13,
13,
17,
13,
2,
2,
13,
17,
13,
0,
13,
13,
4,
13,
13,
10,
2,
13,
10,
2,
13,
10,
4,
13,
10,
4,
13,
10,
2,
13,
10,
13,
13,
10,
2,
13,
10,
17,
13,
10,
2,
13,
10,
4,
13,
10,
2,
13,
10,
4,
13,
10,
12,
13
] | [
[
261,
2
],
[
261,
11
],
[
261,
12
],
[
261,
13
],
[
231,
15
],
[
252,
22
],
[
246,
29
],
[
232,
34
],
[
228,
37
],
[
232,
42
],
[
46,
45
],
[
232,
50
],
[
56,
53
],
[
247,
54
],
[
45,
55
],
[
247,
59
],
[
45,
61
],
[
45,
63
],
[
253,
64
],
[
69,
66
],
[
229,
67
],
[
232,
68
],
[
247,
72
],
[
232,
73
],
[
253,
75
],
[
253,
77
],
[
80,
79
],
[
232,
82
],
[
91,
86
],
[
229,
87
],
[
79,
89
],
[
229,
94
],
[
79,
95
],
[
79,
96
],
[
253,
97
],
[
138,
103
],
[
138,
106
],
[
136,
107
],
[
112,
111
],
[
247,
113
],
[
136,
114
],
[
117,
116
],
[
229,
118
],
[
138,
119
],
[
122,
121
],
[
253,
122
],
[
125,
124
],
[
229,
126
],
[
136,
128
],
[
138,
129
],
[
132,
131
],
[
253,
132
],
[
131,
134
],
[
124,
134
],
[
121,
134
],
[
116,
134
],
[
111,
134
],
[
136,
136
],
[
138,
138
],
[
249,
140
],
[
144,
143
],
[
262,
146
],
[
238,
147
],
[
143,
150
],
[
262,
151
],
[
240,
153
],
[
265,
156
],
[
235,
160
],
[
256,
161
],
[
143,
163
],
[
143,
164
],
[
265,
166
],
[
256,
170
],
[
238,
171
],
[
143,
173
],
[
238,
176
],
[
143,
178
],
[
258,
180
],
[
265,
184
],
[
235,
188
],
[
256,
189
],
[
143,
191
],
[
143,
192
],
[
265,
194
],
[
235,
199
],
[
256,
200
],
[
143,
202
],
[
143,
205
],
[
265,
208
],
[
256,
212
],
[
238,
213
],
[
143,
215
],
[
238,
218
],
[
143,
220
],
[
243,
222
],
[
253,
223
],
[
244,
226
],
[
259,
226
],
[
241,
226
],
[
250,
226
],
[
228,
229
],
[
231,
232
],
[
261,
235
],
[
261,
238
],
[
240,
241
],
[
253,
243
],
[
243,
244
],
[
246,
247
],
[
249,
250
],
[
252,
253
],
[
261,
256
],
[
258,
259
],
[
261,
262
]
] | [
"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)\nfor i in range(1, U+1) :\n fact[i] = (fact[i-1] * i) % MOD\nfact_inv[U] = pow(fact[U], MOD-2, MOD)\nfor i in range(U,0,-1) :\n fact_inv[i-1] = (fact_inv[i] * i) % MOD\n\ndef comb(n, k) :\n if k < 0 or k > n :\n return 0\n x = fact[n]\n x *= fact_inv[k]\n x %= MOD\n x *= fact_inv[n-k]\n x %= MOD\n return x\n\nans = 0\nfor x in range(B,W) :\n if x == B :\n ans += comb(H-A-1+x, x) * comb(A+W-1-x, W-1-x)\n else :\n ans += (comb(H-A-1+x, x) - comb(H-A-1+x-1, x-1)) * comb(A+W-1-x, W-1-x)\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",
"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 fact_inv[i-1] = (fact_inv[i] * i) % MOD",
"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",
"for x in range(B,W) :\n if x == B :\n ans += comb(H-A-1+x, x) * comb(A+W-1-x, W-1-x)\n else :\n ans += (comb(H-A-1+x, x) - comb(H-A-1+x-1, x-1)) * comb(A+W-1-x, W-1-x)\n ans %= MOD",
"x",
"range(B,W)",
"range",
"B",
"W",
"if x == B :\n ans += comb(H-A-1+x, x) * comb(A+W-1-x, W-1-x)\n else :\n ans += (comb(H-A-1+x, x) - comb(H-A-1+x-1, x-1)) * comb(A+W-1-x, W-1-x)\n ",
"x == B",
"x",
"B",
"ans += comb(H-A-1+x, x) * comb(A+W-1-x, W-1-x)",
"ans",
"comb(H-A-1+x, x) * comb(A+W-1-x, W-1-x)",
"comb(H-A-1+x, x)",
"comb",
"H-A-1+x",
"H-A-1",
"H-A",
"H",
"A",
"1",
"x",
"x",
"comb(A+W-1-x, W-1-x)",
"comb",
"A+W-1-x",
"A+W-1",
"A+W",
"A",
"W",
"1",
"x",
"W-1-x",
"W-1",
"W",
"1",
"x",
"ans += (comb(H-A-1+x, x) - comb(H-A-1+x-1, x-1)) * comb(A+W-1-x, W-1-x)",
"ans",
"(comb(H-A-1+x, x) - comb(H-A-1+x-1, x-1)) * comb(A+W-1-x, W-1-x)",
"comb(H-A-1+x, x) - comb(H-A-1+x-1, x-1)",
"comb(H-A-1+x, x)",
"comb",
"H-A-1+x",
"H-A-1",
"H-A",
"H",
"A",
"1",
"x",
"x",
"comb(H-A-1+x-1, x-1)",
"comb",
"H-A-1+x-1",
"H-A-1+x",
"H-A-1",
"H-A",
"H",
"A",
"1",
"x",
"1",
"x-1",
"x",
"1",
"comb(A+W-1-x, W-1-x)",
"comb",
"A+W-1-x",
"A+W-1",
"A+W",
"A",
"W",
"1",
"x",
"W-1-x",
"W-1",
"W",
"1",
"x",
"ans %= MOD",
"ans",
"MOD",
"print(ans)",
"print",
"ans",
"fact_inv = [1]*(U+1)",
"[1]*(U+1)",
"fact_inv",
"U = 2*(10**5)",
"2*(10**5)",
"U",
"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 += comb(H-A-1+x, x) * comb(A+W-1-x, W-1-x)",
"comb(H-A-1+x, x) * comb(A+W-1-x, W-1-x)",
"ans",
"ans %= MOD",
"MOD",
"ans",
"fact = [1]*(U+1)",
"[1]*(U+1)",
"fact",
"ans = 0",
"0",
"ans",
"MOD = 10**9 + 7",
"10**9 + 7",
"MOD",
"A,B = map(int,input().split())",
"map(int,input().split())",
"A",
"ans += (comb(H-A-1+x, x) - comb(H-A-1+x-1, x-1)) * comb(A+W-1-x, W-1-x)",
"(comb(H-A-1+x, x) - comb(H-A-1+x-1, x-1)) * comb(A+W-1-x, W-1-x)",
"ans",
"B = map(int,input().split())",
"map(int,input().split())",
"B",
"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"
] | 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
for x in range(B,W) :
if x == B :
ans += comb(H-A-1+x, x) * comb(A+W-1-x, W-1-x)
else :
ans += (comb(H-A-1+x, x) - comb(H-A-1+x-1, x-1)) * comb(A+W-1-x, W-1-x)
ans %= MOD
print(ans)
|
[
7,
15,
13,
12,
13,
0,
13,
2,
2,
17,
17,
17,
6,
13,
17,
12,
13,
0,
18,
13,
13,
13,
0,
18,
13,
13,
4,
18,
13,
13,
13,
0,
18,
13,
13,
4,
18,
13,
13,
13,
18,
13,
13,
23,
13,
23,
13,
23,
13,
2,
2,
17,
17,
17,
12,
13,
29,
2,
2,
2,
2,
18,
18,
13,
13,
13,
18,
18,
13,
13,
13,
18,
13,
13,
18,
18,
13,
13,
2,
13,
13,
18,
13,
13,
23,
13,
23,
13,
23,
13,
12,
13,
0,
13,
39,
17,
0,
13,
39,
17,
28,
13,
4,
13,
17,
2,
13,
17,
4,
18,
13,
13,
2,
2,
18,
13,
2,
13,
17,
13,
18,
13,
13,
4,
18,
13,
13,
2,
2,
18,
13,
2,
13,
17,
18,
18,
13,
13,
13,
18,
13,
13,
29,
39,
13,
13,
23,
13,
23,
13,
12,
13,
0,
13,
2,
39,
17,
2,
13,
17,
0,
18,
13,
17,
17,
28,
13,
4,
13,
17,
2,
13,
17,
0,
18,
13,
13,
2,
18,
13,
13,
2,
2,
2,
18,
13,
13,
13,
18,
13,
2,
18,
13,
13,
13,
18,
13,
13,
29,
13,
23,
13,
23,
13,
0,
13,
4,
13,
2,
17,
17,
12,
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,
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,
0,
13,
13,
4,
13,
13,
14,
2,
13,
17,
4,
13,
10,
12,
13,
10,
6,
13,
10,
2,
13,
10,
4,
13,
10,
12,
13
] | [
[
285,
6
],
[
21,
18
],
[
44,
19
],
[
48,
20
],
[
48,
21
],
[
26,
23
],
[
44,
24
],
[
44,
28
],
[
46,
30
],
[
35,
32
],
[
44,
33
],
[
44,
37
],
[
46,
39
],
[
35,
40
],
[
44,
41
],
[
44,
44
],
[
46,
46
],
[
49,
48
],
[
85,
63
],
[
87,
65
],
[
85,
68
],
[
89,
70
],
[
85,
72
],
[
286,
73
],
[
85,
76
],
[
87,
79
],
[
89,
80
],
[
85,
82
],
[
286,
83
],
[
85,
85
],
[
87,
87
],
[
89,
89
],
[
94,
93
],
[
98,
97
],
[
102,
101
],
[
149,
106
],
[
93,
110
],
[
93,
115
],
[
101,
117
],
[
101,
119
],
[
147,
121
],
[
286,
122
],
[
97,
125
],
[
97,
130
],
[
101,
132
],
[
147,
136
],
[
101,
138
],
[
147,
140
],
[
286,
141
],
[
147,
147
],
[
149,
149
],
[
154,
153
],
[
203,
158
],
[
164,
161
],
[
153,
162
],
[
167,
166
],
[
203,
171
],
[
177,
174
],
[
153,
175
],
[
166,
176
],
[
201,
179
],
[
286,
180
],
[
201,
185
],
[
286,
186
],
[
166,
187
],
[
153,
189
],
[
201,
192
],
[
286,
193
],
[
166,
194
],
[
201,
196
],
[
286,
197
],
[
153,
199
],
[
201,
201
],
[
203,
203
],
[
288,
205
],
[
215,
214
],
[
280,
221
],
[
215,
223
],
[
215,
224
],
[
215,
225
],
[
228,
227
],
[
231,
230
],
[
214,
236
],
[
224,
237
],
[
241,
240
],
[
289,
243
],
[
230,
246
],
[
225,
247
],
[
230,
250
],
[
289,
253
],
[
214,
258
],
[
230,
259
],
[
223,
260
],
[
225,
261
],
[
214,
264
],
[
230,
265
],
[
268,
267
],
[
286,
268
],
[
267,
271
],
[
240,
271
],
[
227,
271
],
[
292,
277
],
[
285,
286
],
[
288,
289
]
] | [
"import sys\ndef input(): return sys.stdin.readline().strip()\nmod = 10**9+7\n\nclass Combination:\n \"\"\"\n O(n)の前計算を1回行うことで，O(1)でnCr mod mを求められる\n n_max = 10**6のとき前処理は約950ms (PyPyなら約340ms, 10**7で約1800ms)\n 使用例：\n comb = Combination(1000000)\n print(comb(5, 3)) # 10\n \"\"\"\n def __init__(self, n_max, mod=10**9+7):\n self.mod = mod\n self.modinv = self.make_modinv_list(n_max)\n self.fac, self.facinv = self.make_factorial_list(n_max)\n\n def __call__(self, n, r):\n return self.fac[n] * self.facinv[r] % self.mod * self.facinv[n-r] % self.mod\n\n def make_factorial_list(self, n):\n # 階乗のリストと階乗のmod逆元のリストを返す O(n)\n # self.make_modinv_list()が先に実行されている必要がある\n fac = [1]\n facinv = [1]\n for i in range(1, n+1):\n fac.append(fac[i-1] * i % self.mod)\n facinv.append(facinv[i-1] * self.modinv[i] % self.mod)\n return fac, facinv\n\n def make_modinv_list(self, n):\n # 0からnまでのmod逆元のリストを返す O(n)\n modinv = [0] * (n+1)\n modinv[1] = 1\n for i in range(2, n+1):\n modinv[i] = self.mod - self.mod//i * modinv[self.mod%i] % self.mod\n return modinv\n\ncomb = Combination(10**6)\n\ndef main():\n H, W, A, B = map(int, input().split())\n ans = 0\n for i in range(1, H - A + 1):\n ans += comb(i + B - 2, i - 1) * comb(H - i + W - B - 1, H - i)\n ans %= mod\n print(ans)\n\n\nif __name__ == \"__main__\":\n main()",
"import sys",
"sys",
"def input(): return sys.stdin.readline().strip()",
"input",
"mod = 10**9+7",
"mod",
"10**9+7",
"10**9",
"10",
"9",
"7",
"class Combination:\n \"\"\"\n O(n)の前計算を1回行うことで，O(1)でnCr mod mを求められる\n n_max = 10**6のとき前処理は約950ms (PyPyなら約340ms, 10**7で約1800ms)\n 使用例：\n comb = Combination(1000000)\n print(comb(5, 3)) # 10\n \"\"\"\n def __init__(self, n_max, mod=10**9+7):\n self.mod = mod\n self.modinv = self.make_modinv_list(n_max)\n self.fac, self.facinv = self.make_factorial_list(n_max)\n\n def __call__(self, n, r):\n return self.fac[n] * self.facinv[r] % self.mod * self.facinv[n-r] % self.mod\n\n def make_factorial_list(self, n):\n # 階乗のリストと階乗のmod逆元のリストを返す O(n)\n # self.make_modinv_list()が先に実行されている必要がある\n fac = [1]\n facinv = [1]\n for i in range(1, n+1):\n fac.append(fac[i-1] * i % self.mod)\n facinv.append(facinv[i-1] * self.modinv[i] % self.mod)\n return fac, facinv\n\n def make_modinv_list(self, n):\n # 0からnまでのmod逆元のリストを返す O(n)\n modinv = [0] * (n+1)\n modinv[1] = 1\n for i in range(2, n+1):\n modinv[i] = self.mod - self.mod//i * modinv[self.mod%i] % self.mod\n return modinv",
"Combination",
"\"\"\"\n O(n)の前計算を1回行うことで，O(1)でnCr mod mを求められる\n n_max = 10**6のとき前処理は約950ms (PyPyなら約340ms, 10**7で約1800ms)\n 使用例：\n comb = Combination(1000000)\n print(comb(5, 3)) # 10\n \"\"\"",
"def __init__(self, n_max, mod=10**9+7):\n self.mod = mod\n self.modinv = self.make_modinv_list(n_max)\n self.fac, self.facinv = self.make_factorial_list(n_max)\n\n ",
"__init__",
"self.mod = mod",
"self.mod",
"self",
"mod",
"mod",
"self.modinv = self.make_modinv_list(n_max)",
"self.modinv",
"self",
"modinv",
"self.make_modinv_list(n_max)",
"self.make_modinv_list",
"self",
"make_modinv_list",
"n_max",
"self.fac, self.facinv = self.make_factorial_list(n_max)",
"self.fac",
"self",
"fac",
"self.make_factorial_list(n_max)",
"self.make_factorial_list",
"self",
"make_factorial_list",
"n_max",
"self.facinv",
"self",
"facinv",
"self",
"self",
"n_max",
"n_max",
"mod=10**9+7",
"mod",
"10**9+7",
"10**9",
"10",
"9",
"7",
"def __call__(self, n, r):\n return self.fac[n] * self.facinv[r] % self.mod * self.facinv[n-r] % self.mod\n\n ",
"__call__",
"return self.fac[n] * self.facinv[r] % self.mod * self.facinv[n-r] % self.mod",
"self.fac[n] * self.facinv[r] % self.mod * self.facinv[n-r] % self.mod",
"self.fac[n] * self.facinv[r] % self.mod * self.facinv[n-r]",
"self.fac[n] * self.facinv[r] % self.mod",
"self.fac[n] * self.facinv[r]",
"self.fac[n]",
"self.fac",
"self",
"fac",
"n",
"self.facinv[r]",
"self.facinv",
"self",
"facinv",
"r",
"self.mod",
"self",
"mod",
"self.facinv[n-r]",
"self.facinv",
"self",
"facinv",
"n-r",
"n",
"r",
"self.mod",
"self",
"mod",
"self",
"self",
"n",
"n",
"r",
"r",
"def make_factorial_list(self, n):\n # 階乗のリストと階乗のmod逆元のリストを返す O(n)\n # self.make_modinv_list()が先に実行されている必要がある\n fac = [1]\n facinv = [1]\n for i in range(1, n+1):\n fac.append(fac[i-1] * i % self.mod)\n facinv.append(facinv[i-1] * self.modinv[i] % self.mod)\n return fac, facinv\n\n ",
"make_factorial_list",
"fac = [1]",
"fac",
"[1]",
"1",
"facinv = [1]",
"facinv",
"[1]",
"1",
"for i in range(1, n+1):\n fac.append(fac[i-1] * i % self.mod)\n facinv.append(facinv[i-1] * self.modinv[i] % self.mod)\n ",
"i",
"range(1, n+1)",
"range",
"1",
"n+1",
"n",
"1",
"fac.append(fac[i-1] * i % self.mod)",
"fac.append",
"fac",
"append",
"fac[i-1] * i % self.mod",
"fac[i-1] * i",
"fac[i-1]",
"fac",
"i-1",
"i",
"1",
"i",
"self.mod",
"self",
"mod",
"facinv.append(facinv[i-1] * self.modinv[i] % self.mod)",
"facinv.append",
"facinv",
"append",
"facinv[i-1] * self.modinv[i] % self.mod",
"facinv[i-1] * self.modinv[i]",
"facinv[i-1]",
"facinv",
"i-1",
"i",
"1",
"self.modinv[i]",
"self.modinv",
"self",
"modinv",
"i",
"self.mod",
"self",
"mod",
"return fac, facinv",
"return fac, facinv",
"fac",
"facinv",
"self",
"self",
"n",
"n",
"def make_modinv_list(self, n):\n # 0からnまでのmod逆元のリストを返す O(n)\n modinv = [0] * (n+1)\n modinv[1] = 1\n for i in range(2, n+1):\n modinv[i] = self.mod - self.mod//i * modinv[self.mod%i] % self.mod\n return modinv",
"make_modinv_list",
"modinv = [0] * (n+1)",
"modinv",
"[0] * (n+1)",
"[0]",
"0",
"n+1",
"n",
"1",
"modinv[1] = 1",
"modinv[1]",
"modinv",
"1",
"1",
"for i in range(2, n+1):\n modinv[i] = self.mod - self.mod//i * modinv[self.mod%i] % self.mod\n ",
"i",
"range(2, n+1)",
"range",
"2",
"n+1",
"n",
"1",
"modinv[i] = self.mod - self.mod//i * modinv[self.mod%i] % self.mod",
"modinv[i]",
"modinv",
"i",
"self.mod - self.mod//i * modinv[self.mod%i] % self.mod",
"self.mod",
"self",
"mod",
"self.mod//i * modinv[self.mod%i] % self.mod",
"self.mod//i * modinv[self.mod%i]",
"self.mod//i",
"self.mod",
"self",
"mod",
"i",
"modinv[self.mod%i]",
"modinv",
"self.mod%i",
"self.mod",
"self",
"mod",
"i",
"self.mod",
"self",
"mod",
"return modinv",
"modinv",
"self",
"self",
"n",
"n",
"comb = Combination(10**6)",
"comb",
"Combination(10**6)",
"Combination",
"10**6",
"10",
"6",
"def main():\n H, W, A, B = map(int, input().split())\n ans = 0\n for i in range(1, H - A + 1):\n ans += comb(i + B - 2, i - 1) * comb(H - i + W - B - 1, H - i)\n ans %= mod\n print(ans)",
"main",
"H, W, A, B = map(int, input().split())",
"H",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"W",
"A",
"B",
"ans = 0",
"ans",
"0",
"for i in range(1, H - A + 1):\n ans += comb(i + B - 2, i - 1) * comb(H - i + W - B - 1, H - i)\n ans %= mod\n ",
"i",
"range(1, H - A + 1)",
"range",
"1",
"H - A + 1",
"H - A",
"H",
"A",
"1",
"ans += comb(i + B - 2, i - 1) * comb(H - i + W - B - 1, H - i)",
"ans",
"comb(i + B - 2, i - 1) * comb(H - i + W - B - 1, H - i)",
"comb(i + B - 2, i - 1)",
"comb",
"i + B - 2",
"i + B",
"i",
"B",
"2",
"i - 1",
"i",
"1",
"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 %= mod",
"ans",
"mod",
"print(ans)",
"print",
"ans",
"if __name__ == \"__main__\":\n main()",
"__name__ == \"__main__\"",
"__name__",
"\"__main__\"",
"main()",
"main",
"def input(): return sys.stdin.readline().strip()",
"def input(): return sys.stdin.readline().strip()",
"input",
"class Combination:\n \"\"\"\n O(n)の前計算を1回行うことで，O(1)でnCr mod mを求められる\n n_max = 10**6のとき前処理は約950ms (PyPyなら約340ms, 10**7で約1800ms)\n 使用例：\n comb = Combination(1000000)\n print(comb(5, 3)) # 10\n \"\"\"\n def __init__(self, n_max, mod=10**9+7):\n self.mod = mod\n self.modinv = self.make_modinv_list(n_max)\n self.fac, self.facinv = self.make_factorial_list(n_max)\n\n def __call__(self, n, r):\n return self.fac[n] * self.facinv[r] % self.mod * self.facinv[n-r] % self.mod\n\n def make_factorial_list(self, n):\n # 階乗のリストと階乗のmod逆元のリストを返す O(n)\n # self.make_modinv_list()が先に実行されている必要がある\n fac = [1]\n facinv = [1]\n for i in range(1, n+1):\n fac.append(fac[i-1] * i % self.mod)\n facinv.append(facinv[i-1] * self.modinv[i] % self.mod)\n return fac, facinv\n\n def make_modinv_list(self, n):\n # 0からnまでのmod逆元のリストを返す O(n)\n modinv = [0] * (n+1)\n modinv[1] = 1\n for i in range(2, n+1):\n modinv[i] = self.mod - self.mod//i * modinv[self.mod%i] % self.mod\n return modinv",
"class Combination:\n \"\"\"\n O(n)の前計算を1回行うことで，O(1)でnCr mod mを求められる\n n_max = 10**6のとき前処理は約950ms (PyPyなら約340ms, 10**7で約1800ms)\n 使用例：\n comb = Combination(1000000)\n print(comb(5, 3)) # 10\n \"\"\"\n 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",
"mod = 10**9+7",
"10**9+7",
"mod",
"comb = Combination(10**6)",
"Combination(10**6)",
"comb",
"def main():\n H, W, A, B = map(int, input().split())\n ans = 0\n for i in range(1, H - A + 1):\n ans += comb(i + B - 2, i - 1) * comb(H - i + W - B - 1, H - i)\n ans %= mod\n print(ans)",
"def main():\n H, W, A, B = map(int, input().split())\n ans = 0\n for i in range(1, H - A + 1):\n ans += comb(i + B - 2, i - 1) * comb(H - i + W - B - 1, H - i)\n ans %= mod\n print(ans)",
"main"
] | import sys
def input(): return sys.stdin.readline().strip()
mod = 10**9+7
class Combination:
"""
O(n)の前計算を1回行うことで，O(1)でnCr mod mを求められる
n_max = 10**6のとき前処理は約950ms (PyPyなら約340ms, 10**7で約1800ms)
使用例：
comb = Combination(1000000)
print(comb(5, 3)) # 10
"""
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
comb = Combination(10**6)
def main():
H, W, A, B = map(int, input().split())
ans = 0
for i in range(1, H - A + 1):
ans += comb(i + B - 2, i - 1) * comb(H - i + W - B - 1, H - i)
ans %= mod
print(ans)
if __name__ == "__main__":
main()
|
[
7,
41,
28,
13,
4,
18,
4,
13,
13,
4,
4,
13,
13,
0,
13,
13,
13,
13,
13,
0,
13,
2,
2,
17,
17,
17,
12,
13,
29,
4,
13,
13,
13,
13,
23,
13,
23,
13,
23,
13,
12,
13,
0,
13,
2,
39,
17,
2,
2,
13,
13,
17,
0,
18,
13,
17,
17,
0,
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,
17,
17,
0,
18,
13,
17,
17,
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,
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,
13,
2,
4,
13,
2,
2,
2,
2,
13,
13,
17,
13,
13,
2,
2,
13,
13,
17,
4,
13,
2,
2,
2,
2,
2,
13,
17,
13,
17,
13,
13,
2,
13,
17,
13,
4,
13,
13,
14,
2,
13,
17,
4,
13,
10,
13,
13,
10,
2,
13,
10,
12,
13,
10,
13,
13,
10,
13,
13,
10,
12,
13,
10,
13,
13
] | [
[
4,
3
],
[
3,
12
],
[
227,
14
],
[
227,
16
],
[
227,
17
],
[
227,
18
],
[
212,
20
],
[
35,
31
],
[
37,
32
],
[
39,
33
],
[
35,
35
],
[
37,
37
],
[
39,
39
],
[
44,
43
],
[
228,
49
],
[
210,
50
],
[
61,
53
],
[
43,
54
],
[
61,
58
],
[
43,
59
],
[
64,
63
],
[
228,
69
],
[
210,
70
],
[
76,
73
],
[
43,
74
],
[
63,
75
],
[
63,
78
],
[
43,
80
],
[
63,
82
],
[
213,
84
],
[
87,
86
],
[
228,
92
],
[
210,
93
],
[
104,
96
],
[
86,
97
],
[
104,
101
],
[
86,
102
],
[
107,
106
],
[
228,
112
],
[
210,
113
],
[
119,
116
],
[
86,
117
],
[
106,
118
],
[
216,
120
],
[
73,
121
],
[
43,
122
],
[
106,
123
],
[
213,
125
],
[
213,
127
],
[
43,
135
],
[
147,
136
],
[
86,
138
],
[
149,
139
],
[
86,
141
],
[
147,
143
],
[
149,
144
],
[
213,
145
],
[
147,
147
],
[
149,
149
],
[
152,
151
],
[
155,
154
],
[
210,
158
],
[
219,
159
],
[
162,
161
],
[
151,
164
],
[
161,
164
],
[
129,
167
],
[
228,
172
],
[
222,
173
],
[
219,
175
],
[
154,
176
],
[
228,
179
],
[
222,
180
],
[
129,
183
],
[
222,
189
],
[
210,
191
],
[
219,
193
],
[
154,
194
],
[
222,
196
],
[
213,
198
],
[
161,
201
],
[
151,
201
],
[
225,
207
],
[
227,
210
],
[
212,
213
],
[
227,
219
],
[
227,
222
],
[
227,
228
]
] | [
"H, W, A, B = [int(_) for _ in input().split()]\np = 10 ** 9 + 7\n\n\n# 二分累乗法 で n^x % p を求める\n# pow(n,x,p) で得られるので次からはそっちつかう\ndef power(n, x, p):\n return pow(n,x,p)\n # a = n # a^(2^0), a^(2^1), ...\n # ans = 1\n # while x > 0:\n # if x & 1:\n # ans = (ans * a) % p\n # x = x >> 1\n # a = (a ** 2) % p\n # return ans\n\n\ndef solve():\n kaijo = [0] * (H + W + 1)\n kaijo[0] = kaijo[1] = 1\n for i in range(2, H + W + 1):\n kaijo[i] = (i * kaijo[i - 1]) % p\n gyaku = [0] * (H + W + 1)\n gyaku[0] = gyaku[1] = 1\n for i in range(2, H + W + 1):\n gyaku[i] = power(kaijo[i], p - 2, p)\n\n # for i in range(H + W + 1):\n # assert (kaijo[i] * gyaku[i]) % p == 1, (kaijo[i], gyaku[i])\n\n def conb(_x, _y):\n return (kaijo[_x] * gyaku[_y] * gyaku[_x - _y]) % p\n\n # h = H - A - 1\n # h2 = H - (H - A)\n ans = 0\n for i in range(W - B):\n ans = (ans + conb(H - A - 1 + B + i, H - A - 1) * conb(A - 1 + W - 1 - B - i, A - 1)) % p\n # for i in range(B, W):\n # tmp1 = kaijo[h + i] * gyaku[h + i] * gyaku[h + i - max(h, i)]\n # j = W - i - 1\n # tmp2 = kaijo[h2 + j] * gyaku[h2 + j] * gyaku[h2 + j - max(h2, j)]\n # ans = (ans + tmp1 * tmp2) % p\n # print(ans)\n print(ans)\n\n\nif __name__ == '__main__':\n solve()",
"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",
"p = 10 ** 9 + 7",
"p",
"10 ** 9 + 7",
"10 ** 9",
"10",
"9",
"7",
"def power(n, x, p):\n return pow(n,x,p)\n # a = n # a^(2^0), a^(2^1), ...\n # ans = 1\n # while x > 0:\n # if x & 1:\n # ans = (ans * a) % p\n # x = x >> 1\n # a = (a ** 2) % p\n # return ans",
"power",
"return pow(n,x,p)",
"pow(n,x,p)",
"pow",
"n",
"x",
"p",
"n",
"n",
"x",
"x",
"p",
"p",
"def solve():\n kaijo = [0] * (H + W + 1)\n kaijo[0] = kaijo[1] = 1\n for i in range(2, H + W + 1):\n kaijo[i] = (i * kaijo[i - 1]) % p\n gyaku = [0] * (H + W + 1)\n gyaku[0] = gyaku[1] = 1\n for i in range(2, H + W + 1):\n gyaku[i] = power(kaijo[i], p - 2, p)\n\n # for i in range(H + W + 1):\n # assert (kaijo[i] * gyaku[i]) % p == 1, (kaijo[i], gyaku[i])\n\n def conb(_x, _y):\n return (kaijo[_x] * gyaku[_y] * gyaku[_x - _y]) % p\n\n # h = H - A - 1\n # h2 = H - (H - A)\n ans = 0\n for i in range(W - B):\n ans = (ans + conb(H - A - 1 + B + i, H - A - 1) * conb(A - 1 + W - 1 - B - i, A - 1)) % p\n # for i in range(B, W):\n # tmp1 = kaijo[h + i] * gyaku[h + i] * gyaku[h + i - max(h, i)]\n # j = W - i - 1\n # tmp2 = kaijo[h2 + j] * gyaku[h2 + j] * gyaku[h2 + j - max(h2, j)]\n # ans = (ans + tmp1 * tmp2) % p\n # print(ans)\n print(ans)",
"solve",
"kaijo = [0] * (H + W + 1)",
"kaijo",
"[0] * (H + W + 1)",
"[0]",
"0",
"H + W + 1",
"H + W",
"H",
"W",
"1",
"kaijo[0] = kaijo[1] = 1",
"kaijo[0]",
"kaijo",
"0",
"1",
"= kaijo[1] = 1",
"kaijo[1]",
"kaijo",
"1",
"1",
"for i in range(2, H + W + 1):\n kaijo[i] = (i * kaijo[i - 1]) % p\n ",
"i",
"range(2, H + W + 1)",
"range",
"2",
"H + W + 1",
"H + W",
"H",
"W",
"1",
"kaijo[i] = (i * kaijo[i - 1]) % p",
"kaijo[i]",
"kaijo",
"i",
"(i * kaijo[i - 1]) % p",
"i * kaijo[i - 1]",
"i",
"kaijo[i - 1]",
"kaijo",
"i - 1",
"i",
"1",
"p",
"gyaku = [0] * (H + W + 1)",
"gyaku",
"[0] * (H + W + 1)",
"[0]",
"0",
"H + W + 1",
"H + W",
"H",
"W",
"1",
"gyaku[0] = gyaku[1] = 1",
"gyaku[0]",
"gyaku",
"0",
"1",
"= gyaku[1] = 1",
"gyaku[1]",
"gyaku",
"1",
"1",
"for i in range(2, H + W + 1):\n gyaku[i] = power(kaijo[i], p - 2, p)\n\n # for i in range(H + W + 1):\n # assert (kaijo[i] * gyaku[i]) % p == 1, (kaijo[i], gyaku[i])\n\n ",
"i",
"range(2, H + W + 1)",
"range",
"2",
"H + W + 1",
"H + W",
"H",
"W",
"1",
"gyaku[i] = power(kaijo[i], p - 2, p)",
"gyaku[i]",
"gyaku",
"i",
"power(kaijo[i], p - 2, p)",
"power",
"kaijo[i]",
"kaijo",
"i",
"p - 2",
"p",
"2",
"p",
"def conb(_x, _y):\n return (kaijo[_x] * gyaku[_y] * gyaku[_x - _y]) % p\n\n # h = H - A - 1\n # h2 = H - (H - A)\n ",
"conb",
"return (kaijo[_x] * gyaku[_y] * gyaku[_x - _y]) % p",
"(kaijo[_x] * gyaku[_y] * gyaku[_x - _y]) % p",
"kaijo[_x] * gyaku[_y] * gyaku[_x - _y]",
"kaijo[_x] * gyaku[_y]",
"kaijo[_x]",
"kaijo",
"_x",
"gyaku[_y]",
"gyaku",
"_y",
"gyaku[_x - _y]",
"gyaku",
"_x - _y",
"_x",
"_y",
"p",
"_x",
"_x",
"_y",
"_y",
"ans = 0",
"ans",
"0",
"for i in range(W - B):\n ans = (ans + conb(H - A - 1 + B + i, H - A - 1) * conb(A - 1 + W - 1 - B - i, A - 1)) % p\n # for i in range(B, W):\n # tmp1 = kaijo[h + i] * gyaku[h + i] * gyaku[h + i - max(h, i)]\n # j = W - i - 1\n # tmp2 = kaijo[h2 + j] * gyaku[h2 + j] * gyaku[h2 + j - max(h2, j)]\n # ans = (ans + tmp1 * tmp2) % p\n # print(ans)\n ",
"i",
"range(W - B)",
"range",
"W - B",
"W",
"B",
"ans = (ans + conb(H - A - 1 + B + i, H - A - 1) * conb(A - 1 + W - 1 - B - i, A - 1)) % p",
"ans",
"(ans + conb(H - A - 1 + B + i, H - A - 1) * conb(A - 1 + W - 1 - B - i, A - 1)) % p",
"ans + conb(H - A - 1 + B + i, H - A - 1) * conb(A - 1 + W - 1 - B - i, A - 1)",
"ans",
"conb(H - A - 1 + B + i, H - A - 1) * conb(A - 1 + W - 1 - B - i, A - 1)",
"conb(H - A - 1 + B + i, H - A - 1)",
"conb",
"H - A - 1 + B + i",
"H - A - 1 + B",
"H - A - 1",
"H - A",
"H",
"A",
"1",
"B",
"i",
"H - A - 1",
"H - A",
"H",
"A",
"1",
"conb(A - 1 + W - 1 - B - i, A - 1)",
"conb",
"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",
"p",
"print(ans)",
"print",
"ans",
"if __name__ == '__main__':\n solve()",
"__name__ == '__main__'",
"__name__",
"'__main__'",
"solve()",
"solve",
"W, A, B = [int(_) for _ in input().split()]",
"[int(_) for _ in input().split()]",
"W",
"p = 10 ** 9 + 7",
"10 ** 9 + 7",
"p",
"def power(n, x, p):\n return pow(n,x,p)\n # a = n # a^(2^0), a^(2^1), ...\n # ans = 1\n # while x > 0:\n # if x & 1:\n # ans = (ans * a) % p\n # x = x >> 1\n # a = (a ** 2) % p\n # return ans",
"def power(n, x, p):\n return pow(n,x,p)\n # a = n # a^(2^0), a^(2^1), ...\n # ans = 1\n # while x > 0:\n # if x & 1:\n # ans = (ans * a) % p\n # x = x >> 1\n # a = (a ** 2) % p\n # return ans",
"power",
"B = [int(_) for _ in input().split()]",
"[int(_) for _ in input().split()]",
"B",
"A, B = [int(_) for _ in input().split()]",
"[int(_) for _ in input().split()]",
"A",
"def solve():\n kaijo = [0] * (H + W + 1)\n kaijo[0] = kaijo[1] = 1\n for i in range(2, H + W + 1):\n kaijo[i] = (i * kaijo[i - 1]) % p\n gyaku = [0] * (H + W + 1)\n gyaku[0] = gyaku[1] = 1\n for i in range(2, H + W + 1):\n gyaku[i] = power(kaijo[i], p - 2, p)\n\n # for i in range(H + W + 1):\n # assert (kaijo[i] * gyaku[i]) % p == 1, (kaijo[i], gyaku[i])\n\n def conb(_x, _y):\n return (kaijo[_x] * gyaku[_y] * gyaku[_x - _y]) % p\n\n # h = H - A - 1\n # h2 = H - (H - A)\n ans = 0\n for i in range(W - B):\n ans = (ans + conb(H - A - 1 + B + i, H - A - 1) * conb(A - 1 + W - 1 - B - i, A - 1)) % p\n # for i in range(B, W):\n # tmp1 = kaijo[h + i] * gyaku[h + i] * gyaku[h + i - max(h, i)]\n # j = W - i - 1\n # tmp2 = kaijo[h2 + j] * gyaku[h2 + j] * gyaku[h2 + j - max(h2, j)]\n # ans = (ans + tmp1 * tmp2) % p\n # print(ans)\n print(ans)",
"def solve():\n kaijo = [0] * (H + W + 1)\n kaijo[0] = kaijo[1] = 1\n for i in range(2, H + W + 1):\n kaijo[i] = (i * kaijo[i - 1]) % p\n gyaku = [0] * (H + W + 1)\n gyaku[0] = gyaku[1] = 1\n for i in range(2, H + W + 1):\n gyaku[i] = power(kaijo[i], p - 2, p)\n\n # for i in range(H + W + 1):\n # assert (kaijo[i] * gyaku[i]) % p == 1, (kaijo[i], gyaku[i])\n\n def conb(_x, _y):\n return (kaijo[_x] * gyaku[_y] * gyaku[_x - _y]) % p\n\n # h = H - A - 1\n # h2 = H - (H - A)\n ans = 0\n for i in range(W - B):\n ans = (ans + conb(H - A - 1 + B + i, H - A - 1) * conb(A - 1 + W - 1 - B - i, A - 1)) % p\n # for i in range(B, W):\n # tmp1 = kaijo[h + i] * gyaku[h + i] * gyaku[h + i - max(h, i)]\n # j = W - i - 1\n # tmp2 = kaijo[h2 + j] * gyaku[h2 + j] * gyaku[h2 + j - max(h2, j)]\n # ans = (ans + tmp1 * tmp2) % p\n # print(ans)\n print(ans)",
"solve",
"H, W, A, B = [int(_) for _ in input().split()]",
"[int(_) for _ in input().split()]",
"H"
] | H, W, A, B = [int(_) for _ in input().split()]
p = 10 ** 9 + 7
# 二分累乗法 で n^x % p を求める
# pow(n,x,p) で得られるので次からはそっちつかう
def power(n, x, p):
return pow(n,x,p)
# a = n # a^(2^0), a^(2^1), ...
# ans = 1
# while x > 0:
# if x & 1:
# ans = (ans * a) % p
# x = x >> 1
# a = (a ** 2) % p
# return ans
def solve():
kaijo = [0] * (H + W + 1)
kaijo[0] = kaijo[1] = 1
for i in range(2, H + W + 1):
kaijo[i] = (i * kaijo[i - 1]) % p
gyaku = [0] * (H + W + 1)
gyaku[0] = gyaku[1] = 1
for i in range(2, H + W + 1):
gyaku[i] = power(kaijo[i], p - 2, p)
# for i in range(H + W + 1):
# assert (kaijo[i] * gyaku[i]) % p == 1, (kaijo[i], gyaku[i])
def conb(_x, _y):
return (kaijo[_x] * gyaku[_y] * gyaku[_x - _y]) % p
# h = H - A - 1
# h2 = H - (H - A)
ans = 0
for i in range(W - B):
ans = (ans + conb(H - A - 1 + B + i, H - A - 1) * conb(A - 1 + W - 1 - B - i, A - 1)) % p
# for i in range(B, W):
# tmp1 = kaijo[h + i] * gyaku[h + i] * gyaku[h + i - max(h, i)]
# j = W - i - 1
# tmp2 = kaijo[h2 + j] * gyaku[h2 + j] * gyaku[h2 + j - max(h2, j)]
# ans = (ans + tmp1 * tmp2) % p
# print(ans)
print(ans)
if __name__ == '__main__':
solve() |
[
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,
18,
13,
2,
13,
13,
2,
13,
2,
13,
13,
13,
4,
18,
13,
13,
2,
2,
18,
13,
17,
18,
13,
17,
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,
23,
13,
0,
13,
17,
28,
13,
4,
13,
17,
0,
13,
2,
2,
13,
13,
13,
0,
13,
2,
2,
13,
17,
13,
14,
2,
40,
17,
13,
2,
13,
13,
3,
0,
13,
2,
2,
4,
13,
2,
2,
2,
13,
13,
13,
13,
2,
13,
13,
13,
4,
13,
2,
2,
13,
13,
17,
2,
13,
17,
13,
13,
0,
13,
13,
4,
13,
13,
10,
12,
13,
10,
39,
13,
10,
4,
13,
10,
4,
13,
10,
4,
13,
10,
2,
13,
10,
39,
13,
10,
39,
13,
10,
2,
13,
10,
2,
13,
10,
4,
13,
10,
2,
13,
10,
13,
13,
10,
17,
13
] | [
[
214,
2
],
[
214,
11
],
[
214,
12
],
[
214,
13
],
[
208,
15
],
[
187,
22
],
[
205,
27
],
[
202,
32
],
[
38,
37
],
[
215,
43
],
[
197,
44
],
[
188,
48
],
[
188,
53
],
[
37,
55
],
[
209,
56
],
[
203,
59
],
[
203,
64
],
[
209,
66
],
[
37,
67
],
[
209,
69
],
[
209,
71
],
[
37,
72
],
[
209,
73
],
[
206,
76
],
[
206,
81
],
[
203,
84
],
[
209,
86
],
[
114,
91
],
[
112,
92
],
[
188,
100
],
[
112,
101
],
[
206,
103
],
[
114,
104
],
[
206,
106
],
[
112,
108
],
[
114,
109
],
[
116,
110
],
[
112,
112
],
[
114,
114
],
[
116,
116
],
[
223,
118
],
[
122,
121
],
[
199,
126
],
[
215,
129
],
[
191,
130
],
[
121,
131
],
[
211,
133
],
[
194,
136
],
[
121,
138
],
[
200,
143
],
[
212,
145
],
[
197,
146
],
[
217,
149
],
[
185,
153
],
[
215,
157
],
[
197,
158
],
[
200,
159
],
[
212,
160
],
[
215,
162
],
[
200,
163
],
[
209,
164
],
[
185,
166
],
[
200,
169
],
[
212,
170
],
[
200,
173
],
[
209,
175
],
[
209,
176
],
[
220,
178
],
[
209,
179
],
[
221,
182
],
[
218,
182
],
[
224,
182
],
[
187,
188
],
[
214,
191
],
[
214,
194
],
[
214,
197
],
[
199,
200
],
[
202,
203
],
[
205,
206
],
[
208,
209
],
[
211,
212
],
[
214,
215
],
[
217,
218
],
[
209,
220
],
[
220,
221
],
[
223,
224
]
] | [
"h,w,a,b = map(int,input().split())\n\nmod = 10**9+7 \nfact = [1,1]\nfinv = [1,1]\ninv = [0,1]\n \nfor i in range(2,h+w+5):\n fact.append((fact[-1]*i)%mod)\n inv.append((inv[mod%i]*(mod-mod//i))%mod)\n finv.append((finv[-1]*inv[-1])%mod)\n \ndef nCr(n,r,mod):\n if r > n:\n return 0\n else: \n return fact[n]*finv[r]*finv[n-r]%mod\n\nans = 0\n\nfor i in range(100000):\n x = h-a-i\n y = b+1+i\n \n if 0 >= x or y > w:\n break\n \n ans += nCr(h+w-x-y,h-x,mod)*nCr(x+y-2,x-1,mod)%mod\n 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",
"mod = 10**9+7",
"mod",
"10**9+7",
"10**9",
"10",
"9",
"7",
"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,h+w+5):\n fact.append((fact[-1]*i)%mod)\n inv.append((inv[mod%i]*(mod-mod//i))%mod)\n finv.append((finv[-1]*inv[-1])%mod)\n ",
"i",
"range(2,h+w+5)",
"range",
"2",
"h+w+5",
"h+w",
"h",
"w",
"5",
"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-mod//i))%mod)",
"inv.append",
"inv",
"append",
"(inv[mod%i]*(mod-mod//i))%mod",
"inv[mod%i]*(mod-mod//i)",
"inv[mod%i]",
"inv",
"mod%i",
"mod",
"i",
"mod-mod//i",
"mod",
"mod//i",
"mod",
"i",
"mod",
"finv.append((finv[-1]*inv[-1])%mod)",
"finv.append",
"finv",
"append",
"(finv[-1]*inv[-1])%mod",
"finv[-1]*inv[-1]",
"finv[-1]",
"finv",
"-1",
"inv[-1]",
"inv",
"-1",
"mod",
"def nCr(n,r,mod):\n if r > n:\n return 0\n else: \n return fact[n]*finv[r]*finv[n-r]%mod",
"nCr",
"if r > n:\n return 0\n else: \n return fact[n]*finv[r]*finv[n-r]%mod",
"r > n",
"r",
"n",
"return 0",
"0",
"return fact[n]*finv[r]*finv[n-r]%mod",
"fact[n]*finv[r]*finv[n-r]%mod",
"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",
"mod",
"n",
"n",
"r",
"r",
"mod",
"mod",
"ans = 0",
"ans",
"0",
"for i in range(100000):\n x = h-a-i\n y = b+1+i\n \n if 0 >= x or y > w:\n break\n \n ans += nCr(h+w-x-y,h-x,mod)*nCr(x+y-2,x-1,mod)%mod\n ans %= mod",
"i",
"range(100000)",
"range",
"100000",
"x = h-a-i",
"x",
"h-a-i",
"h-a",
"h",
"a",
"i",
"y = b+1+i",
"y",
"b+1+i",
"b+1",
"b",
"1",
"i",
"if 0 >= x or y > w:\n break\n \n ",
"0 >= x or y > w",
"0 >= x",
"0",
"x",
"y > w",
"y",
"w",
"break",
"ans += nCr(h+w-x-y,h-x,mod)*nCr(x+y-2,x-1,mod)%mod",
"ans",
"nCr(h+w-x-y,h-x,mod)*nCr(x+y-2,x-1,mod)%mod",
"nCr(h+w-x-y,h-x,mod)*nCr(x+y-2,x-1,mod)",
"nCr(h+w-x-y,h-x,mod)",
"nCr",
"h+w-x-y",
"h+w-x",
"h+w",
"h",
"w",
"x",
"y",
"h-x",
"h",
"x",
"mod",
"nCr(x+y-2,x-1,mod)",
"nCr",
"x+y-2",
"x+y",
"x",
"y",
"2",
"x-1",
"x",
"1",
"mod",
"mod",
"ans %= mod",
"ans",
"mod",
"print(ans)",
"print",
"ans",
"def nCr(n,r,mod):\n if r > n:\n return 0\n else: \n return fact[n]*finv[r]*finv[n-r]%mod",
"def nCr(n,r,mod):\n if r > n:\n return 0\n else: \n return fact[n]*finv[r]*finv[n-r]%mod",
"nCr",
"fact = [1,1]",
"[1,1]",
"fact",
"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",
"x = h-a-i",
"h-a-i",
"x",
"inv = [0,1]",
"[0,1]",
"inv",
"finv = [1,1]",
"[1,1]",
"finv",
"mod = 10**9+7",
"10**9+7",
"mod",
"y = b+1+i",
"b+1+i",
"y",
"h,w,a,b = map(int,input().split())",
"map(int,input().split())",
"h",
"ans += nCr(h+w-x-y,h-x,mod)*nCr(x+y-2,x-1,mod)%mod",
"nCr(h+w-x-y,h-x,mod)*nCr(x+y-2,x-1,mod)%mod",
"ans",
"ans %= mod",
"mod",
"ans",
"ans = 0",
"0",
"ans"
] | h,w,a,b = map(int,input().split())
mod = 10**9+7
fact = [1,1]
finv = [1,1]
inv = [0,1]
for i in range(2,h+w+5):
fact.append((fact[-1]*i)%mod)
inv.append((inv[mod%i]*(mod-mod//i))%mod)
finv.append((finv[-1]*inv[-1])%mod)
def nCr(n,r,mod):
if r > n:
return 0
else:
return fact[n]*finv[r]*finv[n-r]%mod
ans = 0
for i in range(100000):
x = h-a-i
y = b+1+i
if 0 >= x or y > w:
break
ans += nCr(h+w-x-y,h-x,mod)*nCr(x+y-2,x-1,mod)%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,
41,
28,
13,
4,
13,
2,
13,
13,
4,
17,
0,
13,
13,
41,
28,
13,
4,
13,
2,
13,
13,
4,
17,
0,
13,
13,
0,
13,
17,
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,
28,
13,
4,
13,
17,
2,
13,
13,
0,
13,
2,
2,
13,
13,
13,
0,
18,
13,
13,
13,
28,
13,
4,
13,
17,
2,
13,
13,
0,
13,
4,
13,
18,
13,
13,
2,
13,
17,
13,
0,
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,
23,
13,
0,
13,
17,
28,
13,
4,
13,
13,
13,
0,
13,
2,
2,
13,
2,
2,
4,
13,
2,
2,
2,
13,
13,
13,
17,
13,
13,
4,
13,
2,
2,
2,
13,
13,
13,
17,
2,
13,
17,
13,
13,
13,
4,
13,
13,
10,
2,
13,
10,
4,
13,
10,
4,
13,
10,
2,
13,
10,
17,
13,
10,
12,
13,
10,
13,
13,
10,
4,
13,
10,
13,
13,
10,
4,
13,
10,
17,
13,
10,
4,
13,
10,
2,
13,
10,
12,
13
] | [
[
244,
2
],
[
244,
11
],
[
244,
12
],
[
244,
13
],
[
211,
15
],
[
24,
23
],
[
233,
27
],
[
239,
28
],
[
235,
32
],
[
37,
36
],
[
233,
40
],
[
239,
41
],
[
229,
45
],
[
223,
48
],
[
94,
54
],
[
94,
61
],
[
66,
65
],
[
92,
68
],
[
94,
70
],
[
96,
72
],
[
65,
76
],
[
65,
77
],
[
96,
78
],
[
92,
82
],
[
92,
85
],
[
94,
87
],
[
96,
89
],
[
96,
90
],
[
92,
92
],
[
94,
94
],
[
96,
96
],
[
99,
98
],
[
233,
103
],
[
239,
104
],
[
220,
106
],
[
224,
109
],
[
221,
109
],
[
98,
110
],
[
212,
111
],
[
116,
113
],
[
236,
114
],
[
98,
115
],
[
221,
116
],
[
224,
116
],
[
119,
118
],
[
233,
123
],
[
239,
124
],
[
217,
126
],
[
251,
128
],
[
113,
129
],
[
236,
130
],
[
118,
131
],
[
212,
133
],
[
212,
135
],
[
140,
137
],
[
230,
138
],
[
118,
139
],
[
218,
140
],
[
236,
148
],
[
160,
149
],
[
230,
151
],
[
162,
152
],
[
230,
154
],
[
160,
156
],
[
162,
157
],
[
164,
158
],
[
160,
160
],
[
162,
162
],
[
164,
164
],
[
241,
166
],
[
170,
169
],
[
215,
172
],
[
239,
173
],
[
247,
175
],
[
242,
178
],
[
248,
178
],
[
227,
182
],
[
233,
186
],
[
245,
187
],
[
169,
188
],
[
169,
190
],
[
212,
191
],
[
227,
193
],
[
245,
197
],
[
239,
198
],
[
169,
199
],
[
245,
202
],
[
212,
204
],
[
212,
205
],
[
212,
206
],
[
248,
209
],
[
242,
209
],
[
211,
212
],
[
244,
215
],
[
217,
218
],
[
220,
221
],
[
223,
224
],
[
229,
230
],
[
244,
233
],
[
235,
236
],
[
244,
239
],
[
241,
242
],
[
244,
245
],
[
247,
248
]
] | [
"H,W,A,B = map(int,input().split())\nmod = 10**9+7\nx1 = [1 for i in range(H+W)]\nxi = [1 for i in range(H+W)]\nnum = 1\ndef power2(a,b,p):\n if b == 0:\n return 1\n if b%2 == 0:\n d = power2(a,b//2,p)\n return (d*d)%p\n return (a*power2(a,b-1,p))%p\nfor i in range(1,H+W):\n num = (num*i)%mod\n x1[i] = num\nfor i in range(1,H+W):\n x2 = power2(x1[i],mod-2,mod)\n xi[i] = x2\ndef comb(a,b,p):\n return (x1[a]*xi[b]*xi[a-b])%p\nans = 0\nfor w in range(B,W):\n ans = (ans+ (comb(H-A+w-1,w,mod)*comb(A+W-w-2,A-1,mod))%mod)%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",
"1 for i in range(H+W)",
"for i in range(H+W)",
"i",
"range(H+W)",
"range",
"H+W",
"H",
"W",
"for i in range(H+W)",
"1",
"x1 = [1 for i in range(H+W)]",
"x1",
"[1 for i in range(H+W)]",
"1 for i in range(H+W)",
"for i in range(H+W)",
"i",
"range(H+W)",
"range",
"H+W",
"H",
"W",
"for i in range(H+W)",
"1",
"xi = [1 for i in range(H+W)]",
"xi",
"[1 for i in range(H+W)]",
"num = 1",
"num",
"1",
"def power2(a,b,p):\n if b == 0:\n return 1\n if b%2 == 0:\n d = power2(a,b//2,p)\n return (d*d)%p\n return (a*power2(a,b-1,p))%p",
"power2",
"if b == 0:\n return 1\n ",
"b == 0",
"b",
"0",
"return 1",
"1",
"if b%2 == 0:\n d = power2(a,b//2,p)\n return (d*d)%p\n ",
"b%2 == 0",
"b%2",
"b",
"2",
"0",
"d = power2(a,b//2,p)",
"d",
"power2(a,b//2,p)",
"power2",
"a",
"b//2",
"b",
"2",
"p",
"return (d*d)%p",
"(d*d)%p",
"d*d",
"d",
"d",
"p",
"return (a*power2(a,b-1,p))%p",
"(a*power2(a,b-1,p))%p",
"a*power2(a,b-1,p)",
"a",
"power2(a,b-1,p)",
"power2",
"a",
"b-1",
"b",
"1",
"p",
"p",
"a",
"a",
"b",
"b",
"p",
"p",
"for i in range(1,H+W):\n num = (num*i)%mod\n x1[i] = num",
"i",
"range(1,H+W)",
"range",
"1",
"H+W",
"H",
"W",
"num = (num*i)%mod",
"num",
"(num*i)%mod",
"num*i",
"num",
"i",
"mod",
"x1[i] = num",
"x1[i]",
"x1",
"i",
"num",
"for i in range(1,H+W):\n x2 = power2(x1[i],mod-2,mod)\n xi[i] = x2",
"i",
"range(1,H+W)",
"range",
"1",
"H+W",
"H",
"W",
"x2 = power2(x1[i],mod-2,mod)",
"x2",
"power2(x1[i],mod-2,mod)",
"power2",
"x1[i]",
"x1",
"i",
"mod-2",
"mod",
"2",
"mod",
"xi[i] = x2",
"xi[i]",
"xi",
"i",
"x2",
"def comb(a,b,p):\n return (x1[a]*xi[b]*xi[a-b])%p",
"comb",
"return (x1[a]*xi[b]*xi[a-b])%p",
"(x1[a]*xi[b]*xi[a-b])%p",
"x1[a]*xi[b]*xi[a-b]",
"x1[a]*xi[b]",
"x1[a]",
"x1",
"a",
"xi[b]",
"xi",
"b",
"xi[a-b]",
"xi",
"a-b",
"a",
"b",
"p",
"a",
"a",
"b",
"b",
"p",
"p",
"ans = 0",
"ans",
"0",
"for w in range(B,W):\n ans = (ans+ (comb(H-A+w-1,w,mod)*comb(A+W-w-2,A-1,mod))%mod)%mod",
"w",
"range(B,W)",
"range",
"B",
"W",
"ans = (ans+ (comb(H-A+w-1,w,mod)*comb(A+W-w-2,A-1,mod))%mod)%mod",
"ans",
"(ans+ (comb(H-A+w-1,w,mod)*comb(A+W-w-2,A-1,mod))%mod)%mod",
"ans+ (comb(H-A+w-1,w,mod)*comb(A+W-w-2,A-1,mod))%mod",
"ans",
"(comb(H-A+w-1,w,mod)*comb(A+W-w-2,A-1,mod))%mod",
"comb(H-A+w-1,w,mod)*comb(A+W-w-2,A-1,mod)",
"comb(H-A+w-1,w,mod)",
"comb",
"H-A+w-1",
"H-A+w",
"H-A",
"H",
"A",
"w",
"1",
"w",
"mod",
"comb(A+W-w-2,A-1,mod)",
"comb",
"A+W-w-2",
"A+W-w",
"A+W",
"A",
"W",
"w",
"2",
"A-1",
"A",
"1",
"mod",
"mod",
"mod",
"print(ans)",
"print",
"ans",
"mod = 10**9+7",
"10**9+7",
"mod",
"B = map(int,input().split())",
"map(int,input().split())",
"B",
"x2 = power2(x1[i],mod-2,mod)",
"power2(x1[i],mod-2,mod)",
"x2",
"num = (num*i)%mod",
"(num*i)%mod",
"num",
"num = 1",
"1",
"num",
"def comb(a,b,p):\n return (x1[a]*xi[b]*xi[a-b])%p",
"def comb(a,b,p):\n return (x1[a]*xi[b]*xi[a-b])%p",
"comb",
"xi = [1 for i in range(H+W)]",
"[1 for i in range(H+W)]",
"xi",
"H,W,A,B = map(int,input().split())",
"map(int,input().split())",
"H",
"x1 = [1 for i in range(H+W)]",
"[1 for i in range(H+W)]",
"x1",
"W,A,B = map(int,input().split())",
"map(int,input().split())",
"W",
"ans = 0",
"0",
"ans",
"A,B = map(int,input().split())",
"map(int,input().split())",
"A",
"ans = (ans+ (comb(H-A+w-1,w,mod)*comb(A+W-w-2,A-1,mod))%mod)%mod",
"(ans+ (comb(H-A+w-1,w,mod)*comb(A+W-w-2,A-1,mod))%mod)%mod",
"ans",
"def power2(a,b,p):\n if b == 0:\n return 1\n if b%2 == 0:\n d = power2(a,b//2,p)\n return (d*d)%p\n return (a*power2(a,b-1,p))%p",
"def power2(a,b,p):\n if b == 0:\n return 1\n if b%2 == 0:\n d = power2(a,b//2,p)\n return (d*d)%p\n return (a*power2(a,b-1,p))%p",
"power2"
] | H,W,A,B = map(int,input().split())
mod = 10**9+7
x1 = [1 for i in range(H+W)]
xi = [1 for i in range(H+W)]
num = 1
def power2(a,b,p):
if b == 0:
return 1
if b%2 == 0:
d = power2(a,b//2,p)
return (d*d)%p
return (a*power2(a,b-1,p))%p
for i in range(1,H+W):
num = (num*i)%mod
x1[i] = num
for i in range(1,H+W):
x2 = power2(x1[i],mod-2,mod)
xi[i] = x2
def comb(a,b,p):
return (x1[a]*xi[b]*xi[a-b])%p
ans = 0
for w in range(B,W):
ans = (ans+ (comb(H-A+w-1,w,mod)*comb(A+W-w-2,A-1,mod))%mod)%mod
print(ans) |
[
7,
15,
13,
12,
13,
14,
2,
2,
13,
17,
2,
13,
13,
29,
17,
0,
13,
4,
13,
39,
13,
2,
13,
13,
0,
13,
17,
13,
17,
0,
13,
17,
28,
13,
4,
13,
17,
2,
13,
17,
14,
13,
0,
13,
2,
2,
13,
17,
13,
0,
13,
13,
0,
13,
13,
0,
13,
13,
0,
13,
2,
2,
13,
17,
13,
0,
13,
13,
0,
13,
8,
13,
2,
2,
13,
4,
13,
13,
2,
13,
17,
13,
13,
13,
29,
13,
23,
13,
23,
13,
23,
13,
17,
12,
13,
0,
13,
18,
18,
13,
13,
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,
13,
4,
13,
2,
2,
2,
13,
13,
13,
17,
2,
13,
17,
13,
0,
13,
17,
28,
13,
4,
13,
2,
13,
13,
0,
13,
2,
13,
13,
0,
13,
13,
0,
13,
2,
2,
2,
13,
2,
13,
13,
4,
13,
2,
13,
17,
2,
13,
17,
13,
13,
0,
13,
2,
2,
2,
13,
2,
2,
13,
13,
17,
4,
13,
2,
2,
2,
2,
13,
13,
13,
13,
17,
2,
13,
17,
13,
13,
4,
13,
13,
14,
2,
13,
17,
4,
13,
10,
12,
13,
10,
12,
13
] | [
[
89,
8
],
[
89,
11
],
[
87,
12
],
[
17,
16
],
[
87,
22
],
[
89,
23
],
[
26,
25
],
[
28,
27
],
[
31,
30
],
[
34,
33
],
[
16,
38
],
[
89,
38
],
[
44,
43
],
[
87,
46
],
[
33,
48
],
[
51,
50
],
[
33,
51
],
[
54,
53
],
[
91,
54
],
[
57,
56
],
[
91,
57
],
[
60,
59
],
[
87,
62
],
[
33,
64
],
[
67,
66
],
[
33,
67
],
[
70,
69
],
[
91,
71
],
[
53,
74
],
[
43,
74
],
[
25,
74
],
[
56,
77
],
[
50,
77
],
[
27,
77
],
[
91,
79
],
[
91,
81
],
[
91,
82
],
[
66,
83
],
[
59,
83
],
[
30,
83
],
[
69,
85
],
[
66,
85
],
[
59,
85
],
[
30,
85
],
[
87,
87
],
[
89,
89
],
[
92,
91
],
[
97,
96
],
[
104,
103
],
[
96,
110
],
[
104,
112
],
[
104,
113
],
[
104,
114
],
[
117,
116
],
[
125,
124
],
[
127,
126
],
[
218,
128
],
[
103,
132
],
[
112,
133
],
[
114,
134
],
[
103,
137
],
[
116,
139
],
[
142,
141
],
[
145,
144
],
[
103,
148
],
[
113,
149
],
[
152,
151
],
[
124,
153
],
[
159,
153
],
[
126,
154
],
[
178,
154
],
[
157,
156
],
[
116,
157
],
[
160,
159
],
[
124,
163
],
[
159,
163
],
[
144,
165
],
[
114,
166
],
[
144,
170
],
[
116,
173
],
[
116,
175
],
[
116,
176
],
[
179,
178
],
[
126,
182
],
[
178,
182
],
[
103,
185
],
[
144,
186
],
[
103,
194
],
[
144,
195
],
[
112,
196
],
[
114,
197
],
[
116,
200
],
[
116,
202
],
[
116,
203
],
[
156,
206
],
[
151,
206
],
[
141,
206
],
[
215,
212
]
] | [
"import sys\n\ndef comb(n, r, mod=None):\n if r == 0 or r == n:\n return 1\n r = min([r, n-r])\n x, y = 1, 1\n ans = 1\n for i in range(1, r+1):\n if mod:\n x *= n+1-i\n y *= i\n x %= mod\n y %= mod\n else:\n ans *= n+1-i\n ans //= i\n ans = x*pow(y, mod-2, mod)%mod if mod else ans\n return ans\n\ndef main():\n input = sys.stdin.readline\n h, w, a, b = map(int, input().split())\n mod = pow(10, 9)+7\n \n bef, aft = 1, comb(h+w-b-2, h-1, mod)\n ans = 0\n for i in range(h-a):\n ans += bef*aft\n ans %= mod\n \n bef = bef*(i+b)*pow(i+1, mod-2, mod)%mod\n aft = aft*(h-i-1)*pow(h-i+w-b-2, mod-2, mod)%mod\n \n print(ans)\n\nif __name__ == \"__main__\":\n main()",
"import sys",
"sys",
"def comb(n, r, mod=None):\n if r == 0 or r == n:\n return 1\n r = min([r, n-r])\n x, y = 1, 1\n ans = 1\n for i in range(1, r+1):\n if mod:\n x *= n+1-i\n y *= i\n x %= mod\n y %= mod\n else:\n ans *= n+1-i\n ans //= i\n ans = x*pow(y, mod-2, mod)%mod if mod else ans\n return ans",
"comb",
"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",
"r = min([r, n-r])",
"r",
"min([r, n-r])",
"min",
"[r, n-r]",
"r",
"n-r",
"n",
"r",
"x, y = 1, 1",
"x",
"1",
"y",
"1",
"ans = 1",
"ans",
"1",
"for i in range(1, r+1):\n if mod:\n x *= n+1-i\n y *= i\n x %= mod\n y %= mod\n else:\n ans *= n+1-i\n ans //= i\n ",
"i",
"range(1, r+1)",
"range",
"1",
"r+1",
"r",
"1",
"if mod:\n x *= n+1-i\n y *= i\n x %= mod\n y %= mod\n else:\n ans *= n+1-i\n ans //= i\n ",
"mod",
"x *= n+1-i",
"x",
"n+1-i",
"n+1",
"n",
"1",
"i",
"y *= i",
"y",
"i",
"x %= mod",
"x",
"mod",
"y %= mod",
"y",
"mod",
"ans *= n+1-i",
"ans",
"n+1-i",
"n+1",
"n",
"1",
"i",
"ans //= i",
"ans",
"i",
"ans = x*pow(y, mod-2, mod)%mod if mod else ans",
"ans",
"x*pow(y, mod-2, mod)%mod if mod else ans",
"mod",
"x*pow(y, mod-2, mod)%mod",
"x*pow(y, mod-2, mod)",
"x",
"pow(y, mod-2, mod)",
"pow",
"y",
"mod-2",
"mod",
"2",
"mod",
"mod",
"ans",
"return ans",
"ans",
"n",
"n",
"r",
"r",
"mod=None",
"mod",
"None",
"def main():\n input = sys.stdin.readline\n h, w, a, b = map(int, input().split())\n mod = pow(10, 9)+7\n \n bef, aft = 1, comb(h+w-b-2, h-1, mod)\n ans = 0\n for i in range(h-a):\n ans += bef*aft\n ans %= mod\n \n bef = bef*(i+b)*pow(i+1, mod-2, mod)%mod\n aft = aft*(h-i-1)*pow(h-i+w-b-2, mod-2, mod)%mod\n \n print(ans)",
"main",
"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 = pow(10, 9)+7",
"mod",
"pow(10, 9)+7",
"pow(10, 9)",
"pow",
"10",
"9",
"7",
"bef, aft = 1, comb(h+w-b-2, h-1, mod)",
"bef",
"1",
"aft",
"comb(h+w-b-2, h-1, mod)",
"comb",
"h+w-b-2",
"h+w-b",
"h+w",
"h",
"w",
"b",
"2",
"h-1",
"h",
"1",
"mod",
"ans = 0",
"ans",
"0",
"for i in range(h-a):\n ans += bef*aft\n ans %= mod\n \n bef = bef*(i+b)*pow(i+1, mod-2, mod)%mod\n aft = aft*(h-i-1)*pow(h-i+w-b-2, mod-2, mod)%mod\n \n ",
"i",
"range(h-a)",
"range",
"h-a",
"h",
"a",
"ans += bef*aft",
"ans",
"bef*aft",
"bef",
"aft",
"ans %= mod",
"ans",
"mod",
"bef = bef*(i+b)*pow(i+1, mod-2, mod)%mod",
"bef",
"bef*(i+b)*pow(i+1, mod-2, mod)%mod",
"bef*(i+b)*pow(i+1, mod-2, mod)",
"bef*(i+b)",
"bef",
"i+b",
"i",
"b",
"pow(i+1, mod-2, mod)",
"pow",
"i+1",
"i",
"1",
"mod-2",
"mod",
"2",
"mod",
"mod",
"aft = aft*(h-i-1)*pow(h-i+w-b-2, mod-2, mod)%mod",
"aft",
"aft*(h-i-1)*pow(h-i+w-b-2, mod-2, mod)%mod",
"aft*(h-i-1)*pow(h-i+w-b-2, mod-2, mod)",
"aft*(h-i-1)",
"aft",
"h-i-1",
"h-i",
"h",
"i",
"1",
"pow(h-i+w-b-2, mod-2, mod)",
"pow",
"h-i+w-b-2",
"h-i+w-b",
"h-i+w",
"h-i",
"h",
"i",
"w",
"b",
"2",
"mod-2",
"mod",
"2",
"mod",
"mod",
"print(ans)",
"print",
"ans",
"if __name__ == \"__main__\":\n main()",
"__name__ == \"__main__\"",
"__name__",
"\"__main__\"",
"main()",
"main",
"def main():\n input = sys.stdin.readline\n h, w, a, b = map(int, input().split())\n mod = pow(10, 9)+7\n \n bef, aft = 1, comb(h+w-b-2, h-1, mod)\n ans = 0\n for i in range(h-a):\n ans += bef*aft\n ans %= mod\n \n bef = bef*(i+b)*pow(i+1, mod-2, mod)%mod\n aft = aft*(h-i-1)*pow(h-i+w-b-2, mod-2, mod)%mod\n \n print(ans)",
"def main():\n input = sys.stdin.readline\n h, w, a, b = map(int, input().split())\n mod = pow(10, 9)+7\n \n bef, aft = 1, comb(h+w-b-2, h-1, mod)\n ans = 0\n for i in range(h-a):\n ans += bef*aft\n ans %= mod\n \n bef = bef*(i+b)*pow(i+1, mod-2, mod)%mod\n aft = aft*(h-i-1)*pow(h-i+w-b-2, mod-2, mod)%mod\n \n print(ans)",
"main",
"def comb(n, r, mod=None):\n if r == 0 or r == n:\n return 1\n r = min([r, n-r])\n x, y = 1, 1\n ans = 1\n for i in range(1, r+1):\n if mod:\n x *= n+1-i\n y *= i\n x %= mod\n y %= mod\n else:\n ans *= n+1-i\n ans //= i\n ans = x*pow(y, mod-2, mod)%mod if mod else ans\n return ans",
"def comb(n, r, mod=None):\n if r == 0 or r == n:\n return 1\n r = min([r, n-r])\n x, y = 1, 1\n ans = 1\n for i in range(1, r+1):\n if mod:\n x *= n+1-i\n y *= i\n x %= mod\n y %= mod\n else:\n ans *= n+1-i\n ans //= i\n ans = x*pow(y, mod-2, mod)%mod if mod else ans\n return ans",
"comb"
] | import sys
def comb(n, r, mod=None):
if r == 0 or r == n:
return 1
r = min([r, n-r])
x, y = 1, 1
ans = 1
for i in range(1, r+1):
if mod:
x *= n+1-i
y *= i
x %= mod
y %= mod
else:
ans *= n+1-i
ans //= i
ans = x*pow(y, mod-2, mod)%mod if mod else ans
return ans
def main():
input = sys.stdin.readline
h, w, a, b = map(int, input().split())
mod = pow(10, 9)+7
bef, aft = 1, comb(h+w-b-2, h-1, mod)
ans = 0
for i in range(h-a):
ans += bef*aft
ans %= mod
bef = bef*(i+b)*pow(i+1, mod-2, mod)%mod
aft = aft*(h-i-1)*pow(h-i+w-b-2, mod-2, mod)%mod
print(ans)
if __name__ == "__main__":
main() |
[
7,
0,
13,
4,
13,
13,
4,
18,
4,
13,
13,
13,
13,
13,
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,
23,
13,
0,
13,
2,
2,
17,
17,
17,
0,
13,
4,
13,
2,
2,
2,
13,
13,
13,
17,
2,
2,
2,
13,
13,
13,
17,
0,
13,
4,
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,
28,
13,
4,
13,
2,
13,
13,
0,
13,
2,
2,
17,
17,
17,
0,
13,
2,
4,
13,
2,
2,
2,
2,
13,
13,
13,
17,
13,
2,
2,
13,
13,
17,
13,
13,
0,
13,
2,
4,
13,
2,
2,
2,
2,
2,
13,
17,
13,
13,
17,
13,
2,
13,
17,
13,
13,
0,
13,
2,
2,
13,
13,
13,
0,
13,
2,
13,
13,
4,
13,
13,
10,
4,
13,
10,
17,
13,
10,
2,
13,
10,
4,
13,
10,
2,
13,
10,
4,
13,
10,
39,
13,
10,
4,
13,
10,
39,
13,
10,
4,
13,
10,
39,
13,
10,
2,
13,
10,
2,
13,
10,
4,
13,
10,
12,
13,
10,
2,
13,
10,
2,
13
] | [
[
261,
2
],
[
261,
11
],
[
261,
12
],
[
261,
13
],
[
225,
15
],
[
56,
22
],
[
56,
25
],
[
54,
26
],
[
31,
30
],
[
56,
33
],
[
54,
35
],
[
56,
36
],
[
54,
43
],
[
30,
46
],
[
56,
46
],
[
54,
50
],
[
30,
51
],
[
56,
51
],
[
58,
52
],
[
54,
54
],
[
56,
56
],
[
58,
58
],
[
234,
60
],
[
237,
67
],
[
232,
73
],
[
262,
74
],
[
250,
75
],
[
250,
80
],
[
262,
81
],
[
244,
82
],
[
237,
85
],
[
246,
88
],
[
252,
93
],
[
240,
98
],
[
104,
103
],
[
238,
108
],
[
247,
112
],
[
247,
117
],
[
103,
119
],
[
235,
120
],
[
241,
123
],
[
241,
129
],
[
235,
131
],
[
103,
132
],
[
235,
134
],
[
103,
135
],
[
235,
136
],
[
253,
139
],
[
253,
144
],
[
241,
147
],
[
235,
149
],
[
152,
151
],
[
250,
155
],
[
244,
156
],
[
255,
158
],
[
267,
165
],
[
265,
168
],
[
232,
173
],
[
262,
174
],
[
244,
175
],
[
151,
177
],
[
232,
180
],
[
262,
181
],
[
256,
183
],
[
256,
184
],
[
270,
186
],
[
265,
189
],
[
262,
195
],
[
250,
197
],
[
244,
198
],
[
151,
200
],
[
262,
202
],
[
256,
204
],
[
256,
205
],
[
258,
207
],
[
268,
210
],
[
271,
211
],
[
256,
212
],
[
228,
214
],
[
259,
216
],
[
226,
216
],
[
229,
216
],
[
256,
217
],
[
229,
220
],
[
259,
220
],
[
226,
220
],
[
237,
223
],
[
225,
226
],
[
228,
229
],
[
261,
232
],
[
234,
235
],
[
237,
238
],
[
240,
241
],
[
261,
244
],
[
246,
247
],
[
261,
250
],
[
252,
253
],
[
255,
256
],
[
258,
259
],
[
261,
262
],
[
267,
268
],
[
270,
271
]
] | [
"H, W, A, B = map(int, input().split())\nans = 0\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 = maximum = max(H - A + W - 2, W + A - B - 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 )\n\nfor i in range(W - B):\n #前半の経路\n P = 10 ** 9 + 7\n prev = cmb(H - A + B - 1 + i, H - A - 1, P) % P\n latter = cmb(A - 1 + W - B - 1 - i, A - 1, P) % P\n ans += (prev * latter) % P\n ans = ans % P\nprint(ans)\n\n\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",
"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 = maximum = max(H - A + W - 2, W + A - B - 2)",
"N",
"max(H - A + W - 2, W + A - B - 2)",
"max",
"H - A + W - 2",
"H - A + W",
"H - A",
"H",
"A",
"W",
"2",
"W + A - B - 2",
"W + A - B",
"W + A",
"W",
"A",
"B",
"2",
"= maximum = max(H - A + W - 2, W + A - B - 2)",
"maximum",
"max(H - A + W - 2, W + A - B - 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",
"for i in range(W - B):\n #前半の経路\n P = 10 ** 9 + 7\n prev = cmb(H - A + B - 1 + i, H - A - 1, P) % P\n latter = cmb(A - 1 + W - B - 1 - i, A - 1, P) % P\n ans += (prev * latter) % P\n ans = ans % P",
"i",
"range(W - B)",
"range",
"W - B",
"W",
"B",
"P = 10 ** 9 + 7",
"P",
"10 ** 9 + 7",
"10 ** 9",
"10",
"9",
"7",
"prev = cmb(H - A + B - 1 + i, H - A - 1, P) % P",
"prev",
"cmb(H - A + B - 1 + i, H - A - 1, P) % P",
"cmb(H - A + B - 1 + i, H - A - 1, P)",
"cmb",
"H - A + B - 1 + i",
"H - A + B - 1",
"H - A + B",
"H - A",
"H",
"A",
"B",
"1",
"i",
"H - A - 1",
"H - A",
"H",
"A",
"1",
"P",
"P",
"latter = cmb(A - 1 + W - B - 1 - i, A - 1, P) % P",
"latter",
"cmb(A - 1 + W - B - 1 - i, A - 1, P) % P",
"cmb(A - 1 + W - B - 1 - i, A - 1, P)",
"cmb",
"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",
"A - 1",
"A",
"1",
"P",
"P",
"ans += (prev * latter) % P",
"ans",
"(prev * latter) % P",
"prev * latter",
"prev",
"latter",
"P",
"ans = ans % P",
"ans",
"ans % P",
"ans",
"P",
"print(ans)",
"print",
"ans",
"maximum = max(H - A + W - 2, W + A - B - 2)",
"max(H - A + W - 2, W + A - B - 2)",
"maximum",
"ans = 0",
"0",
"ans",
"ans = ans % P",
"ans % P",
"ans",
"H, W, A, B = map(int, input().split())",
"map(int, input().split())",
"H",
"mod = 10**9+7",
"10**9+7",
"mod",
"N = maximum = max(H - A + W - 2, W + A - B - 2)",
"max(H - A + W - 2, W + A - B - 2)",
"N",
"inverse = [0, 1]",
"[0, 1]",
"inverse",
"B = map(int, input().split())",
"map(int, input().split())",
"B",
"g1 = [1, 1]",
"[1, 1]",
"g1",
"W, A, B = map(int, input().split())",
"map(int, input().split())",
"W",
"g2 = [1, 1]",
"[1, 1]",
"g2",
"P = 10 ** 9 + 7",
"10 ** 9 + 7",
"P",
"ans += (prev * latter) % P",
"(prev * latter) % P",
"ans",
"A, B = map(int, input().split())",
"map(int, input().split())",
"A",
"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",
"prev = cmb(H - A + B - 1 + i, H - A - 1, P) % P",
"cmb(H - A + B - 1 + i, H - A - 1, P) % P",
"prev",
"latter = cmb(A - 1 + W - B - 1 - i, A - 1, P) % P",
"cmb(A - 1 + W - B - 1 - i, A - 1, P) % P",
"latter"
] | H, W, A, B = map(int, input().split())
ans = 0
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 = maximum = max(H - A + W - 2, W + A - B - 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 )
for i in range(W - B):
#前半の経路
P = 10 ** 9 + 7
prev = cmb(H - A + B - 1 + i, H - A - 1, P) % P
latter = cmb(A - 1 + W - B - 1 - i, A - 1, P) % P
ans += (prev * latter) % P
ans = ans % P
print(ans)
|
[
7,
0,
13,
17,
0,
13,
4,
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,
14,
2,
13,
13,
29,
17,
14,
2,
13,
17,
29,
17,
0,
13,
17,
28,
13,
4,
13,
13,
0,
13,
2,
2,
2,
13,
2,
2,
13,
13,
4,
13,
2,
13,
13,
13,
13,
29,
13,
23,
13,
23,
13,
0,
13,
4,
13,
2,
2,
13,
13,
17,
2,
13,
17,
14,
2,
2,
13,
17,
2,
13,
17,
0,
13,
17,
14,
2,
13,
17,
0,
13,
4,
13,
2,
2,
13,
13,
17,
2,
13,
17,
14,
2,
13,
17,
0,
13,
4,
13,
2,
2,
13,
13,
17,
2,
13,
17,
0,
13,
2,
39,
17,
13,
28,
13,
4,
13,
17,
13,
0,
18,
13,
13,
2,
2,
2,
18,
13,
2,
13,
17,
2,
2,
13,
13,
13,
4,
13,
13,
13,
0,
13,
2,
39,
17,
13,
0,
13,
2,
13,
17,
0,
13,
2,
13,
13,
0,
18,
13,
2,
13,
17,
4,
13,
2,
13,
13,
13,
28,
13,
4,
13,
17,
13,
0,
18,
13,
2,
2,
13,
13,
17,
2,
2,
2,
18,
13,
2,
13,
13,
2,
2,
13,
13,
13,
4,
13,
2,
13,
13,
13,
0,
13,
2,
18,
13,
17,
18,
13,
17,
0,
13,
13,
28,
13,
4,
13,
17,
13,
0,
13,
2,
2,
18,
13,
13,
18,
13,
2,
13,
17,
18,
13,
13,
0,
13,
13,
4,
13,
2,
13,
13,
10,
13,
13,
10,
12,
13,
10,
13,
13,
10,
2,
13,
10,
2,
13,
10,
2,
13,
10,
4,
13,
10,
4,
13,
10,
4,
13,
10,
17,
13,
10,
17,
13,
10,
2,
13,
10,
4,
13,
10,
2,
13,
10,
4,
13,
10,
12,
13,
10,
4,
13,
10,
4,
13,
10,
2,
13
] | [
[
294,
2
],
[
318,
5
],
[
318,
16
],
[
318,
17
],
[
318,
18
],
[
30,
24
],
[
295,
26
],
[
295,
28
],
[
30,
30
],
[
73,
35
],
[
75,
36
],
[
75,
41
],
[
47,
46
],
[
50,
49
],
[
75,
52
],
[
55,
54
],
[
46,
58
],
[
54,
58
],
[
73,
61
],
[
49,
62
],
[
271,
64
],
[
75,
66
],
[
49,
67
],
[
295,
68
],
[
295,
69
],
[
54,
71
],
[
46,
71
],
[
73,
73
],
[
75,
75
],
[
288,
77
],
[
313,
79
],
[
292,
82
],
[
316,
83
],
[
292,
86
],
[
319,
91
],
[
304,
94
],
[
297,
97
],
[
319,
101
],
[
285,
104
],
[
313,
106
],
[
292,
109
],
[
304,
110
],
[
292,
113
],
[
304,
117
],
[
309,
120
],
[
313,
122
],
[
316,
125
],
[
319,
126
],
[
316,
129
],
[
282,
132
],
[
304,
136
],
[
139,
138
],
[
304,
142
],
[
147,
144
],
[
283,
145
],
[
138,
146
],
[
283,
151
],
[
138,
153
],
[
292,
157
],
[
319,
158
],
[
138,
159
],
[
271,
161
],
[
138,
162
],
[
295,
163
],
[
279,
165
],
[
304,
169
],
[
306,
171
],
[
319,
173
],
[
321,
176
],
[
316,
178
],
[
304,
179
],
[
186,
181
],
[
280,
182
],
[
304,
184
],
[
313,
187
],
[
307,
189
],
[
322,
190
],
[
307,
191
],
[
194,
193
],
[
304,
197
],
[
206,
199
],
[
280,
200
],
[
304,
203
],
[
193,
204
],
[
280,
210
],
[
304,
212
],
[
193,
213
],
[
307,
216
],
[
322,
217
],
[
193,
218
],
[
271,
220
],
[
322,
222
],
[
193,
223
],
[
295,
224
],
[
300,
226
],
[
283,
229
],
[
280,
232
],
[
273,
235
],
[
295,
236
],
[
239,
238
],
[
304,
242
],
[
276,
244
],
[
144,
247
],
[
283,
248
],
[
238,
249
],
[
283,
251
],
[
238,
253
],
[
280,
256
],
[
238,
257
],
[
267,
259
],
[
295,
260
],
[
268,
264
],
[
277,
264
],
[
274,
264
],
[
301,
264
],
[
310,
264
],
[
286,
264
],
[
298,
264
],
[
289,
264
],
[
295,
265
],
[
295,
267
],
[
267,
268
],
[
295,
273
],
[
273,
274
],
[
276,
277
],
[
279,
280
],
[
282,
283
],
[
285,
286
],
[
288,
289
],
[
318,
292
],
[
294,
295
],
[
297,
298
],
[
300,
301
],
[
318,
304
],
[
306,
307
],
[
309,
310
],
[
318,
316
],
[
318,
319
],
[
321,
322
]
] | [
"M = 1000000007\nh, w, a, b = list(map(int, input().split()))\n\n\ndef inv(k):\n return pow(k, M - 2, M)\n\n\ndef comb(n, k):\n if n < k:\n return 0\n elif k == 0:\n return 1\n else:\n r = 1\n for i in range(k):\n r = (r * ((n - i) * inv(k - i)) % M) % M\n return r\n\n\nans = comb(h + w - 2, h - 1)\n\nif a == 1 and b == 1:\n ans -= 1\nelif a == 1:\n ans -= comb(h + b - 2, h - 1)\nelif b == 1:\n ans -= comb(w + a - 2, w - 1)\nelse:\n\n memo = [1] * b\n for i in range(1, b):\n memo[i] = (memo[i - 1] * (h - a + i) * inv(i)) % M\n\n memo2 = [0] * b\n height = a - 1\n width = w - b\n memo2[b - 1] = comb(height + width, height)\n for i in range(1, b):\n memo2[b - i - 1] = (memo2[b - i] * (height + width + i) * inv(width + i)) % M\n\n ans -= memo[0] * memo2[0]\n ans %= M\n for i in range(1, b):\n ans -= (memo[i] - memo[i - 1]) * memo2[i]\n ans %= M\n\nprint(ans % M)",
"M = 1000000007",
"M",
"1000000007",
"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",
"def inv(k):\n return pow(k, M - 2, M)",
"inv",
"return pow(k, M - 2, M)",
"pow(k, M - 2, M)",
"pow",
"k",
"M - 2",
"M",
"2",
"M",
"k",
"k",
"def comb(n, k):\n if n < k:\n return 0\n elif k == 0:\n return 1\n else:\n r = 1\n for i in range(k):\n r = (r * ((n - i) * inv(k - i)) % M) % M\n return r",
"comb",
"if n < k:\n return 0\n elif k == 0:\n return 1\n else:\n r = 1\n for i in range(k):\n r = (r * ((n - i) * inv(k - i)) % M) % M\n return r",
"n < k",
"n",
"k",
"return 0",
"0",
"elif k == 0:\n return 1\n ",
"k == 0",
"k",
"0",
"return 1",
"1",
"r = 1",
"r",
"1",
"for i in range(k):\n r = (r * ((n - i) * inv(k - i)) % M) % M\n ",
"i",
"range(k)",
"range",
"k",
"r = (r * ((n - i) * inv(k - i)) % M) % M",
"r",
"(r * ((n - i) * inv(k - i)) % M) % M",
"r * ((n - i) * inv(k - i)) % M",
"r * ((n - i) * inv(k - i))",
"r",
"(n - i) * inv(k - i)",
"n - i",
"n",
"i",
"inv(k - i)",
"inv",
"k - i",
"k",
"i",
"M",
"M",
"return r",
"r",
"n",
"n",
"k",
"k",
"ans = comb(h + w - 2, h - 1)",
"ans",
"comb(h + w - 2, h - 1)",
"comb",
"h + w - 2",
"h + w",
"h",
"w",
"2",
"h - 1",
"h",
"1",
"if a == 1 and b == 1:\n ans -= 1\nelif a == 1:\n ans -= comb(h + b - 2, h - 1)\nelif b == 1:\n ans -= comb(w + a - 2, w - 1)\nelse:\n\n memo = [1] * b\n for i in range(1, b):\n memo[i] = (memo[i - 1] * (h - a + i) * inv(i)) % M\n\n memo2 = [0] * b\n height = a - 1\n width = w - b\n memo2[b - 1] = comb(height + width, height)\n for i in range(1, b):\n memo2[b - i - 1] = (memo2[b - i] * (height + width + i) * inv(width + i)) % M\n\n ans -= memo[0] * memo2[0]\n ans %= M\n for i in range(1, b):\n ans -= (memo[i] - memo[i - 1]) * memo2[i]\n ans %= M",
"a == 1 and b == 1",
"a == 1",
"a",
"1",
"b == 1",
"b",
"1",
"ans -= 1",
"ans",
"1",
"elif a == 1:\n ans -= comb(h + b - 2, h - 1)",
"a == 1",
"a",
"1",
"ans -= comb(h + b - 2, h - 1)",
"ans",
"comb(h + b - 2, h - 1)",
"comb",
"h + b - 2",
"h + b",
"h",
"b",
"2",
"h - 1",
"h",
"1",
"elif b == 1:\n ans -= comb(w + a - 2, w - 1)",
"b == 1",
"b",
"1",
"ans -= comb(w + a - 2, w - 1)",
"ans",
"comb(w + a - 2, w - 1)",
"comb",
"w + a - 2",
"w + a",
"w",
"a",
"2",
"w - 1",
"w",
"1",
"memo = [1] * b",
"memo",
"[1] * b",
"[1]",
"1",
"b",
"for i in range(1, b):\n memo[i] = (memo[i - 1] * (h - a + i) * inv(i)) % M\n\n ",
"i",
"range(1, b)",
"range",
"1",
"b",
"memo[i] = (memo[i - 1] * (h - a + i) * inv(i)) % M",
"memo[i]",
"memo",
"i",
"(memo[i - 1] * (h - a + i) * inv(i)) % M",
"memo[i - 1] * (h - a + i) * inv(i)",
"memo[i - 1] * (h - a + i)",
"memo[i - 1]",
"memo",
"i - 1",
"i",
"1",
"h - a + i",
"h - a",
"h",
"a",
"i",
"inv(i)",
"inv",
"i",
"M",
"memo2 = [0] * b",
"memo2",
"[0] * b",
"[0]",
"0",
"b",
"height = a - 1",
"height",
"a - 1",
"a",
"1",
"width = w - b",
"width",
"w - b",
"w",
"b",
"memo2[b - 1] = comb(height + width, height)",
"memo2[b - 1]",
"memo2",
"b - 1",
"b",
"1",
"comb(height + width, height)",
"comb",
"height + width",
"height",
"width",
"height",
"for i in range(1, b):\n memo2[b - i - 1] = (memo2[b - i] * (height + width + i) * inv(width + i)) % M\n\n ",
"i",
"range(1, b)",
"range",
"1",
"b",
"memo2[b - i - 1] = (memo2[b - i] * (height + width + i) * inv(width + i)) % M",
"memo2[b - i - 1]",
"memo2",
"b - i - 1",
"b - i",
"b",
"i",
"1",
"(memo2[b - i] * (height + width + i) * inv(width + i)) % M",
"memo2[b - i] * (height + width + i) * inv(width + i)",
"memo2[b - i] * (height + width + i)",
"memo2[b - i]",
"memo2",
"b - i",
"b",
"i",
"height + width + i",
"height + width",
"height",
"width",
"i",
"inv(width + i)",
"inv",
"width + i",
"width",
"i",
"M",
"ans -= memo[0] * memo2[0]",
"ans",
"memo[0] * memo2[0]",
"memo[0]",
"memo",
"0",
"memo2[0]",
"memo2",
"0",
"ans %= M",
"ans",
"M",
"for i in range(1, b):\n ans -= (memo[i] - memo[i - 1]) * memo2[i]\n ans %= M",
"i",
"range(1, b)",
"range",
"1",
"b",
"ans -= (memo[i] - memo[i - 1]) * memo2[i]",
"ans",
"(memo[i] - memo[i - 1]) * memo2[i]",
"memo[i] - memo[i - 1]",
"memo[i]",
"memo",
"i",
"memo[i - 1]",
"memo",
"i - 1",
"i",
"1",
"memo2[i]",
"memo2",
"i",
"ans %= M",
"ans",
"M",
"print(ans % M)",
"print",
"ans % M",
"ans",
"M",
"ans %= M",
"M",
"ans",
"def inv(k):\n return pow(k, M - 2, M)",
"def inv(k):\n return pow(k, M - 2, M)",
"inv",
"ans %= M",
"M",
"ans",
"ans -= (memo[i] - memo[i - 1]) * memo2[i]",
"(memo[i] - memo[i - 1]) * memo2[i]",
"ans",
"memo2 = [0] * b",
"[0] * b",
"memo2",
"memo = [1] * b",
"[1] * b",
"memo",
"ans -= comb(h + b - 2, h - 1)",
"comb(h + b - 2, h - 1)",
"ans",
"ans = comb(h + w - 2, h - 1)",
"comb(h + w - 2, h - 1)",
"ans",
"h, w, a, b = list(map(int, input().split()))",
"list(map(int, input().split()))",
"h",
"M = 1000000007",
"1000000007",
"M",
"ans -= 1",
"1",
"ans",
"ans -= memo[0] * memo2[0]",
"memo[0] * memo2[0]",
"ans",
"b = list(map(int, input().split()))",
"list(map(int, input().split()))",
"b",
"height = a - 1",
"a - 1",
"height",
"ans -= comb(w + a - 2, w - 1)",
"comb(w + a - 2, w - 1)",
"ans",
"def comb(n, k):\n if n < k:\n return 0\n elif k == 0:\n return 1\n else:\n r = 1\n for i in range(k):\n r = (r * ((n - i) * inv(k - i)) % M) % M\n return r",
"def comb(n, k):\n if n < k:\n return 0\n elif k == 0:\n return 1\n else:\n r = 1\n for i in range(k):\n r = (r * ((n - i) * inv(k - i)) % M) % M\n return r",
"comb",
"w, a, b = list(map(int, input().split()))",
"list(map(int, input().split()))",
"w",
"a, b = list(map(int, input().split()))",
"list(map(int, input().split()))",
"a",
"width = w - b",
"w - b",
"width"
] | M = 1000000007
h, w, a, b = list(map(int, input().split()))
def inv(k):
return pow(k, M - 2, M)
def comb(n, k):
if n < k:
return 0
elif k == 0:
return 1
else:
r = 1
for i in range(k):
r = (r * ((n - i) * inv(k - i)) % M) % M
return r
ans = comb(h + w - 2, h - 1)
if a == 1 and b == 1:
ans -= 1
elif a == 1:
ans -= comb(h + b - 2, h - 1)
elif b == 1:
ans -= comb(w + a - 2, w - 1)
else:
memo = [1] * b
for i in range(1, b):
memo[i] = (memo[i - 1] * (h - a + i) * inv(i)) % M
memo2 = [0] * b
height = a - 1
width = w - b
memo2[b - 1] = comb(height + width, height)
for i in range(1, b):
memo2[b - i - 1] = (memo2[b - i] * (height + width + i) * inv(width + i)) % M
ans -= memo[0] * memo2[0]
ans %= M
for i in range(1, b):
ans -= (memo[i] - memo[i - 1]) * memo2[i]
ans %= M
print(ans % M)
|
[
7,
0,
13,
2,
2,
17,
2,
17,
17,
17,
0,
13,
2,
39,
17,
13,
0,
13,
2,
39,
17,
13,
0,
13,
2,
39,
17,
13,
12,
13,
0,
18,
13,
17,
17,
0,
18,
13,
17,
17,
0,
18,
13,
17,
17,
0,
18,
13,
17,
17,
0,
18,
13,
17,
17,
28,
13,
4,
13,
17,
13,
0,
18,
13,
13,
2,
2,
18,
13,
2,
13,
17,
13,
13,
0,
18,
13,
13,
2,
13,
2,
2,
18,
13,
2,
13,
13,
2,
13,
13,
13,
0,
18,
13,
13,
2,
2,
18,
13,
2,
13,
17,
18,
13,
13,
13,
12,
13,
14,
2,
13,
13,
29,
17,
14,
2,
2,
13,
17,
2,
13,
17,
29,
17,
29,
2,
2,
18,
13,
13,
2,
2,
18,
13,
13,
18,
13,
2,
13,
13,
13,
13,
23,
13,
23,
13,
0,
13,
4,
13,
13,
4,
18,
4,
13,
13,
13,
13,
13,
0,
13,
2,
2,
17,
17,
17,
4,
13,
0,
13,
17,
28,
13,
4,
13,
2,
13,
13,
0,
13,
2,
4,
13,
2,
2,
13,
13,
17,
13,
4,
13,
2,
2,
2,
2,
2,
13,
17,
13,
13,
13,
17,
2,
2,
13,
13,
17,
0,
13,
13,
4,
13,
13,
10,
2,
13,
10,
17,
13,
10,
4,
13,
10,
2,
13,
10,
4,
13,
10,
13,
13,
10,
4,
13,
10,
2,
13,
10,
2,
13,
10,
2,
13,
10,
12,
13,
10,
4,
13,
10,
2,
13,
10,
12,
13
] | [
[
223,
2
],
[
250,
11
],
[
224,
15
],
[
214,
17
],
[
224,
21
],
[
238,
23
],
[
224,
27
],
[
34,
31
],
[
251,
32
],
[
39,
36
],
[
251,
37
],
[
44,
41
],
[
239,
42
],
[
49,
46
],
[
239,
47
],
[
54,
51
],
[
215,
52
],
[
57,
56
],
[
224,
60
],
[
65,
62
],
[
251,
63
],
[
56,
64
],
[
251,
68
],
[
56,
70
],
[
56,
72
],
[
78,
75
],
[
215,
76
],
[
56,
77
],
[
215,
83
],
[
56,
86
],
[
56,
89
],
[
95,
92
],
[
239,
93
],
[
56,
94
],
[
239,
98
],
[
56,
100
],
[
75,
102
],
[
215,
103
],
[
56,
104
],
[
143,
110
],
[
145,
111
],
[
143,
117
],
[
145,
120
],
[
251,
128
],
[
143,
129
],
[
239,
133
],
[
145,
134
],
[
239,
136
],
[
143,
138
],
[
145,
139
],
[
143,
143
],
[
145,
145
],
[
247,
147
],
[
247,
156
],
[
247,
157
],
[
247,
158
],
[
241,
160
],
[
254,
167
],
[
217,
169
],
[
173,
172
],
[
227,
176
],
[
233,
177
],
[
235,
179
],
[
245,
182
],
[
172,
185
],
[
221,
186
],
[
172,
188
],
[
245,
190
],
[
227,
196
],
[
172,
198
],
[
248,
199
],
[
221,
200
],
[
248,
204
],
[
221,
205
],
[
229,
208
],
[
242,
209
],
[
230,
212
],
[
236,
212
],
[
218,
212
],
[
214,
215
],
[
217,
218
],
[
247,
221
],
[
223,
224
],
[
247,
227
],
[
242,
229
],
[
229,
230
],
[
247,
233
],
[
235,
236
],
[
238,
239
],
[
241,
242
],
[
247,
248
],
[
250,
251
]
] | [
"MAX = 2*10**5+100\nfact = [0]*MAX\ninv = [0]*MAX\nfinv = [0]*MAX\n \ndef C_init():\n fact[0] = 1\n fact[1] = 1\n finv[0] = 1\n finv[1] = 1\n inv[1] = 1\n \n for i in range(2, MAX):\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 \ndef C(n, r):\n if n<r:\n return 0\n if n<0 or r<0:\n return 0\n return fact[n]*(finv[r]*finv[n-r]%MOD)%MOD\n\nH, W, A, B = map(int, input().split())\nMOD = 10**9+7\nC_init()\nans = 0\n\nfor i in range(H-A):\n ans += C(i+B-1, i)*C(H-1-i+W-B-1, W-B-1)\n ans %= MOD\n\nprint(ans)",
"MAX = 2*10**5+100",
"MAX",
"2*10**5+100",
"2*10**5",
"2",
"10**5",
"10",
"5",
"100",
"fact = [0]*MAX",
"fact",
"[0]*MAX",
"[0]",
"0",
"MAX",
"inv = [0]*MAX",
"inv",
"[0]*MAX",
"[0]",
"0",
"MAX",
"finv = [0]*MAX",
"finv",
"[0]*MAX",
"[0]",
"0",
"MAX",
"def C_init():\n fact[0] = 1\n fact[1] = 1\n finv[0] = 1\n finv[1] = 1\n inv[1] = 1\n \n for i in range(2, MAX):\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 ",
"C_init",
"fact[0] = 1",
"fact[0]",
"fact",
"0",
"1",
"fact[1] = 1",
"fact[1]",
"fact",
"1",
"1",
"finv[0] = 1",
"finv[0]",
"finv",
"0",
"1",
"finv[1] = 1",
"finv[1]",
"finv",
"1",
"1",
"inv[1] = 1",
"inv[1]",
"inv",
"1",
"1",
"for i in range(2, MAX):\n 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, MAX)",
"range",
"2",
"MAX",
"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",
"def C(n, r):\n if n<r:\n return 0\n if n<0 or r<0:\n return 0\n return fact[n]*(finv[r]*finv[n-r]%MOD)%MOD",
"C",
"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 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",
"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_init()",
"C_init",
"ans = 0",
"ans",
"0",
"for i in range(H-A):\n ans += C(i+B-1, i)*C(H-1-i+W-B-1, W-B-1)\n ans %= MOD",
"i",
"range(H-A)",
"range",
"H-A",
"H",
"A",
"ans += C(i+B-1, i)*C(H-1-i+W-B-1, W-B-1)",
"ans",
"C(i+B-1, i)*C(H-1-i+W-B-1, W-B-1)",
"C(i+B-1, i)",
"C",
"i+B-1",
"i+B",
"i",
"B",
"1",
"i",
"C(H-1-i+W-B-1, 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",
"W-B-1",
"W-B",
"W",
"B",
"1",
"ans %= MOD",
"ans",
"MOD",
"print(ans)",
"print",
"ans",
"inv = [0]*MAX",
"[0]*MAX",
"inv",
"ans = 0",
"0",
"ans",
"B = map(int, input().split())",
"map(int, input().split())",
"B",
"MAX = 2*10**5+100",
"2*10**5+100",
"MAX",
"H, W, A, B = map(int, input().split())",
"map(int, input().split())",
"H",
"ans %= MOD",
"MOD",
"ans",
"A, B = map(int, input().split())",
"map(int, input().split())",
"A",
"ans += C(i+B-1, i)*C(H-1-i+W-B-1, W-B-1)",
"C(i+B-1, i)*C(H-1-i+W-B-1, W-B-1)",
"ans",
"finv = [0]*MAX",
"[0]*MAX",
"finv",
"MOD = 10**9+7",
"10**9+7",
"MOD",
"def C(n, r):\n if n<r:\n return 0\n if n<0 or r<0:\n return 0\n return fact[n]*(finv[r]*finv[n-r]%MOD)%MOD",
"def C(n, r):\n if n<r:\n return 0\n if n<0 or r<0:\n return 0\n return fact[n]*(finv[r]*finv[n-r]%MOD)%MOD",
"C",
"W, A, B = map(int, input().split())",
"map(int, input().split())",
"W",
"fact = [0]*MAX",
"[0]*MAX",
"fact",
"def C_init():\n fact[0] = 1\n fact[1] = 1\n finv[0] = 1\n finv[1] = 1\n inv[1] = 1\n \n for i in range(2, MAX):\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 ",
"def C_init():\n fact[0] = 1\n fact[1] = 1\n finv[0] = 1\n finv[1] = 1\n inv[1] = 1\n \n for i in range(2, MAX):\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 ",
"C_init"
] | MAX = 2*10**5+100
fact = [0]*MAX
inv = [0]*MAX
finv = [0]*MAX
def C_init():
fact[0] = 1
fact[1] = 1
finv[0] = 1
finv[1] = 1
inv[1] = 1
for i in range(2, MAX):
fact[i] = fact[i-1]*i%MOD
inv[i] = MOD-inv[MOD%i]*(MOD//i)%MOD
finv[i] = finv[i-1]*inv[i]%MOD
def C(n, r):
if n<r:
return 0
if n<0 or r<0:
return 0
return fact[n]*(finv[r]*finv[n-r]%MOD)%MOD
H, W, A, B = map(int, input().split())
MOD = 10**9+7
C_init()
ans = 0
for i in range(H-A):
ans += C(i+B-1, i)*C(H-1-i+W-B-1, W-B-1)
ans %= MOD
print(ans) |
[
7,
0,
13,
4,
13,
13,
4,
18,
4,
13,
13,
13,
13,
13,
0,
13,
39,
0,
13,
39,
0,
13,
2,
2,
17,
17,
17,
4,
18,
13,
13,
17,
0,
13,
17,
28,
13,
4,
13,
17,
2,
2,
13,
13,
17,
0,
13,
2,
2,
13,
13,
13,
4,
18,
13,
13,
13,
28,
13,
4,
13,
2,
2,
13,
13,
17,
4,
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,
2,
13,
2,
2,
2,
2,
2,
18,
13,
2,
2,
13,
17,
13,
18,
13,
2,
2,
2,
2,
13,
17,
13,
13,
13,
18,
13,
13,
18,
13,
2,
13,
17,
18,
13,
2,
2,
13,
17,
13,
18,
13,
2,
2,
13,
13,
17,
13,
4,
13,
13,
10,
17,
13,
10,
39,
13,
10,
4,
13,
10,
2,
13,
10,
2,
13,
10,
4,
13,
10,
17,
13,
10,
4,
13,
10,
4,
13,
10,
39,
13,
10,
2,
13
] | [
[
168,
2
],
[
168,
11
],
[
168,
12
],
[
168,
13
],
[
171,
15
],
[
147,
18
],
[
153,
21
],
[
172,
29
],
[
162,
33
],
[
37,
36
],
[
160,
42
],
[
151,
43
],
[
156,
46
],
[
163,
49
],
[
157,
49
],
[
36,
50
],
[
154,
51
],
[
172,
54
],
[
157,
56
],
[
163,
56
],
[
59,
58
],
[
160,
63
],
[
151,
64
],
[
148,
68
],
[
172,
73
],
[
58,
74
],
[
154,
76
],
[
154,
78
],
[
144,
80
],
[
84,
83
],
[
160,
87
],
[
169,
88
],
[
174,
90
],
[
145,
93
],
[
175,
93
],
[
172,
100
],
[
166,
103
],
[
83,
105
],
[
172,
107
],
[
160,
112
],
[
83,
114
],
[
151,
115
],
[
166,
116
],
[
148,
118
],
[
83,
119
],
[
148,
121
],
[
166,
123
],
[
148,
126
],
[
160,
129
],
[
83,
131
],
[
148,
133
],
[
151,
136
],
[
166,
137
],
[
154,
139
],
[
175,
142
],
[
145,
142
],
[
144,
145
],
[
147,
148
],
[
168,
151
],
[
153,
154
],
[
156,
157
],
[
168,
160
],
[
162,
163
],
[
168,
166
],
[
168,
169
],
[
171,
172
],
[
174,
175
]
] | [
"h,w,a,b=map(int,input().split())\nfactorials=[]\ninverses=[]\nMOD=10**9+7\nfactorials.append(1)\ncurr=1\nfor i in range(1,h+w+1):\n curr=(curr*i)%MOD\n factorials.append(curr)\nfor i in range(h+w+1):\n inverses.append(pow(factorials[i],MOD-2,MOD))\nans=0\nfor i in range(h-a):\n ans=(ans+factorials[b-1+i]*factorials[h-2-i+w-b]*inverses[i]*inverses[b-1]*inverses[h-1-i]*inverses[w-b-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",
"factorials=[]",
"factorials",
"[]",
"inverses=[]",
"inverses",
"[]",
"MOD=10**9+7",
"MOD",
"10**9+7",
"10**9",
"10",
"9",
"7",
"factorials.append(1)",
"factorials.append",
"factorials",
"append",
"1",
"curr=1",
"curr",
"1",
"for i in range(1,h+w+1):\n curr=(curr*i)%MOD\n factorials.append(curr)",
"i",
"range(1,h+w+1)",
"range",
"1",
"h+w+1",
"h+w",
"h",
"w",
"1",
"curr=(curr*i)%MOD",
"curr",
"(curr*i)%MOD",
"curr*i",
"curr",
"i",
"MOD",
"factorials.append(curr)",
"factorials.append",
"factorials",
"append",
"curr",
"for i in range(h+w+1):\n inverses.append(pow(factorials[i],MOD-2,MOD))",
"i",
"range(h+w+1)",
"range",
"h+w+1",
"h+w",
"h",
"w",
"1",
"inverses.append(pow(factorials[i],MOD-2,MOD))",
"inverses.append",
"inverses",
"append",
"pow(factorials[i],MOD-2,MOD)",
"pow",
"factorials[i]",
"factorials",
"i",
"MOD-2",
"MOD",
"2",
"MOD",
"ans=0",
"ans",
"0",
"for i in range(h-a):\n ans=(ans+factorials[b-1+i]*factorials[h-2-i+w-b]*inverses[i]*inverses[b-1]*inverses[h-1-i]*inverses[w-b-1])%MOD",
"i",
"range(h-a)",
"range",
"h-a",
"h",
"a",
"ans=(ans+factorials[b-1+i]*factorials[h-2-i+w-b]*inverses[i]*inverses[b-1]*inverses[h-1-i]*inverses[w-b-1])%MOD",
"ans",
"(ans+factorials[b-1+i]*factorials[h-2-i+w-b]*inverses[i]*inverses[b-1]*inverses[h-1-i]*inverses[w-b-1])%MOD",
"ans+factorials[b-1+i]*factorials[h-2-i+w-b]*inverses[i]*inverses[b-1]*inverses[h-1-i]*inverses[w-b-1]",
"ans",
"factorials[b-1+i]*factorials[h-2-i+w-b]*inverses[i]*inverses[b-1]*inverses[h-1-i]*inverses[w-b-1]",
"factorials[b-1+i]*factorials[h-2-i+w-b]*inverses[i]*inverses[b-1]*inverses[h-1-i]",
"factorials[b-1+i]*factorials[h-2-i+w-b]*inverses[i]*inverses[b-1]",
"factorials[b-1+i]*factorials[h-2-i+w-b]*inverses[i]",
"factorials[b-1+i]*factorials[h-2-i+w-b]",
"factorials[b-1+i]",
"factorials",
"b-1+i",
"b-1",
"b",
"1",
"i",
"factorials[h-2-i+w-b]",
"factorials",
"h-2-i+w-b",
"h-2-i+w",
"h-2-i",
"h-2",
"h",
"2",
"i",
"w",
"b",
"inverses[i]",
"inverses",
"i",
"inverses[b-1]",
"inverses",
"b-1",
"b",
"1",
"inverses[h-1-i]",
"inverses",
"h-1-i",
"h-1",
"h",
"1",
"i",
"inverses[w-b-1]",
"inverses",
"w-b-1",
"w-b",
"w",
"b",
"1",
"MOD",
"print(ans)",
"print",
"ans",
"ans=0",
"0",
"ans",
"inverses=[]",
"[]",
"inverses",
"w,a,b=map(int,input().split())",
"map(int,input().split())",
"w",
"MOD=10**9+7",
"10**9+7",
"MOD",
"curr=(curr*i)%MOD",
"(curr*i)%MOD",
"curr",
"h,w,a,b=map(int,input().split())",
"map(int,input().split())",
"h",
"curr=1",
"1",
"curr",
"b=map(int,input().split())",
"map(int,input().split())",
"b",
"a,b=map(int,input().split())",
"map(int,input().split())",
"a",
"factorials=[]",
"[]",
"factorials",
"ans=(ans+factorials[b-1+i]*factorials[h-2-i+w-b]*inverses[i]*inverses[b-1]*inverses[h-1-i]*inverses[w-b-1])%MOD",
"(ans+factorials[b-1+i]*factorials[h-2-i+w-b]*inverses[i]*inverses[b-1]*inverses[h-1-i]*inverses[w-b-1])%MOD",
"ans"
] | h,w,a,b=map(int,input().split())
factorials=[]
inverses=[]
MOD=10**9+7
factorials.append(1)
curr=1
for i in range(1,h+w+1):
curr=(curr*i)%MOD
factorials.append(curr)
for i in range(h+w+1):
inverses.append(pow(factorials[i],MOD-2,MOD))
ans=0
for i in range(h-a):
ans=(ans+factorials[b-1+i]*factorials[h-2-i+w-b]*inverses[i]*inverses[b-1]*inverses[h-1-i]*inverses[w-b-1])%MOD
print(ans) |
[
7,
12,
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,
13,
13,
0,
13,
2,
39,
17,
2,
2,
13,
13,
17,
28,
13,
4,
13,
17,
2,
2,
13,
13,
17,
0,
18,
13,
13,
2,
2,
18,
13,
2,
13,
17,
13,
13,
0,
13,
2,
39,
17,
2,
13,
17,
0,
18,
13,
17,
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,
0,
13,
2,
2,
18,
13,
2,
2,
13,
13,
17,
18,
13,
2,
13,
17,
13,
0,
13,
4,
13,
2,
2,
2,
2,
18,
13,
2,
2,
2,
13,
13,
13,
17,
18,
13,
13,
18,
13,
2,
2,
2,
13,
13,
17,
13,
18,
13,
2,
2,
13,
13,
17,
13,
4,
13,
2,
2,
13,
13,
13,
14,
2,
13,
17,
4,
13,
10,
12,
13
] | [
[
5,
4
],
[
5,
14
],
[
5,
15
],
[
5,
16
],
[
19,
18
],
[
26,
25
],
[
4,
28
],
[
14,
29
],
[
32,
31
],
[
4,
37
],
[
14,
38
],
[
42,
41
],
[
4,
47
],
[
14,
48
],
[
54,
51
],
[
31,
52
],
[
41,
53
],
[
31,
57
],
[
41,
59
],
[
41,
61
],
[
18,
62
],
[
65,
64
],
[
25,
69
],
[
75,
72
],
[
64,
73
],
[
31,
78
],
[
25,
79
],
[
18,
81
],
[
18,
83
],
[
86,
85
],
[
25,
89
],
[
97,
94
],
[
64,
95
],
[
85,
96
],
[
64,
100
],
[
85,
102
],
[
85,
105
],
[
18,
107
],
[
110,
109
],
[
64,
113
],
[
4,
116
],
[
15,
117
],
[
64,
120
],
[
15,
122
],
[
18,
124
],
[
127,
126
],
[
31,
134
],
[
4,
138
],
[
15,
139
],
[
94,
142
],
[
64,
143
],
[
31,
146
],
[
15,
150
],
[
14,
151
],
[
64,
155
],
[
14,
158
],
[
18,
161
],
[
126,
166
],
[
109,
167
],
[
18,
168
],
[
177,
174
]
] | [
"def main():\n h,w,a,b=map(int,input().split(' '))\n mod = 10**9+7\n mx=max(h,w)\n fac=[1]*(h+w+1)\n for i in range(1,h+w+1):\n fac[i]=fac[i-1]*i%mod\n rev=[1]*(mx+1)\n rev[-1]=pow(fac[mx],mod-2,mod)\n for i in range(mx-1,-1,-1):\n rev[i]=rev[i+1]*(i+1)%mod\n const=rev[h-a-1]*rev[a-1]%mod\n ans = sum(fac[h - a + i - 1] * rev[i] * fac[a + w - 2 - i] * rev[w - i - 1] % mod for i in range(b, w))\n print(ans * const % mod)\n\n\n\nif __name__ == '__main__':\n main()",
"def main():\n h,w,a,b=map(int,input().split(' '))\n mod = 10**9+7\n mx=max(h,w)\n fac=[1]*(h+w+1)\n for i in range(1,h+w+1):\n fac[i]=fac[i-1]*i%mod\n rev=[1]*(mx+1)\n rev[-1]=pow(fac[mx],mod-2,mod)\n for i in range(mx-1,-1,-1):\n rev[i]=rev[i+1]*(i+1)%mod\n const=rev[h-a-1]*rev[a-1]%mod\n ans = sum(fac[h - a + i - 1] * rev[i] * fac[a + w - 2 - i] * rev[w - i - 1] % mod for i in range(b, w))\n print(ans * const % 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",
"mx=max(h,w)",
"mx",
"max(h,w)",
"max",
"h",
"w",
"fac=[1]*(h+w+1)",
"fac",
"[1]*(h+w+1)",
"[1]",
"1",
"h+w+1",
"h+w",
"h",
"w",
"1",
"for i in range(1,h+w+1):\n fac[i]=fac[i-1]*i%mod\n ",
"i",
"range(1,h+w+1)",
"range",
"1",
"h+w+1",
"h+w",
"h",
"w",
"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",
"rev=[1]*(mx+1)",
"rev",
"[1]*(mx+1)",
"[1]",
"1",
"mx+1",
"mx",
"1",
"rev[-1]=pow(fac[mx],mod-2,mod)",
"rev[-1]",
"rev",
"-1",
"pow(fac[mx],mod-2,mod)",
"pow",
"fac[mx]",
"fac",
"mx",
"mod-2",
"mod",
"2",
"mod",
"for i in range(mx-1,-1,-1):\n rev[i]=rev[i+1]*(i+1)%mod\n ",
"i",
"range(mx-1,-1,-1)",
"range",
"mx-1",
"mx",
"1",
"-1",
"-1",
"rev[i]=rev[i+1]*(i+1)%mod",
"rev[i]",
"rev",
"i",
"rev[i+1]*(i+1)%mod",
"rev[i+1]*(i+1)",
"rev[i+1]",
"rev",
"i+1",
"i",
"1",
"i+1",
"i",
"1",
"mod",
"const=rev[h-a-1]*rev[a-1]%mod",
"const",
"rev[h-a-1]*rev[a-1]%mod",
"rev[h-a-1]*rev[a-1]",
"rev[h-a-1]",
"rev",
"h-a-1",
"h-a",
"h",
"a",
"1",
"rev[a-1]",
"rev",
"a-1",
"a",
"1",
"mod",
"ans = sum(fac[h - a + i - 1] * rev[i] * fac[a + w - 2 - i] * rev[w - i - 1] % mod for i in range(b, w))",
"ans",
"sum(fac[h - a + i - 1] * rev[i] * fac[a + w - 2 - i] * rev[w - i - 1] % mod for i in range(b, w))",
"sum",
"fac[h - a + i - 1] * rev[i] * fac[a + w - 2 - i] * rev[w - i - 1] % mod",
"fac[h - a + i - 1] * rev[i] * fac[a + w - 2 - i] * rev[w - i - 1]",
"fac[h - a + i - 1] * rev[i] * fac[a + w - 2 - i]",
"fac[h - a + i - 1] * rev[i]",
"fac[h - a + i - 1]",
"fac",
"h - a + i - 1",
"h - a + i",
"h - a",
"h",
"a",
"i",
"1",
"rev[i]",
"rev",
"i",
"fac[a + w - 2 - i]",
"fac",
"a + w - 2 - i",
"a + w - 2",
"a + w",
"a",
"w",
"2",
"i",
"rev[w - i - 1]",
"rev",
"w - i - 1",
"w - i",
"w",
"i",
"1",
"mod",
"print(ans * const % mod)",
"print",
"ans * const % mod",
"ans * const",
"ans",
"const",
"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 mx=max(h,w)\n fac=[1]*(h+w+1)\n for i in range(1,h+w+1):\n fac[i]=fac[i-1]*i%mod\n rev=[1]*(mx+1)\n rev[-1]=pow(fac[mx],mod-2,mod)\n for i in range(mx-1,-1,-1):\n rev[i]=rev[i+1]*(i+1)%mod\n const=rev[h-a-1]*rev[a-1]%mod\n ans = sum(fac[h - a + i - 1] * rev[i] * fac[a + w - 2 - i] * rev[w - i - 1] % mod for i in range(b, w))\n print(ans * const % mod)",
"def main():\n h,w,a,b=map(int,input().split(' '))\n mod = 10**9+7\n mx=max(h,w)\n fac=[1]*(h+w+1)\n for i in range(1,h+w+1):\n fac[i]=fac[i-1]*i%mod\n rev=[1]*(mx+1)\n rev[-1]=pow(fac[mx],mod-2,mod)\n for i in range(mx-1,-1,-1):\n rev[i]=rev[i+1]*(i+1)%mod\n const=rev[h-a-1]*rev[a-1]%mod\n ans = sum(fac[h - a + i - 1] * rev[i] * fac[a + w - 2 - i] * rev[w - i - 1] % mod for i in range(b, w))\n print(ans * const % mod)",
"main"
] | def main():
h,w,a,b=map(int,input().split(' '))
mod = 10**9+7
mx=max(h,w)
fac=[1]*(h+w+1)
for i in range(1,h+w+1):
fac[i]=fac[i-1]*i%mod
rev=[1]*(mx+1)
rev[-1]=pow(fac[mx],mod-2,mod)
for i in range(mx-1,-1,-1):
rev[i]=rev[i+1]*(i+1)%mod
const=rev[h-a-1]*rev[a-1]%mod
ans = sum(fac[h - a + i - 1] * rev[i] * fac[a + w - 2 - i] * rev[w - i - 1] % mod for i in range(b, w))
print(ans * const % mod)
if __name__ == '__main__':
main()
|
[
7,
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,
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,
2,
39,
17,
2,
2,
13,
13,
17,
28,
13,
4,
13,
17,
2,
2,
13,
13,
17,
0,
18,
13,
13,
2,
2,
18,
13,
2,
13,
17,
13,
13,
0,
13,
17,
28,
13,
4,
13,
13,
13,
0,
13,
2,
2,
4,
13,
2,
2,
2,
13,
13,
13,
17,
13,
13,
13,
4,
13,
2,
2,
2,
2,
13,
17,
13,
13,
17,
2,
2,
13,
13,
17,
13,
13,
13,
4,
13,
2,
13,
13,
14,
2,
13,
17,
4,
13,
10,
12,
13,
10,
12,
13
] | [
[
36,
8
],
[
32,
9
],
[
36,
13
],
[
34,
14
],
[
38,
16
],
[
38,
18
],
[
36,
22
],
[
32,
24
],
[
34,
25
],
[
38,
27
],
[
38,
29
],
[
38,
30
],
[
32,
32
],
[
34,
34
],
[
36,
36
],
[
38,
38
],
[
43,
42
],
[
43,
51
],
[
43,
52
],
[
43,
53
],
[
56,
55
],
[
63,
62
],
[
42,
68
],
[
51,
69
],
[
73,
72
],
[
42,
78
],
[
51,
79
],
[
85,
82
],
[
62,
83
],
[
72,
84
],
[
62,
88
],
[
72,
90
],
[
72,
92
],
[
55,
93
],
[
96,
95
],
[
99,
98
],
[
53,
101
],
[
51,
102
],
[
105,
104
],
[
154,
108
],
[
42,
112
],
[
52,
113
],
[
98,
114
],
[
98,
116
],
[
62,
117
],
[
55,
118
],
[
154,
120
],
[
51,
125
],
[
98,
127
],
[
52,
128
],
[
51,
132
],
[
98,
133
],
[
62,
135
],
[
55,
136
],
[
55,
137
],
[
104,
141
],
[
95,
141
],
[
55,
142
],
[
151,
148
]
] | [
"def cmb(a, b, fact, mod):\n return fact[a] * pow(fact[b], mod - 2, mod) * pow(fact[a - b], mod - 2, mod) % mod\n\n\ndef main():\n h, w, a, b = map(int, input().split())\n mod = 10 ** 9 + 7\n\n fact = [1] * (h + w + 1)\n for i in range(1, h + w + 1):\n fact[i] = (fact[i - 1] * i) % mod\n\n ans = 0\n for i in range(b, w):\n ans += cmb(h - a + i - 1, i, fact, mod) * cmb(w - 1 - i + a - 1, w - i - 1, fact, mod) % mod\n print(ans % mod)\n\nif __name__ == '__main__':\n main()\n",
"def cmb(a, b, fact, mod):\n return fact[a] * pow(fact[b], mod - 2, mod) * pow(fact[a - b], mod - 2, mod) % mod",
"cmb",
"return fact[a] * pow(fact[b], mod - 2, mod) * pow(fact[a - b], mod - 2, mod) % mod",
"fact[a] * pow(fact[b], mod - 2, mod) * pow(fact[a - b], mod - 2, mod) % mod",
"fact[a] * pow(fact[b], mod - 2, mod) * pow(fact[a - b], mod - 2, mod)",
"fact[a] * pow(fact[b], mod - 2, mod)",
"fact[a]",
"fact",
"a",
"pow(fact[b], mod - 2, mod)",
"pow",
"fact[b]",
"fact",
"b",
"mod - 2",
"mod",
"2",
"mod",
"pow(fact[a - b], mod - 2, mod)",
"pow",
"fact[a - b]",
"fact",
"a - b",
"a",
"b",
"mod - 2",
"mod",
"2",
"mod",
"mod",
"a",
"a",
"b",
"b",
"fact",
"fact",
"mod",
"mod",
"def main():\n h, w, a, b = map(int, input().split())\n mod = 10 ** 9 + 7\n\n fact = [1] * (h + w + 1)\n for i in range(1, h + w + 1):\n fact[i] = (fact[i - 1] * i) % mod\n\n ans = 0\n for i in range(b, w):\n ans += cmb(h - a + i - 1, i, fact, mod) * cmb(w - 1 - i + a - 1, w - i - 1, fact, mod) % 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",
"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",
"for i in range(1, h + w + 1):\n fact[i] = (fact[i - 1] * i) % mod\n\n ",
"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",
"ans = 0",
"ans",
"0",
"for i in range(b, w):\n ans += cmb(h - a + i - 1, i, fact, mod) * cmb(w - 1 - i + a - 1, w - i - 1, fact, mod) % mod\n ",
"i",
"range(b, w)",
"range",
"b",
"w",
"ans += cmb(h - a + i - 1, i, fact, mod) * cmb(w - 1 - i + a - 1, w - i - 1, fact, mod) % mod",
"ans",
"cmb(h - a + i - 1, i, fact, mod) * cmb(w - 1 - i + a - 1, w - i - 1, fact, mod) % mod",
"cmb(h - a + i - 1, i, fact, mod) * cmb(w - 1 - i + a - 1, w - i - 1, fact, mod)",
"cmb(h - a + i - 1, i, fact, mod)",
"cmb",
"h - a + i - 1",
"h - a + i",
"h - a",
"h",
"a",
"i",
"1",
"i",
"fact",
"mod",
"cmb(w - 1 - i + a - 1, w - i - 1, fact, mod)",
"cmb",
"w - 1 - i + a - 1",
"w - 1 - i + a",
"w - 1 - i",
"w - 1",
"w",
"1",
"i",
"a",
"1",
"w - i - 1",
"w - i",
"w",
"i",
"1",
"fact",
"mod",
"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\n fact = [1] * (h + w + 1)\n for i in range(1, h + w + 1):\n fact[i] = (fact[i - 1] * i) % mod\n\n ans = 0\n for i in range(b, w):\n ans += cmb(h - a + i - 1, i, fact, mod) * cmb(w - 1 - i + a - 1, w - i - 1, fact, mod) % mod\n print(ans % mod)",
"def main():\n h, w, a, b = map(int, input().split())\n mod = 10 ** 9 + 7\n\n fact = [1] * (h + w + 1)\n for i in range(1, h + w + 1):\n fact[i] = (fact[i - 1] * i) % mod\n\n ans = 0\n for i in range(b, w):\n ans += cmb(h - a + i - 1, i, fact, mod) * cmb(w - 1 - i + a - 1, w - i - 1, fact, mod) % mod\n print(ans % mod)",
"main",
"def cmb(a, b, fact, mod):\n return fact[a] * pow(fact[b], mod - 2, mod) * pow(fact[a - b], mod - 2, mod) % mod",
"def cmb(a, b, fact, mod):\n return fact[a] * pow(fact[b], mod - 2, mod) * pow(fact[a - b], mod - 2, mod) % mod",
"cmb"
] | def cmb(a, b, fact, mod):
return fact[a] * pow(fact[b], mod - 2, mod) * pow(fact[a - b], mod - 2, mod) % mod
def main():
h, w, a, b = map(int, input().split())
mod = 10 ** 9 + 7
fact = [1] * (h + w + 1)
for i in range(1, h + w + 1):
fact[i] = (fact[i - 1] * i) % mod
ans = 0
for i in range(b, w):
ans += cmb(h - a + i - 1, i, fact, mod) * cmb(w - 1 - i + a - 1, w - i - 1, fact, mod) % mod
print(ans % mod)
if __name__ == '__main__':
main()
|
[
7,
0,
13,
2,
2,
17,
17,
17,
12,
13,
14,
2,
13,
17,
29,
39,
13,
17,
17,
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,
2,
13,
13,
13,
23,
13,
23,
13,
0,
13,
2,
2,
17,
2,
17,
17,
17,
0,
13,
2,
39,
17,
13,
0,
18,
13,
17,
17,
28,
13,
4,
13,
17,
13,
0,
18,
13,
13,
2,
2,
18,
13,
2,
13,
17,
13,
13,
12,
13,
29,
4,
13,
4,
13,
18,
13,
13,
18,
13,
2,
13,
13,
18,
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,
4,
13,
2,
13,
13,
2,
13,
13,
0,
13,
2,
2,
2,
13,
17,
13,
13,
0,
13,
2,
13,
13,
0,
13,
2,
4,
13,
2,
13,
13,
13,
4,
13,
2,
2,
2,
13,
17,
13,
2,
2,
13,
17,
13,
2,
2,
13,
17,
13,
0,
13,
13,
0,
13,
13,
4,
13,
13,
10,
4,
13,
10,
4,
13,
10,
17,
13,
10,
13,
13,
10,
2,
13,
10,
2,
13,
10,
4,
13,
10,
13,
13,
10,
2,
13,
10,
12,
13,
10,
12,
13,
10,
2,
13,
10,
12,
13,
10,
2,
13,
10,
4,
13,
10,
2,
13
] | [
[
229,
2
],
[
44,
12
],
[
21,
20
],
[
44,
23
],
[
42,
25
],
[
44,
26
],
[
21,
27
],
[
21,
28
],
[
31,
30
],
[
42,
33
],
[
44,
34
],
[
28,
35
],
[
42,
42
],
[
44,
44
],
[
49,
48
],
[
242,
50
],
[
64,
51
],
[
230,
52
],
[
49,
53
],
[
49,
54
],
[
62,
58
],
[
53,
59
],
[
230,
60
],
[
62,
62
],
[
64,
64
],
[
244,
66
],
[
220,
75
],
[
245,
79
],
[
84,
81
],
[
221,
82
],
[
87,
86
],
[
245,
90
],
[
95,
92
],
[
221,
93
],
[
86,
94
],
[
221,
98
],
[
86,
100
],
[
86,
102
],
[
230,
103
],
[
233,
108
],
[
233,
110
],
[
221,
112
],
[
123,
113
],
[
221,
115
],
[
123,
117
],
[
125,
118
],
[
221,
120
],
[
125,
121
],
[
123,
123
],
[
125,
125
],
[
247,
127
],
[
247,
136
],
[
247,
137
],
[
247,
138
],
[
211,
140
],
[
144,
143
],
[
206,
149
],
[
224,
150
],
[
209,
152
],
[
248,
153
],
[
217,
155
],
[
206,
159
],
[
224,
161
],
[
143,
162
],
[
250,
164
],
[
248,
166
],
[
143,
167
],
[
238,
169
],
[
236,
172
],
[
218,
174
],
[
251,
175
],
[
218,
176
],
[
236,
178
],
[
206,
182
],
[
218,
184
],
[
209,
187
],
[
251,
189
],
[
206,
192
],
[
218,
194
],
[
226,
196
],
[
239,
197
],
[
214,
199
],
[
230,
200
],
[
215,
203
],
[
227,
203
],
[
212,
203
],
[
247,
206
],
[
247,
209
],
[
211,
212
],
[
230,
214
],
[
214,
215
],
[
217,
218
],
[
220,
221
],
[
247,
224
],
[
239,
226
],
[
226,
227
],
[
229,
230
],
[
238,
239
],
[
244,
245
],
[
247,
248
],
[
250,
251
]
] | [
"mod = 10 ** 9 + 7\ndef extGCD(a, b):\n if b == 0:\n return a, 1, 0\n g, y, x = extGCD(b, a%b)\n y -= a//b * x\n return g, x, y\n\ndef moddiv(a, b):\n _, inv, _ = extGCD(b, mod)\n return (a * inv) % mod\n\nN = 2 * 10 ** 5 + 10\nfact = [0] * (N)\nfact[0] = 1\nfor i in range(1, N):\n fact[i] = (fact[i-1] * i) % mod\n\ndef comb(a, b):\n return moddiv(moddiv(fact[a], fact[a-b]), fact[b])\n\nh, w, a, b = map(int, input().split())\n\nans = 0\nfor i in range(min(h-a, w-b)):\n x = h - 1 - a - i\n y = b + i\n plus = comb(x + y, x) * comb((h-1 - x) + (w-1 - y), (h-1 - x))\n ans += plus\n ans %= mod\nprint(ans)",
"mod = 10 ** 9 + 7",
"mod",
"10 ** 9 + 7",
"10 ** 9",
"10",
"9",
"7",
"def extGCD(a, b):\n if b == 0:\n return a, 1, 0\n g, y, x = extGCD(b, a%b)\n y -= a//b * x\n return g, x, y",
"extGCD",
"if b == 0:\n return a, 1, 0\n ",
"b == 0",
"b",
"0",
"return a, 1, 0",
"return a, 1, 0",
"a",
"1",
"0",
"g, y, x = extGCD(b, a%b)",
"g",
"extGCD(b, a%b)",
"extGCD",
"b",
"a%b",
"a",
"b",
"y",
"x",
"y -= a//b * x",
"y",
"a//b * x",
"a//b",
"a",
"b",
"x",
"return g, x, y",
"return g, x, y",
"g",
"x",
"y",
"a",
"a",
"b",
"b",
"def moddiv(a, b):\n _, inv, _ = extGCD(b, mod)\n return (a * inv) % mod",
"moddiv",
"_, inv, _ = extGCD(b, mod)",
"_",
"extGCD(b, mod)",
"extGCD",
"b",
"mod",
"inv",
"_",
"return (a * inv) % mod",
"(a * inv) % mod",
"a * inv",
"a",
"inv",
"mod",
"a",
"a",
"b",
"b",
"N = 2 * 10 ** 5 + 10",
"N",
"2 * 10 ** 5 + 10",
"2 * 10 ** 5",
"2",
"10 ** 5",
"10",
"5",
"10",
"fact = [0] * (N)",
"fact",
"[0] * (N)",
"[0]",
"0",
"N",
"fact[0] = 1",
"fact[0]",
"fact",
"0",
"1",
"for i in range(1, N):\n fact[i] = (fact[i-1] * i) % mod",
"i",
"range(1, N)",
"range",
"1",
"N",
"fact[i] = (fact[i-1] * i) % mod",
"fact[i]",
"fact",
"i",
"(fact[i-1] * i) % mod",
"fact[i-1] * i",
"fact[i-1]",
"fact",
"i-1",
"i",
"1",
"i",
"mod",
"def comb(a, b):\n return moddiv(moddiv(fact[a], fact[a-b]), fact[b])",
"comb",
"return moddiv(moddiv(fact[a], fact[a-b]), fact[b])",
"moddiv(moddiv(fact[a], fact[a-b]), fact[b])",
"moddiv",
"moddiv(fact[a], fact[a-b])",
"moddiv",
"fact[a]",
"fact",
"a",
"fact[a-b]",
"fact",
"a-b",
"a",
"b",
"fact[b]",
"fact",
"b",
"a",
"a",
"b",
"b",
"h, w, a, b = map(int, input().split())",
"h",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"w",
"a",
"b",
"ans = 0",
"ans",
"0",
"for i in range(min(h-a, w-b)):\n x = h - 1 - a - i\n y = b + i\n plus = comb(x + y, x) * comb((h-1 - x) + (w-1 - y), (h-1 - x))\n ans += plus\n ans %= mod",
"i",
"range(min(h-a, w-b))",
"range",
"min(h-a, w-b)",
"min",
"h-a",
"h",
"a",
"w-b",
"w",
"b",
"x = h - 1 - a - i",
"x",
"h - 1 - a - i",
"h - 1 - a",
"h - 1",
"h",
"1",
"a",
"i",
"y = b + i",
"y",
"b + i",
"b",
"i",
"plus = comb(x + y, x) * comb((h-1 - x) + (w-1 - y), (h-1 - x))",
"plus",
"comb(x + y, x) * comb((h-1 - x) + (w-1 - y), (h-1 - x))",
"comb(x + y, x)",
"comb",
"x + y",
"x",
"y",
"x",
"comb((h-1 - x) + (w-1 - y), (h-1 - x))",
"comb",
"(h-1 - x) + (w-1 - y)",
"h-1 - x",
"h-1",
"h",
"1",
"x",
"w-1 - y",
"w-1",
"w",
"1",
"y",
"h-1 - x",
"h-1",
"h",
"1",
"x",
"ans += plus",
"ans",
"plus",
"ans %= mod",
"ans",
"mod",
"print(ans)",
"print",
"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",
"ans = 0",
"0",
"ans",
"ans %= mod",
"mod",
"ans",
"x = h - 1 - a - i",
"h - 1 - a - i",
"x",
"fact = [0] * (N)",
"[0] * (N)",
"fact",
"a, b = map(int, input().split())",
"map(int, input().split())",
"a",
"ans += plus",
"plus",
"ans",
"mod = 10 ** 9 + 7",
"10 ** 9 + 7",
"mod",
"def moddiv(a, b):\n _, inv, _ = extGCD(b, mod)\n return (a * inv) % mod",
"def moddiv(a, b):\n _, inv, _ = extGCD(b, mod)\n return (a * inv) % mod",
"moddiv",
"def comb(a, b):\n return moddiv(moddiv(fact[a], fact[a-b]), fact[b])",
"def comb(a, b):\n return moddiv(moddiv(fact[a], fact[a-b]), fact[b])",
"comb",
"plus = comb(x + y, x) * comb((h-1 - x) + (w-1 - y), (h-1 - x))",
"comb(x + y, x) * comb((h-1 - x) + (w-1 - y), (h-1 - x))",
"plus",
"def extGCD(a, b):\n if b == 0:\n return a, 1, 0\n g, y, x = extGCD(b, a%b)\n y -= a//b * x\n return g, x, y",
"def extGCD(a, b):\n if b == 0:\n return a, 1, 0\n g, y, x = extGCD(b, a%b)\n y -= a//b * x\n return g, x, y",
"extGCD",
"N = 2 * 10 ** 5 + 10",
"2 * 10 ** 5 + 10",
"N",
"b = map(int, input().split())",
"map(int, input().split())",
"b",
"y = b + i",
"b + i",
"y"
] | mod = 10 ** 9 + 7
def extGCD(a, b):
if b == 0:
return a, 1, 0
g, y, x = extGCD(b, a%b)
y -= a//b * x
return g, x, y
def moddiv(a, b):
_, inv, _ = extGCD(b, mod)
return (a * inv) % mod
N = 2 * 10 ** 5 + 10
fact = [0] * (N)
fact[0] = 1
for i in range(1, N):
fact[i] = (fact[i-1] * i) % mod
def comb(a, b):
return moddiv(moddiv(fact[a], fact[a-b]), fact[b])
h, w, a, b = map(int, input().split())
ans = 0
for i in range(min(h-a, w-b)):
x = h - 1 - a - i
y = b + i
plus = comb(x + y, x) * comb((h-1 - x) + (w-1 - y), (h-1 - x))
ans += plus
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,
2,
39,
17,
17,
2,
17,
17,
0,
13,
2,
2,
39,
17,
17,
2,
17,
17,
0,
13,
2,
2,
39,
17,
17,
2,
17,
17,
0,
18,
13,
17,
17,
0,
18,
13,
17,
17,
0,
18,
13,
17,
17,
0,
18,
13,
17,
17,
0,
18,
13,
17,
17,
28,
13,
4,
13,
17,
2,
17,
2,
17,
17,
0,
18,
13,
13,
2,
2,
18,
13,
2,
13,
17,
13,
13,
0,
18,
13,
13,
2,
13,
2,
2,
18,
13,
2,
13,
13,
2,
13,
13,
13,
0,
18,
13,
13,
2,
2,
18,
13,
2,
13,
17,
18,
13,
13,
13,
12,
13,
14,
2,
13,
13,
29,
17,
14,
2,
2,
13,
17,
2,
13,
17,
29,
17,
29,
2,
2,
18,
13,
13,
2,
2,
18,
13,
13,
18,
13,
2,
13,
13,
13,
13,
23,
13,
23,
13,
0,
13,
17,
28,
13,
4,
13,
13,
13,
0,
13,
2,
4,
13,
2,
2,
2,
13,
13,
17,
13,
13,
4,
13,
2,
2,
2,
2,
13,
17,
13,
13,
17,
2,
2,
13,
13,
17,
0,
13,
2,
13,
13,
4,
13,
13,
10,
4,
13,
10,
2,
13,
10,
12,
13,
10,
17,
13,
10,
2,
13,
10,
4,
13,
10,
2,
13,
10,
4,
13,
10,
4,
13,
10,
2,
13,
10,
2,
13,
10,
2,
13
] | [
[
242,
2
],
[
242,
11
],
[
242,
12
],
[
242,
13
],
[
251,
15
],
[
221,
22
],
[
236,
32
],
[
248,
42
],
[
60,
52
],
[
222,
53
],
[
60,
57
],
[
222,
58
],
[
70,
62
],
[
237,
63
],
[
70,
67
],
[
237,
68
],
[
75,
72
],
[
249,
73
],
[
78,
77
],
[
90,
87
],
[
222,
88
],
[
77,
89
],
[
222,
93
],
[
77,
95
],
[
77,
97
],
[
252,
98
],
[
103,
100
],
[
249,
101
],
[
77,
102
],
[
252,
104
],
[
249,
108
],
[
252,
110
],
[
77,
111
],
[
252,
113
],
[
77,
114
],
[
252,
115
],
[
120,
117
],
[
237,
118
],
[
77,
119
],
[
237,
123
],
[
77,
125
],
[
100,
127
],
[
249,
128
],
[
77,
129
],
[
252,
130
],
[
168,
135
],
[
170,
136
],
[
168,
142
],
[
170,
145
],
[
222,
153
],
[
168,
154
],
[
237,
158
],
[
170,
159
],
[
237,
161
],
[
168,
163
],
[
170,
164
],
[
252,
165
],
[
252,
166
],
[
168,
168
],
[
170,
170
],
[
227,
172
],
[
176,
175
],
[
219,
178
],
[
234,
179
],
[
245,
181
],
[
225,
184
],
[
240,
188
],
[
243,
189
],
[
175,
191
],
[
175,
192
],
[
225,
194
],
[
243,
199
],
[
234,
201
],
[
175,
202
],
[
234,
206
],
[
175,
207
],
[
230,
210
],
[
246,
212
],
[
228,
212
],
[
231,
212
],
[
252,
213
],
[
231,
216
],
[
246,
216
],
[
228,
216
],
[
242,
219
],
[
221,
222
],
[
227,
228
],
[
230,
231
],
[
242,
234
],
[
236,
237
],
[
242,
240
],
[
242,
243
],
[
245,
246
],
[
248,
249
],
[
251,
252
]
] | [
"# coding: utf-8\n# Your code here!\nh,w,a,b=map(int,input().split())\nMOD=10**9+7\nfac=[0]*2*10**5\nfinv=[0]*2*10**5\ninv=[0]*2*10**5\nfac[0]=fac[1]=1\nfinv[0]=finv[1]=1\ninv[1]=1\nfor i in range(2,2*10**5):\n fac[i]=(fac[i-1]*i)%MOD\n inv[i]=MOD-inv[MOD%i]*(MOD//i)%MOD\n finv[i]=finv[i-1]*inv[i]%MOD\ndef COM(n,k):\n if n<k:\n return 0\n if n<0 or k<0:\n return 0\n return fac[n]*(finv[k]*finv[n-k]%MOD)%MOD\nans=0\nfor i in range(b,w): \n ans+=COM(h-a-1+i,i)*COM(a-1+w-i-1,w-i-1)\n ans=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",
"fac=[0]*2*10**5",
"fac",
"[0]*2*10**5",
"[0]*2",
"[0]",
"0",
"2",
"10**5",
"10",
"5",
"finv=[0]*2*10**5",
"finv",
"[0]*2*10**5",
"[0]*2",
"[0]",
"0",
"2",
"10**5",
"10",
"5",
"inv=[0]*2*10**5",
"inv",
"[0]*2*10**5",
"[0]*2",
"[0]",
"0",
"2",
"10**5",
"10",
"5",
"fac[0]=fac[1]=1",
"fac[0]",
"fac",
"0",
"1",
"=fac[1]=1",
"fac[1]",
"fac",
"1",
"1",
"finv[0]=finv[1]=1",
"finv[0]",
"finv",
"0",
"1",
"=finv[1]=1",
"finv[1]",
"finv",
"1",
"1",
"inv[1]=1",
"inv[1]",
"inv",
"1",
"1",
"for i in range(2,2*10**5):\n fac[i]=(fac[i-1]*i)%MOD\n inv[i]=MOD-inv[MOD%i]*(MOD//i)%MOD\n finv[i]=finv[i-1]*inv[i]%MOD",
"i",
"range(2,2*10**5)",
"range",
"2",
"2*10**5",
"2",
"10**5",
"10",
"5",
"fac[i]=(fac[i-1]*i)%MOD",
"fac[i]",
"fac",
"i",
"(fac[i-1]*i)%MOD",
"fac[i-1]*i",
"fac[i-1]",
"fac",
"i-1",
"i",
"1",
"i",
"MOD",
"inv[i]=MOD-inv[MOD%i]*(MOD//i)%MOD",
"inv[i]",
"inv",
"i",
"MOD-inv[MOD%i]*(MOD//i)%MOD",
"MOD",
"inv[MOD%i]*(MOD//i)%MOD",
"inv[MOD%i]*(MOD//i)",
"inv[MOD%i]",
"inv",
"MOD%i",
"MOD",
"i",
"MOD//i",
"MOD",
"i",
"MOD",
"finv[i]=finv[i-1]*inv[i]%MOD",
"finv[i]",
"finv",
"i",
"finv[i-1]*inv[i]%MOD",
"finv[i-1]*inv[i]",
"finv[i-1]",
"finv",
"i-1",
"i",
"1",
"inv[i]",
"inv",
"i",
"MOD",
"def COM(n,k):\n if n<k:\n return 0\n if n<0 or k<0:\n return 0\n return fac[n]*(finv[k]*finv[n-k]%MOD)%MOD",
"COM",
"if n<k:\n return 0\n ",
"n<k",
"n",
"k",
"return 0",
"0",
"if n<0 or k<0:\n return 0\n ",
"n<0 or k<0",
"n<0",
"n",
"0",
"k<0",
"k",
"0",
"return 0",
"0",
"return fac[n]*(finv[k]*finv[n-k]%MOD)%MOD",
"fac[n]*(finv[k]*finv[n-k]%MOD)%MOD",
"fac[n]*(finv[k]*finv[n-k]%MOD)",
"fac[n]",
"fac",
"n",
"finv[k]*finv[n-k]%MOD",
"finv[k]*finv[n-k]",
"finv[k]",
"finv",
"k",
"finv[n-k]",
"finv",
"n-k",
"n",
"k",
"MOD",
"MOD",
"n",
"n",
"k",
"k",
"ans=0",
"ans",
"0",
"for i in range(b,w): \n ans+=COM(h-a-1+i,i)*COM(a-1+w-i-1,w-i-1)\n ans=ans%MOD",
"i",
"range(b,w)",
"range",
"b",
"w",
"ans+=COM(h-a-1+i,i)*COM(a-1+w-i-1,w-i-1)",
"ans",
"COM(h-a-1+i,i)*COM(a-1+w-i-1,w-i-1)",
"COM(h-a-1+i,i)",
"COM",
"h-a-1+i",
"h-a-1",
"h-a",
"h",
"a",
"1",
"i",
"i",
"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",
"ans=ans%MOD",
"ans",
"ans%MOD",
"ans",
"MOD",
"print(ans)",
"print",
"ans",
"b=map(int,input().split())",
"map(int,input().split())",
"b",
"fac=[0]*2*10**5",
"[0]*2*10**5",
"fac",
"def COM(n,k):\n if n<k:\n return 0\n if n<0 or k<0:\n return 0\n return fac[n]*(finv[k]*finv[n-k]%MOD)%MOD",
"def COM(n,k):\n if n<k:\n return 0\n if n<0 or k<0:\n return 0\n return fac[n]*(finv[k]*finv[n-k]%MOD)%MOD",
"COM",
"ans=0",
"0",
"ans",
"ans=ans%MOD",
"ans%MOD",
"ans",
"w,a,b=map(int,input().split())",
"map(int,input().split())",
"w",
"finv=[0]*2*10**5",
"[0]*2*10**5",
"finv",
"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+=COM(h-a-1+i,i)*COM(a-1+w-i-1,w-i-1)",
"COM(h-a-1+i,i)*COM(a-1+w-i-1,w-i-1)",
"ans",
"inv=[0]*2*10**5",
"[0]*2*10**5",
"inv",
"MOD=10**9+7",
"10**9+7",
"MOD"
] | # coding: utf-8
# Your code here!
h,w,a,b=map(int,input().split())
MOD=10**9+7
fac=[0]*2*10**5
finv=[0]*2*10**5
inv=[0]*2*10**5
fac[0]=fac[1]=1
finv[0]=finv[1]=1
inv[1]=1
for i in range(2,2*10**5):
fac[i]=(fac[i-1]*i)%MOD
inv[i]=MOD-inv[MOD%i]*(MOD//i)%MOD
finv[i]=finv[i-1]*inv[i]%MOD
def COM(n,k):
if n<k:
return 0
if n<0 or k<0:
return 0
return fac[n]*(finv[k]*finv[n-k]%MOD)%MOD
ans=0
for i in range(b,w):
ans+=COM(h-a-1+i,i)*COM(a-1+w-i-1,w-i-1)
ans=ans%MOD
print(ans) |
[
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,
12,
13,
29,
2,
2,
2,
13,
13,
2,
13,
13,
13,
23,
13,
23,
13,
12,
13,
14,
2,
13,
17,
14,
2,
13,
17,
14,
2,
2,
13,
17,
17,
23,
13,
23,
13,
12,
13,
29,
4,
13,
13,
4,
13,
13,
2,
13,
17,
23,
13,
23,
13,
0,
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,
13,
2,
39,
17,
13,
0,
18,
13,
2,
2,
13,
13,
17,
4,
13,
18,
13,
2,
2,
13,
13,
17,
2,
13,
17,
28,
13,
4,
13,
2,
2,
13,
13,
17,
17,
17,
0,
18,
13,
13,
2,
2,
18,
13,
2,
13,
17,
2,
13,
17,
13,
12,
13,
29,
2,
2,
2,
18,
13,
13,
18,
13,
13,
18,
13,
2,
13,
13,
13,
23,
13,
23,
13,
0,
13,
17,
0,
13,
17,
28,
13,
4,
13,
2,
13,
13,
0,
13,
13,
0,
13,
2,
13,
17,
14,
2,
39,
13,
13,
13,
0,
13,
18,
13,
39,
13,
13,
0,
13,
4,
13,
2,
13,
13,
13,
0,
18,
13,
39,
13,
13,
13,
0,
13,
2,
2,
13,
17,
13,
0,
13,
2,
2,
13,
17,
13,
14,
2,
39,
13,
13,
13,
0,
13,
18,
13,
39,
13,
13,
0,
13,
4,
13,
2,
13,
13,
13,
0,
18,
13,
39,
13,
13,
13,
0,
13,
2,
13,
13,
4,
13,
2,
13,
13,
10,
12,
13,
10,
2,
13,
10,
4,
13,
10,
18,
13,
10,
12,
13,
10,
4,
13,
10,
2,
13,
10,
4,
13,
10,
18,
13,
10,
2,
13,
10,
4,
13,
10,
12,
13,
10,
12,
13,
10,
2,
13,
10,
17,
13,
10,
2,
13,
10,
4,
13,
10,
17,
13,
10,
2,
13,
10,
4,
13,
10,
13,
13,
10,
2,
13,
10,
2,
13
] | [
[
336,
2
],
[
336,
11
],
[
336,
12
],
[
336,
13
],
[
345,
15
],
[
295,
17
],
[
337,
18
],
[
342,
20
],
[
39,
32
],
[
343,
33
],
[
41,
35
],
[
343,
36
],
[
343,
37
],
[
39,
39
],
[
41,
41
],
[
61,
46
],
[
61,
50
],
[
61,
55
],
[
59,
59
],
[
61,
61
],
[
280,
66
],
[
75,
67
],
[
313,
69
],
[
77,
70
],
[
343,
72
],
[
75,
75
],
[
77,
77
],
[
318,
79
],
[
346,
83
],
[
86,
85
],
[
346,
89
],
[
94,
91
],
[
319,
92
],
[
85,
93
],
[
319,
97
],
[
85,
99
],
[
85,
101
],
[
343,
102
],
[
297,
104
],
[
346,
108
],
[
117,
110
],
[
298,
111
],
[
295,
114
],
[
337,
115
],
[
313,
118
],
[
319,
120
],
[
295,
123
],
[
337,
124
],
[
343,
127
],
[
131,
130
],
[
295,
135
],
[
337,
136
],
[
144,
141
],
[
298,
142
],
[
130,
143
],
[
298,
147
],
[
130,
149
],
[
130,
152
],
[
343,
154
],
[
319,
162
],
[
174,
163
],
[
298,
165
],
[
176,
166
],
[
298,
168
],
[
174,
170
],
[
176,
171
],
[
343,
172
],
[
174,
174
],
[
176,
176
],
[
330,
178
],
[
321,
181
],
[
185,
184
],
[
295,
188
],
[
328,
189
],
[
339,
191
],
[
184,
192
],
[
282,
194
],
[
310,
196
],
[
322,
203
],
[
288,
205
],
[
322,
207
],
[
300,
212
],
[
292,
214
],
[
340,
216
],
[
283,
217
],
[
340,
218
],
[
225,
220
],
[
322,
221
],
[
301,
225
],
[
289,
225
],
[
333,
227
],
[
295,
230
],
[
184,
232
],
[
306,
234
],
[
337,
237
],
[
310,
239
],
[
322,
245
],
[
303,
247
],
[
322,
249
],
[
285,
254
],
[
292,
256
],
[
334,
258
],
[
307,
259
],
[
334,
260
],
[
267,
262
],
[
322,
263
],
[
286,
267
],
[
304,
267
],
[
324,
269
],
[
301,
271
],
[
289,
271
],
[
286,
272
],
[
304,
272
],
[
325,
276
],
[
331,
276
],
[
343,
277
],
[
282,
283
],
[
285,
286
],
[
288,
289
],
[
336,
295
],
[
297,
298
],
[
300,
301
],
[
303,
304
],
[
306,
307
],
[
336,
310
],
[
318,
319
],
[
321,
322
],
[
324,
325
],
[
336,
328
],
[
330,
331
],
[
333,
334
],
[
336,
337
],
[
184,
339
],
[
339,
340
],
[
342,
343
],
[
345,
346
]
] | [
"H,W,A,B = map(int, input().split())\nN = H+W\n\nMOD = 10**9 + 7\n\ndef mul(a, b):\n return ((a % MOD) * (b % MOD)) % MOD\n \ndef power(x, y):\n if y == 0 : return 1\n elif y == 1 : return x % MOD\n elif y % 2 == 0 : return power(x, y//2)**2 % MOD\n else : return power(x, y//2)**2 * x % MOD\n\ndef div(a, b):\n return mul(a, power(b, MOD-2))\n\n# 階乗計算\nfac = [1] * N\nfor i in range(1, N): \n fac[i] = fac[i-1] * i % MOD\n \ninvfac = [0] * (N)\ninvfac[H+W-1] = power(fac[H+W-1], MOD-2)\nfor i in range(H+W-2, -1, -1):\n invfac[i] = invfac[i+1] * (i+1) % MOD\n \ndef nCr(n, r):\n return fac[n] * invfac[r] * invfac[n-r] % MOD\n\n\n\nans = 0\nf = {}\nfor i in range(H-A):\n h1 = i\n w1 = B-1\n if (h1, w1) in f:\n zenhan = f[(h1, w1)]\n else:\n zenhan = nCr(h1+w1,h1)\n f[(h1, w1)] = zenhan\n \n h2 = (H-1) - i\n w2 = (W-1) - B\n if (h2, w2) in f:\n kouhan = f[(h2, w2)]\n else:\n kouhan = nCr(h2+w2,h2)\n f[(h2, w2)] = kouhan\n\n ans += zenhan * kouhan\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",
"N = H+W",
"N",
"H+W",
"H",
"W",
"MOD = 10**9 + 7",
"MOD",
"10**9 + 7",
"10**9",
"10",
"9",
"7",
"def mul(a, b):\n return ((a % MOD) * (b % MOD)) % MOD\n ",
"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 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",
"def div(a, b):\n return mul(a, power(b, MOD-2))\n\n# 階乗計算",
"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",
"fac = [1] * N",
"fac",
"[1] * N",
"[1]",
"1",
"N",
"for i in range(1, N): \n fac[i] = fac[i-1] * i % MOD\n ",
"i",
"range(1, N)",
"range",
"1",
"N",
"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",
"invfac = [0] * (N)",
"invfac",
"[0] * (N)",
"[0]",
"0",
"N",
"invfac[H+W-1] = power(fac[H+W-1], MOD-2)",
"invfac[H+W-1]",
"invfac",
"H+W-1",
"H+W",
"H",
"W",
"1",
"power(fac[H+W-1], MOD-2)",
"power",
"fac[H+W-1]",
"fac",
"H+W-1",
"H+W",
"H",
"W",
"1",
"MOD-2",
"MOD",
"2",
"for i in range(H+W-2, -1, -1):\n invfac[i] = invfac[i+1] * (i+1) % MOD\n ",
"i",
"range(H+W-2, -1, -1)",
"range",
"H+W-2",
"H+W",
"H",
"W",
"2",
"-1",
"-1",
"invfac[i] = invfac[i+1] * (i+1) % MOD",
"invfac[i]",
"invfac",
"i",
"invfac[i+1] * (i+1) % MOD",
"invfac[i+1] * (i+1)",
"invfac[i+1]",
"invfac",
"i+1",
"i",
"1",
"i+1",
"i",
"1",
"MOD",
"def nCr(n, r):\n return fac[n] * invfac[r] * invfac[n-r] % MOD",
"nCr",
"return fac[n] * invfac[r] * invfac[n-r] % MOD",
"fac[n] * invfac[r] * invfac[n-r] % MOD",
"fac[n] * invfac[r] * invfac[n-r]",
"fac[n] * invfac[r]",
"fac[n]",
"fac",
"n",
"invfac[r]",
"invfac",
"r",
"invfac[n-r]",
"invfac",
"n-r",
"n",
"r",
"MOD",
"n",
"n",
"r",
"r",
"ans = 0",
"ans",
"0",
"f = {}",
"f",
"{}",
"for i in range(H-A):\n h1 = i\n w1 = B-1\n if (h1, w1) in f:\n zenhan = f[(h1, w1)]\n else:\n zenhan = nCr(h1+w1,h1)\n f[(h1, w1)] = zenhan\n \n h2 = (H-1) - i\n w2 = (W-1) - B\n if (h2, w2) in f:\n kouhan = f[(h2, w2)]\n else:\n kouhan = nCr(h2+w2,h2)\n f[(h2, w2)] = kouhan\n\n ans += zenhan * kouhan",
"i",
"range(H-A)",
"range",
"H-A",
"H",
"A",
"h1 = i",
"h1",
"i",
"w1 = B-1",
"w1",
"B-1",
"B",
"1",
"if (h1, w1) in f:\n zenhan = f[(h1, w1)]\n else:\n zenhan = nCr(h1+w1,h1)\n f[(h1, w1)] = zenhan\n \n ",
"(h1, w1) in f",
"(h1, w1)",
"h1",
"w1",
"f",
"zenhan = f[(h1, w1)]",
"zenhan",
"f[(h1, w1)]",
"f",
"(h1, w1)",
"h1",
"w1",
"zenhan = nCr(h1+w1,h1)",
"zenhan",
"nCr(h1+w1,h1)",
"nCr",
"h1+w1",
"h1",
"w1",
"h1",
"f[(h1, w1)] = zenhan",
"f[(h1, w1)]",
"f",
"(h1, w1)",
"h1",
"w1",
"zenhan",
"h2 = (H-1) - i",
"h2",
"(H-1) - i",
"H-1",
"H",
"1",
"i",
"w2 = (W-1) - B",
"w2",
"(W-1) - B",
"W-1",
"W",
"1",
"B",
"if (h2, w2) in f:\n kouhan = f[(h2, w2)]\n else:\n kouhan = nCr(h2+w2,h2)\n f[(h2, w2)] = kouhan\n\n ",
"(h2, w2) in f",
"(h2, w2)",
"h2",
"w2",
"f",
"kouhan = f[(h2, w2)]",
"kouhan",
"f[(h2, w2)]",
"f",
"(h2, w2)",
"h2",
"w2",
"kouhan = nCr(h2+w2,h2)",
"kouhan",
"nCr(h2+w2,h2)",
"nCr",
"h2+w2",
"h2",
"w2",
"h2",
"f[(h2, w2)] = kouhan",
"f[(h2, w2)]",
"f",
"(h2, w2)",
"h2",
"w2",
"kouhan",
"ans += zenhan * kouhan",
"ans",
"zenhan * kouhan",
"zenhan",
"kouhan",
"print(ans % MOD)",
"print",
"ans % MOD",
"ans",
"MOD",
"def mul(a, b):\n return ((a % MOD) * (b % MOD)) % MOD\n ",
"def mul(a, b):\n return ((a % MOD) * (b % MOD)) % MOD\n ",
"mul",
"w1 = B-1",
"B-1",
"w1",
"kouhan = nCr(h2+w2,h2)",
"nCr(h2+w2,h2)",
"kouhan",
"zenhan = f[(h1, w1)]",
"f[(h1, w1)]",
"zenhan",
"def nCr(n, r):\n return fac[n] * invfac[r] * invfac[n-r] % MOD",
"def nCr(n, r):\n return fac[n] * invfac[r] * invfac[n-r] % MOD",
"nCr",
"H,W,A,B = map(int, input().split())",
"map(int, input().split())",
"H",
"invfac = [0] * (N)",
"[0] * (N)",
"invfac",
"zenhan = nCr(h1+w1,h1)",
"nCr(h1+w1,h1)",
"zenhan",
"kouhan = f[(h2, w2)]",
"f[(h2, w2)]",
"kouhan",
"w2 = (W-1) - B",
"(W-1) - B",
"w2",
"B = map(int, input().split())",
"map(int, input().split())",
"B",
"def power(x, y):\n if y == 0 : return 1\n elif y == 1 : return x % MOD\n elif y % 2 == 0 : return power(x, y//2)**2 % MOD\n else : return power(x, y//2)**2 * x % MOD",
"def power(x, y):\n if y == 0 : return 1\n elif y == 1 : return x % MOD\n elif y % 2 == 0 : return power(x, y//2)**2 % MOD\n else : return power(x, y//2)**2 * x % MOD",
"power",
"def div(a, b):\n return mul(a, power(b, MOD-2))\n\n# 階乗計算",
"def div(a, b):\n return mul(a, power(b, MOD-2))\n\n# 階乗計算",
"div",
"fac = [1] * N",
"[1] * N",
"fac",
"f = {}",
"{}",
"f",
"ans += zenhan * kouhan",
"zenhan * kouhan",
"ans",
"A,B = map(int, input().split())",
"map(int, input().split())",
"A",
"ans = 0",
"0",
"ans",
"h2 = (H-1) - i",
"(H-1) - i",
"h2",
"W,A,B = map(int, input().split())",
"map(int, input().split())",
"W",
"h1 = i",
"i",
"h1",
"MOD = 10**9 + 7",
"10**9 + 7",
"MOD",
"N = H+W",
"H+W",
"N"
] | H,W,A,B = map(int, input().split())
N = H+W
MOD = 10**9 + 7
def mul(a, b):
return ((a % MOD) * (b % MOD)) % MOD
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
def div(a, b):
return mul(a, power(b, MOD-2))
# 階乗計算
fac = [1] * N
for i in range(1, N):
fac[i] = fac[i-1] * i % MOD
invfac = [0] * (N)
invfac[H+W-1] = power(fac[H+W-1], MOD-2)
for i in range(H+W-2, -1, -1):
invfac[i] = invfac[i+1] * (i+1) % MOD
def nCr(n, r):
return fac[n] * invfac[r] * invfac[n-r] % MOD
ans = 0
f = {}
for i in range(H-A):
h1 = i
w1 = B-1
if (h1, w1) in f:
zenhan = f[(h1, w1)]
else:
zenhan = nCr(h1+w1,h1)
f[(h1, w1)] = zenhan
h2 = (H-1) - i
w2 = (W-1) - B
if (h2, w2) in f:
kouhan = f[(h2, w2)]
else:
kouhan = nCr(h2+w2,h2)
f[(h2, w2)] = kouhan
ans += zenhan * kouhan
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,
17,
28,
13,
4,
13,
17,
2,
2,
13,
13,
17,
14,
2,
13,
17,
0,
13,
17,
0,
13,
17,
28,
13,
4,
13,
17,
2,
2,
2,
2,
13,
13,
13,
2,
13,
17,
17,
0,
13,
13,
0,
13,
13,
28,
13,
4,
13,
17,
2,
2,
13,
17,
17,
0,
13,
13,
0,
13,
13,
28,
13,
4,
13,
17,
2,
2,
2,
13,
13,
13,
17,
0,
13,
13,
0,
13,
13,
0,
13,
2,
2,
13,
4,
13,
13,
2,
13,
17,
13,
13,
0,
13,
17,
0,
13,
17,
28,
13,
4,
13,
17,
2,
2,
2,
2,
13,
13,
17,
2,
2,
13,
13,
17,
17,
0,
13,
13,
0,
13,
13,
28,
13,
4,
13,
17,
2,
2,
2,
13,
13,
17,
17,
0,
13,
13,
0,
13,
13,
28,
13,
4,
13,
17,
2,
2,
2,
13,
13,
17,
17,
0,
13,
13,
0,
13,
13,
0,
13,
2,
2,
13,
4,
13,
13,
2,
13,
17,
13,
13,
0,
13,
4,
13,
2,
2,
2,
2,
13,
13,
13,
2,
13,
17,
17,
2,
13,
17,
13,
0,
13,
2,
2,
2,
13,
13,
13,
17,
0,
13,
13,
0,
13,
2,
2,
2,
13,
13,
17,
2,
2,
13,
13,
17,
0,
13,
13,
0,
13,
4,
13,
2,
2,
13,
13,
17,
2,
13,
17,
13,
0,
13,
13,
0,
13,
2,
13,
13,
0,
13,
13,
4,
13,
13,
10,
17,
13,
10,
4,
13,
10,
2,
13,
10,
13,
13,
10,
13,
13,
10,
2,
13,
10,
13,
13,
10,
2,
13,
10,
4,
13,
10,
13,
13,
10,
4,
13,
10,
13,
13,
10,
13,
13,
10,
13,
13,
10,
4,
13,
10,
13,
13,
10,
13,
13,
10,
13,
13,
10,
13,
13,
10,
17,
13,
10,
17,
13,
10,
4,
13,
10,
4,
13,
10,
17,
13,
10,
13,
13,
10,
13,
13,
10,
13,
13,
10,
2,
13,
10,
13,
13,
10,
2,
13,
10,
17,
13,
10,
2,
13,
10,
13,
13
] | [
[
333,
2
],
[
333,
11
],
[
333,
12
],
[
333,
13
],
[
354,
15
],
[
327,
22
],
[
26,
25
],
[
310,
31
],
[
292,
32
],
[
25,
36
],
[
267,
39
],
[
357,
42
],
[
46,
45
],
[
310,
53
],
[
292,
54
],
[
25,
55
],
[
334,
57
],
[
351,
61
],
[
45,
62
],
[
363,
64
],
[
355,
65
],
[
68,
67
],
[
334,
73
],
[
279,
77
],
[
67,
78
],
[
345,
80
],
[
355,
81
],
[
84,
83
],
[
310,
90
],
[
292,
91
],
[
25,
92
],
[
306,
95
],
[
83,
96
],
[
318,
98
],
[
355,
99
],
[
273,
101
],
[
364,
104
],
[
352,
104
],
[
268,
104
],
[
343,
104
],
[
340,
104
],
[
337,
104
],
[
319,
107
],
[
307,
107
],
[
346,
107
],
[
280,
107
],
[
358,
107
],
[
295,
107
],
[
304,
107
],
[
322,
107
],
[
286,
107
],
[
325,
107
],
[
355,
109
],
[
355,
111
],
[
355,
112
],
[
336,
114
],
[
324,
117
],
[
121,
120
],
[
271,
128
],
[
334,
129
],
[
292,
133
],
[
25,
134
],
[
339,
138
],
[
120,
139
],
[
342,
141
],
[
355,
142
],
[
145,
144
],
[
271,
151
],
[
334,
152
],
[
285,
156
],
[
144,
157
],
[
321,
159
],
[
355,
160
],
[
163,
162
],
[
292,
169
],
[
25,
170
],
[
303,
174
],
[
162,
175
],
[
294,
177
],
[
355,
178
],
[
360,
180
],
[
343,
183
],
[
340,
183
],
[
337,
183
],
[
364,
183
],
[
352,
183
],
[
268,
183
],
[
295,
186
],
[
304,
186
],
[
322,
186
],
[
286,
186
],
[
325,
186
],
[
319,
186
],
[
307,
186
],
[
346,
186
],
[
280,
186
],
[
358,
186
],
[
355,
188
],
[
355,
190
],
[
355,
191
],
[
330,
193
],
[
310,
200
],
[
292,
201
],
[
25,
202
],
[
334,
204
],
[
355,
208
],
[
355,
210
],
[
348,
212
],
[
310,
216
],
[
292,
217
],
[
25,
218
],
[
312,
221
],
[
355,
222
],
[
282,
224
],
[
271,
228
],
[
334,
229
],
[
292,
233
],
[
25,
234
],
[
276,
237
],
[
355,
238
],
[
297,
240
],
[
292,
245
],
[
25,
246
],
[
355,
249
],
[
355,
251
],
[
315,
253
],
[
355,
254
],
[
288,
256
],
[
313,
258
],
[
349,
258
],
[
331,
258
],
[
274,
258
],
[
316,
259
],
[
298,
259
],
[
277,
259
],
[
283,
259
],
[
361,
259
],
[
300,
261
],
[
355,
262
],
[
301,
265
],
[
289,
265
],
[
328,
265
],
[
267,
268
],
[
333,
271
],
[
273,
274
],
[
355,
276
],
[
276,
277
],
[
67,
279
],
[
279,
280
],
[
282,
283
],
[
144,
285
],
[
285,
286
],
[
288,
289
],
[
333,
292
],
[
355,
294
],
[
294,
295
],
[
297,
298
],
[
355,
300
],
[
300,
301
],
[
162,
303
],
[
303,
304
],
[
83,
306
],
[
306,
307
],
[
333,
310
],
[
355,
312
],
[
312,
313
],
[
355,
315
],
[
315,
316
],
[
355,
318
],
[
318,
319
],
[
355,
321
],
[
321,
322
],
[
324,
325
],
[
327,
328
],
[
330,
331
],
[
333,
334
],
[
336,
337
],
[
120,
339
],
[
339,
340
],
[
355,
342
],
[
342,
343
],
[
355,
345
],
[
345,
346
],
[
348,
349
],
[
45,
351
],
[
351,
352
],
[
354,
355
],
[
357,
358
],
[
360,
361
],
[
355,
363
],
[
363,
364
]
] | [
"h, w, a, b = map(int, input().split())\nmod = 10 ** 9 + 7\n\nans = 0\nfor i in range(1, h-a+1):\n if i == 1:\n t1 = 1\n t2 = 1\n for j in range(1, ((h-a-i)+(b-1)+1)):\n t1 *= j\n t1 %= mod\n for j in range(1, ((b-1)+1)):\n t2 *= j\n t2 %= mod\n for j in range(1, ((h-a-i)+1)):\n t2 *= j\n t2 %= mod\n a1 = t1 * pow(t2, mod-2, mod) % mod\n\n t1 = 1\n t2 = 1\n for j in range(1, ((w-b-1)+(a+i-1)+1)):\n t1 *= j\n t1 %= mod\n for j in range(1, ((w-b-1)+1)):\n t2 *= j\n t2 %= mod\n for j in range(1, ((a+i-1)+1)):\n t2 *= j\n t2 %= mod\n a2 = t1 * pow(t2, mod-2, mod) % mod\n else:\n a1 *= pow((h-a-i)+(b-1)+1, mod-2, mod) \n a1 *= h-a-i+1\n a1 %= mod \n a2 *= (w-b-1)+(a+i-1) \n a2 %= mod\n a2 *= pow(a+i-1, mod-2, mod) \n a2 %= mod\n \n #print(a1, a2)\n ans += a1 * a2 \n ans %= mod\n\nprint(ans)\n",
"h, w, a, b = map(int, input().split())",
"h",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"w",
"a",
"b",
"mod = 10 ** 9 + 7",
"mod",
"10 ** 9 + 7",
"10 ** 9",
"10",
"9",
"7",
"ans = 0",
"ans",
"0",
"for i in range(1, h-a+1):\n if i == 1:\n t1 = 1\n t2 = 1\n for j in range(1, ((h-a-i)+(b-1)+1)):\n t1 *= j\n t1 %= mod\n for j in range(1, ((b-1)+1)):\n t2 *= j\n t2 %= mod\n for j in range(1, ((h-a-i)+1)):\n t2 *= j\n t2 %= mod\n a1 = t1 * pow(t2, mod-2, mod) % mod\n\n t1 = 1\n t2 = 1\n for j in range(1, ((w-b-1)+(a+i-1)+1)):\n t1 *= j\n t1 %= mod\n for j in range(1, ((w-b-1)+1)):\n t2 *= j\n t2 %= mod\n for j in range(1, ((a+i-1)+1)):\n t2 *= j\n t2 %= mod\n a2 = t1 * pow(t2, mod-2, mod) % mod\n else:\n a1 *= pow((h-a-i)+(b-1)+1, mod-2, mod) \n a1 *= h-a-i+1\n a1 %= mod \n a2 *= (w-b-1)+(a+i-1) \n a2 %= mod\n a2 *= pow(a+i-1, mod-2, mod) \n a2 %= mod\n \n #print(a1, a2)\n ans += a1 * a2 \n ans %= mod",
"i",
"range(1, h-a+1)",
"range",
"1",
"h-a+1",
"h-a",
"h",
"a",
"1",
"if i == 1:\n t1 = 1\n t2 = 1\n for j in range(1, ((h-a-i)+(b-1)+1)):\n t1 *= j\n t1 %= mod\n for j in range(1, ((b-1)+1)):\n t2 *= j\n t2 %= mod\n for j in range(1, ((h-a-i)+1)):\n t2 *= j\n t2 %= mod\n a1 = t1 * pow(t2, mod-2, mod) % mod\n\n t1 = 1\n t2 = 1\n for j in range(1, ((w-b-1)+(a+i-1)+1)):\n t1 *= j\n t1 %= mod\n for j in range(1, ((w-b-1)+1)):\n t2 *= j\n t2 %= mod\n for j in range(1, ((a+i-1)+1)):\n t2 *= j\n t2 %= mod\n a2 = t1 * pow(t2, mod-2, mod) % mod\n else:\n a1 *= pow((h-a-i)+(b-1)+1, mod-2, mod) \n a1 *= h-a-i+1\n a1 %= mod \n a2 *= (w-b-1)+(a+i-1) \n a2 %= mod\n a2 *= pow(a+i-1, mod-2, mod) \n a2 %= mod\n \n #print(a1, a2)\n ",
"i == 1",
"i",
"1",
"t1 = 1",
"t1",
"1",
"t2 = 1",
"t2",
"1",
"for j in range(1, ((h-a-i)+(b-1)+1)):\n t1 *= j\n t1 %= mod\n ",
"j",
"range(1, ((h-a-i)+(b-1)+1))",
"range",
"1",
"(h-a-i)+(b-1)+1",
"(h-a-i)+(b-1)",
"h-a-i",
"h-a",
"h",
"a",
"i",
"b-1",
"b",
"1",
"1",
"t1 *= j",
"t1",
"j",
"t1 %= mod",
"t1",
"mod",
"for j in range(1, ((b-1)+1)):\n t2 *= j\n t2 %= mod\n ",
"j",
"range(1, ((b-1)+1))",
"range",
"1",
"(b-1)+1",
"b-1",
"b",
"1",
"1",
"t2 *= j",
"t2",
"j",
"t2 %= mod",
"t2",
"mod",
"for j in range(1, ((h-a-i)+1)):\n t2 *= j\n t2 %= mod\n ",
"j",
"range(1, ((h-a-i)+1))",
"range",
"1",
"(h-a-i)+1",
"h-a-i",
"h-a",
"h",
"a",
"i",
"1",
"t2 *= j",
"t2",
"j",
"t2 %= mod",
"t2",
"mod",
"a1 = t1 * pow(t2, mod-2, mod) % mod",
"a1",
"t1 * pow(t2, mod-2, mod) % mod",
"t1 * pow(t2, mod-2, mod)",
"t1",
"pow(t2, mod-2, mod)",
"pow",
"t2",
"mod-2",
"mod",
"2",
"mod",
"mod",
"t1 = 1",
"t1",
"1",
"t2 = 1",
"t2",
"1",
"for j in range(1, ((w-b-1)+(a+i-1)+1)):\n t1 *= j\n t1 %= mod\n ",
"j",
"range(1, ((w-b-1)+(a+i-1)+1))",
"range",
"1",
"(w-b-1)+(a+i-1)+1",
"(w-b-1)+(a+i-1)",
"w-b-1",
"w-b",
"w",
"b",
"1",
"a+i-1",
"a+i",
"a",
"i",
"1",
"1",
"t1 *= j",
"t1",
"j",
"t1 %= mod",
"t1",
"mod",
"for j in range(1, ((w-b-1)+1)):\n t2 *= j\n t2 %= mod\n ",
"j",
"range(1, ((w-b-1)+1))",
"range",
"1",
"(w-b-1)+1",
"w-b-1",
"w-b",
"w",
"b",
"1",
"1",
"t2 *= j",
"t2",
"j",
"t2 %= mod",
"t2",
"mod",
"for j in range(1, ((a+i-1)+1)):\n t2 *= j\n t2 %= mod\n ",
"j",
"range(1, ((a+i-1)+1))",
"range",
"1",
"(a+i-1)+1",
"a+i-1",
"a+i",
"a",
"i",
"1",
"1",
"t2 *= j",
"t2",
"j",
"t2 %= mod",
"t2",
"mod",
"a2 = t1 * pow(t2, mod-2, mod) % mod",
"a2",
"t1 * pow(t2, mod-2, mod) % mod",
"t1 * pow(t2, mod-2, mod)",
"t1",
"pow(t2, mod-2, mod)",
"pow",
"t2",
"mod-2",
"mod",
"2",
"mod",
"mod",
"a1 *= pow((h-a-i)+(b-1)+1, mod-2, mod)",
"a1",
"pow((h-a-i)+(b-1)+1, mod-2, mod)",
"pow",
"(h-a-i)+(b-1)+1",
"(h-a-i)+(b-1)",
"h-a-i",
"h-a",
"h",
"a",
"i",
"b-1",
"b",
"1",
"1",
"mod-2",
"mod",
"2",
"mod",
"a1 *= h-a-i+1",
"a1",
"h-a-i+1",
"h-a-i",
"h-a",
"h",
"a",
"i",
"1",
"a1 %= mod",
"a1",
"mod",
"a2 *= (w-b-1)+(a+i-1)",
"a2",
"(w-b-1)+(a+i-1)",
"w-b-1",
"w-b",
"w",
"b",
"1",
"a+i-1",
"a+i",
"a",
"i",
"1",
"a2 %= mod",
"a2",
"mod",
"a2 *= pow(a+i-1, mod-2, mod)",
"a2",
"pow(a+i-1, mod-2, mod)",
"pow",
"a+i-1",
"a+i",
"a",
"i",
"1",
"mod-2",
"mod",
"2",
"mod",
"a2 %= mod",
"a2",
"mod",
"ans += a1 * a2",
"ans",
"a1 * a2",
"a1",
"a2",
"ans %= mod",
"ans",
"mod",
"print(ans)",
"print",
"ans",
"t1 = 1",
"1",
"t1",
"w, a, b = map(int, input().split())",
"map(int, input().split())",
"w",
"a1 = t1 * pow(t2, mod-2, mod) % mod",
"t1 * pow(t2, mod-2, mod) % mod",
"a1",
"a2 %= mod",
"mod",
"a2",
"t2 *= j",
"j",
"t2",
"a2 *= (w-b-1)+(a+i-1)",
"(w-b-1)+(a+i-1)",
"a2",
"t2 *= j",
"j",
"t2",
"ans += a1 * a2",
"a1 * a2",
"ans",
"a, b = map(int, input().split())",
"map(int, input().split())",
"a",
"t2 %= mod",
"mod",
"t2",
"a2 *= pow(a+i-1, mod-2, mod)",
"pow(a+i-1, mod-2, mod)",
"a2",
"ans %= mod",
"mod",
"ans",
"t2 *= j",
"j",
"t2",
"t2 *= j",
"j",
"t2",
"h, w, a, b = map(int, input().split())",
"map(int, input().split())",
"h",
"a1 %= mod",
"mod",
"a1",
"a2 %= mod",
"mod",
"a2",
"t2 %= mod",
"mod",
"t2",
"t2 %= mod",
"mod",
"t2",
"t2 = 1",
"1",
"t2",
"ans = 0",
"0",
"ans",
"a1 *= pow((h-a-i)+(b-1)+1, mod-2, mod)",
"pow((h-a-i)+(b-1)+1, mod-2, mod)",
"a1",
"b = map(int, input().split())",
"map(int, input().split())",
"b",
"t1 = 1",
"1",
"t1",
"t1 *= j",
"j",
"t1",
"t1 %= mod",
"mod",
"t1",
"t2 %= mod",
"mod",
"t2",
"a1 *= h-a-i+1",
"h-a-i+1",
"a1",
"t1 *= j",
"j",
"t1",
"mod = 10 ** 9 + 7",
"10 ** 9 + 7",
"mod",
"t2 = 1",
"1",
"t2",
"a2 = t1 * pow(t2, mod-2, mod) % mod",
"t1 * pow(t2, mod-2, mod) % mod",
"a2",
"t1 %= mod",
"mod",
"t1"
] | h, w, a, b = map(int, input().split())
mod = 10 ** 9 + 7
ans = 0
for i in range(1, h-a+1):
if i == 1:
t1 = 1
t2 = 1
for j in range(1, ((h-a-i)+(b-1)+1)):
t1 *= j
t1 %= mod
for j in range(1, ((b-1)+1)):
t2 *= j
t2 %= mod
for j in range(1, ((h-a-i)+1)):
t2 *= j
t2 %= mod
a1 = t1 * pow(t2, mod-2, mod) % mod
t1 = 1
t2 = 1
for j in range(1, ((w-b-1)+(a+i-1)+1)):
t1 *= j
t1 %= mod
for j in range(1, ((w-b-1)+1)):
t2 *= j
t2 %= mod
for j in range(1, ((a+i-1)+1)):
t2 *= j
t2 %= mod
a2 = t1 * pow(t2, mod-2, mod) % mod
else:
a1 *= pow((h-a-i)+(b-1)+1, mod-2, mod)
a1 *= h-a-i+1
a1 %= mod
a2 *= (w-b-1)+(a+i-1)
a2 %= mod
a2 *= pow(a+i-1, mod-2, mod)
a2 %= mod
#print(a1, a2)
ans += a1 * a2
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,
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,
2,
13,
13,
0,
13,
2,
13,
17,
0,
13,
17,
42,
2,
2,
13,
17,
40,
13,
13,
0,
13,
2,
2,
13,
2,
4,
13,
2,
2,
13,
13,
17,
2,
13,
17,
4,
13,
2,
2,
2,
13,
13,
13,
13,
2,
13,
13,
13,
0,
13,
17,
0,
13,
17,
4,
13,
13,
10,
2,
13,
10,
17,
13,
10,
4,
13,
10,
17,
13,
10,
4,
13,
10,
12,
13,
10,
2,
13,
10,
2,
13,
10,
2,
13,
10,
17,
13,
10,
4,
13,
10,
2,
13,
10,
4,
13,
10,
2,
13
] | [
[
225,
2
],
[
225,
11
],
[
225,
12
],
[
225,
13
],
[
213,
15
],
[
210,
22
],
[
196,
27
],
[
226,
28
],
[
33,
30
],
[
211,
31
],
[
38,
35
],
[
211,
36
],
[
189,
40
],
[
196,
45
],
[
226,
46
],
[
51,
48
],
[
190,
49
],
[
56,
53
],
[
190,
54
],
[
59,
58
],
[
196,
63
],
[
226,
64
],
[
69,
66
],
[
211,
67
],
[
58,
68
],
[
211,
72
],
[
58,
74
],
[
58,
76
],
[
214,
77
],
[
82,
79
],
[
190,
80
],
[
58,
81
],
[
66,
84
],
[
211,
85
],
[
58,
86
],
[
214,
88
],
[
214,
90
],
[
95,
94
],
[
128,
97
],
[
126,
99
],
[
128,
100
],
[
103,
102
],
[
211,
104
],
[
126,
105
],
[
108,
107
],
[
190,
111
],
[
94,
112
],
[
128,
112
],
[
190,
114
],
[
126,
116
],
[
94,
117
],
[
128,
117
],
[
214,
118
],
[
102,
122
],
[
107,
123
],
[
214,
124
],
[
126,
126
],
[
128,
128
],
[
222,
130
],
[
196,
132
],
[
220,
133
],
[
228,
135
],
[
202,
137
],
[
198,
140
],
[
223,
145
],
[
217,
145
],
[
229,
148
],
[
193,
148
],
[
226,
149
],
[
207,
151
],
[
199,
154
],
[
208,
154
],
[
205,
157
],
[
223,
160
],
[
217,
160
],
[
229,
161
],
[
193,
161
],
[
223,
164
],
[
217,
164
],
[
205,
167
],
[
196,
171
],
[
223,
172
],
[
217,
172
],
[
226,
173
],
[
229,
174
],
[
193,
174
],
[
196,
176
],
[
223,
177
],
[
217,
177
],
[
214,
178
],
[
216,
180
],
[
192,
183
],
[
208,
187
],
[
199,
187
],
[
189,
190
],
[
192,
193
],
[
225,
196
],
[
198,
199
],
[
225,
202
],
[
207,
208
],
[
210,
211
],
[
213,
214
],
[
216,
217
],
[
225,
220
],
[
222,
223
],
[
225,
226
],
[
228,
229
]
] | [
"# -*- coding: utf-8 -*-\n\nH,W,A,B = map(int, input().split())\nmod = (10 ** 9 + 7)\n\n# 予め組み合わせ計算に必要な階乗と逆元のテーブルを作っておく\nfactorial = [0] * (H+W)\nfactorial[0] = 1\nfactorial[1] = 1\ninverse = [0] * (H+W)\ninverse[0] = 1\ninverse[1] = 1\nfor i in range(2,H+W):\n factorial[i] = factorial[i-1] * i % mod\n # フェルマーの小定理から(x! ** mod-2 % mod == x! ** -1 % mod)\n # powに第三引数入れると冪乗のmod付計算を高速にやってくれる\n inverse[i] = pow(factorial[i], mod-2, mod)\n \n# 組み合わせの数だけ返してくれる関数(自作)\ndef nCr(n, r):\n # 10C7 = 10C3\n r = min(r, n-r)\n # 分子の計算\n numerator = factorial[n]\n # 分母の計算\n denominator = inverse[r] * inverse[n-r] % mod\n return numerator * denominator % mod\n\nh = H - A\nw = B + 1\nans = 0\n# マスを右上に1つずつずらして、必ず通る場所でパターンを足し合わせていく\nwhile h > 0 and w <= W:\n ans = (ans + nCr(h+w-2, h-1) * nCr(H-h+W-w, H-h)) % mod\n h -= 1\n w += 1\n\nprint(ans)",
"H,W,A,B = map(int, input().split())",
"H",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"W",
"A",
"B",
"mod = (10 ** 9 + 7)",
"mod",
"10 ** 9 + 7",
"10 ** 9",
"10",
"9",
"7",
"factorial = [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 % mod\n # フェルマーの小定理から(x! ** mod-2 % mod == x! ** -1 % mod)\n # powに第三引数入れると冪乗のmod付計算を高速にやってくれる\n inverse[i] = pow(factorial[i], mod-2, mod)\n \n# 組み合わせの数だけ返してくれる関数(自作)",
"i",
"range(2,H+W)",
"range",
"2",
"H+W",
"H",
"W",
"factorial[i] = factorial[i-1] * i % mod",
"factorial[i]",
"factorial",
"i",
"factorial[i-1] * i % mod",
"factorial[i-1] * i",
"factorial[i-1]",
"factorial",
"i-1",
"i",
"1",
"i",
"mod",
"inverse[i] = pow(factorial[i], mod-2, mod)",
"inverse[i]",
"inverse",
"i",
"pow(factorial[i], mod-2, mod)",
"pow",
"factorial[i]",
"factorial",
"i",
"mod-2",
"mod",
"2",
"mod",
"def nCr(n, r):\n # 10C7 = 10C3\n r = min(r, n-r)\n # 分子の計算\n numerator = factorial[n]\n # 分母の計算\n denominator = inverse[r] * inverse[n-r] % mod\n return numerator * denominator % mod",
"nCr",
"r = min(r, n-r)",
"r",
"min(r, n-r)",
"min",
"r",
"n-r",
"n",
"r",
"numerator = factorial[n]",
"numerator",
"factorial[n]",
"factorial",
"n",
"denominator = inverse[r] * inverse[n-r] % mod",
"denominator",
"inverse[r] * inverse[n-r] % mod",
"inverse[r] * inverse[n-r]",
"inverse[r]",
"inverse",
"r",
"inverse[n-r]",
"inverse",
"n-r",
"n",
"r",
"mod",
"return numerator * denominator % mod",
"numerator * denominator % mod",
"numerator * denominator",
"numerator",
"denominator",
"mod",
"n",
"n",
"r",
"r",
"h = H - A",
"h",
"H - A",
"H",
"A",
"w = B + 1",
"w",
"B + 1",
"B",
"1",
"ans = 0",
"ans",
"0",
"while h > 0 and w <= W:\n ans = (ans + nCr(h+w-2, h-1) * nCr(H-h+W-w, H-h)) % mod\n h -= 1\n w += 1",
"h > 0 and w <= W",
"h > 0",
"h",
"0",
"w <= W",
"w",
"W",
"ans = (ans + nCr(h+w-2, h-1) * nCr(H-h+W-w, H-h)) % mod",
"ans",
"(ans + nCr(h+w-2, h-1) * nCr(H-h+W-w, H-h)) % mod",
"ans + nCr(h+w-2, h-1) * nCr(H-h+W-w, H-h)",
"ans",
"nCr(h+w-2, h-1) * nCr(H-h+W-w, H-h)",
"nCr(h+w-2, h-1)",
"nCr",
"h+w-2",
"h+w",
"h",
"w",
"2",
"h-1",
"h",
"1",
"nCr(H-h+W-w, H-h)",
"nCr",
"H-h+W-w",
"H-h+W",
"H-h",
"H",
"h",
"W",
"w",
"H-h",
"H",
"h",
"mod",
"h -= 1",
"h",
"1",
"w += 1",
"w",
"1",
"print(ans)",
"print",
"ans",
"inverse = [0] * (H+W)",
"[0] * (H+W)",
"inverse",
"w += 1",
"1",
"w",
"H,W,A,B = map(int, input().split())",
"map(int, input().split())",
"H",
"ans = 0",
"0",
"ans",
"B = map(int, input().split())",
"map(int, input().split())",
"B",
"def nCr(n, r):\n # 10C7 = 10C3\n r = min(r, n-r)\n # 分子の計算\n numerator = factorial[n]\n # 分母の計算\n denominator = inverse[r] * inverse[n-r] % mod\n return numerator * denominator % mod",
"def nCr(n, r):\n # 10C7 = 10C3\n r = min(r, n-r)\n # 分子の計算\n numerator = factorial[n]\n # 分母の計算\n denominator = inverse[r] * inverse[n-r] % mod\n return numerator * denominator % mod",
"nCr",
"ans = (ans + nCr(h+w-2, h-1) * nCr(H-h+W-w, H-h)) % mod",
"(ans + nCr(h+w-2, h-1) * nCr(H-h+W-w, H-h)) % mod",
"ans",
"factorial = [0] * (H+W)",
"[0] * (H+W)",
"factorial",
"mod = (10 ** 9 + 7)",
"10 ** 9 + 7",
"mod",
"h -= 1",
"1",
"h",
"A,B = map(int, input().split())",
"map(int, input().split())",
"A",
"h = H - A",
"H - A",
"h",
"W,A,B = map(int, input().split())",
"map(int, input().split())",
"W",
"w = B + 1",
"B + 1",
"w"
] | # -*- coding: utf-8 -*-
H,W,A,B = map(int, input().split())
mod = (10 ** 9 + 7)
# 予め組み合わせ計算に必要な階乗と逆元のテーブルを作っておく
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 % mod
# フェルマーの小定理から(x! ** mod-2 % mod == x! ** -1 % mod)
# powに第三引数入れると冪乗のmod付計算を高速にやってくれる
inverse[i] = pow(factorial[i], mod-2, mod)
# 組み合わせの数だけ返してくれる関数(自作)
def nCr(n, r):
# 10C7 = 10C3
r = min(r, n-r)
# 分子の計算
numerator = factorial[n]
# 分母の計算
denominator = inverse[r] * inverse[n-r] % mod
return numerator * denominator % mod
h = H - A
w = B + 1
ans = 0
# マスを右上に1つずつずらして、必ず通る場所でパターンを足し合わせていく
while h > 0 and w <= W:
ans = (ans + nCr(h+w-2, h-1) * nCr(H-h+W-w, H-h)) % mod
h -= 1
w += 1
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,
41,
28,
13,
4,
13,
13,
4,
17,
0,
13,
13,
41,
28,
13,
4,
13,
13,
4,
17,
0,
13,
13,
41,
28,
13,
4,
13,
13,
4,
17,
0,
13,
13,
0,
18,
13,
17,
17,
0,
18,
13,
17,
17,
0,
18,
13,
17,
17,
0,
18,
13,
17,
17,
0,
18,
13,
17,
17,
28,
13,
4,
13,
17,
13,
0,
18,
13,
13,
2,
2,
18,
13,
2,
13,
17,
13,
13,
0,
18,
13,
13,
2,
13,
2,
2,
18,
13,
2,
13,
13,
2,
13,
13,
13,
0,
18,
13,
13,
2,
2,
18,
13,
2,
13,
17,
18,
13,
13,
13,
12,
13,
14,
2,
13,
13,
29,
17,
14,
2,
2,
13,
17,
2,
13,
17,
29,
17,
29,
2,
2,
18,
13,
13,
2,
2,
18,
13,
13,
18,
13,
2,
13,
13,
13,
13,
23,
13,
23,
13,
0,
13,
17,
42,
17,
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,
13,
13,
0,
13,
17,
0,
13,
17,
14,
2,
2,
13,
13,
2,
13,
13,
3,
4,
13,
13,
10,
13,
13,
10,
2,
13,
10,
4,
13,
10,
2,
13,
10,
4,
13,
10,
17,
13,
10,
12,
13,
10,
13,
13,
10,
2,
13,
10,
4,
13,
10,
4,
13,
10,
17,
13,
10,
13,
13,
10,
17,
13
] | [
[
260,
2
],
[
260,
11
],
[
260,
12
],
[
260,
13
],
[
254,
15
],
[
239,
24
],
[
33,
32
],
[
255,
35
],
[
230,
39
],
[
44,
43
],
[
255,
46
],
[
266,
50
],
[
55,
54
],
[
255,
57
],
[
251,
61
],
[
72,
64
],
[
231,
65
],
[
72,
69
],
[
231,
70
],
[
82,
74
],
[
267,
75
],
[
82,
79
],
[
267,
80
],
[
87,
84
],
[
252,
85
],
[
90,
89
],
[
255,
93
],
[
98,
95
],
[
231,
96
],
[
89,
97
],
[
231,
101
],
[
89,
103
],
[
89,
105
],
[
240,
106
],
[
111,
108
],
[
252,
109
],
[
89,
110
],
[
240,
112
],
[
252,
116
],
[
240,
118
],
[
89,
119
],
[
240,
121
],
[
89,
122
],
[
240,
123
],
[
128,
125
],
[
267,
126
],
[
89,
127
],
[
267,
131
],
[
89,
133
],
[
108,
135
],
[
252,
136
],
[
89,
137
],
[
240,
138
],
[
176,
143
],
[
178,
144
],
[
176,
150
],
[
178,
153
],
[
231,
161
],
[
176,
162
],
[
267,
166
],
[
178,
167
],
[
267,
169
],
[
176,
171
],
[
178,
172
],
[
240,
173
],
[
240,
174
],
[
176,
176
],
[
178,
178
],
[
269,
180
],
[
233,
185
],
[
270,
188
],
[
234,
188
],
[
249,
191
],
[
258,
195
],
[
237,
196
],
[
246,
196
],
[
243,
198
],
[
264,
198
],
[
243,
199
],
[
264,
199
],
[
249,
201
],
[
237,
205
],
[
246,
205
],
[
261,
206
],
[
243,
207
],
[
264,
207
],
[
237,
209
],
[
246,
209
],
[
240,
210
],
[
245,
212
],
[
263,
215
],
[
246,
220
],
[
237,
220
],
[
258,
221
],
[
264,
223
],
[
243,
223
],
[
261,
224
],
[
234,
228
],
[
270,
228
],
[
230,
231
],
[
233,
234
],
[
260,
237
],
[
239,
240
],
[
260,
243
],
[
245,
246
],
[
251,
252
],
[
254,
255
],
[
260,
258
],
[
260,
261
],
[
263,
264
],
[
266,
267
],
[
269,
270
]
] | [
"H,W,A,B=map(int,input().split())\nMAX_NUM = 2*10**5 + 1\npr = 10**9+7\nfac = [0 for _ in range(MAX_NUM)]\nfinv = [0 for _ in range(MAX_NUM)]\ninv = [0 for _ in range(MAX_NUM)]\nfac[0] = fac[1] = 1\nfinv[0] = finv[1] = 1\ninv[1] = 1\nfor i in range(2,MAX_NUM):\n fac[i] = fac[i-1] * i % pr\n inv[i] = pr - inv[pr%i] * (pr // i) % pr\n finv[i] = finv[i-1] * inv[i] % pr\ndef c(n,k):\n if n < k:\n return 0\n if n < 0 or k < 0:\n return 0\n return fac[n] * (finv[k] * finv[n-k] % pr) % pr\na=0\nwhile 1:\n a=(a+c(H-A-1+B,B)*c(A+W-B-1,A))%pr\n A+=1\n B+=1\n if A==H or B==W:\n break\nprint(a)",
"H,W,A,B=map(int,input().split())",
"H",
"map(int,input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"W",
"A",
"B",
"MAX_NUM = 2*10**5 + 1",
"MAX_NUM",
"2*10**5 + 1",
"2*10**5",
"2",
"10**5",
"10",
"5",
"1",
"pr = 10**9+7",
"pr",
"10**9+7",
"10**9",
"10",
"9",
"7",
"0 for _ in range(MAX_NUM)",
"for _ in range(MAX_NUM)",
"_",
"range(MAX_NUM)",
"range",
"MAX_NUM",
"for _ in range(MAX_NUM)",
"0",
"fac = [0 for _ in range(MAX_NUM)]",
"fac",
"[0 for _ in range(MAX_NUM)]",
"0 for _ in range(MAX_NUM)",
"for _ in range(MAX_NUM)",
"_",
"range(MAX_NUM)",
"range",
"MAX_NUM",
"for _ in range(MAX_NUM)",
"0",
"finv = [0 for _ in range(MAX_NUM)]",
"finv",
"[0 for _ in range(MAX_NUM)]",
"0 for _ in range(MAX_NUM)",
"for _ in range(MAX_NUM)",
"_",
"range(MAX_NUM)",
"range",
"MAX_NUM",
"for _ in range(MAX_NUM)",
"0",
"inv = [0 for _ in range(MAX_NUM)]",
"inv",
"[0 for _ in range(MAX_NUM)]",
"fac[0] = fac[1] = 1",
"fac[0]",
"fac",
"0",
"1",
"= fac[1] = 1",
"fac[1]",
"fac",
"1",
"1",
"finv[0] = finv[1] = 1",
"finv[0]",
"finv",
"0",
"1",
"= finv[1] = 1",
"finv[1]",
"finv",
"1",
"1",
"inv[1] = 1",
"inv[1]",
"inv",
"1",
"1",
"for i in range(2,MAX_NUM):\n fac[i] = fac[i-1] * i % pr\n inv[i] = pr - inv[pr%i] * (pr // i) % pr\n finv[i] = finv[i-1] * inv[i] % pr",
"i",
"range(2,MAX_NUM)",
"range",
"2",
"MAX_NUM",
"fac[i] = fac[i-1] * i % pr",
"fac[i]",
"fac",
"i",
"fac[i-1] * i % pr",
"fac[i-1] * i",
"fac[i-1]",
"fac",
"i-1",
"i",
"1",
"i",
"pr",
"inv[i] = pr - inv[pr%i] * (pr // i) % pr",
"inv[i]",
"inv",
"i",
"pr - inv[pr%i] * (pr // i) % pr",
"pr",
"inv[pr%i] * (pr // i) % pr",
"inv[pr%i] * (pr // i)",
"inv[pr%i]",
"inv",
"pr%i",
"pr",
"i",
"pr // i",
"pr",
"i",
"pr",
"finv[i] = finv[i-1] * inv[i] % pr",
"finv[i]",
"finv",
"i",
"finv[i-1] * inv[i] % pr",
"finv[i-1] * inv[i]",
"finv[i-1]",
"finv",
"i-1",
"i",
"1",
"inv[i]",
"inv",
"i",
"pr",
"def c(n,k):\n if n < k:\n return 0\n if n < 0 or k < 0:\n return 0\n return fac[n] * (finv[k] * finv[n-k] % pr) % pr",
"c",
"if n < k:\n return 0\n ",
"n < k",
"n",
"k",
"return 0",
"0",
"if n < 0 or k < 0:\n return 0\n ",
"n < 0 or k < 0",
"n < 0",
"n",
"0",
"k < 0",
"k",
"0",
"return 0",
"0",
"return fac[n] * (finv[k] * finv[n-k] % pr) % pr",
"fac[n] * (finv[k] * finv[n-k] % pr) % pr",
"fac[n] * (finv[k] * finv[n-k] % pr)",
"fac[n]",
"fac",
"n",
"finv[k] * finv[n-k] % pr",
"finv[k] * finv[n-k]",
"finv[k]",
"finv",
"k",
"finv[n-k]",
"finv",
"n-k",
"n",
"k",
"pr",
"pr",
"n",
"n",
"k",
"k",
"a=0",
"a",
"0",
"while 1:\n a=(a+c(H-A-1+B,B)*c(A+W-B-1,A))%pr\n A+=1\n B+=1\n if A==H or B==W:\n break",
"1",
"a=(a+c(H-A-1+B,B)*c(A+W-B-1,A))%pr",
"a",
"(a+c(H-A-1+B,B)*c(A+W-B-1,A))%pr",
"a+c(H-A-1+B,B)*c(A+W-B-1,A)",
"a",
"c(H-A-1+B,B)*c(A+W-B-1,A)",
"c(H-A-1+B,B)",
"c",
"H-A-1+B",
"H-A-1",
"H-A",
"H",
"A",
"1",
"B",
"B",
"c(A+W-B-1,A)",
"c",
"A+W-B-1",
"A+W-B",
"A+W",
"A",
"W",
"B",
"1",
"A",
"pr",
"A+=1",
"A",
"1",
"B+=1",
"B",
"1",
"if A==H or B==W:\n break",
"A==H or B==W",
"A==H",
"A",
"H",
"B==W",
"B",
"W",
"break",
"print(a)",
"print",
"a",
"fac = [0 for _ in range(MAX_NUM)]",
"[0 for _ in range(MAX_NUM)]",
"fac",
"a=(a+c(H-A-1+B,B)*c(A+W-B-1,A))%pr",
"(a+c(H-A-1+B,B)*c(A+W-B-1,A))%pr",
"a",
"A,B=map(int,input().split())",
"map(int,input().split())",
"A",
"pr = 10**9+7",
"10**9+7",
"pr",
"B=map(int,input().split())",
"map(int,input().split())",
"B",
"A+=1",
"1",
"A",
"def c(n,k):\n if n < k:\n return 0\n if n < 0 or k < 0:\n return 0\n return fac[n] * (finv[k] * finv[n-k] % pr) % pr",
"def c(n,k):\n if n < k:\n return 0\n if n < 0 or k < 0:\n return 0\n return fac[n] * (finv[k] * finv[n-k] % pr) % pr",
"c",
"inv = [0 for _ in range(MAX_NUM)]",
"[0 for _ in range(MAX_NUM)]",
"inv",
"MAX_NUM = 2*10**5 + 1",
"2*10**5 + 1",
"MAX_NUM",
"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+=1",
"1",
"B",
"finv = [0 for _ in range(MAX_NUM)]",
"[0 for _ in range(MAX_NUM)]",
"finv",
"a=0",
"0",
"a"
] | H,W,A,B=map(int,input().split())
MAX_NUM = 2*10**5 + 1
pr = 10**9+7
fac = [0 for _ in range(MAX_NUM)]
finv = [0 for _ in range(MAX_NUM)]
inv = [0 for _ in range(MAX_NUM)]
fac[0] = fac[1] = 1
finv[0] = finv[1] = 1
inv[1] = 1
for i in range(2,MAX_NUM):
fac[i] = fac[i-1] * i % pr
inv[i] = pr - inv[pr%i] * (pr // i) % pr
finv[i] = finv[i-1] * inv[i] % pr
def c(n,k):
if n < k:
return 0
if n < 0 or k < 0:
return 0
return fac[n] * (finv[k] * finv[n-k] % pr) % pr
a=0
while 1:
a=(a+c(H-A-1+B,B)*c(A+W-B-1,A))%pr
A+=1
B+=1
if A==H or B==W:
break
print(a) |
[
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,
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,
29,
2,
2,
2,
18,
13,
2,
2,
13,
13,
17,
18,
13,
2,
13,
17,
18,
13,
2,
13,
17,
13,
23,
13,
23,
13,
0,
13,
17,
28,
13,
4,
13,
2,
13,
17,
2,
13,
17,
0,
13,
2,
4,
13,
2,
13,
13,
13,
4,
13,
13,
2,
2,
13,
13,
17,
0,
13,
13,
4,
13,
4,
13,
13,
10,
4,
13,
10,
4,
13,
10,
4,
13,
10,
39,
13,
10,
2,
13,
10,
39,
13,
10,
2,
13,
10,
12,
13,
10,
13,
13,
10,
4,
13,
10,
17,
13
] | [
[
159,
4
],
[
159,
13
],
[
159,
14
],
[
159,
15
],
[
150,
17
],
[
141,
24
],
[
147,
28
],
[
33,
32
],
[
133,
38
],
[
160,
39
],
[
142,
43
],
[
142,
48
],
[
32,
50
],
[
151,
51
],
[
148,
54
],
[
142,
59
],
[
151,
62
],
[
151,
64
],
[
142,
72
],
[
90,
75
],
[
92,
76
],
[
148,
79
],
[
90,
81
],
[
148,
84
],
[
92,
86
],
[
151,
88
],
[
90,
90
],
[
92,
92
],
[
162,
94
],
[
98,
97
],
[
136,
101
],
[
160,
104
],
[
144,
107
],
[
154,
110
],
[
133,
112
],
[
139,
113
],
[
97,
114
],
[
154,
116
],
[
139,
117
],
[
160,
120
],
[
97,
121
],
[
156,
124
],
[
151,
125
],
[
157,
130
],
[
145,
130
],
[
163,
130
],
[
159,
133
],
[
159,
136
],
[
159,
139
],
[
141,
142
],
[
144,
145
],
[
147,
148
],
[
150,
151
],
[
151,
156
],
[
156,
157
],
[
159,
160
],
[
162,
163
]
] | [
"import math\nH, W, A, B = map(int, input().split())\nMOD = 10 ** 9 + 7\n\nfactorial = [1]\ninv_factorial = [1]\n\n\nfor i in range(1, H+W+1):\n factorial.append(factorial[-1] * i % MOD)\n inv_factorial.append(pow(factorial[-1], MOD-2, MOD))\n\n\ndef f(h, w):\n return (factorial[h+w-2] * inv_factorial[h-1] * inv_factorial[w-1]) % MOD\n\n\nanswer = 0\nfor i in range(B+1, W+1):\n answer += f(H-A, i) * f(A, W-i+1)\n answer %= MOD\n\nprint(int(answer))",
"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",
"factorial = [1]",
"factorial",
"[1]",
"1",
"inv_factorial = [1]",
"inv_factorial",
"[1]",
"1",
"for i in range(1, H+W+1):\n factorial.append(factorial[-1] * i % MOD)\n inv_factorial.append(pow(factorial[-1], MOD-2, MOD))",
"i",
"range(1, H+W+1)",
"range",
"1",
"H+W+1",
"H+W",
"H",
"W",
"1",
"factorial.append(factorial[-1] * i % MOD)",
"factorial.append",
"factorial",
"append",
"factorial[-1] * i % MOD",
"factorial[-1] * i",
"factorial[-1]",
"factorial",
"-1",
"i",
"MOD",
"inv_factorial.append(pow(factorial[-1], MOD-2, MOD))",
"inv_factorial.append",
"inv_factorial",
"append",
"pow(factorial[-1], MOD-2, MOD)",
"pow",
"factorial[-1]",
"factorial",
"-1",
"MOD-2",
"MOD",
"2",
"MOD",
"def f(h, w):\n return (factorial[h+w-2] * inv_factorial[h-1] * inv_factorial[w-1]) % MOD",
"f",
"return (factorial[h+w-2] * inv_factorial[h-1] * inv_factorial[w-1]) % MOD",
"(factorial[h+w-2] * inv_factorial[h-1] * inv_factorial[w-1]) % MOD",
"factorial[h+w-2] * inv_factorial[h-1] * inv_factorial[w-1]",
"factorial[h+w-2] * inv_factorial[h-1]",
"factorial[h+w-2]",
"factorial",
"h+w-2",
"h+w",
"h",
"w",
"2",
"inv_factorial[h-1]",
"inv_factorial",
"h-1",
"h",
"1",
"inv_factorial[w-1]",
"inv_factorial",
"w-1",
"w",
"1",
"MOD",
"h",
"h",
"w",
"w",
"answer = 0",
"answer",
"0",
"for i in range(B+1, W+1):\n answer += f(H-A, i) * f(A, W-i+1)\n answer %= MOD",
"i",
"range(B+1, W+1)",
"range",
"B+1",
"B",
"1",
"W+1",
"W",
"1",
"answer += f(H-A, i) * f(A, W-i+1)",
"answer",
"f(H-A, i) * f(A, W-i+1)",
"f(H-A, i)",
"f",
"H-A",
"H",
"A",
"i",
"f(A, W-i+1)",
"f",
"A",
"W-i+1",
"W-i",
"W",
"i",
"1",
"answer %= MOD",
"answer",
"MOD",
"print(int(answer))",
"print",
"int(answer)",
"int",
"answer",
"H, W, A, B = map(int, input().split())",
"map(int, input().split())",
"H",
"B = map(int, input().split())",
"map(int, input().split())",
"B",
"A, B = map(int, input().split())",
"map(int, input().split())",
"A",
"factorial = [1]",
"[1]",
"factorial",
"answer += f(H-A, i) * f(A, W-i+1)",
"f(H-A, i) * f(A, W-i+1)",
"answer",
"inv_factorial = [1]",
"[1]",
"inv_factorial",
"MOD = 10 ** 9 + 7",
"10 ** 9 + 7",
"MOD",
"def f(h, w):\n return (factorial[h+w-2] * inv_factorial[h-1] * inv_factorial[w-1]) % MOD",
"def f(h, w):\n return (factorial[h+w-2] * inv_factorial[h-1] * inv_factorial[w-1]) % MOD",
"f",
"answer %= MOD",
"MOD",
"answer",
"W, A, B = map(int, input().split())",
"map(int, input().split())",
"W",
"answer = 0",
"0",
"answer"
] | import math
H, W, A, B = map(int, input().split())
MOD = 10 ** 9 + 7
factorial = [1]
inv_factorial = [1]
for i in range(1, H+W+1):
factorial.append(factorial[-1] * i % MOD)
inv_factorial.append(pow(factorial[-1], MOD-2, MOD))
def f(h, w):
return (factorial[h+w-2] * inv_factorial[h-1] * inv_factorial[w-1]) % MOD
answer = 0
for i in range(B+1, W+1):
answer += f(H-A, i) * f(A, W-i+1)
answer %= MOD
print(int(answer))
|
[
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,
2,
13,
13,
0,
13,
2,
39,
17,
2,
13,
13,
0,
13,
17,
28,
13,
4,
13,
13,
0,
13,
2,
2,
13,
2,
13,
17,
13,
0,
18,
13,
2,
13,
17,
13,
0,
13,
4,
13,
18,
13,
13,
2,
13,
17,
13,
0,
18,
13,
13,
13,
28,
13,
4,
13,
13,
0,
13,
2,
2,
13,
2,
13,
13,
13,
0,
18,
13,
2,
2,
13,
13,
17,
13,
12,
13,
29,
2,
2,
2,
18,
13,
2,
13,
13,
18,
13,
13,
18,
13,
13,
13,
23,
13,
23,
13,
0,
13,
17,
0,
13,
17,
42,
2,
2,
2,
40,
2,
2,
2,
13,
13,
13,
17,
17,
40,
2,
13,
13,
13,
40,
2,
13,
13,
13,
40,
2,
2,
2,
13,
13,
13,
17,
17,
0,
13,
2,
2,
13,
2,
4,
13,
2,
2,
2,
13,
13,
13,
17,
2,
13,
13,
4,
13,
2,
13,
13,
2,
2,
2,
13,
13,
13,
17,
13,
0,
13,
17,
4,
13,
13,
10,
4,
13,
10,
4,
13,
10,
2,
13,
10,
2,
13,
10,
12,
13,
10,
2,
13,
10,
17,
13,
10,
2,
13,
10,
2,
13,
10,
17,
13,
10,
2,
13,
10,
4,
13,
10,
4,
13,
10,
17,
13,
10,
17,
13,
10,
2,
13,
10,
4,
13
] | [
[
241,
2
],
[
241,
11
],
[
241,
12
],
[
241,
13
],
[
211,
15
],
[
220,
22
],
[
239,
25
],
[
206,
26
],
[
214,
29
],
[
239,
34
],
[
206,
35
],
[
250,
37
],
[
239,
42
],
[
206,
43
],
[
223,
45
],
[
49,
48
],
[
221,
51
],
[
226,
53
],
[
224,
56
],
[
227,
56
],
[
48,
58
],
[
212,
60
],
[
67,
62
],
[
215,
63
],
[
48,
65
],
[
227,
67
],
[
224,
67
],
[
253,
69
],
[
215,
73
],
[
221,
74
],
[
212,
76
],
[
212,
78
],
[
83,
80
],
[
251,
81
],
[
221,
82
],
[
254,
83
],
[
227,
83
],
[
224,
83
],
[
86,
85
],
[
221,
88
],
[
235,
90
],
[
254,
93
],
[
227,
93
],
[
224,
93
],
[
236,
93
],
[
221,
95
],
[
85,
96
],
[
212,
97
],
[
106,
99
],
[
251,
100
],
[
221,
103
],
[
85,
104
],
[
236,
106
],
[
254,
106
],
[
227,
106
],
[
224,
106
],
[
215,
114
],
[
126,
116
],
[
128,
117
],
[
251,
119
],
[
126,
120
],
[
251,
122
],
[
128,
123
],
[
212,
124
],
[
126,
126
],
[
128,
128
],
[
244,
130
],
[
232,
133
],
[
239,
143
],
[
209,
144
],
[
233,
145
],
[
248,
145
],
[
242,
150
],
[
233,
151
],
[
248,
151
],
[
206,
152
],
[
209,
155
],
[
233,
156
],
[
248,
156
],
[
239,
157
],
[
206,
162
],
[
242,
163
],
[
233,
164
],
[
248,
164
],
[
229,
168
],
[
245,
171
],
[
230,
171
],
[
218,
174
],
[
239,
178
],
[
209,
179
],
[
233,
180
],
[
248,
180
],
[
242,
183
],
[
233,
184
],
[
248,
184
],
[
218,
186
],
[
209,
188
],
[
233,
189
],
[
248,
189
],
[
206,
193
],
[
242,
194
],
[
233,
195
],
[
248,
195
],
[
212,
197
],
[
247,
199
],
[
230,
203
],
[
245,
203
],
[
241,
206
],
[
241,
209
],
[
211,
212
],
[
214,
215
],
[
220,
221
],
[
223,
224
],
[
226,
227
],
[
229,
230
],
[
232,
233
],
[
235,
236
],
[
241,
239
],
[
241,
242
],
[
244,
245
],
[
247,
248
],
[
250,
251
],
[
253,
254
]
] | [
"H, W, A, B = map(int,input().split())\nP = 10**9+7\n# H, W, A, B = map(int,\"2 3 1 1\".split())\n\nM = H+W-1\nfactlist = [1] * (H+W)\nfactinvlist = [1] * (H+W)\nt = 1\nfor i in range(M):\n\tt = (t * (i+1)) % P\n\tfactlist[i+1] = t\nt = pow(factlist[M],P-2,P)\nfactinvlist[M] = t\nfor i in range(M):\n\tt = (t * (M-i)) % P\n\tfactinvlist[M-i-1] = t\n\ndef comb(i,j):\n\treturn (factlist[i+j] * factinvlist[i] * factinvlist[j]) % P\n\ns = 0\ni = 0\nwhile H-A-i-1 >= 0 and B+i <= W and A+i <= H and W-B-i-1 >= 0:\n#\tprint((H-A-i,B+i+1))\n\ts = (s + comb(H-A-i-1,B+i) * comb(A+i,W-B-i-1)) % P\n\ti += 1\t\nprint(s)\n",
"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",
"M = H+W-1",
"M",
"H+W-1",
"H+W",
"H",
"W",
"1",
"factlist = [1] * (H+W)",
"factlist",
"[1] * (H+W)",
"[1]",
"1",
"H+W",
"H",
"W",
"factinvlist = [1] * (H+W)",
"factinvlist",
"[1] * (H+W)",
"[1]",
"1",
"H+W",
"H",
"W",
"t = 1",
"t",
"1",
"for i in range(M):\n\tt = (t * (i+1)) % P\n\tfactlist[i+1] = t",
"i",
"range(M)",
"range",
"M",
"t = (t * (i+1)) % P",
"t",
"(t * (i+1)) % P",
"t * (i+1)",
"t",
"i+1",
"i",
"1",
"P",
"factlist[i+1] = t",
"factlist[i+1]",
"factlist",
"i+1",
"i",
"1",
"t",
"t = pow(factlist[M],P-2,P)",
"t",
"pow(factlist[M],P-2,P)",
"pow",
"factlist[M]",
"factlist",
"M",
"P-2",
"P",
"2",
"P",
"factinvlist[M] = t",
"factinvlist[M]",
"factinvlist",
"M",
"t",
"for i in range(M):\n\tt = (t * (M-i)) % P\n\tfactinvlist[M-i-1] = t",
"i",
"range(M)",
"range",
"M",
"t = (t * (M-i)) % P",
"t",
"(t * (M-i)) % P",
"t * (M-i)",
"t",
"M-i",
"M",
"i",
"P",
"factinvlist[M-i-1] = t",
"factinvlist[M-i-1]",
"factinvlist",
"M-i-1",
"M-i",
"M",
"i",
"1",
"t",
"def comb(i,j):\n\treturn (factlist[i+j] * factinvlist[i] * factinvlist[j]) % P",
"comb",
"return (factlist[i+j] * factinvlist[i] * factinvlist[j]) % P",
"(factlist[i+j] * factinvlist[i] * factinvlist[j]) % P",
"factlist[i+j] * factinvlist[i] * factinvlist[j]",
"factlist[i+j] * factinvlist[i]",
"factlist[i+j]",
"factlist",
"i+j",
"i",
"j",
"factinvlist[i]",
"factinvlist",
"i",
"factinvlist[j]",
"factinvlist",
"j",
"P",
"i",
"i",
"j",
"j",
"s = 0",
"s",
"0",
"i = 0",
"i",
"0",
"while H-A-i-1 >= 0 and B+i <= W and A+i <= H and W-B-i-1 >= 0:\n#\tprint((H-A-i,B+i+1))\n\ts = (s + comb(H-A-i-1,B+i) * comb(A+i,W-B-i-1)) % P\n\ti += 1\t",
"H-A-i-1 >= 0 and B+i <= W and A+i <= H and W-B-i-1 >= 0",
"H-A-i-1 >= 0 and B+i <= W and A+i <= H",
"H-A-i-1 >= 0 and B+i <= W",
"H-A-i-1 >= 0",
"H-A-i-1",
"H-A-i",
"H-A",
"H",
"A",
"i",
"1",
"0",
"B+i <= W",
"B+i",
"B",
"i",
"W",
"A+i <= H",
"A+i",
"A",
"i",
"H",
"W-B-i-1 >= 0",
"W-B-i-1",
"W-B-i",
"W-B",
"W",
"B",
"i",
"1",
"0",
"s = (s + comb(H-A-i-1,B+i) * comb(A+i,W-B-i-1)) % P",
"s",
"(s + comb(H-A-i-1,B+i) * comb(A+i,W-B-i-1)) % P",
"s + comb(H-A-i-1,B+i) * comb(A+i,W-B-i-1)",
"s",
"comb(H-A-i-1,B+i) * comb(A+i,W-B-i-1)",
"comb(H-A-i-1,B+i)",
"comb",
"H-A-i-1",
"H-A-i",
"H-A",
"H",
"A",
"i",
"1",
"B+i",
"B",
"i",
"comb(A+i,W-B-i-1)",
"comb",
"A+i",
"A",
"i",
"W-B-i-1",
"W-B-i",
"W-B",
"W",
"B",
"i",
"1",
"P",
"i += 1",
"i",
"1",
"print(s)",
"print",
"s",
"W, A, B = map(int,input().split())",
"map(int,input().split())",
"W",
"A, B = map(int,input().split())",
"map(int,input().split())",
"A",
"P = 10**9+7",
"10**9+7",
"P",
"factlist = [1] * (H+W)",
"[1] * (H+W)",
"factlist",
"def comb(i,j):\n\treturn (factlist[i+j] * factinvlist[i] * factinvlist[j]) % P",
"def comb(i,j):\n\treturn (factlist[i+j] * factinvlist[i] * factinvlist[j]) % P",
"comb",
"M = H+W-1",
"H+W-1",
"M",
"t = 1",
"1",
"t",
"t = (t * (i+1)) % P",
"(t * (i+1)) % P",
"t",
"s = (s + comb(H-A-i-1,B+i) * comb(A+i,W-B-i-1)) % P",
"(s + comb(H-A-i-1,B+i) * comb(A+i,W-B-i-1)) % P",
"s",
"i = 0",
"0",
"i",
"t = (t * (M-i)) % P",
"(t * (M-i)) % P",
"t",
"H, W, A, B = map(int,input().split())",
"map(int,input().split())",
"H",
"B = map(int,input().split())",
"map(int,input().split())",
"B",
"s = 0",
"0",
"s",
"i += 1",
"1",
"i",
"factinvlist = [1] * (H+W)",
"[1] * (H+W)",
"factinvlist",
"t = pow(factlist[M],P-2,P)",
"pow(factlist[M],P-2,P)",
"t"
] | H, W, A, B = map(int,input().split())
P = 10**9+7
# H, W, A, B = map(int,"2 3 1 1".split())
M = H+W-1
factlist = [1] * (H+W)
factinvlist = [1] * (H+W)
t = 1
for i in range(M):
t = (t * (i+1)) % P
factlist[i+1] = t
t = pow(factlist[M],P-2,P)
factinvlist[M] = t
for i in range(M):
t = (t * (M-i)) % P
factinvlist[M-i-1] = t
def comb(i,j):
return (factlist[i+j] * factinvlist[i] * factinvlist[j]) % P
s = 0
i = 0
while H-A-i-1 >= 0 and B+i <= W and A+i <= H and W-B-i-1 >= 0:
# print((H-A-i,B+i+1))
s = (s + comb(H-A-i-1,B+i) * comb(A+i,W-B-i-1)) % P
i += 1
print(s)
|
[
7,
15,
15,
13,
4,
18,
13,
13,
17,
0,
13,
2,
2,
17,
17,
17,
0,
13,
18,
13,
13,
41,
28,
13,
4,
18,
4,
18,
4,
13,
13,
13,
4,
4,
13,
13,
0,
13,
13,
13,
13,
13,
0,
13,
39,
17,
28,
13,
4,
13,
17,
2,
13,
13,
4,
18,
13,
13,
2,
2,
18,
13,
2,
13,
17,
13,
13,
12,
13,
14,
2,
13,
17,
29,
17,
14,
2,
13,
17,
29,
2,
13,
13,
14,
2,
2,
13,
17,
17,
29,
2,
2,
4,
13,
13,
4,
13,
2,
13,
17,
17,
13,
29,
2,
2,
2,
4,
13,
13,
4,
13,
2,
2,
13,
17,
17,
17,
13,
13,
23,
13,
23,
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,
2,
39,
17,
2,
13,
13,
0,
18,
13,
17,
4,
13,
18,
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,
13,
13,
0,
13,
2,
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,
2,
13,
13,
10,
17,
13,
10,
2,
13,
10,
13,
13,
10,
18,
13,
10,
13,
13,
10,
12,
13,
10,
39,
13,
10,
12,
13,
10,
2,
13,
10,
2,
13,
10,
13,
13,
10,
13,
13
] | [
[
238,
10
],
[
244,
17
],
[
24,
23
],
[
245,
29
],
[
23,
35
],
[
268,
37
],
[
268,
39
],
[
268,
40
],
[
268,
41
],
[
253,
43
],
[
48,
47
],
[
242,
52
],
[
248,
53
],
[
254,
56
],
[
254,
61
],
[
47,
63
],
[
47,
65
],
[
239,
66
],
[
122,
71
],
[
122,
77
],
[
120,
81
],
[
239,
82
],
[
122,
86
],
[
120,
94
],
[
122,
98
],
[
239,
101
],
[
120,
108
],
[
122,
113
],
[
120,
117
],
[
239,
118
],
[
120,
120
],
[
122,
122
],
[
254,
131
],
[
144,
132
],
[
146,
135
],
[
239,
136
],
[
144,
140
],
[
146,
141
],
[
239,
142
],
[
144,
144
],
[
146,
146
],
[
259,
148
],
[
242,
153
],
[
248,
154
],
[
159,
156
],
[
260,
157
],
[
257,
160
],
[
254,
162
],
[
239,
165
],
[
169,
168
],
[
242,
173
],
[
248,
174
],
[
182,
179
],
[
260,
180
],
[
168,
181
],
[
260,
185
],
[
168,
187
],
[
168,
190
],
[
239,
192
],
[
235,
194
],
[
198,
197
],
[
269,
200
],
[
248,
201
],
[
262,
203
],
[
251,
207
],
[
197,
211
],
[
242,
212
],
[
266,
213
],
[
197,
215
],
[
251,
217
],
[
266,
221
],
[
248,
222
],
[
197,
223
],
[
266,
226
],
[
239,
228
],
[
263,
232
],
[
236,
232
],
[
239,
233
],
[
235,
236
],
[
238,
239
],
[
268,
242
],
[
244,
245
],
[
268,
248
],
[
253,
254
],
[
259,
260
],
[
262,
263
],
[
268,
266
],
[
268,
269
]
] | [
"from sys import stdin\nimport sys\nsys.setrecursionlimit(1000000)\nmod = 10 ** 9 + 7\ninput = stdin.readline\n\nH, W, A, B = [int(x) for x in input().rstrip().split()]\n\nfactorial = [1]\nfor i in range(1, H+W):\n\tfactorial.append(factorial[i-1] * i % mod)\n\ndef power(x, y):\n\tif y == 0:\n\t\treturn 1\n\telif y == 1:\n\t\treturn x % mod\n\telif y % 2 == 0:\n\t\treturn power(x, int(y/2)) ** 2 % mod\n\telse:\n\t\treturn power(x, int((y-1)/2)) ** 2 * x % mod\ndef C(n, r):\n\treturn (((factorial[n] * x_inv[r]) % mod) * x_inv[n-r]) % mod\n# x_inv = []\n# for i in range(H+W):\n# \tx_inv.append(power(factorial[i], mod-2))\n\nx_inv = [0] * (H+W)\nx_inv[-1] = power(factorial[-1], mod-2)\nfor i in range(H+W-2, -1, -1):\n\tx_inv[i] = x_inv[i+1] * (i+1) % mod\n\nsum = 0\nfor i in range(B, W):\n\tsum += C(i+H-A-1, i) * C(A+W-i-2, A-1) % mod\nprint(sum%mod)",
"from sys import stdin",
"import sys",
"sys",
"sys.setrecursionlimit(1000000)",
"sys.setrecursionlimit",
"sys",
"setrecursionlimit",
"1000000",
"mod = 10 ** 9 + 7",
"mod",
"10 ** 9 + 7",
"10 ** 9",
"10",
"9",
"7",
"input = stdin.readline",
"input",
"stdin.readline",
"stdin",
"readline",
"int(x) for x in input().rstrip().split()",
"for x in input().rstrip().split()",
"x",
"input().rstrip().split()",
"().rstrip().split",
"().rstrip()",
"().rstrip",
"()",
"input",
"rstrip",
"split",
"for x in input().rstrip().split()",
"int(x)",
"int",
"x",
"H, W, A, B = [int(x) for x in input().rstrip().split()]",
"H",
"[int(x) for x in input().rstrip().split()]",
"W",
"A",
"B",
"factorial = [1]",
"factorial",
"[1]",
"1",
"for i in range(1, H+W):\n\tfactorial.append(factorial[i-1] * i % mod)",
"i",
"range(1, H+W)",
"range",
"1",
"H+W",
"H",
"W",
"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",
"def power(x, y):\n\tif y == 0:\n\t\treturn 1\n\telif y == 1:\n\t\treturn x % mod\n\telif y % 2 == 0:\n\t\treturn power(x, int(y/2)) ** 2 % mod\n\telse:\n\t\treturn power(x, int((y-1)/2)) ** 2 * x % mod",
"power",
"if y == 0:\n\t\treturn 1\n\telif y == 1:\n\t\treturn x % mod\n\telif y % 2 == 0:\n\t\treturn power(x, int(y/2)) ** 2 % mod\n\telse:\n\t\treturn power(x, int((y-1)/2)) ** 2 * x % mod",
"y == 0",
"y",
"0",
"return 1",
"1",
"elif y == 1:\n\t\treturn x % mod\n\t",
"y == 1",
"y",
"1",
"return x % mod",
"x % mod",
"x",
"mod",
"elif y % 2 == 0:\n\t\treturn power(x, int(y/2)) ** 2 % mod\n\t",
"y % 2 == 0",
"y % 2",
"y",
"2",
"0",
"return power(x, int(y/2)) ** 2 % mod",
"power(x, int(y/2)) ** 2 % mod",
"power(x, int(y/2)) ** 2",
"power(x, int(y/2))",
"power",
"x",
"int(y/2)",
"int",
"y/2",
"y",
"2",
"2",
"mod",
"return power(x, int((y-1)/2)) ** 2 * x % mod",
"power(x, int((y-1)/2)) ** 2 * x % mod",
"power(x, int((y-1)/2)) ** 2 * x",
"power(x, int((y-1)/2)) ** 2",
"power(x, int((y-1)/2))",
"power",
"x",
"int((y-1)/2)",
"int",
"(y-1)/2",
"y-1",
"y",
"1",
"2",
"2",
"x",
"mod",
"x",
"x",
"y",
"y",
"def C(n, r):\n\treturn (((factorial[n] * x_inv[r]) % mod) * x_inv[n-r]) % mod\n# x_inv = []\n# for i in range(H+W):\n# \tx_inv.append(power(factorial[i], mod-2))",
"C",
"return (((factorial[n] * x_inv[r]) % mod) * x_inv[n-r]) % mod",
"(((factorial[n] * x_inv[r]) % mod) * x_inv[n-r]) % mod",
"((factorial[n] * x_inv[r]) % mod) * x_inv[n-r]",
"(factorial[n] * x_inv[r]) % mod",
"factorial[n] * x_inv[r]",
"factorial[n]",
"factorial",
"n",
"x_inv[r]",
"x_inv",
"r",
"mod",
"x_inv[n-r]",
"x_inv",
"n-r",
"n",
"r",
"mod",
"n",
"n",
"r",
"r",
"x_inv = [0] * (H+W)",
"x_inv",
"[0] * (H+W)",
"[0]",
"0",
"H+W",
"H",
"W",
"x_inv[-1] = power(factorial[-1], mod-2)",
"x_inv[-1]",
"x_inv",
"-1",
"power(factorial[-1], mod-2)",
"power",
"factorial[-1]",
"factorial",
"-1",
"mod-2",
"mod",
"2",
"for i in range(H+W-2, -1, -1):\n\tx_inv[i] = x_inv[i+1] * (i+1) % mod",
"i",
"range(H+W-2, -1, -1)",
"range",
"H+W-2",
"H+W",
"H",
"W",
"2",
"-1",
"-1",
"x_inv[i] = x_inv[i+1] * (i+1) % mod",
"x_inv[i]",
"x_inv",
"i",
"x_inv[i+1] * (i+1) % mod",
"x_inv[i+1] * (i+1)",
"x_inv[i+1]",
"x_inv",
"i+1",
"i",
"1",
"i+1",
"i",
"1",
"mod",
"sum = 0",
"sum",
"0",
"for i in range(B, W):\n\tsum += C(i+H-A-1, i) * C(A+W-i-2, A-1) % mod",
"i",
"range(B, W)",
"range",
"B",
"W",
"sum += C(i+H-A-1, i) * C(A+W-i-2, A-1) % mod",
"sum",
"C(i+H-A-1, i) * C(A+W-i-2, A-1) % mod",
"C(i+H-A-1, i) * C(A+W-i-2, A-1)",
"C(i+H-A-1, i)",
"C",
"i+H-A-1",
"i+H-A",
"i+H",
"i",
"H",
"A",
"1",
"i",
"C(A+W-i-2, A-1)",
"C",
"A+W-i-2",
"A+W-i",
"A+W",
"A",
"W",
"i",
"2",
"A-1",
"A",
"1",
"mod",
"print(sum%mod)",
"print",
"sum%mod",
"sum",
"mod",
"sum = 0",
"0",
"sum",
"mod = 10 ** 9 + 7",
"10 ** 9 + 7",
"mod",
"H, W, A, B = [int(x) for x in input().rstrip().split()]",
"[int(x) for x in input().rstrip().split()]",
"H",
"input = stdin.readline",
"stdin.readline",
"input",
"W, A, B = [int(x) for x in input().rstrip().split()]",
"[int(x) for x in input().rstrip().split()]",
"W",
"def C(n, r):\n\treturn (((factorial[n] * x_inv[r]) % mod) * x_inv[n-r]) % mod\n# x_inv = []\n# for i in range(H+W):\n# \tx_inv.append(power(factorial[i], mod-2))",
"def C(n, r):\n\treturn (((factorial[n] * x_inv[r]) % mod) * x_inv[n-r]) % mod\n# x_inv = []\n# for i in range(H+W):\n# \tx_inv.append(power(factorial[i], mod-2))",
"C",
"factorial = [1]",
"[1]",
"factorial",
"def power(x, y):\n\tif y == 0:\n\t\treturn 1\n\telif y == 1:\n\t\treturn x % mod\n\telif y % 2 == 0:\n\t\treturn power(x, int(y/2)) ** 2 % mod\n\telse:\n\t\treturn power(x, int((y-1)/2)) ** 2 * x % mod",
"def power(x, y):\n\tif y == 0:\n\t\treturn 1\n\telif y == 1:\n\t\treturn x % mod\n\telif y % 2 == 0:\n\t\treturn power(x, int(y/2)) ** 2 % mod\n\telse:\n\t\treturn power(x, int((y-1)/2)) ** 2 * x % mod",
"power",
"x_inv = [0] * (H+W)",
"[0] * (H+W)",
"x_inv",
"sum += C(i+H-A-1, i) * C(A+W-i-2, A-1) % mod",
"C(i+H-A-1, i) * C(A+W-i-2, A-1) % mod",
"sum",
"A, B = [int(x) for x in input().rstrip().split()]",
"[int(x) for x in input().rstrip().split()]",
"A",
"B = [int(x) for x in input().rstrip().split()]",
"[int(x) for x in input().rstrip().split()]",
"B"
] | from sys import stdin
import sys
sys.setrecursionlimit(1000000)
mod = 10 ** 9 + 7
input = stdin.readline
H, W, A, B = [int(x) for x in input().rstrip().split()]
factorial = [1]
for i in range(1, H+W):
factorial.append(factorial[i-1] * i % mod)
def power(x, y):
if y == 0:
return 1
elif y == 1:
return x % mod
elif y % 2 == 0:
return power(x, int(y/2)) ** 2 % mod
else:
return power(x, int((y-1)/2)) ** 2 * x % mod
def C(n, r):
return (((factorial[n] * x_inv[r]) % mod) * x_inv[n-r]) % mod
# x_inv = []
# for i in range(H+W):
# x_inv.append(power(factorial[i], mod-2))
x_inv = [0] * (H+W)
x_inv[-1] = power(factorial[-1], mod-2)
for i in range(H+W-2, -1, -1):
x_inv[i] = x_inv[i+1] * (i+1) % mod
sum = 0
for i in range(B, W):
sum += C(i+H-A-1, i) * C(A+W-i-2, A-1) % mod
print(sum%mod)
|
[
7,
0,
13,
39,
17,
0,
13,
39,
17,
0,
13,
2,
2,
17,
17,
17,
0,
13,
4,
13,
13,
4,
18,
4,
13,
13,
13,
13,
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,
13,
2,
13,
17,
13,
0,
13,
17,
28,
13,
4,
13,
13,
13,
0,
13,
2,
2,
2,
18,
13,
2,
2,
2,
13,
13,
17,
13,
18,
13,
2,
2,
13,
13,
17,
18,
13,
13,
2,
2,
18,
13,
2,
2,
2,
13,
17,
13,
13,
18,
13,
2,
13,
17,
18,
13,
2,
2,
13,
13,
17,
0,
13,
13,
4,
13,
13,
10,
4,
13,
10,
17,
13,
10,
39,
13,
10,
4,
13,
10,
13,
13,
10,
4,
13,
10,
2,
13,
10,
2,
13,
10,
39,
13,
10,
4,
13
] | [
[
150,
2
],
[
132,
6
],
[
147,
10
],
[
153,
17
],
[
153,
26
],
[
153,
27
],
[
153,
28
],
[
31,
30
],
[
136,
36
],
[
142,
37
],
[
151,
41
],
[
151,
46
],
[
30,
48
],
[
148,
49
],
[
133,
52
],
[
151,
57
],
[
30,
58
],
[
148,
60
],
[
148,
62
],
[
129,
64
],
[
68,
67
],
[
154,
70
],
[
142,
71
],
[
144,
73
],
[
151,
78
],
[
136,
82
],
[
127,
83
],
[
67,
85
],
[
133,
87
],
[
136,
90
],
[
127,
91
],
[
133,
94
],
[
67,
95
],
[
151,
99
],
[
127,
103
],
[
142,
105
],
[
67,
106
],
[
133,
108
],
[
127,
110
],
[
133,
113
],
[
142,
116
],
[
67,
117
],
[
138,
120
],
[
148,
121
],
[
139,
124
],
[
145,
124
],
[
130,
124
],
[
153,
127
],
[
129,
130
],
[
132,
133
],
[
153,
136
],
[
148,
138
],
[
138,
139
],
[
153,
142
],
[
144,
145
],
[
147,
148
],
[
150,
151
],
[
153,
154
]
] | [
"fact = [1]\ninvfact = [1]\nmod = 10 ** 9 + 7\nh, w, a, b = map(int, input().split())\nfor i in range(1, h+w+1):\n fact.append((fact[-1] * i) % mod)\n invfact.append(pow(fact[i], mod - 2, mod))\n\nans = 0\nfor i in range(b, w):\n ans += (fact[h - a - 1 + i] * invfact[h - a - 1] * invfact[i]) * \\\n (fact[a - 2 + w - i] * invfact[a - 1] * invfact[w - i-1])\n ans %= mod\nprint(ans)",
"fact = [1]",
"fact",
"[1]",
"1",
"invfact = [1]",
"invfact",
"[1]",
"1",
"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",
"for i in range(1, h+w+1):\n fact.append((fact[-1] * i) % mod)\n invfact.append(pow(fact[i], mod - 2, mod))",
"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",
"invfact.append(pow(fact[i], mod - 2, mod))",
"invfact.append",
"invfact",
"append",
"pow(fact[i], mod - 2, mod)",
"pow",
"fact[i]",
"fact",
"i",
"mod - 2",
"mod",
"2",
"mod",
"ans = 0",
"ans",
"0",
"for i in range(b, w):\n ans += (fact[h - a - 1 + i] * invfact[h - a - 1] * invfact[i]) * \\\n (fact[a - 2 + w - i] * invfact[a - 1] * invfact[w - i-1])\n ans %= mod",
"i",
"range(b, w)",
"range",
"b",
"w",
"ans += (fact[h - a - 1 + i] * invfact[h - a - 1] * invfact[i]) * \\\n (fact[a - 2 + w - i] * invfact[a - 1] * invfact[w - i-1])",
"ans",
"(fact[h - a - 1 + i] * invfact[h - a - 1] * invfact[i]) * \\\n (fact[a - 2 + w - i] * invfact[a - 1] * invfact[w - i-1])",
"fact[h - a - 1 + i] * invfact[h - a - 1] * invfact[i]",
"fact[h - a - 1 + i] * invfact[h - a - 1]",
"fact[h - a - 1 + i]",
"fact",
"h - a - 1 + i",
"h - a - 1",
"h - a",
"h",
"a",
"1",
"i",
"invfact[h - a - 1]",
"invfact",
"h - a - 1",
"h - a",
"h",
"a",
"1",
"invfact[i]",
"invfact",
"i",
"fact[a - 2 + w - i] * invfact[a - 1] * invfact[w - i-1]",
"fact[a - 2 + w - i] * invfact[a - 1]",
"fact[a - 2 + w - i]",
"fact",
"a - 2 + w - i",
"a - 2 + w",
"a - 2",
"a",
"2",
"w",
"i",
"invfact[a - 1]",
"invfact",
"a - 1",
"a",
"1",
"invfact[w - i-1]",
"invfact",
"w - i-1",
"w - i",
"w",
"i",
"1",
"ans %= mod",
"ans",
"mod",
"print(ans)",
"print",
"ans",
"a, b = map(int, input().split())",
"map(int, input().split())",
"a",
"ans = 0",
"0",
"ans",
"invfact = [1]",
"[1]",
"invfact",
"h, w, a, b = map(int, input().split())",
"map(int, input().split())",
"h",
"ans %= mod",
"mod",
"ans",
"w, a, b = map(int, input().split())",
"map(int, input().split())",
"w",
"ans += (fact[h - a - 1 + i] * invfact[h - a - 1] * invfact[i]) * \\\n (fact[a - 2 + w - i] * invfact[a - 1] * invfact[w - i-1])",
"(fact[h - a - 1 + i] * invfact[h - a - 1] * invfact[i]) * \\\n (fact[a - 2 + w - i] * invfact[a - 1] * invfact[w - i-1])",
"ans",
"mod = 10 ** 9 + 7",
"10 ** 9 + 7",
"mod",
"fact = [1]",
"[1]",
"fact",
"b = map(int, input().split())",
"map(int, input().split())",
"b"
] | fact = [1]
invfact = [1]
mod = 10 ** 9 + 7
h, w, a, b = map(int, input().split())
for i in range(1, h+w+1):
fact.append((fact[-1] * i) % mod)
invfact.append(pow(fact[i], mod - 2, mod))
ans = 0
for i in range(b, w):
ans += (fact[h - a - 1 + i] * invfact[h - a - 1] * invfact[i]) * \
(fact[a - 2 + w - i] * invfact[a - 1] * invfact[w - i-1])
ans %= 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,
4,
13,
13,
4,
18,
4,
13,
13,
13,
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,
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,
17,
13,
2,
13,
17,
13,
0,
13,
13,
4,
13,
13,
10,
2,
13,
10,
13,
13,
10,
2,
13,
10,
39,
13,
10,
4,
13,
10,
39,
13,
10,
12,
13,
10,
4,
13,
10,
4,
13,
10,
4,
13,
10,
17,
13,
10,
2,
13,
10,
39,
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
],
[
203,
44
],
[
203,
53
],
[
203,
54
],
[
203,
55
],
[
182,
57
],
[
209,
64
],
[
212,
69
],
[
185,
74
],
[
191,
79
],
[
85,
84
],
[
210,
89
],
[
213,
93
],
[
213,
98
],
[
84,
100
],
[
183,
101
],
[
192,
104
],
[
192,
110
],
[
183,
112
],
[
84,
113
],
[
183,
115
],
[
84,
116
],
[
183,
117
],
[
186,
120
],
[
186,
125
],
[
192,
128
],
[
183,
130
],
[
206,
132
],
[
136,
135
],
[
201,
138
],
[
204,
139
],
[
176,
141
],
[
195,
144
],
[
198,
148
],
[
189,
149
],
[
135,
151
],
[
135,
152
],
[
183,
153
],
[
195,
155
],
[
189,
160
],
[
204,
162
],
[
135,
164
],
[
189,
166
],
[
183,
168
],
[
179,
170
],
[
183,
171
],
[
180,
174
],
[
177,
174
],
[
207,
174
],
[
176,
177
],
[
183,
179
],
[
179,
180
],
[
182,
183
],
[
185,
186
],
[
203,
189
],
[
191,
192
],
[
203,
198
],
[
203,
201
],
[
203,
204
],
[
206,
207
],
[
209,
210
],
[
212,
213
]
] | [
"def cmb1(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 \nh,w,a,b=map(int,input().split())\n \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\nans=0\nfor i in range(b,w):\n ans+=cmb1(h-a-1+i,i,mod)*cmb1(a-1+w-1-i,a-1,mod)\n ans%=mod\nprint(ans)",
"def cmb1(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 ",
"cmb1",
"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",
"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**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=0",
"ans",
"0",
"for i in range(b,w):\n ans+=cmb1(h-a-1+i,i,mod)*cmb1(a-1+w-1-i,a-1,mod)\n ans%=mod",
"i",
"range(b,w)",
"range",
"b",
"w",
"ans+=cmb1(h-a-1+i,i,mod)*cmb1(a-1+w-1-i,a-1,mod)",
"ans",
"cmb1(h-a-1+i,i,mod)*cmb1(a-1+w-1-i,a-1,mod)",
"cmb1(h-a-1+i,i,mod)",
"cmb1",
"h-a-1+i",
"h-a-1",
"h-a",
"h",
"a",
"1",
"i",
"i",
"mod",
"cmb1(a-1+w-1-i,a-1,mod)",
"cmb1",
"a-1+w-1-i",
"a-1+w-1",
"a-1+w",
"a-1",
"a",
"1",
"w",
"1",
"i",
"a-1",
"a",
"1",
"mod",
"ans%=mod",
"ans",
"mod",
"print(ans)",
"print",
"ans",
"ans+=cmb1(h-a-1+i,i,mod)*cmb1(a-1+w-1-i,a-1,mod)",
"cmb1(h-a-1+i,i,mod)*cmb1(a-1+w-1-i,a-1,mod)",
"ans",
"ans%=mod",
"mod",
"ans",
"mod=10**9+7",
"10**9+7",
"mod",
"g2=[1,1]",
"[1,1]",
"g2",
"a,b=map(int,input().split())",
"map(int,input().split())",
"a",
"inverse=[0,1]",
"[0,1]",
"inverse",
"def cmb1(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 ",
"def cmb1(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 ",
"cmb1",
"h,w,a,b=map(int,input().split())",
"map(int,input().split())",
"h",
"b=map(int,input().split())",
"map(int,input().split())",
"b",
"w,a,b=map(int,input().split())",
"map(int,input().split())",
"w",
"ans=0",
"0",
"ans",
"n=10**6",
"10**6",
"n",
"g1=[1,1]",
"[1,1]",
"g1"
] | def cmb1(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
h,w,a,b=map(int,input().split())
# 前処理
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=0
for i in range(b,w):
ans+=cmb1(h-a-1+i,i,mod)*cmb1(a-1+w-1-i,a-1,mod)
ans%=mod
print(ans) |
[
7,
0,
13,
2,
17,
2,
17,
17,
0,
13,
2,
2,
17,
17,
17,
0,
13,
2,
39,
17,
2,
13,
17,
0,
13,
2,
39,
17,
2,
13,
17,
28,
13,
4,
13,
17,
2,
13,
17,
0,
18,
13,
13,
2,
2,
18,
13,
2,
13,
17,
13,
13,
0,
18,
13,
13,
4,
13,
18,
13,
13,
2,
13,
17,
13,
28,
13,
4,
13,
13,
17,
17,
0,
18,
13,
2,
13,
17,
2,
2,
18,
13,
13,
13,
13,
12,
13,
14,
2,
2,
13,
17,
2,
13,
13,
29,
17,
0,
13,
18,
13,
13,
0,
13,
18,
13,
13,
0,
13,
13,
0,
13,
18,
13,
2,
13,
13,
0,
13,
13,
29,
13,
23,
13,
23,
13,
41,
28,
13,
4,
18,
4,
13,
13,
17,
4,
4,
13,
13,
0,
13,
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,
13,
17,
2,
2,
13,
17,
13,
2,
2,
13,
17,
13,
13,
0,
13,
13,
4,
13,
13,
10,
2,
13,
10,
13,
13,
10,
13,
13,
10,
2,
13,
10,
13,
13,
10,
2,
13,
10,
13,
13,
10,
2,
13,
10,
2,
13,
10,
12,
13,
10,
17,
13,
10,
13,
13
] | [
[
216,
2
],
[
213,
9
],
[
192,
16
],
[
217,
21
],
[
201,
24
],
[
217,
29
],
[
33,
32
],
[
217,
37
],
[
43,
40
],
[
193,
41
],
[
32,
42
],
[
193,
46
],
[
32,
48
],
[
32,
50
],
[
214,
51
],
[
56,
53
],
[
202,
54
],
[
217,
55
],
[
193,
59
],
[
217,
60
],
[
214,
62
],
[
214,
64
],
[
67,
66
],
[
217,
69
],
[
78,
73
],
[
202,
74
],
[
66,
76
],
[
202,
81
],
[
66,
82
],
[
66,
83
],
[
214,
84
],
[
125,
90
],
[
125,
93
],
[
123,
94
],
[
99,
98
],
[
193,
100
],
[
123,
101
],
[
104,
103
],
[
202,
105
],
[
125,
106
],
[
109,
108
],
[
214,
109
],
[
112,
111
],
[
202,
113
],
[
123,
115
],
[
125,
116
],
[
119,
118
],
[
214,
119
],
[
118,
121
],
[
111,
121
],
[
108,
121
],
[
103,
121
],
[
98,
121
],
[
123,
123
],
[
125,
125
],
[
129,
128
],
[
128,
138
],
[
225,
140
],
[
225,
142
],
[
225,
143
],
[
225,
144
],
[
222,
146
],
[
150,
149
],
[
199,
152
],
[
205,
153
],
[
207,
155
],
[
220,
159
],
[
196,
163
],
[
226,
164
],
[
149,
166
],
[
149,
167
],
[
220,
169
],
[
226,
172
],
[
205,
176
],
[
149,
178
],
[
205,
181
],
[
149,
183
],
[
214,
184
],
[
210,
186
],
[
214,
187
],
[
211,
190
],
[
208,
190
],
[
223,
190
],
[
192,
193
],
[
225,
196
],
[
225,
199
],
[
201,
202
],
[
225,
205
],
[
207,
208
],
[
214,
210
],
[
210,
211
],
[
213,
214
],
[
216,
217
],
[
222,
223
],
[
225,
226
]
] | [
"U = 2*10**5\nMOD = 10**9+7\n \nfact = [1] * (U+1)\nfact_inv = [1] * (U+1)\n\n# 階乗のテーブル作成\nfor i in range(1, U+1):\n fact[i] = (fact[i-1] * i) % MOD\n\n# 階乗の逆元のテーブル作成\nfact_inv[U] = pow(fact[U], MOD-2, MOD)\nfor i in range(U, 0, -1):\n fact_inv[i-1] = (fact_inv[i] * i) % MOD\n\ndef comb(n, k):\n if k < 0 or k > n:\n return 0\n x = fact[n]\n x *= fact_inv[k]\n x %= MOD\n x *= fact_inv[n-k]\n x %= MOD\n return x\n\nH, W, A, B = [int(i) for i in input().split(\" \")]\n\nans = 0\n# 経路の足し上げ C(縦+横, 縦(or横)) (重複のある組み合わせ)\nfor i in range(B, W):\n ans += comb((H-A-1) + i, i) * comb((A - 1) + (W-1-i), W-1- i) % MOD\n ans %= MOD\nprint(ans)",
"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\n\n# 階乗の逆元のテーブル作成",
"i",
"range(1, U+1)",
"range",
"1",
"U+1",
"U",
"1",
"fact[i] = (fact[i-1] * i) % MOD",
"fact[i]",
"fact",
"i",
"(fact[i-1] * i) % MOD",
"fact[i-1] * i",
"fact[i-1]",
"fact",
"i-1",
"i",
"1",
"i",
"MOD",
"fact_inv[U] = pow(fact[U], MOD-2, MOD)",
"fact_inv[U]",
"fact_inv",
"U",
"pow(fact[U], MOD-2, MOD)",
"pow",
"fact[U]",
"fact",
"U",
"MOD-2",
"MOD",
"2",
"MOD",
"for i in range(U, 0, -1):\n fact_inv[i-1] = (fact_inv[i] * i) % MOD",
"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",
"int(i) for i in input().split(\" \")",
"for i in input().split(\" \")",
"i",
"input().split(\" \")",
"().split",
"()",
"input",
"split",
"\" \"",
"for i in input().split(\" \")",
"int(i)",
"int",
"i",
"H, W, A, B = [int(i) for i in input().split(\" \")]",
"H",
"[int(i) for i in input().split(\" \")]",
"W",
"A",
"B",
"ans = 0",
"ans",
"0",
"for i in range(B, W):\n ans += comb((H-A-1) + i, i) * comb((A - 1) + (W-1-i), W-1- i) % MOD\n ans %= MOD",
"i",
"range(B, W)",
"range",
"B",
"W",
"ans += comb((H-A-1) + i, i) * comb((A - 1) + (W-1-i), W-1- i) % MOD",
"ans",
"comb((H-A-1) + i, i) * comb((A - 1) + (W-1-i), W-1- i) % MOD",
"comb((H-A-1) + i, i) * comb((A - 1) + (W-1-i), W-1- i)",
"comb((H-A-1) + i, i)",
"comb",
"(H-A-1) + i",
"H-A-1",
"H-A",
"H",
"A",
"1",
"i",
"i",
"comb((A - 1) + (W-1-i), W-1- i)",
"comb",
"(A - 1) + (W-1-i)",
"A - 1",
"A",
"1",
"W-1-i",
"W-1",
"W",
"1",
"i",
"W-1- i",
"W-1",
"W",
"1",
"i",
"MOD",
"ans %= MOD",
"ans",
"MOD",
"print(ans)",
"print",
"ans",
"fact = [1] * (U+1)",
"[1] * (U+1)",
"fact",
"H, W, A, B = [int(i) for i in input().split(\" \")]",
"[int(i) for i in input().split(\" \")]",
"H",
"B = [int(i) for i in input().split(\" \")]",
"[int(i) for i in input().split(\" \")]",
"B",
"fact_inv = [1] * (U+1)",
"[1] * (U+1)",
"fact_inv",
"W, A, B = [int(i) for i in input().split(\" \")]",
"[int(i) for i in input().split(\" \")]",
"W",
"ans += comb((H-A-1) + i, i) * comb((A - 1) + (W-1-i), W-1- i) % MOD",
"comb((H-A-1) + i, i) * comb((A - 1) + (W-1-i), W-1- i) % MOD",
"ans",
"ans %= MOD",
"MOD",
"ans",
"MOD = 10**9+7",
"10**9+7",
"MOD",
"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",
"ans = 0",
"0",
"ans",
"A, B = [int(i) for i in input().split(\" \")]",
"[int(i) for i in input().split(\" \")]",
"A"
] | 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
H, W, A, B = [int(i) for i in input().split(" ")]
ans = 0
# 経路の足し上げ C(縦+横, 縦(or横)) (重複のある組み合わせ)
for i in range(B, W):
ans += comb((H-A-1) + i, i) * comb((A - 1) + (W-1-i), W-1- i) % MOD
ans %= MOD
print(ans) |
[
7,
41,
28,
13,
4,
18,
4,
13,
13,
4,
4,
13,
13,
0,
13,
13,
13,
13,
13,
12,
13,
14,
2,
13,
17,
29,
17,
14,
2,
13,
17,
29,
2,
13,
17,
14,
2,
2,
13,
17,
17,
29,
2,
2,
4,
13,
13,
2,
13,
17,
17,
17,
29,
2,
2,
2,
4,
13,
13,
2,
13,
17,
17,
13,
17,
23,
13,
23,
13,
12,
13,
29,
2,
2,
13,
4,
13,
13,
17,
17,
23,
13,
23,
13,
0,
13,
17,
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,
18,
13,
13,
2,
13,
17,
0,
18,
13,
2,
13,
17,
2,
18,
13,
2,
13,
17,
17,
0,
13,
2,
39,
17,
2,
13,
17,
0,
18,
13,
13,
4,
13,
18,
13,
13,
17,
28,
13,
4,
13,
13,
17,
17,
0,
18,
13,
2,
13,
17,
2,
2,
18,
13,
13,
13,
17,
12,
13,
29,
2,
2,
2,
18,
13,
13,
18,
13,
2,
13,
13,
18,
13,
13,
17,
23,
13,
23,
13,
0,
13,
4,
13,
2,
2,
13,
13,
17,
2,
13,
17,
28,
13,
4,
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,
17,
13,
13,
13,
17,
2,
2,
13,
13,
17,
0,
13,
2,
13,
17,
4,
13,
13,
10,
13,
13,
10,
13,
13,
10,
12,
13,
10,
13,
13,
10,
4,
13,
10,
2,
13,
10,
12,
13,
10,
13,
13,
10,
17,
13,
10,
2,
13,
10,
12,
13,
10,
2,
13,
10,
2,
13
] | [
[
4,
3
],
[
3,
12
],
[
273,
14
],
[
273,
16
],
[
273,
17
],
[
273,
18
],
[
68,
23
],
[
68,
29
],
[
66,
33
],
[
68,
38
],
[
66,
46
],
[
68,
48
],
[
66,
58
],
[
68,
60
],
[
66,
63
],
[
66,
66
],
[
68,
68
],
[
81,
74
],
[
271,
76
],
[
83,
77
],
[
81,
81
],
[
83,
83
],
[
276,
85
],
[
267,
88
],
[
277,
93
],
[
99,
96
],
[
268,
97
],
[
102,
101
],
[
277,
104
],
[
111,
106
],
[
268,
107
],
[
101,
109
],
[
268,
113
],
[
101,
114
],
[
101,
116
],
[
124,
119
],
[
268,
120
],
[
101,
122
],
[
268,
126
],
[
101,
128
],
[
285,
132
],
[
277,
137
],
[
143,
140
],
[
286,
141
],
[
277,
142
],
[
271,
144
],
[
268,
146
],
[
277,
147
],
[
151,
150
],
[
277,
153
],
[
162,
157
],
[
286,
158
],
[
150,
160
],
[
286,
165
],
[
150,
166
],
[
150,
167
],
[
268,
176
],
[
188,
177
],
[
286,
179
],
[
188,
181
],
[
190,
182
],
[
286,
184
],
[
190,
185
],
[
188,
188
],
[
190,
190
],
[
264,
192
],
[
259,
194
],
[
262,
197
],
[
253,
198
],
[
262,
201
],
[
205,
204
],
[
256,
207
],
[
288,
209
],
[
259,
212
],
[
262,
217
],
[
256,
218
],
[
204,
219
],
[
274,
220
],
[
274,
223
],
[
259,
226
],
[
256,
232
],
[
204,
234
],
[
253,
235
],
[
274,
236
],
[
253,
240
],
[
274,
241
],
[
279,
244
],
[
289,
246
],
[
265,
246
],
[
280,
246
],
[
280,
250
],
[
289,
250
],
[
265,
250
],
[
273,
253
],
[
273,
256
],
[
273,
262
],
[
264,
265
],
[
267,
268
],
[
273,
274
],
[
276,
277
],
[
279,
280
],
[
285,
286
],
[
288,
289
]
] | [
"H, W, A, B = (int(i) for i in input().split())\n\ndef power(a, b):\n\tif b == 0:\n\t\treturn 0\n\telif b == 1:\n\t\treturn a % 1000000007\n\telif b % 2 == 0:\n\t\treturn (power(a, b//2) ** 2) % 1000000007\n\telse:\n\t\treturn (power(a, b//2) ** 2 * a) % 1000000007\n \ndef divide(a, b):\n\treturn (a * power(b, 1000000005)) % 1000000007\n\n\n#階乗の逆元を求める\nfac_lim = 300000\nfac = [None]*(fac_lim+1)\nfac[0] = 1\nfor i in range(fac_lim):\n fac[i+1] = fac[i] * (i+1)\n fac[i+1] = fac[i + 1] % 1000000007\n\nfac_inv = [None]*(fac_lim+1)\nfac_inv[fac_lim] = power(fac[fac_lim], 1000000005)\nfor i in range(fac_lim, 0, -1):\n fac_inv[i-1] = (fac_inv[i] * i) % 1000000007\n\ndef conv(a, b):\n return (fac[a] * fac_inv[a-b] * fac_inv[b]) % 1000000007\n\nres = conv(H+W-2, H-1)\nfor i in range(A):\n res -= conv(H-A+i + B-1, B-1) * conv(A-1-i + W-B-1, W-B-1)\n res = res % 1000000007\n\nprint(res)",
"int(i) for i in input().split()",
"for i in input().split()",
"i",
"input().split()",
"().split",
"()",
"input",
"split",
"for i in input().split()",
"int(i)",
"int",
"i",
"H, W, A, B = (int(i) for i in input().split())",
"H",
"(int(i) for i in input().split())",
"W",
"A",
"B",
"def power(a, b):\n\tif b == 0:\n\t\treturn 0\n\telif b == 1:\n\t\treturn a % 1000000007\n\telif b % 2 == 0:\n\t\treturn (power(a, b//2) ** 2) % 1000000007\n\telse:\n\t\treturn (power(a, b//2) ** 2 * a) % 1000000007\n ",
"power",
"if b == 0:\n\t\treturn 0\n\telif b == 1:\n\t\treturn a % 1000000007\n\telif b % 2 == 0:\n\t\treturn (power(a, b//2) ** 2) % 1000000007\n\telse:\n\t\treturn (power(a, b//2) ** 2 * a) % 1000000007\n ",
"b == 0",
"b",
"0",
"return 0",
"0",
"elif b == 1:\n\t\treturn a % 1000000007\n\t",
"b == 1",
"b",
"1",
"return a % 1000000007",
"a % 1000000007",
"a",
"1000000007",
"elif b % 2 == 0:\n\t\treturn (power(a, b//2) ** 2) % 1000000007\n\t",
"b % 2 == 0",
"b % 2",
"b",
"2",
"0",
"return (power(a, b//2) ** 2) % 1000000007",
"(power(a, b//2) ** 2) % 1000000007",
"power(a, b//2) ** 2",
"power(a, b//2)",
"power",
"a",
"b//2",
"b",
"2",
"2",
"1000000007",
"return (power(a, b//2) ** 2 * a) % 1000000007",
"(power(a, b//2) ** 2 * a) % 1000000007",
"power(a, b//2) ** 2 * a",
"power(a, b//2) ** 2",
"power(a, b//2)",
"power",
"a",
"b//2",
"b",
"2",
"2",
"a",
"1000000007",
"a",
"a",
"b",
"b",
"def divide(a, b):\n\treturn (a * power(b, 1000000005)) % 1000000007\n\n\n#階乗の逆元を求める",
"divide",
"return (a * power(b, 1000000005)) % 1000000007",
"(a * power(b, 1000000005)) % 1000000007",
"a * power(b, 1000000005)",
"a",
"power(b, 1000000005)",
"power",
"b",
"1000000005",
"1000000007",
"a",
"a",
"b",
"b",
"fac_lim = 300000",
"fac_lim",
"300000",
"fac = [None]*(fac_lim+1)",
"fac",
"[None]*(fac_lim+1)",
"[None]",
"None",
"fac_lim+1",
"fac_lim",
"1",
"fac[0] = 1",
"fac[0]",
"fac",
"0",
"1",
"for i in range(fac_lim):\n fac[i+1] = fac[i] * (i+1)\n fac[i+1] = fac[i + 1] % 1000000007",
"i",
"range(fac_lim)",
"range",
"fac_lim",
"fac[i+1] = fac[i] * (i+1)",
"fac[i+1]",
"fac",
"i+1",
"i",
"1",
"fac[i] * (i+1)",
"fac[i]",
"fac",
"i",
"i+1",
"i",
"1",
"fac[i+1] = fac[i + 1] % 1000000007",
"fac[i+1]",
"fac",
"i+1",
"i",
"1",
"fac[i + 1] % 1000000007",
"fac[i + 1]",
"fac",
"i + 1",
"i",
"1",
"1000000007",
"fac_inv = [None]*(fac_lim+1)",
"fac_inv",
"[None]*(fac_lim+1)",
"[None]",
"None",
"fac_lim+1",
"fac_lim",
"1",
"fac_inv[fac_lim] = power(fac[fac_lim], 1000000005)",
"fac_inv[fac_lim]",
"fac_inv",
"fac_lim",
"power(fac[fac_lim], 1000000005)",
"power",
"fac[fac_lim]",
"fac",
"fac_lim",
"1000000005",
"for i in range(fac_lim, 0, -1):\n fac_inv[i-1] = (fac_inv[i] * i) % 1000000007",
"i",
"range(fac_lim, 0, -1)",
"range",
"fac_lim",
"0",
"-1",
"fac_inv[i-1] = (fac_inv[i] * i) % 1000000007",
"fac_inv[i-1]",
"fac_inv",
"i-1",
"i",
"1",
"(fac_inv[i] * i) % 1000000007",
"fac_inv[i] * i",
"fac_inv[i]",
"fac_inv",
"i",
"i",
"1000000007",
"def conv(a, b):\n return (fac[a] * fac_inv[a-b] * fac_inv[b]) % 1000000007",
"conv",
"return (fac[a] * fac_inv[a-b] * fac_inv[b]) % 1000000007",
"(fac[a] * fac_inv[a-b] * fac_inv[b]) % 1000000007",
"fac[a] * fac_inv[a-b] * fac_inv[b]",
"fac[a] * fac_inv[a-b]",
"fac[a]",
"fac",
"a",
"fac_inv[a-b]",
"fac_inv",
"a-b",
"a",
"b",
"fac_inv[b]",
"fac_inv",
"b",
"1000000007",
"a",
"a",
"b",
"b",
"res = conv(H+W-2, H-1)",
"res",
"conv(H+W-2, H-1)",
"conv",
"H+W-2",
"H+W",
"H",
"W",
"2",
"H-1",
"H",
"1",
"for i in range(A):\n res -= conv(H-A+i + B-1, B-1) * conv(A-1-i + W-B-1, W-B-1)\n res = res % 1000000007",
"i",
"range(A)",
"range",
"A",
"res -= conv(H-A+i + B-1, B-1) * conv(A-1-i + W-B-1, W-B-1)",
"res",
"conv(H-A+i + B-1, B-1) * conv(A-1-i + W-B-1, W-B-1)",
"conv(H-A+i + B-1, B-1)",
"conv",
"H-A+i + B-1",
"H-A+i + B",
"H-A+i",
"H-A",
"H",
"A",
"i",
"B",
"1",
"B-1",
"B",
"1",
"conv(A-1-i + W-B-1, W-B-1)",
"conv",
"A-1-i + W-B-1",
"A-1-i + W-B",
"A-1-i + W",
"A-1-i",
"A-1",
"A",
"1",
"i",
"W",
"B",
"1",
"W-B-1",
"W-B",
"W",
"B",
"1",
"res = res % 1000000007",
"res",
"res % 1000000007",
"res",
"1000000007",
"print(res)",
"print",
"res",
"W, A, B = (int(i) for i in input().split())",
"(int(i) for i in input().split())",
"W",
"A, B = (int(i) for i in input().split())",
"(int(i) for i in input().split())",
"A",
"def conv(a, b):\n return (fac[a] * fac_inv[a-b] * fac_inv[b]) % 1000000007",
"def conv(a, b):\n return (fac[a] * fac_inv[a-b] * fac_inv[b]) % 1000000007",
"conv",
"H, W, A, B = (int(i) for i in input().split())",
"(int(i) for i in input().split())",
"H",
"res = conv(H+W-2, H-1)",
"conv(H+W-2, H-1)",
"res",
"fac = [None]*(fac_lim+1)",
"[None]*(fac_lim+1)",
"fac",
"def power(a, b):\n\tif b == 0:\n\t\treturn 0\n\telif b == 1:\n\t\treturn a % 1000000007\n\telif b % 2 == 0:\n\t\treturn (power(a, b//2) ** 2) % 1000000007\n\telse:\n\t\treturn (power(a, b//2) ** 2 * a) % 1000000007\n ",
"def power(a, b):\n\tif b == 0:\n\t\treturn 0\n\telif b == 1:\n\t\treturn a % 1000000007\n\telif b % 2 == 0:\n\t\treturn (power(a, b//2) ** 2) % 1000000007\n\telse:\n\t\treturn (power(a, b//2) ** 2 * a) % 1000000007\n ",
"power",
"B = (int(i) for i in input().split())",
"(int(i) for i in input().split())",
"B",
"fac_lim = 300000",
"300000",
"fac_lim",
"res = res % 1000000007",
"res % 1000000007",
"res",
"def divide(a, b):\n\treturn (a * power(b, 1000000005)) % 1000000007\n\n\n#階乗の逆元を求める",
"def divide(a, b):\n\treturn (a * power(b, 1000000005)) % 1000000007\n\n\n#階乗の逆元を求める",
"divide",
"fac_inv = [None]*(fac_lim+1)",
"[None]*(fac_lim+1)",
"fac_inv",
"res -= conv(H-A+i + B-1, B-1) * conv(A-1-i + W-B-1, W-B-1)",
"conv(H-A+i + B-1, B-1) * conv(A-1-i + W-B-1, W-B-1)",
"res"
] | H, W, A, B = (int(i) for i in input().split())
def power(a, b):
if b == 0:
return 0
elif b == 1:
return a % 1000000007
elif b % 2 == 0:
return (power(a, b//2) ** 2) % 1000000007
else:
return (power(a, b//2) ** 2 * a) % 1000000007
def divide(a, b):
return (a * power(b, 1000000005)) % 1000000007
#階乗の逆元を求める
fac_lim = 300000
fac = [None]*(fac_lim+1)
fac[0] = 1
for i in range(fac_lim):
fac[i+1] = fac[i] * (i+1)
fac[i+1] = fac[i + 1] % 1000000007
fac_inv = [None]*(fac_lim+1)
fac_inv[fac_lim] = power(fac[fac_lim], 1000000005)
for i in range(fac_lim, 0, -1):
fac_inv[i-1] = (fac_inv[i] * i) % 1000000007
def conv(a, b):
return (fac[a] * fac_inv[a-b] * fac_inv[b]) % 1000000007
res = conv(H+W-2, H-1)
for i in range(A):
res -= conv(H-A+i + B-1, B-1) * conv(A-1-i + W-B-1, W-B-1)
res = res % 1000000007
print(res) |
[
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,
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,
0,
13,
2,
18,
13,
17,
18,
13,
17,
0,
13,
2,
18,
13,
17,
18,
13,
17,
29,
4,
13,
2,
13,
13,
13,
13,
23,
13,
23,
13,
0,
13,
39,
17,
17,
13,
39,
2,
13,
17,
2,
13,
17,
0,
13,
4,
13,
13,
13,
28,
13,
4,
13,
13,
0,
13,
2,
2,
4,
13,
13,
39,
2,
2,
13,
13,
17,
2,
13,
17,
4,
13,
39,
2,
2,
13,
13,
17,
13,
13,
13,
4,
13,
2,
13,
13,
10,
39,
13,
10,
12,
13,
10,
4,
13,
10,
4,
13,
10,
39,
13,
10,
4,
13,
10,
4,
13,
10,
2,
13,
10,
39,
13,
10,
4,
13,
10,
39,
13,
10,
12,
13,
10,
39,
13,
10,
2,
13,
10,
2,
13
] | [
[
247,
2
],
[
247,
11
],
[
247,
12
],
[
247,
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
],
[
259,
57
],
[
262,
62
],
[
232,
69
],
[
244,
74
],
[
220,
79
],
[
85,
84
],
[
260,
89
],
[
233,
93
],
[
233,
98
],
[
84,
100
],
[
263,
101
],
[
221,
104
],
[
221,
110
],
[
263,
112
],
[
84,
113
],
[
263,
115
],
[
84,
116
],
[
263,
117
],
[
245,
120
],
[
245,
125
],
[
221,
128
],
[
263,
130
],
[
135,
134
],
[
162,
137
],
[
160,
140
],
[
144,
143
],
[
162,
146
],
[
160,
149
],
[
224,
153
],
[
134,
155
],
[
143,
156
],
[
134,
157
],
[
263,
158
],
[
160,
160
],
[
162,
162
],
[
250,
164
],
[
256,
168
],
[
248,
171
],
[
236,
174
],
[
226,
177
],
[
254,
179
],
[
251,
180
],
[
257,
181
],
[
184,
183
],
[
230,
186
],
[
241,
188
],
[
254,
192
],
[
251,
193
],
[
248,
197
],
[
183,
198
],
[
239,
201
],
[
254,
204
],
[
248,
208
],
[
183,
209
],
[
257,
212
],
[
263,
213
],
[
242,
217
],
[
227,
217
],
[
263,
218
],
[
220,
221
],
[
226,
227
],
[
247,
230
],
[
232,
233
],
[
247,
236
],
[
247,
239
],
[
241,
242
],
[
244,
245
],
[
247,
248
],
[
250,
251
],
[
256,
257
],
[
259,
260
],
[
262,
263
]
] | [
"H,W,A,B = map(int,input().split())\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\nN = 10**6 #出力の制限\nmod = 10**9+7 \ng1 = [1, 1] # 元テーブル\ng2 = [1, 1] #逆元テーブル\ninverse = [0, 1] #逆元テーブル計算用テーブル\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 path(a,b):\n h=b[0]-a[0]\n w=b[1]-a[1]\n return cmb(h+w,h,mod)\nst,gl = [0,0],[H-1,W-1]\nans = path(st,gl)\nfor i in range(A):\n ans-=(path(st,[H-i-1,B-1])*path([H-i-1,B],gl))%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",
"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",
"N = 10**6",
"N",
"10**6",
"10",
"6",
"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",
"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 path(a,b):\n h=b[0]-a[0]\n w=b[1]-a[1]\n return cmb(h+w,h,mod)",
"path",
"h=b[0]-a[0]",
"h",
"b[0]-a[0]",
"b[0]",
"b",
"0",
"a[0]",
"a",
"0",
"w=b[1]-a[1]",
"w",
"b[1]-a[1]",
"b[1]",
"b",
"1",
"a[1]",
"a",
"1",
"return cmb(h+w,h,mod)",
"cmb(h+w,h,mod)",
"cmb",
"h+w",
"h",
"w",
"h",
"mod",
"a",
"a",
"b",
"b",
"st,gl = [0,0],[H-1,W-1]",
"st",
"[0,0]",
"0",
"0",
"gl",
"[H-1,W-1]",
"H-1",
"H",
"1",
"W-1",
"W",
"1",
"ans = path(st,gl)",
"ans",
"path(st,gl)",
"path",
"st",
"gl",
"for i in range(A):\n ans-=(path(st,[H-i-1,B-1])*path([H-i-1,B],gl))%mod",
"i",
"range(A)",
"range",
"A",
"ans-=(path(st,[H-i-1,B-1])*path([H-i-1,B],gl))%mod",
"ans",
"(path(st,[H-i-1,B-1])*path([H-i-1,B],gl))%mod",
"path(st,[H-i-1,B-1])*path([H-i-1,B],gl)",
"path(st,[H-i-1,B-1])",
"path",
"st",
"[H-i-1,B-1]",
"H-i-1",
"H-i",
"H",
"i",
"1",
"B-1",
"B",
"1",
"path([H-i-1,B],gl)",
"path",
"[H-i-1,B]",
"H-i-1",
"H-i",
"H",
"i",
"1",
"B",
"gl",
"mod",
"print(ans%mod)",
"print",
"ans%mod",
"ans",
"mod",
"inverse = [0, 1]",
"[0, 1]",
"inverse",
"def cmb(n, r, mod):\n if ( r<0 or r>n ):\n return 0\n r = min(r, n-r)\n return g1[n] * g2[r] * g2[n-r] % mod",
"def cmb(n, r, mod):\n if ( r<0 or r>n ):\n return 0\n r = min(r, n-r)\n return g1[n] * g2[r] * g2[n-r] % mod",
"cmb",
"ans = path(st,gl)",
"path(st,gl)",
"ans",
"A,B = map(int,input().split())",
"map(int,input().split())",
"A",
"g1 = [1, 1]",
"[1, 1]",
"g1",
"W,A,B = map(int,input().split())",
"map(int,input().split())",
"W",
"B = map(int,input().split())",
"map(int,input().split())",
"B",
"ans-=(path(st,[H-i-1,B-1])*path([H-i-1,B],gl))%mod",
"(path(st,[H-i-1,B-1])*path([H-i-1,B],gl))%mod",
"ans",
"g2 = [1, 1]",
"[1, 1]",
"g2",
"H,W,A,B = map(int,input().split())",
"map(int,input().split())",
"H",
"st,gl = [0,0],[H-1,W-1]",
"[0,0]",
"st",
"def path(a,b):\n h=b[0]-a[0]\n w=b[1]-a[1]\n return cmb(h+w,h,mod)",
"def path(a,b):\n h=b[0]-a[0]\n w=b[1]-a[1]\n return cmb(h+w,h,mod)",
"path",
"gl = [0,0],[H-1,W-1]",
"[H-1,W-1]",
"gl",
"N = 10**6",
"10**6",
"N",
"mod = 10**9+7",
"10**9+7",
"mod"
] | 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
N = 10**6 #出力の制限
mod = 10**9+7
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 )
def path(a,b):
h=b[0]-a[0]
w=b[1]-a[1]
return cmb(h+w,h,mod)
st,gl = [0,0],[H-1,W-1]
ans = path(st,gl)
for i in range(A):
ans-=(path(st,[H-i-1,B-1])*path([H-i-1,B],gl))%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,
41,
28,
13,
4,
13,
2,
2,
13,
13,
17,
4,
17,
0,
13,
13,
28,
13,
4,
13,
17,
4,
13,
13,
0,
18,
13,
13,
2,
2,
18,
13,
2,
13,
17,
13,
13,
41,
28,
13,
4,
13,
2,
2,
13,
13,
17,
4,
17,
0,
13,
13,
28,
13,
4,
13,
17,
4,
13,
13,
0,
18,
13,
13,
4,
13,
18,
13,
13,
2,
13,
17,
13,
41,
28,
13,
4,
13,
2,
13,
13,
4,
17,
0,
13,
13,
28,
13,
4,
13,
4,
13,
13,
0,
13,
2,
13,
13,
0,
13,
2,
2,
13,
13,
17,
0,
13,
2,
13,
13,
0,
13,
13,
0,
18,
13,
13,
2,
2,
2,
18,
13,
13,
18,
13,
13,
18,
13,
2,
13,
13,
13,
0,
13,
17,
28,
13,
4,
13,
4,
13,
13,
0,
13,
2,
2,
2,
13,
13,
13,
17,
0,
13,
2,
13,
17,
0,
13,
2,
13,
13,
0,
13,
13,
0,
13,
2,
2,
2,
18,
13,
13,
18,
13,
13,
18,
13,
2,
13,
13,
13,
0,
13,
2,
2,
18,
13,
13,
13,
13,
4,
13,
2,
13,
13,
10,
2,
13,
10,
2,
13,
10,
13,
13,
10,
13,
13,
10,
13,
13,
10,
4,
13,
10,
2,
13,
10,
2,
13,
10,
2,
13,
10,
2,
13,
10,
4,
13,
10,
4,
13,
10,
13,
13,
10,
17,
13,
10,
2,
13,
10,
2,
13,
10,
4,
13,
10,
13,
13,
10,
2,
13
] | [
[
264,
2
],
[
264,
11
],
[
264,
12
],
[
264,
13
],
[
219,
15
],
[
24,
23
],
[
247,
28
],
[
250,
29
],
[
222,
34
],
[
38,
37
],
[
223,
43
],
[
48,
45
],
[
223,
46
],
[
37,
47
],
[
223,
51
],
[
37,
53
],
[
37,
55
],
[
220,
56
],
[
60,
59
],
[
247,
64
],
[
250,
65
],
[
267,
70
],
[
74,
73
],
[
223,
79
],
[
84,
81
],
[
268,
82
],
[
73,
83
],
[
45,
86
],
[
223,
87
],
[
73,
88
],
[
220,
90
],
[
220,
92
],
[
96,
95
],
[
250,
99
],
[
232,
100
],
[
252,
104
],
[
108,
107
],
[
253,
112
],
[
216,
114
],
[
232,
116
],
[
107,
117
],
[
237,
119
],
[
247,
122
],
[
265,
123
],
[
234,
126
],
[
217,
128
],
[
238,
129
],
[
228,
131
],
[
217,
132
],
[
137,
134
],
[
253,
135
],
[
107,
136
],
[
223,
141
],
[
235,
142
],
[
268,
144
],
[
229,
145
],
[
268,
147
],
[
235,
149
],
[
229,
150
],
[
220,
151
],
[
255,
153
],
[
157,
156
],
[
253,
161
],
[
243,
163
],
[
250,
167
],
[
232,
168
],
[
156,
169
],
[
240,
172
],
[
265,
174
],
[
258,
177
],
[
244,
179
],
[
217,
179
],
[
241,
180
],
[
238,
180
],
[
225,
182
],
[
244,
183
],
[
217,
183
],
[
270,
185
],
[
223,
190
],
[
259,
191
],
[
235,
191
],
[
268,
193
],
[
226,
194
],
[
229,
194
],
[
268,
196
],
[
259,
198
],
[
235,
198
],
[
226,
199
],
[
229,
199
],
[
220,
200
],
[
261,
202
],
[
134,
205
],
[
253,
206
],
[
156,
207
],
[
271,
208
],
[
220,
209
],
[
262,
213
],
[
256,
213
],
[
220,
214
],
[
216,
217
],
[
219,
220
],
[
222,
223
],
[
244,
225
],
[
217,
225
],
[
225,
226
],
[
217,
228
],
[
228,
229
],
[
264,
232
],
[
234,
235
],
[
237,
238
],
[
240,
241
],
[
243,
244
],
[
264,
247
],
[
264,
250
],
[
252,
253
],
[
255,
256
],
[
258,
259
],
[
261,
262
],
[
264,
265
],
[
267,
268
],
[
270,
271
]
] | [
"h,w,a,b =map(int,input().split())\nmod = 10**9+7\n\n#階乗を求める\nfact_l = [1 for i in range(h+w+1)]\nfor i in range(1,len(fact_l)):\n fact_l[i] *= (fact_l[i-1]*i)%mod\n\n#逆元\nfactinv_l = [1 for i in range(h+w+1)]\nfor i in range(1,len(fact_l)):\n factinv_l[i] = pow(fact_l[i],mod-2,mod)\n \n#必ず通るポイントまでの組み合わせ\npoint1 = [1 for i in range(w-b)]\nfor i in range(len(point1)):\n yoko = b+i \n tate = h-a-1\n n = yoko+tate\n r = yoko\n point1[i] = fact_l[n]*factinv_l[r]*factinv_l[n-r]%mod\n\n#point1からの経路\nout = 0\nfor i in range(len(point1)):\n yoko = w-b-i-1\n tate = a-1\n n = yoko+tate\n r = yoko\n case = fact_l[n]*factinv_l[r]*factinv_l[n-r]%mod\n out += (point1[i]*case)%mod\nprint(out%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",
"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",
"fact_l = [1 for i in range(h+w+1)]",
"fact_l",
"[1 for i in range(h+w+1)]",
"for i in range(1,len(fact_l)):\n fact_l[i] *= (fact_l[i-1]*i)%mod\n\n#逆元",
"i",
"range(1,len(fact_l))",
"range",
"1",
"len(fact_l)",
"len",
"fact_l",
"fact_l[i] *= (fact_l[i-1]*i)%mod",
"fact_l[i]",
"fact_l",
"i",
"(fact_l[i-1]*i)%mod",
"fact_l[i-1]*i",
"fact_l[i-1]",
"fact_l",
"i-1",
"i",
"1",
"i",
"mod",
"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",
"factinv_l = [1 for i in range(h+w+1)]",
"factinv_l",
"[1 for i in range(h+w+1)]",
"for i in range(1,len(fact_l)):\n factinv_l[i] = pow(fact_l[i],mod-2,mod)\n \n#必ず通るポイントまでの組み合わせ",
"i",
"range(1,len(fact_l))",
"range",
"1",
"len(fact_l)",
"len",
"fact_l",
"factinv_l[i] = pow(fact_l[i],mod-2,mod)",
"factinv_l[i]",
"factinv_l",
"i",
"pow(fact_l[i],mod-2,mod)",
"pow",
"fact_l[i]",
"fact_l",
"i",
"mod-2",
"mod",
"2",
"mod",
"1 for i in range(w-b)",
"for i in range(w-b)",
"i",
"range(w-b)",
"range",
"w-b",
"w",
"b",
"for i in range(w-b)",
"1",
"point1 = [1 for i in range(w-b)]",
"point1",
"[1 for i in range(w-b)]",
"for i in range(len(point1)):\n yoko = b+i \n tate = h-a-1\n n = yoko+tate\n r = yoko\n point1[i] = fact_l[n]*factinv_l[r]*factinv_l[n-r]%mod\n\n#point1からの経路",
"i",
"range(len(point1))",
"range",
"len(point1)",
"len",
"point1",
"yoko = b+i",
"yoko",
"b+i",
"b",
"i",
"tate = h-a-1",
"tate",
"h-a-1",
"h-a",
"h",
"a",
"1",
"n = yoko+tate",
"n",
"yoko+tate",
"yoko",
"tate",
"r = yoko",
"r",
"yoko",
"point1[i] = fact_l[n]*factinv_l[r]*factinv_l[n-r]%mod",
"point1[i]",
"point1",
"i",
"fact_l[n]*factinv_l[r]*factinv_l[n-r]%mod",
"fact_l[n]*factinv_l[r]*factinv_l[n-r]",
"fact_l[n]*factinv_l[r]",
"fact_l[n]",
"fact_l",
"n",
"factinv_l[r]",
"factinv_l",
"r",
"factinv_l[n-r]",
"factinv_l",
"n-r",
"n",
"r",
"mod",
"out = 0",
"out",
"0",
"for i in range(len(point1)):\n yoko = w-b-i-1\n tate = a-1\n n = yoko+tate\n r = yoko\n case = fact_l[n]*factinv_l[r]*factinv_l[n-r]%mod\n out += (point1[i]*case)%mod",
"i",
"range(len(point1))",
"range",
"len(point1)",
"len",
"point1",
"yoko = w-b-i-1",
"yoko",
"w-b-i-1",
"w-b-i",
"w-b",
"w",
"b",
"i",
"1",
"tate = a-1",
"tate",
"a-1",
"a",
"1",
"n = yoko+tate",
"n",
"yoko+tate",
"yoko",
"tate",
"r = yoko",
"r",
"yoko",
"case = fact_l[n]*factinv_l[r]*factinv_l[n-r]%mod",
"case",
"fact_l[n]*factinv_l[r]*factinv_l[n-r]%mod",
"fact_l[n]*factinv_l[r]*factinv_l[n-r]",
"fact_l[n]*factinv_l[r]",
"fact_l[n]",
"fact_l",
"n",
"factinv_l[r]",
"factinv_l",
"r",
"factinv_l[n-r]",
"factinv_l",
"n-r",
"n",
"r",
"mod",
"out += (point1[i]*case)%mod",
"out",
"(point1[i]*case)%mod",
"point1[i]*case",
"point1[i]",
"point1",
"i",
"case",
"mod",
"print(out%mod)",
"print",
"out%mod",
"out",
"mod",
"yoko = b+i",
"b+i",
"yoko",
"mod = 10**9+7",
"10**9+7",
"mod",
"fact_l = [1 for i in range(h+w+1)]",
"[1 for i in range(h+w+1)]",
"fact_l",
"r = yoko",
"yoko",
"r",
"r = yoko",
"yoko",
"r",
"b =map(int,input().split())",
"map(int,input().split())",
"b",
"n = yoko+tate",
"yoko+tate",
"n",
"tate = h-a-1",
"h-a-1",
"tate",
"tate = a-1",
"a-1",
"tate",
"yoko = w-b-i-1",
"w-b-i-1",
"yoko",
"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",
"point1 = [1 for i in range(w-b)]",
"[1 for i in range(w-b)]",
"point1",
"out = 0",
"0",
"out",
"n = yoko+tate",
"yoko+tate",
"n",
"out += (point1[i]*case)%mod",
"(point1[i]*case)%mod",
"out",
"a,b =map(int,input().split())",
"map(int,input().split())",
"a",
"factinv_l = [1 for i in range(h+w+1)]",
"[1 for i in range(h+w+1)]",
"factinv_l",
"case = fact_l[n]*factinv_l[r]*factinv_l[n-r]%mod",
"fact_l[n]*factinv_l[r]*factinv_l[n-r]%mod",
"case"
] | h,w,a,b =map(int,input().split())
mod = 10**9+7
#階乗を求める
fact_l = [1 for i in range(h+w+1)]
for i in range(1,len(fact_l)):
fact_l[i] *= (fact_l[i-1]*i)%mod
#逆元
factinv_l = [1 for i in range(h+w+1)]
for i in range(1,len(fact_l)):
factinv_l[i] = pow(fact_l[i],mod-2,mod)
#必ず通るポイントまでの組み合わせ
point1 = [1 for i in range(w-b)]
for i in range(len(point1)):
yoko = b+i
tate = h-a-1
n = yoko+tate
r = yoko
point1[i] = fact_l[n]*factinv_l[r]*factinv_l[n-r]%mod
#point1からの経路
out = 0
for i in range(len(point1)):
yoko = w-b-i-1
tate = a-1
n = yoko+tate
r = yoko
case = fact_l[n]*factinv_l[r]*factinv_l[n-r]%mod
out += (point1[i]*case)%mod
print(out%mod) |
[
7,
0,
13,
2,
2,
17,
17,
17,
0,
13,
39,
17,
28,
13,
4,
13,
17,
17,
4,
18,
13,
13,
2,
2,
18,
13,
17,
13,
13,
41,
28,
13,
13,
4,
4,
13,
13,
2,
13,
17,
13,
0,
13,
13,
12,
13,
29,
2,
2,
2,
18,
13,
13,
18,
13,
13,
18,
13,
2,
13,
13,
13,
23,
13,
23,
13,
12,
13,
29,
4,
13,
2,
2,
13,
13,
17,
2,
13,
17,
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,
2,
2,
4,
13,
13,
13,
4,
13,
2,
13,
13,
2,
2,
13,
13,
17,
13,
4,
13,
2,
13,
13,
10,
4,
13,
10,
12,
13,
10,
12,
13,
10,
2,
13,
10,
4,
13,
10,
2,
13,
10,
4,
13,
10,
17,
13,
10,
4,
13,
10,
13,
13,
10,
39,
13
] | [
[
143,
2
],
[
164,
9
],
[
14,
13
],
[
165,
20
],
[
165,
25
],
[
13,
27
],
[
144,
28
],
[
32,
31
],
[
165,
31
],
[
31,
36
],
[
144,
38
],
[
144,
40
],
[
161,
42
],
[
165,
51
],
[
63,
52
],
[
162,
54
],
[
65,
55
],
[
162,
57
],
[
63,
59
],
[
65,
60
],
[
144,
61
],
[
63,
63
],
[
65,
65
],
[
141,
70
],
[
80,
73
],
[
82,
74
],
[
80,
77
],
[
80,
80
],
[
82,
82
],
[
158,
84
],
[
158,
93
],
[
158,
94
],
[
158,
95
],
[
155,
97
],
[
101,
100
],
[
159,
106
],
[
153,
107
],
[
149,
110
],
[
138,
114
],
[
135,
115
],
[
100,
116
],
[
138,
118
],
[
147,
120
],
[
135,
121
],
[
159,
124
],
[
100,
125
],
[
144,
127
],
[
150,
131
],
[
156,
131
],
[
144,
132
],
[
158,
135
],
[
143,
144
],
[
158,
147
],
[
149,
150
],
[
158,
153
],
[
155,
156
],
[
158,
159
],
[
161,
162
],
[
164,
165
]
] | [
"MOD = 10**9 + 7\nfactorials = [1]\nfor i in range(1, 200000):\n factorials.append((factorials[-1] * i) % MOD)\ninvs = [pow(x, MOD - 2, MOD) for x in factorials]\n\n\ndef combinations(n, k):\n return (factorials[n] * invs[k] * invs[n - k]) % MOD\n\n\ndef f(x, y):\n return combinations(x + y - 2, x - 1)\n\n\nh, w, a, b = map(int, input().split())\nres = 0\nfor y in range(1, h - a + 1):\n res += (f(b, y) * f(w - b, h - y + 1)) % MOD\nprint(res % MOD)",
"MOD = 10**9 + 7",
"MOD",
"10**9 + 7",
"10**9",
"10",
"9",
"7",
"factorials = [1]",
"factorials",
"[1]",
"1",
"for i in range(1, 200000):\n factorials.append((factorials[-1] * i) % MOD)",
"i",
"range(1, 200000)",
"range",
"1",
"200000",
"factorials.append((factorials[-1] * i) % MOD)",
"factorials.append",
"factorials",
"append",
"(factorials[-1] * i) % MOD",
"factorials[-1] * i",
"factorials[-1]",
"factorials",
"-1",
"i",
"MOD",
"pow(x, MOD - 2, MOD) for x in factorials",
"for x in factorials",
"x",
"factorials",
"for x in factorials",
"pow(x, MOD - 2, MOD)",
"pow",
"x",
"MOD - 2",
"MOD",
"2",
"MOD",
"invs = [pow(x, MOD - 2, MOD) for x in factorials]",
"invs",
"[pow(x, MOD - 2, MOD) for x in factorials]",
"def combinations(n, k):\n return (factorials[n] * invs[k] * invs[n - k]) % MOD",
"combinations",
"return (factorials[n] * invs[k] * invs[n - k]) % MOD",
"(factorials[n] * invs[k] * invs[n - k]) % MOD",
"factorials[n] * invs[k] * invs[n - k]",
"factorials[n] * invs[k]",
"factorials[n]",
"factorials",
"n",
"invs[k]",
"invs",
"k",
"invs[n - k]",
"invs",
"n - k",
"n",
"k",
"MOD",
"n",
"n",
"k",
"k",
"def f(x, y):\n return combinations(x + y - 2, x - 1)",
"f",
"return combinations(x + y - 2, x - 1)",
"combinations(x + y - 2, x - 1)",
"combinations",
"x + y - 2",
"x + y",
"x",
"y",
"2",
"x - 1",
"x",
"1",
"x",
"x",
"y",
"y",
"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",
"for y in range(1, h - a + 1):\n res += (f(b, y) * f(w - b, h - y + 1)) % MOD",
"y",
"range(1, h - a + 1)",
"range",
"1",
"h - a + 1",
"h - a",
"h",
"a",
"1",
"res += (f(b, y) * f(w - b, h - y + 1)) % MOD",
"res",
"(f(b, y) * f(w - b, h - y + 1)) % MOD",
"f(b, y) * f(w - b, h - y + 1)",
"f(b, y)",
"f",
"b",
"y",
"f(w - b, h - y + 1)",
"f",
"w - b",
"w",
"b",
"h - y + 1",
"h - y",
"h",
"y",
"1",
"MOD",
"print(res % MOD)",
"print",
"res % MOD",
"res",
"MOD",
"b = map(int, input().split())",
"map(int, input().split())",
"b",
"def f(x, y):\n return combinations(x + y - 2, x - 1)",
"def f(x, y):\n return combinations(x + y - 2, x - 1)",
"f",
"def combinations(n, k):\n return (factorials[n] * invs[k] * invs[n - k]) % MOD",
"def combinations(n, k):\n return (factorials[n] * invs[k] * invs[n - k]) % MOD",
"combinations",
"MOD = 10**9 + 7",
"10**9 + 7",
"MOD",
"w, a, b = map(int, input().split())",
"map(int, input().split())",
"w",
"res += (f(b, y) * f(w - b, h - y + 1)) % MOD",
"(f(b, y) * f(w - b, h - y + 1)) % MOD",
"res",
"a, b = map(int, input().split())",
"map(int, input().split())",
"a",
"res = 0",
"0",
"res",
"h, w, a, b = map(int, input().split())",
"map(int, input().split())",
"h",
"invs = [pow(x, MOD - 2, MOD) for x in factorials]",
"[pow(x, MOD - 2, MOD) for x in factorials]",
"invs",
"factorials = [1]",
"[1]",
"factorials"
] | MOD = 10**9 + 7
factorials = [1]
for i in range(1, 200000):
factorials.append((factorials[-1] * i) % MOD)
invs = [pow(x, MOD - 2, MOD) for x in factorials]
def combinations(n, k):
return (factorials[n] * invs[k] * invs[n - k]) % MOD
def f(x, y):
return combinations(x + y - 2, x - 1)
h, w, a, b = map(int, input().split())
res = 0
for y in range(1, h - a + 1):
res += (f(b, y) * f(w - b, h - y + 1)) % MOD
print(res % MOD) |
[
7,
6,
13,
12,
13,
0,
18,
13,
13,
13,
0,
18,
13,
13,
13,
23,
13,
23,
13,
23,
13,
12,
13,
29,
4,
13,
18,
13,
13,
23,
13,
12,
13,
29,
4,
18,
17,
13,
18,
13,
13,
18,
13,
13,
23,
13,
12,
13,
0,
13,
2,
18,
13,
13,
18,
13,
13,
0,
13,
18,
13,
13,
29,
4,
13,
13,
18,
13,
13,
23,
13,
23,
13,
12,
13,
0,
13,
2,
18,
13,
13,
18,
13,
13,
0,
13,
18,
13,
13,
29,
4,
13,
13,
18,
13,
13,
23,
13,
23,
13,
12,
13,
0,
13,
2,
18,
13,
13,
18,
13,
13,
0,
13,
18,
13,
13,
29,
4,
13,
13,
18,
13,
13,
23,
13,
23,
13,
12,
13,
0,
13,
4,
13,
18,
13,
13,
13,
18,
13,
13,
29,
4,
13,
13,
18,
13,
13,
23,
13,
23,
13,
12,
13,
29,
4,
18,
13,
13,
2,
18,
13,
13,
17,
23,
13,
12,
13,
0,
13,
2,
13,
4,
18,
13,
13,
29,
4,
13,
13,
18,
13,
13,
23,
13,
23,
13,
0,
13,
4,
13,
13,
4,
18,
4,
13,
13,
13,
13,
13,
0,
13,
2,
2,
17,
17,
17,
0,
13,
39,
4,
13,
17,
13,
0,
13,
39,
4,
18,
4,
13,
17,
13,
13,
12,
13,
29,
2,
2,
18,
13,
13,
18,
13,
13,
18,
13,
2,
13,
13,
23,
13,
23,
13,
28,
13,
4,
13,
17,
2,
2,
13,
13,
17,
4,
18,
13,
13,
2,
18,
13,
17,
4,
13,
13,
13,
4,
18,
13,
13,
4,
18,
18,
13,
17,
13,
0,
13,
4,
13,
17,
13,
28,
13,
4,
13,
13,
13,
0,
13,
2,
4,
13,
2,
2,
2,
13,
13,
17,
13,
13,
4,
13,
2,
2,
2,
2,
13,
17,
13,
13,
17,
2,
13,
17,
4,
13,
13,
10,
4,
13,
10,
4,
13,
10,
39,
13,
10,
2,
13,
10,
39,
13,
10,
12,
13,
10,
4,
13,
10,
6,
13,
10,
2,
13,
10,
4,
13,
10,
4,
13
] | [
[
9,
6
],
[
16,
7
],
[
18,
8
],
[
18,
9
],
[
14,
11
],
[
16,
12
],
[
20,
13
],
[
20,
14
],
[
16,
16
],
[
18,
18
],
[
20,
20
],
[
30,
27
],
[
30,
30
],
[
45,
39
],
[
45,
42
],
[
45,
45
],
[
50,
49
],
[
70,
52
],
[
72,
55
],
[
59,
58
],
[
70,
60
],
[
58,
65
],
[
49,
65
],
[
70,
67
],
[
70,
70
],
[
72,
72
],
[
77,
76
],
[
97,
79
],
[
99,
82
],
[
86,
85
],
[
97,
87
],
[
85,
92
],
[
76,
92
],
[
97,
94
],
[
97,
97
],
[
99,
99
],
[
104,
103
],
[
124,
106
],
[
126,
109
],
[
113,
112
],
[
124,
114
],
[
112,
119
],
[
103,
119
],
[
124,
121
],
[
124,
124
],
[
126,
126
],
[
131,
130
],
[
148,
134
],
[
150,
136
],
[
148,
138
],
[
130,
143
],
[
148,
145
],
[
148,
148
],
[
150,
150
],
[
164,
156
],
[
128,
157
],
[
164,
160
],
[
164,
164
],
[
169,
168
],
[
183,
170
],
[
185,
173
],
[
152,
174
],
[
168,
178
],
[
183,
180
],
[
183,
183
],
[
185,
185
],
[
348,
187
],
[
348,
196
],
[
348,
197
],
[
348,
198
],
[
342,
200
],
[
324,
207
],
[
343,
212
],
[
330,
214
],
[
343,
221
],
[
152,
222
],
[
325,
229
],
[
240,
230
],
[
331,
232
],
[
242,
233
],
[
331,
235
],
[
240,
237
],
[
242,
238
],
[
240,
240
],
[
242,
242
],
[
245,
244
],
[
337,
250
],
[
319,
251
],
[
325,
255
],
[
325,
259
],
[
244,
263
],
[
343,
264
],
[
331,
267
],
[
325,
272
],
[
152,
274
],
[
321,
276
],
[
343,
280
],
[
283,
282
],
[
349,
285
],
[
319,
286
],
[
327,
288
],
[
334,
291
],
[
337,
295
],
[
346,
296
],
[
282,
298
],
[
282,
299
],
[
334,
301
],
[
346,
306
],
[
319,
308
],
[
282,
309
],
[
346,
312
],
[
328,
316
],
[
322,
316
],
[
348,
319
],
[
321,
322
],
[
324,
325
],
[
327,
328
],
[
330,
331
],
[
348,
337
],
[
342,
343
],
[
348,
346
],
[
348,
349
]
] | [
"class ModInt:\n def __init__(self, num, mod):\n self.num = num\n self.mod = mod\n\n def __str__(self):\n return str(self.num)\n\n def __repr__(self):\n return \"ModInt(num: {}, mod: {}\".format(self.num, self.mod)\n\n def __add__(self, other):\n ret = self.num + other.num\n ret %= self.mod\n return ModInt(ret, self.mod)\n\n def __sub__(self, other):\n ret = self.num - other.num\n ret %= self.mod\n return ModInt(ret, self.mod)\n\n def __mul__(self, other):\n ret = self.num * other.num\n ret %= self.mod\n return ModInt(ret, self.mod)\n\n def pow(self, times):\n pw = pow(self.num, times, self.mod)\n return ModInt(pw, self.mod)\n\n def inverse(self):\n return self.pow(self.mod - 2)\n\n def __truediv__(self, other):\n num = self * other.inverse()\n return ModInt(num, self.mod)\n\n\nh, w, a, b = map(int, input().split())\nmod = 10 ** 9 + 7\n\npower = [ModInt(1, mod)]\ninv = [ModInt(1, mod).inverse()]\n\n\ndef comb(n, r):\n return power[n] * inv[r] * inv[n-r]\n\n\nfor i in range(1, h + w - 1):\n power.append(power[-1] * ModInt(i, mod))\n inv.append(power[-1].inverse())\n\nans = ModInt(0, mod)\nfor wi in range(b, w):\n ans += comb(h - a - 1 + wi, wi) * comb(a - 1 + w - wi - 1, a - 1)\n\nprint(ans)",
"class ModInt:\n def __init__(self, num, mod):\n self.num = num\n self.mod = mod\n\n def __str__(self):\n return str(self.num)\n\n def __repr__(self):\n return \"ModInt(num: {}, mod: {}\".format(self.num, self.mod)\n\n def __add__(self, other):\n ret = self.num + other.num\n ret %= self.mod\n return ModInt(ret, self.mod)\n\n def __sub__(self, other):\n ret = self.num - other.num\n ret %= self.mod\n return ModInt(ret, self.mod)\n\n def __mul__(self, other):\n ret = self.num * other.num\n ret %= self.mod\n return ModInt(ret, self.mod)\n\n def pow(self, times):\n pw = pow(self.num, times, self.mod)\n return ModInt(pw, self.mod)\n\n def inverse(self):\n return self.pow(self.mod - 2)\n\n def __truediv__(self, other):\n num = self * other.inverse()\n return ModInt(num, self.mod)",
"ModInt",
"def __init__(self, num, mod):\n self.num = num\n self.mod = mod\n\n ",
"__init__",
"self.num = num",
"self.num",
"self",
"num",
"num",
"self.mod = mod",
"self.mod",
"self",
"mod",
"mod",
"self",
"self",
"num",
"num",
"mod",
"mod",
"def __str__(self):\n return str(self.num)\n\n ",
"__str__",
"return str(self.num)",
"str(self.num)",
"str",
"self.num",
"self",
"num",
"self",
"self",
"def __repr__(self):\n return \"ModInt(num: {}, mod: {}\".format(self.num, self.mod)\n\n ",
"__repr__",
"return \"ModInt(num: {}, mod: {}\".format(self.num, self.mod)",
"\"ModInt(num: {}, mod: {}\".format(self.num, self.mod)",
"\"ModInt(num: {}, mod: {}\".format",
"\"ModInt(num: {}, mod: {}\"",
"format",
"self.num",
"self",
"num",
"self.mod",
"self",
"mod",
"self",
"self",
"def __add__(self, other):\n ret = self.num + other.num\n ret %= self.mod\n return ModInt(ret, self.mod)\n\n ",
"__add__",
"ret = self.num + other.num",
"ret",
"self.num + other.num",
"self.num",
"self",
"num",
"other.num",
"other",
"num",
"ret %= self.mod",
"ret",
"self.mod",
"self",
"mod",
"return ModInt(ret, self.mod)",
"ModInt(ret, self.mod)",
"ModInt",
"ret",
"self.mod",
"self",
"mod",
"self",
"self",
"other",
"other",
"def __sub__(self, other):\n ret = self.num - other.num\n ret %= self.mod\n return ModInt(ret, self.mod)\n\n ",
"__sub__",
"ret = self.num - other.num",
"ret",
"self.num - other.num",
"self.num",
"self",
"num",
"other.num",
"other",
"num",
"ret %= self.mod",
"ret",
"self.mod",
"self",
"mod",
"return ModInt(ret, self.mod)",
"ModInt(ret, self.mod)",
"ModInt",
"ret",
"self.mod",
"self",
"mod",
"self",
"self",
"other",
"other",
"def __mul__(self, other):\n ret = self.num * other.num\n ret %= self.mod\n return ModInt(ret, self.mod)\n\n ",
"__mul__",
"ret = self.num * other.num",
"ret",
"self.num * other.num",
"self.num",
"self",
"num",
"other.num",
"other",
"num",
"ret %= self.mod",
"ret",
"self.mod",
"self",
"mod",
"return ModInt(ret, self.mod)",
"ModInt(ret, self.mod)",
"ModInt",
"ret",
"self.mod",
"self",
"mod",
"self",
"self",
"other",
"other",
"def pow(self, times):\n pw = pow(self.num, times, self.mod)\n return ModInt(pw, self.mod)\n\n ",
"pow",
"pw = pow(self.num, times, self.mod)",
"pw",
"pow(self.num, times, self.mod)",
"pow",
"self.num",
"self",
"num",
"times",
"self.mod",
"self",
"mod",
"return ModInt(pw, self.mod)",
"ModInt(pw, self.mod)",
"ModInt",
"pw",
"self.mod",
"self",
"mod",
"self",
"self",
"times",
"times",
"def inverse(self):\n return self.pow(self.mod - 2)\n\n ",
"inverse",
"return self.pow(self.mod - 2)",
"self.pow(self.mod - 2)",
"self.pow",
"self",
"pow",
"self.mod - 2",
"self.mod",
"self",
"mod",
"2",
"self",
"self",
"def __truediv__(self, other):\n num = self * other.inverse()\n return ModInt(num, self.mod)",
"__truediv__",
"num = self * other.inverse()",
"num",
"self * other.inverse()",
"self",
"other.inverse()",
"other.inverse",
"other",
"inverse",
"return ModInt(num, self.mod)",
"ModInt(num, self.mod)",
"ModInt",
"num",
"self.mod",
"self",
"mod",
"self",
"self",
"other",
"other",
"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",
"power = [ModInt(1, mod)]",
"power",
"[ModInt(1, mod)]",
"ModInt(1, mod)",
"ModInt",
"1",
"mod",
"inv = [ModInt(1, mod).inverse()]",
"inv",
"[ModInt(1, mod).inverse()]",
"ModInt(1, mod).inverse()",
"(1, mod).inverse",
"(1, mod)",
"ModInt",
"1",
"mod",
"inverse",
"def comb(n, r):\n return power[n] * inv[r] * inv[n-r]",
"comb",
"return power[n] * inv[r] * inv[n-r]",
"power[n] * inv[r] * inv[n-r]",
"power[n] * inv[r]",
"power[n]",
"power",
"n",
"inv[r]",
"inv",
"r",
"inv[n-r]",
"inv",
"n-r",
"n",
"r",
"n",
"n",
"r",
"r",
"for i in range(1, h + w - 1):\n power.append(power[-1] * ModInt(i, mod))\n inv.append(power[-1].inverse())",
"i",
"range(1, h + w - 1)",
"range",
"1",
"h + w - 1",
"h + w",
"h",
"w",
"1",
"power.append(power[-1] * ModInt(i, mod))",
"power.append",
"power",
"append",
"power[-1] * ModInt(i, mod)",
"power[-1]",
"power",
"-1",
"ModInt(i, mod)",
"ModInt",
"i",
"mod",
"inv.append(power[-1].inverse())",
"inv.append",
"inv",
"append",
"power[-1].inverse()",
"[-1].inverse",
"[-1]",
"power",
"-1",
"inverse",
"ans = ModInt(0, mod)",
"ans",
"ModInt(0, mod)",
"ModInt",
"0",
"mod",
"for wi in range(b, w):\n ans += comb(h - a - 1 + wi, wi) * comb(a - 1 + w - wi - 1, a - 1)",
"wi",
"range(b, w)",
"range",
"b",
"w",
"ans += comb(h - a - 1 + wi, wi) * comb(a - 1 + w - wi - 1, a - 1)",
"ans",
"comb(h - a - 1 + wi, wi) * comb(a - 1 + w - wi - 1, a - 1)",
"comb(h - a - 1 + wi, wi)",
"comb",
"h - a - 1 + wi",
"h - a - 1",
"h - a",
"h",
"a",
"1",
"wi",
"wi",
"comb(a - 1 + w - wi - 1, a - 1)",
"comb",
"a - 1 + w - wi - 1",
"a - 1 + w - wi",
"a - 1 + w",
"a - 1",
"a",
"1",
"w",
"wi",
"1",
"a - 1",
"a",
"1",
"print(ans)",
"print",
"ans",
"w, a, b = map(int, input().split())",
"map(int, input().split())",
"w",
"ans = ModInt(0, mod)",
"ModInt(0, mod)",
"ans",
"power = [ModInt(1, mod)]",
"[ModInt(1, mod)]",
"power",
"ans += comb(h - a - 1 + wi, wi) * comb(a - 1 + w - wi - 1, a - 1)",
"comb(h - a - 1 + wi, wi) * comb(a - 1 + w - wi - 1, a - 1)",
"ans",
"inv = [ModInt(1, mod).inverse()]",
"[ModInt(1, mod).inverse()]",
"inv",
"def comb(n, r):\n return power[n] * inv[r] * inv[n-r]",
"def comb(n, r):\n return power[n] * inv[r] * inv[n-r]",
"comb",
"h, w, a, b = map(int, input().split())",
"map(int, input().split())",
"h",
"class ModInt:\n def __init__(self, num, mod):\n self.num = num\n self.mod = mod\n\n def __str__(self):\n return str(self.num)\n\n def __repr__(self):\n return \"ModInt(num: {}, mod: {}\".format(self.num, self.mod)\n\n def __add__(self, other):\n ret = self.num + other.num\n ret %= self.mod\n return ModInt(ret, self.mod)\n\n def __sub__(self, other):\n ret = self.num - other.num\n ret %= self.mod\n return ModInt(ret, self.mod)\n\n def __mul__(self, other):\n ret = self.num * other.num\n ret %= self.mod\n return ModInt(ret, self.mod)\n\n def pow(self, times):\n pw = pow(self.num, times, self.mod)\n return ModInt(pw, self.mod)\n\n def inverse(self):\n return self.pow(self.mod - 2)\n\n def __truediv__(self, other):\n num = self * other.inverse()\n return ModInt(num, self.mod)",
"class ModInt:\n def __init__(self, num, mod):\n self.num = num\n self.mod = mod\n\n def __str__(self):\n return str(self.num)\n\n def __repr__(self):\n return \"ModInt(num: {}, mod: {}\".format(self.num, self.mod)\n\n def __add__(self, other):\n ret = self.num + other.num\n ret %= self.mod\n return ModInt(ret, self.mod)\n\n def __sub__(self, other):\n ret = self.num - other.num\n ret %= self.mod\n return ModInt(ret, self.mod)\n\n def __mul__(self, other):\n ret = self.num * other.num\n ret %= self.mod\n return ModInt(ret, self.mod)\n\n def pow(self, times):\n pw = pow(self.num, times, self.mod)\n return ModInt(pw, self.mod)\n\n def inverse(self):\n return self.pow(self.mod - 2)\n\n def __truediv__(self, other):\n num = self * other.inverse()\n return ModInt(num, self.mod)",
"ModInt",
"mod = 10 ** 9 + 7",
"10 ** 9 + 7",
"mod",
"a, b = map(int, input().split())",
"map(int, input().split())",
"a",
"b = map(int, input().split())",
"map(int, input().split())",
"b"
] | class ModInt:
def __init__(self, num, mod):
self.num = num
self.mod = mod
def __str__(self):
return str(self.num)
def __repr__(self):
return "ModInt(num: {}, mod: {}".format(self.num, self.mod)
def __add__(self, other):
ret = self.num + other.num
ret %= self.mod
return ModInt(ret, self.mod)
def __sub__(self, other):
ret = self.num - other.num
ret %= self.mod
return ModInt(ret, self.mod)
def __mul__(self, other):
ret = self.num * other.num
ret %= self.mod
return ModInt(ret, self.mod)
def pow(self, times):
pw = pow(self.num, times, self.mod)
return ModInt(pw, self.mod)
def inverse(self):
return self.pow(self.mod - 2)
def __truediv__(self, other):
num = self * other.inverse()
return ModInt(num, self.mod)
h, w, a, b = map(int, input().split())
mod = 10 ** 9 + 7
power = [ModInt(1, mod)]
inv = [ModInt(1, mod).inverse()]
def comb(n, r):
return power[n] * inv[r] * inv[n-r]
for i in range(1, h + w - 1):
power.append(power[-1] * ModInt(i, mod))
inv.append(power[-1].inverse())
ans = ModInt(0, mod)
for wi in range(b, w):
ans += comb(h - a - 1 + wi, wi) * comb(a - 1 + w - wi - 1, a - 1)
print(ans)
|
[
7,
0,
13,
4,
13,
2,
17,
17,
12,
13,
14,
2,
13,
17,
4,
18,
13,
13,
4,
18,
13,
13,
17,
4,
18,
13,
13,
17,
29,
13,
0,
13,
4,
13,
13,
2,
13,
13,
13,
0,
13,
18,
13,
17,
0,
13,
2,
18,
13,
17,
2,
2,
13,
13,
18,
13,
17,
0,
18,
13,
17,
13,
0,
18,
13,
17,
13,
29,
13,
23,
13,
23,
13,
23,
13,
12,
13,
0,
13,
39,
4,
13,
13,
13,
13,
29,
2,
2,
18,
13,
17,
13,
13,
23,
13,
0,
13,
4,
13,
13,
4,
18,
4,
13,
13,
13,
13,
13,
41,
28,
13,
4,
13,
2,
13,
13,
4,
17,
0,
13,
13,
28,
13,
4,
13,
17,
4,
13,
13,
0,
18,
13,
13,
2,
2,
18,
13,
2,
13,
17,
13,
13,
41,
28,
13,
4,
13,
2,
13,
13,
4,
17,
0,
13,
13,
28,
13,
4,
13,
17,
4,
13,
13,
0,
18,
13,
13,
4,
13,
18,
13,
13,
12,
13,
29,
2,
2,
2,
18,
13,
13,
18,
13,
2,
13,
13,
18,
13,
13,
13,
23,
13,
23,
13,
0,
13,
4,
13,
2,
2,
13,
13,
17,
2,
13,
17,
28,
13,
4,
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,
13,
13,
0,
13,
2,
2,
2,
13,
13,
13,
13,
4,
13,
13,
10,
4,
13,
10,
2,
13,
10,
13,
13,
10,
4,
13,
10,
4,
13,
10,
12,
13,
10,
12,
13,
10,
4,
13,
10,
4,
13,
10,
12,
13,
10,
13,
13,
10,
4,
13,
10,
2,
13
] | [
[
256,
2
],
[
72,
12
],
[
74,
16
],
[
74,
20
],
[
74,
25
],
[
70,
29
],
[
32,
31
],
[
72,
34
],
[
70,
36
],
[
72,
37
],
[
74,
38
],
[
41,
40
],
[
74,
42
],
[
46,
45
],
[
74,
48
],
[
70,
52
],
[
72,
53
],
[
74,
55
],
[
61,
58
],
[
74,
59
],
[
40,
61
],
[
66,
63
],
[
74,
64
],
[
45,
66
],
[
31,
68
],
[
70,
70
],
[
72,
72
],
[
74,
74
],
[
79,
78
],
[
284,
81
],
[
94,
82
],
[
257,
83
],
[
78,
84
],
[
78,
89
],
[
257,
91
],
[
257,
92
],
[
94,
94
],
[
289,
96
],
[
289,
105
],
[
289,
106
],
[
289,
107
],
[
111,
110
],
[
278,
114
],
[
281,
115
],
[
262,
119
],
[
123,
122
],
[
263,
128
],
[
133,
130
],
[
263,
131
],
[
122,
132
],
[
263,
136
],
[
122,
138
],
[
122,
140
],
[
257,
141
],
[
145,
144
],
[
278,
148
],
[
281,
149
],
[
286,
153
],
[
157,
156
],
[
287,
162
],
[
167,
164
],
[
287,
165
],
[
156,
166
],
[
272,
168
],
[
130,
169
],
[
263,
170
],
[
156,
171
],
[
263,
179
],
[
191,
180
],
[
287,
182
],
[
191,
184
],
[
193,
185
],
[
287,
187
],
[
193,
188
],
[
257,
189
],
[
191,
191
],
[
193,
193
],
[
268,
195
],
[
275,
197
],
[
278,
200
],
[
281,
201
],
[
278,
204
],
[
208,
207
],
[
290,
212
],
[
259,
215
],
[
275,
219
],
[
278,
223
],
[
266,
224
],
[
207,
225
],
[
207,
228
],
[
275,
231
],
[
266,
235
],
[
281,
236
],
[
207,
237
],
[
281,
240
],
[
207,
241
],
[
257,
242
],
[
292,
244
],
[
269,
248
],
[
293,
248
],
[
260,
249
],
[
257,
250
],
[
257,
251
],
[
293,
254
],
[
269,
254
],
[
256,
257
],
[
259,
260
],
[
262,
263
],
[
289,
266
],
[
268,
269
],
[
289,
278
],
[
289,
281
],
[
286,
287
],
[
289,
290
],
[
292,
293
]
] | [
"mod = int(1e9+7)\n\n\ndef exgcd(a, b, arr):\n if b == 0:\n arr.clear()\n arr.append(1)\n arr.append(0)\n return a\n else:\n d = exgcd(b, a % b, arr)\n x = arr[1]\n y = arr[0] - a//b * arr[1]\n arr[0] = x\n arr[1] = y\n return d\n\n\ndef Inv(a):\n arr = []\n exgcd(a, mod, arr)\n return (arr[0] + mod) % mod\n\n\nH, W, A, B = map(int, input().split())\n\nfac = [1 for i in range(H + W)]\nfor i in range(1, len(fac)):\n fac[i] = fac[i-1] * i % mod\ninv = [1 for i in range(H+W)]\nfor i in range(0, len(inv)):\n inv[i] = Inv(fac[i])\n\n\ndef Cnm(n, m):\n return fac[n] * inv[n-m] * inv[m] % mod\n\n\nans = Cnm(H+W-2, H-1)\nfor i in range(1, B+1):\n tmp = Cnm(H-A+i-2, i-1) * Cnm(A+W-i-1, W-i) % mod\n ans = (ans - tmp + mod) % mod\nprint(ans)",
"mod = int(1e9+7)",
"mod",
"int(1e9+7)",
"int",
"1e9+7",
"1e9",
"7",
"def exgcd(a, b, arr):\n if b == 0:\n arr.clear()\n arr.append(1)\n arr.append(0)\n return a\n else:\n d = exgcd(b, a % b, arr)\n x = arr[1]\n y = arr[0] - a//b * arr[1]\n arr[0] = x\n arr[1] = y\n return d",
"exgcd",
"if b == 0:\n arr.clear()\n arr.append(1)\n arr.append(0)\n return a\n else:\n d = exgcd(b, a % b, arr)\n x = arr[1]\n y = arr[0] - a//b * arr[1]\n arr[0] = x\n arr[1] = y\n return d",
"b == 0",
"b",
"0",
"arr.clear()",
"arr.clear",
"arr",
"clear",
"arr.append(1)",
"arr.append",
"arr",
"append",
"1",
"arr.append(0)",
"arr.append",
"arr",
"append",
"0",
"return a",
"a",
"d = exgcd(b, a % b, arr)",
"d",
"exgcd(b, a % b, arr)",
"exgcd",
"b",
"a % b",
"a",
"b",
"arr",
"x = arr[1]",
"x",
"arr[1]",
"arr",
"1",
"y = arr[0] - a//b * arr[1]",
"y",
"arr[0] - a//b * arr[1]",
"arr[0]",
"arr",
"0",
"a//b * arr[1]",
"a//b",
"a",
"b",
"arr[1]",
"arr",
"1",
"arr[0] = x",
"arr[0]",
"arr",
"0",
"x",
"arr[1] = y",
"arr[1]",
"arr",
"1",
"y",
"return d",
"d",
"a",
"a",
"b",
"b",
"arr",
"arr",
"def Inv(a):\n arr = []\n exgcd(a, mod, arr)\n return (arr[0] + mod) % mod",
"Inv",
"arr = []",
"arr",
"[]",
"exgcd(a, mod, arr)",
"exgcd",
"a",
"mod",
"arr",
"return (arr[0] + mod) % mod",
"(arr[0] + mod) % mod",
"arr[0] + mod",
"arr[0]",
"arr",
"0",
"mod",
"mod",
"a",
"a",
"H, W, A, B = map(int, input().split())",
"H",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"W",
"A",
"B",
"1 for i in range(H + W)",
"for i in range(H + W)",
"i",
"range(H + W)",
"range",
"H + W",
"H",
"W",
"for i in range(H + W)",
"1",
"fac = [1 for i in range(H + W)]",
"fac",
"[1 for i in range(H + W)]",
"for i in range(1, len(fac)):\n fac[i] = fac[i-1] * i % mod",
"i",
"range(1, len(fac))",
"range",
"1",
"len(fac)",
"len",
"fac",
"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",
"1 for i in range(H+W)",
"for i in range(H+W)",
"i",
"range(H+W)",
"range",
"H+W",
"H",
"W",
"for i in range(H+W)",
"1",
"inv = [1 for i in range(H+W)]",
"inv",
"[1 for i in range(H+W)]",
"for i in range(0, len(inv)):\n inv[i] = Inv(fac[i])",
"i",
"range(0, len(inv))",
"range",
"0",
"len(inv)",
"len",
"inv",
"inv[i] = Inv(fac[i])",
"inv[i]",
"inv",
"i",
"Inv(fac[i])",
"Inv",
"fac[i]",
"fac",
"i",
"def Cnm(n, m):\n return fac[n] * inv[n-m] * inv[m] % mod",
"Cnm",
"return fac[n] * inv[n-m] * inv[m] % mod",
"fac[n] * inv[n-m] * inv[m] % mod",
"fac[n] * inv[n-m] * inv[m]",
"fac[n] * inv[n-m]",
"fac[n]",
"fac",
"n",
"inv[n-m]",
"inv",
"n-m",
"n",
"m",
"inv[m]",
"inv",
"m",
"mod",
"n",
"n",
"m",
"m",
"ans = Cnm(H+W-2, H-1)",
"ans",
"Cnm(H+W-2, H-1)",
"Cnm",
"H+W-2",
"H+W",
"H",
"W",
"2",
"H-1",
"H",
"1",
"for i in range(1, B+1):\n tmp = Cnm(H-A+i-2, i-1) * Cnm(A+W-i-1, W-i) % mod\n ans = (ans - tmp + mod) % mod",
"i",
"range(1, B+1)",
"range",
"1",
"B+1",
"B",
"1",
"tmp = Cnm(H-A+i-2, i-1) * Cnm(A+W-i-1, W-i) % mod",
"tmp",
"Cnm(H-A+i-2, i-1) * Cnm(A+W-i-1, W-i) % mod",
"Cnm(H-A+i-2, i-1) * Cnm(A+W-i-1, W-i)",
"Cnm(H-A+i-2, i-1)",
"Cnm",
"H-A+i-2",
"H-A+i",
"H-A",
"H",
"A",
"i",
"2",
"i-1",
"i",
"1",
"Cnm(A+W-i-1, W-i)",
"Cnm",
"A+W-i-1",
"A+W-i",
"A+W",
"A",
"W",
"i",
"1",
"W-i",
"W",
"i",
"mod",
"ans = (ans - tmp + mod) % mod",
"ans",
"(ans - tmp + mod) % mod",
"ans - tmp + mod",
"ans - tmp",
"ans",
"tmp",
"mod",
"mod",
"print(ans)",
"print",
"ans",
"mod = int(1e9+7)",
"int(1e9+7)",
"mod",
"tmp = Cnm(H-A+i-2, i-1) * Cnm(A+W-i-1, W-i) % mod",
"Cnm(H-A+i-2, i-1) * Cnm(A+W-i-1, W-i) % mod",
"tmp",
"fac = [1 for i in range(H + W)]",
"[1 for i in range(H + W)]",
"fac",
"A, B = map(int, input().split())",
"map(int, input().split())",
"A",
"ans = Cnm(H+W-2, H-1)",
"Cnm(H+W-2, H-1)",
"ans",
"def Inv(a):\n arr = []\n exgcd(a, mod, arr)\n return (arr[0] + mod) % mod",
"def Inv(a):\n arr = []\n exgcd(a, mod, arr)\n return (arr[0] + mod) % mod",
"Inv",
"def Cnm(n, m):\n return fac[n] * inv[n-m] * inv[m] % mod",
"def Cnm(n, m):\n return fac[n] * inv[n-m] * inv[m] % mod",
"Cnm",
"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 exgcd(a, b, arr):\n if b == 0:\n arr.clear()\n arr.append(1)\n arr.append(0)\n return a\n else:\n d = exgcd(b, a % b, arr)\n x = arr[1]\n y = arr[0] - a//b * arr[1]\n arr[0] = x\n arr[1] = y\n return d",
"def exgcd(a, b, arr):\n if b == 0:\n arr.clear()\n arr.append(1)\n arr.append(0)\n return a\n else:\n d = exgcd(b, a % b, arr)\n x = arr[1]\n y = arr[0] - a//b * arr[1]\n arr[0] = x\n arr[1] = y\n return d",
"exgcd",
"inv = [1 for i in range(H+W)]",
"[1 for i in range(H+W)]",
"inv",
"B = map(int, input().split())",
"map(int, input().split())",
"B",
"ans = (ans - tmp + mod) % mod",
"(ans - tmp + mod) % mod",
"ans"
] | mod = int(1e9+7)
def exgcd(a, b, arr):
if b == 0:
arr.clear()
arr.append(1)
arr.append(0)
return a
else:
d = exgcd(b, a % b, arr)
x = arr[1]
y = arr[0] - a//b * arr[1]
arr[0] = x
arr[1] = y
return d
def Inv(a):
arr = []
exgcd(a, mod, arr)
return (arr[0] + mod) % mod
H, W, A, B = map(int, input().split())
fac = [1 for i in range(H + W)]
for i in range(1, len(fac)):
fac[i] = fac[i-1] * i % mod
inv = [1 for i in range(H+W)]
for i in range(0, len(inv)):
inv[i] = Inv(fac[i])
def Cnm(n, m):
return fac[n] * inv[n-m] * inv[m] % mod
ans = Cnm(H+W-2, H-1)
for i in range(1, B+1):
tmp = Cnm(H-A+i-2, i-1) * Cnm(A+W-i-1, W-i) % mod
ans = (ans - tmp + mod) % mod
print(ans)
|
[
7,
15,
13,
4,
18,
13,
13,
2,
17,
17,
0,
13,
4,
13,
17,
0,
13,
17,
6,
13,
12,
13,
0,
13,
2,
39,
17,
2,
13,
17,
13,
2,
39,
17,
2,
13,
17,
13,
2,
39,
17,
2,
13,
17,
0,
18,
13,
39,
17,
39,
17,
17,
0,
18,
13,
39,
17,
39,
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,
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,
0,
18,
13,
13,
13,
0,
18,
13,
13,
13,
0,
18,
13,
13,
13,
0,
18,
13,
13,
13,
0,
18,
13,
13,
13,
23,
13,
23,
13,
23,
13,
13,
12,
13,
14,
2,
13,
13,
29,
17,
14,
2,
2,
13,
17,
2,
13,
17,
29,
17,
0,
13,
18,
13,
13,
0,
13,
18,
13,
13,
0,
13,
18,
13,
13,
29,
2,
2,
18,
13,
13,
2,
2,
18,
13,
13,
18,
13,
2,
13,
13,
13,
13,
23,
13,
23,
13,
23,
13,
13,
12,
13,
0,
13,
4,
13,
2,
2,
13,
13,
17,
13,
0,
13,
17,
28,
13,
4,
13,
13,
13,
0,
13,
4,
13,
2,
2,
2,
13,
13,
17,
13,
13,
0,
13,
4,
13,
2,
2,
2,
13,
13,
13,
17,
2,
2,
13,
13,
17,
0,
13,
13,
0,
13,
13,
0,
13,
13,
4,
13,
13,
29,
23,
13,
23,
13,
23,
13,
23,
13,
12,
13,
12,
13,
28,
13,
18,
13,
13,
28,
13,
4,
18,
13,
13,
27,
13,
0,
13,
4,
13,
0,
13,
4,
13,
4,
13,
13,
0,
13,
4,
13,
4,
13,
13,
0,
13,
4,
13,
4,
13,
13,
0,
13,
4,
13,
4,
13,
13,
4,
13,
13,
13,
13,
13,
14,
2,
13,
17,
4,
13,
10,
6,
13,
10,
17,
13,
10,
4,
13,
10,
12,
13,
10,
12,
13
] | [
[
345,
11
],
[
342,
16
],
[
24,
23
],
[
145,
28
],
[
31,
30
],
[
145,
35
],
[
38,
37
],
[
145,
42
],
[
49,
45
],
[
23,
46
],
[
57,
53
],
[
30,
54
],
[
64,
61
],
[
37,
62
],
[
67,
66
],
[
145,
71
],
[
77,
74
],
[
23,
75
],
[
66,
76
],
[
23,
80
],
[
66,
82
],
[
66,
84
],
[
147,
85
],
[
90,
87
],
[
37,
88
],
[
66,
89
],
[
37,
94
],
[
147,
96
],
[
66,
97
],
[
147,
99
],
[
66,
100
],
[
147,
101
],
[
106,
103
],
[
30,
104
],
[
66,
105
],
[
30,
109
],
[
66,
111
],
[
87,
113
],
[
37,
114
],
[
66,
115
],
[
147,
116
],
[
121,
118
],
[
143,
119
],
[
145,
120
],
[
145,
121
],
[
126,
123
],
[
143,
124
],
[
343,
125
],
[
147,
126
],
[
131,
128
],
[
143,
129
],
[
23,
130
],
[
23,
131
],
[
136,
133
],
[
143,
134
],
[
30,
135
],
[
30,
136
],
[
141,
138
],
[
143,
139
],
[
37,
140
],
[
37,
141
],
[
143,
143
],
[
145,
145
],
[
148,
147
],
[
203,
153
],
[
205,
154
],
[
203,
160
],
[
205,
163
],
[
169,
168
],
[
201,
170
],
[
174,
173
],
[
201,
175
],
[
179,
178
],
[
201,
180
],
[
343,
181
],
[
168,
186
],
[
203,
187
],
[
173,
191
],
[
205,
192
],
[
173,
194
],
[
203,
196
],
[
205,
197
],
[
178,
198
],
[
178,
199
],
[
201,
201
],
[
203,
203
],
[
205,
205
],
[
211,
210
],
[
270,
215
],
[
272,
216
],
[
343,
218
],
[
221,
220
],
[
224,
223
],
[
276,
226
],
[
272,
227
],
[
230,
229
],
[
210,
231
],
[
270,
235
],
[
274,
236
],
[
223,
238
],
[
223,
239
],
[
242,
241
],
[
210,
243
],
[
274,
247
],
[
272,
248
],
[
223,
249
],
[
272,
253
],
[
223,
254
],
[
258,
257
],
[
343,
258
],
[
261,
260
],
[
257,
261
],
[
241,
261
],
[
229,
261
],
[
264,
263
],
[
343,
264
],
[
263,
267
],
[
260,
267
],
[
220,
267
],
[
270,
270
],
[
272,
272
],
[
274,
274
],
[
276,
276
],
[
283,
282
],
[
288,
287
],
[
282,
290
],
[
287,
293
],
[
296,
295
],
[
280,
297
],
[
300,
299
],
[
295,
304
],
[
307,
306
],
[
295,
311
],
[
314,
313
],
[
295,
318
],
[
321,
320
],
[
295,
325
],
[
349,
327
],
[
299,
328
],
[
306,
329
],
[
313,
330
],
[
320,
331
],
[
352,
337
],
[
342,
343
],
[
345,
346
]
] | [
"#!/usr/bin/env python3\nimport sys\nsys.setrecursionlimit(10**8)\nINF = float(\"inf\")\n\nMOD = 1000000007 # type: int\n\n\nclass Combination(object):\n\n def __init__(self, N, mod=MOD):\n fac, finv, inv = [0]*(N+1), [0]*(N+1), [0]*(N+1)\n fac[:2] = 1, 1\n finv[:2] = 1, 1\n inv[1] = 1\n for i in range(2, N+1):\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 self.N = N\n self.MOD = mod\n self.fac = fac\n self.finv = finv\n self.inv = inv\n\n def __call__(self, n, k):\n if n < k:\n return 0\n if n < 0 or k < 0:\n return 0\n fac = self.fac\n finv = self.finv\n mod = self.MOD\n return fac[n] * (finv[k]*finv[n-k] % mod) % mod\n\n\ndef solve(H: int, W: int, A: int, B: int):\n\n cmb = Combination(H+W+1, MOD)\n\n ans = 0\n for i in range(B, W):\n buf = cmb(H-A-1+i, i)\n buf *= cmb(A+W-i-2, W-i-1)\n buf %= MOD\n ans += buf\n ans %= MOD\n print(ans)\n\n return\n\n\ndef main():\n\n def iterate_tokens():\n for line in sys.stdin:\n for word in line.split():\n yield word\n tokens = iterate_tokens()\n H = int(next(tokens)) # type: int\n W = int(next(tokens)) # type: int\n A = int(next(tokens)) # type: int\n B = int(next(tokens)) # type: int\n solve(H, W, A, B)\n\n\nif __name__ == '__main__':\n main()",
"import sys",
"sys",
"sys.setrecursionlimit(10**8)",
"sys.setrecursionlimit",
"sys",
"setrecursionlimit",
"10**8",
"10",
"8",
"INF = float(\"inf\")",
"INF",
"float(\"inf\")",
"float",
"\"inf\"",
"MOD = 1000000007",
"MOD",
"1000000007",
"class Combination(object):\n\n def __init__(self, N, mod=MOD):\n fac, finv, inv = [0]*(N+1), [0]*(N+1), [0]*(N+1)\n fac[:2] = 1, 1\n finv[:2] = 1, 1\n inv[1] = 1\n for i in range(2, N+1):\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 self.N = N\n self.MOD = mod\n self.fac = fac\n self.finv = finv\n self.inv = inv\n\n def __call__(self, n, k):\n if n < k:\n return 0\n if n < 0 or k < 0:\n return 0\n fac = self.fac\n finv = self.finv\n mod = self.MOD\n return fac[n] * (finv[k]*finv[n-k] % mod) % mod",
"Combination",
"def __init__(self, N, mod=MOD):\n fac, finv, inv = [0]*(N+1), [0]*(N+1), [0]*(N+1)\n fac[:2] = 1, 1\n finv[:2] = 1, 1\n inv[1] = 1\n for i in range(2, N+1):\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 self.N = N\n self.MOD = mod\n self.fac = fac\n self.finv = finv\n self.inv = inv\n\n ",
"__init__",
"fac, finv, inv = [0]*(N+1), [0]*(N+1), [0]*(N+1)",
"fac",
"[0]*(N+1)",
"[0]",
"0",
"N+1",
"N",
"1",
"finv",
"[0]*(N+1)",
"[0]",
"0",
"N+1",
"N",
"1",
"inv",
"[0]*(N+1)",
"[0]",
"0",
"N+1",
"N",
"1",
"fac[:2] = 1, 1",
"fac[:2]",
"fac",
":2",
"2",
"fac[:2] = 1, 1",
"1",
"1",
"finv[:2] = 1, 1",
"finv[:2]",
"finv",
":2",
"2",
"finv[:2] = 1, 1",
"1",
"1",
"inv[1] = 1",
"inv[1]",
"inv",
"1",
"1",
"for i in range(2, N+1):\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 ",
"i",
"range(2, N+1)",
"range",
"2",
"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[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",
"self.N = N",
"self.N",
"self",
"N",
"N",
"self.MOD = mod",
"self.MOD",
"self",
"MOD",
"mod",
"self.fac = fac",
"self.fac",
"self",
"fac",
"fac",
"self.finv = finv",
"self.finv",
"self",
"finv",
"finv",
"self.inv = inv",
"self.inv",
"self",
"inv",
"inv",
"self",
"self",
"N",
"N",
"mod=MOD",
"mod",
"MOD",
"def __call__(self, n, k):\n if n < k:\n return 0\n if n < 0 or k < 0:\n return 0\n fac = self.fac\n finv = self.finv\n mod = self.MOD\n return fac[n] * (finv[k]*finv[n-k] % mod) % mod",
"__call__",
"if n < k:\n return 0\n ",
"n < k",
"n",
"k",
"return 0",
"0",
"if n < 0 or k < 0:\n return 0\n ",
"n < 0 or k < 0",
"n < 0",
"n",
"0",
"k < 0",
"k",
"0",
"return 0",
"0",
"fac = self.fac",
"fac",
"self.fac",
"self",
"fac",
"finv = self.finv",
"finv",
"self.finv",
"self",
"finv",
"mod = self.MOD",
"mod",
"self.MOD",
"self",
"MOD",
"return fac[n] * (finv[k]*finv[n-k] % mod) % mod",
"fac[n] * (finv[k]*finv[n-k] % mod) % mod",
"fac[n] * (finv[k]*finv[n-k] % mod)",
"fac[n]",
"fac",
"n",
"finv[k]*finv[n-k] % mod",
"finv[k]*finv[n-k]",
"finv[k]",
"finv",
"k",
"finv[n-k]",
"finv",
"n-k",
"n",
"k",
"mod",
"mod",
"self",
"self",
"n",
"n",
"k",
"k",
"object",
"def solve(H: int, W: int, A: int, B: int):\n\n cmb = Combination(H+W+1, MOD)\n\n ans = 0\n for i in range(B, W):\n buf = cmb(H-A-1+i, i)\n buf *= cmb(A+W-i-2, W-i-1)\n buf %= MOD\n ans += buf\n ans %= MOD\n print(ans)\n\n return",
"solve",
"cmb = Combination(H+W+1, MOD)",
"cmb",
"Combination(H+W+1, MOD)",
"Combination",
"H+W+1",
"H+W",
"H",
"W",
"1",
"MOD",
"ans = 0",
"ans",
"0",
"for i in range(B, W):\n buf = cmb(H-A-1+i, i)\n buf *= cmb(A+W-i-2, W-i-1)\n buf %= MOD\n ans += buf\n ans %= MOD\n ",
"i",
"range(B, W)",
"range",
"B",
"W",
"buf = cmb(H-A-1+i, i)",
"buf",
"cmb(H-A-1+i, i)",
"cmb",
"H-A-1+i",
"H-A-1",
"H-A",
"H",
"A",
"1",
"i",
"i",
"buf *= cmb(A+W-i-2, W-i-1)",
"buf",
"cmb(A+W-i-2, W-i-1)",
"cmb",
"A+W-i-2",
"A+W-i",
"A+W",
"A",
"W",
"i",
"2",
"W-i-1",
"W-i",
"W",
"i",
"1",
"buf %= MOD",
"buf",
"MOD",
"ans += buf",
"ans",
"buf",
"ans %= MOD",
"ans",
"MOD",
"print(ans)",
"print",
"ans",
"return",
"H: int",
"H",
"W: int",
"W",
"A: int",
"A",
"B: int",
"B",
"def main():\n\n def iterate_tokens():\n for line in sys.stdin:\n for word in line.split():\n yield word\n tokens = iterate_tokens()\n H = int(next(tokens)) # type: int\n W = int(next(tokens)) # type: int\n A = int(next(tokens)) # type: int\n B = int(next(tokens)) # type: int\n solve(H, W, A, B)",
"main",
"def iterate_tokens():\n for line in sys.stdin:\n for word in line.split():\n yield word\n ",
"iterate_tokens",
"for line in sys.stdin:\n for word in line.split():\n yield word\n ",
"line",
"sys.stdin",
"sys",
"stdin",
"for word in line.split():\n yield word\n ",
"word",
"line.split()",
"line.split",
"line",
"split",
"yield word",
"word",
"tokens = iterate_tokens()",
"tokens",
"iterate_tokens()",
"iterate_tokens",
"H = int(next(tokens))",
"H",
"int(next(tokens))",
"int",
"next(tokens)",
"next",
"tokens",
"W = int(next(tokens))",
"W",
"int(next(tokens))",
"int",
"next(tokens)",
"next",
"tokens",
"A = int(next(tokens))",
"A",
"int(next(tokens))",
"int",
"next(tokens)",
"next",
"tokens",
"B = int(next(tokens))",
"B",
"int(next(tokens))",
"int",
"next(tokens)",
"next",
"tokens",
"solve(H, W, A, B)",
"solve",
"H",
"W",
"A",
"B",
"if __name__ == '__main__':\n main()",
"__name__ == '__main__'",
"__name__",
"'__main__'",
"main()",
"main",
"class Combination(object):\n\n def __init__(self, N, mod=MOD):\n fac, finv, inv = [0]*(N+1), [0]*(N+1), [0]*(N+1)\n fac[:2] = 1, 1\n finv[:2] = 1, 1\n inv[1] = 1\n for i in range(2, N+1):\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 self.N = N\n self.MOD = mod\n self.fac = fac\n self.finv = finv\n self.inv = inv\n\n def __call__(self, n, k):\n if n < k:\n return 0\n if n < 0 or k < 0:\n return 0\n fac = self.fac\n finv = self.finv\n mod = self.MOD\n return fac[n] * (finv[k]*finv[n-k] % mod) % mod",
"class Combination(object):\n\n def __init__(self, N, mod=MOD):\n fac, finv, inv = [0]*(N+1), [0]*(N+1), [0]*(N+1)\n fac[:2] = 1, 1\n finv[:2] = 1, 1\n inv[1] = 1\n for i in range(2, N+1):\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 self.N = N\n self.MOD = mod\n self.fac = fac\n self.finv = finv\n self.inv = inv\n\n def __call__(self, n, k):\n if n < k:\n return 0\n if n < 0 or k < 0:\n return 0\n fac = self.fac\n finv = self.finv\n mod = self.MOD\n return fac[n] * (finv[k]*finv[n-k] % mod) % mod",
"Combination",
"MOD = 1000000007",
"1000000007",
"MOD",
"INF = float(\"inf\")",
"float(\"inf\")",
"INF",
"def solve(H: int, W: int, A: int, B: int):\n\n cmb = Combination(H+W+1, MOD)\n\n ans = 0\n for i in range(B, W):\n buf = cmb(H-A-1+i, i)\n buf *= cmb(A+W-i-2, W-i-1)\n buf %= MOD\n ans += buf\n ans %= MOD\n print(ans)\n\n return",
"def solve(H: int, W: int, A: int, B: int):\n\n cmb = Combination(H+W+1, MOD)\n\n ans = 0\n for i in range(B, W):\n buf = cmb(H-A-1+i, i)\n buf *= cmb(A+W-i-2, W-i-1)\n buf %= MOD\n ans += buf\n ans %= MOD\n print(ans)\n\n return",
"solve",
"def main():\n\n def iterate_tokens():\n for line in sys.stdin:\n for word in line.split():\n yield word\n tokens = iterate_tokens()\n H = int(next(tokens)) # type: int\n W = int(next(tokens)) # type: int\n A = int(next(tokens)) # type: int\n B = int(next(tokens)) # type: int\n solve(H, W, A, B)",
"def main():\n\n def iterate_tokens():\n for line in sys.stdin:\n for word in line.split():\n yield word\n tokens = iterate_tokens()\n H = int(next(tokens)) # type: int\n W = int(next(tokens)) # type: int\n A = int(next(tokens)) # type: int\n B = int(next(tokens)) # type: int\n solve(H, W, A, B)",
"main"
] | #!/usr/bin/env python3
import sys
sys.setrecursionlimit(10**8)
INF = float("inf")
MOD = 1000000007 # type: int
class Combination(object):
def __init__(self, N, mod=MOD):
fac, finv, inv = [0]*(N+1), [0]*(N+1), [0]*(N+1)
fac[:2] = 1, 1
finv[:2] = 1, 1
inv[1] = 1
for i in range(2, N+1):
fac[i] = fac[i-1]*i % mod
inv[i] = -inv[mod % i]*(mod//i) % mod
finv[i] = finv[i-1]*inv[i] % mod
self.N = N
self.MOD = mod
self.fac = fac
self.finv = finv
self.inv = inv
def __call__(self, n, k):
if n < k:
return 0
if n < 0 or k < 0:
return 0
fac = self.fac
finv = self.finv
mod = self.MOD
return fac[n] * (finv[k]*finv[n-k] % mod) % mod
def solve(H: int, W: int, A: int, B: int):
cmb = Combination(H+W+1, MOD)
ans = 0
for i in range(B, W):
buf = cmb(H-A-1+i, i)
buf *= cmb(A+W-i-2, W-i-1)
buf %= MOD
ans += buf
ans %= MOD
print(ans)
return
def main():
def iterate_tokens():
for line in sys.stdin:
for word in line.split():
yield word
tokens = iterate_tokens()
H = int(next(tokens)) # type: int
W = int(next(tokens)) # type: int
A = int(next(tokens)) # type: int
B = int(next(tokens)) # type: int
solve(H, W, A, B)
if __name__ == '__main__':
main()
|
[
7,
6,
13,
12,
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,
4,
18,
13,
13,
13,
23,
13,
23,
13,
23,
13,
2,
2,
17,
17,
17,
12,
13,
28,
13,
4,
13,
17,
2,
13,
17,
4,
18,
18,
13,
13,
13,
2,
2,
18,
18,
13,
13,
17,
13,
18,
13,
13,
4,
18,
18,
13,
13,
13,
2,
2,
40,
18,
18,
13,
13,
2,
18,
13,
13,
13,
2,
18,
13,
13,
13,
18,
13,
13,
4,
18,
18,
13,
13,
13,
2,
2,
18,
18,
13,
13,
17,
18,
18,
13,
13,
17,
18,
13,
13,
23,
13,
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,
14,
2,
2,
13,
17,
2,
13,
13,
29,
17,
0,
13,
17,
0,
13,
4,
13,
13,
2,
13,
13,
28,
13,
4,
13,
2,
2,
13,
13,
17,
2,
13,
17,
0,
13,
13,
0,
13,
18,
13,
13,
29,
2,
2,
13,
18,
18,
13,
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,
4,
13,
2,
2,
13,
13,
17,
0,
13,
17,
28,
13,
4,
13,
2,
13,
13,
0,
13,
4,
18,
13,
13,
2,
2,
13,
13,
17,
13,
0,
13,
2,
2,
13,
13,
17,
0,
13,
2,
2,
13,
13,
17,
0,
13,
4,
18,
13,
13,
2,
13,
13,
13,
0,
13,
2,
2,
13,
13,
17,
0,
13,
17,
4,
13,
13,
14,
2,
13,
17,
4,
13,
10,
12,
13,
10,
6,
13
] | [
[
9,
6
],
[
37,
7
],
[
41,
8
],
[
41,
9
],
[
14,
11
],
[
37,
12
],
[
21,
18
],
[
37,
19
],
[
28,
25
],
[
37,
26
],
[
37,
33
],
[
39,
35
],
[
37,
37
],
[
39,
39
],
[
42,
41
],
[
51,
50
],
[
124,
55
],
[
122,
60
],
[
122,
67
],
[
50,
70
],
[
122,
72
],
[
122,
77
],
[
122,
85
],
[
122,
89
],
[
50,
91
],
[
122,
94
],
[
50,
96
],
[
122,
98
],
[
122,
103
],
[
122,
110
],
[
122,
115
],
[
122,
119
],
[
122,
122
],
[
124,
124
],
[
174,
130
],
[
174,
133
],
[
172,
134
],
[
139,
138
],
[
174,
141
],
[
172,
143
],
[
174,
144
],
[
170,
151
],
[
172,
153
],
[
170,
156
],
[
138,
158
],
[
174,
158
],
[
170,
161
],
[
172,
164
],
[
138,
165
],
[
174,
165
],
[
170,
167
],
[
170,
170
],
[
172,
172
],
[
174,
174
],
[
235,
180
],
[
235,
183
],
[
233,
184
],
[
189,
188
],
[
192,
191
],
[
235,
194
],
[
233,
196
],
[
235,
197
],
[
200,
199
],
[
233,
204
],
[
191,
205
],
[
235,
205
],
[
233,
208
],
[
212,
211
],
[
199,
212
],
[
215,
214
],
[
231,
216
],
[
214,
221
],
[
211,
221
],
[
188,
221
],
[
231,
224
],
[
191,
226
],
[
235,
226
],
[
231,
228
],
[
231,
231
],
[
233,
233
],
[
235,
235
],
[
240,
239
],
[
240,
248
],
[
240,
249
],
[
240,
250
],
[
253,
252
],
[
239,
257
],
[
248,
258
],
[
262,
261
],
[
265,
264
],
[
239,
268
],
[
249,
269
],
[
272,
271
],
[
252,
274
],
[
126,
274
],
[
252,
275
],
[
126,
275
],
[
250,
278
],
[
264,
279
],
[
264,
281
],
[
284,
283
],
[
248,
286
],
[
250,
287
],
[
291,
290
],
[
239,
293
],
[
264,
294
],
[
298,
297
],
[
252,
300
],
[
126,
300
],
[
252,
301
],
[
126,
301
],
[
283,
303
],
[
290,
304
],
[
290,
305
],
[
308,
307
],
[
297,
310
],
[
271,
311
],
[
315,
314
],
[
314,
318
],
[
307,
318
],
[
261,
318
],
[
327,
324
]
] | [
"\n\nclass Cmber:\n def __init__(self,gensize,mod=10**9+7):\n self.mod = mod\n self.g1=[1,1]\n self.g2 = [1, 1] #逆元テーブル\n self.inverse = [0, 1] #逆元テーブル計算用テーブル\n self.getgen(gensize)\n def getgen(self,N):\n for i in range( 2, N + 1 ):\n self.g1.append( ( self.g1[-1] * i ) % self.mod )\n self.inverse.append( ( -self.inverse[self.mod % i] * (self.mod//i) ) % self.mod )\n self.g2.append( (self.g2[-1] * self.inverse[-1]) % self.mod )\n\n def cmb(self,n, r):\n if ( r<0 or r>n ):\n return 0\n r = min(r, n-r)\n return self.g1[n] * self.g2[r] * self.g2[n-r] % self.mod\n\n def cmb_very_high_n(self,n, r):\n if ( r<0 or r>n ):\n return 0\n g1=1\n r = min(r, n-r)\n for i in range(n-r+1,n+1):\n g1*=i\n g1%=self.mod\n return g1 * self.g2[r] % self.mod\n\n\ndef resolve():\n H,W,A,B= map(int,input().split())\n cmb= Cmber(H+W+1)\n sm =0\n for i in range(H-A):\n bef = cmb.cmb(B+i-1,i)\n r=W-B-1\n u=H-i-1\n aft = cmb.cmb(r+u,u)\n sm += (aft*bef) % 1000000007\n sm %= 1000000007\n# print(i,r,u,bef,aft)\n print(sm)\n\nif __name__ == \"__main__\":\n resolve()",
"class Cmber:\n def __init__(self,gensize,mod=10**9+7):\n self.mod = mod\n self.g1=[1,1]\n self.g2 = [1, 1] #逆元テーブル\n self.inverse = [0, 1] #逆元テーブル計算用テーブル\n self.getgen(gensize)\n def getgen(self,N):\n for i in range( 2, N + 1 ):\n self.g1.append( ( self.g1[-1] * i ) % self.mod )\n self.inverse.append( ( -self.inverse[self.mod % i] * (self.mod//i) ) % self.mod )\n self.g2.append( (self.g2[-1] * self.inverse[-1]) % self.mod )\n\n def cmb(self,n, r):\n if ( r<0 or r>n ):\n return 0\n r = min(r, n-r)\n return self.g1[n] * self.g2[r] * self.g2[n-r] % self.mod\n\n def cmb_very_high_n(self,n, r):\n if ( r<0 or r>n ):\n return 0\n g1=1\n r = min(r, n-r)\n for i in range(n-r+1,n+1):\n g1*=i\n g1%=self.mod\n return g1 * self.g2[r] % self.mod",
"Cmber",
"def __init__(self,gensize,mod=10**9+7):\n self.mod = mod\n self.g1=[1,1]\n self.g2 = [1, 1] #逆元テーブル\n self.inverse = [0, 1] #逆元テーブル計算用テーブル\n self.getgen(gensize)\n ",
"__init__",
"self.mod = mod",
"self.mod",
"self",
"mod",
"mod",
"self.g1=[1,1]",
"self.g1",
"self",
"g1",
"[1,1]",
"1",
"1",
"self.g2 = [1, 1]",
"self.g2",
"self",
"g2",
"[1, 1]",
"1",
"1",
"self.inverse = [0, 1]",
"self.inverse",
"self",
"inverse",
"[0, 1]",
"0",
"1",
"self.getgen(gensize)",
"self.getgen",
"self",
"getgen",
"gensize",
"self",
"self",
"gensize",
"gensize",
"mod=10**9+7",
"mod",
"10**9+7",
"10**9",
"10",
"9",
"7",
"def getgen(self,N):\n for i in range( 2, N + 1 ):\n self.g1.append( ( self.g1[-1] * i ) % self.mod )\n self.inverse.append( ( -self.inverse[self.mod % i] * (self.mod//i) ) % self.mod )\n self.g2.append( (self.g2[-1] * self.inverse[-1]) % self.mod )\n\n ",
"getgen",
"for i in range( 2, N + 1 ):\n self.g1.append( ( self.g1[-1] * i ) % self.mod )\n self.inverse.append( ( -self.inverse[self.mod % i] * (self.mod//i) ) % self.mod )\n self.g2.append( (self.g2[-1] * self.inverse[-1]) % self.mod )\n\n ",
"i",
"range( 2, N + 1 )",
"range",
"2",
"N + 1",
"N",
"1",
"self.g1.append( ( self.g1[-1] * i ) % self.mod )",
"self.g1.append",
"self.g1",
"self",
"g1",
"append",
"( self.g1[-1] * i ) % self.mod",
"self.g1[-1] * i",
"self.g1[-1]",
"self.g1",
"self",
"g1",
"-1",
"i",
"self.mod",
"self",
"mod",
"self.inverse.append( ( -self.inverse[self.mod % i] * (self.mod//i) ) % self.mod )",
"self.inverse.append",
"self.inverse",
"self",
"inverse",
"append",
"( -self.inverse[self.mod % i] * (self.mod//i) ) % self.mod",
"-self.inverse[self.mod % i] * (self.mod//i)",
"-self.inverse[self.mod % i]",
"self.inverse[self.mod % i]",
"self.inverse",
"self",
"inverse",
"self.mod % i",
"self.mod",
"self",
"mod",
"i",
"self.mod//i",
"self.mod",
"self",
"mod",
"i",
"self.mod",
"self",
"mod",
"self.g2.append( (self.g2[-1] * self.inverse[-1]) % self.mod )",
"self.g2.append",
"self.g2",
"self",
"g2",
"append",
"(self.g2[-1] * self.inverse[-1]) % self.mod",
"self.g2[-1] * self.inverse[-1]",
"self.g2[-1]",
"self.g2",
"self",
"g2",
"-1",
"self.inverse[-1]",
"self.inverse",
"self",
"inverse",
"-1",
"self.mod",
"self",
"mod",
"self",
"self",
"N",
"N",
"def cmb(self,n, r):\n if ( r<0 or r>n ):\n return 0\n r = min(r, n-r)\n return self.g1[n] * self.g2[r] * self.g2[n-r] % self.mod\n\n ",
"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 self.g1[n] * self.g2[r] * self.g2[n-r] % self.mod",
"self.g1[n] * self.g2[r] * self.g2[n-r] % self.mod",
"self.g1[n] * self.g2[r] * self.g2[n-r]",
"self.g1[n] * self.g2[r]",
"self.g1[n]",
"self.g1",
"self",
"g1",
"n",
"self.g2[r]",
"self.g2",
"self",
"g2",
"r",
"self.g2[n-r]",
"self.g2",
"self",
"g2",
"n-r",
"n",
"r",
"self.mod",
"self",
"mod",
"self",
"self",
"n",
"n",
"r",
"r",
"def cmb_very_high_n(self,n, r):\n if ( r<0 or r>n ):\n return 0\n g1=1\n r = min(r, n-r)\n for i in range(n-r+1,n+1):\n g1*=i\n g1%=self.mod\n return g1 * self.g2[r] % self.mod",
"cmb_very_high_n",
"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",
"g1=1",
"g1",
"1",
"r = min(r, n-r)",
"r",
"min(r, n-r)",
"min",
"r",
"n-r",
"n",
"r",
"for i in range(n-r+1,n+1):\n g1*=i\n g1%=self.mod\n ",
"i",
"range(n-r+1,n+1)",
"range",
"n-r+1",
"n-r",
"n",
"r",
"1",
"n+1",
"n",
"1",
"g1*=i",
"g1",
"i",
"g1%=self.mod",
"g1",
"self.mod",
"self",
"mod",
"return g1 * self.g2[r] % self.mod",
"g1 * self.g2[r] % self.mod",
"g1 * self.g2[r]",
"g1",
"self.g2[r]",
"self.g2",
"self",
"g2",
"r",
"self.mod",
"self",
"mod",
"self",
"self",
"n",
"n",
"r",
"r",
"def resolve():\n H,W,A,B= map(int,input().split())\n cmb= Cmber(H+W+1)\n sm =0\n for i in range(H-A):\n bef = cmb.cmb(B+i-1,i)\n r=W-B-1\n u=H-i-1\n aft = cmb.cmb(r+u,u)\n sm += (aft*bef) % 1000000007\n sm %= 1000000007\n# print(i,r,u,bef,aft)\n print(sm)",
"resolve",
"H,W,A,B= map(int,input().split())",
"H",
"map(int,input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"W",
"A",
"B",
"cmb= Cmber(H+W+1)",
"cmb",
"Cmber(H+W+1)",
"Cmber",
"H+W+1",
"H+W",
"H",
"W",
"1",
"sm =0",
"sm",
"0",
"for i in range(H-A):\n bef = cmb.cmb(B+i-1,i)\n r=W-B-1\n u=H-i-1\n aft = cmb.cmb(r+u,u)\n sm += (aft*bef) % 1000000007\n sm %= 1000000007\n# print(i,r,u,bef,aft)\n ",
"i",
"range(H-A)",
"range",
"H-A",
"H",
"A",
"bef = cmb.cmb(B+i-1,i)",
"bef",
"cmb.cmb(B+i-1,i)",
"cmb.cmb",
"cmb",
"cmb",
"B+i-1",
"B+i",
"B",
"i",
"1",
"i",
"r=W-B-1",
"r",
"W-B-1",
"W-B",
"W",
"B",
"1",
"u=H-i-1",
"u",
"H-i-1",
"H-i",
"H",
"i",
"1",
"aft = cmb.cmb(r+u,u)",
"aft",
"cmb.cmb(r+u,u)",
"cmb.cmb",
"cmb",
"cmb",
"r+u",
"r",
"u",
"u",
"sm += (aft*bef) % 1000000007",
"sm",
"(aft*bef) % 1000000007",
"aft*bef",
"aft",
"bef",
"1000000007",
"sm %= 1000000007",
"sm",
"1000000007",
"print(sm)",
"print",
"sm",
"if __name__ == \"__main__\":\n resolve()",
"__name__ == \"__main__\"",
"__name__",
"\"__main__\"",
"resolve()",
"resolve",
"def resolve():\n H,W,A,B= map(int,input().split())\n cmb= Cmber(H+W+1)\n sm =0\n for i in range(H-A):\n bef = cmb.cmb(B+i-1,i)\n r=W-B-1\n u=H-i-1\n aft = cmb.cmb(r+u,u)\n sm += (aft*bef) % 1000000007\n sm %= 1000000007\n# print(i,r,u,bef,aft)\n print(sm)",
"def resolve():\n H,W,A,B= map(int,input().split())\n cmb= Cmber(H+W+1)\n sm =0\n for i in range(H-A):\n bef = cmb.cmb(B+i-1,i)\n r=W-B-1\n u=H-i-1\n aft = cmb.cmb(r+u,u)\n sm += (aft*bef) % 1000000007\n sm %= 1000000007\n# print(i,r,u,bef,aft)\n print(sm)",
"resolve",
"class Cmber:\n def __init__(self,gensize,mod=10**9+7):\n self.mod = mod\n self.g1=[1,1]\n self.g2 = [1, 1] #逆元テーブル\n self.inverse = [0, 1] #逆元テーブル計算用テーブル\n self.getgen(gensize)\n def getgen(self,N):\n for i in range( 2, N + 1 ):\n self.g1.append( ( self.g1[-1] * i ) % self.mod )\n self.inverse.append( ( -self.inverse[self.mod % i] * (self.mod//i) ) % self.mod )\n self.g2.append( (self.g2[-1] * self.inverse[-1]) % self.mod )\n\n def cmb(self,n, r):\n if ( r<0 or r>n ):\n return 0\n r = min(r, n-r)\n return self.g1[n] * self.g2[r] * self.g2[n-r] % self.mod\n\n def cmb_very_high_n(self,n, r):\n if ( r<0 or r>n ):\n return 0\n g1=1\n r = min(r, n-r)\n for i in range(n-r+1,n+1):\n g1*=i\n g1%=self.mod\n return g1 * self.g2[r] % self.mod",
"class Cmber:\n def __init__(self,gensize,mod=10**9+7):\n self.mod = mod\n self.g1=[1,1]\n self.g2 = [1, 1] #逆元テーブル\n self.inverse = [0, 1] #逆元テーブル計算用テーブル\n self.getgen(gensize)\n def getgen(self,N):\n for i in range( 2, N + 1 ):\n self.g1.append( ( self.g1[-1] * i ) % self.mod )\n self.inverse.append( ( -self.inverse[self.mod % i] * (self.mod//i) ) % self.mod )\n self.g2.append( (self.g2[-1] * self.inverse[-1]) % self.mod )\n\n def cmb(self,n, r):\n if ( r<0 or r>n ):\n return 0\n r = min(r, n-r)\n return self.g1[n] * self.g2[r] * self.g2[n-r] % self.mod\n\n def cmb_very_high_n(self,n, r):\n if ( r<0 or r>n ):\n return 0\n g1=1\n r = min(r, n-r)\n for i in range(n-r+1,n+1):\n g1*=i\n g1%=self.mod\n return g1 * self.g2[r] % self.mod",
"Cmber"
] |
class Cmber:
def __init__(self,gensize,mod=10**9+7):
self.mod = mod
self.g1=[1,1]
self.g2 = [1, 1] #逆元テーブル
self.inverse = [0, 1] #逆元テーブル計算用テーブル
self.getgen(gensize)
def getgen(self,N):
for i in range( 2, N + 1 ):
self.g1.append( ( self.g1[-1] * i ) % self.mod )
self.inverse.append( ( -self.inverse[self.mod % i] * (self.mod//i) ) % self.mod )
self.g2.append( (self.g2[-1] * self.inverse[-1]) % self.mod )
def cmb(self,n, r):
if ( r<0 or r>n ):
return 0
r = min(r, n-r)
return self.g1[n] * self.g2[r] * self.g2[n-r] % self.mod
def cmb_very_high_n(self,n, r):
if ( r<0 or r>n ):
return 0
g1=1
r = min(r, n-r)
for i in range(n-r+1,n+1):
g1*=i
g1%=self.mod
return g1 * self.g2[r] % self.mod
def resolve():
H,W,A,B= map(int,input().split())
cmb= Cmber(H+W+1)
sm =0
for i in range(H-A):
bef = cmb.cmb(B+i-1,i)
r=W-B-1
u=H-i-1
aft = cmb.cmb(r+u,u)
sm += (aft*bef) % 1000000007
sm %= 1000000007
# print(i,r,u,bef,aft)
print(sm)
if __name__ == "__main__":
resolve() |
[
7,
15,
13,
4,
18,
13,
13,
2,
17,
17,
0,
13,
2,
17,
17,
0,
13,
2,
2,
17,
17,
17,
0,
13,
12,
4,
18,
4,
18,
18,
13,
13,
13,
13,
0,
13,
12,
4,
13,
8,
13,
39,
4,
13,
17,
4,
13,
17,
23,
0,
13,
12,
4,
13,
8,
13,
39,
4,
13,
17,
4,
13,
17,
23,
0,
13,
12,
2,
4,
13,
13,
17,
23,
12,
13,
0,
13,
4,
13,
13,
4,
18,
4,
13,
13,
13,
13,
13,
12,
13,
0,
13,
2,
39,
17,
4,
13,
17,
2,
13,
17,
13,
2,
39,
17,
4,
13,
17,
2,
13,
17,
13,
2,
39,
17,
4,
13,
17,
2,
13,
17,
0,
18,
13,
17,
17,
0,
18,
13,
17,
17,
0,
18,
13,
17,
17,
0,
18,
13,
17,
17,
0,
18,
13,
17,
17,
28,
13,
4,
13,
17,
2,
13,
17,
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,
0,
13,
4,
13,
2,
13,
13,
13,
13,
13,
12,
13,
14,
2,
2,
2,
13,
13,
2,
13,
17,
2,
13,
17,
29,
17,
29,
2,
2,
18,
13,
13,
2,
2,
18,
13,
13,
18,
13,
2,
13,
13,
13,
13,
23,
13,
23,
13,
23,
13,
13,
0,
13,
17,
28,
13,
4,
13,
13,
13,
0,
13,
2,
4,
13,
2,
2,
2,
13,
13,
17,
13,
13,
4,
13,
2,
2,
2,
13,
17,
13,
13,
2,
13,
17,
0,
13,
13,
4,
13,
13,
14,
2,
13,
17,
4,
13,
10,
2,
13,
10,
2,
13,
10,
12,
13,
10,
12,
13,
10,
12,
13,
10,
12,
13,
10,
12,
13
] | [
[
306,
11
],
[
309,
16
],
[
318,
23
],
[
321,
35
],
[
312,
50
],
[
324,
65
],
[
77,
76
],
[
319,
83
],
[
77,
85
],
[
77,
86
],
[
77,
87
],
[
92,
91
],
[
205,
99
],
[
102,
101
],
[
205,
109
],
[
112,
111
],
[
205,
119
],
[
130,
122
],
[
91,
123
],
[
130,
127
],
[
91,
128
],
[
140,
132
],
[
101,
133
],
[
140,
137
],
[
101,
138
],
[
145,
142
],
[
111,
143
],
[
148,
147
],
[
205,
152
],
[
158,
155
],
[
91,
156
],
[
147,
157
],
[
91,
161
],
[
147,
163
],
[
147,
165
],
[
207,
166
],
[
171,
168
],
[
111,
169
],
[
147,
170
],
[
207,
172
],
[
111,
176
],
[
207,
178
],
[
147,
179
],
[
207,
181
],
[
147,
182
],
[
207,
183
],
[
188,
185
],
[
101,
186
],
[
147,
187
],
[
101,
191
],
[
147,
193
],
[
168,
195
],
[
111,
196
],
[
147,
197
],
[
207,
198
],
[
205,
205
],
[
207,
207
],
[
210,
209
],
[
89,
211
],
[
76,
213
],
[
85,
214
],
[
310,
215
],
[
210,
216
],
[
210,
217
],
[
253,
224
],
[
255,
225
],
[
253,
227
],
[
255,
230
],
[
209,
238
],
[
253,
239
],
[
216,
243
],
[
255,
244
],
[
216,
246
],
[
253,
248
],
[
255,
249
],
[
257,
250
],
[
257,
251
],
[
253,
253
],
[
255,
255
],
[
258,
257
],
[
261,
260
],
[
264,
263
],
[
87,
266
],
[
85,
267
],
[
270,
269
],
[
219,
272
],
[
76,
276
],
[
86,
277
],
[
263,
279
],
[
263,
280
],
[
219,
282
],
[
86,
286
],
[
85,
288
],
[
263,
289
],
[
86,
291
],
[
295,
294
],
[
310,
295
],
[
294,
298
],
[
269,
298
],
[
260,
298
],
[
316,
304
],
[
306,
307
],
[
309,
310
],
[
312,
313
],
[
318,
319
],
[
321,
322
],
[
324,
325
]
] | [
"# -*- coding: utf-8 -*-\nimport sys\nsys.setrecursionlimit(10**9)\nINF=10**18\nMOD=10**9+7\ninput=lambda: sys.stdin.readline().rstrip()\nYesNo=lambda b: bool([print('Yes')] if b else print('No'))\nYESNO=lambda b: bool([print('YES')] if b else print('NO'))\nint1=lambda x:int(x)-1\n\ndef main():\n H,W,A,B=map(int,input().split())\n def COMinit(n,MOD):\n fac,finv,inv=[0]*max(2,n+1),[0]*max(2,n+1),[0]*max(2,n+1)\n fac[0]=fac[1]=1\n finv[0]=finv[1]=1\n inv[1]=1\n for i in range(2,(n+1)):\n fac[i]=fac[i-1]*i%MOD\n inv[i]=MOD-inv[MOD%i]*(MOD//i)%MOD\n finv[i]=finv[i-1]*inv[i]%MOD\n return fac,finv,inv\n \n fac,finv,inv=COMinit(H+W,MOD)\n \n def COM(n, k, MOD=MOD):\n if n<k or n<0 or k<0:\n return 0\n return fac[n]*(finv[k]*finv[n-k]%MOD)%MOD\n \n ans=0\n for i in range(B,W):\n ans+=COM(H-A-1+i,i)*COM(A-2+W-i,A-1)\n ans%=MOD\n print(ans)\n\nif __name__ == '__main__':\n main()",
"import sys",
"sys",
"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",
"input=lambda: sys.stdin.readline().rstrip()",
"input",
"lambda: sys.stdin.readline().rstrip()",
"sys.stdin.readline().rstrip()",
"sys.stdin.readline().rstrip",
"sys.stdin.readline()",
"sys.stdin.readline",
"sys.stdin",
"sys",
"stdin",
"readline",
"rstrip",
"YesNo=lambda b: bool([print('Yes')] if b else print('No'))",
"YesNo",
"lambda b: bool([print('Yes')] if b else print('No'))",
"bool([print('Yes')] if b else print('No'))",
"bool",
"[print('Yes')] if b else print('No')",
"b",
"[print('Yes')]",
"print('Yes')",
"print",
"'Yes'",
"print('No')",
"print",
"'No'",
"b",
"YESNO=lambda b: bool([print('YES')] if b else print('NO'))",
"YESNO",
"lambda b: bool([print('YES')] if b else print('NO'))",
"bool([print('YES')] if b else print('NO'))",
"bool",
"[print('YES')] if b else print('NO')",
"b",
"[print('YES')]",
"print('YES')",
"print",
"'YES'",
"print('NO')",
"print",
"'NO'",
"b",
"int1=lambda x:int(x)-1",
"int1",
"lambda x:int(x)-1",
"int(x)-1",
"int(x)",
"int",
"x",
"1",
"x",
"def main():\n H,W,A,B=map(int,input().split())\n def COMinit(n,MOD):\n fac,finv,inv=[0]*max(2,n+1),[0]*max(2,n+1),[0]*max(2,n+1)\n fac[0]=fac[1]=1\n finv[0]=finv[1]=1\n inv[1]=1\n for i in range(2,(n+1)):\n fac[i]=fac[i-1]*i%MOD\n inv[i]=MOD-inv[MOD%i]*(MOD//i)%MOD\n finv[i]=finv[i-1]*inv[i]%MOD\n return fac,finv,inv\n \n fac,finv,inv=COMinit(H+W,MOD)\n \n def COM(n, k, MOD=MOD):\n if n<k or n<0 or k<0:\n return 0\n return fac[n]*(finv[k]*finv[n-k]%MOD)%MOD\n \n ans=0\n for i in range(B,W):\n ans+=COM(H-A-1+i,i)*COM(A-2+W-i,A-1)\n ans%=MOD\n print(ans)",
"main",
"H,W,A,B=map(int,input().split())",
"H",
"map(int,input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"W",
"A",
"B",
"def COMinit(n,MOD):\n fac,finv,inv=[0]*max(2,n+1),[0]*max(2,n+1),[0]*max(2,n+1)\n fac[0]=fac[1]=1\n finv[0]=finv[1]=1\n inv[1]=1\n for i in range(2,(n+1)):\n fac[i]=fac[i-1]*i%MOD\n inv[i]=MOD-inv[MOD%i]*(MOD//i)%MOD\n finv[i]=finv[i-1]*inv[i]%MOD\n return fac,finv,inv\n \n ",
"COMinit",
"fac,finv,inv=[0]*max(2,n+1),[0]*max(2,n+1),[0]*max(2,n+1)",
"fac",
"[0]*max(2,n+1)",
"[0]",
"0",
"max(2,n+1)",
"max",
"2",
"n+1",
"n",
"1",
"finv",
"[0]*max(2,n+1)",
"[0]",
"0",
"max(2,n+1)",
"max",
"2",
"n+1",
"n",
"1",
"inv",
"[0]*max(2,n+1)",
"[0]",
"0",
"max(2,n+1)",
"max",
"2",
"n+1",
"n",
"1",
"fac[0]=fac[1]=1",
"fac[0]",
"fac",
"0",
"1",
"=fac[1]=1",
"fac[1]",
"fac",
"1",
"1",
"finv[0]=finv[1]=1",
"finv[0]",
"finv",
"0",
"1",
"=finv[1]=1",
"finv[1]",
"finv",
"1",
"1",
"inv[1]=1",
"inv[1]",
"inv",
"1",
"1",
"for i in range(2,(n+1)):\n fac[i]=fac[i-1]*i%MOD\n inv[i]=MOD-inv[MOD%i]*(MOD//i)%MOD\n finv[i]=finv[i-1]*inv[i]%MOD\n ",
"i",
"range(2,(n+1))",
"range",
"2",
"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[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 fac,finv,inv",
"return fac,finv,inv",
"fac",
"finv",
"inv",
"n",
"n",
"MOD",
"MOD",
"fac,finv,inv=COMinit(H+W,MOD)",
"fac",
"COMinit(H+W,MOD)",
"COMinit",
"H+W",
"H",
"W",
"MOD",
"finv",
"inv",
"def COM(n, k, MOD=MOD):\n if n<k or n<0 or k<0:\n return 0\n return fac[n]*(finv[k]*finv[n-k]%MOD)%MOD\n \n ",
"COM",
"if n<k or n<0 or k<0:\n return 0\n ",
"n<k or n<0 or k<0",
"n<k or n<0",
"n<k",
"n",
"k",
"n<0",
"n",
"0",
"k<0",
"k",
"0",
"return 0",
"0",
"return fac[n]*(finv[k]*finv[n-k]%MOD)%MOD",
"fac[n]*(finv[k]*finv[n-k]%MOD)%MOD",
"fac[n]*(finv[k]*finv[n-k]%MOD)",
"fac[n]",
"fac",
"n",
"finv[k]*finv[n-k]%MOD",
"finv[k]*finv[n-k]",
"finv[k]",
"finv",
"k",
"finv[n-k]",
"finv",
"n-k",
"n",
"k",
"MOD",
"MOD",
"n",
"n",
"k",
"k",
"MOD=MOD",
"MOD",
"MOD",
"ans=0",
"ans",
"0",
"for i in range(B,W):\n ans+=COM(H-A-1+i,i)*COM(A-2+W-i,A-1)\n ans%=MOD\n ",
"i",
"range(B,W)",
"range",
"B",
"W",
"ans+=COM(H-A-1+i,i)*COM(A-2+W-i,A-1)",
"ans",
"COM(H-A-1+i,i)*COM(A-2+W-i,A-1)",
"COM(H-A-1+i,i)",
"COM",
"H-A-1+i",
"H-A-1",
"H-A",
"H",
"A",
"1",
"i",
"i",
"COM(A-2+W-i,A-1)",
"COM",
"A-2+W-i",
"A-2+W",
"A-2",
"A",
"2",
"W",
"i",
"A-1",
"A",
"1",
"ans%=MOD",
"ans",
"MOD",
"print(ans)",
"print",
"ans",
"if __name__ == '__main__':\n main()",
"__name__ == '__main__'",
"__name__",
"'__main__'",
"main()",
"main",
"INF=10**18",
"10**18",
"INF",
"MOD=10**9+7",
"10**9+7",
"MOD",
"YESNO=lambda b: bool([print('YES')] if b else print('NO'))",
"lambda b: bool([print('YES')] if b else print('NO'))",
"YESNO",
"def main():\n H,W,A,B=map(int,input().split())\n def COMinit(n,MOD):\n fac,finv,inv=[0]*max(2,n+1),[0]*max(2,n+1),[0]*max(2,n+1)\n fac[0]=fac[1]=1\n finv[0]=finv[1]=1\n inv[1]=1\n for i in range(2,(n+1)):\n fac[i]=fac[i-1]*i%MOD\n inv[i]=MOD-inv[MOD%i]*(MOD//i)%MOD\n finv[i]=finv[i-1]*inv[i]%MOD\n return fac,finv,inv\n \n fac,finv,inv=COMinit(H+W,MOD)\n \n def COM(n, k, MOD=MOD):\n if n<k or n<0 or k<0:\n return 0\n return fac[n]*(finv[k]*finv[n-k]%MOD)%MOD\n \n ans=0\n for i in range(B,W):\n ans+=COM(H-A-1+i,i)*COM(A-2+W-i,A-1)\n ans%=MOD\n print(ans)",
"def main():\n H,W,A,B=map(int,input().split())\n def COMinit(n,MOD):\n fac,finv,inv=[0]*max(2,n+1),[0]*max(2,n+1),[0]*max(2,n+1)\n fac[0]=fac[1]=1\n finv[0]=finv[1]=1\n inv[1]=1\n for i in range(2,(n+1)):\n fac[i]=fac[i-1]*i%MOD\n inv[i]=MOD-inv[MOD%i]*(MOD//i)%MOD\n finv[i]=finv[i-1]*inv[i]%MOD\n return fac,finv,inv\n \n fac,finv,inv=COMinit(H+W,MOD)\n \n def COM(n, k, MOD=MOD):\n if n<k or n<0 or k<0:\n return 0\n return fac[n]*(finv[k]*finv[n-k]%MOD)%MOD\n \n ans=0\n for i in range(B,W):\n ans+=COM(H-A-1+i,i)*COM(A-2+W-i,A-1)\n ans%=MOD\n print(ans)",
"main",
"input=lambda: sys.stdin.readline().rstrip()",
"lambda: sys.stdin.readline().rstrip()",
"input",
"YesNo=lambda b: bool([print('Yes')] if b else print('No'))",
"lambda b: bool([print('Yes')] if b else print('No'))",
"YesNo",
"int1=lambda x:int(x)-1",
"lambda x:int(x)-1",
"int1"
] | # -*- coding: utf-8 -*-
import sys
sys.setrecursionlimit(10**9)
INF=10**18
MOD=10**9+7
input=lambda: sys.stdin.readline().rstrip()
YesNo=lambda b: bool([print('Yes')] if b else print('No'))
YESNO=lambda b: bool([print('YES')] if b else print('NO'))
int1=lambda x:int(x)-1
def main():
H,W,A,B=map(int,input().split())
def COMinit(n,MOD):
fac,finv,inv=[0]*max(2,n+1),[0]*max(2,n+1),[0]*max(2,n+1)
fac[0]=fac[1]=1
finv[0]=finv[1]=1
inv[1]=1
for i in range(2,(n+1)):
fac[i]=fac[i-1]*i%MOD
inv[i]=MOD-inv[MOD%i]*(MOD//i)%MOD
finv[i]=finv[i-1]*inv[i]%MOD
return fac,finv,inv
fac,finv,inv=COMinit(H+W,MOD)
def COM(n, k, MOD=MOD):
if n<k or n<0 or k<0:
return 0
return fac[n]*(finv[k]*finv[n-k]%MOD)%MOD
ans=0
for i in range(B,W):
ans+=COM(H-A-1+i,i)*COM(A-2+W-i,A-1)
ans%=MOD
print(ans)
if __name__ == '__main__':
main()
|
[
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,
0,
18,
13,
13,
4,
13,
18,
13,
13,
2,
13,
17,
13,
12,
13,
0,
13,
2,
2,
18,
13,
2,
13,
13,
18,
13,
13,
18,
13,
13,
29,
2,
13,
13,
23,
13,
23,
13,
0,
13,
17,
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,
4,
13,
2,
13,
13,
10,
2,
13,
10,
12,
13,
10,
4,
13,
10,
4,
13,
10,
4,
13,
10,
4,
13,
10,
2,
13,
10,
2,
13,
10,
2,
13,
10,
17,
13
] | [
[
153,
2
],
[
153,
11
],
[
153,
12
],
[
153,
13
],
[
156,
15
],
[
159,
22
],
[
154,
28
],
[
151,
29
],
[
138,
32
],
[
154,
38
],
[
151,
39
],
[
43,
42
],
[
154,
48
],
[
151,
49
],
[
55,
52
],
[
160,
53
],
[
42,
54
],
[
160,
58
],
[
42,
60
],
[
42,
62
],
[
157,
63
],
[
68,
65
],
[
139,
66
],
[
42,
67
],
[
52,
70
],
[
160,
71
],
[
42,
72
],
[
157,
74
],
[
157,
76
],
[
81,
80
],
[
160,
84
],
[
99,
86
],
[
101,
87
],
[
139,
89
],
[
99,
90
],
[
139,
92
],
[
101,
93
],
[
80,
96
],
[
157,
97
],
[
99,
99
],
[
101,
101
],
[
165,
103
],
[
107,
106
],
[
148,
109
],
[
151,
110
],
[
162,
112
],
[
142,
115
],
[
106,
116
],
[
154,
119
],
[
145,
120
],
[
142,
123
],
[
151,
126
],
[
106,
128
],
[
145,
130
],
[
163,
135
],
[
166,
135
],
[
157,
136
],
[
138,
139
],
[
153,
145
],
[
153,
148
],
[
153,
151
],
[
153,
154
],
[
156,
157
],
[
159,
160
],
[
162,
163
],
[
165,
166
]
] | [
"H, W, A, B = map(int, input().split())\n\nmod = 10 ** 9 + 7\n\n# 階乗\nfac = [1] * (H + W - 2)\n# 逆元\ninv = [1] * (H + W - 2)\nfor i in range(1, H + W - 2):\n fac[i] = (fac[i - 1] * i) % mod\n inv[i] = pow(fac[i], mod - 2, mod)\n\n\ndef f(x, y):\n res = fac[x + y] * inv[x] * inv[y]\n return res % mod\n\n\nans = 0\nfor x in range(B, W):\n ans += f(x, H - A - 1) * f(W - 1 - x, A - 1)\nprint(ans % mod)\n",
"H, W, A, B = map(int, input().split())",
"H",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"W",
"A",
"B",
"mod = 10 ** 9 + 7",
"mod",
"10 ** 9 + 7",
"10 ** 9",
"10",
"9",
"7",
"fac = [1] * (H + W - 2)",
"fac",
"[1] * (H + W - 2)",
"[1]",
"1",
"H + W - 2",
"H + W",
"H",
"W",
"2",
"inv = [1] * (H + W - 2)",
"inv",
"[1] * (H + W - 2)",
"[1]",
"1",
"H + W - 2",
"H + W",
"H",
"W",
"2",
"for i in range(1, H + W - 2):\n fac[i] = (fac[i - 1] * i) % mod\n inv[i] = pow(fac[i], mod - 2, mod)",
"i",
"range(1, H + W - 2)",
"range",
"1",
"H + W - 2",
"H + W",
"H",
"W",
"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] = 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 res = fac[x + y] * inv[x] * inv[y]\n return res % mod",
"f",
"res = fac[x + y] * inv[x] * inv[y]",
"res",
"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",
"return res % mod",
"res % mod",
"res",
"mod",
"x",
"x",
"y",
"y",
"ans = 0",
"ans",
"0",
"for x in range(B, W):\n ans += f(x, H - A - 1) * f(W - 1 - x, A - 1)",
"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",
"print(ans % mod)",
"print",
"ans % mod",
"ans",
"mod",
"inv = [1] * (H + W - 2)",
"[1] * (H + W - 2)",
"inv",
"def f(x, y):\n res = fac[x + y] * inv[x] * inv[y]\n return res % mod",
"def f(x, y):\n res = fac[x + y] * inv[x] * inv[y]\n return res % mod",
"f",
"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",
"H, W, A, B = map(int, input().split())",
"map(int, input().split())",
"H",
"mod = 10 ** 9 + 7",
"10 ** 9 + 7",
"mod",
"fac = [1] * (H + W - 2)",
"[1] * (H + W - 2)",
"fac",
"ans += f(x, H - A - 1) * f(W - 1 - x, A - 1)",
"f(x, H - A - 1) * f(W - 1 - x, A - 1)",
"ans",
"ans = 0",
"0",
"ans"
] | H, W, A, B = map(int, input().split())
mod = 10 ** 9 + 7
# 階乗
fac = [1] * (H + W - 2)
# 逆元
inv = [1] * (H + W - 2)
for i in range(1, H + W - 2):
fac[i] = (fac[i - 1] * i) % mod
inv[i] = pow(fac[i], mod - 2, mod)
def f(x, y):
res = fac[x + y] * inv[x] * inv[y]
return res % mod
ans = 0
for x in range(B, W):
ans += f(x, H - A - 1) * f(W - 1 - x, A - 1)
print(ans % mod)
|
[
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,
39,
17,
28,
13,
4,
13,
17,
17,
4,
18,
13,
13,
2,
2,
18,
13,
17,
13,
13,
12,
13,
29,
18,
13,
13,
23,
13,
23,
13,
13,
12,
13,
14,
2,
2,
13,
17,
2,
13,
17,
29,
17,
14,
2,
13,
13,
29,
17,
0,
13,
17,
0,
13,
4,
13,
13,
13,
0,
13,
4,
13,
4,
13,
13,
13,
2,
13,
17,
13,
0,
13,
4,
13,
4,
13,
2,
13,
13,
13,
2,
13,
17,
13,
29,
2,
13,
13,
23,
13,
23,
13,
23,
13,
13,
0,
13,
17,
28,
13,
4,
13,
13,
13,
0,
13,
2,
4,
13,
2,
2,
13,
2,
13,
13,
17,
13,
4,
13,
2,
2,
2,
13,
13,
13,
17,
2,
13,
17,
0,
13,
13,
4,
13,
13,
10,
13,
13,
10,
2,
13,
10,
13,
13,
10,
13,
13,
10,
2,
13,
10,
13,
13,
10,
13,
13,
10,
39,
13,
10,
12,
13,
10,
17,
13,
10,
12,
13
] | [
[
4,
3
],
[
3,
12
],
[
181,
14
],
[
181,
16
],
[
181,
17
],
[
181,
18
],
[
175,
20
],
[
184,
27
],
[
32,
31
],
[
185,
38
],
[
185,
43
],
[
31,
45
],
[
176,
46
],
[
185,
51
],
[
54,
52
],
[
54,
54
],
[
57,
56
],
[
116,
63
],
[
118,
66
],
[
116,
72
],
[
118,
73
],
[
78,
77
],
[
81,
80
],
[
194,
82
],
[
116,
83
],
[
120,
84
],
[
87,
86
],
[
194,
90
],
[
118,
91
],
[
120,
92
],
[
120,
94
],
[
120,
96
],
[
99,
98
],
[
194,
102
],
[
116,
104
],
[
118,
105
],
[
120,
106
],
[
120,
108
],
[
120,
110
],
[
98,
113
],
[
86,
113
],
[
80,
113
],
[
77,
113
],
[
120,
114
],
[
116,
116
],
[
118,
118
],
[
121,
120
],
[
190,
123
],
[
127,
126
],
[
173,
129
],
[
179,
130
],
[
166,
132
],
[
188,
135
],
[
126,
138
],
[
170,
140
],
[
182,
141
],
[
126,
143
],
[
188,
145
],
[
179,
149
],
[
126,
150
],
[
182,
151
],
[
182,
154
],
[
163,
157
],
[
176,
158
],
[
164,
161
],
[
167,
161
],
[
191,
161
],
[
176,
163
],
[
163,
164
],
[
166,
167
],
[
181,
170
],
[
181,
173
],
[
175,
176
],
[
181,
179
],
[
181,
182
],
[
184,
185
],
[
190,
191
]
] | [
"h, w, a, b = [int(i) for i in input().split()]\n\nmod = 10 ** 9 + 7\nkkai = [1]\nfor i in range(1, 210000):\n kkai.append(kkai[-1] * i % mod)\n\n\ndef kai(x, p=mod):\n return kkai[x]\n\n\ndef comb(a, b, p=mod):\n if a < 0 or b < 0:\n return 0\n elif a < b:\n return 0\n c = 1\n c *= kai(a, p)\n c *= pow(kai(b, p), p - 2, p)\n c *= pow(kai(a - b, p), p - 2, p)\n return c % p\n\n\nans = 0\nfor i in range(b, w):\n ans += comb(i+(h-a)-1, i)*comb((w-i)+a-2, a-1)\n ans %= mod\nprint(ans)",
"int(i) for i in input().split()",
"for i in input().split()",
"i",
"input().split()",
"().split",
"()",
"input",
"split",
"for i in input().split()",
"int(i)",
"int",
"i",
"h, w, a, b = [int(i) for i in input().split()]",
"h",
"[int(i) for i in input().split()]",
"w",
"a",
"b",
"mod = 10 ** 9 + 7",
"mod",
"10 ** 9 + 7",
"10 ** 9",
"10",
"9",
"7",
"kkai = [1]",
"kkai",
"[1]",
"1",
"for i in range(1, 210000):\n kkai.append(kkai[-1] * i % mod)",
"i",
"range(1, 210000)",
"range",
"1",
"210000",
"kkai.append(kkai[-1] * i % mod)",
"kkai.append",
"kkai",
"append",
"kkai[-1] * i % mod",
"kkai[-1] * i",
"kkai[-1]",
"kkai",
"-1",
"i",
"mod",
"def kai(x, p=mod):\n return kkai[x]",
"kai",
"return kkai[x]",
"kkai[x]",
"kkai",
"x",
"x",
"x",
"p=mod",
"p",
"mod",
"def comb(a, b, p=mod):\n if a < 0 or b < 0:\n return 0\n elif a < b:\n return 0\n c = 1\n c *= kai(a, p)\n c *= pow(kai(b, p), p - 2, p)\n c *= pow(kai(a - b, p), p - 2, p)\n return c % p",
"comb",
"if a < 0 or b < 0:\n return 0\n elif a < b:\n return 0\n ",
"a < 0 or b < 0",
"a < 0",
"a",
"0",
"b < 0",
"b",
"0",
"return 0",
"0",
"elif a < b:\n return 0\n ",
"a < b",
"a",
"b",
"return 0",
"0",
"c = 1",
"c",
"1",
"c *= kai(a, p)",
"c",
"kai(a, p)",
"kai",
"a",
"p",
"c *= pow(kai(b, p), p - 2, p)",
"c",
"pow(kai(b, p), p - 2, p)",
"pow",
"kai(b, p)",
"kai",
"b",
"p",
"p - 2",
"p",
"2",
"p",
"c *= pow(kai(a - b, p), p - 2, p)",
"c",
"pow(kai(a - b, p), p - 2, p)",
"pow",
"kai(a - b, p)",
"kai",
"a - b",
"a",
"b",
"p",
"p - 2",
"p",
"2",
"p",
"return c % p",
"c % p",
"c",
"p",
"a",
"a",
"b",
"b",
"p=mod",
"p",
"mod",
"ans = 0",
"ans",
"0",
"for i in range(b, w):\n ans += comb(i+(h-a)-1, i)*comb((w-i)+a-2, a-1)\n ans %= mod",
"i",
"range(b, w)",
"range",
"b",
"w",
"ans += comb(i+(h-a)-1, i)*comb((w-i)+a-2, a-1)",
"ans",
"comb(i+(h-a)-1, i)*comb((w-i)+a-2, a-1)",
"comb(i+(h-a)-1, i)",
"comb",
"i+(h-a)-1",
"i+(h-a)",
"i",
"h-a",
"h",
"a",
"1",
"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",
"ans %= mod",
"ans",
"mod",
"print(ans)",
"print",
"ans",
"ans %= mod",
"mod",
"ans",
"ans += comb(i+(h-a)-1, i)*comb((w-i)+a-2, a-1)",
"comb(i+(h-a)-1, i)*comb((w-i)+a-2, a-1)",
"ans",
"h, w, a, b = [int(i) for i in input().split()]",
"[int(i) for i in input().split()]",
"h",
"b = [int(i) for i in input().split()]",
"[int(i) for i in input().split()]",
"b",
"mod = 10 ** 9 + 7",
"10 ** 9 + 7",
"mod",
"w, a, b = [int(i) for i in input().split()]",
"[int(i) for i in input().split()]",
"w",
"a, b = [int(i) for i in input().split()]",
"[int(i) for i in input().split()]",
"a",
"kkai = [1]",
"[1]",
"kkai",
"def comb(a, b, p=mod):\n if a < 0 or b < 0:\n return 0\n elif a < b:\n return 0\n c = 1\n c *= kai(a, p)\n c *= pow(kai(b, p), p - 2, p)\n c *= pow(kai(a - b, p), p - 2, p)\n return c % p",
"def comb(a, b, p=mod):\n if a < 0 or b < 0:\n return 0\n elif a < b:\n return 0\n c = 1\n c *= kai(a, p)\n c *= pow(kai(b, p), p - 2, p)\n c *= pow(kai(a - b, p), p - 2, p)\n return c % p",
"comb",
"ans = 0",
"0",
"ans",
"def kai(x, p=mod):\n return kkai[x]",
"def kai(x, p=mod):\n return kkai[x]",
"kai"
] | h, w, a, b = [int(i) for i in input().split()]
mod = 10 ** 9 + 7
kkai = [1]
for i in range(1, 210000):
kkai.append(kkai[-1] * i % mod)
def kai(x, p=mod):
return kkai[x]
def comb(a, b, p=mod):
if a < 0 or b < 0:
return 0
elif a < b:
return 0
c = 1
c *= kai(a, p)
c *= pow(kai(b, p), p - 2, p)
c *= pow(kai(a - b, p), p - 2, p)
return c % p
ans = 0
for i in range(b, w):
ans += comb(i+(h-a)-1, i)*comb((w-i)+a-2, a-1)
ans %= mod
print(ans)
|
[
7,
12,
13,
0,
13,
4,
13,
13,
4,
18,
4,
13,
13,
13,
13,
13,
0,
13,
4,
13,
13,
13,
0,
13,
2,
2,
17,
17,
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,
13,
2,
39,
17,
2,
13,
17,
0,
18,
13,
17,
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,
0,
13,
2,
2,
18,
13,
2,
2,
13,
13,
17,
18,
13,
2,
13,
17,
13,
0,
13,
4,
13,
2,
2,
2,
2,
18,
13,
2,
2,
2,
13,
13,
13,
17,
18,
13,
13,
18,
13,
2,
2,
2,
13,
13,
17,
13,
18,
13,
2,
2,
13,
13,
17,
13,
4,
13,
2,
2,
13,
13,
13,
14,
2,
13,
17,
10,
12,
13
] | [
[
5,
4
],
[
5,
13
],
[
5,
14
],
[
5,
15
],
[
18,
17
],
[
4,
20
],
[
13,
21
],
[
24,
23
],
[
31,
30
],
[
4,
36
],
[
13,
37
],
[
41,
40
],
[
4,
46
],
[
13,
47
],
[
53,
50
],
[
30,
51
],
[
40,
52
],
[
30,
56
],
[
40,
58
],
[
40,
60
],
[
23,
61
],
[
64,
63
],
[
17,
68
],
[
74,
71
],
[
63,
72
],
[
30,
77
],
[
17,
78
],
[
23,
80
],
[
23,
82
],
[
85,
84
],
[
17,
88
],
[
96,
93
],
[
63,
94
],
[
84,
95
],
[
63,
99
],
[
84,
101
],
[
84,
104
],
[
23,
106
],
[
109,
108
],
[
63,
112
],
[
4,
115
],
[
14,
116
],
[
63,
119
],
[
14,
121
],
[
23,
123
],
[
126,
125
],
[
30,
133
],
[
4,
137
],
[
14,
138
],
[
93,
141
],
[
63,
142
],
[
30,
145
],
[
14,
149
],
[
13,
150
],
[
63,
154
],
[
13,
157
],
[
23,
160
],
[
125,
165
],
[
108,
166
],
[
23,
167
]
] | [
"def solve():\n\th,w,a,b = map(int, input().split())\n\tmx = max(h,w)\n\tmod = 10**9+7\n\tfac = [1]*(h+w+1)\n\tfor i in range(1,h+w+1):\n\t\tfac[i]=fac[i-1]*i%mod\n\tinv = [1]*(mx+1)\n\tinv[-1] = pow(fac[mx], mod-2, mod)\n\tfor i in range(mx-1, -1, -1):\n\t\tinv[i] = inv[i+1]*(i+1)%mod\n\tconst = inv[h-a-1]*inv[a-1]%mod\n\tans = sum(fac[h-a+i-1]*inv[i]*fac[a+w-2-i]*inv[w-i-1]%mod for i in range(b,w))\n\tprint(ans*const%mod)\n\nif __name__==\"__main__\":solve()",
"def solve():\n\th,w,a,b = map(int, input().split())\n\tmx = max(h,w)\n\tmod = 10**9+7\n\tfac = [1]*(h+w+1)\n\tfor i in range(1,h+w+1):\n\t\tfac[i]=fac[i-1]*i%mod\n\tinv = [1]*(mx+1)\n\tinv[-1] = pow(fac[mx], mod-2, mod)\n\tfor i in range(mx-1, -1, -1):\n\t\tinv[i] = inv[i+1]*(i+1)%mod\n\tconst = inv[h-a-1]*inv[a-1]%mod\n\tans = sum(fac[h-a+i-1]*inv[i]*fac[a+w-2-i]*inv[w-i-1]%mod for i in range(b,w))\n\tprint(ans*const%mod)",
"solve",
"h,w,a,b = map(int, input().split())",
"h",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"w",
"a",
"b",
"mx = max(h,w)",
"mx",
"max(h,w)",
"max",
"h",
"w",
"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",
"for i in range(1,h+w+1):\n\t\tfac[i]=fac[i-1]*i%mod\n\t",
"i",
"range(1,h+w+1)",
"range",
"1",
"h+w+1",
"h+w",
"h",
"w",
"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]*(mx+1)",
"inv",
"[1]*(mx+1)",
"[1]",
"1",
"mx+1",
"mx",
"1",
"inv[-1] = pow(fac[mx], mod-2, mod)",
"inv[-1]",
"inv",
"-1",
"pow(fac[mx], mod-2, mod)",
"pow",
"fac[mx]",
"fac",
"mx",
"mod-2",
"mod",
"2",
"mod",
"for i in range(mx-1, -1, -1):\n\t\tinv[i] = inv[i+1]*(i+1)%mod\n\t",
"i",
"range(mx-1, -1, -1)",
"range",
"mx-1",
"mx",
"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",
"const = inv[h-a-1]*inv[a-1]%mod",
"const",
"inv[h-a-1]*inv[a-1]%mod",
"inv[h-a-1]*inv[a-1]",
"inv[h-a-1]",
"inv",
"h-a-1",
"h-a",
"h",
"a",
"1",
"inv[a-1]",
"inv",
"a-1",
"a",
"1",
"mod",
"ans = sum(fac[h-a+i-1]*inv[i]*fac[a+w-2-i]*inv[w-i-1]%mod for i in range(b,w))",
"ans",
"sum(fac[h-a+i-1]*inv[i]*fac[a+w-2-i]*inv[w-i-1]%mod for i in range(b,w))",
"sum",
"fac[h-a+i-1]*inv[i]*fac[a+w-2-i]*inv[w-i-1]%mod",
"fac[h-a+i-1]*inv[i]*fac[a+w-2-i]*inv[w-i-1]",
"fac[h-a+i-1]*inv[i]*fac[a+w-2-i]",
"fac[h-a+i-1]*inv[i]",
"fac[h-a+i-1]",
"fac",
"h-a+i-1",
"h-a+i",
"h-a",
"h",
"a",
"i",
"1",
"inv[i]",
"inv",
"i",
"fac[a+w-2-i]",
"fac",
"a+w-2-i",
"a+w-2",
"a+w",
"a",
"w",
"2",
"i",
"inv[w-i-1]",
"inv",
"w-i-1",
"w-i",
"w",
"i",
"1",
"mod",
"print(ans*const%mod)",
"print",
"ans*const%mod",
"ans*const",
"ans",
"const",
"mod",
"if __name__==\"__main__\":solve()",
"__name__==\"__main__\"",
"__name__",
"\"__main__\"",
"def solve():\n\th,w,a,b = map(int, input().split())\n\tmx = max(h,w)\n\tmod = 10**9+7\n\tfac = [1]*(h+w+1)\n\tfor i in range(1,h+w+1):\n\t\tfac[i]=fac[i-1]*i%mod\n\tinv = [1]*(mx+1)\n\tinv[-1] = pow(fac[mx], mod-2, mod)\n\tfor i in range(mx-1, -1, -1):\n\t\tinv[i] = inv[i+1]*(i+1)%mod\n\tconst = inv[h-a-1]*inv[a-1]%mod\n\tans = sum(fac[h-a+i-1]*inv[i]*fac[a+w-2-i]*inv[w-i-1]%mod for i in range(b,w))\n\tprint(ans*const%mod)",
"def solve():\n\th,w,a,b = map(int, input().split())\n\tmx = max(h,w)\n\tmod = 10**9+7\n\tfac = [1]*(h+w+1)\n\tfor i in range(1,h+w+1):\n\t\tfac[i]=fac[i-1]*i%mod\n\tinv = [1]*(mx+1)\n\tinv[-1] = pow(fac[mx], mod-2, mod)\n\tfor i in range(mx-1, -1, -1):\n\t\tinv[i] = inv[i+1]*(i+1)%mod\n\tconst = inv[h-a-1]*inv[a-1]%mod\n\tans = sum(fac[h-a+i-1]*inv[i]*fac[a+w-2-i]*inv[w-i-1]%mod for i in range(b,w))\n\tprint(ans*const%mod)",
"solve"
] | def solve():
h,w,a,b = map(int, input().split())
mx = max(h,w)
mod = 10**9+7
fac = [1]*(h+w+1)
for i in range(1,h+w+1):
fac[i]=fac[i-1]*i%mod
inv = [1]*(mx+1)
inv[-1] = pow(fac[mx], mod-2, mod)
for i in range(mx-1, -1, -1):
inv[i] = inv[i+1]*(i+1)%mod
const = inv[h-a-1]*inv[a-1]%mod
ans = sum(fac[h-a+i-1]*inv[i]*fac[a+w-2-i]*inv[w-i-1]%mod for i in range(b,w))
print(ans*const%mod)
if __name__=="__main__":solve() |
[
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,
41,
28,
13,
4,
13,
13,
4,
17,
0,
13,
13,
0,
18,
13,
17,
17,
28,
13,
4,
13,
17,
13,
0,
18,
13,
13,
2,
2,
13,
18,
13,
2,
13,
17,
13,
41,
28,
13,
4,
13,
13,
4,
17,
0,
13,
13,
0,
18,
13,
17,
17,
28,
13,
4,
13,
17,
13,
0,
18,
13,
13,
4,
13,
18,
13,
13,
2,
13,
17,
13,
12,
13,
29,
2,
2,
2,
18,
13,
13,
18,
13,
2,
13,
13,
18,
13,
13,
13,
23,
13,
23,
13,
12,
13,
29,
2,
4,
13,
2,
13,
13,
13,
13,
23,
13,
23,
13,
0,
13,
39,
28,
13,
4,
13,
13,
4,
18,
13,
13,
2,
4,
13,
2,
2,
13,
13,
17,
13,
4,
13,
2,
2,
13,
17,
13,
2,
13,
17,
0,
13,
2,
4,
13,
2,
13,
17,
2,
13,
17,
4,
13,
13,
4,
13,
2,
13,
13,
10,
13,
13,
10,
4,
13,
10,
4,
13,
10,
2,
13,
10,
39,
13,
10,
4,
13,
10,
12,
13,
10,
4,
13,
10,
13,
13,
10,
12,
13,
10,
2,
13,
10,
2,
13
] | [
[
207,
2
],
[
207,
11
],
[
207,
12
],
[
207,
13
],
[
216,
15
],
[
195,
22
],
[
190,
25
],
[
193,
26
],
[
31,
30
],
[
196,
33
],
[
210,
37
],
[
43,
40
],
[
211,
41
],
[
46,
45
],
[
196,
49
],
[
54,
51
],
[
211,
52
],
[
45,
53
],
[
45,
56
],
[
211,
58
],
[
45,
60
],
[
217,
62
],
[
66,
65
],
[
196,
68
],
[
186,
72
],
[
78,
75
],
[
187,
76
],
[
81,
80
],
[
196,
84
],
[
89,
86
],
[
187,
87
],
[
80,
88
],
[
51,
91
],
[
211,
92
],
[
80,
93
],
[
217,
95
],
[
217,
97
],
[
211,
105
],
[
117,
106
],
[
187,
108
],
[
117,
110
],
[
119,
111
],
[
187,
113
],
[
119,
114
],
[
217,
115
],
[
117,
117
],
[
119,
119
],
[
205,
125
],
[
132,
127
],
[
134,
128
],
[
134,
129
],
[
217,
130
],
[
132,
132
],
[
134,
134
],
[
198,
136
],
[
140,
139
],
[
208,
142
],
[
199,
145
],
[
214,
149
],
[
190,
152
],
[
202,
153
],
[
139,
155
],
[
214,
157
],
[
193,
160
],
[
139,
162
],
[
202,
164
],
[
219,
167
],
[
214,
170
],
[
193,
172
],
[
190,
175
],
[
199,
179
],
[
220,
183
],
[
217,
184
],
[
186,
187
],
[
207,
190
],
[
207,
193
],
[
195,
196
],
[
198,
199
],
[
207,
202
],
[
207,
208
],
[
210,
211
],
[
216,
217
],
[
219,
220
]
] | [
"\n#ABC042D\nH, W, A, B = map(int, input().split())\nmod=10**9+7\nN=H+W+1\nbikkuri=[0 for i in range(N)]\nbikkuri[0]=1\nfor i in range(1,N):\n bikkuri[i] = (i * bikkuri[i-1])%mod\ngyaku=[0 for i in range(N)]\ngyaku[0]=1\nfor i in range(1, N):\n gyaku[i]=pow(bikkuri[i], mod-2, mod)\ndef comb(n,r):\n return bikkuri[n]*gyaku[n-r]*gyaku[r]%mod\ndef homb(n,r):\n return comb(n+r,r)%mod\ndame = []\nfor i in range(B):\n dame.append(homb(H-A-1, i) * homb(W-1-i,A-1))\nans = homb(W-1, H-1) - sum(dame)\nprint(ans%mod)",
"H, W, A, B = map(int, input().split())",
"H",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"W",
"A",
"B",
"mod=10**9+7",
"mod",
"10**9+7",
"10**9",
"10",
"9",
"7",
"N=H+W+1",
"N",
"H+W+1",
"H+W",
"H",
"W",
"1",
"0 for i in range(N)",
"for i in range(N)",
"i",
"range(N)",
"range",
"N",
"for i in range(N)",
"0",
"bikkuri=[0 for i in range(N)]",
"bikkuri",
"[0 for i in range(N)]",
"bikkuri[0]=1",
"bikkuri[0]",
"bikkuri",
"0",
"1",
"for i in range(1,N):\n bikkuri[i] = (i * bikkuri[i-1])%mod",
"i",
"range(1,N)",
"range",
"1",
"N",
"bikkuri[i] = (i * bikkuri[i-1])%mod",
"bikkuri[i]",
"bikkuri",
"i",
"(i * bikkuri[i-1])%mod",
"i * bikkuri[i-1]",
"i",
"bikkuri[i-1]",
"bikkuri",
"i-1",
"i",
"1",
"mod",
"0 for i in range(N)",
"for i in range(N)",
"i",
"range(N)",
"range",
"N",
"for i in range(N)",
"0",
"gyaku=[0 for i in range(N)]",
"gyaku",
"[0 for i in range(N)]",
"gyaku[0]=1",
"gyaku[0]",
"gyaku",
"0",
"1",
"for i in range(1, N):\n gyaku[i]=pow(bikkuri[i], mod-2, mod)",
"i",
"range(1, N)",
"range",
"1",
"N",
"gyaku[i]=pow(bikkuri[i], mod-2, mod)",
"gyaku[i]",
"gyaku",
"i",
"pow(bikkuri[i], mod-2, mod)",
"pow",
"bikkuri[i]",
"bikkuri",
"i",
"mod-2",
"mod",
"2",
"mod",
"def comb(n,r):\n return bikkuri[n]*gyaku[n-r]*gyaku[r]%mod",
"comb",
"return bikkuri[n]*gyaku[n-r]*gyaku[r]%mod",
"bikkuri[n]*gyaku[n-r]*gyaku[r]%mod",
"bikkuri[n]*gyaku[n-r]*gyaku[r]",
"bikkuri[n]*gyaku[n-r]",
"bikkuri[n]",
"bikkuri",
"n",
"gyaku[n-r]",
"gyaku",
"n-r",
"n",
"r",
"gyaku[r]",
"gyaku",
"r",
"mod",
"n",
"n",
"r",
"r",
"def homb(n,r):\n return comb(n+r,r)%mod",
"homb",
"return comb(n+r,r)%mod",
"comb(n+r,r)%mod",
"comb(n+r,r)",
"comb",
"n+r",
"n",
"r",
"r",
"mod",
"n",
"n",
"r",
"r",
"dame = []",
"dame",
"[]",
"for i in range(B):\n dame.append(homb(H-A-1, i) * homb(W-1-i,A-1))",
"i",
"range(B)",
"range",
"B",
"dame.append(homb(H-A-1, i) * homb(W-1-i,A-1))",
"dame.append",
"dame",
"append",
"homb(H-A-1, i) * homb(W-1-i,A-1)",
"homb(H-A-1, i)",
"homb",
"H-A-1",
"H-A",
"H",
"A",
"1",
"i",
"homb(W-1-i,A-1)",
"homb",
"W-1-i",
"W-1",
"W",
"1",
"i",
"A-1",
"A",
"1",
"ans = homb(W-1, H-1) - sum(dame)",
"ans",
"homb(W-1, H-1) - sum(dame)",
"homb(W-1, H-1)",
"homb",
"W-1",
"W",
"1",
"H-1",
"H",
"1",
"sum(dame)",
"sum",
"dame",
"print(ans%mod)",
"print",
"ans%mod",
"ans",
"mod",
"gyaku=[0 for i in range(N)]",
"[0 for i in range(N)]",
"gyaku",
"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",
"N=H+W+1",
"H+W+1",
"N",
"dame = []",
"[]",
"dame",
"A, B = map(int, input().split())",
"map(int, input().split())",
"A",
"def comb(n,r):\n return bikkuri[n]*gyaku[n-r]*gyaku[r]%mod",
"def comb(n,r):\n return bikkuri[n]*gyaku[n-r]*gyaku[r]%mod",
"comb",
"B = map(int, input().split())",
"map(int, input().split())",
"B",
"bikkuri=[0 for i in range(N)]",
"[0 for i in range(N)]",
"bikkuri",
"def homb(n,r):\n return comb(n+r,r)%mod",
"def homb(n,r):\n return comb(n+r,r)%mod",
"homb",
"mod=10**9+7",
"10**9+7",
"mod",
"ans = homb(W-1, H-1) - sum(dame)",
"homb(W-1, H-1) - sum(dame)",
"ans"
] |
#ABC042D
H, W, A, B = map(int, input().split())
mod=10**9+7
N=H+W+1
bikkuri=[0 for i in range(N)]
bikkuri[0]=1
for i in range(1,N):
bikkuri[i] = (i * bikkuri[i-1])%mod
gyaku=[0 for i in range(N)]
gyaku[0]=1
for i in range(1, N):
gyaku[i]=pow(bikkuri[i], mod-2, mod)
def comb(n,r):
return bikkuri[n]*gyaku[n-r]*gyaku[r]%mod
def homb(n,r):
return comb(n+r,r)%mod
dame = []
for i in range(B):
dame.append(homb(H-A-1, i) * homb(W-1-i,A-1))
ans = homb(W-1, H-1) - sum(dame)
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,
2,
13,
13,
0,
13,
2,
39,
17,
2,
13,
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,
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,
23,
13,
23,
13,
0,
13,
17,
28,
13,
4,
13,
17,
4,
13,
2,
2,
13,
13,
17,
2,
2,
13,
13,
17,
0,
13,
2,
2,
13,
13,
17,
0,
13,
2,
2,
13,
13,
13,
0,
13,
2,
2,
13,
2,
4,
13,
2,
13,
13,
13,
4,
13,
2,
2,
2,
2,
13,
13,
13,
13,
17,
2,
2,
13,
13,
17,
13,
4,
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,
4,
13,
10,
2,
13,
10,
2,
13,
10,
12,
13,
10,
2,
13
] | [
[
194,
2
],
[
194,
11
],
[
194,
12
],
[
194,
13
],
[
179,
15
],
[
197,
22
],
[
189,
27
],
[
186,
28
],
[
206,
30
],
[
189,
35
],
[
186,
36
],
[
170,
38
],
[
189,
43
],
[
186,
44
],
[
47,
46
],
[
189,
51
],
[
186,
52
],
[
57,
54
],
[
198,
55
],
[
46,
56
],
[
198,
60
],
[
46,
62
],
[
46,
64
],
[
180,
65
],
[
70,
67
],
[
207,
68
],
[
46,
69
],
[
207,
74
],
[
180,
76
],
[
46,
77
],
[
180,
79
],
[
46,
80
],
[
180,
81
],
[
86,
83
],
[
171,
84
],
[
46,
85
],
[
171,
89
],
[
46,
91
],
[
67,
93
],
[
207,
94
],
[
46,
95
],
[
180,
96
],
[
100,
100
],
[
102,
102
],
[
191,
104
],
[
108,
107
],
[
186,
115
],
[
174,
116
],
[
189,
120
],
[
195,
121
],
[
182,
124
],
[
174,
127
],
[
107,
128
],
[
200,
131
],
[
189,
134
],
[
195,
135
],
[
107,
136
],
[
176,
138
],
[
192,
141
],
[
177,
141
],
[
204,
144
],
[
183,
146
],
[
201,
147
],
[
183,
148
],
[
204,
150
],
[
186,
155
],
[
189,
156
],
[
183,
157
],
[
201,
158
],
[
186,
162
],
[
183,
163
],
[
180,
165
],
[
177,
168
],
[
192,
168
],
[
170,
171
],
[
194,
174
],
[
176,
177
],
[
179,
180
],
[
182,
183
],
[
194,
186
],
[
194,
189
],
[
191,
192
],
[
194,
195
],
[
197,
198
],
[
200,
201
],
[
206,
207
]
] | [
"H,W,A,B = map(int,input().split())\nP=10**9+7\nfac=[1]*(H+W)\ninv=[1]*(H+W)\nfinv=[1]*(H+W)\nfor n in range(2,H+W):\n fac[n]=fac[n-1]*n%P\n inv[n]=(-inv[P%n]*(P//n))%P\n finv[n]=finv[n-1]*inv[n]%P\ndef comb(n,k):return ((fac[n]*finv[k]%P)*finv[n-k])%P\nans=0\nfor i in range(1,min(W-B+1,H-A+1)):\n w=B+i-1\n h=H-A-i\n ans=(ans+comb(w+h,w)*comb(W+H-w-h-2,W-w-1))%P\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",
"P=10**9+7",
"P",
"10**9+7",
"10**9",
"10",
"9",
"7",
"fac=[1]*(H+W)",
"fac",
"[1]*(H+W)",
"[1]",
"1",
"H+W",
"H",
"W",
"inv=[1]*(H+W)",
"inv",
"[1]*(H+W)",
"[1]",
"1",
"H+W",
"H",
"W",
"finv=[1]*(H+W)",
"finv",
"[1]*(H+W)",
"[1]",
"1",
"H+W",
"H",
"W",
"for n in range(2,H+W):\n fac[n]=fac[n-1]*n%P\n inv[n]=(-inv[P%n]*(P//n))%P\n finv[n]=finv[n-1]*inv[n]%P",
"n",
"range(2,H+W)",
"range",
"2",
"H+W",
"H",
"W",
"fac[n]=fac[n-1]*n%P",
"fac[n]",
"fac",
"n",
"fac[n-1]*n%P",
"fac[n-1]*n",
"fac[n-1]",
"fac",
"n-1",
"n",
"1",
"n",
"P",
"inv[n]=(-inv[P%n]*(P//n))%P",
"inv[n]",
"inv",
"n",
"(-inv[P%n]*(P//n))%P",
"-inv[P%n]*(P//n)",
"-inv[P%n]",
"inv[P%n]",
"inv",
"P%n",
"P",
"n",
"P//n",
"P",
"n",
"P",
"finv[n]=finv[n-1]*inv[n]%P",
"finv[n]",
"finv",
"n",
"finv[n-1]*inv[n]%P",
"finv[n-1]*inv[n]",
"finv[n-1]",
"finv",
"n-1",
"n",
"1",
"inv[n]",
"inv",
"n",
"P",
"def comb(n,k):return ((fac[n]*finv[k]%P)*finv[n-k])%P",
"comb",
"n",
"n",
"k",
"k",
"ans=0",
"ans",
"0",
"for i in range(1,min(W-B+1,H-A+1)):\n w=B+i-1\n h=H-A-i\n ans=(ans+comb(w+h,w)*comb(W+H-w-h-2,W-w-1))%P",
"i",
"range(1,min(W-B+1,H-A+1))",
"range",
"1",
"min(W-B+1,H-A+1)",
"min",
"W-B+1",
"W-B",
"W",
"B",
"1",
"H-A+1",
"H-A",
"H",
"A",
"1",
"w=B+i-1",
"w",
"B+i-1",
"B+i",
"B",
"i",
"1",
"h=H-A-i",
"h",
"H-A-i",
"H-A",
"H",
"A",
"i",
"ans=(ans+comb(w+h,w)*comb(W+H-w-h-2,W-w-1))%P",
"ans",
"(ans+comb(w+h,w)*comb(W+H-w-h-2,W-w-1))%P",
"ans+comb(w+h,w)*comb(W+H-w-h-2,W-w-1)",
"ans",
"comb(w+h,w)*comb(W+H-w-h-2,W-w-1)",
"comb(w+h,w)",
"comb",
"w+h",
"w",
"h",
"w",
"comb(W+H-w-h-2,W-w-1)",
"comb",
"W+H-w-h-2",
"W+H-w-h",
"W+H-w",
"W+H",
"W",
"H",
"w",
"h",
"2",
"W-w-1",
"W-w",
"W",
"w",
"1",
"P",
"print(ans)",
"print",
"ans",
"finv=[1]*(H+W)",
"[1]*(H+W)",
"finv",
"B = map(int,input().split())",
"map(int,input().split())",
"B",
"ans=(ans+comb(w+h,w)*comb(W+H-w-h-2,W-w-1))%P",
"(ans+comb(w+h,w)*comb(W+H-w-h-2,W-w-1))%P",
"ans",
"P=10**9+7",
"10**9+7",
"P",
"w=B+i-1",
"B+i-1",
"w",
"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",
"ans=0",
"0",
"ans",
"A,B = map(int,input().split())",
"map(int,input().split())",
"A",
"fac=[1]*(H+W)",
"[1]*(H+W)",
"fac",
"h=H-A-i",
"H-A-i",
"h",
"def comb(n,k):return ((fac[n]*finv[k]%P)*finv[n-k])%P",
"def comb(n,k):return ((fac[n]*finv[k]%P)*finv[n-k])%P",
"comb",
"inv=[1]*(H+W)",
"[1]*(H+W)",
"inv"
] | H,W,A,B = map(int,input().split())
P=10**9+7
fac=[1]*(H+W)
inv=[1]*(H+W)
finv=[1]*(H+W)
for n in range(2,H+W):
fac[n]=fac[n-1]*n%P
inv[n]=(-inv[P%n]*(P//n))%P
finv[n]=finv[n-1]*inv[n]%P
def comb(n,k):return ((fac[n]*finv[k]%P)*finv[n-k])%P
ans=0
for i in range(1,min(W-B+1,H-A+1)):
w=B+i-1
h=H-A-i
ans=(ans+comb(w+h,w)*comb(W+H-w-h-2,W-w-1))%P
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,
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,
2,
13,
17,
13,
13,
4,
18,
13,
13,
2,
13,
2,
2,
18,
13,
2,
13,
13,
2,
13,
13,
13,
4,
18,
13,
13,
2,
2,
18,
13,
2,
13,
17,
18,
13,
13,
13,
12,
13,
14,
2,
13,
13,
29,
17,
14,
2,
2,
13,
17,
2,
13,
17,
29,
17,
29,
2,
2,
18,
13,
13,
2,
2,
18,
13,
13,
18,
13,
2,
13,
13,
13,
13,
23,
13,
23,
13,
0,
13,
17,
28,
13,
4,
13,
2,
13,
13,
0,
13,
2,
2,
4,
13,
2,
2,
13,
13,
17,
2,
13,
17,
4,
13,
2,
2,
2,
2,
2,
13,
17,
13,
13,
13,
17,
2,
2,
13,
13,
17,
13,
0,
13,
13,
4,
13,
13,
10,
4,
13,
10,
39,
13,
10,
4,
13,
10,
12,
13,
10,
4,
13,
10,
39,
13,
10,
39,
13,
10,
2,
13,
10,
4,
13,
10,
2,
13,
10,
13,
13,
10,
17,
13
] | [
[
205,
2
],
[
205,
11
],
[
205,
12
],
[
205,
13
],
[
208,
15
],
[
199,
22
],
[
184,
27
],
[
196,
32
],
[
38,
37
],
[
194,
43
],
[
206,
44
],
[
200,
48
],
[
200,
53
],
[
37,
55
],
[
37,
57
],
[
209,
58
],
[
185,
61
],
[
209,
64
],
[
185,
68
],
[
209,
70
],
[
37,
71
],
[
209,
73
],
[
37,
74
],
[
209,
75
],
[
197,
78
],
[
197,
83
],
[
37,
85
],
[
185,
88
],
[
37,
89
],
[
209,
90
],
[
128,
95
],
[
130,
96
],
[
128,
102
],
[
130,
105
],
[
200,
113
],
[
128,
114
],
[
197,
118
],
[
130,
119
],
[
197,
121
],
[
128,
123
],
[
130,
124
],
[
209,
125
],
[
209,
126
],
[
128,
128
],
[
130,
130
],
[
214,
132
],
[
136,
135
],
[
194,
139
],
[
188,
140
],
[
202,
142
],
[
191,
146
],
[
135,
149
],
[
182,
150
],
[
182,
153
],
[
191,
156
],
[
194,
162
],
[
135,
164
],
[
206,
165
],
[
182,
166
],
[
206,
170
],
[
182,
171
],
[
209,
173
],
[
211,
175
],
[
209,
176
],
[
212,
179
],
[
203,
179
],
[
215,
179
],
[
205,
182
],
[
184,
185
],
[
205,
188
],
[
205,
194
],
[
196,
197
],
[
199,
200
],
[
202,
203
],
[
205,
206
],
[
208,
209
],
[
209,
211
],
[
211,
212
],
[
214,
215
]
] | [
"h, w, a, b = map(int, input().split())\n\nmod = 10**9 + 7\nfac = [1, 1]\ninv = [1, 1]\nfinv = [1, 1]\nfor i in range(2, h+w+5):\n fac.append(fac[i-1] * i % mod)\n inv.append(mod - inv[mod%i] * (mod//i) % mod)\n finv.append(finv[i-1] * inv[i] % mod)\n\ndef nck(n, k):\n if n < k:\n return 0\n if n < 0 or k < 0:\n return 0\n return fac[n] * (finv[k] * finv[n-k] % mod) % mod\n\nans = 0\nfor i in range(h-a):\n ans += nck(i+b-1, b-1) * nck(h-1-i + w-b-1, w-b-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",
"mod = 10**9 + 7",
"mod",
"10**9 + 7",
"10**9",
"10",
"9",
"7",
"fac = [1, 1]",
"fac",
"[1, 1]",
"1",
"1",
"inv = [1, 1]",
"inv",
"[1, 1]",
"1",
"1",
"finv = [1, 1]",
"finv",
"[1, 1]",
"1",
"1",
"for i in range(2, h+w+5):\n fac.append(fac[i-1] * i % mod)\n inv.append(mod - inv[mod%i] * (mod//i) % mod)\n finv.append(finv[i-1] * inv[i] % mod)",
"i",
"range(2, h+w+5)",
"range",
"2",
"h+w+5",
"h+w",
"h",
"w",
"5",
"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(mod - inv[mod%i] * (mod//i) % mod)",
"inv.append",
"inv",
"append",
"mod - inv[mod%i] * (mod//i) % mod",
"mod",
"inv[mod%i] * (mod//i) % mod",
"inv[mod%i] * (mod//i)",
"inv[mod%i]",
"inv",
"mod%i",
"mod",
"i",
"mod//i",
"mod",
"i",
"mod",
"finv.append(finv[i-1] * inv[i] % mod)",
"finv.append",
"finv",
"append",
"finv[i-1] * inv[i] % mod",
"finv[i-1] * inv[i]",
"finv[i-1]",
"finv",
"i-1",
"i",
"1",
"inv[i]",
"inv",
"i",
"mod",
"def nck(n, k):\n if n < k:\n return 0\n if n < 0 or k < 0:\n return 0\n return fac[n] * (finv[k] * finv[n-k] % mod) % mod",
"nck",
"if n < k:\n return 0\n ",
"n < k",
"n",
"k",
"return 0",
"0",
"if n < 0 or k < 0:\n return 0\n ",
"n < 0 or k < 0",
"n < 0",
"n",
"0",
"k < 0",
"k",
"0",
"return 0",
"0",
"return fac[n] * (finv[k] * finv[n-k] % mod) % mod",
"fac[n] * (finv[k] * finv[n-k] % mod) % mod",
"fac[n] * (finv[k] * finv[n-k] % mod)",
"fac[n]",
"fac",
"n",
"finv[k] * finv[n-k] % mod",
"finv[k] * finv[n-k]",
"finv[k]",
"finv",
"k",
"finv[n-k]",
"finv",
"n-k",
"n",
"k",
"mod",
"mod",
"n",
"n",
"k",
"k",
"ans = 0",
"ans",
"0",
"for i in range(h-a):\n ans += nck(i+b-1, b-1) * nck(h-1-i + w-b-1, w-b-1) % mod\n ans %= mod",
"i",
"range(h-a)",
"range",
"h-a",
"h",
"a",
"ans += nck(i+b-1, b-1) * nck(h-1-i + w-b-1, w-b-1) % mod",
"ans",
"nck(i+b-1, b-1) * nck(h-1-i + w-b-1, w-b-1) % mod",
"nck(i+b-1, b-1) * nck(h-1-i + w-b-1, w-b-1)",
"nck(i+b-1, b-1)",
"nck",
"i+b-1",
"i+b",
"i",
"b",
"1",
"b-1",
"b",
"1",
"nck(h-1-i + w-b-1, w-b-1)",
"nck",
"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",
"ans %= mod",
"ans",
"mod",
"print(ans)",
"print",
"ans",
"b = map(int, input().split())",
"map(int, input().split())",
"b",
"inv = [1, 1]",
"[1, 1]",
"inv",
"a, b = map(int, input().split())",
"map(int, input().split())",
"a",
"def nck(n, k):\n if n < k:\n return 0\n if n < 0 or k < 0:\n return 0\n return fac[n] * (finv[k] * finv[n-k] % mod) % mod",
"def nck(n, k):\n if n < k:\n return 0\n if n < 0 or k < 0:\n return 0\n return fac[n] * (finv[k] * finv[n-k] % mod) % mod",
"nck",
"h, w, a, b = map(int, input().split())",
"map(int, input().split())",
"h",
"finv = [1, 1]",
"[1, 1]",
"finv",
"fac = [1, 1]",
"[1, 1]",
"fac",
"ans += nck(i+b-1, b-1) * nck(h-1-i + w-b-1, w-b-1) % mod",
"nck(i+b-1, b-1) * nck(h-1-i + w-b-1, w-b-1) % mod",
"ans",
"w, a, b = map(int, input().split())",
"map(int, input().split())",
"w",
"mod = 10**9 + 7",
"10**9 + 7",
"mod",
"ans %= mod",
"mod",
"ans",
"ans = 0",
"0",
"ans"
] | h, w, a, b = map(int, input().split())
mod = 10**9 + 7
fac = [1, 1]
inv = [1, 1]
finv = [1, 1]
for i in range(2, h+w+5):
fac.append(fac[i-1] * i % mod)
inv.append(mod - inv[mod%i] * (mod//i) % mod)
finv.append(finv[i-1] * inv[i] % mod)
def nck(n, k):
if n < k:
return 0
if n < 0 or k < 0:
return 0
return fac[n] * (finv[k] * finv[n-k] % mod) % mod
ans = 0
for i in range(h-a):
ans += nck(i+b-1, b-1) * nck(h-1-i + w-b-1, w-b-1) % mod
ans %= mod
print(ans) |
[
7,
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,
2,
13,
13,
17,
0,
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,
12,
13,
0,
13,
18,
13,
13,
14,
2,
39,
13,
13,
13,
0,
13,
18,
13,
39,
13,
13,
0,
13,
2,
4,
13,
18,
13,
13,
2,
13,
17,
13,
4,
13,
18,
13,
2,
13,
13,
2,
13,
17,
13,
29,
2,
2,
13,
13,
13,
23,
13,
23,
13,
0,
13,
17,
28,
13,
4,
13,
17,
2,
2,
13,
13,
17,
0,
13,
2,
2,
4,
13,
2,
2,
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,
4,
13,
10,
12,
13,
10,
2,
13,
10,
4,
13,
10,
2,
13,
10,
17,
13,
10,
4,
13,
10,
2,
13,
10,
17,
13,
10,
4,
13
] | [
[
171,
3
],
[
192,
10
],
[
192,
19
],
[
192,
20
],
[
192,
21
],
[
186,
23
],
[
175,
29
],
[
166,
30
],
[
180,
33
],
[
37,
36
],
[
175,
42
],
[
166,
43
],
[
49,
46
],
[
187,
47
],
[
36,
48
],
[
187,
52
],
[
36,
54
],
[
36,
56
],
[
172,
57
],
[
62,
61
],
[
187,
63
],
[
108,
64
],
[
181,
70
],
[
73,
72
],
[
181,
74
],
[
80,
79
],
[
187,
84
],
[
110,
85
],
[
172,
87
],
[
172,
89
],
[
187,
93
],
[
108,
95
],
[
110,
96
],
[
172,
98
],
[
172,
100
],
[
61,
104
],
[
79,
105
],
[
72,
105
],
[
172,
106
],
[
108,
108
],
[
110,
110
],
[
189,
112
],
[
116,
115
],
[
175,
121
],
[
184,
122
],
[
177,
125
],
[
169,
129
],
[
193,
132
],
[
115,
135
],
[
115,
138
],
[
169,
141
],
[
166,
145
],
[
193,
146
],
[
175,
149
],
[
115,
150
],
[
166,
153
],
[
193,
154
],
[
172,
156
],
[
178,
162
],
[
190,
162
],
[
172,
163
],
[
192,
166
],
[
171,
172
],
[
192,
175
],
[
177,
178
],
[
180,
181
],
[
192,
184
],
[
186,
187
],
[
189,
190
],
[
192,
193
]
] | [
"from math import factorial\n\nmod = 10**9 + 7\n\nH, W, A, B = map(int, input().split())\nmemo_fact = [1] * (H + W - 1)\nmemo_denometer = {}\nfor i in range(1, H + W - 1):\n memo_fact[i] = memo_fact[i - 1] * i % mod\n\ndef nCr(n,r):\n numerator = memo_fact[n]\n if (n, r) in memo_denometer:\n denometer = memo_denometer[(n, r)]\n else:\n denometer = pow(memo_fact[r], mod-2, mod) * pow(memo_fact[n-r], mod-2, mod)\n return (numerator * denometer) % mod\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))",
"from math import factorial",
"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",
"memo_fact = [1] * (H + W - 1)",
"memo_fact",
"[1] * (H + W - 1)",
"[1]",
"1",
"H + W - 1",
"H + W",
"H",
"W",
"1",
"memo_denometer = {}",
"memo_denometer",
"{}",
"for i in range(1, H + W - 1):\n memo_fact[i] = memo_fact[i - 1] * i % mod",
"i",
"range(1, H + W - 1)",
"range",
"1",
"H + W - 1",
"H + W",
"H",
"W",
"1",
"memo_fact[i] = memo_fact[i - 1] * i % mod",
"memo_fact[i]",
"memo_fact",
"i",
"memo_fact[i - 1] * i % mod",
"memo_fact[i - 1] * i",
"memo_fact[i - 1]",
"memo_fact",
"i - 1",
"i",
"1",
"i",
"mod",
"def nCr(n,r):\n numerator = memo_fact[n]\n if (n, r) in memo_denometer:\n denometer = memo_denometer[(n, r)]\n else:\n denometer = pow(memo_fact[r], mod-2, mod) * pow(memo_fact[n-r], mod-2, mod)\n return (numerator * denometer) % mod",
"nCr",
"numerator = memo_fact[n]",
"numerator",
"memo_fact[n]",
"memo_fact",
"n",
"if (n, r) in memo_denometer:\n denometer = memo_denometer[(n, r)]\n else:\n denometer = pow(memo_fact[r], mod-2, mod) * pow(memo_fact[n-r], mod-2, mod)\n ",
"(n, r) in memo_denometer",
"(n, r)",
"n",
"r",
"memo_denometer",
"denometer = memo_denometer[(n, r)]",
"denometer",
"memo_denometer[(n, r)]",
"memo_denometer",
"(n, r)",
"n",
"r",
"denometer = pow(memo_fact[r], mod-2, mod) * pow(memo_fact[n-r], mod-2, mod)",
"denometer",
"pow(memo_fact[r], mod-2, mod) * pow(memo_fact[n-r], mod-2, mod)",
"pow(memo_fact[r], mod-2, mod)",
"pow",
"memo_fact[r]",
"memo_fact",
"r",
"mod-2",
"mod",
"2",
"mod",
"pow(memo_fact[n-r], mod-2, mod)",
"pow",
"memo_fact[n-r]",
"memo_fact",
"n-r",
"n",
"r",
"mod-2",
"mod",
"2",
"mod",
"return (numerator * denometer) % mod",
"(numerator * denometer) % mod",
"numerator * denometer",
"numerator",
"denometer",
"mod",
"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",
"W, A, B = map(int, input().split())",
"map(int, input().split())",
"W",
"def nCr(n,r):\n numerator = memo_fact[n]\n if (n, r) in memo_denometer:\n denometer = memo_denometer[(n, r)]\n else:\n denometer = pow(memo_fact[r], mod-2, mod) * pow(memo_fact[n-r], mod-2, mod)\n return (numerator * denometer) % mod",
"def nCr(n,r):\n numerator = memo_fact[n]\n if (n, r) in memo_denometer:\n denometer = memo_denometer[(n, r)]\n else:\n denometer = pow(memo_fact[r], mod-2, mod) * pow(memo_fact[n-r], mod-2, mod)\n return (numerator * denometer) % mod",
"nCr",
"mod = 10**9 + 7",
"10**9 + 7",
"mod",
"H, W, A, B = map(int, input().split())",
"map(int, input().split())",
"H",
"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",
"memo_denometer = {}",
"{}",
"memo_denometer",
"A, B = map(int, input().split())",
"map(int, input().split())",
"A",
"memo_fact = [1] * (H + W - 1)",
"[1] * (H + W - 1)",
"memo_fact",
"result = 0",
"0",
"result",
"B = map(int, input().split())",
"map(int, input().split())",
"B"
] | from math import factorial
mod = 10**9 + 7
H, W, A, B = map(int, input().split())
memo_fact = [1] * (H + W - 1)
memo_denometer = {}
for i in range(1, H + W - 1):
memo_fact[i] = memo_fact[i - 1] * i % mod
def nCr(n,r):
numerator = memo_fact[n]
if (n, r) in memo_denometer:
denometer = memo_denometer[(n, r)]
else:
denometer = pow(memo_fact[r], mod-2, mod) * pow(memo_fact[n-r], mod-2, mod)
return (numerator * denometer) % mod
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,
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,
13,
18,
13,
2,
13,
17,
13,
0,
13,
2,
39,
17,
2,
2,
13,
13,
17,
0,
18,
13,
17,
4,
13,
18,
13,
17,
2,
2,
17,
17,
17,
13,
28,
13,
4,
13,
2,
2,
13,
13,
17,
17,
17,
0,
18,
13,
2,
13,
17,
2,
2,
18,
13,
13,
13,
13,
0,
13,
17,
28,
13,
4,
13,
13,
13,
0,
13,
2,
2,
13,
13,
17,
0,
13,
2,
2,
2,
18,
13,
2,
13,
13,
18,
13,
13,
18,
13,
13,
2,
2,
18,
13,
2,
2,
2,
2,
2,
13,
17,
13,
13,
17,
13,
18,
13,
2,
2,
13,
17,
13,
18,
13,
2,
2,
13,
17,
13,
0,
13,
13,
4,
13,
13,
10,
2,
13,
10,
2,
13,
10,
2,
13,
10,
4,
13,
10,
2,
13,
10,
17,
13,
10,
4,
13,
10,
2,
13,
10,
4,
13,
10,
4,
13,
10,
13,
13
] | [
[
203,
2
],
[
203,
11
],
[
203,
12
],
[
203,
13
],
[
179,
15
],
[
188,
22
],
[
186,
28
],
[
201,
29
],
[
35,
32
],
[
189,
33
],
[
38,
37
],
[
186,
43
],
[
201,
44
],
[
50,
47
],
[
189,
48
],
[
37,
49
],
[
37,
52
],
[
189,
54
],
[
37,
56
],
[
180,
58
],
[
182,
60
],
[
186,
66
],
[
201,
67
],
[
73,
70
],
[
183,
71
],
[
189,
76
],
[
180,
83
],
[
86,
85
],
[
186,
90
],
[
201,
91
],
[
101,
96
],
[
183,
97
],
[
85,
99
],
[
183,
104
],
[
85,
105
],
[
85,
106
],
[
180,
107
],
[
191,
109
],
[
113,
112
],
[
204,
115
],
[
201,
116
],
[
176,
118
],
[
186,
121
],
[
195,
122
],
[
197,
125
],
[
189,
130
],
[
112,
132
],
[
177,
133
],
[
183,
135
],
[
112,
136
],
[
183,
138
],
[
177,
139
],
[
189,
143
],
[
201,
149
],
[
112,
151
],
[
186,
152
],
[
177,
154
],
[
183,
156
],
[
186,
159
],
[
177,
161
],
[
183,
163
],
[
201,
166
],
[
112,
168
],
[
206,
170
],
[
180,
171
],
[
207,
174
],
[
198,
174
],
[
192,
174
],
[
176,
177
],
[
179,
180
],
[
182,
183
],
[
203,
186
],
[
188,
189
],
[
191,
192
],
[
203,
195
],
[
197,
198
],
[
203,
201
],
[
203,
204
],
[
180,
206
],
[
206,
207
]
] | [
"H,W,A,B=map(int,input().split())\nINF=10**9+7\nx=[0]*(H+W-1)\nx[0]=1\nfor i in range(1,H+W-1):\n x[i]=(i*x[i-1])%INF\ny=[0]*(H+W-1)\ny[-1]=pow(x[-1],10**9+5,INF)\nfor i in range(H+W-2,0,-1):\n y[i-1]=(y[i]*i)%INF\nans=0\nfor i in range(B,W):\n j=H-A-1\n ans+=(x[i+j]*y[i]*y[j])*(x[W-1-i+H-2-j]*y[H-2-j]*y[W-1-i])\n ans%=INF\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",
"INF=10**9+7",
"INF",
"10**9+7",
"10**9",
"10",
"9",
"7",
"x=[0]*(H+W-1)",
"x",
"[0]*(H+W-1)",
"[0]",
"0",
"H+W-1",
"H+W",
"H",
"W",
"1",
"x[0]=1",
"x[0]",
"x",
"0",
"1",
"for i in range(1,H+W-1):\n x[i]=(i*x[i-1])%INF",
"i",
"range(1,H+W-1)",
"range",
"1",
"H+W-1",
"H+W",
"H",
"W",
"1",
"x[i]=(i*x[i-1])%INF",
"x[i]",
"x",
"i",
"(i*x[i-1])%INF",
"i*x[i-1]",
"i",
"x[i-1]",
"x",
"i-1",
"i",
"1",
"INF",
"y=[0]*(H+W-1)",
"y",
"[0]*(H+W-1)",
"[0]",
"0",
"H+W-1",
"H+W",
"H",
"W",
"1",
"y[-1]=pow(x[-1],10**9+5,INF)",
"y[-1]",
"y",
"-1",
"pow(x[-1],10**9+5,INF)",
"pow",
"x[-1]",
"x",
"-1",
"10**9+5",
"10**9",
"10",
"9",
"5",
"INF",
"for i in range(H+W-2,0,-1):\n y[i-1]=(y[i]*i)%INF",
"i",
"range(H+W-2,0,-1)",
"range",
"H+W-2",
"H+W",
"H",
"W",
"2",
"0",
"-1",
"y[i-1]=(y[i]*i)%INF",
"y[i-1]",
"y",
"i-1",
"i",
"1",
"(y[i]*i)%INF",
"y[i]*i",
"y[i]",
"y",
"i",
"i",
"INF",
"ans=0",
"ans",
"0",
"for i in range(B,W):\n j=H-A-1\n ans+=(x[i+j]*y[i]*y[j])*(x[W-1-i+H-2-j]*y[H-2-j]*y[W-1-i])\n ans%=INF",
"i",
"range(B,W)",
"range",
"B",
"W",
"j=H-A-1",
"j",
"H-A-1",
"H-A",
"H",
"A",
"1",
"ans+=(x[i+j]*y[i]*y[j])*(x[W-1-i+H-2-j]*y[H-2-j]*y[W-1-i])",
"ans",
"(x[i+j]*y[i]*y[j])*(x[W-1-i+H-2-j]*y[H-2-j]*y[W-1-i])",
"x[i+j]*y[i]*y[j]",
"x[i+j]*y[i]",
"x[i+j]",
"x",
"i+j",
"i",
"j",
"y[i]",
"y",
"i",
"y[j]",
"y",
"j",
"x[W-1-i+H-2-j]*y[H-2-j]*y[W-1-i]",
"x[W-1-i+H-2-j]*y[H-2-j]",
"x[W-1-i+H-2-j]",
"x",
"W-1-i+H-2-j",
"W-1-i+H-2",
"W-1-i+H",
"W-1-i",
"W-1",
"W",
"1",
"i",
"H",
"2",
"j",
"y[H-2-j]",
"y",
"H-2-j",
"H-2",
"H",
"2",
"j",
"y[W-1-i]",
"y",
"W-1-i",
"W-1",
"W",
"1",
"i",
"ans%=INF",
"ans",
"INF",
"print(ans)",
"print",
"ans",
"j=H-A-1",
"H-A-1",
"j",
"INF=10**9+7",
"10**9+7",
"INF",
"y=[0]*(H+W-1)",
"[0]*(H+W-1)",
"y",
"H,W,A,B=map(int,input().split())",
"map(int,input().split())",
"H",
"x=[0]*(H+W-1)",
"[0]*(H+W-1)",
"x",
"ans=0",
"0",
"ans",
"A,B=map(int,input().split())",
"map(int,input().split())",
"A",
"ans+=(x[i+j]*y[i]*y[j])*(x[W-1-i+H-2-j]*y[H-2-j]*y[W-1-i])",
"(x[i+j]*y[i]*y[j])*(x[W-1-i+H-2-j]*y[H-2-j]*y[W-1-i])",
"ans",
"W,A,B=map(int,input().split())",
"map(int,input().split())",
"W",
"B=map(int,input().split())",
"map(int,input().split())",
"B",
"ans%=INF",
"INF",
"ans"
] | H,W,A,B=map(int,input().split())
INF=10**9+7
x=[0]*(H+W-1)
x[0]=1
for i in range(1,H+W-1):
x[i]=(i*x[i-1])%INF
y=[0]*(H+W-1)
y[-1]=pow(x[-1],10**9+5,INF)
for i in range(H+W-2,0,-1):
y[i-1]=(y[i]*i)%INF
ans=0
for i in range(B,W):
j=H-A-1
ans+=(x[i+j]*y[i]*y[j])*(x[W-1-i+H-2-j]*y[H-2-j]*y[W-1-i])
ans%=INF
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,
41,
28,
13,
4,
13,
13,
4,
17,
0,
13,
13,
41,
28,
13,
4,
13,
13,
4,
17,
0,
13,
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,
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,
2,
2,
13,
13,
17,
2,
13,
17,
28,
13,
4,
13,
13,
0,
13,
2,
2,
4,
13,
2,
2,
2,
13,
13,
13,
17,
13,
4,
13,
2,
2,
2,
13,
13,
13,
17,
2,
13,
17,
13,
0,
13,
13,
4,
13,
13,
10,
4,
13,
10,
2,
13,
10,
13,
13,
10,
12,
13,
10,
4,
13,
10,
4,
13,
10,
2,
13,
10,
4,
13,
10,
2,
13,
10,
13,
13,
10,
13,
13,
10,
4,
13
] | [
[
188,
2
],
[
188,
11
],
[
188,
12
],
[
188,
13
],
[
158,
15
],
[
173,
22
],
[
171,
24
],
[
189,
25
],
[
29,
28
],
[
174,
31
],
[
182,
35
],
[
40,
39
],
[
174,
42
],
[
161,
46
],
[
50,
49
],
[
174,
53
],
[
58,
55
],
[
183,
56
],
[
49,
57
],
[
183,
61
],
[
49,
63
],
[
49,
65
],
[
159,
66
],
[
71,
68
],
[
162,
69
],
[
49,
70
],
[
55,
73
],
[
183,
74
],
[
49,
75
],
[
159,
77
],
[
159,
79
],
[
183,
88
],
[
101,
89
],
[
162,
91
],
[
103,
92
],
[
159,
93
],
[
162,
95
],
[
101,
97
],
[
103,
98
],
[
159,
99
],
[
101,
101
],
[
103,
103
],
[
167,
105
],
[
165,
107
],
[
171,
110
],
[
189,
111
],
[
171,
114
],
[
118,
117
],
[
156,
120
],
[
179,
122
],
[
165,
126
],
[
171,
130
],
[
177,
131
],
[
117,
132
],
[
117,
134
],
[
165,
136
],
[
177,
140
],
[
189,
141
],
[
117,
142
],
[
177,
145
],
[
159,
147
],
[
185,
149
],
[
159,
150
],
[
186,
153
],
[
180,
153
],
[
168,
153
],
[
188,
156
],
[
158,
159
],
[
161,
162
],
[
167,
168
],
[
188,
171
],
[
173,
174
],
[
188,
177
],
[
179,
180
],
[
182,
183
],
[
159,
185
],
[
185,
186
],
[
188,
189
]
] | [
"h, w, a, b = map(int, input().split())\nmod = 10 ** 9 + 7\nn = h + w\n\nf = [1 for _ in range(n)]\nf_inv = [1 for _ in range(n)]\nfor i in range(1, n):\n f[i] = f[i-1] * i % mod\n f_inv[i] = pow(f[i], mod-2, mod)\n\n\ndef comb(n, k):\n return (f[n] * f_inv[k] % mod) * f_inv[n-k] % mod\n\nans = comb(h+w-2, h-1)\nfor i in range(b):\n ans -= comb(h-a+i-1, i) * comb(a+w-i-2, 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",
"mod = 10 ** 9 + 7",
"mod",
"10 ** 9 + 7",
"10 ** 9",
"10",
"9",
"7",
"n = h + w",
"n",
"h + w",
"h",
"w",
"1 for _ in range(n)",
"for _ in range(n)",
"_",
"range(n)",
"range",
"n",
"for _ in range(n)",
"1",
"f = [1 for _ in range(n)]",
"f",
"[1 for _ in range(n)]",
"1 for _ in range(n)",
"for _ in range(n)",
"_",
"range(n)",
"range",
"n",
"for _ in range(n)",
"1",
"f_inv = [1 for _ in range(n)]",
"f_inv",
"[1 for _ in range(n)]",
"for i in range(1, n):\n f[i] = f[i-1] * i % mod\n f_inv[i] = pow(f[i], mod-2, mod)",
"i",
"range(1, n)",
"range",
"1",
"n",
"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",
"f_inv[i] = pow(f[i], mod-2, mod)",
"f_inv[i]",
"f_inv",
"i",
"pow(f[i], mod-2, mod)",
"pow",
"f[i]",
"f",
"i",
"mod-2",
"mod",
"2",
"mod",
"def comb(n, k):\n return (f[n] * f_inv[k] % mod) * f_inv[n-k] % mod",
"comb",
"return (f[n] * f_inv[k] % mod) * f_inv[n-k] % mod",
"(f[n] * f_inv[k] % mod) * f_inv[n-k] % mod",
"(f[n] * f_inv[k] % mod) * f_inv[n-k]",
"f[n] * f_inv[k] % mod",
"f[n] * f_inv[k]",
"f[n]",
"f",
"n",
"f_inv[k]",
"f_inv",
"k",
"mod",
"f_inv[n-k]",
"f_inv",
"n-k",
"n",
"k",
"mod",
"n",
"n",
"k",
"k",
"ans = comb(h+w-2, h-1)",
"ans",
"comb(h+w-2, h-1)",
"comb",
"h+w-2",
"h+w",
"h",
"w",
"2",
"h-1",
"h",
"1",
"for i in range(b):\n ans -= comb(h-a+i-1, i) * comb(a+w-i-2, a-1) % mod\n ans %= mod",
"i",
"range(b)",
"range",
"b",
"ans -= comb(h-a+i-1, i) * comb(a+w-i-2, a-1) % mod",
"ans",
"comb(h-a+i-1, i) * comb(a+w-i-2, a-1) % mod",
"comb(h-a+i-1, i) * comb(a+w-i-2, a-1)",
"comb(h-a+i-1, i)",
"comb",
"h-a+i-1",
"h-a+i",
"h-a",
"h",
"a",
"i",
"1",
"i",
"comb(a+w-i-2, a-1)",
"comb",
"a+w-i-2",
"a+w-i",
"a+w",
"a",
"w",
"i",
"2",
"a-1",
"a",
"1",
"mod",
"ans %= mod",
"ans",
"mod",
"print(ans)",
"print",
"ans",
"b = map(int, input().split())",
"map(int, input().split())",
"b",
"mod = 10 ** 9 + 7",
"10 ** 9 + 7",
"mod",
"f_inv = [1 for _ in range(n)]",
"[1 for _ in range(n)]",
"f_inv",
"def comb(n, k):\n return (f[n] * f_inv[k] % mod) * f_inv[n-k] % mod",
"def comb(n, k):\n return (f[n] * f_inv[k] % mod) * f_inv[n-k] % mod",
"comb",
"ans = comb(h+w-2, h-1)",
"comb(h+w-2, h-1)",
"ans",
"h, w, a, b = map(int, input().split())",
"map(int, input().split())",
"h",
"n = h + w",
"h + w",
"n",
"a, b = map(int, input().split())",
"map(int, input().split())",
"a",
"ans -= comb(h-a+i-1, i) * comb(a+w-i-2, a-1) % mod",
"comb(h-a+i-1, i) * comb(a+w-i-2, a-1) % mod",
"ans",
"f = [1 for _ in range(n)]",
"[1 for _ in range(n)]",
"f",
"ans %= mod",
"mod",
"ans",
"w, a, b = map(int, input().split())",
"map(int, input().split())",
"w"
] | h, w, a, b = map(int, input().split())
mod = 10 ** 9 + 7
n = h + w
f = [1 for _ in range(n)]
f_inv = [1 for _ in range(n)]
for i in range(1, n):
f[i] = f[i-1] * i % mod
f_inv[i] = pow(f[i], mod-2, mod)
def comb(n, k):
return (f[n] * f_inv[k] % mod) * f_inv[n-k] % mod
ans = comb(h+w-2, h-1)
for i in range(b):
ans -= comb(h-a+i-1, i) * comb(a+w-i-2, a-1) % mod
ans %= mod
print(ans) |
[
7,
0,
13,
2,
2,
17,
17,
17,
0,
13,
2,
2,
17,
2,
17,
17,
17,
0,
13,
39,
17,
17,
0,
13,
39,
17,
17,
28,
13,
4,
13,
17,
2,
13,
17,
0,
13,
2,
2,
18,
13,
17,
13,
13,
4,
18,
13,
13,
13,
4,
18,
13,
13,
4,
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,
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,
2,
2,
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,
13,
13,
13,
13,
4,
13,
13,
10,
4,
13,
10,
2,
13,
10,
2,
13,
10,
39,
13,
10,
4,
13,
10,
2,
13,
10,
4,
13,
10,
39,
13,
10,
12,
13,
10,
4,
13,
10,
17,
13,
10,
2,
13
] | [
[
180,
2
],
[
153,
9
],
[
156,
18
],
[
168,
23
],
[
29,
28
],
[
154,
33
],
[
150,
36
],
[
157,
40
],
[
28,
42
],
[
181,
43
],
[
157,
46
],
[
151,
48
],
[
169,
51
],
[
151,
55
],
[
181,
57
],
[
181,
59
],
[
157,
67
],
[
79,
68
],
[
169,
70
],
[
81,
71
],
[
169,
73
],
[
79,
75
],
[
81,
76
],
[
83,
77
],
[
79,
79
],
[
81,
81
],
[
83,
83
],
[
174,
85
],
[
174,
94
],
[
174,
95
],
[
174,
96
],
[
177,
98
],
[
102,
101
],
[
160,
107
],
[
166,
108
],
[
162,
111
],
[
178,
114
],
[
163,
114
],
[
172,
117
],
[
101,
120
],
[
175,
121
],
[
101,
124
],
[
181,
126
],
[
172,
128
],
[
160,
133
],
[
101,
134
],
[
148,
135
],
[
175,
136
],
[
160,
139
],
[
101,
140
],
[
181,
141
],
[
181,
142
],
[
163,
145
],
[
178,
145
],
[
174,
148
],
[
150,
151
],
[
153,
154
],
[
156,
157
],
[
174,
160
],
[
162,
163
],
[
174,
166
],
[
168,
169
],
[
174,
175
],
[
177,
178
],
[
180,
181
]
] | [
"#cmb\nmod=10**9+7\nMAX=2*10**5+100\n\ng1=[1,1]\ng2=[1,1]\nfor i in range(2,MAX+1):\n num_1=g1[-1]*i%mod\n g1.append(num_1)\n g2.append(pow(num_1,mod-2,mod))\n \ndef cmb(n,r,MOD):\n return g1[n]*g2[r]*g2[n-r]%MOD\n\nh,w,a,b=map(int,input().split())\nans=0\nfor i in range(1,h-a+1):\n ans=(ans+cmb(i+b-2,i-1,mod)*cmb(h-i+w-b-1,h-i,mod))%mod\n\nprint(ans)",
"mod=10**9+7",
"mod",
"10**9+7",
"10**9",
"10",
"9",
"7",
"MAX=2*10**5+100",
"MAX",
"2*10**5+100",
"2*10**5",
"2",
"10**5",
"10",
"5",
"100",
"g1=[1,1]",
"g1",
"[1,1]",
"1",
"1",
"g2=[1,1]",
"g2",
"[1,1]",
"1",
"1",
"for i in range(2,MAX+1):\n num_1=g1[-1]*i%mod\n g1.append(num_1)\n g2.append(pow(num_1,mod-2,mod))\n ",
"i",
"range(2,MAX+1)",
"range",
"2",
"MAX+1",
"MAX",
"1",
"num_1=g1[-1]*i%mod",
"num_1",
"g1[-1]*i%mod",
"g1[-1]*i",
"g1[-1]",
"g1",
"-1",
"i",
"mod",
"g1.append(num_1)",
"g1.append",
"g1",
"append",
"num_1",
"g2.append(pow(num_1,mod-2,mod))",
"g2.append",
"g2",
"append",
"pow(num_1,mod-2,mod)",
"pow",
"num_1",
"mod-2",
"mod",
"2",
"mod",
"def cmb(n,r,MOD):\n return g1[n]*g2[r]*g2[n-r]%MOD",
"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",
"MOD",
"MOD",
"h,w,a,b=map(int,input().split())",
"h",
"map(int,input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"w",
"a",
"b",
"ans=0",
"ans",
"0",
"for i in range(1,h-a+1):\n ans=(ans+cmb(i+b-2,i-1,mod)*cmb(h-i+w-b-1,h-i,mod))%mod",
"i",
"range(1,h-a+1)",
"range",
"1",
"h-a+1",
"h-a",
"h",
"a",
"1",
"ans=(ans+cmb(i+b-2,i-1,mod)*cmb(h-i+w-b-1,h-i,mod))%mod",
"ans",
"(ans+cmb(i+b-2,i-1,mod)*cmb(h-i+w-b-1,h-i,mod))%mod",
"ans+cmb(i+b-2,i-1,mod)*cmb(h-i+w-b-1,h-i,mod)",
"ans",
"cmb(i+b-2,i-1,mod)*cmb(h-i+w-b-1,h-i,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,h-i,mod)",
"cmb",
"h-i+w-b-1",
"h-i+w-b",
"h-i+w",
"h-i",
"h",
"i",
"w",
"b",
"1",
"h-i",
"h",
"i",
"mod",
"mod",
"print(ans)",
"print",
"ans",
"w,a,b=map(int,input().split())",
"map(int,input().split())",
"w",
"num_1=g1[-1]*i%mod",
"g1[-1]*i%mod",
"num_1",
"MAX=2*10**5+100",
"2*10**5+100",
"MAX",
"g1=[1,1]",
"[1,1]",
"g1",
"h,w,a,b=map(int,input().split())",
"map(int,input().split())",
"h",
"ans=(ans+cmb(i+b-2,i-1,mod)*cmb(h-i+w-b-1,h-i,mod))%mod",
"(ans+cmb(i+b-2,i-1,mod)*cmb(h-i+w-b-1,h-i,mod))%mod",
"ans",
"a,b=map(int,input().split())",
"map(int,input().split())",
"a",
"g2=[1,1]",
"[1,1]",
"g2",
"def cmb(n,r,MOD):\n return g1[n]*g2[r]*g2[n-r]%MOD",
"def cmb(n,r,MOD):\n return g1[n]*g2[r]*g2[n-r]%MOD",
"cmb",
"b=map(int,input().split())",
"map(int,input().split())",
"b",
"ans=0",
"0",
"ans",
"mod=10**9+7",
"10**9+7",
"mod"
] | #cmb
mod=10**9+7
MAX=2*10**5+100
g1=[1,1]
g2=[1,1]
for i in range(2,MAX+1):
num_1=g1[-1]*i%mod
g1.append(num_1)
g2.append(pow(num_1,mod-2,mod))
def cmb(n,r,MOD):
return g1[n]*g2[r]*g2[n-r]%MOD
h,w,a,b=map(int,input().split())
ans=0
for i in range(1,h-a+1):
ans=(ans+cmb(i+b-2,i-1,mod)*cmb(h-i+w-b-1,h-i,mod))%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,
2,
13,
13,
17,
4,
18,
13,
13,
2,
2,
18,
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,
18,
13,
17,
17,
12,
13,
14,
2,
40,
13,
17,
2,
13,
17,
29,
17,
14,
2,
2,
13,
17,
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,
2,
13,
17,
2,
13,
17,
0,
13,
2,
2,
13,
13,
2,
2,
13,
13,
17,
14,
2,
2,
13,
17,
2,
13,
17,
3,
0,
13,
2,
2,
13,
2,
2,
4,
13,
2,
2,
13,
13,
17,
2,
13,
17,
4,
13,
2,
2,
2,
13,
13,
13,
13,
2,
13,
13,
13,
13,
4,
13,
13,
10,
4,
13,
10,
4,
13,
10,
2,
13,
10,
4,
13,
10,
17,
13,
10,
2,
13,
10,
2,
13,
10,
2,
13,
10,
4,
13,
10,
39,
13,
10,
12,
13
] | [
[
234,
2
],
[
234,
11
],
[
234,
12
],
[
234,
13
],
[
216,
15
],
[
237,
22
],
[
27,
26
],
[
220,
32
],
[
214,
33
],
[
238,
37
],
[
238,
42
],
[
26,
44
],
[
217,
45
],
[
228,
47
],
[
220,
53
],
[
214,
54
],
[
62,
57
],
[
229,
58
],
[
220,
60
],
[
214,
61
],
[
238,
65
],
[
220,
67
],
[
214,
68
],
[
217,
70
],
[
217,
72
],
[
75,
74
],
[
220,
78
],
[
214,
79
],
[
88,
83
],
[
229,
84
],
[
74,
86
],
[
229,
91
],
[
74,
92
],
[
74,
93
],
[
217,
94
],
[
99,
96
],
[
229,
97
],
[
139,
105
],
[
141,
108
],
[
139,
115
],
[
141,
118
],
[
238,
127
],
[
139,
128
],
[
229,
130
],
[
141,
131
],
[
229,
133
],
[
139,
135
],
[
141,
136
],
[
217,
137
],
[
139,
139
],
[
141,
141
],
[
222,
143
],
[
147,
146
],
[
211,
150
],
[
214,
153
],
[
231,
156
],
[
220,
159
],
[
235,
160
],
[
146,
163
],
[
211,
164
],
[
146,
169
],
[
232,
172
],
[
225,
176
],
[
223,
179
],
[
226,
179
],
[
241,
183
],
[
232,
186
],
[
146,
187
],
[
146,
190
],
[
241,
193
],
[
220,
197
],
[
214,
198
],
[
232,
199
],
[
146,
200
],
[
214,
202
],
[
146,
203
],
[
217,
204
],
[
217,
205
],
[
226,
208
],
[
223,
208
],
[
234,
211
],
[
234,
214
],
[
216,
217
],
[
234,
220
],
[
222,
223
],
[
225,
226
],
[
228,
229
],
[
231,
232
],
[
234,
235
],
[
237,
238
]
] | [
"H,W,A,B = map(int, input().split())\n\nmod = 10**9+7\nfact = [1]\nfor i in range(1, H+W+1):\n fact.append ( fact[-1] * i % mod)\n\ninv_fact = [0] * (H+W+1)\ninv_fact[H+W] = pow(fact[H+W], mod-2, mod)\n\nfor i in range(H+W, 1, -1):\n inv_fact[i-1] = inv_fact[i] * i % mod\n\ninv_fact[0] = 1\n\ndef C(a,b):\n if a <= 0 or b < 0:\n return 0\n if a==0 or b == 0:\n return 1\n return fact[a] * inv_fact[b] * inv_fact[a-b] % mod\n\nans = 0\nfor w in range(B+1, W+1):\n h = H-A - (w-B-1)\n if w == 0 or h == 0:\n break\n ans = (ans + C(h+w-2, w-1) * C(H+W-h-w, W-w) % mod) % mod\nprint(ans)",
"H,W,A,B = map(int, input().split())",
"H",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"W",
"A",
"B",
"mod = 10**9+7",
"mod",
"10**9+7",
"10**9",
"10",
"9",
"7",
"fact = [1]",
"fact",
"[1]",
"1",
"for i in range(1, H+W+1):\n fact.append ( fact[-1] * i % mod)",
"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 = [0] * (H+W+1)",
"inv_fact",
"[0] * (H+W+1)",
"[0]",
"0",
"H+W+1",
"H+W",
"H",
"W",
"1",
"inv_fact[H+W] = pow(fact[H+W], mod-2, mod)",
"inv_fact[H+W]",
"inv_fact",
"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, 1, -1):\n inv_fact[i-1] = inv_fact[i] * i % mod",
"i",
"range(H+W, 1, -1)",
"range",
"H+W",
"H",
"W",
"1",
"-1",
"inv_fact[i-1] = inv_fact[i] * i % mod",
"inv_fact[i-1]",
"inv_fact",
"i-1",
"i",
"1",
"inv_fact[i] * i % mod",
"inv_fact[i] * i",
"inv_fact[i]",
"inv_fact",
"i",
"i",
"mod",
"inv_fact[0] = 1",
"inv_fact[0]",
"inv_fact",
"0",
"1",
"def C(a,b):\n if a <= 0 or b < 0:\n return 0\n if a==0 or b == 0:\n return 1\n return fact[a] * inv_fact[b] * inv_fact[a-b] % mod",
"C",
"if a <= 0 or b < 0:\n return 0\n ",
"a <= 0 or b < 0",
"a <= 0",
"a",
"0",
"b < 0",
"b",
"0",
"return 0",
"0",
"if a==0 or b == 0:\n return 1\n ",
"a==0 or b == 0",
"a==0",
"a",
"0",
"b == 0",
"b",
"0",
"return 1",
"1",
"return fact[a] * inv_fact[b] * inv_fact[a-b] % mod",
"fact[a] * inv_fact[b] * inv_fact[a-b] % mod",
"fact[a] * inv_fact[b] * inv_fact[a-b]",
"fact[a] * inv_fact[b]",
"fact[a]",
"fact",
"a",
"inv_fact[b]",
"inv_fact",
"b",
"inv_fact[a-b]",
"inv_fact",
"a-b",
"a",
"b",
"mod",
"a",
"a",
"b",
"b",
"ans = 0",
"ans",
"0",
"for w in range(B+1, W+1):\n h = H-A - (w-B-1)\n if w == 0 or h == 0:\n break\n ans = (ans + C(h+w-2, w-1) * C(H+W-h-w, W-w) % mod) % mod",
"w",
"range(B+1, W+1)",
"range",
"B+1",
"B",
"1",
"W+1",
"W",
"1",
"h = H-A - (w-B-1)",
"h",
"H-A - (w-B-1)",
"H-A",
"H",
"A",
"w-B-1",
"w-B",
"w",
"B",
"1",
"if w == 0 or h == 0:\n break\n ",
"w == 0 or h == 0",
"w == 0",
"w",
"0",
"h == 0",
"h",
"0",
"break",
"ans = (ans + C(h+w-2, w-1) * C(H+W-h-w, W-w) % mod) % mod",
"ans",
"(ans + C(h+w-2, w-1) * C(H+W-h-w, W-w) % mod) % mod",
"ans + C(h+w-2, w-1) * C(H+W-h-w, W-w) % mod",
"ans",
"C(h+w-2, w-1) * C(H+W-h-w, W-w) % mod",
"C(h+w-2, w-1) * C(H+W-h-w, W-w)",
"C(h+w-2, w-1)",
"C",
"h+w-2",
"h+w",
"h",
"w",
"2",
"w-1",
"w",
"1",
"C(H+W-h-w, W-w)",
"C",
"H+W-h-w",
"H+W-h",
"H+W",
"H",
"W",
"h",
"w",
"W-w",
"W",
"w",
"mod",
"mod",
"print(ans)",
"print",
"ans",
"B = map(int, input().split())",
"map(int, input().split())",
"B",
"W,A,B = map(int, input().split())",
"map(int, input().split())",
"W",
"mod = 10**9+7",
"10**9+7",
"mod",
"H,W,A,B = map(int, input().split())",
"map(int, input().split())",
"H",
"ans = 0",
"0",
"ans",
"ans = (ans + C(h+w-2, w-1) * C(H+W-h-w, W-w) % mod) % mod",
"(ans + C(h+w-2, w-1) * C(H+W-h-w, W-w) % mod) % mod",
"ans",
"inv_fact = [0] * (H+W+1)",
"[0] * (H+W+1)",
"inv_fact",
"h = H-A - (w-B-1)",
"H-A - (w-B-1)",
"h",
"A,B = map(int, input().split())",
"map(int, input().split())",
"A",
"fact = [1]",
"[1]",
"fact",
"def C(a,b):\n if a <= 0 or b < 0:\n return 0\n if a==0 or b == 0:\n return 1\n return fact[a] * inv_fact[b] * inv_fact[a-b] % mod",
"def C(a,b):\n if a <= 0 or b < 0:\n return 0\n if a==0 or b == 0:\n return 1\n return fact[a] * inv_fact[b] * inv_fact[a-b] % mod",
"C"
] | 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 = [0] * (H+W+1)
inv_fact[H+W] = pow(fact[H+W], mod-2, mod)
for i in range(H+W, 1, -1):
inv_fact[i-1] = inv_fact[i] * i % mod
inv_fact[0] = 1
def C(a,b):
if a <= 0 or b < 0:
return 0
if a==0 or b == 0:
return 1
return fact[a] * inv_fact[b] * inv_fact[a-b] % mod
ans = 0
for w in range(B+1, W+1):
h = H-A - (w-B-1)
if w == 0 or h == 0:
break
ans = (ans + C(h+w-2, w-1) * C(H+W-h-w, W-w) % mod) % mod
print(ans) |
[
7,
15,
13,
15,
0,
13,
2,
2,
17,
17,
17,
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,
13,
4,
18,
13,
13,
4,
13,
18,
13,
13,
2,
13,
17,
13,
29,
39,
13,
13,
23,
13,
12,
13,
14,
2,
13,
13,
29,
17,
14,
2,
2,
13,
17,
2,
13,
17,
29,
17,
29,
2,
2,
18,
18,
13,
17,
13,
2,
2,
18,
18,
13,
17,
13,
18,
18,
13,
17,
2,
13,
13,
13,
13,
23,
13,
23,
13,
23,
13,
12,
13,
29,
2,
4,
13,
13,
4,
13,
13,
23,
13,
23,
13,
12,
13,
14,
2,
13,
17,
29,
13,
29,
4,
13,
13,
2,
13,
13,
23,
13,
23,
13,
12,
13,
0,
13,
4,
13,
13,
13,
29,
4,
13,
2,
2,
13,
13,
13,
23,
13,
23,
13,
12,
13,
29,
2,
13,
13,
23,
13,
12,
13,
0,
13,
4,
13,
4,
13,
13,
4,
18,
4,
13,
13,
13,
13,
13,
0,
13,
4,
13,
2,
13,
13,
0,
13,
17,
28,
13,
4,
13,
13,
13,
0,
13,
2,
4,
13,
2,
2,
2,
13,
17,
13,
13,
13,
13,
4,
13,
2,
2,
13,
17,
2,
2,
13,
17,
13,
2,
2,
13,
17,
13,
13,
0,
13,
4,
13,
13,
4,
13,
4,
18,
17,
13,
13,
14,
2,
13,
17,
4,
13,
10,
12,
13,
10,
12,
13,
10,
2,
13,
10,
12,
13,
10,
12,
13,
10,
12,
13,
10,
12,
13,
10,
12,
13
] | [
[
259,
5
],
[
15,
14
],
[
19,
18
],
[
23,
22
],
[
60,
27
],
[
14,
31
],
[
14,
36
],
[
22,
38
],
[
22,
40
],
[
260,
41
],
[
18,
44
],
[
14,
49
],
[
22,
50
],
[
260,
52
],
[
260,
54
],
[
60,
60
],
[
104,
65
],
[
106,
66
],
[
104,
72
],
[
106,
75
],
[
108,
84
],
[
104,
86
],
[
108,
91
],
[
106,
93
],
[
108,
96
],
[
104,
99
],
[
106,
100
],
[
260,
101
],
[
260,
102
],
[
104,
104
],
[
106,
106
],
[
108,
108
],
[
120,
115
],
[
122,
118
],
[
120,
120
],
[
122,
122
],
[
141,
127
],
[
139,
130
],
[
141,
134
],
[
139,
136
],
[
141,
137
],
[
139,
139
],
[
141,
141
],
[
146,
145
],
[
272,
147
],
[
159,
148
],
[
161,
149
],
[
159,
155
],
[
145,
156
],
[
161,
157
],
[
159,
159
],
[
161,
161
],
[
169,
166
],
[
260,
167
],
[
169,
169
],
[
174,
173
],
[
174,
184
],
[
174,
185
],
[
174,
186
],
[
189,
188
],
[
263,
190
],
[
173,
192
],
[
184,
193
],
[
196,
195
],
[
199,
198
],
[
186,
201
],
[
184,
202
],
[
205,
204
],
[
266,
207
],
[
173,
211
],
[
185,
213
],
[
198,
214
],
[
198,
215
],
[
188,
216
],
[
266,
218
],
[
185,
221
],
[
184,
225
],
[
198,
227
],
[
184,
230
],
[
198,
232
],
[
188,
233
],
[
236,
235
],
[
257,
237
],
[
204,
238
],
[
195,
238
],
[
235,
245
],
[
269,
251
],
[
259,
260
]
] | [
"# coding:UTF-8\nimport sys\nfrom math import factorial\n\nMOD = 10 ** 9 + 7\n\ndef combInit(n):\n fact = [1]\n finv = [1]\n for i in range(1, n + 1):\n fact.append(fact[i - 1] * i % MOD)\n finv.append(pow(fact[i], MOD - 2, MOD))\n return [fact, finv]\n\ndef comb(n, k, f):\n if n < k:\n return 0\n elif n < 0 or k < 0:\n return 0\n else:\n return f[0][n] * (f[1][k] * f[1][n - k] % MOD) % MOD\n\n\ndef perm(n, r):\n return factorial(n) // factorial(r)\n\n\ndef gcb(a, b):\n if b == 0:\n return a\n else:\n return gcb(b, a % b)\n\n\ndef lcm(a, b):\n d = gcb(a, b)\n return int(a / d * b)\n\n\ndef surP(x):\n return x % MOD\n\n\ndef main():\n # ------ 入力 ------#\n h, w, a, b = list(map(int, input().split())) # スペース区切り連続数字\n\n # ------ 処理 ------#\n f = combInit(h + w)\n res = 0\n for i in range(b, w):\n res += comb((h-1-a)+i, i, f) * comb((a-1)+(w-1-i), w-1-i, f)\n\n out = surP(res)\n # ------ 出力 ------#\n print(\"{}\".format(out))\n # if flg == 0:\n # print(\"YES\")\n # else:\n # print(\"NO\")\n\n\nif __name__ == '__main__':\n main()",
"import sys",
"sys",
"from math import factorial",
"MOD = 10 ** 9 + 7",
"MOD",
"10 ** 9 + 7",
"10 ** 9",
"10",
"9",
"7",
"def combInit(n):\n fact = [1]\n finv = [1]\n for i in range(1, n + 1):\n fact.append(fact[i - 1] * i % MOD)\n finv.append(pow(fact[i], MOD - 2, MOD))\n return [fact, finv]",
"combInit",
"fact = [1]",
"fact",
"[1]",
"1",
"finv = [1]",
"finv",
"[1]",
"1",
"for i in range(1, n + 1):\n fact.append(fact[i - 1] * i % MOD)\n finv.append(pow(fact[i], MOD - 2, MOD))\n ",
"i",
"range(1, n + 1)",
"range",
"1",
"n + 1",
"n",
"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",
"finv.append(pow(fact[i], MOD - 2, MOD))",
"finv.append",
"finv",
"append",
"pow(fact[i], MOD - 2, MOD)",
"pow",
"fact[i]",
"fact",
"i",
"MOD - 2",
"MOD",
"2",
"MOD",
"return [fact, finv]",
"[fact, finv]",
"fact",
"finv",
"n",
"n",
"def comb(n, k, f):\n if n < k:\n return 0\n elif n < 0 or k < 0:\n return 0\n else:\n return f[0][n] * (f[1][k] * f[1][n - k] % MOD) % MOD",
"comb",
"if n < k:\n return 0\n elif n < 0 or k < 0:\n return 0\n else:\n return f[0][n] * (f[1][k] * f[1][n - k] % MOD) % MOD",
"n < k",
"n",
"k",
"return 0",
"0",
"elif n < 0 or k < 0:\n return 0\n ",
"n < 0 or k < 0",
"n < 0",
"n",
"0",
"k < 0",
"k",
"0",
"return 0",
"0",
"return f[0][n] * (f[1][k] * f[1][n - k] % MOD) % MOD",
"f[0][n] * (f[1][k] * f[1][n - k] % MOD) % MOD",
"f[0][n] * (f[1][k] * f[1][n - k] % MOD)",
"f[0][n]",
"[0]",
"f",
"0",
"n",
"f[1][k] * f[1][n - k] % MOD",
"f[1][k] * f[1][n - k]",
"f[1][k]",
"[1]",
"f",
"1",
"k",
"f[1][n - k]",
"[1]",
"f",
"1",
"n - k",
"n",
"k",
"MOD",
"MOD",
"n",
"n",
"k",
"k",
"f",
"f",
"def perm(n, r):\n return factorial(n) // factorial(r)",
"perm",
"return factorial(n) // factorial(r)",
"factorial(n) // factorial(r)",
"factorial(n)",
"factorial",
"n",
"factorial(r)",
"factorial",
"r",
"n",
"n",
"r",
"r",
"def gcb(a, b):\n if b == 0:\n return a\n else:\n return gcb(b, a % b)",
"gcb",
"if b == 0:\n return a\n else:\n return gcb(b, a % b)",
"b == 0",
"b",
"0",
"return a",
"a",
"return gcb(b, a % b)",
"gcb(b, a % b)",
"gcb",
"b",
"a % b",
"a",
"b",
"a",
"a",
"b",
"b",
"def lcm(a, b):\n d = gcb(a, b)\n return int(a / d * b)",
"lcm",
"d = gcb(a, b)",
"d",
"gcb(a, b)",
"gcb",
"a",
"b",
"return int(a / d * b)",
"int(a / d * b)",
"int",
"a / d * b",
"a / d",
"a",
"d",
"b",
"a",
"a",
"b",
"b",
"def surP(x):\n return x % MOD",
"surP",
"return x % MOD",
"x % MOD",
"x",
"MOD",
"x",
"x",
"def main():\n # ------ 入力 ------#\n h, w, a, b = list(map(int, input().split())) # スペース区切り連続数字\n\n # ------ 処理 ------#\n f = combInit(h + w)\n res = 0\n for i in range(b, w):\n res += comb((h-1-a)+i, i, f) * comb((a-1)+(w-1-i), w-1-i, f)\n\n out = surP(res)\n # ------ 出力 ------#\n print(\"{}\".format(out))\n # if flg == 0:\n # print(\"YES\")\n # else:\n # print(\"NO\")",
"main",
"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",
"f = combInit(h + w)",
"f",
"combInit(h + w)",
"combInit",
"h + w",
"h",
"w",
"res = 0",
"res",
"0",
"for i in range(b, w):\n res += comb((h-1-a)+i, i, f) * comb((a-1)+(w-1-i), w-1-i, f)\n\n ",
"i",
"range(b, w)",
"range",
"b",
"w",
"res += comb((h-1-a)+i, i, f) * comb((a-1)+(w-1-i), w-1-i, f)",
"res",
"comb((h-1-a)+i, i, f) * comb((a-1)+(w-1-i), w-1-i, f)",
"comb((h-1-a)+i, i, f)",
"comb",
"(h-1-a)+i",
"h-1-a",
"h-1",
"h",
"1",
"a",
"i",
"i",
"f",
"comb((a-1)+(w-1-i), w-1-i, f)",
"comb",
"(a-1)+(w-1-i)",
"a-1",
"a",
"1",
"w-1-i",
"w-1",
"w",
"1",
"i",
"w-1-i",
"w-1",
"w",
"1",
"i",
"f",
"out = surP(res)",
"out",
"surP(res)",
"surP",
"res",
"print(\"{}\".format(out))",
"print",
"\"{}\".format(out)",
"\"{}\".format",
"\"{}\"",
"format",
"out",
"if __name__ == '__main__':\n main()",
"__name__ == '__main__'",
"__name__",
"'__main__'",
"main()",
"main",
"def lcm(a, b):\n d = gcb(a, b)\n return int(a / d * b)",
"def lcm(a, b):\n d = gcb(a, b)\n return int(a / d * b)",
"lcm",
"def surP(x):\n return x % MOD",
"def surP(x):\n return x % MOD",
"surP",
"MOD = 10 ** 9 + 7",
"10 ** 9 + 7",
"MOD",
"def combInit(n):\n fact = [1]\n finv = [1]\n for i in range(1, n + 1):\n fact.append(fact[i - 1] * i % MOD)\n finv.append(pow(fact[i], MOD - 2, MOD))\n return [fact, finv]",
"def combInit(n):\n fact = [1]\n finv = [1]\n for i in range(1, n + 1):\n fact.append(fact[i - 1] * i % MOD)\n finv.append(pow(fact[i], MOD - 2, MOD))\n return [fact, finv]",
"combInit",
"def comb(n, k, f):\n if n < k:\n return 0\n elif n < 0 or k < 0:\n return 0\n else:\n return f[0][n] * (f[1][k] * f[1][n - k] % MOD) % MOD",
"def comb(n, k, f):\n if n < k:\n return 0\n elif n < 0 or k < 0:\n return 0\n else:\n return f[0][n] * (f[1][k] * f[1][n - k] % MOD) % MOD",
"comb",
"def main():\n # ------ 入力 ------#\n h, w, a, b = list(map(int, input().split())) # スペース区切り連続数字\n\n # ------ 処理 ------#\n f = combInit(h + w)\n res = 0\n for i in range(b, w):\n res += comb((h-1-a)+i, i, f) * comb((a-1)+(w-1-i), w-1-i, f)\n\n out = surP(res)\n # ------ 出力 ------#\n print(\"{}\".format(out))\n # if flg == 0:\n # print(\"YES\")\n # else:\n # print(\"NO\")",
"def main():\n # ------ 入力 ------#\n h, w, a, b = list(map(int, input().split())) # スペース区切り連続数字\n\n # ------ 処理 ------#\n f = combInit(h + w)\n res = 0\n for i in range(b, w):\n res += comb((h-1-a)+i, i, f) * comb((a-1)+(w-1-i), w-1-i, f)\n\n out = surP(res)\n # ------ 出力 ------#\n print(\"{}\".format(out))\n # if flg == 0:\n # print(\"YES\")\n # else:\n # print(\"NO\")",
"main",
"def gcb(a, b):\n if b == 0:\n return a\n else:\n return gcb(b, a % b)",
"def gcb(a, b):\n if b == 0:\n return a\n else:\n return gcb(b, a % b)",
"gcb",
"def perm(n, r):\n return factorial(n) // factorial(r)",
"def perm(n, r):\n return factorial(n) // factorial(r)",
"perm"
] | # coding:UTF-8
import sys
from math import factorial
MOD = 10 ** 9 + 7
def combInit(n):
fact = [1]
finv = [1]
for i in range(1, n + 1):
fact.append(fact[i - 1] * i % MOD)
finv.append(pow(fact[i], MOD - 2, MOD))
return [fact, finv]
def comb(n, k, f):
if n < k:
return 0
elif n < 0 or k < 0:
return 0
else:
return f[0][n] * (f[1][k] * f[1][n - k] % MOD) % MOD
def perm(n, r):
return factorial(n) // factorial(r)
def gcb(a, b):
if b == 0:
return a
else:
return gcb(b, a % b)
def lcm(a, b):
d = gcb(a, b)
return int(a / d * b)
def surP(x):
return x % MOD
def main():
# ------ 入力 ------#
h, w, a, b = list(map(int, input().split())) # スペース区切り連続数字
# ------ 処理 ------#
f = combInit(h + w)
res = 0
for i in range(b, w):
res += comb((h-1-a)+i, i, f) * comb((a-1)+(w-1-i), w-1-i, f)
out = surP(res)
# ------ 出力 ------#
print("{}".format(out))
# if flg == 0:
# print("YES")
# else:
# print("NO")
if __name__ == '__main__':
main()
|
[
7,
15,
15,
13,
13,
13,
13,
13,
13,
13,
13,
4,
18,
13,
13,
2,
17,
17,
0,
13,
4,
13,
17,
0,
13,
2,
2,
17,
17,
17,
0,
13,
2,
17,
17,
12,
13,
12,
13,
0,
13,
4,
13,
13,
13,
13,
0,
13,
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,
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,
12,
13,
29,
2,
2,
2,
18,
13,
13,
18,
13,
13,
18,
13,
2,
13,
13,
13,
23,
13,
23,
13,
28,
13,
4,
13,
2,
13,
17,
2,
13,
17,
0,
13,
2,
13,
13,
0,
13,
13,
0,
13,
2,
2,
13,
13,
17,
0,
13,
2,
2,
4,
13,
2,
2,
13,
13,
17,
2,
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,
2,
13,
10,
12,
13,
10,
12,
13,
10,
4,
13,
10,
2,
13,
10,
2,
13,
10,
12,
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,
13,
13,
10,
13,
13
] | [
[
233,
19
],
[
245,
24
],
[
251,
31
],
[
248,
40
],
[
216,
42
],
[
248,
43
],
[
248,
44
],
[
248,
45
],
[
230,
47
],
[
221,
50
],
[
243,
52
],
[
219,
53
],
[
209,
55
],
[
222,
60
],
[
64,
63
],
[
222,
68
],
[
74,
71
],
[
210,
72
],
[
63,
73
],
[
210,
77
],
[
63,
79
],
[
63,
81
],
[
246,
82
],
[
236,
84
],
[
222,
89
],
[
95,
92
],
[
237,
93
],
[
222,
94
],
[
210,
98
],
[
222,
99
],
[
246,
101
],
[
246,
103
],
[
106,
105
],
[
222,
108
],
[
117,
112
],
[
237,
113
],
[
105,
115
],
[
237,
120
],
[
105,
121
],
[
105,
122
],
[
246,
123
],
[
210,
131
],
[
143,
132
],
[
237,
134
],
[
145,
135
],
[
237,
137
],
[
143,
139
],
[
145,
140
],
[
246,
141
],
[
143,
143
],
[
145,
145
],
[
148,
147
],
[
204,
151
],
[
219,
154
],
[
239,
157
],
[
243,
159
],
[
249,
160
],
[
254,
162
],
[
249,
163
],
[
224,
165
],
[
219,
168
],
[
147,
169
],
[
206,
172
],
[
213,
176
],
[
147,
179
],
[
240,
180
],
[
240,
183
],
[
213,
186
],
[
255,
189
],
[
225,
190
],
[
225,
193
],
[
246,
195
],
[
257,
197
],
[
246,
198
],
[
258,
201
],
[
207,
201
],
[
231,
201
],
[
248,
204
],
[
206,
207
],
[
209,
210
],
[
248,
219
],
[
221,
222
],
[
224,
225
],
[
230,
231
],
[
233,
234
],
[
236,
237
],
[
239,
240
],
[
248,
243
],
[
245,
246
],
[
248,
249
],
[
251,
252
],
[
249,
254
],
[
254,
255
],
[
246,
257
],
[
257,
258
]
] | [
"from collections import defaultdict,deque\nimport sys,heapq,bisect,math,itertools,string,queue,datetime\nsys.setrecursionlimit(10**8)\nINF = float('inf')\nmod = 10**9+7\neps = 10**-7\ndef inpl(): return list(map(int, input().split()))\ndef inpl_s(): return list(input().split())\n\nH,W,A,B=inpl()\nans = 0\n\nMAX = H+W\nfac = [1]*(MAX+1)\nfor i in range(1,MAX+1):\n\tfac[i] = (fac[i-1]*i)%mod\n\ngyakugen = [1]*(MAX+1)\ngyakugen[MAX] = pow(fac[MAX],mod-2,mod)\nfor i in range(MAX,0,-1):\n\tgyakugen[i-1] = (gyakugen[i]*i)%mod\n\ndef Comb(n,k):#nCk\n\treturn (fac[n]*gyakugen[k]*gyakugen[n-k])%mod\n\nfor x1 in range(B+1,W+1):\n\ty1 = H-A\n\tx2 = A\n\ty2 = W-x1+1\n\tans += (Comb(x1+y1-2,y1-1)*Comb(x2+y2-2,y2-1))%mod\n\tans %= mod\n\nprint(ans)",
"from collections import defaultdict,deque",
"import sys,heapq,bisect,math,itertools,string,queue,datetime",
"sys",
"heapq",
"bisect",
"math",
"itertools",
"string",
"queue",
"datetime",
"sys.setrecursionlimit(10**8)",
"sys.setrecursionlimit",
"sys",
"setrecursionlimit",
"10**8",
"10",
"8",
"INF = float('inf')",
"INF",
"float('inf')",
"float",
"'inf'",
"mod = 10**9+7",
"mod",
"10**9+7",
"10**9",
"10",
"9",
"7",
"eps = 10**-7",
"eps",
"10**-7",
"10",
"-7",
"def inpl(): return list(map(int, input().split()))",
"inpl",
"def inpl_s(): return list(input().split())",
"inpl_s",
"H,W,A,B=inpl()",
"H",
"inpl()",
"inpl",
"W",
"A",
"B",
"ans = 0",
"ans",
"0",
"MAX = H+W",
"MAX",
"H+W",
"H",
"W",
"fac = [1]*(MAX+1)",
"fac",
"[1]*(MAX+1)",
"[1]",
"1",
"MAX+1",
"MAX",
"1",
"for i in range(1,MAX+1):\n\tfac[i] = (fac[i-1]*i)%mod",
"i",
"range(1,MAX+1)",
"range",
"1",
"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",
"gyakugen = [1]*(MAX+1)",
"gyakugen",
"[1]*(MAX+1)",
"[1]",
"1",
"MAX+1",
"MAX",
"1",
"gyakugen[MAX] = pow(fac[MAX],mod-2,mod)",
"gyakugen[MAX]",
"gyakugen",
"MAX",
"pow(fac[MAX],mod-2,mod)",
"pow",
"fac[MAX]",
"fac",
"MAX",
"mod-2",
"mod",
"2",
"mod",
"for i in range(MAX,0,-1):\n\tgyakugen[i-1] = (gyakugen[i]*i)%mod",
"i",
"range(MAX,0,-1)",
"range",
"MAX",
"0",
"-1",
"gyakugen[i-1] = (gyakugen[i]*i)%mod",
"gyakugen[i-1]",
"gyakugen",
"i-1",
"i",
"1",
"(gyakugen[i]*i)%mod",
"gyakugen[i]*i",
"gyakugen[i]",
"gyakugen",
"i",
"i",
"mod",
"def Comb(n,k):#nCk\n\treturn (fac[n]*gyakugen[k]*gyakugen[n-k])%mod",
"Comb",
"return (fac[n]*gyakugen[k]*gyakugen[n-k])%mod",
"(fac[n]*gyakugen[k]*gyakugen[n-k])%mod",
"fac[n]*gyakugen[k]*gyakugen[n-k]",
"fac[n]*gyakugen[k]",
"fac[n]",
"fac",
"n",
"gyakugen[k]",
"gyakugen",
"k",
"gyakugen[n-k]",
"gyakugen",
"n-k",
"n",
"k",
"mod",
"n",
"n",
"k",
"k",
"for x1 in range(B+1,W+1):\n\ty1 = H-A\n\tx2 = A\n\ty2 = W-x1+1\n\tans += (Comb(x1+y1-2,y1-1)*Comb(x2+y2-2,y2-1))%mod\n\tans %= mod",
"x1",
"range(B+1,W+1)",
"range",
"B+1",
"B",
"1",
"W+1",
"W",
"1",
"y1 = H-A",
"y1",
"H-A",
"H",
"A",
"x2 = A",
"x2",
"A",
"y2 = W-x1+1",
"y2",
"W-x1+1",
"W-x1",
"W",
"x1",
"1",
"ans += (Comb(x1+y1-2,y1-1)*Comb(x2+y2-2,y2-1))%mod",
"ans",
"(Comb(x1+y1-2,y1-1)*Comb(x2+y2-2,y2-1))%mod",
"Comb(x1+y1-2,y1-1)*Comb(x2+y2-2,y2-1)",
"Comb(x1+y1-2,y1-1)",
"Comb",
"x1+y1-2",
"x1+y1",
"x1",
"y1",
"2",
"y1-1",
"y1",
"1",
"Comb(x2+y2-2,y2-1)",
"Comb",
"x2+y2-2",
"x2+y2",
"x2",
"y2",
"2",
"y2-1",
"y2",
"1",
"mod",
"ans %= mod",
"ans",
"mod",
"print(ans)",
"print",
"ans",
"B=inpl()",
"inpl()",
"B",
"ans += (Comb(x1+y1-2,y1-1)*Comb(x2+y2-2,y2-1))%mod",
"(Comb(x1+y1-2,y1-1)*Comb(x2+y2-2,y2-1))%mod",
"ans",
"fac = [1]*(MAX+1)",
"[1]*(MAX+1)",
"fac",
"def Comb(n,k):#nCk\n\treturn (fac[n]*gyakugen[k]*gyakugen[n-k])%mod",
"def Comb(n,k):#nCk\n\treturn (fac[n]*gyakugen[k]*gyakugen[n-k])%mod",
"Comb",
"def inpl(): return list(map(int, input().split()))",
"def inpl(): return list(map(int, input().split()))",
"inpl",
"W,A,B=inpl()",
"inpl()",
"W",
"MAX = H+W",
"H+W",
"MAX",
"y2 = W-x1+1",
"W-x1+1",
"y2",
"def inpl_s(): return list(input().split())",
"def inpl_s(): return list(input().split())",
"inpl_s",
"ans = 0",
"0",
"ans",
"INF = float('inf')",
"float('inf')",
"INF",
"gyakugen = [1]*(MAX+1)",
"[1]*(MAX+1)",
"gyakugen",
"y1 = H-A",
"H-A",
"y1",
"H,W,A,B=inpl()",
"inpl()",
"H",
"mod = 10**9+7",
"10**9+7",
"mod",
"A,B=inpl()",
"inpl()",
"A",
"eps = 10**-7",
"10**-7",
"eps",
"x2 = A",
"A",
"x2",
"ans %= mod",
"mod",
"ans"
] | from collections import defaultdict,deque
import sys,heapq,bisect,math,itertools,string,queue,datetime
sys.setrecursionlimit(10**8)
INF = float('inf')
mod = 10**9+7
eps = 10**-7
def inpl(): return list(map(int, input().split()))
def inpl_s(): return list(input().split())
H,W,A,B=inpl()
ans = 0
MAX = H+W
fac = [1]*(MAX+1)
for i in range(1,MAX+1):
fac[i] = (fac[i-1]*i)%mod
gyakugen = [1]*(MAX+1)
gyakugen[MAX] = pow(fac[MAX],mod-2,mod)
for i in range(MAX,0,-1):
gyakugen[i-1] = (gyakugen[i]*i)%mod
def Comb(n,k):#nCk
return (fac[n]*gyakugen[k]*gyakugen[n-k])%mod
for x1 in range(B+1,W+1):
y1 = H-A
x2 = A
y2 = W-x1+1
ans += (Comb(x1+y1-2,y1-1)*Comb(x2+y2-2,y2-1))%mod
ans %= mod
print(ans)
|
[
7,
15,
13,
15,
13,
14,
4,
18,
13,
13,
17,
0,
18,
13,
13,
4,
13,
17,
17,
4,
18,
13,
13,
17,
0,
13,
4,
13,
17,
0,
13,
2,
17,
17,
0,
13,
2,
2,
17,
17,
17,
0,
13,
4,
13,
4,
13,
13,
4,
18,
4,
18,
18,
13,
13,
13,
13,
13,
13,
13,
12,
13,
17,
0,
13,
39,
17,
0,
13,
17,
14,
13,
28,
13,
4,
13,
17,
2,
13,
17,
0,
13,
13,
0,
13,
13,
4,
18,
13,
13,
13,
28,
13,
4,
13,
17,
2,
13,
17,
0,
13,
13,
4,
18,
13,
13,
13,
29,
13,
23,
13,
23,
13,
17,
12,
13,
17,
29,
4,
13,
13,
2,
13,
17,
13,
23,
13,
23,
13,
0,
13,
4,
13,
2,
13,
13,
13,
12,
13,
17,
14,
2,
13,
13,
29,
17,
29,
2,
2,
2,
18,
13,
13,
4,
13,
18,
13,
13,
13,
4,
13,
18,
13,
2,
13,
13,
13,
13,
23,
13,
23,
13,
23,
13,
17,
0,
13,
17,
28,
13,
4,
13,
2,
13,
13,
0,
13,
2,
4,
13,
2,
2,
2,
13,
13,
17,
2,
2,
13,
13,
17,
2,
2,
13,
13,
17,
13,
4,
13,
2,
2,
13,
17,
13,
13,
13,
0,
13,
13,
4,
13,
13,
10,
4,
13,
10,
13,
13,
10,
2,
13,
10,
12,
13,
10,
2,
13,
10,
4,
13,
10,
4,
13,
10,
4,
13,
10,
2,
13,
10,
4,
13,
10,
4,
13,
10,
12,
13,
10,
12,
13,
10,
17,
13
] | [
[
15,
12
],
[
241,
25
],
[
247,
30
],
[
235,
35
],
[
250,
42
],
[
12,
52
],
[
250,
57
],
[
250,
58
],
[
250,
59
],
[
65,
64
],
[
69,
68
],
[
74,
73
],
[
110,
78
],
[
82,
81
],
[
73,
82
],
[
85,
84
],
[
112,
85
],
[
64,
88
],
[
84,
90
],
[
81,
90
],
[
68,
90
],
[
93,
92
],
[
110,
97
],
[
101,
100
],
[
92,
101
],
[
64,
104
],
[
100,
106
],
[
68,
106
],
[
64,
108
],
[
110,
110
],
[
113,
112
],
[
126,
120
],
[
128,
122
],
[
128,
124
],
[
126,
126
],
[
128,
128
],
[
253,
130
],
[
260,
132
],
[
251,
134
],
[
245,
135
],
[
236,
136
],
[
169,
142
],
[
171,
143
],
[
254,
151
],
[
169,
152
],
[
233,
154
],
[
254,
156
],
[
171,
157
],
[
173,
158
],
[
233,
160
],
[
254,
162
],
[
169,
164
],
[
171,
165
],
[
173,
166
],
[
173,
167
],
[
169,
169
],
[
171,
171
],
[
174,
173
],
[
262,
176
],
[
180,
179
],
[
245,
183
],
[
239,
184
],
[
229,
186
],
[
257,
189
],
[
251,
193
],
[
224,
194
],
[
245,
198
],
[
179,
199
],
[
245,
203
],
[
179,
204
],
[
236,
206
],
[
257,
208
],
[
224,
211
],
[
179,
213
],
[
179,
214
],
[
236,
215
],
[
226,
217
],
[
236,
218
],
[
227,
221
],
[
230,
221
],
[
263,
221
],
[
250,
224
],
[
236,
226
],
[
226,
227
],
[
229,
230
],
[
235,
236
],
[
250,
239
],
[
241,
242
],
[
250,
245
],
[
247,
248
],
[
250,
251
],
[
253,
254
],
[
262,
263
]
] | [
"import os\nimport sys\n\nif os.getenv(\"LOCAL\"):\n sys.stdin = open(\"_in.txt\", \"r\")\n\nsys.setrecursionlimit(2147483647)\nINF = float(\"inf\")\nIINF = 10 ** 18\nMOD = 10 ** 9 + 7\n\nH, W, A, B = list(map(int, sys.stdin.readline().split()))\n\n\n# dp = np.ones(W, dtype=int)\n# for h in range(1, H - A):\n# dp = dp.cumsum() % MOD\n# for h in range(H - A, H):\n# dp[B:] = dp[B:].cumsum() % MOD\n# print(dp[-1])\n\n\ndef get_factorials(max, mod=None):\n \"\"\"\n 階乗 0!, 1!, 2!, ..., max!\n :param int max:\n :param int mod:\n :return:\n \"\"\"\n ret = [1]\n n = 1\n if mod:\n for i in range(1, max + 1):\n n *= i\n n %= mod\n ret.append(n)\n else:\n for i in range(1, max + 1):\n n *= i\n ret.append(n)\n return ret\n\ndef mod_inv(a, mod):\n \"\"\"\n a の逆元\n :param int a:\n :param int mod:\n :return:\n \"\"\"\n return pow(a, mod - 2, mod)\n\n\nfactorials = get_factorials(H + W, MOD)\n\n\ndef ncr(n, r, mod=None):\n \"\"\"\n scipy.misc.comb または scipy.special.comb と同じ\n 組み合わせの数 nCr\n :param int n:\n :param int r:\n :param int mod: 3 以上の素数であること\n :rtype: int\n \"\"\"\n if n < r:\n return 0\n\n return factorials[n] * mod_inv(factorials[r], mod) * mod_inv(factorials[n - r], mod) % mod\n\n\nans = 0\nfor i in range(W - B):\n ans += ncr((H - A - 1) + (W - i - 1), W - i - 1, MOD) * ncr((A - 1) + i, i, MOD)\n ans %= MOD\nprint(ans)",
"import os",
"os",
"import sys",
"sys",
"if os.getenv(\"LOCAL\"):\n sys.stdin = open(\"_in.txt\", \"r\")",
"os.getenv(\"LOCAL\")",
"os.getenv",
"os",
"getenv",
"\"LOCAL\"",
"sys.stdin = open(\"_in.txt\", \"r\")",
"sys.stdin",
"sys",
"stdin",
"open(\"_in.txt\", \"r\")",
"open",
"\"_in.txt\"",
"\"r\"",
"sys.setrecursionlimit(2147483647)",
"sys.setrecursionlimit",
"sys",
"setrecursionlimit",
"2147483647",
"INF = float(\"inf\")",
"INF",
"float(\"inf\")",
"float",
"\"inf\"",
"IINF = 10 ** 18",
"IINF",
"10 ** 18",
"10",
"18",
"MOD = 10 ** 9 + 7",
"MOD",
"10 ** 9 + 7",
"10 ** 9",
"10",
"9",
"7",
"H, W, A, B = list(map(int, sys.stdin.readline().split()))",
"H",
"list(map(int, sys.stdin.readline().split()))",
"list",
"map(int, sys.stdin.readline().split())",
"map",
"int",
"sys.stdin.readline().split()",
"sys.stdin.readline().split",
"sys.stdin.readline()",
"sys.stdin.readline",
"sys.stdin",
"sys",
"stdin",
"readline",
"split",
"W",
"A",
"B",
"def get_factorials(max, mod=None):\n \"\"\"\n 階乗 0!, 1!, 2!, ..., max!\n :param int max:\n :param int mod:\n :return:\n \"\"\"\n ret = [1]\n n = 1\n if mod:\n for i in range(1, max + 1):\n n *= i\n n %= mod\n ret.append(n)\n else:\n for i in range(1, max + 1):\n n *= i\n ret.append(n)\n return ret",
"get_factorials",
"\"\"\"\n 階乗 0!, 1!, 2!, ..., max!\n :param int max:\n :param int mod:\n :return:\n \"\"\"",
"ret = [1]",
"ret",
"[1]",
"1",
"n = 1",
"n",
"1",
"if mod:\n for i in range(1, max + 1):\n n *= i\n n %= mod\n ret.append(n)\n else:\n for i in range(1, max + 1):\n n *= i\n ret.append(n)\n ",
"mod",
"for i in range(1, max + 1):\n n *= i\n n %= mod\n ret.append(n)\n ",
"i",
"range(1, max + 1)",
"range",
"1",
"max + 1",
"max",
"1",
"n *= i",
"n",
"i",
"n %= mod",
"n",
"mod",
"ret.append(n)",
"ret.append",
"ret",
"append",
"n",
"for i in range(1, max + 1):\n n *= i\n ret.append(n)\n ",
"i",
"range(1, max + 1)",
"range",
"1",
"max + 1",
"max",
"1",
"n *= i",
"n",
"i",
"ret.append(n)",
"ret.append",
"ret",
"append",
"n",
"return ret",
"ret",
"max",
"max",
"mod=None",
"mod",
"None",
"def mod_inv(a, mod):\n \"\"\"\n a の逆元\n :param int a:\n :param int mod:\n :return:\n \"\"\"\n return pow(a, mod - 2, mod)",
"mod_inv",
"\"\"\"\n a の逆元\n :param int a:\n :param int mod:\n :return:\n \"\"\"",
"return pow(a, mod - 2, mod)",
"pow(a, mod - 2, mod)",
"pow",
"a",
"mod - 2",
"mod",
"2",
"mod",
"a",
"a",
"mod",
"mod",
"factorials = get_factorials(H + W, MOD)",
"factorials",
"get_factorials(H + W, MOD)",
"get_factorials",
"H + W",
"H",
"W",
"MOD",
"def ncr(n, r, mod=None):\n \"\"\"\n scipy.misc.comb または scipy.special.comb と同じ\n 組み合わせの数 nCr\n :param int n:\n :param int r:\n :param int mod: 3 以上の素数であること\n :rtype: int\n \"\"\"\n if n < r:\n return 0\n\n return factorials[n] * mod_inv(factorials[r], mod) * mod_inv(factorials[n - r], mod) % mod",
"ncr",
"\"\"\"\n scipy.misc.comb または scipy.special.comb と同じ\n 組み合わせの数 nCr\n :param int n:\n :param int r:\n :param int mod: 3 以上の素数であること\n :rtype: int\n \"\"\"",
"if n < r:\n return 0\n\n ",
"n < r",
"n",
"r",
"return 0",
"0",
"return factorials[n] * mod_inv(factorials[r], mod) * mod_inv(factorials[n - r], mod) % mod",
"factorials[n] * mod_inv(factorials[r], mod) * mod_inv(factorials[n - r], mod) % mod",
"factorials[n] * mod_inv(factorials[r], mod) * mod_inv(factorials[n - r], mod)",
"factorials[n] * mod_inv(factorials[r], mod)",
"factorials[n]",
"factorials",
"n",
"mod_inv(factorials[r], mod)",
"mod_inv",
"factorials[r]",
"factorials",
"r",
"mod",
"mod_inv(factorials[n - r], mod)",
"mod_inv",
"factorials[n - r]",
"factorials",
"n - r",
"n",
"r",
"mod",
"mod",
"n",
"n",
"r",
"r",
"mod=None",
"mod",
"None",
"ans = 0",
"ans",
"0",
"for i in range(W - B):\n ans += ncr((H - A - 1) + (W - i - 1), W - i - 1, MOD) * ncr((A - 1) + i, i, MOD)\n ans %= MOD",
"i",
"range(W - B)",
"range",
"W - B",
"W",
"B",
"ans += ncr((H - A - 1) + (W - i - 1), W - i - 1, MOD) * ncr((A - 1) + i, i, MOD)",
"ans",
"ncr((H - A - 1) + (W - i - 1), W - i - 1, MOD) * ncr((A - 1) + i, i, MOD)",
"ncr((H - A - 1) + (W - i - 1), W - i - 1, MOD)",
"ncr",
"(H - A - 1) + (W - i - 1)",
"H - A - 1",
"H - A",
"H",
"A",
"1",
"W - i - 1",
"W - i",
"W",
"i",
"1",
"W - i - 1",
"W - i",
"W",
"i",
"1",
"MOD",
"ncr((A - 1) + i, i, MOD)",
"ncr",
"(A - 1) + i",
"A - 1",
"A",
"1",
"i",
"i",
"MOD",
"ans %= MOD",
"ans",
"MOD",
"print(ans)",
"print",
"ans",
"A, B = list(map(int, sys.stdin.readline().split()))",
"list(map(int, sys.stdin.readline().split()))",
"A",
"ans %= MOD",
"MOD",
"ans",
"ans += ncr((H - A - 1) + (W - i - 1), W - i - 1, MOD) * ncr((A - 1) + i, i, MOD)",
"ncr((H - A - 1) + (W - i - 1), W - i - 1, MOD) * ncr((A - 1) + i, i, MOD)",
"ans",
"def mod_inv(a, mod):\n \"\"\"\n a の逆元\n :param int a:\n :param int mod:\n :return:\n \"\"\"\n return pow(a, mod - 2, mod)",
"def mod_inv(a, mod):\n \"\"\"\n a の逆元\n :param int a:\n :param int mod:\n :return:\n \"\"\"\n return pow(a, mod - 2, mod)",
"mod_inv",
"MOD = 10 ** 9 + 7",
"10 ** 9 + 7",
"MOD",
"B = list(map(int, sys.stdin.readline().split()))",
"list(map(int, sys.stdin.readline().split()))",
"B",
"INF = float(\"inf\")",
"float(\"inf\")",
"INF",
"W, A, B = list(map(int, sys.stdin.readline().split()))",
"list(map(int, sys.stdin.readline().split()))",
"W",
"IINF = 10 ** 18",
"10 ** 18",
"IINF",
"H, W, A, B = list(map(int, sys.stdin.readline().split()))",
"list(map(int, sys.stdin.readline().split()))",
"H",
"factorials = get_factorials(H + W, MOD)",
"get_factorials(H + W, MOD)",
"factorials",
"def ncr(n, r, mod=None):\n \"\"\"\n scipy.misc.comb または scipy.special.comb と同じ\n 組み合わせの数 nCr\n :param int n:\n :param int r:\n :param int mod: 3 以上の素数であること\n :rtype: int\n \"\"\"\n if n < r:\n return 0\n\n return factorials[n] * mod_inv(factorials[r], mod) * mod_inv(factorials[n - r], mod) % mod",
"def ncr(n, r, mod=None):\n \"\"\"\n scipy.misc.comb または scipy.special.comb と同じ\n 組み合わせの数 nCr\n :param int n:\n :param int r:\n :param int mod: 3 以上の素数であること\n :rtype: int\n \"\"\"\n if n < r:\n return 0\n\n return factorials[n] * mod_inv(factorials[r], mod) * mod_inv(factorials[n - r], mod) % mod",
"ncr",
"def get_factorials(max, mod=None):\n \"\"\"\n 階乗 0!, 1!, 2!, ..., max!\n :param int max:\n :param int mod:\n :return:\n \"\"\"\n ret = [1]\n n = 1\n if mod:\n for i in range(1, max + 1):\n n *= i\n n %= mod\n ret.append(n)\n else:\n for i in range(1, max + 1):\n n *= i\n ret.append(n)\n return ret",
"def get_factorials(max, mod=None):\n \"\"\"\n 階乗 0!, 1!, 2!, ..., max!\n :param int max:\n :param int mod:\n :return:\n \"\"\"\n ret = [1]\n n = 1\n if mod:\n for i in range(1, max + 1):\n n *= i\n n %= mod\n ret.append(n)\n else:\n for i in range(1, max + 1):\n n *= i\n ret.append(n)\n return ret",
"get_factorials",
"ans = 0",
"0",
"ans"
] | import os
import sys
if os.getenv("LOCAL"):
sys.stdin = open("_in.txt", "r")
sys.setrecursionlimit(2147483647)
INF = float("inf")
IINF = 10 ** 18
MOD = 10 ** 9 + 7
H, W, A, B = list(map(int, sys.stdin.readline().split()))
# dp = np.ones(W, dtype=int)
# for h in range(1, H - A):
# dp = dp.cumsum() % MOD
# for h in range(H - A, H):
# dp[B:] = dp[B:].cumsum() % MOD
# print(dp[-1])
def get_factorials(max, mod=None):
"""
階乗 0!, 1!, 2!, ..., max!
:param int max:
:param int mod:
:return:
"""
ret = [1]
n = 1
if mod:
for i in range(1, max + 1):
n *= i
n %= mod
ret.append(n)
else:
for i in range(1, max + 1):
n *= i
ret.append(n)
return ret
def mod_inv(a, mod):
"""
a の逆元
:param int a:
:param int mod:
:return:
"""
return pow(a, mod - 2, mod)
factorials = get_factorials(H + W, MOD)
def ncr(n, r, mod=None):
"""
scipy.misc.comb または scipy.special.comb と同じ
組み合わせの数 nCr
:param int n:
:param int r:
:param int mod: 3 以上の素数であること
:rtype: int
"""
if n < r:
return 0
return factorials[n] * mod_inv(factorials[r], mod) * mod_inv(factorials[n - r], mod) % mod
ans = 0
for i in range(W - B):
ans += ncr((H - A - 1) + (W - i - 1), W - i - 1, MOD) * ncr((A - 1) + i, i, MOD)
ans %= MOD
print(ans)
|
[
7,
0,
13,
4,
13,
13,
4,
18,
4,
13,
13,
13,
13,
13,
0,
13,
2,
4,
13,
17,
17,
12,
13,
0,
13,
17,
13,
17,
13,
17,
13,
17,
13,
13,
13,
13,
42,
40,
13,
17,
0,
13,
13,
13,
13,
13,
2,
13,
2,
13,
2,
13,
13,
13,
2,
13,
2,
13,
2,
13,
13,
0,
13,
13,
13,
2,
13,
13,
29,
2,
13,
13,
23,
13,
41,
28,
13,
4,
13,
2,
2,
2,
2,
13,
13,
13,
13,
17,
4,
17,
0,
13,
13,
41,
28,
13,
4,
13,
2,
2,
2,
2,
13,
13,
13,
13,
17,
4,
17,
0,
13,
13,
28,
13,
4,
13,
2,
2,
2,
13,
13,
13,
13,
0,
18,
13,
2,
13,
17,
2,
2,
18,
13,
13,
2,
13,
17,
13,
0,
18,
13,
17,
4,
13,
18,
13,
17,
28,
13,
4,
13,
2,
2,
2,
13,
13,
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,
18,
13,
2,
2,
13,
13,
17,
18,
13,
13,
18,
13,
2,
2,
2,
2,
13,
13,
13,
13,
17,
18,
13,
2,
2,
13,
17,
13,
13,
0,
13,
13,
0,
13,
2,
2,
18,
13,
2,
13,
17,
18,
13,
2,
2,
13,
13,
17,
13,
0,
13,
13,
4,
13,
13,
10,
2,
13,
10,
12,
13,
10,
17,
13,
10,
2,
13,
10,
13,
13,
10,
4,
13,
10,
13,
13,
10,
13,
13,
10,
4,
13,
10,
13,
13,
10,
2,
13,
10,
4,
13,
10,
4,
13
] | [
[
281,
2
],
[
281,
11
],
[
281,
12
],
[
281,
13
],
[
275,
15
],
[
25,
24
],
[
27,
26
],
[
29,
28
],
[
31,
30
],
[
33,
32
],
[
73,
33
],
[
35,
34
],
[
276,
35
],
[
34,
38
],
[
64,
38
],
[
42,
41
],
[
28,
42
],
[
45,
42
],
[
44,
43
],
[
30,
44
],
[
53,
44
],
[
46,
45
],
[
41,
47
],
[
24,
47
],
[
28,
49
],
[
45,
49
],
[
32,
51
],
[
62,
51
],
[
34,
52
],
[
64,
52
],
[
54,
53
],
[
43,
55
],
[
26,
55
],
[
30,
57
],
[
53,
57
],
[
32,
59
],
[
62,
59
],
[
34,
60
],
[
64,
60
],
[
63,
62
],
[
34,
63
],
[
64,
63
],
[
65,
64
],
[
62,
66
],
[
32,
66
],
[
34,
67
],
[
64,
67
],
[
41,
70
],
[
24,
70
],
[
276,
71
],
[
73,
73
],
[
77,
76
],
[
279,
83
],
[
261,
84
],
[
270,
85
],
[
282,
86
],
[
272,
91
],
[
96,
95
],
[
279,
102
],
[
261,
103
],
[
270,
104
],
[
282,
105
],
[
263,
110
],
[
114,
113
],
[
279,
119
],
[
261,
120
],
[
270,
121
],
[
282,
122
],
[
129,
124
],
[
273,
125
],
[
113,
127
],
[
273,
132
],
[
113,
133
],
[
113,
135
],
[
276,
137
],
[
142,
139
],
[
264,
140
],
[
249,
143
],
[
273,
145
],
[
149,
148
],
[
279,
154
],
[
261,
155
],
[
270,
156
],
[
282,
157
],
[
166,
161
],
[
264,
162
],
[
148,
164
],
[
264,
169
],
[
148,
170
],
[
148,
171
],
[
276,
172
],
[
251,
174
],
[
178,
177
],
[
279,
181
],
[
270,
182
],
[
254,
184
],
[
273,
190
],
[
177,
193
],
[
282,
194
],
[
264,
197
],
[
177,
198
],
[
273,
200
],
[
279,
205
],
[
177,
206
],
[
261,
207
],
[
282,
208
],
[
264,
211
],
[
279,
214
],
[
177,
216
],
[
276,
217
],
[
266,
219
],
[
276,
220
],
[
245,
222
],
[
264,
226
],
[
282,
228
],
[
264,
231
],
[
261,
234
],
[
282,
235
],
[
276,
237
],
[
257,
239
],
[
276,
240
],
[
258,
243
],
[
246,
243
],
[
267,
243
],
[
255,
243
],
[
252,
243
],
[
245,
246
],
[
251,
252
],
[
254,
255
],
[
276,
257
],
[
257,
258
],
[
281,
261
],
[
263,
264
],
[
276,
266
],
[
266,
267
],
[
281,
270
],
[
272,
273
],
[
275,
276
],
[
281,
279
],
[
281,
282
]
] | [
"H, W, A, B = map(int, input().split())\nmod = int(1e9) + 7\ndef inved(a):\n x, y, u, v, k, l = 1, 0, 0, 1, a, mod\n while l != 0:\n x, y, u, v = u, v, x - u * (k // l), y - v * (k // l)\n k, l = l, k % l\n return x % mod\nfact = [1 for _ in range(H+W+A+B+1)]\ninvf = [1 for _ in range(H+W+A+B+1)]\nfor i in range(H+W+A+B):\n fact[i+1] = (fact[i] * (i + 1)) % mod\ninvf[-1] = inved(fact[-1])\nfor i in range(H+W+A+B, 0, -1):\n invf[i-1] = (invf[i] * i) % mod\nS = 0\nfor i in range(H-A):\n S += (fact[i+B-1] * invf[i] * fact[H-i+W-B-2] * invf[H-1-i]) % mod\n S %= mod\nS *= (invf[B-1] * invf[W-B-1]) % mod\nS %= mod\n\nprint(S)",
"H, W, A, B = map(int, input().split())",
"H",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"W",
"A",
"B",
"mod = int(1e9) + 7",
"mod",
"int(1e9) + 7",
"int(1e9)",
"int",
"1e9",
"7",
"def inved(a):\n x, y, u, v, k, l = 1, 0, 0, 1, a, mod\n while l != 0:\n x, y, u, v = u, v, x - u * (k // l), y - v * (k // l)\n k, l = l, k % l\n return x % mod",
"inved",
"x, y, u, v, k, l = 1, 0, 0, 1, a, mod",
"x",
"1",
"y",
"0",
"u",
"0",
"v",
"1",
"k",
"a",
"l",
"mod",
"while l != 0:\n x, y, u, v = u, v, x - u * (k // l), y - v * (k // l)\n k, l = l, k % l\n ",
"l != 0",
"l",
"0",
"x, y, u, v = u, v, x - u * (k // l), y - v * (k // l)",
"x",
"u",
"y",
"v",
"u",
"x - u * (k // l)",
"x",
"u * (k // l)",
"u",
"k // l",
"k",
"l",
"v",
"y - v * (k // l)",
"y",
"v * (k // l)",
"v",
"k // l",
"k",
"l",
"k, l = l, k % l",
"k",
"l",
"l",
"k % l",
"k",
"l",
"return x % mod",
"x % mod",
"x",
"mod",
"a",
"a",
"1 for _ in range(H+W+A+B+1)",
"for _ in range(H+W+A+B+1)",
"_",
"range(H+W+A+B+1)",
"range",
"H+W+A+B+1",
"H+W+A+B",
"H+W+A",
"H+W",
"H",
"W",
"A",
"B",
"1",
"for _ in range(H+W+A+B+1)",
"1",
"fact = [1 for _ in range(H+W+A+B+1)]",
"fact",
"[1 for _ in range(H+W+A+B+1)]",
"1 for _ in range(H+W+A+B+1)",
"for _ in range(H+W+A+B+1)",
"_",
"range(H+W+A+B+1)",
"range",
"H+W+A+B+1",
"H+W+A+B",
"H+W+A",
"H+W",
"H",
"W",
"A",
"B",
"1",
"for _ in range(H+W+A+B+1)",
"1",
"invf = [1 for _ in range(H+W+A+B+1)]",
"invf",
"[1 for _ in range(H+W+A+B+1)]",
"for i in range(H+W+A+B):\n fact[i+1] = (fact[i] * (i + 1)) % mod",
"i",
"range(H+W+A+B)",
"range",
"H+W+A+B",
"H+W+A",
"H+W",
"H",
"W",
"A",
"B",
"fact[i+1] = (fact[i] * (i + 1)) % mod",
"fact[i+1]",
"fact",
"i+1",
"i",
"1",
"(fact[i] * (i + 1)) % mod",
"fact[i] * (i + 1)",
"fact[i]",
"fact",
"i",
"i + 1",
"i",
"1",
"mod",
"invf[-1] = inved(fact[-1])",
"invf[-1]",
"invf",
"-1",
"inved(fact[-1])",
"inved",
"fact[-1]",
"fact",
"-1",
"for i in range(H+W+A+B, 0, -1):\n invf[i-1] = (invf[i] * i) % mod",
"i",
"range(H+W+A+B, 0, -1)",
"range",
"H+W+A+B",
"H+W+A",
"H+W",
"H",
"W",
"A",
"B",
"0",
"-1",
"invf[i-1] = (invf[i] * i) % mod",
"invf[i-1]",
"invf",
"i-1",
"i",
"1",
"(invf[i] * i) % mod",
"invf[i] * i",
"invf[i]",
"invf",
"i",
"i",
"mod",
"S = 0",
"S",
"0",
"for i in range(H-A):\n S += (fact[i+B-1] * invf[i] * fact[H-i+W-B-2] * invf[H-1-i]) % mod\n S %= mod",
"i",
"range(H-A)",
"range",
"H-A",
"H",
"A",
"S += (fact[i+B-1] * invf[i] * fact[H-i+W-B-2] * invf[H-1-i]) % mod",
"S",
"(fact[i+B-1] * invf[i] * fact[H-i+W-B-2] * invf[H-1-i]) % mod",
"fact[i+B-1] * invf[i] * fact[H-i+W-B-2] * invf[H-1-i]",
"fact[i+B-1] * invf[i] * fact[H-i+W-B-2]",
"fact[i+B-1] * invf[i]",
"fact[i+B-1]",
"fact",
"i+B-1",
"i+B",
"i",
"B",
"1",
"invf[i]",
"invf",
"i",
"fact[H-i+W-B-2]",
"fact",
"H-i+W-B-2",
"H-i+W-B",
"H-i+W",
"H-i",
"H",
"i",
"W",
"B",
"2",
"invf[H-1-i]",
"invf",
"H-1-i",
"H-1",
"H",
"1",
"i",
"mod",
"S %= mod",
"S",
"mod",
"S *= (invf[B-1] * invf[W-B-1]) % mod",
"S",
"(invf[B-1] * invf[W-B-1]) % mod",
"invf[B-1] * invf[W-B-1]",
"invf[B-1]",
"invf",
"B-1",
"B",
"1",
"invf[W-B-1]",
"invf",
"W-B-1",
"W-B",
"W",
"B",
"1",
"mod",
"S %= mod",
"S",
"mod",
"print(S)",
"print",
"S",
"S *= (invf[B-1] * invf[W-B-1]) % mod",
"(invf[B-1] * invf[W-B-1]) % mod",
"S",
"def inved(a):\n x, y, u, v, k, l = 1, 0, 0, 1, a, mod\n while l != 0:\n x, y, u, v = u, v, x - u * (k // l), y - v * (k // l)\n k, l = l, k % l\n return x % mod",
"def inved(a):\n x, y, u, v, k, l = 1, 0, 0, 1, a, mod\n while l != 0:\n x, y, u, v = u, v, x - u * (k // l), y - v * (k // l)\n k, l = l, k % l\n return x % mod",
"inved",
"S = 0",
"0",
"S",
"S += (fact[i+B-1] * invf[i] * fact[H-i+W-B-2] * invf[H-1-i]) % mod",
"(fact[i+B-1] * invf[i] * fact[H-i+W-B-2] * invf[H-1-i]) % mod",
"S",
"S %= mod",
"mod",
"S",
"W, A, B = map(int, input().split())",
"map(int, input().split())",
"W",
"invf = [1 for _ in range(H+W+A+B+1)]",
"[1 for _ in range(H+W+A+B+1)]",
"invf",
"S %= mod",
"mod",
"S",
"A, B = map(int, input().split())",
"map(int, input().split())",
"A",
"fact = [1 for _ in range(H+W+A+B+1)]",
"[1 for _ in range(H+W+A+B+1)]",
"fact",
"mod = int(1e9) + 7",
"int(1e9) + 7",
"mod",
"H, W, A, B = map(int, input().split())",
"map(int, input().split())",
"H",
"B = map(int, input().split())",
"map(int, input().split())",
"B"
] | H, W, A, B = map(int, input().split())
mod = int(1e9) + 7
def inved(a):
x, y, u, v, k, l = 1, 0, 0, 1, a, mod
while l != 0:
x, y, u, v = u, v, x - u * (k // l), y - v * (k // l)
k, l = l, k % l
return x % mod
fact = [1 for _ in range(H+W+A+B+1)]
invf = [1 for _ in range(H+W+A+B+1)]
for i in range(H+W+A+B):
fact[i+1] = (fact[i] * (i + 1)) % mod
invf[-1] = inved(fact[-1])
for i in range(H+W+A+B, 0, -1):
invf[i-1] = (invf[i] * i) % mod
S = 0
for i in range(H-A):
S += (fact[i+B-1] * invf[i] * fact[H-i+W-B-2] * invf[H-1-i]) % mod
S %= mod
S *= (invf[B-1] * invf[W-B-1]) % mod
S %= mod
print(S) |
[
7,
15,
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,
17,
2,
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,
0,
13,
17,
28,
13,
4,
13,
13,
13,
0,
13,
18,
13,
2,
2,
2,
13,
13,
13,
17,
0,
13,
18,
13,
2,
2,
13,
13,
17,
0,
13,
13,
0,
13,
18,
13,
13,
0,
13,
13,
0,
13,
18,
13,
2,
2,
2,
2,
13,
13,
17,
13,
17,
0,
13,
18,
13,
2,
2,
13,
13,
17,
0,
13,
13,
0,
13,
18,
13,
2,
13,
17,
0,
13,
13,
0,
13,
2,
2,
13,
13,
13,
0,
13,
13,
4,
13,
13,
10,
18,
13,
10,
13,
13,
10,
13,
13,
10,
18,
13,
10,
13,
13,
10,
2,
13,
10,
2,
13,
10,
18,
13,
10,
13,
13,
10,
13,
13,
10,
18,
13,
10,
18,
13,
10,
13,
13,
10,
2,
13,
10,
2,
13,
10,
18,
13,
10,
13,
13,
10,
13,
13,
10,
2,
13,
10,
13,
13,
10,
17,
13
] | [
[
5,
4
],
[
4,
13
],
[
250,
15
],
[
250,
17
],
[
250,
18
],
[
250,
19
],
[
208,
21
],
[
211,
28
],
[
235,
35
],
[
212,
40
],
[
232,
43
],
[
212,
48
],
[
52,
51
],
[
212,
56
],
[
62,
59
],
[
236,
60
],
[
51,
61
],
[
236,
65
],
[
51,
67
],
[
51,
69
],
[
209,
70
],
[
75,
72
],
[
233,
73
],
[
212,
74
],
[
236,
78
],
[
212,
79
],
[
209,
81
],
[
209,
83
],
[
86,
85
],
[
212,
88
],
[
97,
92
],
[
233,
93
],
[
85,
95
],
[
233,
100
],
[
85,
101
],
[
85,
102
],
[
209,
103
],
[
253,
105
],
[
109,
108
],
[
251,
111
],
[
200,
112
],
[
223,
114
],
[
236,
116
],
[
108,
120
],
[
242,
121
],
[
221,
122
],
[
226,
125
],
[
233,
127
],
[
242,
130
],
[
221,
131
],
[
229,
134
],
[
209,
135
],
[
202,
137
],
[
233,
139
],
[
108,
140
],
[
244,
142
],
[
209,
143
],
[
214,
145
],
[
236,
147
],
[
200,
152
],
[
108,
153
],
[
221,
155
],
[
238,
158
],
[
233,
160
],
[
200,
163
],
[
108,
164
],
[
196,
167
],
[
209,
168
],
[
193,
170
],
[
233,
172
],
[
221,
174
],
[
217,
177
],
[
209,
178
],
[
247,
180
],
[
245,
183
],
[
203,
183
],
[
230,
183
],
[
227,
183
],
[
224,
183
],
[
218,
184
],
[
194,
184
],
[
197,
184
],
[
239,
184
],
[
215,
184
],
[
209,
185
],
[
205,
187
],
[
209,
188
],
[
206,
191
],
[
248,
191
],
[
254,
191
],
[
193,
194
],
[
209,
196
],
[
196,
197
],
[
250,
200
],
[
202,
203
],
[
209,
205
],
[
205,
206
],
[
208,
209
],
[
211,
212
],
[
214,
215
],
[
209,
217
],
[
217,
218
],
[
250,
221
],
[
223,
224
],
[
226,
227
],
[
209,
229
],
[
229,
230
],
[
232,
233
],
[
235,
236
],
[
238,
239
],
[
250,
242
],
[
209,
244
],
[
244,
245
],
[
247,
248
],
[
250,
251
],
[
253,
254
]
] | [
"from sys import exit\nH,W,A,B = [int(n) for n in input().split()]\nMOD = 10**9+7\nNUM = 2*10**5\n\nfact=[1]*(NUM+1)\nfactinv=[1]*(NUM+1)\nfor i in range(1,NUM+1):\n fact[i]=(fact[i-1]*i)%MOD\n\nfactinv[NUM]=pow(fact[NUM],MOD-2,MOD)\nfor i in range(NUM,0,-1):\n factinv[i-1]=(factinv[i]*i) % MOD\nans=0\nfor i in range(B,W):\n tmp0 = fact[i+H-A-1]\n tmp0 *= factinv[H-A-1]\n tmp0 %= MOD\n tmp0 *= factinv[i]\n tmp0 %= MOD\n\n tmp1 = fact[W-i-1+A-1]\n tmp1 *= factinv[W-i-1]\n tmp1 %= MOD\n tmp1 *= factinv[A-1]\n tmp1 %= MOD\n ans += (tmp0 * tmp1) % MOD\n ans %= MOD\nprint(ans)",
"from sys import exit",
"int(n) for n in input().split()",
"for n in input().split()",
"n",
"input().split()",
"().split",
"()",
"input",
"split",
"for n in input().split()",
"int(n)",
"int",
"n",
"H,W,A,B = [int(n) for n in input().split()]",
"H",
"[int(n) for n in input().split()]",
"W",
"A",
"B",
"MOD = 10**9+7",
"MOD",
"10**9+7",
"10**9",
"10",
"9",
"7",
"NUM = 2*10**5",
"NUM",
"2*10**5",
"2",
"10**5",
"10",
"5",
"fact=[1]*(NUM+1)",
"fact",
"[1]*(NUM+1)",
"[1]",
"1",
"NUM+1",
"NUM",
"1",
"factinv=[1]*(NUM+1)",
"factinv",
"[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",
"factinv[NUM]=pow(fact[NUM],MOD-2,MOD)",
"factinv[NUM]",
"factinv",
"NUM",
"pow(fact[NUM],MOD-2,MOD)",
"pow",
"fact[NUM]",
"fact",
"NUM",
"MOD-2",
"MOD",
"2",
"MOD",
"for i in range(NUM,0,-1):\n factinv[i-1]=(factinv[i]*i) % MOD",
"i",
"range(NUM,0,-1)",
"range",
"NUM",
"0",
"-1",
"factinv[i-1]=(factinv[i]*i) % MOD",
"factinv[i-1]",
"factinv",
"i-1",
"i",
"1",
"(factinv[i]*i) % MOD",
"factinv[i]*i",
"factinv[i]",
"factinv",
"i",
"i",
"MOD",
"ans=0",
"ans",
"0",
"for i in range(B,W):\n tmp0 = fact[i+H-A-1]\n tmp0 *= factinv[H-A-1]\n tmp0 %= MOD\n tmp0 *= factinv[i]\n tmp0 %= MOD\n\n tmp1 = fact[W-i-1+A-1]\n tmp1 *= factinv[W-i-1]\n tmp1 %= MOD\n tmp1 *= factinv[A-1]\n tmp1 %= MOD\n ans += (tmp0 * tmp1) % MOD\n ans %= MOD",
"i",
"range(B,W)",
"range",
"B",
"W",
"tmp0 = fact[i+H-A-1]",
"tmp0",
"fact[i+H-A-1]",
"fact",
"i+H-A-1",
"i+H-A",
"i+H",
"i",
"H",
"A",
"1",
"tmp0 *= factinv[H-A-1]",
"tmp0",
"factinv[H-A-1]",
"factinv",
"H-A-1",
"H-A",
"H",
"A",
"1",
"tmp0 %= MOD",
"tmp0",
"MOD",
"tmp0 *= factinv[i]",
"tmp0",
"factinv[i]",
"factinv",
"i",
"tmp0 %= MOD",
"tmp0",
"MOD",
"tmp1 = fact[W-i-1+A-1]",
"tmp1",
"fact[W-i-1+A-1]",
"fact",
"W-i-1+A-1",
"W-i-1+A",
"W-i-1",
"W-i",
"W",
"i",
"1",
"A",
"1",
"tmp1 *= factinv[W-i-1]",
"tmp1",
"factinv[W-i-1]",
"factinv",
"W-i-1",
"W-i",
"W",
"i",
"1",
"tmp1 %= MOD",
"tmp1",
"MOD",
"tmp1 *= factinv[A-1]",
"tmp1",
"factinv[A-1]",
"factinv",
"A-1",
"A",
"1",
"tmp1 %= MOD",
"tmp1",
"MOD",
"ans += (tmp0 * tmp1) % MOD",
"ans",
"(tmp0 * tmp1) % MOD",
"tmp0 * tmp1",
"tmp0",
"tmp1",
"MOD",
"ans %= MOD",
"ans",
"MOD",
"print(ans)",
"print",
"ans",
"tmp1 *= factinv[A-1]",
"factinv[A-1]",
"tmp1",
"tmp1 %= MOD",
"MOD",
"tmp1",
"W,A,B = [int(n) for n in input().split()]",
"[int(n) for n in input().split()]",
"W",
"tmp0 *= factinv[i]",
"factinv[i]",
"tmp0",
"ans %= MOD",
"MOD",
"ans",
"MOD = 10**9+7",
"10**9+7",
"MOD",
"NUM = 2*10**5",
"2*10**5",
"NUM",
"tmp1 = fact[W-i-1+A-1]",
"fact[W-i-1+A-1]",
"tmp1",
"tmp1 %= MOD",
"MOD",
"tmp1",
"A,B = [int(n) for n in input().split()]",
"[int(n) for n in input().split()]",
"A",
"tmp0 = fact[i+H-A-1]",
"fact[i+H-A-1]",
"tmp0",
"tmp0 *= factinv[H-A-1]",
"factinv[H-A-1]",
"tmp0",
"tmp0 %= MOD",
"MOD",
"tmp0",
"factinv=[1]*(NUM+1)",
"[1]*(NUM+1)",
"factinv",
"fact=[1]*(NUM+1)",
"[1]*(NUM+1)",
"fact",
"tmp1 *= factinv[W-i-1]",
"factinv[W-i-1]",
"tmp1",
"H,W,A,B = [int(n) for n in input().split()]",
"[int(n) for n in input().split()]",
"H",
"tmp0 %= MOD",
"MOD",
"tmp0",
"ans += (tmp0 * tmp1) % MOD",
"(tmp0 * tmp1) % MOD",
"ans",
"B = [int(n) for n in input().split()]",
"[int(n) for n in input().split()]",
"B",
"ans=0",
"0",
"ans"
] | from sys import exit
H,W,A,B = [int(n) for n in input().split()]
MOD = 10**9+7
NUM = 2*10**5
fact=[1]*(NUM+1)
factinv=[1]*(NUM+1)
for i in range(1,NUM+1):
fact[i]=(fact[i-1]*i)%MOD
factinv[NUM]=pow(fact[NUM],MOD-2,MOD)
for i in range(NUM,0,-1):
factinv[i-1]=(factinv[i]*i) % MOD
ans=0
for i in range(B,W):
tmp0 = fact[i+H-A-1]
tmp0 *= factinv[H-A-1]
tmp0 %= MOD
tmp0 *= factinv[i]
tmp0 %= MOD
tmp1 = fact[W-i-1+A-1]
tmp1 *= factinv[W-i-1]
tmp1 %= MOD
tmp1 *= factinv[A-1]
tmp1 %= MOD
ans += (tmp0 * tmp1) % MOD
ans %= MOD
print(ans)
|
[
7,
0,
13,
4,
13,
13,
4,
18,
4,
13,
13,
13,
13,
13,
0,
13,
4,
13,
13,
13,
0,
13,
2,
2,
17,
17,
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,
13,
2,
39,
17,
2,
13,
17,
0,
18,
13,
17,
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,
0,
13,
2,
2,
18,
13,
2,
2,
13,
13,
17,
18,
13,
2,
13,
17,
13,
0,
13,
17,
28,
13,
4,
13,
13,
13,
0,
13,
2,
2,
2,
2,
18,
13,
2,
2,
2,
13,
13,
13,
17,
18,
13,
13,
18,
13,
2,
2,
2,
13,
13,
17,
13,
18,
13,
2,
2,
13,
13,
17,
13,
4,
13,
2,
2,
13,
13,
13,
10,
2,
13,
10,
4,
13,
10,
2,
13,
10,
4,
13,
10,
4,
13,
10,
2,
13,
10,
17,
13,
10,
4,
13,
10,
2,
13,
10,
4,
13,
10,
2,
13
] | [
[
201,
2
],
[
201,
11
],
[
201,
12
],
[
201,
13
],
[
186,
15
],
[
178,
18
],
[
196,
19
],
[
189,
21
],
[
174,
28
],
[
178,
34
],
[
196,
35
],
[
39,
38
],
[
178,
44
],
[
196,
45
],
[
51,
48
],
[
175,
49
],
[
38,
50
],
[
175,
54
],
[
38,
56
],
[
38,
58
],
[
190,
59
],
[
180,
61
],
[
187,
66
],
[
72,
69
],
[
181,
70
],
[
175,
75
],
[
187,
76
],
[
190,
78
],
[
190,
80
],
[
83,
82
],
[
187,
86
],
[
94,
91
],
[
181,
92
],
[
82,
93
],
[
181,
97
],
[
82,
99
],
[
82,
102
],
[
190,
104
],
[
198,
106
],
[
181,
110
],
[
178,
113
],
[
184,
114
],
[
181,
117
],
[
184,
119
],
[
190,
121
],
[
192,
123
],
[
127,
126
],
[
202,
129
],
[
196,
130
],
[
204,
132
],
[
175,
138
],
[
178,
142
],
[
184,
143
],
[
126,
144
],
[
91,
146
],
[
181,
147
],
[
126,
148
],
[
175,
150
],
[
184,
154
],
[
196,
155
],
[
126,
157
],
[
181,
159
],
[
196,
162
],
[
126,
163
],
[
190,
165
],
[
205,
170
],
[
193,
170
],
[
199,
171
],
[
190,
172
],
[
174,
175
],
[
201,
178
],
[
180,
181
],
[
201,
184
],
[
186,
187
],
[
189,
190
],
[
192,
193
],
[
201,
196
],
[
198,
199
],
[
201,
202
],
[
204,
205
]
] | [
"h,w,a,b = map(int, input().split())\nmx = max(h,w)\nmod = 10**9+7\nfac = [1]*(h+w+1)\nfor i in range(1,h+w+1):\n\tfac[i]=fac[i-1]*i%mod\nrev = [1]*(mx+1)\nrev[-1] = pow(fac[mx], mod-2, mod)\nfor i in range(mx-1, -1, -1):\n\trev[i] = rev[i+1]*(i+1)%mod\nconst = rev[h-a-1]*rev[a-1]%mod\nans = 0\nfor i in range(b,w):\n\tans += fac[h-a+i-1]*rev[i]*fac[a+w-2-i]*rev[w-i-1]%mod\nprint(ans*const%mod)",
"h,w,a,b = map(int, input().split())",
"h",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"w",
"a",
"b",
"mx = max(h,w)",
"mx",
"max(h,w)",
"max",
"h",
"w",
"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",
"for i in range(1,h+w+1):\n\tfac[i]=fac[i-1]*i%mod",
"i",
"range(1,h+w+1)",
"range",
"1",
"h+w+1",
"h+w",
"h",
"w",
"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",
"rev = [1]*(mx+1)",
"rev",
"[1]*(mx+1)",
"[1]",
"1",
"mx+1",
"mx",
"1",
"rev[-1] = pow(fac[mx], mod-2, mod)",
"rev[-1]",
"rev",
"-1",
"pow(fac[mx], mod-2, mod)",
"pow",
"fac[mx]",
"fac",
"mx",
"mod-2",
"mod",
"2",
"mod",
"for i in range(mx-1, -1, -1):\n\trev[i] = rev[i+1]*(i+1)%mod",
"i",
"range(mx-1, -1, -1)",
"range",
"mx-1",
"mx",
"1",
"-1",
"-1",
"rev[i] = rev[i+1]*(i+1)%mod",
"rev[i]",
"rev",
"i",
"rev[i+1]*(i+1)%mod",
"rev[i+1]*(i+1)",
"rev[i+1]",
"rev",
"i+1",
"i",
"1",
"i+1",
"i",
"1",
"mod",
"const = rev[h-a-1]*rev[a-1]%mod",
"const",
"rev[h-a-1]*rev[a-1]%mod",
"rev[h-a-1]*rev[a-1]",
"rev[h-a-1]",
"rev",
"h-a-1",
"h-a",
"h",
"a",
"1",
"rev[a-1]",
"rev",
"a-1",
"a",
"1",
"mod",
"ans = 0",
"ans",
"0",
"for i in range(b,w):\n\tans += fac[h-a+i-1]*rev[i]*fac[a+w-2-i]*rev[w-i-1]%mod",
"i",
"range(b,w)",
"range",
"b",
"w",
"ans += fac[h-a+i-1]*rev[i]*fac[a+w-2-i]*rev[w-i-1]%mod",
"ans",
"fac[h-a+i-1]*rev[i]*fac[a+w-2-i]*rev[w-i-1]%mod",
"fac[h-a+i-1]*rev[i]*fac[a+w-2-i]*rev[w-i-1]",
"fac[h-a+i-1]*rev[i]*fac[a+w-2-i]",
"fac[h-a+i-1]*rev[i]",
"fac[h-a+i-1]",
"fac",
"h-a+i-1",
"h-a+i",
"h-a",
"h",
"a",
"i",
"1",
"rev[i]",
"rev",
"i",
"fac[a+w-2-i]",
"fac",
"a+w-2-i",
"a+w-2",
"a+w",
"a",
"w",
"2",
"i",
"rev[w-i-1]",
"rev",
"w-i-1",
"w-i",
"w",
"i",
"1",
"mod",
"print(ans*const%mod)",
"print",
"ans*const%mod",
"ans*const",
"ans",
"const",
"mod",
"fac = [1]*(h+w+1)",
"[1]*(h+w+1)",
"fac",
"h,w,a,b = map(int, input().split())",
"map(int, input().split())",
"h",
"rev = [1]*(mx+1)",
"[1]*(mx+1)",
"rev",
"a,b = map(int, input().split())",
"map(int, input().split())",
"a",
"mx = max(h,w)",
"max(h,w)",
"mx",
"mod = 10**9+7",
"10**9+7",
"mod",
"ans = 0",
"0",
"ans",
"w,a,b = map(int, input().split())",
"map(int, input().split())",
"w",
"const = rev[h-a-1]*rev[a-1]%mod",
"rev[h-a-1]*rev[a-1]%mod",
"const",
"b = map(int, input().split())",
"map(int, input().split())",
"b",
"ans += fac[h-a+i-1]*rev[i]*fac[a+w-2-i]*rev[w-i-1]%mod",
"fac[h-a+i-1]*rev[i]*fac[a+w-2-i]*rev[w-i-1]%mod",
"ans"
] | h,w,a,b = map(int, input().split())
mx = max(h,w)
mod = 10**9+7
fac = [1]*(h+w+1)
for i in range(1,h+w+1):
fac[i]=fac[i-1]*i%mod
rev = [1]*(mx+1)
rev[-1] = pow(fac[mx], mod-2, mod)
for i in range(mx-1, -1, -1):
rev[i] = rev[i+1]*(i+1)%mod
const = rev[h-a-1]*rev[a-1]%mod
ans = 0
for i in range(b,w):
ans += fac[h-a+i-1]*rev[i]*fac[a+w-2-i]*rev[w-i-1]%mod
print(ans*const%mod) |
[
7,
12,
13,
0,
13,
13,
14,
40,
4,
18,
13,
13,
13,
17,
17,
29,
18,
13,
13,
0,
13,
2,
13,
17,
0,
13,
17,
42,
40,
13,
17,
14,
2,
2,
13,
17,
17,
0,
13,
13,
0,
13,
13,
0,
13,
13,
0,
13,
13,
0,
13,
17,
0,
13,
13,
0,
13,
13,
0,
18,
13,
13,
13,
29,
13,
23,
13,
23,
13,
23,
13,
12,
13,
28,
13,
4,
13,
17,
2,
13,
17,
0,
18,
13,
13,
2,
2,
18,
13,
2,
13,
17,
13,
13,
23,
13,
23,
13,
23,
13,
12,
13,
29,
2,
2,
2,
18,
13,
2,
13,
13,
4,
13,
13,
18,
13,
13,
13,
4,
13,
13,
18,
13,
13,
13,
13,
23,
13,
23,
13,
23,
13,
23,
13,
23,
13,
0,
13,
4,
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,
0,
13,
17,
4,
13,
13,
2,
13,
13,
13,
0,
13,
17,
28,
13,
4,
13,
2,
13,
13,
0,
13,
2,
4,
13,
13,
13,
2,
13,
13,
2,
2,
13,
13,
17,
13,
4,
13,
13,
13,
2,
2,
2,
13,
13,
17,
13,
2,
13,
17,
13,
0,
13,
13,
4,
13,
13,
10,
13,
13,
10,
12,
13,
10,
17,
13,
10,
2,
13,
10,
13,
13,
10,
12,
13,
10,
12,
13,
10,
4,
13,
10,
17,
13,
10,
4,
13,
10,
2,
13,
10,
4,
13,
10,
4,
13
] | [
[
5,
4
],
[
68,
5
],
[
66,
10
],
[
68,
12
],
[
66,
17
],
[
68,
18
],
[
21,
20
],
[
70,
22
],
[
26,
25
],
[
20,
29
],
[
50,
29
],
[
20,
34
],
[
50,
34
],
[
39,
38
],
[
68,
39
],
[
47,
39
],
[
44,
39
],
[
42,
41
],
[
70,
42
],
[
45,
44
],
[
44,
45
],
[
68,
45
],
[
47,
45
],
[
48,
47
],
[
70,
48
],
[
51,
50
],
[
54,
53
],
[
41,
54
],
[
38,
54
],
[
25,
54
],
[
57,
56
],
[
70,
57
],
[
62,
59
],
[
66,
60
],
[
4,
61
],
[
56,
62
],
[
53,
62
],
[
47,
62
],
[
44,
62
],
[
68,
62
],
[
56,
64
],
[
53,
64
],
[
47,
64
],
[
44,
64
],
[
68,
64
],
[
66,
66
],
[
68,
68
],
[
70,
70
],
[
75,
74
],
[
97,
79
],
[
85,
82
],
[
95,
83
],
[
74,
84
],
[
95,
88
],
[
74,
90
],
[
74,
92
],
[
95,
95
],
[
97,
97
],
[
99,
99
],
[
127,
107
],
[
131,
109
],
[
133,
110
],
[
247,
112
],
[
129,
113
],
[
127,
115
],
[
131,
116
],
[
135,
117
],
[
247,
119
],
[
129,
120
],
[
127,
122
],
[
133,
123
],
[
135,
124
],
[
135,
125
],
[
127,
127
],
[
129,
129
],
[
131,
131
],
[
133,
133
],
[
135,
135
],
[
267,
137
],
[
267,
148
],
[
267,
149
],
[
267,
150
],
[
261,
152
],
[
161,
160
],
[
259,
165
],
[
265,
166
],
[
243,
171
],
[
255,
174
],
[
250,
177
],
[
244,
178
],
[
259,
180
],
[
265,
181
],
[
262,
182
],
[
237,
184
],
[
188,
187
],
[
265,
191
],
[
253,
192
],
[
240,
194
],
[
235,
197
],
[
244,
198
],
[
256,
199
],
[
253,
201
],
[
187,
202
],
[
259,
205
],
[
268,
206
],
[
262,
208
],
[
235,
210
],
[
244,
211
],
[
256,
212
],
[
265,
216
],
[
253,
217
],
[
187,
219
],
[
268,
221
],
[
262,
223
],
[
231,
225
],
[
262,
226
],
[
232,
229
],
[
241,
229
],
[
238,
229
],
[
262,
231
],
[
231,
232
],
[
237,
238
],
[
240,
241
],
[
243,
244
],
[
267,
253
],
[
255,
256
],
[
267,
259
],
[
261,
262
],
[
267,
265
],
[
267,
268
]
] | [
"def mod_inv(inv,a,m):\n i=a\n if inv.get(a,0)!=0:\n return inv[a]\n e=m-2\n tmp=1\n while e!=1:\n if e%2==1:\n tmp*=a\n tmp%=m\n a*=a\n a%=m\n e//=2\n a*=tmp\n a%=m\n inv[i]=a\n return a\n\ndef factrial(fact,a,m):\n for i in range(1,a+1):\n fact[i]=fact[i-1]*i%mod\n\ndef comb(fact,inv,a,b,m):\n return (fact[a+b]*mod_inv(inv,fact[a],m)*mod_inv(inv,fact[b],m))%m\n\nH,W,A,B=list(map(int,input().split()))\nmod=10**9+7\nfact=[1 for _ in range(H+W+1)]\ninv={}\nfactrial(fact,H+W,mod)\n\nans=0\nfor i in range(W-B):\n ans+=comb(fact,inv,B+i,H-A-1,mod)*comb(fact,inv,W-B-1-i,A-1,mod)\n ans%=mod\nprint(ans)",
"def mod_inv(inv,a,m):\n i=a\n if inv.get(a,0)!=0:\n return inv[a]\n e=m-2\n tmp=1\n while e!=1:\n if e%2==1:\n tmp*=a\n tmp%=m\n a*=a\n a%=m\n e//=2\n a*=tmp\n a%=m\n inv[i]=a\n return a",
"mod_inv",
"i=a",
"i",
"a",
"if inv.get(a,0)!=0:\n return inv[a]\n ",
"inv.get(a,0)!=0",
"inv.get(a,0)",
"inv.get",
"inv",
"get",
"a",
"0",
"0",
"return inv[a]",
"inv[a]",
"inv",
"a",
"e=m-2",
"e",
"m-2",
"m",
"2",
"tmp=1",
"tmp",
"1",
"while e!=1:\n if e%2==1:\n tmp*=a\n tmp%=m\n a*=a\n a%=m\n e//=2\n ",
"e!=1",
"e",
"1",
"if e%2==1:\n tmp*=a\n tmp%=m\n ",
"e%2==1",
"e%2",
"e",
"2",
"1",
"tmp*=a",
"tmp",
"a",
"tmp%=m",
"tmp",
"m",
"a*=a",
"a",
"a",
"a%=m",
"a",
"m",
"e//=2",
"e",
"2",
"a*=tmp",
"a",
"tmp",
"a%=m",
"a",
"m",
"inv[i]=a",
"inv[i]",
"inv",
"i",
"a",
"return a",
"a",
"inv",
"inv",
"a",
"a",
"m",
"m",
"def factrial(fact,a,m):\n for i in range(1,a+1):\n fact[i]=fact[i-1]*i%mod",
"factrial",
"for i in range(1,a+1):\n fact[i]=fact[i-1]*i%mod",
"i",
"range(1,a+1)",
"range",
"1",
"a+1",
"a",
"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",
"fact",
"a",
"a",
"m",
"m",
"def comb(fact,inv,a,b,m):\n return (fact[a+b]*mod_inv(inv,fact[a],m)*mod_inv(inv,fact[b],m))%m",
"comb",
"return (fact[a+b]*mod_inv(inv,fact[a],m)*mod_inv(inv,fact[b],m))%m",
"(fact[a+b]*mod_inv(inv,fact[a],m)*mod_inv(inv,fact[b],m))%m",
"fact[a+b]*mod_inv(inv,fact[a],m)*mod_inv(inv,fact[b],m)",
"fact[a+b]*mod_inv(inv,fact[a],m)",
"fact[a+b]",
"fact",
"a+b",
"a",
"b",
"mod_inv(inv,fact[a],m)",
"mod_inv",
"inv",
"fact[a]",
"fact",
"a",
"m",
"mod_inv(inv,fact[b],m)",
"mod_inv",
"inv",
"fact[b]",
"fact",
"b",
"m",
"m",
"fact",
"fact",
"inv",
"inv",
"a",
"a",
"b",
"b",
"m",
"m",
"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=10**9+7",
"mod",
"10**9+7",
"10**9",
"10",
"9",
"7",
"1 for _ in range(H+W+1)",
"for _ in range(H+W+1)",
"_",
"range(H+W+1)",
"range",
"H+W+1",
"H+W",
"H",
"W",
"1",
"for _ in range(H+W+1)",
"1",
"fact=[1 for _ in range(H+W+1)]",
"fact",
"[1 for _ in range(H+W+1)]",
"inv={}",
"inv",
"{}",
"factrial(fact,H+W,mod)",
"factrial",
"fact",
"H+W",
"H",
"W",
"mod",
"ans=0",
"ans",
"0",
"for i in range(W-B):\n ans+=comb(fact,inv,B+i,H-A-1,mod)*comb(fact,inv,W-B-1-i,A-1,mod)\n ans%=mod",
"i",
"range(W-B)",
"range",
"W-B",
"W",
"B",
"ans+=comb(fact,inv,B+i,H-A-1,mod)*comb(fact,inv,W-B-1-i,A-1,mod)",
"ans",
"comb(fact,inv,B+i,H-A-1,mod)*comb(fact,inv,W-B-1-i,A-1,mod)",
"comb(fact,inv,B+i,H-A-1,mod)",
"comb",
"fact",
"inv",
"B+i",
"B",
"i",
"H-A-1",
"H-A",
"H",
"A",
"1",
"mod",
"comb(fact,inv,W-B-1-i,A-1,mod)",
"comb",
"fact",
"inv",
"W-B-1-i",
"W-B-1",
"W-B",
"W",
"B",
"1",
"i",
"A-1",
"A",
"1",
"mod",
"ans%=mod",
"ans",
"mod",
"print(ans)",
"print",
"ans",
"ans%=mod",
"mod",
"ans",
"def comb(fact,inv,a,b,m):\n return (fact[a+b]*mod_inv(inv,fact[a],m)*mod_inv(inv,fact[b],m))%m",
"def comb(fact,inv,a,b,m):\n return (fact[a+b]*mod_inv(inv,fact[a],m)*mod_inv(inv,fact[b],m))%m",
"comb",
"ans=0",
"0",
"ans",
"ans+=comb(fact,inv,B+i,H-A-1,mod)*comb(fact,inv,W-B-1-i,A-1,mod)",
"comb(fact,inv,B+i,H-A-1,mod)*comb(fact,inv,W-B-1-i,A-1,mod)",
"ans",
"fact=[1 for _ in range(H+W+1)]",
"[1 for _ in range(H+W+1)]",
"fact",
"def mod_inv(inv,a,m):\n i=a\n if inv.get(a,0)!=0:\n return inv[a]\n e=m-2\n tmp=1\n while e!=1:\n if e%2==1:\n tmp*=a\n tmp%=m\n a*=a\n a%=m\n e//=2\n a*=tmp\n a%=m\n inv[i]=a\n return a",
"def mod_inv(inv,a,m):\n i=a\n if inv.get(a,0)!=0:\n return inv[a]\n e=m-2\n tmp=1\n while e!=1:\n if e%2==1:\n tmp*=a\n tmp%=m\n a*=a\n a%=m\n e//=2\n a*=tmp\n a%=m\n inv[i]=a\n return a",
"mod_inv",
"def factrial(fact,a,m):\n for i in range(1,a+1):\n fact[i]=fact[i-1]*i%mod",
"def factrial(fact,a,m):\n for i in range(1,a+1):\n fact[i]=fact[i-1]*i%mod",
"factrial",
"B=list(map(int,input().split()))",
"list(map(int,input().split()))",
"B",
"inv={}",
"{}",
"inv",
"H,W,A,B=list(map(int,input().split()))",
"list(map(int,input().split()))",
"H",
"mod=10**9+7",
"10**9+7",
"mod",
"W,A,B=list(map(int,input().split()))",
"list(map(int,input().split()))",
"W",
"A,B=list(map(int,input().split()))",
"list(map(int,input().split()))",
"A"
] | def mod_inv(inv,a,m):
i=a
if inv.get(a,0)!=0:
return inv[a]
e=m-2
tmp=1
while e!=1:
if e%2==1:
tmp*=a
tmp%=m
a*=a
a%=m
e//=2
a*=tmp
a%=m
inv[i]=a
return a
def factrial(fact,a,m):
for i in range(1,a+1):
fact[i]=fact[i-1]*i%mod
def comb(fact,inv,a,b,m):
return (fact[a+b]*mod_inv(inv,fact[a],m)*mod_inv(inv,fact[b],m))%m
H,W,A,B=list(map(int,input().split()))
mod=10**9+7
fact=[1 for _ in range(H+W+1)]
inv={}
factrial(fact,H+W,mod)
ans=0
for i in range(W-B):
ans+=comb(fact,inv,B+i,H-A-1,mod)*comb(fact,inv,W-B-1-i,A-1,mod)
ans%=mod
print(ans) |
[
7,
0,
13,
4,
13,
13,
4,
18,
4,
13,
13,
13,
13,
13,
0,
13,
2,
39,
17,
2,
2,
17,
4,
13,
13,
13,
17,
0,
13,
2,
39,
17,
2,
2,
17,
4,
13,
13,
13,
17,
0,
18,
13,
17,
17,
0,
18,
13,
17,
17,
0,
13,
2,
2,
17,
17,
17,
28,
13,
4,
13,
17,
2,
2,
17,
4,
13,
13,
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,
17,
4,
13,
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,
17,
2,
13,
17,
0,
13,
2,
2,
2,
18,
13,
2,
2,
2,
2,
13,
17,
13,
17,
13,
18,
13,
2,
2,
13,
17,
13,
18,
13,
2,
13,
17,
13,
0,
13,
2,
2,
2,
18,
13,
2,
2,
2,
13,
13,
13,
17,
18,
13,
2,
13,
13,
18,
13,
2,
13,
17,
13,
0,
13,
2,
2,
13,
2,
2,
13,
13,
13,
13,
4,
13,
13,
10,
4,
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,
17,
13,
10,
2,
13
] | [
[
221,
2
],
[
221,
11
],
[
221,
12
],
[
221,
13
],
[
212,
15
],
[
222,
24
],
[
204,
25
],
[
224,
28
],
[
222,
37
],
[
204,
38
],
[
44,
41
],
[
213,
42
],
[
49,
46
],
[
225,
47
],
[
218,
51
],
[
59,
58
],
[
222,
67
],
[
204,
68
],
[
74,
71
],
[
225,
72
],
[
58,
73
],
[
225,
77
],
[
58,
79
],
[
58,
81
],
[
219,
82
],
[
87,
84
],
[
213,
85
],
[
225,
90
],
[
219,
93
],
[
219,
95
],
[
98,
97
],
[
222,
104
],
[
204,
105
],
[
114,
109
],
[
213,
110
],
[
97,
112
],
[
213,
117
],
[
97,
118
],
[
97,
119
],
[
219,
120
],
[
230,
122
],
[
126,
125
],
[
207,
129
],
[
204,
132
],
[
227,
135
],
[
225,
140
],
[
125,
145
],
[
222,
147
],
[
216,
149
],
[
213,
151
],
[
222,
154
],
[
216,
156
],
[
213,
158
],
[
125,
160
],
[
219,
162
],
[
233,
164
],
[
225,
169
],
[
204,
173
],
[
125,
174
],
[
216,
175
],
[
213,
178
],
[
204,
180
],
[
125,
181
],
[
213,
183
],
[
216,
185
],
[
219,
187
],
[
209,
189
],
[
231,
192
],
[
210,
192
],
[
228,
195
],
[
234,
196
],
[
219,
197
],
[
219,
198
],
[
210,
201
],
[
231,
201
],
[
221,
204
],
[
221,
207
],
[
209,
210
],
[
212,
213
],
[
221,
216
],
[
218,
219
],
[
221,
222
],
[
224,
225
],
[
227,
228
],
[
230,
231
],
[
233,
234
]
] | [
"h,w,a,b=map(int,input().split())\ninv=[0]*(2*max(h,w)+1)\nfact=[0]*(2*max(h,w)+1)\ninv[0]=1;fact[0]=1\nmod=10**9+7\nfor i in range(1,2*max(h,w)+1):\n fact[i]=fact[i-1]*i%mod\ninv[-1]=pow(fact[-1],mod-2,mod)\nfor i in range(2*max(h,w),0,-1):\n inv[i-1]=inv[i]*i%mod\nans=0\nfor yoko in range(b+1,w+1):\n re=fact[yoko-1+h-1-a]*inv[h-1-a]*inv[yoko-1]%mod\n rr=fact[w-yoko+a-1]*inv[w-yoko]*inv[a-1]%mod\n ans=(ans+re*rr%mod)%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",
"inv=[0]*(2*max(h,w)+1)",
"inv",
"[0]*(2*max(h,w)+1)",
"[0]",
"0",
"2*max(h,w)+1",
"2*max(h,w)",
"2",
"max(h,w)",
"max",
"h",
"w",
"1",
"fact=[0]*(2*max(h,w)+1)",
"fact",
"[0]*(2*max(h,w)+1)",
"[0]",
"0",
"2*max(h,w)+1",
"2*max(h,w)",
"2",
"max(h,w)",
"max",
"h",
"w",
"1",
"inv[0]=1",
"inv[0]",
"inv",
"0",
"1",
"fact[0]=1",
"fact[0]",
"fact",
"0",
"1",
"mod=10**9+7",
"mod",
"10**9+7",
"10**9",
"10",
"9",
"7",
"for i in range(1,2*max(h,w)+1):\n fact[i]=fact[i-1]*i%mod",
"i",
"range(1,2*max(h,w)+1)",
"range",
"1",
"2*max(h,w)+1",
"2*max(h,w)",
"2",
"max(h,w)",
"max",
"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",
"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",
"for i in range(2*max(h,w),0,-1):\n inv[i-1]=inv[i]*i%mod",
"i",
"range(2*max(h,w),0,-1)",
"range",
"2*max(h,w)",
"2",
"max(h,w)",
"max",
"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 yoko in range(b+1,w+1):\n re=fact[yoko-1+h-1-a]*inv[h-1-a]*inv[yoko-1]%mod\n rr=fact[w-yoko+a-1]*inv[w-yoko]*inv[a-1]%mod\n ans=(ans+re*rr%mod)%mod",
"yoko",
"range(b+1,w+1)",
"range",
"b+1",
"b",
"1",
"w+1",
"w",
"1",
"re=fact[yoko-1+h-1-a]*inv[h-1-a]*inv[yoko-1]%mod",
"re",
"fact[yoko-1+h-1-a]*inv[h-1-a]*inv[yoko-1]%mod",
"fact[yoko-1+h-1-a]*inv[h-1-a]*inv[yoko-1]",
"fact[yoko-1+h-1-a]*inv[h-1-a]",
"fact[yoko-1+h-1-a]",
"fact",
"yoko-1+h-1-a",
"yoko-1+h-1",
"yoko-1+h",
"yoko-1",
"yoko",
"1",
"h",
"1",
"a",
"inv[h-1-a]",
"inv",
"h-1-a",
"h-1",
"h",
"1",
"a",
"inv[yoko-1]",
"inv",
"yoko-1",
"yoko",
"1",
"mod",
"rr=fact[w-yoko+a-1]*inv[w-yoko]*inv[a-1]%mod",
"rr",
"fact[w-yoko+a-1]*inv[w-yoko]*inv[a-1]%mod",
"fact[w-yoko+a-1]*inv[w-yoko]*inv[a-1]",
"fact[w-yoko+a-1]*inv[w-yoko]",
"fact[w-yoko+a-1]",
"fact",
"w-yoko+a-1",
"w-yoko+a",
"w-yoko",
"w",
"yoko",
"a",
"1",
"inv[w-yoko]",
"inv",
"w-yoko",
"w",
"yoko",
"inv[a-1]",
"inv",
"a-1",
"a",
"1",
"mod",
"ans=(ans+re*rr%mod)%mod",
"ans",
"(ans+re*rr%mod)%mod",
"ans+re*rr%mod",
"ans",
"re*rr%mod",
"re*rr",
"re",
"rr",
"mod",
"mod",
"print(ans)",
"print",
"ans",
"w,a,b=map(int,input().split())",
"map(int,input().split())",
"w",
"b=map(int,input().split())",
"map(int,input().split())",
"b",
"ans=(ans+re*rr%mod)%mod",
"(ans+re*rr%mod)%mod",
"ans",
"inv=[0]*(2*max(h,w)+1)",
"[0]*(2*max(h,w)+1)",
"inv",
"a,b=map(int,input().split())",
"map(int,input().split())",
"a",
"mod=10**9+7",
"10**9+7",
"mod",
"h,w,a,b=map(int,input().split())",
"map(int,input().split())",
"h",
"fact=[0]*(2*max(h,w)+1)",
"[0]*(2*max(h,w)+1)",
"fact",
"re=fact[yoko-1+h-1-a]*inv[h-1-a]*inv[yoko-1]%mod",
"fact[yoko-1+h-1-a]*inv[h-1-a]*inv[yoko-1]%mod",
"re",
"ans=0",
"0",
"ans",
"rr=fact[w-yoko+a-1]*inv[w-yoko]*inv[a-1]%mod",
"fact[w-yoko+a-1]*inv[w-yoko]*inv[a-1]%mod",
"rr"
] | h,w,a,b=map(int,input().split())
inv=[0]*(2*max(h,w)+1)
fact=[0]*(2*max(h,w)+1)
inv[0]=1;fact[0]=1
mod=10**9+7
for i in range(1,2*max(h,w)+1):
fact[i]=fact[i-1]*i%mod
inv[-1]=pow(fact[-1],mod-2,mod)
for i in range(2*max(h,w),0,-1):
inv[i-1]=inv[i]*i%mod
ans=0
for yoko in range(b+1,w+1):
re=fact[yoko-1+h-1-a]*inv[h-1-a]*inv[yoko-1]%mod
rr=fact[w-yoko+a-1]*inv[w-yoko]*inv[a-1]%mod
ans=(ans+re*rr%mod)%mod
print(ans) |
[
7,
12,
13,
6,
13,
17,
0,
13,
39,
17,
17,
17,
12,
13,
0,
13,
39,
17,
13,
39,
0,
13,
18,
13,
13,
13,
18,
13,
13,
28,
13,
4,
13,
17,
2,
13,
17,
4,
13,
2,
2,
18,
13,
17,
13,
13,
4,
13,
4,
13,
18,
13,
17,
2,
13,
17,
13,
28,
13,
4,
13,
13,
17,
17,
4,
13,
2,
2,
18,
13,
17,
13,
13,
0,
18,
13,
13,
13,
18,
13,
13,
13,
18,
13,
13,
18,
13,
39,
17,
23,
13,
23,
13,
2,
17,
17,
23,
13,
2,
2,
17,
17,
17,
12,
13,
14,
2,
2,
2,
13,
17,
2,
13,
17,
2,
13,
13,
29,
17,
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,
13,
41,
28,
13,
4,
18,
4,
13,
13,
4,
4,
13,
13,
0,
13,
13,
13,
13,
13,
0,
13,
4,
13,
0,
13,
2,
13,
13,
41,
28,
13,
4,
13,
13,
13,
4,
2,
4,
18,
13,
13,
2,
2,
2,
13,
13,
17,
13,
2,
2,
13,
13,
17,
4,
18,
13,
13,
2,
2,
2,
2,
13,
17,
13,
17,
13,
2,
13,
17,
0,
13,
4,
13,
13,
29,
2,
13,
13,
23,
13,
2,
2,
17,
17,
17,
4,
13,
4,
13,
10,
12,
13
] | [
[
8,
7
],
[
16,
15
],
[
19,
18
],
[
22,
21
],
[
15,
23
],
[
26,
25
],
[
18,
27
],
[
31,
30
],
[
92,
35
],
[
21,
38
],
[
15,
42
],
[
30,
44
],
[
97,
45
],
[
25,
47
],
[
15,
51
],
[
97,
54
],
[
97,
56
],
[
59,
58
],
[
92,
61
],
[
25,
65
],
[
18,
69
],
[
58,
71
],
[
97,
72
],
[
77,
74
],
[
90,
75
],
[
97,
76
],
[
97,
77
],
[
81,
78
],
[
90,
79
],
[
15,
81
],
[
85,
82
],
[
90,
83
],
[
18,
86
],
[
90,
90
],
[
93,
92
],
[
98,
97
],
[
146,
109
],
[
148,
112
],
[
146,
115
],
[
148,
116
],
[
144,
125
],
[
146,
127
],
[
144,
130
],
[
148,
132
],
[
144,
135
],
[
146,
138
],
[
148,
139
],
[
144,
141
],
[
144,
144
],
[
146,
146
],
[
148,
148
],
[
153,
152
],
[
152,
161
],
[
164,
163
],
[
164,
165
],
[
164,
166
],
[
164,
167
],
[
170,
169
],
[
174,
173
],
[
163,
175
],
[
165,
176
],
[
180,
179
],
[
167,
182
],
[
165,
183
],
[
169,
188
],
[
104,
189
],
[
163,
193
],
[
166,
194
],
[
179,
196
],
[
163,
199
],
[
166,
200
],
[
169,
204
],
[
104,
205
],
[
166,
210
],
[
165,
212
],
[
179,
214
],
[
166,
216
],
[
220,
219
],
[
219,
225
],
[
228,
226
],
[
229,
228
],
[
240,
237
]
] | [
"def d_iroha_and_a_grid(MOD=10**9 + 7):\n class Combination(object):\n \"\"\"参考: https://harigami.net/contents?id=5f169f85-5707-4137-87a5-f0068749d9bb\"\"\"\n __slots__ = [\"mod\", \"factorial\", \"inverse\"]\n\n def __init__(self, max_n: int = 10**6, mod: int = 10**9 + 7):\n fac, inv = [1], []\n fac_append, inv_append = fac.append, inv.append\n\n for i in range(1, max_n + 1):\n fac_append(fac[-1] * i % mod)\n\n inv_append(pow(fac[-1], mod - 2, mod))\n\n for i in range(max_n, 0, -1):\n inv_append(inv[-1] * i % mod)\n\n self.mod, self.factorial, self.inverse = mod, fac, inv[::-1]\n\n def comb(self, n, r):\n if n < 0 or r < 0 or n < r:\n return 0\n return self.factorial[n] * self.inverse[r] * self.inverse[n - r] % self.mod\n\n H, W, A, B = [int(i) for i in input().split()]\n c = Combination(max_n=H + W)\n # 左上のマスの座標を(0,0)としたとき、B<=i<=W-1を満たすiについて、\n # (0,0)→(H-A-1,i)への行き方 * (H-A-1,i)→(H-A,i)への行き方(1通り) *\n # (H-A,i)→(H-1,W-1)への行き方 の値の総和を取る(10**9+7で剰余を取る)\n ans = sum([c.comb(H - A - 1 + i, H - A - 1)\n * c.comb(A - 1 + W - 1 - i, A - 1) for i in range(B, W)])\n return ans % MOD\n\nprint(d_iroha_and_a_grid())",
"def d_iroha_and_a_grid(MOD=10**9 + 7):\n class Combination(object):\n \"\"\"参考: https://harigami.net/contents?id=5f169f85-5707-4137-87a5-f0068749d9bb\"\"\"\n __slots__ = [\"mod\", \"factorial\", \"inverse\"]\n\n def __init__(self, max_n: int = 10**6, mod: int = 10**9 + 7):\n fac, inv = [1], []\n fac_append, inv_append = fac.append, inv.append\n\n for i in range(1, max_n + 1):\n fac_append(fac[-1] * i % mod)\n\n inv_append(pow(fac[-1], mod - 2, mod))\n\n for i in range(max_n, 0, -1):\n inv_append(inv[-1] * i % mod)\n\n self.mod, self.factorial, self.inverse = mod, fac, inv[::-1]\n\n def comb(self, n, r):\n if n < 0 or r < 0 or n < r:\n return 0\n return self.factorial[n] * self.inverse[r] * self.inverse[n - r] % self.mod\n\n H, W, A, B = [int(i) for i in input().split()]\n c = Combination(max_n=H + W)\n # 左上のマスの座標を(0,0)としたとき、B<=i<=W-1を満たすiについて、\n # (0,0)→(H-A-1,i)への行き方 * (H-A-1,i)→(H-A,i)への行き方(1通り) *\n # (H-A,i)→(H-1,W-1)への行き方 の値の総和を取る(10**9+7で剰余を取る)\n ans = sum([c.comb(H - A - 1 + i, H - A - 1)\n * c.comb(A - 1 + W - 1 - i, A - 1) for i in range(B, W)])\n return ans % MOD",
"d_iroha_and_a_grid",
"class Combination(object):\n \"\"\"参考: https://harigami.net/contents?id=5f169f85-5707-4137-87a5-f0068749d9bb\"\"\"\n __slots__ = [\"mod\", \"factorial\", \"inverse\"]\n\n def __init__(self, max_n: int = 10**6, mod: int = 10**9 + 7):\n fac, inv = [1], []\n fac_append, inv_append = fac.append, inv.append\n\n for i in range(1, max_n + 1):\n fac_append(fac[-1] * i % mod)\n\n inv_append(pow(fac[-1], mod - 2, mod))\n\n for i in range(max_n, 0, -1):\n inv_append(inv[-1] * i % mod)\n\n self.mod, self.factorial, self.inverse = mod, fac, inv[::-1]\n\n def comb(self, n, r):\n if n < 0 or r < 0 or n < r:\n return 0\n return self.factorial[n] * self.inverse[r] * self.inverse[n - r] % self.mod\n\n ",
"Combination",
"\"\"\"参考: https://harigami.net/contents?id=5f169f85-5707-4137-87a5-f0068749d9bb\"\"\"",
"__slots__ = [\"mod\", \"factorial\", \"inverse\"]",
"__slots__",
"[\"mod\", \"factorial\", \"inverse\"]",
"\"mod\"",
"\"factorial\"",
"\"inverse\"",
"def __init__(self, max_n: int = 10**6, mod: int = 10**9 + 7):\n fac, inv = [1], []\n fac_append, inv_append = fac.append, inv.append\n\n for i in range(1, max_n + 1):\n fac_append(fac[-1] * i % mod)\n\n inv_append(pow(fac[-1], mod - 2, mod))\n\n for i in range(max_n, 0, -1):\n inv_append(inv[-1] * i % mod)\n\n self.mod, self.factorial, self.inverse = mod, fac, inv[::-1]\n\n ",
"__init__",
"fac, inv = [1], []",
"fac",
"[1]",
"1",
"inv",
"[]",
"fac_append, inv_append = fac.append, inv.append",
"fac_append",
"fac.append",
"fac",
"append",
"inv_append",
"inv.append",
"inv",
"append",
"for i in range(1, max_n + 1):\n fac_append(fac[-1] * i % mod)\n\n ",
"i",
"range(1, max_n + 1)",
"range",
"1",
"max_n + 1",
"max_n",
"1",
"fac_append(fac[-1] * i % mod)",
"fac_append",
"fac[-1] * i % mod",
"fac[-1] * i",
"fac[-1]",
"fac",
"-1",
"i",
"mod",
"inv_append(pow(fac[-1], mod - 2, mod))",
"inv_append",
"pow(fac[-1], mod - 2, mod)",
"pow",
"fac[-1]",
"fac",
"-1",
"mod - 2",
"mod",
"2",
"mod",
"for i in range(max_n, 0, -1):\n inv_append(inv[-1] * i % mod)\n\n ",
"i",
"range(max_n, 0, -1)",
"range",
"max_n",
"0",
"-1",
"inv_append(inv[-1] * i % mod)",
"inv_append",
"inv[-1] * i % mod",
"inv[-1] * i",
"inv[-1]",
"inv",
"-1",
"i",
"mod",
"self.mod, self.factorial, self.inverse = mod, fac, inv[::-1]",
"self.mod",
"self",
"mod",
"mod",
"self.factorial",
"self",
"factorial",
"fac",
"self.inverse",
"self",
"inverse",
"inv[::-1]",
"inv",
"::-1",
"-1",
"self",
"self",
"max_n: int = 10**6",
"max_n",
"10**6",
"10",
"6",
"mod: int = 10**9 + 7",
"mod",
"10**9 + 7",
"10**9",
"10",
"9",
"7",
"def comb(self, n, r):\n if n < 0 or r < 0 or n < r:\n return 0\n return self.factorial[n] * self.inverse[r] * self.inverse[n - r] % self.mod\n\n ",
"comb",
"if n < 0 or r < 0 or n < r:\n return 0\n ",
"n < 0 or r < 0 or n < r",
"n < 0 or r < 0",
"n < 0",
"n",
"0",
"r < 0",
"r",
"0",
"n < r",
"n",
"r",
"return 0",
"0",
"return self.factorial[n] * self.inverse[r] * self.inverse[n - r] % self.mod",
"self.factorial[n] * self.inverse[r] * self.inverse[n - r] % self.mod",
"self.factorial[n] * self.inverse[r] * self.inverse[n - r]",
"self.factorial[n] * self.inverse[r]",
"self.factorial[n]",
"self.factorial",
"self",
"factorial",
"n",
"self.inverse[r]",
"self.inverse",
"self",
"inverse",
"r",
"self.inverse[n - r]",
"self.inverse",
"self",
"inverse",
"n - r",
"n",
"r",
"self.mod",
"self",
"mod",
"self",
"self",
"n",
"n",
"r",
"r",
"object",
"int(i) for i in input().split()",
"for i in input().split()",
"i",
"input().split()",
"().split",
"()",
"input",
"split",
"for i in input().split()",
"int(i)",
"int",
"i",
"H, W, A, B = [int(i) for i in input().split()]",
"H",
"[int(i) for i in input().split()]",
"W",
"A",
"B",
"c = Combination(max_n=H + W)",
"c",
"Combination(max_n=H + W)",
"Combination",
"max_n=H + W",
"max_n",
"H + W",
"H",
"W",
"c.comb(H - A - 1 + i, H - A - 1)\n * c.comb(A - 1 + W - 1 - i, A - 1) 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)",
"c.comb(H - A - 1 + i, H - A - 1)\n * c.comb(A - 1 + W - 1 - i, A - 1)",
"c.comb(H - A - 1 + i, H - A - 1)",
"c.comb",
"c",
"comb",
"H - A - 1 + i",
"H - A - 1",
"H - A",
"H",
"A",
"1",
"i",
"H - A - 1",
"H - A",
"H",
"A",
"1",
"c.comb(A - 1 + W - 1 - i, A - 1)",
"c.comb",
"c",
"comb",
"A - 1 + W - 1 - i",
"A - 1 + W - 1",
"A - 1 + W",
"A - 1",
"A",
"1",
"W",
"1",
"i",
"A - 1",
"A",
"1",
"ans = sum([c.comb(H - A - 1 + i, H - A - 1)\n * c.comb(A - 1 + W - 1 - i, A - 1) for i in range(B, W)])",
"ans",
"sum([c.comb(H - A - 1 + i, H - A - 1)\n * c.comb(A - 1 + W - 1 - i, A - 1) for i in range(B, W)])",
"sum",
"[c.comb(H - A - 1 + i, H - A - 1)\n * c.comb(A - 1 + W - 1 - i, A - 1) for i in range(B, W)]",
"return ans % MOD",
"ans % MOD",
"ans",
"MOD",
"MOD=10**9 + 7",
"MOD",
"10**9 + 7",
"10**9",
"10",
"9",
"7",
"print(d_iroha_and_a_grid())",
"print",
"d_iroha_and_a_grid()",
"d_iroha_and_a_grid",
"def d_iroha_and_a_grid(MOD=10**9 + 7):\n class Combination(object):\n \"\"\"参考: https://harigami.net/contents?id=5f169f85-5707-4137-87a5-f0068749d9bb\"\"\"\n __slots__ = [\"mod\", \"factorial\", \"inverse\"]\n\n def __init__(self, max_n: int = 10**6, mod: int = 10**9 + 7):\n fac, inv = [1], []\n fac_append, inv_append = fac.append, inv.append\n\n for i in range(1, max_n + 1):\n fac_append(fac[-1] * i % mod)\n\n inv_append(pow(fac[-1], mod - 2, mod))\n\n for i in range(max_n, 0, -1):\n inv_append(inv[-1] * i % mod)\n\n self.mod, self.factorial, self.inverse = mod, fac, inv[::-1]\n\n def comb(self, n, r):\n if n < 0 or r < 0 or n < r:\n return 0\n return self.factorial[n] * self.inverse[r] * self.inverse[n - r] % self.mod\n\n H, W, A, B = [int(i) for i in input().split()]\n c = Combination(max_n=H + W)\n # 左上のマスの座標を(0,0)としたとき、B<=i<=W-1を満たすiについて、\n # (0,0)→(H-A-1,i)への行き方 * (H-A-1,i)→(H-A,i)への行き方(1通り) *\n # (H-A,i)→(H-1,W-1)への行き方 の値の総和を取る(10**9+7で剰余を取る)\n ans = sum([c.comb(H - A - 1 + i, H - A - 1)\n * c.comb(A - 1 + W - 1 - i, A - 1) for i in range(B, W)])\n return ans % MOD",
"def d_iroha_and_a_grid(MOD=10**9 + 7):\n class Combination(object):\n \"\"\"参考: https://harigami.net/contents?id=5f169f85-5707-4137-87a5-f0068749d9bb\"\"\"\n __slots__ = [\"mod\", \"factorial\", \"inverse\"]\n\n def __init__(self, max_n: int = 10**6, mod: int = 10**9 + 7):\n fac, inv = [1], []\n fac_append, inv_append = fac.append, inv.append\n\n for i in range(1, max_n + 1):\n fac_append(fac[-1] * i % mod)\n\n inv_append(pow(fac[-1], mod - 2, mod))\n\n for i in range(max_n, 0, -1):\n inv_append(inv[-1] * i % mod)\n\n self.mod, self.factorial, self.inverse = mod, fac, inv[::-1]\n\n def comb(self, n, r):\n if n < 0 or r < 0 or n < r:\n return 0\n return self.factorial[n] * self.inverse[r] * self.inverse[n - r] % self.mod\n\n H, W, A, B = [int(i) for i in input().split()]\n c = Combination(max_n=H + W)\n # 左上のマスの座標を(0,0)としたとき、B<=i<=W-1を満たすiについて、\n # (0,0)→(H-A-1,i)への行き方 * (H-A-1,i)→(H-A,i)への行き方(1通り) *\n # (H-A,i)→(H-1,W-1)への行き方 の値の総和を取る(10**9+7で剰余を取る)\n ans = sum([c.comb(H - A - 1 + i, H - A - 1)\n * c.comb(A - 1 + W - 1 - i, A - 1) for i in range(B, W)])\n return ans % MOD",
"d_iroha_and_a_grid"
] | def d_iroha_and_a_grid(MOD=10**9 + 7):
class Combination(object):
"""参考: https://harigami.net/contents?id=5f169f85-5707-4137-87a5-f0068749d9bb"""
__slots__ = ["mod", "factorial", "inverse"]
def __init__(self, max_n: int = 10**6, mod: int = 10**9 + 7):
fac, inv = [1], []
fac_append, inv_append = fac.append, inv.append
for i in range(1, max_n + 1):
fac_append(fac[-1] * i % mod)
inv_append(pow(fac[-1], mod - 2, mod))
for i in range(max_n, 0, -1):
inv_append(inv[-1] * i % mod)
self.mod, self.factorial, self.inverse = mod, fac, inv[::-1]
def comb(self, n, r):
if n < 0 or r < 0 or n < r:
return 0
return self.factorial[n] * self.inverse[r] * self.inverse[n - r] % self.mod
H, W, A, B = [int(i) for i in input().split()]
c = Combination(max_n=H + W)
# 左上のマスの座標を(0,0)としたとき、B<=i<=W-1を満たすiについて、
# (0,0)→(H-A-1,i)への行き方 * (H-A-1,i)→(H-A,i)への行き方(1通り) *
# (H-A,i)→(H-1,W-1)への行き方 の値の総和を取る(10**9+7で剰余を取る)
ans = sum([c.comb(H - A - 1 + i, H - A - 1)
* c.comb(A - 1 + W - 1 - i, A - 1) for i in range(B, W)])
return ans % MOD
print(d_iroha_and_a_grid()) |
[
7,
12,
13,
6,
13,
12,
13,
0,
18,
13,
13,
13,
0,
18,
13,
13,
2,
39,
17,
2,
13,
17,
0,
18,
13,
13,
2,
39,
17,
2,
13,
17,
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,
4,
13,
18,
18,
13,
13,
13,
2,
13,
17,
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,
13,
23,
13,
23,
13,
23,
13,
12,
13,
14,
2,
2,
2,
13,
13,
2,
13,
17,
2,
13,
17,
29,
17,
29,
2,
2,
2,
18,
18,
13,
13,
13,
18,
18,
13,
13,
2,
13,
13,
18,
18,
13,
13,
13,
13,
23,
13,
23,
13,
23,
13,
23,
13,
0,
13,
4,
13,
13,
13,
13,
0,
13,
2,
13,
13,
0,
13,
4,
13,
13,
13,
0,
13,
4,
18,
13,
13,
2,
2,
2,
13,
13,
13,
17,
2,
13,
17,
13,
0,
13,
17,
28,
13,
4,
13,
17,
2,
13,
13,
0,
13,
2,
2,
2,
4,
18,
13,
13,
2,
13,
13,
13,
13,
13,
4,
18,
13,
13,
2,
2,
2,
2,
13,
13,
13,
17,
13,
2,
2,
13,
17,
13,
13,
13,
0,
13,
13,
0,
13,
4,
18,
13,
13,
2,
13,
13,
13,
13,
4,
13,
13,
23,
13,
15,
13,
12,
13,
12,
13,
12,
13,
12,
13,
0,
13,
2,
2,
17,
17,
17,
0,
13,
4,
13,
17,
4,
13,
13,
10,
12,
13,
10,
12,
13,
10,
12,
13,
10,
2,
13,
10,
12,
13,
10,
12,
13,
10,
4,
13
] | [
[
11,
8
],
[
103,
9
],
[
105,
10
],
[
105,
11
],
[
16,
13
],
[
103,
14
],
[
105,
20
],
[
26,
23
],
[
103,
24
],
[
105,
30
],
[
34,
33
],
[
105,
38
],
[
46,
41
],
[
13,
42
],
[
103,
43
],
[
33,
45
],
[
13,
49
],
[
103,
50
],
[
33,
53
],
[
33,
55
],
[
107,
56
],
[
63,
58
],
[
23,
59
],
[
103,
60
],
[
105,
62
],
[
13,
66
],
[
103,
67
],
[
105,
69
],
[
107,
71
],
[
107,
73
],
[
76,
75
],
[
105,
79
],
[
89,
84
],
[
23,
85
],
[
103,
86
],
[
75,
88
],
[
23,
92
],
[
103,
93
],
[
75,
96
],
[
75,
99
],
[
107,
101
],
[
103,
103
],
[
105,
105
],
[
107,
107
],
[
151,
114
],
[
149,
115
],
[
149,
117
],
[
151,
120
],
[
147,
130
],
[
149,
132
],
[
147,
135
],
[
149,
138
],
[
151,
139
],
[
147,
142
],
[
151,
144
],
[
153,
145
],
[
147,
147
],
[
149,
149
],
[
151,
151
],
[
153,
153
],
[
156,
155
],
[
156,
158
],
[
156,
159
],
[
156,
160
],
[
163,
162
],
[
155,
164
],
[
158,
165
],
[
168,
167
],
[
162,
170
],
[
253,
171
],
[
174,
173
],
[
167,
176
],
[
109,
177
],
[
158,
181
],
[
155,
182
],
[
160,
183
],
[
155,
186
],
[
253,
188
],
[
191,
190
],
[
194,
193
],
[
155,
198
],
[
159,
199
],
[
202,
201
],
[
167,
207
],
[
109,
208
],
[
160,
210
],
[
193,
211
],
[
193,
212
],
[
253,
213
],
[
190,
214
],
[
239,
214
],
[
167,
217
],
[
109,
218
],
[
158,
223
],
[
155,
224
],
[
160,
225
],
[
193,
227
],
[
155,
230
],
[
193,
232
],
[
253,
233
],
[
253,
234
],
[
237,
236
],
[
253,
237
],
[
240,
239
],
[
167,
242
],
[
109,
243
],
[
160,
245
],
[
193,
246
],
[
193,
247
],
[
253,
248
],
[
236,
251
],
[
201,
251
],
[
173,
251
],
[
253,
253
],
[
289,
265
],
[
298,
272
],
[
281,
277
],
[
290,
278
],
[
289,
290
],
[
298,
299
]
] | [
"def examD(mod):\n class combination():\n def __init__(self, n, mod):\n self.n = n\n self.fac = [1] * (n + 1)\n self.inv = [1] * (n + 1)\n for j in range(1, n + 1):\n self.fac[j] = self.fac[j - 1] * j % mod\n\n self.inv[n] = pow(self.fac[n], mod - 2, mod)\n for j in range(n - 1, -1, -1):\n self.inv[j] = self.inv[j + 1] * (j + 1) % mod\n\n def comb(self, n, r, mod):\n if r > n or n < 0 or r < 0:\n return 0\n return self.fac[n] * self.inv[n - r] * self.inv[r] % mod\n\n H, W, A, B =LI()\n N = H + W\n C = combination(N,mod)\n ans = C.comb(W+H-B-2, H-1,mod)\n pre = 1\n for i in range(1, H-A):\n ans += (C.comb(B+i,i,mod)-pre)*C.comb(W+H-B-2-i, H-1-i,mod)%mod\n ans %= mod\n pre = C.comb(B+i, i,mod)\n print(ans)\n\nimport sys\ndef I(): return int(sys.stdin.readline())\ndef LI(): return list(map(int,sys.stdin.readline().split()))\ndef LS(): return sys.stdin.readline().split()\ndef S(): return sys.stdin.readline().strip()\nmod = 10**9 + 7\ninf = float('inf')\n\nexamD(mod)",
"def examD(mod):\n class combination():\n def __init__(self, n, mod):\n self.n = n\n self.fac = [1] * (n + 1)\n self.inv = [1] * (n + 1)\n for j in range(1, n + 1):\n self.fac[j] = self.fac[j - 1] * j % mod\n\n self.inv[n] = pow(self.fac[n], mod - 2, mod)\n for j in range(n - 1, -1, -1):\n self.inv[j] = self.inv[j + 1] * (j + 1) % mod\n\n def comb(self, n, r, mod):\n if r > n or n < 0 or r < 0:\n return 0\n return self.fac[n] * self.inv[n - r] * self.inv[r] % mod\n\n H, W, A, B =LI()\n N = H + W\n C = combination(N,mod)\n ans = C.comb(W+H-B-2, H-1,mod)\n pre = 1\n for i in range(1, H-A):\n ans += (C.comb(B+i,i,mod)-pre)*C.comb(W+H-B-2-i, H-1-i,mod)%mod\n ans %= mod\n pre = C.comb(B+i, i,mod)\n print(ans)",
"examD",
"class combination():\n def __init__(self, n, mod):\n self.n = n\n self.fac = [1] * (n + 1)\n self.inv = [1] * (n + 1)\n for j in range(1, n + 1):\n self.fac[j] = self.fac[j - 1] * j % mod\n\n self.inv[n] = pow(self.fac[n], mod - 2, mod)\n for j in range(n - 1, -1, -1):\n self.inv[j] = self.inv[j + 1] * (j + 1) % mod\n\n def comb(self, n, r, mod):\n if r > n or n < 0 or r < 0:\n return 0\n return self.fac[n] * self.inv[n - r] * self.inv[r] % mod\n\n ",
"combination",
"def __init__(self, n, mod):\n self.n = n\n self.fac = [1] * (n + 1)\n self.inv = [1] * (n + 1)\n for j in range(1, n + 1):\n self.fac[j] = self.fac[j - 1] * j % mod\n\n self.inv[n] = pow(self.fac[n], mod - 2, mod)\n for j in range(n - 1, -1, -1):\n self.inv[j] = self.inv[j + 1] * (j + 1) % mod\n\n ",
"__init__",
"self.n = n",
"self.n",
"self",
"n",
"n",
"self.fac = [1] * (n + 1)",
"self.fac",
"self",
"fac",
"[1] * (n + 1)",
"[1]",
"1",
"n + 1",
"n",
"1",
"self.inv = [1] * (n + 1)",
"self.inv",
"self",
"inv",
"[1] * (n + 1)",
"[1]",
"1",
"n + 1",
"n",
"1",
"for j in range(1, n + 1):\n self.fac[j] = self.fac[j - 1] * j % mod\n\n ",
"j",
"range(1, n + 1)",
"range",
"1",
"n + 1",
"n",
"1",
"self.fac[j] = self.fac[j - 1] * j % mod",
"self.fac[j]",
"self.fac",
"self",
"fac",
"j",
"self.fac[j - 1] * j % mod",
"self.fac[j - 1] * j",
"self.fac[j - 1]",
"self.fac",
"self",
"fac",
"j - 1",
"j",
"1",
"j",
"mod",
"self.inv[n] = pow(self.fac[n], mod - 2, mod)",
"self.inv[n]",
"self.inv",
"self",
"inv",
"n",
"pow(self.fac[n], mod - 2, mod)",
"pow",
"self.fac[n]",
"self.fac",
"self",
"fac",
"n",
"mod - 2",
"mod",
"2",
"mod",
"for j in range(n - 1, -1, -1):\n self.inv[j] = self.inv[j + 1] * (j + 1) % mod\n\n ",
"j",
"range(n - 1, -1, -1)",
"range",
"n - 1",
"n",
"1",
"-1",
"-1",
"self.inv[j] = self.inv[j + 1] * (j + 1) % mod",
"self.inv[j]",
"self.inv",
"self",
"inv",
"j",
"self.inv[j + 1] * (j + 1) % mod",
"self.inv[j + 1] * (j + 1)",
"self.inv[j + 1]",
"self.inv",
"self",
"inv",
"j + 1",
"j",
"1",
"j + 1",
"j",
"1",
"mod",
"self",
"self",
"n",
"n",
"mod",
"mod",
"def comb(self, n, r, mod):\n if r > n or n < 0 or r < 0:\n return 0\n return self.fac[n] * self.inv[n - r] * self.inv[r] % mod\n\n ",
"comb",
"if r > n or n < 0 or r < 0:\n return 0\n ",
"r > n or n < 0 or r < 0",
"r > n or n < 0",
"r > n",
"r",
"n",
"n < 0",
"n",
"0",
"r < 0",
"r",
"0",
"return 0",
"0",
"return self.fac[n] * self.inv[n - r] * self.inv[r] % mod",
"self.fac[n] * self.inv[n - r] * self.inv[r] % mod",
"self.fac[n] * self.inv[n - r] * self.inv[r]",
"self.fac[n] * self.inv[n - r]",
"self.fac[n]",
"self.fac",
"self",
"fac",
"n",
"self.inv[n - r]",
"self.inv",
"self",
"inv",
"n - r",
"n",
"r",
"self.inv[r]",
"self.inv",
"self",
"inv",
"r",
"mod",
"self",
"self",
"n",
"n",
"r",
"r",
"mod",
"mod",
"H, W, A, B =LI()",
"H",
"LI()",
"LI",
"W",
"A",
"B",
"N = H + W",
"N",
"H + W",
"H",
"W",
"C = combination(N,mod)",
"C",
"combination(N,mod)",
"combination",
"N",
"mod",
"ans = C.comb(W+H-B-2, H-1,mod)",
"ans",
"C.comb(W+H-B-2, H-1,mod)",
"C.comb",
"C",
"comb",
"W+H-B-2",
"W+H-B",
"W+H",
"W",
"H",
"B",
"2",
"H-1",
"H",
"1",
"mod",
"pre = 1",
"pre",
"1",
"for i in range(1, H-A):\n ans += (C.comb(B+i,i,mod)-pre)*C.comb(W+H-B-2-i, H-1-i,mod)%mod\n ans %= mod\n pre = C.comb(B+i, i,mod)\n ",
"i",
"range(1, H-A)",
"range",
"1",
"H-A",
"H",
"A",
"ans += (C.comb(B+i,i,mod)-pre)*C.comb(W+H-B-2-i, H-1-i,mod)%mod",
"ans",
"(C.comb(B+i,i,mod)-pre)*C.comb(W+H-B-2-i, H-1-i,mod)%mod",
"(C.comb(B+i,i,mod)-pre)*C.comb(W+H-B-2-i, H-1-i,mod)",
"C.comb(B+i,i,mod)-pre",
"C.comb(B+i,i,mod)",
"C.comb",
"C",
"comb",
"B+i",
"B",
"i",
"i",
"mod",
"pre",
"C.comb(W+H-B-2-i, H-1-i,mod)",
"C.comb",
"C",
"comb",
"W+H-B-2-i",
"W+H-B-2",
"W+H-B",
"W+H",
"W",
"H",
"B",
"2",
"i",
"H-1-i",
"H-1",
"H",
"1",
"i",
"mod",
"mod",
"ans %= mod",
"ans",
"mod",
"pre = C.comb(B+i, i,mod)",
"pre",
"C.comb(B+i, i,mod)",
"C.comb",
"C",
"comb",
"B+i",
"B",
"i",
"i",
"mod",
"print(ans)",
"print",
"ans",
"mod",
"mod",
"import sys",
"sys",
"def I(): return int(sys.stdin.readline())",
"I",
"def LI(): return list(map(int,sys.stdin.readline().split()))",
"LI",
"def LS(): return sys.stdin.readline().split()",
"LS",
"def S(): return sys.stdin.readline().strip()",
"S",
"mod = 10**9 + 7",
"mod",
"10**9 + 7",
"10**9",
"10",
"9",
"7",
"inf = float('inf')",
"inf",
"float('inf')",
"float",
"'inf'",
"examD(mod)",
"examD",
"mod",
"def examD(mod):\n class combination():\n def __init__(self, n, mod):\n self.n = n\n self.fac = [1] * (n + 1)\n self.inv = [1] * (n + 1)\n for j in range(1, n + 1):\n self.fac[j] = self.fac[j - 1] * j % mod\n\n self.inv[n] = pow(self.fac[n], mod - 2, mod)\n for j in range(n - 1, -1, -1):\n self.inv[j] = self.inv[j + 1] * (j + 1) % mod\n\n def comb(self, n, r, mod):\n if r > n or n < 0 or r < 0:\n return 0\n return self.fac[n] * self.inv[n - r] * self.inv[r] % mod\n\n H, W, A, B =LI()\n N = H + W\n C = combination(N,mod)\n ans = C.comb(W+H-B-2, H-1,mod)\n pre = 1\n for i in range(1, H-A):\n ans += (C.comb(B+i,i,mod)-pre)*C.comb(W+H-B-2-i, H-1-i,mod)%mod\n ans %= mod\n pre = C.comb(B+i, i,mod)\n print(ans)",
"def examD(mod):\n class combination():\n def __init__(self, n, mod):\n self.n = n\n self.fac = [1] * (n + 1)\n self.inv = [1] * (n + 1)\n for j in range(1, n + 1):\n self.fac[j] = self.fac[j - 1] * j % mod\n\n self.inv[n] = pow(self.fac[n], mod - 2, mod)\n for j in range(n - 1, -1, -1):\n self.inv[j] = self.inv[j + 1] * (j + 1) % mod\n\n def comb(self, n, r, mod):\n if r > n or n < 0 or r < 0:\n return 0\n return self.fac[n] * self.inv[n - r] * self.inv[r] % mod\n\n H, W, A, B =LI()\n N = H + W\n C = combination(N,mod)\n ans = C.comb(W+H-B-2, H-1,mod)\n pre = 1\n for i in range(1, H-A):\n ans += (C.comb(B+i,i,mod)-pre)*C.comb(W+H-B-2-i, H-1-i,mod)%mod\n ans %= mod\n pre = C.comb(B+i, i,mod)\n print(ans)",
"examD",
"def LS(): return sys.stdin.readline().split()",
"def LS(): return sys.stdin.readline().split()",
"LS",
"def I(): return int(sys.stdin.readline())",
"def I(): return int(sys.stdin.readline())",
"I",
"mod = 10**9 + 7",
"10**9 + 7",
"mod",
"def S(): return sys.stdin.readline().strip()",
"def S(): return sys.stdin.readline().strip()",
"S",
"def LI(): return list(map(int,sys.stdin.readline().split()))",
"def LI(): return list(map(int,sys.stdin.readline().split()))",
"LI",
"inf = float('inf')",
"float('inf')",
"inf"
] | def examD(mod):
class combination():
def __init__(self, n, mod):
self.n = n
self.fac = [1] * (n + 1)
self.inv = [1] * (n + 1)
for j in range(1, n + 1):
self.fac[j] = self.fac[j - 1] * j % mod
self.inv[n] = pow(self.fac[n], mod - 2, mod)
for j in range(n - 1, -1, -1):
self.inv[j] = self.inv[j + 1] * (j + 1) % mod
def comb(self, n, r, mod):
if r > n or n < 0 or r < 0:
return 0
return self.fac[n] * self.inv[n - r] * self.inv[r] % mod
H, W, A, B =LI()
N = H + W
C = combination(N,mod)
ans = C.comb(W+H-B-2, H-1,mod)
pre = 1
for i in range(1, H-A):
ans += (C.comb(B+i,i,mod)-pre)*C.comb(W+H-B-2-i, H-1-i,mod)%mod
ans %= mod
pre = C.comb(B+i, i,mod)
print(ans)
import sys
def I(): return int(sys.stdin.readline())
def LI(): return list(map(int,sys.stdin.readline().split()))
def LS(): return sys.stdin.readline().split()
def S(): return sys.stdin.readline().strip()
mod = 10**9 + 7
inf = float('inf')
examD(mod) |
[
7,
12,
13,
14,
2,
13,
17,
29,
13,
29,
4,
13,
2,
13,
13,
13,
23,
13,
23,
13,
12,
13,
0,
13,
4,
13,
13,
13,
14,
40,
13,
17,
29,
17,
29,
4,
13,
13,
2,
13,
17,
13,
23,
13,
23,
13,
12,
13,
0,
13,
2,
13,
13,
0,
13,
4,
13,
13,
13,
14,
2,
13,
17,
4,
13,
17,
29,
2,
2,
13,
13,
13,
23,
13,
23,
13,
23,
13,
0,
13,
2,
2,
17,
17,
17,
0,
13,
4,
13,
4,
13,
13,
4,
18,
4,
13,
13,
17,
13,
13,
13,
0,
13,
39,
0,
13,
17,
28,
13,
4,
13,
17,
17,
0,
13,
13,
0,
13,
13,
4,
18,
13,
13,
13,
12,
13,
14,
2,
13,
17,
29,
17,
41,
29,
18,
13,
2,
13,
17,
23,
13,
12,
13,
0,
13,
17,
0,
13,
2,
13,
13,
0,
13,
2,
2,
13,
2,
13,
13,
17,
0,
13,
2,
13,
17,
0,
13,
17,
28,
13,
4,
13,
13,
2,
13,
17,
0,
13,
2,
2,
4,
13,
2,
2,
13,
13,
17,
4,
13,
2,
2,
4,
13,
2,
13,
17,
4,
13,
2,
13,
17,
13,
13,
13,
0,
13,
13,
0,
13,
13,
0,
13,
13,
0,
13,
2,
2,
4,
13,
2,
2,
13,
2,
2,
13,
13,
17,
17,
4,
13,
2,
2,
4,
13,
2,
13,
17,
4,
13,
2,
13,
13,
13,
13,
13,
0,
13,
2,
13,
13,
29,
13,
23,
13,
23,
13,
23,
13,
23,
13,
0,
13,
4,
13,
13,
13,
13,
13,
4,
13,
2,
13,
2,
2,
17,
17,
17,
10,
17,
13,
10,
4,
13,
10,
2,
13,
10,
39,
13,
10,
4,
13,
10,
4,
13,
10,
4,
13,
10,
12,
13,
10,
12,
13,
10,
12,
13,
10,
13,
13,
10,
12,
13,
10,
4,
13,
10,
12,
13,
10,
13,
13
] | [
[
17,
5
],
[
19,
8
],
[
19,
13
],
[
17,
14
],
[
17,
15
],
[
17,
17
],
[
19,
19
],
[
24,
23
],
[
312,
25
],
[
43,
26
],
[
45,
27
],
[
23,
30
],
[
43,
37
],
[
45,
39
],
[
45,
41
],
[
43,
43
],
[
45,
45
],
[
50,
49
],
[
73,
51
],
[
77,
52
],
[
55,
54
],
[
300,
56
],
[
75,
57
],
[
77,
58
],
[
54,
61
],
[
54,
69
],
[
49,
70
],
[
73,
70
],
[
77,
71
],
[
73,
73
],
[
75,
75
],
[
77,
77
],
[
284,
79
],
[
314,
86
],
[
314,
98
],
[
314,
99
],
[
314,
100
],
[
287,
102
],
[
278,
105
],
[
109,
108
],
[
308,
114
],
[
108,
115
],
[
320,
117
],
[
285,
118
],
[
288,
121
],
[
321,
123
],
[
309,
123
],
[
279,
123
],
[
140,
128
],
[
140,
137
],
[
140,
140
],
[
145,
144
],
[
148,
147
],
[
253,
149
],
[
257,
150
],
[
153,
152
],
[
255,
155
],
[
255,
157
],
[
259,
158
],
[
162,
161
],
[
257,
163
],
[
167,
166
],
[
170,
169
],
[
152,
172
],
[
255,
174
],
[
178,
177
],
[
303,
181
],
[
147,
184
],
[
169,
185
],
[
300,
188
],
[
303,
192
],
[
147,
194
],
[
303,
197
],
[
169,
199
],
[
285,
201
],
[
285,
202
],
[
285,
203
],
[
206,
205
],
[
177,
206
],
[
208,
206
],
[
209,
208
],
[
166,
209
],
[
211,
209
],
[
212,
211
],
[
205,
212
],
[
215,
214
],
[
303,
218
],
[
161,
221
],
[
255,
224
],
[
169,
225
],
[
300,
229
],
[
303,
233
],
[
161,
235
],
[
303,
238
],
[
255,
240
],
[
169,
241
],
[
285,
242
],
[
285,
243
],
[
285,
244
],
[
247,
246
],
[
208,
248
],
[
177,
248
],
[
214,
249
],
[
246,
251
],
[
144,
251
],
[
253,
253
],
[
255,
255
],
[
257,
257
],
[
259,
259
],
[
281,
261
],
[
318,
263
],
[
291,
264
],
[
297,
265
],
[
294,
266
],
[
315,
267
],
[
282,
271
],
[
278,
279
],
[
281,
282
],
[
284,
285
],
[
287,
288
],
[
314,
291
],
[
314,
294
],
[
314,
297
],
[
108,
308
],
[
308,
309
],
[
314,
315
],
[
285,
320
],
[
320,
321
]
] | [
"\n# Function to find modulo inverse of b. It returns \n# -1 when inverse doesn't \n# modInverse works for prime m \ndef gcd(b, m):\n if b == 0:\n return m\n return gcd(m%b, b)\n\ndef modInverse(b,m): \n g = gcd(b, m) \n if (g != 1): \n # print(\"Inverse doesn't exist\") \n return -1\n else: \n # If b and m are relatively prime, \n # then modulo inverse is b^(m-2) mode m \n return pow(b, m - 2, m) \n \n \n# Function to compute a/b under modulo m \ndef modDivide(a,b,m): \n a = a % m \n inv = modInverse(b,m) \n if(inv == -1): \n print(\"Division not defined\") \n else: \n return (inv*a) % m\n\nMOD = (10 ** 9) + 7\nH, W, A, B = list(map(int, input().split(' ')))\n\nDP = []\nj = 1\nfor i in range(1,200002):\n j *= i\n j %= MOD\n DP.append(j)\n\n# print(DP)\ndef factorial(i):\n if (i == 0):\n return 1\n global DP\n # print(i)\n # print(i, DP[i-1])\n # print(DP[i-1])\n return DP[i-1]\n\ndef move2(H, W, A, B):\n numPaths = 0\n h = H-A\n w = W-(W-B)+1\n a = A+1\n pttp = 0\n for b in range(w, W+1):\n # print(h, b, a, W-b+1)\n ttp = (factorial(h+b-2)*modInverse((factorial(h-1)*factorial(b-1))% MOD, MOD)) % MOD\n tpttp = ttp\n ttp -= pttp\n pttp = tpttp\n btp = (factorial(a+(W-b+1)-2)*modInverse((factorial(a-1)*factorial(W-b))% MOD, MOD)) % MOD\n # btp = factorial(a+(W-b+1)-2)//(factorial(a-1)*factorial(W-b))\n numPaths += ttp*btp\n return numPaths\n\nways = move2(H, W, A, B)\nprint(ways % (10**9 + 7))",
"def gcd(b, m):\n if b == 0:\n return m\n return gcd(m%b, b)",
"gcd",
"if b == 0:\n return m\n ",
"b == 0",
"b",
"0",
"return m",
"m",
"return gcd(m%b, b)",
"gcd(m%b, b)",
"gcd",
"m%b",
"m",
"b",
"b",
"b",
"b",
"m",
"m",
"def modInverse(b,m): \n g = gcd(b, m) \n if (g != 1): \n # print(\"Inverse doesn't exist\") \n return -1\n else: \n # If b and m are relatively prime, \n # then modulo inverse is b^(m-2) mode m \n return pow(b, m - 2, m) \n \n \n# Function to compute a/b under modulo m ",
"modInverse",
"g = gcd(b, m)",
"g",
"gcd(b, m)",
"gcd",
"b",
"m",
"if (g != 1): \n # print(\"Inverse doesn't exist\") \n return -1\n else: \n # If b and m are relatively prime, \n # then modulo inverse is b^(m-2) mode m \n return pow(b, m - 2, m) \n \n \n# Function to compute a/b under modulo m ",
"g != 1",
"g",
"1",
"return -1",
"-1",
"return pow(b, m - 2, m)",
"pow(b, m - 2, m)",
"pow",
"b",
"m - 2",
"m",
"2",
"m",
"b",
"b",
"m",
"m",
"def modDivide(a,b,m): \n a = a % m \n inv = modInverse(b,m) \n if(inv == -1): \n print(\"Division not defined\") \n else: \n return (inv*a) % m",
"modDivide",
"a = a % m",
"a",
"a % m",
"a",
"m",
"inv = modInverse(b,m)",
"inv",
"modInverse(b,m)",
"modInverse",
"b",
"m",
"if(inv == -1): \n print(\"Division not defined\") \n else: \n return (inv*a) % m",
"inv == -1",
"inv",
"-1",
"print(\"Division not defined\")",
"print",
"\"Division not defined\"",
"return (inv*a) % m",
"(inv*a) % m",
"inv*a",
"inv",
"a",
"m",
"a",
"a",
"b",
"b",
"m",
"m",
"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",
"DP = []",
"DP",
"[]",
"j = 1",
"j",
"1",
"for i in range(1,200002):\n j *= i\n j %= MOD\n DP.append(j)\n\n# print(DP)",
"i",
"range(1,200002)",
"range",
"1",
"200002",
"j *= i",
"j",
"i",
"j %= MOD",
"j",
"MOD",
"DP.append(j)",
"DP.append",
"DP",
"append",
"j",
"def factorial(i):\n if (i == 0):\n return 1\n global DP\n # print(i)\n # print(i, DP[i-1])\n # print(DP[i-1])\n return DP[i-1]",
"factorial",
"if (i == 0):\n return 1\n ",
"i == 0",
"i",
"0",
"return 1",
"1",
"global DP",
"return DP[i-1]",
"DP[i-1]",
"DP",
"i-1",
"i",
"1",
"i",
"i",
"def move2(H, W, A, B):\n numPaths = 0\n h = H-A\n w = W-(W-B)+1\n a = A+1\n pttp = 0\n for b in range(w, W+1):\n # print(h, b, a, W-b+1)\n ttp = (factorial(h+b-2)*modInverse((factorial(h-1)*factorial(b-1))% MOD, MOD)) % MOD\n tpttp = ttp\n ttp -= pttp\n pttp = tpttp\n btp = (factorial(a+(W-b+1)-2)*modInverse((factorial(a-1)*factorial(W-b))% MOD, MOD)) % MOD\n # btp = factorial(a+(W-b+1)-2)//(factorial(a-1)*factorial(W-b))\n numPaths += ttp*btp\n return numPaths",
"move2",
"numPaths = 0",
"numPaths",
"0",
"h = H-A",
"h",
"H-A",
"H",
"A",
"w = W-(W-B)+1",
"w",
"W-(W-B)+1",
"W-(W-B)",
"W",
"W-B",
"W",
"B",
"1",
"a = A+1",
"a",
"A+1",
"A",
"1",
"pttp = 0",
"pttp",
"0",
"for b in range(w, W+1):\n # print(h, b, a, W-b+1)\n ttp = (factorial(h+b-2)*modInverse((factorial(h-1)*factorial(b-1))% MOD, MOD)) % MOD\n tpttp = ttp\n ttp -= pttp\n pttp = tpttp\n btp = (factorial(a+(W-b+1)-2)*modInverse((factorial(a-1)*factorial(W-b))% MOD, MOD)) % MOD\n # btp = factorial(a+(W-b+1)-2)//(factorial(a-1)*factorial(W-b))\n numPaths += ttp*btp\n ",
"b",
"range(w, W+1)",
"range",
"w",
"W+1",
"W",
"1",
"ttp = (factorial(h+b-2)*modInverse((factorial(h-1)*factorial(b-1))% MOD, MOD)) % MOD",
"ttp",
"(factorial(h+b-2)*modInverse((factorial(h-1)*factorial(b-1))% MOD, MOD)) % MOD",
"factorial(h+b-2)*modInverse((factorial(h-1)*factorial(b-1))% MOD, MOD)",
"factorial(h+b-2)",
"factorial",
"h+b-2",
"h+b",
"h",
"b",
"2",
"modInverse((factorial(h-1)*factorial(b-1))% MOD, MOD)",
"modInverse",
"(factorial(h-1)*factorial(b-1))% MOD",
"factorial(h-1)*factorial(b-1)",
"factorial(h-1)",
"factorial",
"h-1",
"h",
"1",
"factorial(b-1)",
"factorial",
"b-1",
"b",
"1",
"MOD",
"MOD",
"MOD",
"tpttp = ttp",
"tpttp",
"ttp",
"ttp -= pttp",
"ttp",
"pttp",
"pttp = tpttp",
"pttp",
"tpttp",
"btp = (factorial(a+(W-b+1)-2)*modInverse((factorial(a-1)*factorial(W-b))% MOD, MOD)) % MOD",
"btp",
"(factorial(a+(W-b+1)-2)*modInverse((factorial(a-1)*factorial(W-b))% MOD, MOD)) % MOD",
"factorial(a+(W-b+1)-2)*modInverse((factorial(a-1)*factorial(W-b))% MOD, MOD)",
"factorial(a+(W-b+1)-2)",
"factorial",
"a+(W-b+1)-2",
"a+(W-b+1)",
"a",
"W-b+1",
"W-b",
"W",
"b",
"1",
"2",
"modInverse((factorial(a-1)*factorial(W-b))% MOD, MOD)",
"modInverse",
"(factorial(a-1)*factorial(W-b))% MOD",
"factorial(a-1)*factorial(W-b)",
"factorial(a-1)",
"factorial",
"a-1",
"a",
"1",
"factorial(W-b)",
"factorial",
"W-b",
"W",
"b",
"MOD",
"MOD",
"MOD",
"numPaths += ttp*btp",
"numPaths",
"ttp*btp",
"ttp",
"btp",
"return numPaths",
"numPaths",
"H",
"H",
"W",
"W",
"A",
"A",
"B",
"B",
"ways = move2(H, W, A, B)",
"ways",
"move2(H, W, A, B)",
"move2",
"H",
"W",
"A",
"B",
"print(ways % (10**9 + 7))",
"print",
"ways % (10**9 + 7)",
"ways",
"10**9 + 7",
"10**9",
"10",
"9",
"7",
"j = 1",
"1",
"j",
"ways = move2(H, W, A, B)",
"move2(H, W, A, B)",
"ways",
"MOD = (10 ** 9) + 7",
"(10 ** 9) + 7",
"MOD",
"DP = []",
"[]",
"DP",
"H, W, A, B = list(map(int, input().split(' ')))",
"list(map(int, input().split(' ')))",
"H",
"A, B = list(map(int, input().split(' ')))",
"list(map(int, input().split(' ')))",
"A",
"W, A, B = list(map(int, input().split(' ')))",
"list(map(int, input().split(' ')))",
"W",
"def modInverse(b,m): \n g = gcd(b, m) \n if (g != 1): \n # print(\"Inverse doesn't exist\") \n return -1\n else: \n # If b and m are relatively prime, \n # then modulo inverse is b^(m-2) mode m \n return pow(b, m - 2, m) \n \n \n# Function to compute a/b under modulo m ",
"def modInverse(b,m): \n g = gcd(b, m) \n if (g != 1): \n # print(\"Inverse doesn't exist\") \n return -1\n else: \n # If b and m are relatively prime, \n # then modulo inverse is b^(m-2) mode m \n return pow(b, m - 2, m) \n \n \n# Function to compute a/b under modulo m ",
"modInverse",
"def factorial(i):\n if (i == 0):\n return 1\n global DP\n # print(i)\n # print(i, DP[i-1])\n # print(DP[i-1])\n return DP[i-1]",
"def factorial(i):\n if (i == 0):\n return 1\n global DP\n # print(i)\n # print(i, DP[i-1])\n # print(DP[i-1])\n return DP[i-1]",
"factorial",
"def modDivide(a,b,m): \n a = a % m \n inv = modInverse(b,m) \n if(inv == -1): \n print(\"Division not defined\") \n else: \n return (inv*a) % m",
"def modDivide(a,b,m): \n a = a % m \n inv = modInverse(b,m) \n if(inv == -1): \n print(\"Division not defined\") \n else: \n return (inv*a) % m",
"modDivide",
"j *= i",
"i",
"j",
"def gcd(b, m):\n if b == 0:\n return m\n return gcd(m%b, b)",
"def gcd(b, m):\n if b == 0:\n return m\n return gcd(m%b, b)",
"gcd",
"B = list(map(int, input().split(' ')))",
"list(map(int, input().split(' ')))",
"B",
"def move2(H, W, A, B):\n numPaths = 0\n h = H-A\n w = W-(W-B)+1\n a = A+1\n pttp = 0\n for b in range(w, W+1):\n # print(h, b, a, W-b+1)\n ttp = (factorial(h+b-2)*modInverse((factorial(h-1)*factorial(b-1))% MOD, MOD)) % MOD\n tpttp = ttp\n ttp -= pttp\n pttp = tpttp\n btp = (factorial(a+(W-b+1)-2)*modInverse((factorial(a-1)*factorial(W-b))% MOD, MOD)) % MOD\n # btp = factorial(a+(W-b+1)-2)//(factorial(a-1)*factorial(W-b))\n numPaths += ttp*btp\n return numPaths",
"def move2(H, W, A, B):\n numPaths = 0\n h = H-A\n w = W-(W-B)+1\n a = A+1\n pttp = 0\n for b in range(w, W+1):\n # print(h, b, a, W-b+1)\n ttp = (factorial(h+b-2)*modInverse((factorial(h-1)*factorial(b-1))% MOD, MOD)) % MOD\n tpttp = ttp\n ttp -= pttp\n pttp = tpttp\n btp = (factorial(a+(W-b+1)-2)*modInverse((factorial(a-1)*factorial(W-b))% MOD, MOD)) % MOD\n # btp = factorial(a+(W-b+1)-2)//(factorial(a-1)*factorial(W-b))\n numPaths += ttp*btp\n return numPaths",
"move2",
"j %= MOD",
"MOD",
"j"
] |
# Function to find modulo inverse of b. It returns
# -1 when inverse doesn't
# modInverse works for prime m
def gcd(b, m):
if b == 0:
return m
return gcd(m%b, b)
def modInverse(b,m):
g = gcd(b, m)
if (g != 1):
# print("Inverse doesn't exist")
return -1
else:
# If b and m are relatively prime,
# then modulo inverse is b^(m-2) mode m
return pow(b, m - 2, m)
# Function to compute a/b under modulo m
def modDivide(a,b,m):
a = a % m
inv = modInverse(b,m)
if(inv == -1):
print("Division not defined")
else:
return (inv*a) % m
MOD = (10 ** 9) + 7
H, W, A, B = list(map(int, input().split(' ')))
DP = []
j = 1
for i in range(1,200002):
j *= i
j %= MOD
DP.append(j)
# print(DP)
def factorial(i):
if (i == 0):
return 1
global DP
# print(i)
# print(i, DP[i-1])
# print(DP[i-1])
return DP[i-1]
def move2(H, W, A, B):
numPaths = 0
h = H-A
w = W-(W-B)+1
a = A+1
pttp = 0
for b in range(w, W+1):
# print(h, b, a, W-b+1)
ttp = (factorial(h+b-2)*modInverse((factorial(h-1)*factorial(b-1))% MOD, MOD)) % MOD
tpttp = ttp
ttp -= pttp
pttp = tpttp
btp = (factorial(a+(W-b+1)-2)*modInverse((factorial(a-1)*factorial(W-b))% MOD, MOD)) % MOD
# btp = factorial(a+(W-b+1)-2)//(factorial(a-1)*factorial(W-b))
numPaths += ttp*btp
return numPaths
ways = move2(H, W, A, B)
print(ways % (10**9 + 7)) |
[
7,
0,
13,
4,
13,
13,
4,
18,
4,
13,
13,
13,
13,
13,
0,
13,
2,
17,
2,
17,
17,
0,
13,
2,
17,
2,
17,
17,
0,
13,
2,
2,
17,
17,
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,
40,
18,
13,
2,
13,
13,
2,
13,
13,
13,
12,
13,
28,
13,
4,
13,
17,
2,
13,
17,
0,
18,
13,
13,
2,
2,
13,
18,
13,
2,
13,
17,
13,
0,
18,
13,
17,
17,
28,
13,
4,
13,
17,
2,
13,
17,
0,
18,
13,
13,
2,
2,
18,
13,
13,
18,
13,
2,
13,
17,
13,
29,
23,
13,
23,
13,
12,
13,
14,
2,
2,
13,
17,
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,
2,
39,
17,
2,
13,
17,
0,
13,
2,
39,
17,
2,
13,
17,
4,
13,
13,
13,
0,
13,
2,
39,
17,
2,
13,
13,
0,
13,
2,
2,
13,
13,
17,
28,
13,
4,
13,
2,
13,
13,
0,
18,
13,
13,
4,
13,
2,
2,
13,
13,
13,
2,
13,
13,
0,
13,
2,
39,
17,
2,
13,
13,
0,
13,
13,
28,
13,
4,
13,
2,
13,
13,
0,
18,
13,
13,
4,
13,
2,
2,
2,
2,
13,
13,
13,
13,
17,
2,
2,
2,
13,
13,
13,
17,
28,
13,
4,
13,
2,
2,
13,
13,
17,
0,
18,
13,
13,
18,
13,
2,
13,
17,
28,
13,
4,
13,
2,
13,
13,
0,
18,
13,
13,
2,
2,
18,
13,
13,
18,
13,
13,
13,
4,
13,
2,
4,
13,
13,
13,
10,
2,
13,
10,
2,
13,
10,
12,
13,
10,
2,
13,
10,
4,
13,
10,
2,
13,
10,
13,
13,
10,
4,
13,
10,
2,
13,
10,
12,
13,
10,
4,
13,
10,
4,
13,
10,
2,
13,
10,
2,
13,
10,
2,
13,
10,
2,
13
] | [
[
335,
2
],
[
335,
11
],
[
335,
12
],
[
335,
13
],
[
302,
15
],
[
347,
22
],
[
344,
29
],
[
317,
36
],
[
348,
41
],
[
47,
44
],
[
318,
45
],
[
50,
49
],
[
348,
54
],
[
60,
57
],
[
318,
58
],
[
49,
59
],
[
318,
64
],
[
345,
66
],
[
49,
67
],
[
345,
69
],
[
49,
70
],
[
345,
71
],
[
76,
75
],
[
125,
80
],
[
86,
83
],
[
75,
85
],
[
75,
88
],
[
75,
92
],
[
345,
94
],
[
99,
96
],
[
102,
101
],
[
127,
106
],
[
112,
109
],
[
101,
111
],
[
57,
114
],
[
318,
115
],
[
101,
116
],
[
101,
120
],
[
345,
122
],
[
125,
125
],
[
127,
127
],
[
157,
133
],
[
159,
136
],
[
157,
146
],
[
159,
149
],
[
157,
153
],
[
159,
154
],
[
345,
155
],
[
157,
157
],
[
159,
159
],
[
338,
161
],
[
303,
166
],
[
341,
169
],
[
303,
174
],
[
330,
177
],
[
303,
178
],
[
303,
179
],
[
326,
181
],
[
315,
186
],
[
324,
187
],
[
311,
189
],
[
336,
192
],
[
333,
193
],
[
197,
196
],
[
315,
200
],
[
324,
201
],
[
206,
203
],
[
327,
204
],
[
196,
205
],
[
309,
207
],
[
312,
210
],
[
196,
211
],
[
324,
212
],
[
196,
214
],
[
324,
215
],
[
305,
217
],
[
315,
222
],
[
324,
223
],
[
320,
225
],
[
333,
226
],
[
229,
228
],
[
315,
232
],
[
324,
233
],
[
238,
235
],
[
306,
236
],
[
228,
237
],
[
309,
239
],
[
321,
244
],
[
312,
244
],
[
315,
245
],
[
324,
246
],
[
228,
247
],
[
315,
252
],
[
324,
253
],
[
228,
254
],
[
258,
257
],
[
315,
262
],
[
324,
263
],
[
269,
266
],
[
306,
267
],
[
257,
268
],
[
306,
270
],
[
257,
272
],
[
276,
275
],
[
315,
279
],
[
324,
280
],
[
285,
282
],
[
327,
283
],
[
275,
284
],
[
203,
287
],
[
282,
287
],
[
327,
288
],
[
275,
289
],
[
266,
290
],
[
235,
290
],
[
306,
291
],
[
275,
292
],
[
345,
293
],
[
327,
299
],
[
345,
300
],
[
302,
303
],
[
305,
306
],
[
311,
312
],
[
335,
315
],
[
317,
318
],
[
333,
320
],
[
320,
321
],
[
335,
324
],
[
326,
327
],
[
335,
333
],
[
335,
336
],
[
338,
339
],
[
341,
342
],
[
344,
345
],
[
347,
348
]
] | [
"h, w, a, b = map(int, input().split())\n\nn = 2 * 10 ** 5\nk = 2 * 10 ** 5\nmod = 10**9 + 7\n\nmodinv_table = [-1] * (k+1)\nmodinv_table[1] = 1\nfor i in range(2, k+1):\n modinv_table[i] = (-modinv_table[mod % i] * (mod // i)) % mod\n\ndef prepare_binomial_coefficients(n, k):\n for i in range(1,n+1):\n bc_num[i] = i * bc_num[i-1] % mod\n bc_num[0] = 0\n for i in range(1,k+1):\n bc_den[i] = modinv_table[i] * bc_den[i-1] % mod\n return\n\ndef binomial_coefficients(n, k):\n if n == 0 and k == 0:\n return 1\n return bc_num[n] * bc_den[k] * bc_den[n-k] % mod\n\nbc_num = [1]*(n+1)\nbc_den = [1]*(n+1)\nprepare_binomial_coefficients(n, n)\n\nmids = [0]*(w-b)\ndis_mid = h - a - 1\nfor i in range(w-b):\n mids[i] = binomial_coefficients(dis_mid+i+b,i+b)\n\n#print(mids)\n\nmids_down = [0]*(w-b)\ndis_mid = a\nfor i in range(w-b):\n mids_down[i] = binomial_coefficients(dis_mid+w-b-i-1,w-b-i-1)\n\n#print(mids_down)\n\nfor i in range(w-b-1):\n mids_down[i] -= mids_down[i+1]\n\n#print(mids_down)\n\nfor i in range(w-b):\n mids[i] = (mids[i] * mids_down[i]) % mod\n\n#print(mids)\n\nprint(sum(mids)%mod)",
"h, w, a, b = map(int, input().split())",
"h",
"map(int, input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"w",
"a",
"b",
"n = 2 * 10 ** 5",
"n",
"2 * 10 ** 5",
"2",
"10 ** 5",
"10",
"5",
"k = 2 * 10 ** 5",
"k",
"2 * 10 ** 5",
"2",
"10 ** 5",
"10",
"5",
"mod = 10**9 + 7",
"mod",
"10**9 + 7",
"10**9",
"10",
"9",
"7",
"modinv_table = [-1] * (k+1)",
"modinv_table",
"[-1] * (k+1)",
"[-1]",
"-1",
"k+1",
"k",
"1",
"modinv_table[1] = 1",
"modinv_table[1]",
"modinv_table",
"1",
"1",
"for i in range(2, k+1):\n modinv_table[i] = (-modinv_table[mod % i] * (mod // i)) % mod",
"i",
"range(2, k+1)",
"range",
"2",
"k+1",
"k",
"1",
"modinv_table[i] = (-modinv_table[mod % i] * (mod // i)) % mod",
"modinv_table[i]",
"modinv_table",
"i",
"(-modinv_table[mod % i] * (mod // i)) % mod",
"-modinv_table[mod % i] * (mod // i)",
"-modinv_table[mod % i]",
"modinv_table[mod % i]",
"modinv_table",
"mod % i",
"mod",
"i",
"mod // i",
"mod",
"i",
"mod",
"def prepare_binomial_coefficients(n, k):\n for i in range(1,n+1):\n bc_num[i] = i * bc_num[i-1] % mod\n bc_num[0] = 0\n for i in range(1,k+1):\n bc_den[i] = modinv_table[i] * bc_den[i-1] % mod\n return",
"prepare_binomial_coefficients",
"for i in range(1,n+1):\n bc_num[i] = i * bc_num[i-1] % mod\n ",
"i",
"range(1,n+1)",
"range",
"1",
"n+1",
"n",
"1",
"bc_num[i] = i * bc_num[i-1] % mod",
"bc_num[i]",
"bc_num",
"i",
"i * bc_num[i-1] % mod",
"i * bc_num[i-1]",
"i",
"bc_num[i-1]",
"bc_num",
"i-1",
"i",
"1",
"mod",
"bc_num[0] = 0",
"bc_num[0]",
"bc_num",
"0",
"0",
"for i in range(1,k+1):\n bc_den[i] = modinv_table[i] * bc_den[i-1] % mod\n ",
"i",
"range(1,k+1)",
"range",
"1",
"k+1",
"k",
"1",
"bc_den[i] = modinv_table[i] * bc_den[i-1] % mod",
"bc_den[i]",
"bc_den",
"i",
"modinv_table[i] * bc_den[i-1] % mod",
"modinv_table[i] * bc_den[i-1]",
"modinv_table[i]",
"modinv_table",
"i",
"bc_den[i-1]",
"bc_den",
"i-1",
"i",
"1",
"mod",
"return",
"n",
"n",
"k",
"k",
"def binomial_coefficients(n, k):\n if n == 0 and k == 0:\n return 1\n return bc_num[n] * bc_den[k] * bc_den[n-k] % mod",
"binomial_coefficients",
"if n == 0 and k == 0:\n return 1\n ",
"n == 0 and k == 0",
"n == 0",
"n",
"0",
"k == 0",
"k",
"0",
"return 1",
"1",
"return bc_num[n] * bc_den[k] * bc_den[n-k] % mod",
"bc_num[n] * bc_den[k] * bc_den[n-k] % mod",
"bc_num[n] * bc_den[k] * bc_den[n-k]",
"bc_num[n] * bc_den[k]",
"bc_num[n]",
"bc_num",
"n",
"bc_den[k]",
"bc_den",
"k",
"bc_den[n-k]",
"bc_den",
"n-k",
"n",
"k",
"mod",
"n",
"n",
"k",
"k",
"bc_num = [1]*(n+1)",
"bc_num",
"[1]*(n+1)",
"[1]",
"1",
"n+1",
"n",
"1",
"bc_den = [1]*(n+1)",
"bc_den",
"[1]*(n+1)",
"[1]",
"1",
"n+1",
"n",
"1",
"prepare_binomial_coefficients(n, n)",
"prepare_binomial_coefficients",
"n",
"n",
"mids = [0]*(w-b)",
"mids",
"[0]*(w-b)",
"[0]",
"0",
"w-b",
"w",
"b",
"dis_mid = h - a - 1",
"dis_mid",
"h - a - 1",
"h - a",
"h",
"a",
"1",
"for i in range(w-b):\n mids[i] = binomial_coefficients(dis_mid+i+b,i+b)\n\n#print(mids)",
"i",
"range(w-b)",
"range",
"w-b",
"w",
"b",
"mids[i] = binomial_coefficients(dis_mid+i+b,i+b)",
"mids[i]",
"mids",
"i",
"binomial_coefficients(dis_mid+i+b,i+b)",
"binomial_coefficients",
"dis_mid+i+b",
"dis_mid+i",
"dis_mid",
"i",
"b",
"i+b",
"i",
"b",
"mids_down = [0]*(w-b)",
"mids_down",
"[0]*(w-b)",
"[0]",
"0",
"w-b",
"w",
"b",
"dis_mid = a",
"dis_mid",
"a",
"for i in range(w-b):\n mids_down[i] = binomial_coefficients(dis_mid+w-b-i-1,w-b-i-1)\n\n#print(mids_down)",
"i",
"range(w-b)",
"range",
"w-b",
"w",
"b",
"mids_down[i] = binomial_coefficients(dis_mid+w-b-i-1,w-b-i-1)",
"mids_down[i]",
"mids_down",
"i",
"binomial_coefficients(dis_mid+w-b-i-1,w-b-i-1)",
"binomial_coefficients",
"dis_mid+w-b-i-1",
"dis_mid+w-b-i",
"dis_mid+w-b",
"dis_mid+w",
"dis_mid",
"w",
"b",
"i",
"1",
"w-b-i-1",
"w-b-i",
"w-b",
"w",
"b",
"i",
"1",
"for i in range(w-b-1):\n mids_down[i] -= mids_down[i+1]\n\n#print(mids_down)",
"i",
"range(w-b-1)",
"range",
"w-b-1",
"w-b",
"w",
"b",
"1",
"mids_down[i] -= mids_down[i+1]",
"mids_down[i]",
"mids_down",
"i",
"mids_down[i+1]",
"mids_down",
"i+1",
"i",
"1",
"for i in range(w-b):\n mids[i] = (mids[i] * mids_down[i]) % mod\n\n#print(mids)",
"i",
"range(w-b)",
"range",
"w-b",
"w",
"b",
"mids[i] = (mids[i] * mids_down[i]) % mod",
"mids[i]",
"mids",
"i",
"(mids[i] * mids_down[i]) % mod",
"mids[i] * mids_down[i]",
"mids[i]",
"mids",
"i",
"mids_down[i]",
"mids_down",
"i",
"mod",
"print(sum(mids)%mod)",
"print",
"sum(mids)%mod",
"sum(mids)",
"sum",
"mids",
"mod",
"n = 2 * 10 ** 5",
"2 * 10 ** 5",
"n",
"mids_down = [0]*(w-b)",
"[0]*(w-b)",
"mids_down",
"def binomial_coefficients(n, k):\n if n == 0 and k == 0:\n return 1\n return bc_num[n] * bc_den[k] * bc_den[n-k] % mod",
"def binomial_coefficients(n, k):\n if n == 0 and k == 0:\n return 1\n return bc_num[n] * bc_den[k] * bc_den[n-k] % mod",
"binomial_coefficients",
"dis_mid = h - a - 1",
"h - a - 1",
"dis_mid",
"w, a, b = map(int, input().split())",
"map(int, input().split())",
"w",
"modinv_table = [-1] * (k+1)",
"[-1] * (k+1)",
"modinv_table",
"dis_mid = a",
"a",
"dis_mid",
"b = map(int, input().split())",
"map(int, input().split())",
"b",
"mids = [0]*(w-b)",
"[0]*(w-b)",
"mids",
"def prepare_binomial_coefficients(n, k):\n for i in range(1,n+1):\n bc_num[i] = i * bc_num[i-1] % mod\n bc_num[0] = 0\n for i in range(1,k+1):\n bc_den[i] = modinv_table[i] * bc_den[i-1] % mod\n return",
"def prepare_binomial_coefficients(n, k):\n for i in range(1,n+1):\n bc_num[i] = i * bc_num[i-1] % mod\n bc_num[0] = 0\n for i in range(1,k+1):\n bc_den[i] = modinv_table[i] * bc_den[i-1] % mod\n return",
"prepare_binomial_coefficients",
"a, b = map(int, input().split())",
"map(int, input().split())",
"a",
"h, w, a, b = map(int, input().split())",
"map(int, input().split())",
"h",
"bc_num = [1]*(n+1)",
"[1]*(n+1)",
"bc_num",
"bc_den = [1]*(n+1)",
"[1]*(n+1)",
"bc_den",
"mod = 10**9 + 7",
"10**9 + 7",
"mod",
"k = 2 * 10 ** 5",
"2 * 10 ** 5",
"k"
] | h, w, a, b = map(int, input().split())
n = 2 * 10 ** 5
k = 2 * 10 ** 5
mod = 10**9 + 7
modinv_table = [-1] * (k+1)
modinv_table[1] = 1
for i in range(2, k+1):
modinv_table[i] = (-modinv_table[mod % i] * (mod // i)) % mod
def prepare_binomial_coefficients(n, k):
for i in range(1,n+1):
bc_num[i] = i * bc_num[i-1] % mod
bc_num[0] = 0
for i in range(1,k+1):
bc_den[i] = modinv_table[i] * bc_den[i-1] % mod
return
def binomial_coefficients(n, k):
if n == 0 and k == 0:
return 1
return bc_num[n] * bc_den[k] * bc_den[n-k] % mod
bc_num = [1]*(n+1)
bc_den = [1]*(n+1)
prepare_binomial_coefficients(n, n)
mids = [0]*(w-b)
dis_mid = h - a - 1
for i in range(w-b):
mids[i] = binomial_coefficients(dis_mid+i+b,i+b)
#print(mids)
mids_down = [0]*(w-b)
dis_mid = a
for i in range(w-b):
mids_down[i] = binomial_coefficients(dis_mid+w-b-i-1,w-b-i-1)
#print(mids_down)
for i in range(w-b-1):
mids_down[i] -= mids_down[i+1]
#print(mids_down)
for i in range(w-b):
mids[i] = (mids[i] * mids_down[i]) % mod
#print(mids)
print(sum(mids)%mod)
|
[
7,
6,
13,
12,
13,
0,
18,
13,
13,
13,
0,
18,
13,
13,
39,
17,
17,
0,
18,
13,
13,
39,
17,
17,
0,
18,
13,
13,
39,
17,
17,
23,
13,
23,
13,
12,
13,
0,
13,
18,
13,
13,
0,
13,
18,
18,
13,
13,
17,
13,
18,
18,
13,
13,
17,
28,
13,
4,
13,
4,
13,
18,
13,
13,
2,
13,
17,
0,
13,
2,
2,
13,
13,
13,
0,
13,
2,
2,
40,
18,
18,
13,
13,
2,
13,
13,
2,
13,
13,
13,
0,
13,
2,
2,
13,
13,
13,
0,
13,
13,
13,
13,
4,
18,
18,
13,
13,
13,
13,
4,
18,
18,
13,
13,
13,
13,
4,
18,
18,
13,
13,
13,
13,
23,
13,
23,
13,
12,
13,
14,
40,
4,
13,
18,
13,
13,
13,
4,
18,
13,
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,
13,
0,
13,
17,
0,
13,
2,
2,
13,
13,
17,
28,
13,
4,
13,
13,
13,
0,
13,
2,
2,
13,
2,
4,
13,
2,
13,
13,
13,
4,
13,
2,
2,
2,
2,
13,
17,
13,
13,
17,
2,
2,
13,
13,
17,
13,
29,
13,
4,
13,
4,
13,
10,
12,
13,
10,
6,
13
] | [
[
9,
6
],
[
32,
7
],
[
34,
8
],
[
34,
9
],
[
14,
11
],
[
32,
12
],
[
21,
18
],
[
32,
19
],
[
28,
25
],
[
32,
26
],
[
32,
32
],
[
34,
34
],
[
39,
38
],
[
124,
40
],
[
44,
43
],
[
124,
46
],
[
50,
49
],
[
124,
52
],
[
57,
56
],
[
124,
62
],
[
126,
65
],
[
69,
68
],
[
43,
71
],
[
98,
71
],
[
56,
72
],
[
38,
73
],
[
76,
75
],
[
124,
81
],
[
38,
84
],
[
56,
85
],
[
38,
87
],
[
56,
88
],
[
38,
89
],
[
92,
91
],
[
49,
94
],
[
100,
94
],
[
75,
95
],
[
38,
96
],
[
99,
98
],
[
68,
99
],
[
101,
100
],
[
91,
101
],
[
124,
105
],
[
98,
108
],
[
43,
108
],
[
124,
112
],
[
100,
115
],
[
49,
115
],
[
124,
119
],
[
75,
122
],
[
124,
124
],
[
126,
126
],
[
167,
134
],
[
169,
136
],
[
167,
139
],
[
36,
140
],
[
169,
141
],
[
167,
148
],
[
169,
150
],
[
167,
153
],
[
171,
155
],
[
167,
158
],
[
169,
161
],
[
171,
162
],
[
167,
164
],
[
167,
167
],
[
169,
169
],
[
171,
171
],
[
176,
175
],
[
176,
184
],
[
176,
185
],
[
176,
186
],
[
189,
188
],
[
196,
195
],
[
188,
198
],
[
201,
200
],
[
204,
203
],
[
175,
206
],
[
185,
207
],
[
211,
210
],
[
186,
213
],
[
184,
214
],
[
217,
216
],
[
200,
219
],
[
216,
219
],
[
195,
222
],
[
203,
224
],
[
210,
225
],
[
210,
226
],
[
195,
228
],
[
185,
233
],
[
184,
235
],
[
210,
236
],
[
184,
240
],
[
210,
241
],
[
188,
243
],
[
216,
245
],
[
200,
245
],
[
252,
249
]
] | [
"class nCrMod():\n def __init__(self, mod):\n self.mod = mod\n self.fac = [1, 1]\n self.finv = [1, 1]\n self.inv = [0, 1]\n\n def prep(self, n):\n mod = self.mod\n f, fi = self.fac[-1], self.finv[-1]\n for i in range(len(self.fac), n + 1):\n fn = f * i % mod\n v = -self.inv[mod % i] * (mod // i) % mod\n fin = fi * v % mod\n f, fi = fn, fin\n self.fac.append(f)\n self.finv.append(fi)\n self.inv.append(v)\n\n def __call__(self, n, r):\n if len(self.fac) <= n:\n self.prep(n)\n return self.fac[n] * self.finv[r] * self.finv[n - r] % self.mod\n\ndef main():\n H, W, A, B = map(int, input().split())\n mod = 10 ** 9 + 7\n nCr = nCrMod(mod)\n r = 0\n a = H - A - 1\n for i in range(B, W):\n r = (r + nCr(a + i, i) * nCr(A - 1 + W - i - 1, W - i - 1)) % mod\n return r\n\n\nprint(main())",
"class nCrMod():\n def __init__(self, mod):\n self.mod = mod\n self.fac = [1, 1]\n self.finv = [1, 1]\n self.inv = [0, 1]\n\n def prep(self, n):\n mod = self.mod\n f, fi = self.fac[-1], self.finv[-1]\n for i in range(len(self.fac), n + 1):\n fn = f * i % mod\n v = -self.inv[mod % i] * (mod // i) % mod\n fin = fi * v % mod\n f, fi = fn, fin\n self.fac.append(f)\n self.finv.append(fi)\n self.inv.append(v)\n\n def __call__(self, n, r):\n if len(self.fac) <= n:\n self.prep(n)\n return self.fac[n] * self.finv[r] * self.finv[n - r] % self.mod",
"nCrMod",
"def __init__(self, mod):\n self.mod = mod\n self.fac = [1, 1]\n self.finv = [1, 1]\n self.inv = [0, 1]\n\n ",
"__init__",
"self.mod = mod",
"self.mod",
"self",
"mod",
"mod",
"self.fac = [1, 1]",
"self.fac",
"self",
"fac",
"[1, 1]",
"1",
"1",
"self.finv = [1, 1]",
"self.finv",
"self",
"finv",
"[1, 1]",
"1",
"1",
"self.inv = [0, 1]",
"self.inv",
"self",
"inv",
"[0, 1]",
"0",
"1",
"self",
"self",
"mod",
"mod",
"def prep(self, n):\n mod = self.mod\n f, fi = self.fac[-1], self.finv[-1]\n for i in range(len(self.fac), n + 1):\n fn = f * i % mod\n v = -self.inv[mod % i] * (mod // i) % mod\n fin = fi * v % mod\n f, fi = fn, fin\n self.fac.append(f)\n self.finv.append(fi)\n self.inv.append(v)\n\n ",
"prep",
"mod = self.mod",
"mod",
"self.mod",
"self",
"mod",
"f, fi = self.fac[-1], self.finv[-1]",
"f",
"self.fac[-1]",
"self.fac",
"self",
"fac",
"-1",
"fi",
"self.finv[-1]",
"self.finv",
"self",
"finv",
"-1",
"for i in range(len(self.fac), n + 1):\n fn = f * i % mod\n v = -self.inv[mod % i] * (mod // i) % mod\n fin = fi * v % mod\n f, fi = fn, fin\n self.fac.append(f)\n self.finv.append(fi)\n self.inv.append(v)\n\n ",
"i",
"range(len(self.fac), n + 1)",
"range",
"len(self.fac)",
"len",
"self.fac",
"self",
"fac",
"n + 1",
"n",
"1",
"fn = f * i % mod",
"fn",
"f * i % mod",
"f * i",
"f",
"i",
"mod",
"v = -self.inv[mod % i] * (mod // i) % mod",
"v",
"-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",
"fin = fi * v % mod",
"fin",
"fi * v % mod",
"fi * v",
"fi",
"v",
"mod",
"f, fi = fn, fin",
"f",
"fn",
"fi",
"fin",
"self.fac.append(f)",
"self.fac.append",
"self.fac",
"self",
"fac",
"append",
"f",
"self.finv.append(fi)",
"self.finv.append",
"self.finv",
"self",
"finv",
"append",
"fi",
"self.inv.append(v)",
"self.inv.append",
"self.inv",
"self",
"inv",
"append",
"v",
"self",
"self",
"n",
"n",
"def __call__(self, n, r):\n if len(self.fac) <= n:\n self.prep(n)\n return self.fac[n] * self.finv[r] * self.finv[n - r] % self.mod",
"__call__",
"if len(self.fac) <= n:\n self.prep(n)\n ",
"len(self.fac) <= n",
"len(self.fac)",
"len",
"self.fac",
"self",
"fac",
"n",
"self.prep(n)",
"self.prep",
"self",
"prep",
"n",
"return self.fac[n] * self.finv[r] * self.finv[n - r] % self.mod",
"self.fac[n] * self.finv[r] * self.finv[n - r] % self.mod",
"self.fac[n] * self.finv[r] * self.finv[n - r]",
"self.fac[n] * self.finv[r]",
"self.fac[n]",
"self.fac",
"self",
"fac",
"n",
"self.finv[r]",
"self.finv",
"self",
"finv",
"r",
"self.finv[n - r]",
"self.finv",
"self",
"finv",
"n - r",
"n",
"r",
"self.mod",
"self",
"mod",
"self",
"self",
"n",
"n",
"r",
"r",
"def main():\n H, W, A, B = map(int, input().split())\n mod = 10 ** 9 + 7\n nCr = nCrMod(mod)\n r = 0\n a = H - A - 1\n for i in range(B, W):\n r = (r + nCr(a + i, i) * nCr(A - 1 + W - i - 1, W - i - 1)) % mod\n return r",
"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",
"nCr = nCrMod(mod)",
"nCr",
"nCrMod(mod)",
"nCrMod",
"mod",
"r = 0",
"r",
"0",
"a = H - A - 1",
"a",
"H - A - 1",
"H - A",
"H",
"A",
"1",
"for i in range(B, W):\n r = (r + nCr(a + i, i) * nCr(A - 1 + W - i - 1, W - i - 1)) % mod\n ",
"i",
"range(B, W)",
"range",
"B",
"W",
"r = (r + nCr(a + i, i) * nCr(A - 1 + W - i - 1, W - i - 1)) % mod",
"r",
"(r + nCr(a + i, i) * nCr(A - 1 + W - i - 1, W - i - 1)) % mod",
"r + nCr(a + i, i) * nCr(A - 1 + W - i - 1, W - i - 1)",
"r",
"nCr(a + i, i) * nCr(A - 1 + W - i - 1, W - i - 1)",
"nCr(a + i, i)",
"nCr",
"a + i",
"a",
"i",
"i",
"nCr(A - 1 + W - i - 1, W - i - 1)",
"nCr",
"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",
"return r",
"r",
"print(main())",
"print",
"main()",
"main",
"def main():\n H, W, A, B = map(int, input().split())\n mod = 10 ** 9 + 7\n nCr = nCrMod(mod)\n r = 0\n a = H - A - 1\n for i in range(B, W):\n r = (r + nCr(a + i, i) * nCr(A - 1 + W - i - 1, W - i - 1)) % mod\n return r",
"def main():\n H, W, A, B = map(int, input().split())\n mod = 10 ** 9 + 7\n nCr = nCrMod(mod)\n r = 0\n a = H - A - 1\n for i in range(B, W):\n r = (r + nCr(a + i, i) * nCr(A - 1 + W - i - 1, W - i - 1)) % mod\n return r",
"main",
"class nCrMod():\n def __init__(self, mod):\n self.mod = mod\n self.fac = [1, 1]\n self.finv = [1, 1]\n self.inv = [0, 1]\n\n def prep(self, n):\n mod = self.mod\n f, fi = self.fac[-1], self.finv[-1]\n for i in range(len(self.fac), n + 1):\n fn = f * i % mod\n v = -self.inv[mod % i] * (mod // i) % mod\n fin = fi * v % mod\n f, fi = fn, fin\n self.fac.append(f)\n self.finv.append(fi)\n self.inv.append(v)\n\n def __call__(self, n, r):\n if len(self.fac) <= n:\n self.prep(n)\n return self.fac[n] * self.finv[r] * self.finv[n - r] % self.mod",
"class nCrMod():\n def __init__(self, mod):\n self.mod = mod\n self.fac = [1, 1]\n self.finv = [1, 1]\n self.inv = [0, 1]\n\n def prep(self, n):\n mod = self.mod\n f, fi = self.fac[-1], self.finv[-1]\n for i in range(len(self.fac), n + 1):\n fn = f * i % mod\n v = -self.inv[mod % i] * (mod // i) % mod\n fin = fi * v % mod\n f, fi = fn, fin\n self.fac.append(f)\n self.finv.append(fi)\n self.inv.append(v)\n\n def __call__(self, n, r):\n if len(self.fac) <= n:\n self.prep(n)\n return self.fac[n] * self.finv[r] * self.finv[n - r] % self.mod",
"nCrMod"
] | class nCrMod():
def __init__(self, mod):
self.mod = mod
self.fac = [1, 1]
self.finv = [1, 1]
self.inv = [0, 1]
def prep(self, n):
mod = self.mod
f, fi = self.fac[-1], self.finv[-1]
for i in range(len(self.fac), n + 1):
fn = f * i % mod
v = -self.inv[mod % i] * (mod // i) % mod
fin = fi * v % mod
f, fi = fn, fin
self.fac.append(f)
self.finv.append(fi)
self.inv.append(v)
def __call__(self, n, r):
if len(self.fac) <= n:
self.prep(n)
return self.fac[n] * self.finv[r] * self.finv[n - r] % self.mod
def main():
H, W, A, B = map(int, input().split())
mod = 10 ** 9 + 7
nCr = nCrMod(mod)
r = 0
a = H - A - 1
for i in range(B, W):
r = (r + nCr(a + i, i) * nCr(A - 1 + W - i - 1, W - i - 1)) % mod
return r
print(main())
|
[
7,
15,
13,
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,
13,
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,
2,
18,
13,
13,
18,
13,
13,
18,
13,
2,
13,
13,
13,
23,
13,
23,
13,
0,
13,
39,
28,
13,
4,
13,
13,
13,
4,
18,
13,
13,
4,
13,
2,
2,
2,
13,
13,
13,
17,
13,
0,
13,
17,
0,
13,
17,
28,
13,
4,
13,
2,
2,
13,
13,
17,
17,
17,
0,
13,
4,
13,
2,
2,
13,
13,
17,
2,
13,
17,
0,
13,
2,
13,
18,
13,
13,
0,
13,
17,
4,
13,
2,
13,
13,
10,
13,
13,
10,
2,
13,
10,
17,
13,
10,
2,
13,
10,
17,
13,
10,
4,
13,
10,
39,
13,
10,
17,
13,
10,
13,
13,
10,
13,
13,
10,
2,
13,
10,
2,
13,
10,
2,
13,
10,
4,
13,
10,
17,
13,
10,
2,
13,
10,
13,
13,
10,
12,
13,
10,
2,
13
] | [
[
6,
5
],
[
5,
14
],
[
247,
16
],
[
247,
18
],
[
247,
19
],
[
247,
20
],
[
229,
22
],
[
232,
29
],
[
227,
31
],
[
224,
32
],
[
244,
34
],
[
233,
39
],
[
235,
42
],
[
233,
47
],
[
220,
50
],
[
54,
53
],
[
233,
58
],
[
202,
61
],
[
245,
62
],
[
53,
63
],
[
221,
66
],
[
203,
66
],
[
53,
67
],
[
230,
68
],
[
202,
70
],
[
214,
73
],
[
236,
74
],
[
233,
75
],
[
245,
79
],
[
233,
80
],
[
230,
82
],
[
230,
84
],
[
214,
86
],
[
90,
89
],
[
233,
92
],
[
253,
96
],
[
236,
97
],
[
89,
99
],
[
215,
103
],
[
203,
103
],
[
221,
103
],
[
254,
103
],
[
89,
104
],
[
230,
105
],
[
253,
107
],
[
245,
116
],
[
128,
117
],
[
236,
119
],
[
130,
120
],
[
236,
122
],
[
128,
124
],
[
130,
125
],
[
230,
126
],
[
128,
128
],
[
130,
130
],
[
217,
132
],
[
136,
135
],
[
248,
138
],
[
224,
139
],
[
218,
142
],
[
251,
145
],
[
135,
149
],
[
227,
150
],
[
200,
151
],
[
135,
153
],
[
211,
155
],
[
205,
158
],
[
162,
161
],
[
224,
166
],
[
248,
167
],
[
238,
172
],
[
251,
174
],
[
161,
177
],
[
200,
178
],
[
200,
181
],
[
208,
184
],
[
239,
186
],
[
218,
188
],
[
206,
189
],
[
242,
189
],
[
241,
191
],
[
209,
196
],
[
212,
196
],
[
230,
197
],
[
247,
200
],
[
202,
203
],
[
205,
206
],
[
208,
209
],
[
211,
212
],
[
214,
215
],
[
217,
218
],
[
220,
221
],
[
247,
224
],
[
247,
227
],
[
229,
230
],
[
232,
233
],
[
235,
236
],
[
238,
239
],
[
241,
242
],
[
244,
245
],
[
247,
248
],
[
253,
254
]
] | [
"import math\nh, w, a, b = [int(i) for i in input().split()]\n\nMOD = 10**9 + 7\nN = h + w\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\ndef comb(n, k):\n return fact[n] * rfact[k] * rfact[n-k] % MOD\n\ntmp = []\nfor i in range(b, w):\n tmp.append(comb(i+h-a-1, i))\n\nans = 0\ncnt = 0\nfor i in range(w-b-1, -1, -1):\n t = comb(i + a - 1, a - 1)\n ans += t * tmp[cnt]\n cnt += 1\nprint(ans%MOD)",
"import math",
"math",
"int(i) for i in input().split()",
"for i in input().split()",
"i",
"input().split()",
"().split",
"()",
"input",
"split",
"for i in input().split()",
"int(i)",
"int",
"i",
"h, w, a, b = [int(i) for i in input().split()]",
"h",
"[int(i) for i in input().split()]",
"w",
"a",
"b",
"MOD = 10**9 + 7",
"MOD",
"10**9 + 7",
"10**9",
"10",
"9",
"7",
"N = h + w",
"N",
"h + w",
"h",
"w",
"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",
"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 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",
"tmp = []",
"tmp",
"[]",
"for i in range(b, w):\n tmp.append(comb(i+h-a-1, i))",
"i",
"range(b, w)",
"range",
"b",
"w",
"tmp.append(comb(i+h-a-1, i))",
"tmp.append",
"tmp",
"append",
"comb(i+h-a-1, i)",
"comb",
"i+h-a-1",
"i+h-a",
"i+h",
"i",
"h",
"a",
"1",
"i",
"ans = 0",
"ans",
"0",
"cnt = 0",
"cnt",
"0",
"for i in range(w-b-1, -1, -1):\n t = comb(i + a - 1, a - 1)\n ans += t * tmp[cnt]\n cnt += 1",
"i",
"range(w-b-1, -1, -1)",
"range",
"w-b-1",
"w-b",
"w",
"b",
"1",
"-1",
"-1",
"t = comb(i + a - 1, a - 1)",
"t",
"comb(i + a - 1, a - 1)",
"comb",
"i + a - 1",
"i + a",
"i",
"a",
"1",
"a - 1",
"a",
"1",
"ans += t * tmp[cnt]",
"ans",
"t * tmp[cnt]",
"t",
"tmp[cnt]",
"tmp",
"cnt",
"cnt += 1",
"cnt",
"1",
"print(ans%MOD)",
"print",
"ans%MOD",
"ans",
"MOD",
"a, b = [int(i) for i in input().split()]",
"[int(i) for i in input().split()]",
"a",
"r = r * i % MOD",
"r * i % MOD",
"r",
"cnt = 0",
"0",
"cnt",
"ans += t * tmp[cnt]",
"t * tmp[cnt]",
"ans",
"ans = 0",
"0",
"ans",
"r = pow(fact[N], MOD-2, MOD)",
"pow(fact[N], MOD-2, MOD)",
"r",
"tmp = []",
"[]",
"tmp",
"r = 1",
"1",
"r",
"w, a, b = [int(i) for i in input().split()]",
"[int(i) for i in input().split()]",
"w",
"h, w, a, b = [int(i) for i in input().split()]",
"[int(i) for i in input().split()]",
"h",
"MOD = 10**9 + 7",
"10**9 + 7",
"MOD",
"N = h + w",
"h + w",
"N",
"rfact = [1]*(N+1)",
"[1]*(N+1)",
"rfact",
"t = comb(i + a - 1, a - 1)",
"comb(i + a - 1, a - 1)",
"t",
"cnt += 1",
"1",
"cnt",
"fact = [1]*(N+1)",
"[1]*(N+1)",
"fact",
"b = [int(i) for i in input().split()]",
"[int(i) for i in input().split()]",
"b",
"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",
"r = r * i % MOD",
"r * i % MOD",
"r"
] | import math
h, w, a, b = [int(i) for i in input().split()]
MOD = 10**9 + 7
N = h + w
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
def comb(n, k):
return fact[n] * rfact[k] * rfact[n-k] % MOD
tmp = []
for i in range(b, w):
tmp.append(comb(i+h-a-1, i))
ans = 0
cnt = 0
for i in range(w-b-1, -1, -1):
t = comb(i + a - 1, a - 1)
ans += t * tmp[cnt]
cnt += 1
print(ans%MOD) |
[
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,
0,
13,
2,
2,
17,
2,
17,
17,
17,
0,
13,
2,
4,
13,
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,
17,
0,
13,
4,
13,
13,
4,
18,
4,
13,
13,
13,
13,
13,
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,
2,
13,
13,
17,
13,
13,
17,
2,
2,
13,
13,
17,
2,
2,
17,
17,
17,
4,
13,
2,
13,
2,
2,
17,
17,
17,
10,
17,
13,
10,
4,
13,
10,
39,
13,
10,
4,
13,
10,
39,
13,
10,
4,
13,
10,
39,
13,
10,
2,
13,
10,
2,
13,
10,
4,
13,
10,
12,
13,
10,
2,
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
],
[
38,
38
],
[
40,
40
],
[
213,
42
],
[
210,
51
],
[
195,
59
],
[
201,
64
],
[
207,
69
],
[
75,
74
],
[
214,
79
],
[
196,
83
],
[
196,
88
],
[
74,
90
],
[
211,
91
],
[
208,
94
],
[
208,
100
],
[
211,
102
],
[
74,
103
],
[
211,
105
],
[
74,
106
],
[
211,
107
],
[
202,
110
],
[
202,
115
],
[
208,
118
],
[
211,
120
],
[
189,
122
],
[
216,
125
],
[
216,
134
],
[
216,
135
],
[
216,
136
],
[
139,
138
],
[
217,
142
],
[
205,
143
],
[
222,
145
],
[
220,
149
],
[
193,
152
],
[
138,
154
],
[
138,
155
],
[
220,
157
],
[
199,
163
],
[
193,
164
],
[
217,
166
],
[
138,
167
],
[
199,
171
],
[
193,
172
],
[
223,
182
],
[
190,
182
],
[
189,
190
],
[
216,
193
],
[
195,
196
],
[
216,
199
],
[
201,
202
],
[
216,
205
],
[
207,
208
],
[
210,
211
],
[
213,
214
],
[
216,
217
],
[
222,
223
]
] | [
"# -*- coding: utf-8 -*-\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 + 1000 # N は必要分だけ用意する\nmod = pow(10, 9) + 7\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\nans = 0\nh, w, a, b = map(int,input().split())\nfor i in range(h - a):\n #print(b - 1 + i, i, w - b - 1 + h - i - 1, w - b - 1)\n ans += (cmb(b - 1 + i, i) * cmb(w - b - 1 + h - i - 1, w - b - 1)) % (10 ** 9 + 7)\nprint(ans % (10 ** 9 + 7))",
"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 + 1000",
"N",
"2 * 10 ** 5 + 1000",
"2 * 10 ** 5",
"2",
"10 ** 5",
"10",
"5",
"1000",
"mod = pow(10, 9) + 7",
"mod",
"pow(10, 9) + 7",
"pow(10, 9)",
"pow",
"10",
"9",
"7",
"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",
"ans = 0",
"ans",
"0",
"h, w, a, b = map(int,input().split())",
"h",
"map(int,input().split())",
"map",
"int",
"input().split()",
"().split",
"()",
"input",
"split",
"w",
"a",
"b",
"for i in range(h - a):\n #print(b - 1 + i, i, w - b - 1 + h - i - 1, w - b - 1)\n ans += (cmb(b - 1 + i, i) * cmb(w - b - 1 + h - i - 1, w - b - 1)) % (10 ** 9 + 7)",
"i",
"range(h - a)",
"range",
"h - a",
"h",
"a",
"ans += (cmb(b - 1 + i, i) * cmb(w - b - 1 + h - i - 1, w - b - 1)) % (10 ** 9 + 7)",
"ans",
"(cmb(b - 1 + i, i) * cmb(w - b - 1 + h - i - 1, w - b - 1)) % (10 ** 9 + 7)",
"cmb(b - 1 + i, i) * cmb(w - b - 1 + h - i - 1, w - b - 1)",
"cmb(b - 1 + i, i)",
"cmb",
"b - 1 + i",
"b - 1",
"b",
"1",
"i",
"i",
"cmb(w - b - 1 + h - i - 1, w - b - 1)",
"cmb",
"w - b - 1 + h - i - 1",
"w - b - 1 + h - i",
"w - b - 1 + h",
"w - b - 1",
"w - b",
"w",
"b",
"1",
"h",
"i",
"1",
"w - b - 1",
"w - b",
"w",
"b",
"1",
"10 ** 9 + 7",
"10 ** 9",
"10",
"9",
"7",
"print(ans % (10 ** 9 + 7))",
"print",
"ans % (10 ** 9 + 7)",
"ans",
"10 ** 9 + 7",
"10 ** 9",
"10",
"9",
"7",
"ans = 0",
"0",
"ans",
"b = map(int,input().split())",
"map(int,input().split())",
"b",
"fact = [1, 1]",
"[1, 1]",
"fact",
"w, a, b = map(int,input().split())",
"map(int,input().split())",
"w",
"factinv = [1, 1]",
"[1, 1]",
"factinv",
"a, b = map(int,input().split())",
"map(int,input().split())",
"a",
"inv = [0, 1]",
"[0, 1]",
"inv",
"mod = pow(10, 9) + 7",
"pow(10, 9) + 7",
"mod",
"N = 2 * 10 ** 5 + 1000",
"2 * 10 ** 5 + 1000",
"N",
"h, w, a, b = map(int,input().split())",
"map(int,input().split())",
"h",
"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",
"ans += (cmb(b - 1 + i, i) * cmb(w - b - 1 + h - i - 1, w - b - 1)) % (10 ** 9 + 7)",
"(cmb(b - 1 + i, i) * cmb(w - b - 1 + h - i - 1, w - b - 1)) % (10 ** 9 + 7)",
"ans"
] | # -*- coding: utf-8 -*-
#コンビネーション
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 + 1000 # N は必要分だけ用意する
mod = pow(10, 9) + 7
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)
ans = 0
h, w, a, b = map(int,input().split())
for i in range(h - a):
#print(b - 1 + i, i, w - b - 1 + h - i - 1, w - b - 1)
ans += (cmb(b - 1 + i, i) * cmb(w - b - 1 + h - i - 1, w - b - 1)) % (10 ** 9 + 7)
print(ans % (10 ** 9 + 7))
|
[
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,
41,
28,
13,
4,
13,
2,
2,
13,
13,
17,
4,
13,
0,
13,
13,
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,
4,
18,
13,
13,
0,
18,
13,
17,
4,
13,
18,
13,
17,
2,
13,
17,
13,
28,
13,
4,
13,
2,
13,
13,
17,
17,
0,
18,
13,
2,
13,
17,
2,
2,
13,
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,
17,
28,
13,
4,
13,
13,
4,
13,
2,
2,
13,
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,
13,
17,
0,
13,
13,
4,
13,
13,
10,
13,
13,
10,
12,
13,
10,
13,
13,
10,
4,
13,
10,
2,
13,
10,
13,
13,
10,
13,
13,
10,
13,
13,
10,
2,
13,
10,
17,
13,
10,
13,
13
] | [
[
4,
3
],
[
3,
12
],
[
203,
14
],
[
203,
16
],
[
203,
17
],
[
203,
18
],
[
206,
20
],
[
29,
28
],
[
201,
33
],
[
204,
34
],
[
28,
37
],
[
212,
39
],
[
45,
42
],
[
213,
43
],
[
48,
47
],
[
201,
53
],
[
204,
54
],
[
60,
57
],
[
213,
58
],
[
47,
59
],
[
213,
63
],
[
47,
65
],
[
47,
67
],
[
207,
68
],
[
191,
70
],
[
213,
73
],
[
79,
76
],
[
192,
77
],
[
192,
82
],
[
207,
85
],
[
207,
87
],
[
90,
89
],
[
201,
93
],
[
204,
94
],
[
103,
98
],
[
192,
99
],
[
89,
101
],
[
89,
105
],
[
192,
107
],
[
89,
108
],
[
207,
109
],
[
213,
117
],
[
129,
118
],
[
192,
120
],
[
131,
121
],
[
192,
123
],
[
129,
125
],
[
131,
126
],
[
207,
127
],
[
129,
129
],
[
131,
131
],
[
209,
133
],
[
137,
136
],
[
198,
139
],
[
198,
144
],
[
201,
145
],
[
183,
146
],
[
204,
147
],
[
194,
149
],
[
186,
152
],
[
201,
156
],
[
183,
157
],
[
198,
158
],
[
136,
160
],
[
186,
162
],
[
204,
166
],
[
183,
167
],
[
198,
168
],
[
204,
172
],
[
136,
173
],
[
188,
176
],
[
207,
177
],
[
189,
180
],
[
195,
180
],
[
210,
180
],
[
203,
183
],
[
207,
188
],
[
188,
189
],
[
191,
192
],
[
194,
195
],
[
203,
198
],
[
203,
201
],
[
203,
204
],
[
206,
207
],
[
209,
210
],
[
212,
213
]
] | [
"H, W, A, B = [int(_) for _ in input().split()]\nmod = 10**9 + 7\n \nX = [i for i in range(H + W + 1)]\nX[0] = 1\nfor i in range(2, H + W + 1):\n X[i] = X[i - 1] * i % mod\n \nY = X.copy()\nY[-1] = pow(Y[-1], mod - 2, mod)\nfor i in range(H + W, 1, -1):\n Y[i - 1] = i * Y[i] % mod\n \n \ndef comb(x, y):\n return X[x] * Y[y] * Y[x - y] % mod\n \n \nans = 0\nfor i in range(B, min(B + H - A, W)):\n ans += comb(H - A + B - 1, i) * comb(W + A - B - 1, W - i - 1)\n ans %= mod\nprint(ans)",
"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",
"mod = 10**9 + 7",
"mod",
"10**9 + 7",
"10**9",
"10",
"9",
"7",
"i 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)",
"i",
"X = [i for i in range(H + W + 1)]",
"X",
"[i for i in range(H + W + 1)]",
"X[0] = 1",
"X[0]",
"X",
"0",
"1",
"for i in range(2, H + W + 1):\n X[i] = X[i - 1] * i % mod\n ",
"i",
"range(2, H + W + 1)",
"range",
"2",
"H + W + 1",
"H + W",
"H",
"W",
"1",
"X[i] = X[i - 1] * i % mod",
"X[i]",
"X",
"i",
"X[i - 1] * i % mod",
"X[i - 1] * i",
"X[i - 1]",
"X",
"i - 1",
"i",
"1",
"i",
"mod",
"Y = X.copy()",
"Y",
"X.copy()",
"X.copy",
"X",
"copy",
"Y[-1] = pow(Y[-1], mod - 2, mod)",
"Y[-1]",
"Y",
"-1",
"pow(Y[-1], mod - 2, mod)",
"pow",
"Y[-1]",
"Y",
"-1",
"mod - 2",
"mod",
"2",
"mod",
"for i in range(H + W, 1, -1):\n Y[i - 1] = i * Y[i] % mod\n \n ",
"i",
"range(H + W, 1, -1)",
"range",
"H + W",
"H",
"W",
"1",
"-1",
"Y[i - 1] = i * Y[i] % mod",
"Y[i - 1]",
"Y",
"i - 1",
"i",
"1",
"i * Y[i] % mod",
"i * Y[i]",
"i",
"Y[i]",
"Y",
"i",
"mod",
"def comb(x, y):\n return X[x] * Y[y] * Y[x - y] % mod\n \n ",
"comb",
"return X[x] * Y[y] * Y[x - y] % mod",
"X[x] * Y[y] * Y[x - y] % mod",
"X[x] * Y[y] * Y[x - y]",
"X[x] * Y[y]",
"X[x]",
"X",
"x",
"Y[y]",
"Y",
"y",
"Y[x - y]",
"Y",
"x - y",
"x",
"y",
"mod",
"x",
"x",
"y",
"y",
"ans = 0",
"ans",
"0",
"for i in range(B, min(B + H - A, W)):\n ans += comb(H - A + B - 1, i) * comb(W + A - B - 1, W - i - 1)\n ans %= mod",
"i",
"range(B, min(B + H - A, W))",
"range",
"B",
"min(B + H - A, W)",
"min",
"B + H - A",
"B + H",
"B",
"H",
"A",
"W",
"ans += comb(H - A + B - 1, i) * comb(W + A - B - 1, W - i - 1)",
"ans",
"comb(H - A + B - 1, i) * comb(W + A - B - 1, W - i - 1)",
"comb(H - A + B - 1, i)",
"comb",
"H - A + B - 1",
"H - A + B",
"H - A",
"H",
"A",
"B",
"1",
"i",
"comb(W + A - B - 1, W - i - 1)",
"comb",
"W + A - B - 1",
"W + A - B",
"W + A",
"W",
"A",
"B",
"1",
"W - i - 1",
"W - i",
"W",
"i",
"1",
"ans %= mod",
"ans",
"mod",
"print(ans)",
"print",
"ans",
"A, B = [int(_) for _ in input().split()]",
"[int(_) for _ in input().split()]",
"A",
"def comb(x, y):\n return X[x] * Y[y] * Y[x - y] % mod\n \n ",
"def comb(x, y):\n return X[x] * Y[y] * Y[x - y] % mod\n \n ",
"comb",
"ans %= mod",
"mod",
"ans",
"Y = X.copy()",
"X.copy()",
"Y",
"ans += comb(H - A + B - 1, i) * comb(W + A - B - 1, W - i - 1)",
"comb(H - A + B - 1, i) * comb(W + A - B - 1, W - i - 1)",
"ans",
"B = [int(_) for _ in input().split()]",
"[int(_) for _ in input().split()]",
"B",
"H, W, A, B = [int(_) for _ in input().split()]",
"[int(_) for _ in input().split()]",
"H",
"W, A, B = [int(_) for _ in input().split()]",
"[int(_) for _ in input().split()]",
"W",
"mod = 10**9 + 7",
"10**9 + 7",
"mod",
"ans = 0",
"0",
"ans",
"X = [i for i in range(H + W + 1)]",
"[i for i in range(H + W + 1)]",
"X"
] | H, W, A, B = [int(_) for _ in input().split()]
mod = 10**9 + 7
X = [i for i in range(H + W + 1)]
X[0] = 1
for i in range(2, H + W + 1):
X[i] = X[i - 1] * i % mod
Y = X.copy()
Y[-1] = pow(Y[-1], mod - 2, mod)
for i in range(H + W, 1, -1):
Y[i - 1] = i * Y[i] % mod
def comb(x, y):
return X[x] * Y[y] * Y[x - y] % mod
ans = 0
for i in range(B, min(B + H - A, W)):
ans += comb(H - A + B - 1, i) * comb(W + A - B - 1, W - i - 1)
ans %= mod
print(ans)
|
Subsets and Splits
No saved queries yet
Save your SQL queries to embed, download, and access them later. Queries will appear here once saved.