Datasets:

---

codefuse-ai

/

GALLa

like 1

Follow

CodeFuse AI 145

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

[ [ 4, 3 ], [ 3, 12 ], [ 47, 14 ], [ 47, 16 ], [ 44, 18 ], [ 22, 21 ], [ 42, 24 ], [ 45, 27 ], [ 45, 39 ], [ 47, 42 ], [ 44, 45 ], [ 47, 48 ] ]

[ "N, L = [int(x) for x in input().split()]\nS = []\nfor s in range(N):\n S.append(input())\nprint(''.join(sorted(S)))", "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", "N, L = [int(x) for x in input().split()]", "N", "[int(x) for x in input().split()]", "L", "S = []", "S", "[]", "for s in range(N):\n S.append(input())", "s", "range(N)", "range", "N", "S.append(input())", "S.append", "S", "append", "input()", "input", "print(''.join(sorted(S)))", "print", "''.join(sorted(S))", "''.join", "''", "join", "sorted(S)", "sorted", "S", "N, L = [int(x) for x in input().split()]", "[int(x) for x in input().split()]", "N", "S = []", "[]", "S", "L = [int(x) for x in input().split()]", "[int(x) for x in input().split()]", "L" ]

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

[ [ 60, 2 ], [ 60, 11 ], [ 57, 13 ], [ 48, 16 ], [ 20, 19 ], [ 61, 22 ], [ 58, 25 ], [ 54, 30 ], [ 58, 33 ], [ 36, 35 ], [ 61, 38 ], [ 63, 40 ], [ 55, 42 ], [ 35, 43 ], [ 64, 46 ], [ 49, 46 ], [ 48, 49 ], [ 60, 52 ], [ 54, 55 ], [ 57, 58 ], [ 60, 61 ], [ 63, 64 ] ]

[ "N,L = map(int,input().split())\nstr_list=[]\nfinal_str = \"\"\nfor i in range(N):\n str_list.append(input())\nnew_list = sorted(str_list)\nfor n in range(N):\n final_str += new_list[n]\nprint(final_str)", "N,L = map(int,input().split())", "N", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "L", "str_list=[]", "str_list", "[]", "final_str = \"\"", "final_str", "\"\"", "for i in range(N):\n str_list.append(input())", "i", "range(N)", "range", "N", "str_list.append(input())", "str_list.append", "str_list", "append", "input()", "input", "new_list = sorted(str_list)", "new_list", "sorted(str_list)", "sorted", "str_list", "for n in range(N):\n final_str += new_list[n]", "n", "range(N)", "range", "N", "final_str += new_list[n]", "final_str", "new_list[n]", "new_list", "n", "print(final_str)", "print", "final_str", "final_str = \"\"", "\"\"", "final_str", "L = map(int,input().split())", "map(int,input().split())", "L", "new_list = sorted(str_list)", "sorted(str_list)", "new_list", "str_list=[]", "[]", "str_list", "N,L = map(int,input().split())", "map(int,input().split())", "N", "final_str += new_list[n]", "new_list[n]", "final_str" ]

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

[ [ 53, 2 ], [ 53, 11 ], [ 50, 13 ], [ 17, 16 ], [ 54, 19 ], [ 51, 22 ], [ 51, 28 ], [ 32, 31 ], [ 54, 34 ], [ 51, 38 ], [ 31, 39 ], [ 42, 41 ], [ 53, 48 ], [ 50, 51 ], [ 53, 54 ] ]

[ "n,l = map(int,input().split())\nline = []\nfor i in range(n):\n line.append(input())\nline.sort()\nfor i in range(n):\n print(line[i],end=\"\")\nprint(\"\")", "n,l = map(int,input().split())", "n", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "l", "line = []", "line", "[]", "for i in range(n):\n line.append(input())", "i", "range(n)", "range", "n", "line.append(input())", "line.append", "line", "append", "input()", "input", "line.sort()", "line.sort", "line", "sort", "for i in range(n):\n print(line[i],end=\"\")", "i", "range(n)", "range", "n", "print(line[i],end=\"\")", "print", "line[i]", "line", "i", "end=\"\"", "end", "\"\"", "print(\"\")", "print", "\"\"", "l = map(int,input().split())", "map(int,input().split())", "l", "line = []", "[]", "line", "n,l = map(int,input().split())", "map(int,input().split())", "n" ]

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

[ [ 56, 2 ], [ 56, 11 ], [ 44, 13 ], [ 17, 16 ], [ 51, 19 ], [ 53, 21 ], [ 45, 26 ], [ 54, 28 ], [ 45, 31 ], [ 47, 34 ], [ 45, 39 ], [ 48, 42 ], [ 45, 42 ], [ 44, 45 ], [ 47, 48 ], [ 56, 51 ], [ 53, 54 ], [ 56, 57 ] ]

[ "#NとLを入力\nN, L = map(int, input().split())\n\n\n# 空のリストを生成\nS = []\n\n#入力\nfor i in range(N):\n array = input()\n S.append(array)\n\n#辞書順に並べ替え\nS.sort()\n\n#pythonのリストの出力では[と,が出力されるので取る\nS=''.join(S)\n\n#出力\nprint(S)", "N, L = map(int, input().split())", "N", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "L", "S = []", "S", "[]", "for i in range(N):\n array = input()\n S.append(array)\n\n#辞書順に並べ替え", "i", "range(N)", "range", "N", "array = input()", "array", "input()", "input", "S.append(array)", "S.append", "S", "append", "array", "S.sort()", "S.sort", "S", "sort", "S=''.join(S)", "S", "''.join(S)", "''.join", "''", "join", "S", "print(S)", "print", "S", "S = []", "[]", "S", "S=''.join(S)", "''.join(S)", "S", "N, L = map(int, input().split())", "map(int, input().split())", "N", "array = input()", "input()", "array", "L = map(int, input().split())", "map(int, input().split())", "L" ]

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

[ [ 30, 2 ], [ 30, 12 ], [ 30, 13 ], [ 30, 28 ], [ 30, 31 ] ]

[ "N, L, *S = open(0).read().split()\nS.sort()\nprint(''.join(S))", "N, L, *S = open(0).read().split()", "N", "open(0).read().split()", "(0).read().split", "(0).read()", "(0).read", "(0)", "open", "0", "read", "split", "L", "*S", "S", "S.sort()", "S.sort", "S", "sort", "print(''.join(S))", "print", "''.join(S)", "''.join", "''", "join", "S", "L, *S = open(0).read().split()", "open(0).read().split()", "L", "N, L, *S = open(0).read().split()", "open(0).read().split()", "N" ]

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

[ [ 40, 2 ], [ 40, 11 ], [ 15, 14 ], [ 38, 17 ], [ 43, 25 ], [ 44, 35 ], [ 40, 38 ], [ 40, 41 ], [ 43, 44 ] ]

[ "N,L = map(int,input().split())\nS = sorted([input().strip() for _ in range(N)])\nprint(\"\".join(S))", "N,L = map(int,input().split())", "N", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "L", "input().strip() for _ in range(N)", "for _ in range(N)", "_", "range(N)", "range", "N", "for _ in range(N)", "input().strip()", "().strip", "()", "input", "strip", "S = sorted([input().strip() for _ in range(N)])", "S", "sorted([input().strip() for _ in range(N)])", "sorted", "[input().strip() for _ in range(N)]", "print(\"\".join(S))", "print", "\"\".join(S)", "\"\".join", "\"\"", "join", "S", "N,L = map(int,input().split())", "map(int,input().split())", "N", "L = map(int,input().split())", "map(int,input().split())", "L", "S = sorted([input().strip() for _ in range(N)])", "sorted([input().strip() for _ in range(N)])", "S" ]

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

[ [ 52, 2 ], [ 52, 11 ], [ 58, 13 ], [ 55, 16 ], [ 20, 19 ], [ 53, 22 ], [ 61, 24 ], [ 56, 29 ], [ 62, 31 ], [ 56, 34 ], [ 38, 37 ], [ 56, 37 ], [ 49, 40 ], [ 37, 41 ], [ 50, 44 ], [ 59, 44 ], [ 52, 47 ], [ 37, 49 ], [ 49, 50 ], [ 52, 53 ], [ 55, 56 ], [ 58, 59 ], [ 61, 62 ] ]

[ "n,l = map(int,input().split())\nans = ''\nk = []\nfor i in range(n):\n s = input()\n k.append(s)\nk.sort()\nfor i in k:\n ans +=i\nprint(ans)", "n,l = map(int,input().split())", "n", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "l", "ans = ''", "ans", "''", "k = []", "k", "[]", "for i in range(n):\n s = input()\n k.append(s)", "i", "range(n)", "range", "n", "s = input()", "s", "input()", "input", "k.append(s)", "k.append", "k", "append", "s", "k.sort()", "k.sort", "k", "sort", "for i in k:\n ans +=i", "i", "k", "ans +=i", "ans", "i", "print(ans)", "print", "ans", "l = map(int,input().split())", "map(int,input().split())", "l", "ans +=i", "i", "ans", "n,l = map(int,input().split())", "map(int,input().split())", "n", "k = []", "[]", "k", "ans = ''", "''", "ans", "s = input()", "input()", "s" ]

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

[ [ 51, 2 ], [ 51, 11 ], [ 15, 14 ], [ 40, 17 ], [ 45, 22 ], [ 42, 25 ], [ 29, 28 ], [ 46, 31 ], [ 48, 33 ], [ 28, 34 ], [ 49, 37 ], [ 43, 37 ], [ 51, 40 ], [ 42, 43 ], [ 45, 46 ], [ 28, 48 ], [ 48, 49 ], [ 51, 52 ] ]

[ "N, L = map(int, input().split())\nS_i = [input() for i in range(N)]\nm = \"\"\nfor x in sorted(S_i):\n m += x\nelse:\n print(m)", "N, L = map(int, input().split())", "N", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "L", "input() for i in range(N)", "for i in range(N)", "i", "range(N)", "range", "N", "for i in range(N)", "input()", "input", "S_i = [input() for i in range(N)]", "S_i", "[input() for i in range(N)]", "m = \"\"", "m", "\"\"", "for x in sorted(S_i):\n m += x\nelse:\n print(m)", "x", "sorted(S_i)", "sorted", "S_i", "m += x", "m", "x", "print(m)", "print", "m", "N, L = map(int, input().split())", "map(int, input().split())", "N", "m = \"\"", "\"\"", "m", "S_i = [input() for i in range(N)]", "[input() for i in range(N)]", "S_i", "m += x", "x", "m", "L = map(int, input().split())", "map(int, input().split())", "L" ]

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

[ [ 5, 4 ], [ 5, 14 ], [ 18, 17 ], [ 4, 20 ], [ 26, 25 ], [ 29, 28 ], [ 4, 31 ], [ 25, 36 ], [ 39, 38 ], [ 25, 42 ], [ 25, 46 ], [ 51, 48 ] ]

[ "def main():\n n,l=map(int,input().split(' '))\n li=[input() for i in range(n)]\n for i in range(n):\n print(min(li),end='')\n li.remove(min(li))\n\nmain()", "def main():\n n,l=map(int,input().split(' '))\n li=[input() for i in range(n)]\n for i in range(n):\n print(min(li),end='')\n li.remove(min(li))", "main", "n,l=map(int,input().split(' '))", "n", "map(int,input().split(' '))", "map", "int", "input().split(' ')", "().split", "()", "input", "split", "' '", "l", "input() for i in range(n)", "for i in range(n)", "i", "range(n)", "range", "n", "for i in range(n)", "input()", "input", "li=[input() for i in range(n)]", "li", "[input() for i in range(n)]", "for i in range(n):\n print(min(li),end='')\n li.remove(min(li))", "i", "range(n)", "range", "n", "print(min(li),end='')", "print", "min(li)", "min", "li", "end=''", "end", "''", "li.remove(min(li))", "li.remove", "li", "remove", "min(li)", "min", "li", "main()", "main", "def main():\n n,l=map(int,input().split(' '))\n li=[input() for i in range(n)]\n for i in range(n):\n print(min(li),end='')\n li.remove(min(li))", "def main():\n n,l=map(int,input().split(' '))\n li=[input() for i in range(n)]\n for i in range(n):\n print(min(li),end='')\n li.remove(min(li))", "main" ]

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

[ [ 127, 13 ], [ 130, 24 ], [ 109, 39 ], [ 131, 44 ], [ 121, 46 ], [ 112, 58 ], [ 71, 70 ], [ 124, 79 ], [ 131, 81 ], [ 124, 82 ], [ 118, 84 ], [ 88, 87 ], [ 116, 90 ], [ 119, 93 ], [ 119, 99 ], [ 119, 107 ], [ 109, 110 ], [ 112, 113 ], [ 124, 116 ], [ 118, 119 ], [ 121, 122 ], [ 124, 125 ], [ 127, 128 ], [ 130, 131 ] ]

[ "import sys\nimport math\n\n#https://atcoder.jp/contests/agc008/submissions/15248942\nsys.setrecursionlimit(10 ** 8)\nini = lambda: int(sys.stdin.readline())\ninm = lambda: map(int, sys.stdin.readline().split())\ninl = lambda: list(inm())\nins = lambda: sys.stdin.readline().rstrip()\ndebug = lambda *a, **kw: print(\"\\033[33m\", *a, \"\\033[0m\", **dict(file=sys.stderr, **kw))\n\nN,L = inm()\nS = []\nfor _ in range(N):\n S.append(input())\n\nS.sort()\nprint(''.join(S))", "import sys", "sys", "import math", "math", "sys.setrecursionlimit(10 ** 8)", "sys.setrecursionlimit", "sys", "setrecursionlimit", "10 ** 8", "10", "8", "ini = lambda: int(sys.stdin.readline())", "ini", "lambda: int(sys.stdin.readline())", "int(sys.stdin.readline())", "int", "sys.stdin.readline()", "sys.stdin.readline", "sys.stdin", "sys", "stdin", "readline", "inm = lambda: map(int, sys.stdin.readline().split())", "inm", "lambda: map(int, sys.stdin.readline().split())", "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", "inl = lambda: list(inm())", "inl", "lambda: list(inm())", "list(inm())", "list", "inm()", "inm", "ins = lambda: sys.stdin.readline().rstrip()", "ins", "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", "debug = lambda *a, **kw: print(\"\\033[33m\", *a, \"\\033[0m\", **dict(file=sys.stderr, **kw))", "debug", "lambda *a, **kw: print(\"\\033[33m\", *a, \"\\033[0m\", **dict(file=sys.stderr, **kw))", "print(\"\\033[33m\", *a, \"\\033[0m\", **dict(file=sys.stderr, **kw))", "print", "\"\\033[33m\"", "*a", "a", "\"\\033[0m\"", "**dict(file=sys.stderr, **kw)", "dict(file=sys.stderr, **kw)", "dict", "file=sys.stderr", "file", "sys.stderr", "sys", "stderr", "**kw", "kw", "*a", "**kw", "N,L = inm()", "N", "inm()", "inm", "L", "S = []", "S", "[]", "for _ in range(N):\n S.append(input())", "_", "range(N)", "range", "N", "S.append(input())", "S.append", "S", "append", "input()", "input", "S.sort()", "S.sort", "S", "sort", "print(''.join(S))", "print", "''.join(S)", "''.join", "''", "join", "S", "inl = lambda: list(inm())", "lambda: list(inm())", "inl", "debug = lambda *a, **kw: print(\"\\033[33m\", *a, \"\\033[0m\", **dict(file=sys.stderr, **kw))", "lambda *a, **kw: print(\"\\033[33m\", *a, \"\\033[0m\", **dict(file=sys.stderr, **kw))", "debug", "N,L = inm()", "inm()", "N", "S = []", "[]", "S", "ins = lambda: sys.stdin.readline().rstrip()", "lambda: sys.stdin.readline().rstrip()", "ins", "L = inm()", "inm()", "L", "ini = lambda: int(sys.stdin.readline())", "lambda: int(sys.stdin.readline())", "ini", "inm = lambda: map(int, sys.stdin.readline().split())", "lambda: map(int, sys.stdin.readline().split())", "inm" ]

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

[ [ 52, 2 ], [ 52, 11 ], [ 46, 13 ], [ 17, 16 ], [ 53, 19 ], [ 49, 21 ], [ 47, 26 ], [ 50, 28 ], [ 47, 31 ], [ 35, 34 ], [ 47, 34 ], [ 34, 38 ], [ 41, 40 ], [ 52, 44 ], [ 46, 47 ], [ 49, 50 ], [ 52, 53 ] ]

[ "n, m = map(int, input().split())\nli = []\nfor i in range(n):\n s = input()\n li.append(s)\nli.sort()\nfor i in li:\n print(i, end=\"\")", "n, m = map(int, input().split())", "n", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "m", "li = []", "li", "[]", "for i in range(n):\n s = input()\n li.append(s)", "i", "range(n)", "range", "n", "s = input()", "s", "input()", "input", "li.append(s)", "li.append", "li", "append", "s", "li.sort()", "li.sort", "li", "sort", "for i in li:\n print(i, end=\"\")", "i", "li", "print(i, end=\"\")", "print", "i", "end=\"\"", "end", "\"\"", "m = map(int, input().split())", "map(int, input().split())", "m", "li = []", "[]", "li", "s = input()", "input()", "s", "n, m = map(int, input().split())", "map(int, input().split())", "n" ]

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

[ [ 42, 2 ], [ 42, 11 ], [ 48, 13 ], [ 17, 16 ], [ 40, 19 ], [ 49, 22 ], [ 45, 27 ], [ 49, 30 ], [ 46, 37 ], [ 49, 37 ], [ 42, 40 ], [ 42, 43 ], [ 45, 46 ], [ 48, 49 ] ]

[ "n, l = map(int, input().split())\ns = []\nfor _ in range(n):\n s.append(input())\ns = sorted(s)\nprint(''.join(s))", "n, l = map(int, input().split())", "n", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "l", "s = []", "s", "[]", "for _ in range(n):\n s.append(input())", "_", "range(n)", "range", "n", "s.append(input())", "s.append", "s", "append", "input()", "input", "s = sorted(s)", "s", "sorted(s)", "sorted", "s", "print(''.join(s))", "print", "''.join(s)", "''.join", "''", "join", "s", "n, l = map(int, input().split())", "map(int, input().split())", "n", "l = map(int, input().split())", "map(int, input().split())", "l", "s = sorted(s)", "sorted(s)", "s", "s = []", "[]", "s" ]

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

[ [ 57, 2 ], [ 57, 11 ], [ 15, 14 ], [ 58, 17 ], [ 60, 22 ], [ 61, 26 ], [ 51, 29 ], [ 33, 32 ], [ 58, 35 ], [ 52, 38 ], [ 61, 41 ], [ 32, 42 ], [ 52, 46 ], [ 49, 48 ], [ 51, 52 ], [ 57, 55 ], [ 57, 58 ], [ 60, 61 ] ]

[ "N, L = map(int, input().split())\nS = [input() for i in range(N)]\nS.sort()\nS2 = []\nfor i in range(N):\n S2.append(S[i])\nprint(*(S2), sep='')", "N, L = map(int, input().split())", "N", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "L", "input() for i in range(N)", "for i in range(N)", "i", "range(N)", "range", "N", "for i in range(N)", "input()", "input", "S = [input() for i in range(N)]", "S", "[input() for i in range(N)]", "S.sort()", "S.sort", "S", "sort", "S2 = []", "S2", "[]", "for i in range(N):\n S2.append(S[i])", "i", "range(N)", "range", "N", "S2.append(S[i])", "S2.append", "S2", "append", "S[i]", "S", "i", "print(*(S2), sep='')", "print", "*(S2)", "S2", "sep=''", "sep", "''", "S2 = []", "[]", "S2", "L = map(int, input().split())", "map(int, input().split())", "L", "N, L = map(int, input().split())", "map(int, input().split())", "N", "S = [input() for i in range(N)]", "[input() for i in range(N)]", "S" ]

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

[ [ 50, 2 ], [ 50, 11 ], [ 53, 13 ], [ 18, 17 ], [ 48, 20 ], [ 54, 23 ], [ 54, 29 ], [ 33, 32 ], [ 48, 35 ], [ 54, 39 ], [ 32, 40 ], [ 43, 42 ], [ 50, 48 ], [ 50, 51 ], [ 53, 54 ] ]

[ "N,L=map(int,input().split())\nS=list()\nfor i in range(N):\n S.append(input())\nS.sort()\nfor i in range(N):\n print(S[i],end=\"\")\nprint()", "N,L=map(int,input().split())", "N", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "L", "S=list()", "S", "list()", "list", "for i in range(N):\n S.append(input())", "i", "range(N)", "range", "N", "S.append(input())", "S.append", "S", "append", "input()", "input", "S.sort()", "S.sort", "S", "sort", "for i in range(N):\n print(S[i],end=\"\")", "i", "range(N)", "range", "N", "print(S[i],end=\"\")", "print", "S[i]", "S", "i", "end=\"\"", "end", "\"\"", "print()", "print", "N,L=map(int,input().split())", "map(int,input().split())", "N", "L=map(int,input().split())", "map(int,input().split())", "L", "S=list()", "list()", "S" ]

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

[ [ 51, 2 ], [ 42, 6 ], [ 52, 9 ], [ 48, 12 ], [ 16, 15 ], [ 43, 21 ], [ 45, 24 ], [ 49, 29 ], [ 46, 31 ], [ 52, 31 ], [ 49, 40 ], [ 42, 43 ], [ 45, 46 ], [ 48, 49 ], [ 51, 52 ] ]

[ "val = input()\nsplited_val = val.split()\n\nval_list=[]\n\nfor x in range(int(splited_val[0])):\n val = input()\n val_list.append(val)\n\nprint(\"\".join(sorted(val_list)))", "val = input()", "val", "input()", "input", "splited_val = val.split()", "splited_val", "val.split()", "val.split", "val", "split", "val_list=[]", "val_list", "[]", "for x in range(int(splited_val[0])):\n val = input()\n val_list.append(val)", "x", "range(int(splited_val[0]))", "range", "int(splited_val[0])", "int", "splited_val[0]", "splited_val", "0", "val = input()", "val", "input()", "input", "val_list.append(val)", "val_list.append", "val_list", "append", "val", "print(\"\".join(sorted(val_list)))", "print", "\"\".join(sorted(val_list))", "\"\".join", "\"\"", "join", "sorted(val_list)", "sorted", "val_list", "splited_val = val.split()", "val.split()", "splited_val", "val = input()", "input()", "val", "val_list=[]", "[]", "val_list", "val = input()", "input()", "val" ]

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

[ [ 36, 2 ], [ 36, 11 ], [ 39, 13 ], [ 40, 20 ], [ 42, 23 ], [ 40, 28 ], [ 43, 31 ], [ 36, 34 ], [ 36, 37 ], [ 39, 40 ], [ 42, 43 ] ]

[ "n, l = map(int, input().split())\ns = list(input() for i in range(n))\ns.sort()\n\nx = \"\".join(s)\n\nprint(x)", "n, l = map(int, input().split())", "n", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "l", "s = list(input() for i in range(n))", "s", "list(input() for i in range(n))", "list", "input()", "input", "s.sort()", "s.sort", "s", "sort", "x = \"\".join(s)", "x", "\"\".join(s)", "\"\".join", "\"\"", "join", "s", "print(x)", "print", "x", "n, l = map(int, input().split())", "map(int, input().split())", "n", "l = map(int, input().split())", "map(int, input().split())", "l", "s = list(input() for i in range(n))", "list(input() for i in range(n))", "s", "x = \"\".join(s)", "\"\".join(s)", "x" ]

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

[ [ 46, 2 ], [ 46, 11 ], [ 15, 14 ], [ 44, 17 ], [ 37, 22 ], [ 40, 25 ], [ 38, 28 ], [ 41, 35 ], [ 37, 38 ], [ 40, 41 ], [ 46, 44 ], [ 46, 47 ] ]

[ "N, L = map(int, input().split())\ntext_list = [input() for _ in range(N)]\n\nsorted_list = sorted(text_list)\n\nprint(''.join(sorted_list))", "N, L = map(int, input().split())", "N", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "L", "input() for _ in range(N)", "for _ in range(N)", "_", "range(N)", "range", "N", "for _ in range(N)", "input()", "input", "text_list = [input() for _ in range(N)]", "text_list", "[input() for _ in range(N)]", "sorted_list = sorted(text_list)", "sorted_list", "sorted(text_list)", "sorted", "text_list", "print(''.join(sorted_list))", "print", "''.join(sorted_list)", "''.join", "''", "join", "sorted_list", "text_list = [input() for _ in range(N)]", "[input() for _ in range(N)]", "text_list", "sorted_list = sorted(text_list)", "sorted(text_list)", "sorted_list", "N, L = map(int, input().split())", "map(int, input().split())", "N", "L = map(int, input().split())", "map(int, input().split())", "L" ]

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

[ [ 67, 13 ], [ 64, 20 ], [ 64, 29 ], [ 33, 32 ], [ 65, 35 ], [ 58, 40 ], [ 61, 43 ], [ 59, 46 ], [ 62, 53 ], [ 64, 56 ], [ 58, 59 ], [ 61, 62 ], [ 64, 65 ], [ 67, 68 ] ]

[ "from sys import stdin, stdout\nfrom time import perf_counter\n\nimport sys\nsys.setrecursionlimit(10**9)\nmod = 10**9+7\n\n# import sys\n# sys.stdout = open(\"e:/cp/output.txt\",\"w\")\n# sys.stdin = open(\"e:/cp/input.txt\",\"r\")\n\nn,l = map(int,input().split())\na = [input() for item in range(n)]\nb = sorted(a)\nprint(''.join(b))", "from sys import stdin, stdout", "from time import perf_counter", "import sys", "sys", "sys.setrecursionlimit(10**9)", "sys.setrecursionlimit", "sys", "setrecursionlimit", "10**9", "10", "9", "mod = 10**9+7", "mod", "10**9+7", "10**9", "10", "9", "7", "n,l = map(int,input().split())", "n", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "l", "input() for item in range(n)", "for item in range(n)", "item", "range(n)", "range", "n", "for item in range(n)", "input()", "input", "a = [input() for item in range(n)]", "a", "[input() for item in range(n)]", "b = sorted(a)", "b", "sorted(a)", "sorted", "a", "print(''.join(b))", "print", "''.join(b)", "''.join", "''", "join", "b", "l = map(int,input().split())", "map(int,input().split())", "l", "a = [input() for item in range(n)]", "[input() for item in range(n)]", "a", "b = sorted(a)", "sorted(a)", "b", "n,l = map(int,input().split())", "map(int,input().split())", "n", "mod = 10**9+7", "10**9+7", "mod" ]

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

[ [ 54, 2 ], [ 54, 11 ], [ 51, 13 ], [ 17, 16 ], [ 55, 19 ], [ 42, 21 ], [ 52, 26 ], [ 43, 28 ], [ 48, 30 ], [ 52, 37 ], [ 49, 40 ], [ 52, 40 ], [ 42, 43 ], [ 54, 46 ], [ 48, 49 ], [ 51, 52 ], [ 54, 55 ] ]

[ "a,b = map(int,input().split())\narr = []\nfor i in range(a):\n\tvalue = input()\n\tarr.append(value)\narr = \"\".join(sorted(arr))\nprint(arr)", "a,b = map(int,input().split())", "a", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "b", "arr = []", "arr", "[]", "for i in range(a):\n\tvalue = input()\n\tarr.append(value)", "i", "range(a)", "range", "a", "value = input()", "value", "input()", "input", "arr.append(value)", "arr.append", "arr", "append", "value", "arr = \"\".join(sorted(arr))", "arr", "\"\".join(sorted(arr))", "\"\".join", "\"\"", "join", "sorted(arr)", "sorted", "arr", "print(arr)", "print", "arr", "value = input()", "input()", "value", "b = map(int,input().split())", "map(int,input().split())", "b", "arr = \"\".join(sorted(arr))", "\"\".join(sorted(arr))", "arr", "arr = []", "[]", "arr", "a,b = map(int,input().split())", "map(int,input().split())", "a" ]

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

[ [ 5, 4 ], [ 5, 13 ], [ 17, 16 ], [ 4, 19 ], [ 25, 24 ], [ 24, 28 ], [ 32, 31 ], [ 24, 36 ], [ 31, 38 ], [ 45, 42 ] ]

[ "def solve():\n N, L = map(int, input().split())\n S = [input() for _ in range(N)]\n S.sort()\n ans = ''.join(S)\n return ans\nprint(solve())", "def solve():\n N, L = map(int, input().split())\n S = [input() for _ in range(N)]\n S.sort()\n ans = ''.join(S)\n return ans", "solve", "N, L = map(int, input().split())", "N", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "L", "input() for _ in range(N)", "for _ in range(N)", "_", "range(N)", "range", "N", "for _ in range(N)", "input()", "input", "S = [input() for _ in range(N)]", "S", "[input() for _ in range(N)]", "S.sort()", "S.sort", "S", "sort", "ans = ''.join(S)", "ans", "''.join(S)", "''.join", "''", "join", "S", "return ans", "ans", "print(solve())", "print", "solve()", "solve", "def solve():\n N, L = map(int, input().split())\n S = [input() for _ in range(N)]\n S.sort()\n ans = ''.join(S)\n return ans", "def solve():\n N, L = map(int, input().split())\n S = [input() for _ in range(N)]\n S.sort()\n ans = ''.join(S)\n return ans", "solve" ]

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

[ [ 26, 2 ], [ 26, 11 ], [ 21, 20 ], [ 26, 24 ], [ 26, 27 ] ]

[ "n,l=map(int,input().split());print(*sorted(input() for _ in range(n)),sep='')", "n,l=map(int,input().split())", "n", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "l", "print(*sorted(input() for _ in range(n)),sep='')", "print", "*sorted(input() for _ in range(n))", "sorted(input() for _ in range(n))", "sorted", "input()", "input", "sep=''", "sep", "''", "n,l=map(int,input().split())", "map(int,input().split())", "n", "l=map(int,input().split())", "map(int,input().split())", "l" ]

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

[ [ 48, 2 ], [ 48, 11 ], [ 54, 13 ], [ 17, 16 ], [ 49, 19 ], [ 51, 21 ], [ 55, 26 ], [ 52, 28 ], [ 55, 31 ], [ 35, 34 ], [ 55, 34 ], [ 34, 38 ], [ 41, 40 ], [ 48, 46 ], [ 48, 49 ], [ 51, 52 ], [ 54, 55 ] ]

[ "N, L = map(int, input().split())\n\nS = []\n\nfor _ in range(N):\n s = input()\n S.append(s)\n\nS.sort()\n\nfor obj in S:\n print(obj, end=\"\")\n\nprint()", "N, L = map(int, input().split())", "N", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "L", "S = []", "S", "[]", "for _ in range(N):\n s = input()\n S.append(s)", "_", "range(N)", "range", "N", "s = input()", "s", "input()", "input", "S.append(s)", "S.append", "S", "append", "s", "S.sort()", "S.sort", "S", "sort", "for obj in S:\n print(obj, end=\"\")", "obj", "S", "print(obj, end=\"\")", "print", "obj", "end=\"\"", "end", "\"\"", "print()", "print", "L = map(int, input().split())", "map(int, input().split())", "L", "N, L = map(int, input().split())", "map(int, input().split())", "N", "s = input()", "input()", "s", "S = []", "[]", "S" ]

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

[ [ 51, 2 ], [ 51, 11 ], [ 54, 13 ], [ 17, 16 ], [ 52, 20 ], [ 55, 23 ], [ 55, 29 ], [ 33, 32 ], [ 52, 36 ], [ 55, 40 ], [ 32, 41 ], [ 44, 43 ], [ 51, 49 ], [ 51, 52 ], [ 54, 55 ] ]

[ "N,L=map(int,input().split())\nS=[]\nfor i in range(0,N):\n S.append(input())\n \nS.sort()\n\nfor i in range(0,N):\n print(S[i],end='')\nprint()", "N,L=map(int,input().split())", "N", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "L", "S=[]", "S", "[]", "for i in range(0,N):\n S.append(input())\n ", "i", "range(0,N)", "range", "0", "N", "S.append(input())", "S.append", "S", "append", "input()", "input", "S.sort()", "S.sort", "S", "sort", "for i in range(0,N):\n print(S[i],end='')", "i", "range(0,N)", "range", "0", "N", "print(S[i],end='')", "print", "S[i]", "S", "i", "end=''", "end", "''", "print()", "print", "L=map(int,input().split())", "map(int,input().split())", "L", "N,L=map(int,input().split())", "map(int,input().split())", "N", "S=[]", "[]", "S" ]

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

[ [ 49, 2 ], [ 61, 6 ], [ 50, 9 ], [ 52, 12 ], [ 16, 15 ], [ 62, 21 ], [ 50, 21 ], [ 58, 24 ], [ 53, 29 ], [ 59, 31 ], [ 53, 34 ], [ 55, 37 ], [ 41, 40 ], [ 53, 40 ], [ 64, 43 ], [ 40, 44 ], [ 65, 47 ], [ 56, 47 ], [ 49, 50 ], [ 52, 53 ], [ 55, 56 ], [ 58, 59 ], [ 61, 62 ], [ 40, 64 ], [ 64, 65 ] ]

[ "FirstLine = input()\nFirstLine = FirstLine.split()\nL1 = []\nfor i in range(int(FirstLine[0])):\n s = input()\n L1.append(s)\nL1.sort()\na = \"\"\nfor i in L1:\n a += i\n \nprint(a)", "FirstLine = input()", "FirstLine", "input()", "input", "FirstLine = FirstLine.split()", "FirstLine", "FirstLine.split()", "FirstLine.split", "FirstLine", "split", "L1 = []", "L1", "[]", "for i in range(int(FirstLine[0])):\n s = input()\n L1.append(s)", "i", "range(int(FirstLine[0]))", "range", "int(FirstLine[0])", "int", "FirstLine[0]", "FirstLine", "0", "s = input()", "s", "input()", "input", "L1.append(s)", "L1.append", "L1", "append", "s", "L1.sort()", "L1.sort", "L1", "sort", "a = \"\"", "a", "\"\"", "for i in L1:\n a += i\n ", "i", "L1", "a += i", "a", "i", "print(a)", "print", "a", "FirstLine = input()", "input()", "FirstLine", "L1 = []", "[]", "L1", "a = \"\"", "\"\"", "a", "s = input()", "input()", "s", "FirstLine = FirstLine.split()", "FirstLine.split()", "FirstLine", "a += i", "i", "a" ]

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

[ [ 56, 2 ], [ 56, 11 ], [ 47, 13 ], [ 17, 16 ], [ 45, 19 ], [ 48, 22 ], [ 59, 27 ], [ 48, 30 ], [ 50, 32 ], [ 36, 35 ], [ 60, 35 ], [ 53, 38 ], [ 35, 39 ], [ 54, 42 ], [ 51, 42 ], [ 56, 45 ], [ 47, 48 ], [ 50, 51 ], [ 35, 53 ], [ 53, 54 ], [ 56, 57 ], [ 59, 60 ] ]

[ "n,l = map(int,input().split())\ns = []\nfor i in range(n):\n s.append(input())\nsort_s = sorted(s)\nans = ''\nfor i in sort_s:\n ans += i\nprint(ans)", "n,l = map(int,input().split())", "n", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "l", "s = []", "s", "[]", "for i in range(n):\n s.append(input())", "i", "range(n)", "range", "n", "s.append(input())", "s.append", "s", "append", "input()", "input", "sort_s = sorted(s)", "sort_s", "sorted(s)", "sorted", "s", "ans = ''", "ans", "''", "for i in sort_s:\n ans += i", "i", "sort_s", "ans += i", "ans", "i", "print(ans)", "print", "ans", "n,l = map(int,input().split())", "map(int,input().split())", "n", "s = []", "[]", "s", "ans = ''", "''", "ans", "ans += i", "i", "ans", "l = map(int,input().split())", "map(int,input().split())", "l", "sort_s = sorted(s)", "sorted(s)", "sort_s" ]

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

[ [ 7, 6 ], [ 15, 14 ], [ 6, 20 ], [ 14, 27 ], [ 30, 29 ], [ 30, 31 ], [ 35, 34 ], [ 29, 37 ], [ 6, 42 ], [ 46, 45 ], [ 49, 48 ], [ 45, 51 ], [ 48, 58 ], [ 45, 58 ], [ 67, 64 ] ]

[ "# row = [int(x) for x in input().rstrip().split(\" \")]\n# n = int(input().rstrip())\n# s = input().rstrip()\n\ndef resolve():\n import sys\n input = sys.stdin.readline\n\n n, l = [int(x) for x in input().rstrip().split(\" \")]\n\n s_list = [input().rstrip() for _ in range(n)]\n s_list = sorted(s_list)\n print(\"\".join(s_list))\n\n\nif __name__ == \"__main__\":\n resolve()", "def resolve():\n import sys\n input = sys.stdin.readline\n\n n, l = [int(x) for x in input().rstrip().split(\" \")]\n\n s_list = [input().rstrip() for _ in range(n)]\n s_list = sorted(s_list)\n print(\"\".join(s_list))", "resolve", "import sys", "sys", "input = sys.stdin.readline", "input", "sys.stdin.readline", "sys.stdin", "sys", "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", "n, l = [int(x) for x in input().rstrip().split(\" \")]", "n", "[int(x) for x in input().rstrip().split(\" \")]", "l", "input().rstrip() for _ in range(n)", "for _ in range(n)", "_", "range(n)", "range", "n", "for _ in range(n)", "input().rstrip()", "().rstrip", "()", "input", "rstrip", "s_list = [input().rstrip() for _ in range(n)]", "s_list", "[input().rstrip() for _ in range(n)]", "s_list = sorted(s_list)", "s_list", "sorted(s_list)", "sorted", "s_list", "print(\"\".join(s_list))", "print", "\"\".join(s_list)", "\"\".join", "\"\"", "join", "s_list", "if __name__ == \"__main__\":\n resolve()", "__name__ == \"__main__\"", "__name__", "\"__main__\"", "resolve()", "resolve", "def resolve():\n import sys\n input = sys.stdin.readline\n\n n, l = [int(x) for x in input().rstrip().split(\" \")]\n\n s_list = [input().rstrip() for _ in range(n)]\n s_list = sorted(s_list)\n print(\"\".join(s_list))", "def resolve():\n import sys\n input = sys.stdin.readline\n\n n, l = [int(x) for x in input().rstrip().split(\" \")]\n\n s_list = [input().rstrip() for _ in range(n)]\n s_list = sorted(s_list)\n print(\"\".join(s_list))", "resolve" ]

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

[ [ 36, 2 ], [ 36, 13 ], [ 17, 16 ], [ 37, 19 ], [ 36, 34 ], [ 36, 37 ] ]

[ "a,b=list(map(int, input().split()))\nprint(''.join(sorted([input() for i in range(a)])))", "a,b=list(map(int, input().split()))", "a", "list(map(int, input().split()))", "list", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "b", "input() for i in range(a)", "for i in range(a)", "i", "range(a)", "range", "a", "for i in range(a)", "input()", "input", "print(''.join(sorted([input() for i in range(a)])))", "print", "''.join(sorted([input() for i in range(a)]))", "''.join", "''", "join", "sorted([input() for i in range(a)])", "sorted", "[input() for i in range(a)]", "b=list(map(int, input().split()))", "list(map(int, input().split()))", "b", "a,b=list(map(int, input().split()))", "list(map(int, input().split()))", "a" ]

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

[ [ 43, 2 ], [ 43, 11 ], [ 15, 14 ], [ 44, 17 ], [ 40, 22 ], [ 46, 25 ], [ 41, 28 ], [ 47, 35 ], [ 41, 35 ], [ 43, 38 ], [ 40, 41 ], [ 43, 44 ], [ 46, 47 ] ]

[ "n, l = map(int, input().split())\ns = [input() for _ in range(n)]\ns = sorted(s)\nprint(''.join(s))", "n, l = map(int, input().split())", "n", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "l", "input() for _ in range(n)", "for _ in range(n)", "_", "range(n)", "range", "n", "for _ in range(n)", "input()", "input", "s = [input() for _ in range(n)]", "s", "[input() for _ in range(n)]", "s = sorted(s)", "s", "sorted(s)", "sorted", "s", "print(''.join(s))", "print", "''.join(s)", "''.join", "''", "join", "s", "l = map(int, input().split())", "map(int, input().split())", "l", "s = [input() for _ in range(n)]", "[input() for _ in range(n)]", "s", "n, l = map(int, input().split())", "map(int, input().split())", "n", "s = sorted(s)", "sorted(s)", "s" ]

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

[ [ 53, 2 ], [ 53, 11 ], [ 15, 14 ], [ 42, 17 ], [ 50, 22 ], [ 51, 26 ], [ 44, 29 ], [ 33, 32 ], [ 51, 32 ], [ 47, 35 ], [ 32, 36 ], [ 48, 39 ], [ 45, 39 ], [ 53, 42 ], [ 44, 45 ], [ 32, 47 ], [ 47, 48 ], [ 50, 51 ], [ 53, 54 ] ]

[ "N, L = map(int, input().split())\nS = [input() for s in range(N)]\nS.sort()\noutput = \"\"\nfor i in S:\n output+=i\nprint(output)", "N, L = map(int, input().split())", "N", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "L", "input() for s in range(N)", "for s in range(N)", "s", "range(N)", "range", "N", "for s in range(N)", "input()", "input", "S = [input() for s in range(N)]", "S", "[input() for s in range(N)]", "S.sort()", "S.sort", "S", "sort", "output = \"\"", "output", "\"\"", "for i in S:\n output+=i", "i", "S", "output+=i", "output", "i", "print(output)", "print", "output", "N, L = map(int, input().split())", "map(int, input().split())", "N", "output = \"\"", "\"\"", "output", "output+=i", "i", "output", "S = [input() for s in range(N)]", "[input() for s in range(N)]", "S", "L = map(int, input().split())", "map(int, input().split())", "L" ]

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

[ [ 99, 9 ], [ 99, 18 ], [ 22, 21 ], [ 88, 24 ], [ 96, 29 ], [ 93, 32 ], [ 88, 34 ], [ 38, 37 ], [ 94, 40 ], [ 43, 42 ], [ 94, 46 ], [ 37, 47 ], [ 64, 50 ], [ 97, 51 ], [ 42, 52 ], [ 97, 54 ], [ 42, 56 ], [ 90, 59 ], [ 64, 60 ], [ 97, 61 ], [ 42, 62 ], [ 67, 64 ], [ 97, 65 ], [ 42, 66 ], [ 97, 68 ], [ 42, 70 ], [ 78, 73 ], [ 97, 74 ], [ 42, 76 ], [ 91, 78 ], [ 88, 78 ], [ 97, 85 ], [ 99, 88 ], [ 64, 90 ], [ 90, 91 ], [ 93, 94 ], [ 96, 97 ], [ 99, 100 ] ]

[ "from collections import Counter\nimport math\nimport statistics\nimport itertools\na,b=map(int,input().split())\n# b=input()\n# c=[]\n# for i in a:\n# c.append(int(i))\n# A,B,C= map(int,input().split())\n# f = list(map(int,input().split()))\n#g = [list(map(lambda x: '{}'.format(x), list(input()))) for _ in range(a)]\n# h = []\n# for i in range(a):\n# h.append(list(map(int,input().split())))\n# a = [[0] for _ in range(H)]#nizigen\nlis=[input() for i in range(a)]\nra=a-1\nfor i in range(ra):\n for k in range(ra-i):\n if lis[k]>lis[k+1]:\n a=lis[k]\n lis[k]=lis[k+1]\n lis[k+1]=a\nprint(\"\".join(lis))\n", "from collections import Counter", "import math", "math", "import statistics", "statistics", "import itertools", "itertools", "a,b=map(int,input().split())", "a", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "b", "input() for i in range(a)", "for i in range(a)", "i", "range(a)", "range", "a", "for i in range(a)", "input()", "input", "lis=[input() for i in range(a)]", "lis", "[input() for i in range(a)]", "ra=a-1", "ra", "a-1", "a", "1", "for i in range(ra):\n for k in range(ra-i):\n if lis[k]>lis[k+1]:\n a=lis[k]\n lis[k]=lis[k+1]\n lis[k+1]=a", "i", "range(ra)", "range", "ra", "for k in range(ra-i):\n if lis[k]>lis[k+1]:\n a=lis[k]\n lis[k]=lis[k+1]\n lis[k+1]=a", "k", "range(ra-i)", "range", "ra-i", "ra", "i", "if lis[k]>lis[k+1]:\n a=lis[k]\n lis[k]=lis[k+1]\n lis[k+1]=a", "lis[k]>lis[k+1]", "lis[k]", "lis", "k", "lis[k+1]", "lis", "k+1", "k", "1", "a=lis[k]", "a", "lis[k]", "lis", "k", "lis[k]=lis[k+1]", "lis[k]", "lis", "k", "lis[k+1]", "lis", "k+1", "k", "1", "lis[k+1]=a", "lis[k+1]", "lis", "k+1", "k", "1", "a", "print(\"\".join(lis))", "print", "\"\".join(lis)", "\"\".join", "\"\"", "join", "lis", "a,b=map(int,input().split())", "map(int,input().split())", "a", "a=lis[k]", "lis[k]", "a", "ra=a-1", "a-1", "ra", "lis=[input() for i in range(a)]", "[input() for i in range(a)]", "lis", "b=map(int,input().split())", "map(int,input().split())", "b" ]

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

[ [ 54, 2 ], [ 54, 11 ], [ 15, 14 ], [ 49, 17 ], [ 42, 22 ], [ 57, 25 ], [ 43, 28 ], [ 45, 30 ], [ 34, 33 ], [ 58, 33 ], [ 51, 36 ], [ 33, 37 ], [ 52, 40 ], [ 46, 40 ], [ 42, 43 ], [ 45, 46 ], [ 54, 49 ], [ 33, 51 ], [ 51, 52 ], [ 54, 55 ], [ 57, 58 ] ]

[ "n,l =map(int,input().split())\nss = [input() for _ in range(n)]\ns =sorted(ss)\nans =\"\"\nfor i in s:\n ans += i\nprint(ans)", "n,l =map(int,input().split())", "n", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "l", "input() for _ in range(n)", "for _ in range(n)", "_", "range(n)", "range", "n", "for _ in range(n)", "input()", "input", "ss = [input() for _ in range(n)]", "ss", "[input() for _ in range(n)]", "s =sorted(ss)", "s", "sorted(ss)", "sorted", "ss", "ans =\"\"", "ans", "\"\"", "for i in s:\n ans += i", "i", "s", "ans += i", "ans", "i", "print(ans)", "print", "ans", "ss = [input() for _ in range(n)]", "[input() for _ in range(n)]", "ss", "ans =\"\"", "\"\"", "ans", "n,l =map(int,input().split())", "map(int,input().split())", "n", "ans += i", "i", "ans", "l =map(int,input().split())", "map(int,input().split())", "l", "s =sorted(ss)", "sorted(ss)", "s" ]

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

[ [ 44, 2 ], [ 44, 11 ], [ 15, 14 ], [ 39, 17 ], [ 41, 24 ], [ 42, 28 ], [ 42, 36 ], [ 44, 39 ], [ 41, 42 ], [ 44, 45 ] ]

[ "N,J = map(int,input().split())\nS = [str(input()) for _ in range(N)]\nS.sort()\nprint(\"\".join(S))", "N,J = map(int,input().split())", "N", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "J", "str(input()) for _ in range(N)", "for _ in range(N)", "_", "range(N)", "range", "N", "for _ in range(N)", "str(input())", "str", "input()", "input", "S = [str(input()) for _ in range(N)]", "S", "[str(input()) for _ in range(N)]", "S.sort()", "S.sort", "S", "sort", "print(\"\".join(S))", "print", "\"\".join(S)", "\"\".join", "\"\"", "join", "S", "N,J = map(int,input().split())", "map(int,input().split())", "N", "S = [str(input()) for _ in range(N)]", "[str(input()) for _ in range(N)]", "S", "J = map(int,input().split())", "map(int,input().split())", "J" ]

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

[ [ 45, 2 ], [ 45, 11 ], [ 15, 14 ], [ 46, 17 ], [ 48, 22 ], [ 49, 26 ], [ 39, 29 ], [ 49, 34 ], [ 40, 37 ], [ 39, 40 ], [ 45, 43 ], [ 45, 46 ], [ 48, 49 ] ]

[ "N, L = map(int,input().split())\nstr_list = [input() for i in range(N)]\n\nstr_list.sort()\nans = \"\".join(str_list)\nprint(ans)", "N, L = map(int,input().split())", "N", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "L", "input() for i in range(N)", "for i in range(N)", "i", "range(N)", "range", "N", "for i in range(N)", "input()", "input", "str_list = [input() for i in range(N)]", "str_list", "[input() for i in range(N)]", "str_list.sort()", "str_list.sort", "str_list", "sort", "ans = \"\".join(str_list)", "ans", "\"\".join(str_list)", "\"\".join", "\"\"", "join", "str_list", "print(ans)", "print", "ans", "ans = \"\".join(str_list)", "\"\".join(str_list)", "ans", "L = map(int,input().split())", "map(int,input().split())", "L", "N, L = map(int,input().split())", "map(int,input().split())", "N", "str_list = [input() for i in range(N)]", "[input() for i in range(N)]", "str_list" ]

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

[ [ 42, 2 ], [ 42, 11 ], [ 15, 14 ], [ 43, 17 ], [ 45, 24 ], [ 48, 27 ], [ 46, 30 ], [ 49, 37 ], [ 46, 37 ], [ 42, 40 ], [ 42, 43 ], [ 45, 46 ], [ 48, 49 ] ]

[ "n, l = map(int, input().split())\ns_l = [ str(input()) for _ in range(n) ]\ns_l = sorted(s_l)\nprint(''.join(s_l))", "n, l = map(int, input().split())", "n", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "l", "str(input()) for _ in range(n)", "for _ in range(n)", "_", "range(n)", "range", "n", "for _ in range(n)", "str(input())", "str", "input()", "input", "s_l = [ str(input()) for _ in range(n) ]", "s_l", "[ str(input()) for _ in range(n) ]", "s_l = sorted(s_l)", "s_l", "sorted(s_l)", "sorted", "s_l", "print(''.join(s_l))", "print", "''.join(s_l)", "''.join", "''", "join", "s_l", "l = map(int, input().split())", "map(int, input().split())", "l", "n, l = map(int, input().split())", "map(int, input().split())", "n", "s_l = [ str(input()) for _ in range(n) ]", "[ str(input()) for _ in range(n) ]", "s_l", "s_l = sorted(s_l)", "sorted(s_l)", "s_l" ]

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

[ [ 46, 2 ], [ 46, 11 ], [ 49, 13 ], [ 17, 16 ], [ 44, 19 ], [ 50, 22 ], [ 50, 28 ], [ 52, 31 ], [ 35, 34 ], [ 50, 34 ], [ 55, 37 ], [ 34, 38 ], [ 56, 41 ], [ 53, 41 ], [ 46, 44 ], [ 46, 47 ], [ 49, 50 ], [ 52, 53 ], [ 34, 55 ], [ 55, 56 ] ]

[ "N, L = map(int,input().split())\na = []\nfor i in range(N):\n a.append(input())\na.sort()\nans= ''\nfor i in a:\n ans += i\nprint(ans)", "N, L = map(int,input().split())", "N", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "L", "a = []", "a", "[]", "for i in range(N):\n a.append(input())", "i", "range(N)", "range", "N", "a.append(input())", "a.append", "a", "append", "input()", "input", "a.sort()", "a.sort", "a", "sort", "ans= ''", "ans", "''", "for i in a:\n ans += i", "i", "a", "ans += i", "ans", "i", "print(ans)", "print", "ans", "N, L = map(int,input().split())", "map(int,input().split())", "N", "L = map(int,input().split())", "map(int,input().split())", "L", "a = []", "[]", "a", "ans= ''", "''", "ans", "ans += i", "i", "ans" ]

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

[ [ 5, 4 ], [ 5, 13 ], [ 16, 15 ], [ 19, 18 ], [ 4, 21 ], [ 24, 23 ], [ 15, 28 ], [ 23, 30 ], [ 15, 33 ], [ 37, 36 ], [ 15, 41 ], [ 36, 44 ], [ 53, 50 ] ]

[ "def main():\n N, L = map(int, input().split())\n S = []\n for i in range(N):\n s = input()\n S.append(s)\n S.sort()\n ans = ''.join(S)\n print(ans)\n\nif __name__ == \"__main__\":\n main()", "def main():\n N, L = map(int, input().split())\n S = []\n for i in range(N):\n s = input()\n S.append(s)\n S.sort()\n ans = ''.join(S)\n print(ans)", "main", "N, L = map(int, input().split())", "N", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "L", "S = []", "S", "[]", "for i in range(N):\n s = input()\n S.append(s)\n ", "i", "range(N)", "range", "N", "s = input()", "s", "input()", "input", "S.append(s)", "S.append", "S", "append", "s", "S.sort()", "S.sort", "S", "sort", "ans = ''.join(S)", "ans", "''.join(S)", "''.join", "''", "join", "S", "print(ans)", "print", "ans", "if __name__ == \"__main__\":\n main()", "__name__ == \"__main__\"", "__name__", "\"__main__\"", "main()", "main", "def main():\n N, L = map(int, input().split())\n S = []\n for i in range(N):\n s = input()\n S.append(s)\n S.sort()\n ans = ''.join(S)\n print(ans)", "def main():\n N, L = map(int, input().split())\n S = []\n for i in range(N):\n s = input()\n S.append(s)\n S.sort()\n ans = ''.join(S)\n print(ans)", "main" ]

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

[ [ 40, 2 ], [ 40, 11 ], [ 15, 14 ], [ 35, 17 ], [ 37, 22 ], [ 38, 29 ], [ 32, 31 ], [ 40, 35 ], [ 37, 38 ], [ 40, 41 ] ]

[ "n,l = map(int,input().split())\ns = sorted([input() for i in range(n)])\nprint(*s,sep=\"\")", "n,l = map(int,input().split())", "n", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "l", "input() for i in range(n)", "for i in range(n)", "i", "range(n)", "range", "n", "for i in range(n)", "input()", "input", "s = sorted([input() for i in range(n)])", "s", "sorted([input() for i in range(n)])", "sorted", "[input() for i in range(n)]", "print(*s,sep=\"\")", "print", "*s", "s", "sep=\"\"", "sep", "\"\"", "n,l = map(int,input().split())", "map(int,input().split())", "n", "s = sorted([input() for i in range(n)])", "sorted([input() for i in range(n)])", "s", "l = map(int,input().split())", "map(int,input().split())", "l" ]

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

[ [ 44, 2 ], [ 44, 11 ], [ 41, 13 ], [ 17, 16 ], [ 45, 19 ], [ 42, 22 ], [ 42, 36 ], [ 44, 39 ], [ 41, 42 ], [ 44, 45 ] ]

[ "N,L=map(int,input().split())\nS=[]\nfor i in range(N):\n S.append(str(input()))\nprint(\"\".join(sorted(S)))", "N,L=map(int,input().split())", "N", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "L", "S=[]", "S", "[]", "for i in range(N):\n S.append(str(input()))", "i", "range(N)", "range", "N", "S.append(str(input()))", "S.append", "S", "append", "str(input())", "str", "input()", "input", "print(\"\".join(sorted(S)))", "print", "\"\".join(sorted(S))", "\"\".join", "\"\"", "join", "sorted(S)", "sorted", "S", "L=map(int,input().split())", "map(int,input().split())", "L", "S=[]", "[]", "S", "N,L=map(int,input().split())", "map(int,input().split())", "N" ]

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

[ [ 37, 2 ], [ 37, 11 ], [ 15, 14 ], [ 38, 17 ], [ 37, 35 ], [ 37, 38 ] ]

[ "N,L = map(int,input().split())\nprint(\"\".join(sorted([input().strip() for _ in range(N)])))", "N,L = map(int,input().split())", "N", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "L", "input().strip() for _ in range(N)", "for _ in range(N)", "_", "range(N)", "range", "N", "for _ in range(N)", "input().strip()", "().strip", "()", "input", "strip", "print(\"\".join(sorted([input().strip() for _ in range(N)])))", "print", "\"\".join(sorted([input().strip() for _ in range(N)]))", "\"\".join", "\"\"", "join", "sorted([input().strip() for _ in range(N)])", "sorted", "[input().strip() for _ in range(N)]", "L = map(int,input().split())", "map(int,input().split())", "L", "N,L = map(int,input().split())", "map(int,input().split())", "N" ]

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

[ [ 48, 2 ], [ 48, 8 ], [ 51, 10 ], [ 14, 13 ], [ 43, 18 ], [ 52, 21 ], [ 52, 27 ], [ 45, 30 ], [ 34, 33 ], [ 52, 33 ], [ 54, 36 ], [ 33, 37 ], [ 55, 40 ], [ 46, 40 ], [ 48, 43 ], [ 45, 46 ], [ 48, 49 ], [ 51, 52 ], [ 33, 54 ], [ 54, 55 ] ]

[ "n,l = input().split()\nS = []\nfor i in range(int(n)):\n S.append(input())\nS.sort()\nstr = ''\nfor s in S:\n str += s\nprint(str)", "n,l = input().split()", "n", "input().split()", "().split", "()", "input", "split", "l", "S = []", "S", "[]", "for i in range(int(n)):\n S.append(input())", "i", "range(int(n))", "range", "int(n)", "int", "n", "S.append(input())", "S.append", "S", "append", "input()", "input", "S.sort()", "S.sort", "S", "sort", "str = ''", "str", "''", "for s in S:\n str += s", "s", "S", "str += s", "str", "s", "print(str)", "print", "str", "n,l = input().split()", "input().split()", "n", "str = ''", "''", "str", "l = input().split()", "input().split()", "l", "S = []", "[]", "S", "str += s", "s", "str" ]

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

[ [ 67, 2 ], [ 67, 13 ], [ 64, 15 ], [ 61, 18 ], [ 22, 21 ], [ 68, 24 ], [ 65, 27 ], [ 73, 32 ], [ 65, 35 ], [ 55, 37 ], [ 41, 40 ], [ 68, 43 ], [ 70, 45 ], [ 56, 47 ], [ 71, 47 ], [ 74, 49 ], [ 62, 49 ], [ 40, 50 ], [ 71, 53 ], [ 56, 53 ], [ 55, 56 ], [ 67, 59 ], [ 61, 62 ], [ 64, 65 ], [ 67, 68 ], [ 70, 71 ], [ 73, 74 ] ]

[ "N,L=list(map(int,input().split()))\nS=[]\nB=[]\nfor n in range(N):\n S.append(input())\n \nB=sorted(S)\nC=\"\"\nfor n in range(N):\n C=C+(B[n])\n \nprint(C)", "N,L=list(map(int,input().split()))", "N", "list(map(int,input().split()))", "list", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "L", "S=[]", "S", "[]", "B=[]", "B", "[]", "for n in range(N):\n S.append(input())\n ", "n", "range(N)", "range", "N", "S.append(input())", "S.append", "S", "append", "input()", "input", "B=sorted(S)", "B", "sorted(S)", "sorted", "S", "C=\"\"", "C", "\"\"", "for n in range(N):\n C=C+(B[n])\n ", "n", "range(N)", "range", "N", "C=C+(B[n])", "C", "C+(B[n])", "C", "B[n]", "B", "n", "print(C)", "print", "C", "C=\"\"", "\"\"", "C", "L=list(map(int,input().split()))", "list(map(int,input().split()))", "L", "B=[]", "[]", "B", "S=[]", "[]", "S", "N,L=list(map(int,input().split()))", "list(map(int,input().split()))", "N", "C=C+(B[n])", "C+(B[n])", "C", "B=sorted(S)", "sorted(S)", "B" ]

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

[ [ 42, 2 ], [ 42, 11 ], [ 15, 14 ], [ 43, 17 ], [ 39, 22 ], [ 40, 26 ], [ 40, 34 ], [ 42, 37 ], [ 39, 40 ], [ 42, 43 ] ]

[ "n,_ = map(int,input().split())\ns = [input() for _ in range(n)]\ns.sort()\nprint(''.join(s))", "n,_ = map(int,input().split())", "n", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "_", "input() for _ in range(n)", "for _ in range(n)", "_", "range(n)", "range", "n", "for _ in range(n)", "input()", "input", "s = [input() for _ in range(n)]", "s", "[input() for _ in range(n)]", "s.sort()", "s.sort", "s", "sort", "print(''.join(s))", "print", "''.join(s)", "''.join", "''", "join", "s", "_ = map(int,input().split())", "map(int,input().split())", "_", "s = [input() for _ in range(n)]", "[input() for _ in range(n)]", "s", "n,_ = map(int,input().split())", "map(int,input().split())", "n" ]

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

[ [ 51, 4 ], [ 57, 11 ], [ 52, 18 ], [ 57, 20 ], [ 60, 22 ], [ 26, 25 ], [ 58, 28 ], [ 61, 31 ], [ 52, 36 ], [ 61, 41 ], [ 61, 49 ], [ 51, 52 ], [ 57, 55 ], [ 57, 58 ], [ 60, 61 ] ]

[ "# n, m, l = map(int, input().split())\n\n# list_n = list(map(int, input().split()))\n\n# n = input()\n# list = [input() for i in range(N)\n\n# list = [[i for i in range(N)] for _ in range(M)]\n\nimport sys\ninput = sys.stdin.readline\n\nN, L = map(int, input().split())\nS = []\nfor i in range(N):\n S.append(input().rstrip('\\n'))\nS.sort()\nprint(''.join(S))", "import sys", "sys", "input = sys.stdin.readline", "input", "sys.stdin.readline", "sys.stdin", "sys", "stdin", "readline", "N, L = map(int, input().split())", "N", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "L", "S = []", "S", "[]", "for i in range(N):\n S.append(input().rstrip('\\n'))", "i", "range(N)", "range", "N", "S.append(input().rstrip('\\n'))", "S.append", "S", "append", "input().rstrip('\\n')", "().rstrip", "()", "input", "rstrip", "'\\n'", "S.sort()", "S.sort", "S", "sort", "print(''.join(S))", "print", "''.join(S)", "''.join", "''", "join", "S", "input = sys.stdin.readline", "sys.stdin.readline", "input", "L = map(int, input().split())", "map(int, input().split())", "L", "N, L = map(int, input().split())", "map(int, input().split())", "N", "S = []", "[]", "S" ]

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

[ [ 58, 2 ], [ 58, 11 ], [ 52, 13 ], [ 18, 17 ], [ 59, 20 ], [ 53, 23 ], [ 53, 31 ], [ 61, 34 ], [ 38, 37 ], [ 59, 40 ], [ 64, 42 ], [ 62, 44 ], [ 65, 44 ], [ 53, 46 ], [ 37, 47 ], [ 65, 50 ], [ 62, 50 ], [ 52, 53 ], [ 58, 56 ], [ 58, 59 ], [ 61, 62 ], [ 64, 65 ] ]

[ "n, l = map(int, input().split())\ns = list()\nfor i in range(n):\n s.append(str(input()))\ns.sort()\nans = ''\nfor j in range(n):\n ans = ans + s[j]\nprint(ans)", "n, l = map(int, input().split())", "n", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "l", "s = list()", "s", "list()", "list", "for i in range(n):\n s.append(str(input()))", "i", "range(n)", "range", "n", "s.append(str(input()))", "s.append", "s", "append", "str(input())", "str", "input()", "input", "s.sort()", "s.sort", "s", "sort", "ans = ''", "ans", "''", "for j in range(n):\n ans = ans + s[j]", "j", "range(n)", "range", "n", "ans = ans + s[j]", "ans", "ans + s[j]", "ans", "s[j]", "s", "j", "print(ans)", "print", "ans", "s = list()", "list()", "s", "l = map(int, input().split())", "map(int, input().split())", "l", "n, l = map(int, input().split())", "map(int, input().split())", "n", "ans = ''", "''", "ans", "ans = ans + s[j]", "ans + s[j]", "ans" ]

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

[ [ 52, 2 ], [ 52, 11 ], [ 15, 14 ], [ 53, 17 ], [ 55, 22 ], [ 58, 25 ], [ 29, 28 ], [ 53, 31 ], [ 61, 33 ], [ 56, 36 ], [ 56, 40 ], [ 56, 44 ], [ 62, 47 ], [ 59, 47 ], [ 52, 50 ], [ 52, 53 ], [ 55, 56 ], [ 58, 59 ], [ 61, 62 ] ]

[ "n, l = map(int,input().split())\nS = [input() for i in range(n)]\nans = ''\nfor i in range(n):\n ans += S.pop(S.index(min(S)))\nprint(ans)", "n, l = map(int,input().split())", "n", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "l", "input() for i in range(n)", "for i in range(n)", "i", "range(n)", "range", "n", "for i in range(n)", "input()", "input", "S = [input() for i in range(n)]", "S", "[input() for i in range(n)]", "ans = ''", "ans", "''", "for i in range(n):\n ans += S.pop(S.index(min(S)))", "i", "range(n)", "range", "n", "ans += S.pop(S.index(min(S)))", "ans", "S.pop(S.index(min(S)))", "S.pop", "S", "pop", "S.index(min(S))", "S.index", "S", "index", "min(S)", "min", "S", "print(ans)", "print", "ans", "l = map(int,input().split())", "map(int,input().split())", "l", "n, l = map(int,input().split())", "map(int,input().split())", "n", "S = [input() for i in range(n)]", "[input() for i in range(n)]", "S", "ans = ''", "''", "ans", "ans += S.pop(S.index(min(S)))", "S.pop(S.index(min(S)))", "ans" ]

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

[ [ 66, 13 ], [ 63, 20 ], [ 63, 29 ], [ 33, 32 ], [ 64, 35 ], [ 69, 40 ], [ 70, 44 ], [ 57, 47 ], [ 70, 52 ], [ 58, 55 ], [ 57, 58 ], [ 63, 61 ], [ 63, 64 ], [ 66, 67 ], [ 69, 70 ] ]

[ "from sys import stdin, stdout\nfrom time import perf_counter\n\nimport sys\nsys.setrecursionlimit(10**9)\nmod = 10**9+7\n\n\n\n\n\nn,l = map(int, input().split())\ns = [input() for _ in range(n)]\ns.sort()\nresult =\"\".join(s)\nprint(result)", "from sys import stdin, stdout", "from time import perf_counter", "import sys", "sys", "sys.setrecursionlimit(10**9)", "sys.setrecursionlimit", "sys", "setrecursionlimit", "10**9", "10", "9", "mod = 10**9+7", "mod", "10**9+7", "10**9", "10", "9", "7", "n,l = map(int, input().split())", "n", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "l", "input() for _ in range(n)", "for _ in range(n)", "_", "range(n)", "range", "n", "for _ in range(n)", "input()", "input", "s = [input() for _ in range(n)]", "s", "[input() for _ in range(n)]", "s.sort()", "s.sort", "s", "sort", "result =\"\".join(s)", "result", "\"\".join(s)", "\"\".join", "\"\"", "join", "s", "print(result)", "print", "result", "result =\"\".join(s)", "\"\".join(s)", "result", "l = map(int, input().split())", "map(int, input().split())", "l", "n,l = map(int, input().split())", "map(int, input().split())", "n", "mod = 10**9+7", "10**9+7", "mod", "s = [input() for _ in range(n)]", "[input() for _ in range(n)]", "s" ]

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

[ [ 52, 2 ], [ 58, 19 ], [ 53, 21 ], [ 55, 24 ], [ 53, 26 ], [ 31, 30 ], [ 59, 33 ], [ 61, 38 ], [ 62, 42 ], [ 62, 50 ], [ 52, 53 ], [ 55, 56 ], [ 58, 59 ], [ 61, 62 ] ]

[ "nl = list(map(lambda x: int(x), input().split(\" \")))\nn = nl[0]\nl = nl[1]\n\nstrs = [input() for i in range(n)]\n\nstrs.sort()\n\nprint(''.join(strs))", "nl = list(map(lambda x: int(x), input().split(\" \")))", "nl", "list(map(lambda x: int(x), input().split(\" \")))", "list", "map(lambda x: int(x), input().split(\" \"))", "map", "lambda x: int(x)", "int(x)", "int", "x", "x", "input().split(\" \")", "().split", "()", "input", "split", "\" \"", "n = nl[0]", "n", "nl[0]", "nl", "0", "l = nl[1]", "l", "nl[1]", "nl", "1", "input() for i in range(n)", "for i in range(n)", "i", "range(n)", "range", "n", "for i in range(n)", "input()", "input", "strs = [input() for i in range(n)]", "strs", "[input() for i in range(n)]", "strs.sort()", "strs.sort", "strs", "sort", "print(''.join(strs))", "print", "''.join(strs)", "''.join", "''", "join", "strs", "nl = list(map(lambda x: int(x), input().split(\" \")))", "list(map(lambda x: int(x), input().split(\" \")))", "nl", "l = nl[1]", "nl[1]", "l", "n = nl[0]", "nl[0]", "n", "strs = [input() for i in range(n)]", "[input() for i in range(n)]", "strs" ]

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

[ [ 188, 4 ], [ 194, 11 ], [ 189, 16 ], [ 182, 23 ], [ 182, 32 ], [ 37, 36 ], [ 183, 39 ], [ 195, 43 ], [ 71, 45 ], [ 36, 46 ], [ 195, 48 ], [ 73, 50 ], [ 36, 51 ], [ 195, 57 ], [ 71, 59 ], [ 36, 60 ], [ 195, 62 ], [ 73, 64 ], [ 36, 65 ], [ 71, 71 ], [ 73, 73 ], [ 78, 77 ], [ 152, 80 ], [ 83, 82 ], [ 77, 86 ], [ 77, 93 ], [ 132, 93 ], [ 125, 93 ], [ 97, 96 ], [ 192, 98 ], [ 152, 100 ], [ 82, 102 ], [ 116, 102 ], [ 77, 104 ], [ 132, 104 ], [ 125, 104 ], [ 150, 106 ], [ 96, 110 ], [ 96, 113 ], [ 117, 116 ], [ 82, 119 ], [ 116, 119 ], [ 77, 121 ], [ 132, 121 ], [ 125, 121 ], [ 126, 125 ], [ 77, 128 ], [ 132, 128 ], [ 125, 128 ], [ 133, 132 ], [ 77, 134 ], [ 132, 134 ], [ 125, 134 ], [ 152, 140 ], [ 152, 146 ], [ 150, 150 ], [ 152, 152 ], [ 185, 154 ], [ 158, 157 ], [ 180, 160 ], [ 197, 162 ], [ 177, 164 ], [ 186, 167 ], [ 198, 167 ], [ 198, 174 ], [ 186, 174 ], [ 182, 180 ], [ 182, 183 ], [ 185, 186 ], [ 188, 189 ], [ 194, 195 ], [ 197, 198 ] ]

[ "import string\n\nalph_list=list(string.ascii_lowercase)\nmydict=dict(zip(alph_list,list(range(26))))\nN, L=map(int,input().split())\n\ndef compare_str(s,t):\n for i in range(L):\n if mydict[s[i]]<mydict[t[i]]:\n return '<'\n elif mydict[s[i]]>mydict[t[i]]:\n return '>'\n return '='\n\ndef newlist(w,lst):\n l=len(lst)\n pos=0\n if l==0:\n return [w]\n while l>0:\n ineq=compare_str(lst[pos+l//2],w)\n if ineq=='<' or ineq=='=':\n pos=pos+l//2+1\n l=(l-1)//2\n else:\n l=l//2\n return lst[:pos] + [w] + lst[pos:]\n\nmylist=[]\nfor _ in range(N):\n mylist=newlist(input(),mylist)\n\nprint(''.join(mylist))", "import string", "string", "alph_list=list(string.ascii_lowercase)", "alph_list", "list(string.ascii_lowercase)", "list", "string.ascii_lowercase", "string", "ascii_lowercase", "mydict=dict(zip(alph_list,list(range(26))))", "mydict", "dict(zip(alph_list,list(range(26))))", "dict", "zip(alph_list,list(range(26)))", "zip", "alph_list", "list(range(26))", "list", "range(26)", "range", "26", "N, L=map(int,input().split())", "N", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "L", "def compare_str(s,t):\n for i in range(L):\n if mydict[s[i]]<mydict[t[i]]:\n return '<'\n elif mydict[s[i]]>mydict[t[i]]:\n return '>'\n return '='", "compare_str", "for i in range(L):\n if mydict[s[i]]<mydict[t[i]]:\n return '<'\n elif mydict[s[i]]>mydict[t[i]]:\n return '>'\n ", "i", "range(L)", "range", "L", "if mydict[s[i]]<mydict[t[i]]:\n return '<'\n elif mydict[s[i]]>mydict[t[i]]:\n return '>'\n ", "mydict[s[i]]<mydict[t[i]]", "mydict[s[i]]", "mydict", "s[i]", "s", "i", "mydict[t[i]]", "mydict", "t[i]", "t", "i", "return '<'", "'<'", "elif mydict[s[i]]>mydict[t[i]]:\n return '>'\n ", "mydict[s[i]]>mydict[t[i]]", "mydict[s[i]]", "mydict", "s[i]", "s", "i", "mydict[t[i]]", "mydict", "t[i]", "t", "i", "return '>'", "'>'", "return '='", "'='", "s", "s", "t", "t", "def newlist(w,lst):\n l=len(lst)\n pos=0\n if l==0:\n return [w]\n while l>0:\n ineq=compare_str(lst[pos+l//2],w)\n if ineq=='<' or ineq=='=':\n pos=pos+l//2+1\n l=(l-1)//2\n else:\n l=l//2\n return lst[:pos] + [w] + lst[pos:]", "newlist", "l=len(lst)", "l", "len(lst)", "len", "lst", "pos=0", "pos", "0", "if l==0:\n return [w]\n ", "l==0", "l", "0", "return [w]", "[w]", "w", "while l>0:\n ineq=compare_str(lst[pos+l//2],w)\n if ineq=='<' or ineq=='=':\n pos=pos+l//2+1\n l=(l-1)//2\n else:\n l=l//2\n ", "l>0", "l", "0", "ineq=compare_str(lst[pos+l//2],w)", "ineq", "compare_str(lst[pos+l//2],w)", "compare_str", "lst[pos+l//2]", "lst", "pos+l//2", "pos", "l//2", "l", "2", "w", "if ineq=='<' or ineq=='=':\n pos=pos+l//2+1\n l=(l-1)//2\n else:\n l=l//2\n ", "ineq=='<' or ineq=='='", "ineq=='<'", "ineq", "'<'", "ineq=='='", "ineq", "'='", "pos=pos+l//2+1", "pos", "pos+l//2+1", "pos+l//2", "pos", "l//2", "l", "2", "1", "l=(l-1)//2", "l", "(l-1)//2", "l-1", "l", "1", "2", "l=l//2", "l", "l//2", "l", "2", "return lst[:pos] + [w] + lst[pos:]", "lst[:pos] + [w] + lst[pos:]", "lst[:pos] + [w]", "lst[:pos]", "lst", ":pos", "pos", "[w]", "w", "lst[pos:]", "lst", "pos:", "pos", "w", "w", "lst", "lst", "mylist=[]", "mylist", "[]", "for _ in range(N):\n mylist=newlist(input(),mylist)", "_", "range(N)", "range", "N", "mylist=newlist(input(),mylist)", "mylist", "newlist(input(),mylist)", "newlist", "input()", "input", "mylist", "print(''.join(mylist))", "print", "''.join(mylist)", "''.join", "''", "join", "mylist", "def newlist(w,lst):\n l=len(lst)\n pos=0\n if l==0:\n return [w]\n while l>0:\n ineq=compare_str(lst[pos+l//2],w)\n if ineq=='<' or ineq=='=':\n pos=pos+l//2+1\n l=(l-1)//2\n else:\n l=l//2\n return lst[:pos] + [w] + lst[pos:]", "def newlist(w,lst):\n l=len(lst)\n pos=0\n if l==0:\n return [w]\n while l>0:\n ineq=compare_str(lst[pos+l//2],w)\n if ineq=='<' or ineq=='=':\n pos=pos+l//2+1\n l=(l-1)//2\n else:\n l=l//2\n return lst[:pos] + [w] + lst[pos:]", "newlist", "N, L=map(int,input().split())", "map(int,input().split())", "N", "L=map(int,input().split())", "map(int,input().split())", "L", "mylist=[]", "[]", "mylist", "alph_list=list(string.ascii_lowercase)", "list(string.ascii_lowercase)", "alph_list", "def compare_str(s,t):\n for i in range(L):\n if mydict[s[i]]<mydict[t[i]]:\n return '<'\n elif mydict[s[i]]>mydict[t[i]]:\n return '>'\n return '='", "def compare_str(s,t):\n for i in range(L):\n if mydict[s[i]]<mydict[t[i]]:\n return '<'\n elif mydict[s[i]]>mydict[t[i]]:\n return '>'\n return '='", "compare_str", "mydict=dict(zip(alph_list,list(range(26))))", "dict(zip(alph_list,list(range(26))))", "mydict", "mylist=newlist(input(),mylist)", "newlist(input(),mylist)", "mylist" ]

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

[ [ 42, 2 ], [ 42, 11 ], [ 45, 13 ], [ 17, 16 ], [ 40, 19 ], [ 46, 22 ], [ 48, 27 ], [ 46, 30 ], [ 49, 37 ], [ 42, 40 ], [ 42, 43 ], [ 45, 46 ], [ 48, 49 ] ]

[ "n, l = map(int, input().split())\ns = []\nfor i in range(n):\n s.append(input())\ns_sorted = sorted(s)\nprint(''.join(s_sorted))", "n, l = map(int, input().split())", "n", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "l", "s = []", "s", "[]", "for i in range(n):\n s.append(input())", "i", "range(n)", "range", "n", "s.append(input())", "s.append", "s", "append", "input()", "input", "s_sorted = sorted(s)", "s_sorted", "sorted(s)", "sorted", "s", "print(''.join(s_sorted))", "print", "''.join(s_sorted)", "''.join", "''", "join", "s_sorted", "n, l = map(int, input().split())", "map(int, input().split())", "n", "l = map(int, input().split())", "map(int, input().split())", "l", "s = []", "[]", "s", "s_sorted = sorted(s)", "sorted(s)", "s_sorted" ]

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

[ [ 50, 2 ], [ 50, 11 ], [ 15, 14 ], [ 51, 17 ], [ 56, 24 ], [ 57, 28 ], [ 59, 31 ], [ 35, 34 ], [ 51, 37 ], [ 53, 39 ], [ 57, 41 ], [ 34, 42 ], [ 54, 45 ], [ 60, 45 ], [ 50, 48 ], [ 50, 51 ], [ 53, 54 ], [ 56, 57 ], [ 59, 60 ] ]

[ "N, L = map(int, input().split())\ns = [str(input()) for i in range(N)]\ns.sort()\nS=\"\"\nfor i in range(N):\n S+=s[i]\nprint(S)", "N, L = map(int, input().split())", "N", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "L", "str(input()) for i in range(N)", "for i in range(N)", "i", "range(N)", "range", "N", "for i in range(N)", "str(input())", "str", "input()", "input", "s = [str(input()) for i in range(N)]", "s", "[str(input()) for i in range(N)]", "s.sort()", "s.sort", "s", "sort", "S=\"\"", "S", "\"\"", "for i in range(N):\n S+=s[i]", "i", "range(N)", "range", "N", "S+=s[i]", "S", "s[i]", "s", "i", "print(S)", "print", "S", "L = map(int, input().split())", "map(int, input().split())", "L", "N, L = map(int, input().split())", "map(int, input().split())", "N", "S+=s[i]", "s[i]", "S", "s = [str(input()) for i in range(N)]", "[str(input()) for i in range(N)]", "s", "S=\"\"", "\"\"", "S" ]

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

[ [ 4, 3 ], [ 3, 12 ], [ 53, 14 ], [ 53, 16 ], [ 47, 18 ], [ 22, 21 ], [ 54, 24 ], [ 48, 27 ], [ 50, 32 ], [ 48, 35 ], [ 51, 39 ], [ 48, 39 ], [ 42, 41 ], [ 53, 45 ], [ 47, 48 ], [ 50, 51 ], [ 53, 54 ] ]

[ "N, L = [int(a) for a in input().split()]\nS = []\nfor i in range(N):\n S.append(input())\n\nS = sorted(S)\n\nprint(*S,sep=\"\")", "int(a) for a in input().split()", "for a in input().split()", "a", "input().split()", "().split", "()", "input", "split", "for a in input().split()", "int(a)", "int", "a", "N, L = [int(a) for a in input().split()]", "N", "[int(a) for a in input().split()]", "L", "S = []", "S", "[]", "for i in range(N):\n S.append(input())", "i", "range(N)", "range", "N", "S.append(input())", "S.append", "S", "append", "input()", "input", "S = sorted(S)", "S", "sorted(S)", "sorted", "S", "print(*S,sep=\"\")", "print", "*S", "S", "sep=\"\"", "sep", "\"\"", "L = [int(a) for a in input().split()]", "[int(a) for a in input().split()]", "L", "S = []", "[]", "S", "S = sorted(S)", "sorted(S)", "S", "N, L = [int(a) for a in input().split()]", "[int(a) for a in input().split()]", "N" ]

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

[ [ 30, 6 ], [ 31, 20 ], [ 31, 28 ], [ 30, 31 ] ]

[ "import sys\ninput()\nl=list(sys.stdin.read().split())\nl.sort()\nprint(\"\".join(l))", "import sys", "sys", "input()", "input", "l=list(sys.stdin.read().split())", "l", "list(sys.stdin.read().split())", "list", "sys.stdin.read().split()", "sys.stdin.read().split", "sys.stdin.read()", "sys.stdin.read", "sys.stdin", "sys", "stdin", "read", "split", "l.sort()", "l.sort", "l", "sort", "print(\"\".join(l))", "print", "\"\".join(l)", "\"\".join", "\"\"", "join", "l", "l=list(sys.stdin.read().split())", "list(sys.stdin.read().split())", "l" ]

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

[ [ 10, 9 ], [ 9, 18 ], [ 21, 20 ], [ 21, 22 ], [ 25, 24 ], [ 28, 27 ], [ 20, 30 ], [ 24, 33 ], [ 24, 39 ], [ 24, 47 ], [ 65, 49 ], [ 53, 52 ], [ 66, 57 ], [ 68, 60 ], [ 72, 62 ], [ 65, 66 ], [ 68, 69 ] ]

[ "# -*- coding: utf-8 -*-\nimport sys\nfrom collections import deque, defaultdict\nfrom math import sqrt, factorial\n# def input(): return sys.stdin.readline()[:-1] # warning not \\n\n# def input(): return sys.stdin.buffer.readline().strip() # warning bytes\n# def input(): return sys.stdin.buffer.readline().decode('utf-8')\n\n\ndef solve():\n n, l = [int(x) for x in input().split()]\n a = []\n for _ in range(n):\n a.append(input())\n a.sort()\n print(''.join(a))\n\n\n\nt = 1\n# t = int(input())\nfor case in range(1,t+1):\n ans = solve()\n\n\n\"\"\"\n\na aa c ca c a b a ab a b c\n\n\"\"\"", "import sys", "sys", "from collections import deque, defaultdict", "from math import sqrt, factorial", "def solve():\n n, l = [int(x) for x in input().split()]\n a = []\n for _ in range(n):\n a.append(input())\n a.sort()\n print(''.join(a))", "solve", "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", "n, l = [int(x) for x in input().split()]", "n", "[int(x) for x in input().split()]", "l", "a = []", "a", "[]", "for _ in range(n):\n a.append(input())\n ", "_", "range(n)", "range", "n", "a.append(input())", "a.append", "a", "append", "input()", "input", "a.sort()", "a.sort", "a", "sort", "print(''.join(a))", "print", "''.join(a)", "''.join", "''", "join", "a", "t = 1", "t", "1", "for case in range(1,t+1):\n ans = solve()", "case", "range(1,t+1)", "range", "1", "t+1", "t", "1", "ans = solve()", "ans", "solve()", "solve", "\"\"\"\n\na aa c ca c a b a ab a b c\n\n\"\"\"", "t = 1", "1", "t", "ans = solve()", "solve()", "ans", "def solve():\n n, l = [int(x) for x in input().split()]\n a = []\n for _ in range(n):\n a.append(input())\n a.sort()\n print(''.join(a))", "def solve():\n n, l = [int(x) for x in input().split()]\n a = []\n for _ in range(n):\n a.append(input())\n a.sort()\n print(''.join(a))", "solve" ]

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

[ [ 60, 2 ], [ 60, 13 ], [ 63, 15 ], [ 19, 18 ], [ 55, 21 ], [ 57, 23 ], [ 58, 30 ], [ 61, 31 ], [ 64, 39 ], [ 58, 41 ], [ 64, 44 ], [ 64, 52 ], [ 60, 55 ], [ 57, 58 ], [ 60, 61 ], [ 63, 64 ] ]

[ "N, L = list(map(int, input().split()))\narr_input=[]\nfor i in range(N):\n\tinput_ = input()\n\tif(len(input_)!=L):\n\t\tprint(\"Input length is wrong\")\n\t\texit()\n\tarr_input.append(input_)\narr_input.sort()\nprint(\"\".join(arr_input))", "N, L = list(map(int, input().split()))", "N", "list(map(int, input().split()))", "list", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "L", "arr_input=[]", "arr_input", "[]", "for i in range(N):\n\tinput_ = input()\n\tif(len(input_)!=L):\n\t\tprint(\"Input length is wrong\")\n\t\texit()\n\tarr_input.append(input_)", "i", "range(N)", "range", "N", "input_ = input()", "input_", "input()", "input", "if(len(input_)!=L):\n\t\tprint(\"Input length is wrong\")\n\t\texit()\n\t", "len(input_)!=L", "len(input_)", "len", "input_", "L", "print(\"Input length is wrong\")", "print", "\"Input length is wrong\"", "exit()", "exit", "arr_input.append(input_)", "arr_input.append", "arr_input", "append", "input_", "arr_input.sort()", "arr_input.sort", "arr_input", "sort", "print(\"\".join(arr_input))", "print", "\"\".join(arr_input)", "\"\".join", "\"\"", "join", "arr_input", "N, L = list(map(int, input().split()))", "list(map(int, input().split()))", "N", "input_ = input()", "input()", "input_", "L = list(map(int, input().split()))", "list(map(int, input().split()))", "L", "arr_input=[]", "[]", "arr_input" ]

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

[ [ 61, 2 ], [ 61, 11 ], [ 15, 14 ], [ 59, 17 ], [ 70, 21 ], [ 25, 24 ], [ 59, 27 ], [ 32, 29 ], [ 71, 30 ], [ 24, 31 ], [ 67, 35 ], [ 71, 38 ], [ 64, 40 ], [ 44, 43 ], [ 68, 48 ], [ 71, 48 ], [ 73, 50 ], [ 29, 51 ], [ 68, 52 ], [ 71, 52 ], [ 43, 53 ], [ 74, 56 ], [ 65, 56 ], [ 61, 59 ], [ 61, 62 ], [ 64, 65 ], [ 67, 68 ], [ 70, 71 ], [ 29, 73 ], [ 73, 74 ] ]

[ "N, L = map(int, input().split())\nS = [\"\" for _ in range(N)]\nfor i in range(N):\n S[i] = input()\nS = sorted(S)\n\nans = \"\"\nfor i in range(len(S)):\n ans += S[i]\nprint(ans)", "N, L = map(int, input().split())", "N", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "L", "\"\" for _ in range(N)", "for _ in range(N)", "_", "range(N)", "range", "N", "for _ in range(N)", "\"\"", "S = [\"\" for _ in range(N)]", "S", "[\"\" for _ in range(N)]", "for i in range(N):\n S[i] = input()", "i", "range(N)", "range", "N", "S[i] = input()", "S[i]", "S", "i", "input()", "input", "S = sorted(S)", "S", "sorted(S)", "sorted", "S", "ans = \"\"", "ans", "\"\"", "for i in range(len(S)):\n ans += S[i]", "i", "range(len(S))", "range", "len(S)", "len", "S", "ans += S[i]", "ans", "S[i]", "S", "i", "print(ans)", "print", "ans", "N, L = map(int, input().split())", "map(int, input().split())", "N", "L = map(int, input().split())", "map(int, input().split())", "L", "ans = \"\"", "\"\"", "ans", "S = sorted(S)", "sorted(S)", "S", "S = [\"\" for _ in range(N)]", "[\"\" for _ in range(N)]", "S", "ans += S[i]", "S[i]", "ans" ]

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

[ [ 32, 2 ], [ 32, 11 ], [ 29, 13 ], [ 30, 21 ], [ 24, 23 ], [ 32, 27 ], [ 29, 30 ], [ 32, 33 ] ]

[ "n, l = map(int, input().split())\ns = sorted(input() for _ in range(n))\nprint(*s, sep=\"\")", "n, l = map(int, input().split())", "n", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "l", "s = sorted(input() for _ in range(n))", "s", "sorted(input() for _ in range(n))", "sorted", "input()", "input", "print(*s, sep=\"\")", "print", "*s", "s", "sep=\"\"", "sep", "\"\"", "n, l = map(int, input().split())", "map(int, input().split())", "n", "s = sorted(input() for _ in range(n))", "sorted(input() for _ in range(n))", "s", "l = map(int, input().split())", "map(int, input().split())", "l" ]

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

[ [ 4, 3 ], [ 3, 12 ], [ 46, 14 ], [ 46, 16 ], [ 20, 19 ], [ 47, 23 ], [ 43, 28 ], [ 44, 38 ], [ 46, 41 ], [ 43, 44 ], [ 46, 47 ] ]

[ "N,L = (int(T) for T in input().split())\nS = sorted([input() for T in range(0,N)])\nprint(''.join(S))", "int(T) for T in input().split()", "for T in input().split()", "T", "input().split()", "().split", "()", "input", "split", "for T in input().split()", "int(T)", "int", "T", "N,L = (int(T) for T in input().split())", "N", "(int(T) for T in input().split())", "L", "input() for T in range(0,N)", "for T in range(0,N)", "T", "range(0,N)", "range", "0", "N", "for T in range(0,N)", "input()", "input", "S = sorted([input() for T in range(0,N)])", "S", "sorted([input() for T in range(0,N)])", "sorted", "[input() for T in range(0,N)]", "print(''.join(S))", "print", "''.join(S)", "''.join", "''", "join", "S", "L = (int(T) for T in input().split())", "(int(T) for T in input().split())", "L", "S = sorted([input() for T in range(0,N)])", "sorted([input() for T in range(0,N)])", "S", "N,L = (int(T) for T in input().split())", "(int(T) for T in input().split())", "N" ]

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

[ [ 79, 4 ], [ 18, 17 ], [ 26, 25 ], [ 80, 34 ], [ 26, 37 ], [ 40, 39 ], [ 43, 42 ], [ 25, 45 ], [ 39, 48 ], [ 80, 53 ], [ 57, 56 ], [ 60, 59 ], [ 39, 62 ], [ 65, 64 ], [ 59, 65 ], [ 64, 68 ], [ 56, 68 ], [ 77, 74 ], [ 79, 80 ] ]

[ "import sys\ninput = sys.stdin.readline\n\n\ndef log(*args):\n print(*args, file=sys.stderr)\n\n\ndef main():\n N, L = map(int, input().rstrip().split())\n s = []\n for _ in range(N):\n s.append(input().rstrip())\n ans = ''\n for st in sorted(s):\n ans += st\n print(ans)\n\n\nif __name__ == '__main__':\n main()", "import sys", "sys", "input = sys.stdin.readline", "input", "sys.stdin.readline", "sys.stdin", "sys", "stdin", "readline", "def log(*args):\n print(*args, file=sys.stderr)", "log", "print(*args, file=sys.stderr)", "print", "*args", "args", "file=sys.stderr", "file", "sys.stderr", "sys", "stderr", "*args", "def main():\n N, L = map(int, input().rstrip().split())\n s = []\n for _ in range(N):\n s.append(input().rstrip())\n ans = ''\n for st in sorted(s):\n ans += st\n print(ans)", "main", "N, L = map(int, input().rstrip().split())", "N", "map(int, input().rstrip().split())", "map", "int", "input().rstrip().split()", "().rstrip().split", "().rstrip()", "().rstrip", "()", "input", "rstrip", "split", "L", "s = []", "s", "[]", "for _ in range(N):\n s.append(input().rstrip())\n ", "_", "range(N)", "range", "N", "s.append(input().rstrip())", "s.append", "s", "append", "input().rstrip()", "().rstrip", "()", "input", "rstrip", "ans = ''", "ans", "''", "for st in sorted(s):\n ans += st\n ", "st", "sorted(s)", "sorted", "s", "ans += st", "ans", "st", "print(ans)", "print", "ans", "if __name__ == '__main__':\n main()", "__name__ == '__main__'", "__name__", "'__main__'", "main()", "main", "def main():\n N, L = map(int, input().rstrip().split())\n s = []\n for _ in range(N):\n s.append(input().rstrip())\n ans = ''\n for st in sorted(s):\n ans += st\n print(ans)", "def main():\n N, L = map(int, input().rstrip().split())\n s = []\n for _ in range(N):\n s.append(input().rstrip())\n ans = ''\n for st in sorted(s):\n ans += st\n print(ans)", "main", "input = sys.stdin.readline", "sys.stdin.readline", "input", "def log(*args):\n print(*args, file=sys.stderr)", "def log(*args):\n print(*args, file=sys.stderr)", "log" ]

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

[ [ 34, 2 ], [ 34, 11 ], [ 15, 14 ], [ 35, 17 ], [ 34, 32 ], [ 34, 35 ] ]

[ "N,L=map(int,input().split())\nprint(''.join(sorted([input()for _ in range(N)])))", "N,L=map(int,input().split())", "N", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "L", "input()for _ in range(N)", "for _ in range(N)", "_", "range(N)", "range", "N", "for _ in range(N)", "input()", "input", "print(''.join(sorted([input()for _ in range(N)])))", "print", "''.join(sorted([input()for _ in range(N)]))", "''.join", "''", "join", "sorted([input()for _ in range(N)])", "sorted", "[input()for _ in range(N)]", "L=map(int,input().split())", "map(int,input().split())", "L", "N,L=map(int,input().split())", "map(int,input().split())", "N" ]

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

[ [ 54, 2 ], [ 54, 11 ], [ 48, 13 ], [ 17, 16 ], [ 43, 19 ], [ 51, 21 ], [ 49, 26 ], [ 52, 28 ], [ 45, 30 ], [ 49, 33 ], [ 46, 40 ], [ 49, 40 ], [ 54, 43 ], [ 45, 46 ], [ 48, 49 ], [ 51, 52 ], [ 54, 55 ] ]

[ "n, l = map(int, input().split())\nlst = []\nfor i in range(n):\n s = input()\n lst.append(s)\nlst = sorted(lst)\nprint(''.join(lst))", "n, l = map(int, input().split())", "n", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "l", "lst = []", "lst", "[]", "for i in range(n):\n s = input()\n lst.append(s)", "i", "range(n)", "range", "n", "s = input()", "s", "input()", "input", "lst.append(s)", "lst.append", "lst", "append", "s", "lst = sorted(lst)", "lst", "sorted(lst)", "sorted", "lst", "print(''.join(lst))", "print", "''.join(lst)", "''.join", "''", "join", "lst", "n, l = map(int, input().split())", "map(int, input().split())", "n", "lst = sorted(lst)", "sorted(lst)", "lst", "lst = []", "[]", "lst", "s = input()", "input()", "s", "l = map(int, input().split())", "map(int, input().split())", "l" ]

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

[ [ 37, 2 ], [ 37, 11 ], [ 15, 14 ], [ 35, 17 ], [ 40, 22 ], [ 41, 32 ], [ 37, 35 ], [ 37, 38 ], [ 40, 41 ] ]

[ "n, _l = map(int,input().split())\ns = [input() for _ in range(n)]\nprint(\"\".join(sorted(s)))", "n, _l = map(int,input().split())", "n", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "_l", "input() for _ in range(n)", "for _ in range(n)", "_", "range(n)", "range", "n", "for _ in range(n)", "input()", "input", "s = [input() for _ in range(n)]", "s", "[input() for _ in range(n)]", "print(\"\".join(sorted(s)))", "print", "\"\".join(sorted(s))", "\"\".join", "\"\"", "join", "sorted(s)", "sorted", "s", "n, _l = map(int,input().split())", "map(int,input().split())", "n", "_l = map(int,input().split())", "map(int,input().split())", "_l", "s = [input() for _ in range(n)]", "[input() for _ in range(n)]", "s" ]

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

[ [ 42, 2 ], [ 42, 11 ], [ 15, 14 ], [ 43, 17 ], [ 36, 22 ], [ 37, 26 ], [ 37, 34 ], [ 36, 37 ], [ 42, 40 ], [ 42, 43 ] ]

[ "N,L = map(int, input().split())\nstring_list = [input() for i in range(N)]\nstring_list.sort()\nprint(''.join(string_list))", "N,L = map(int, input().split())", "N", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "L", "input() for i in range(N)", "for i in range(N)", "i", "range(N)", "range", "N", "for i in range(N)", "input()", "input", "string_list = [input() for i in range(N)]", "string_list", "[input() for i in range(N)]", "string_list.sort()", "string_list.sort", "string_list", "sort", "print(''.join(string_list))", "print", "''.join(string_list)", "''.join", "''", "join", "string_list", "string_list = [input() for i in range(N)]", "[input() for i in range(N)]", "string_list", "L = map(int, input().split())", "map(int, input().split())", "L", "N,L = map(int, input().split())", "map(int, input().split())", "N" ]

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

[ [ 59, 2 ], [ 59, 11 ], [ 56, 13 ], [ 60, 17 ], [ 20, 19 ], [ 60, 22 ], [ 27, 24 ], [ 57, 25 ], [ 19, 26 ], [ 50, 32 ], [ 57, 35 ], [ 38, 37 ], [ 60, 40 ], [ 24, 43 ], [ 51, 44 ], [ 57, 44 ], [ 37, 45 ], [ 48, 47 ], [ 50, 51 ], [ 59, 54 ], [ 56, 57 ], [ 59, 60 ] ]

[ "N, L = map(int, input().split())\nS = [0] * N\nfor i in range(N):\n S[i] = str(input())\n \nS = sorted(S)\nfor i in range(N):\n print(S[i], end = \"\")\n\n\n", "N, L = map(int, input().split())", "N", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "L", "S = [0] * N", "S", "[0] * N", "[0]", "0", "N", "for i in range(N):\n S[i] = str(input())\n ", "i", "range(N)", "range", "N", "S[i] = str(input())", "S[i]", "S", "i", "str(input())", "str", "input()", "input", "S = sorted(S)", "S", "sorted(S)", "sorted", "S", "for i in range(N):\n print(S[i], end = \"\")", "i", "range(N)", "range", "N", "print(S[i], end = \"\")", "print", "S[i]", "S", "i", "end = \"\"", "end", "\"\"", "S = sorted(S)", "sorted(S)", "S", "L = map(int, input().split())", "map(int, input().split())", "L", "S = [0] * N", "[0] * N", "S", "N, L = map(int, input().split())", "map(int, input().split())", "N" ]

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

[ [ 39, 2 ], [ 39, 11 ], [ 15, 14 ], [ 37, 17 ], [ 42, 22 ], [ 28, 27 ], [ 43, 27 ], [ 27, 31 ], [ 34, 33 ], [ 39, 37 ], [ 39, 40 ], [ 42, 43 ] ]

[ "n,l=map(int,input().split())\nS=sorted([input() for i in range(n)])\nfor s in S:\n print(s,end=\"\")", "n,l=map(int,input().split())", "n", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "l", "input() for i in range(n)", "for i in range(n)", "i", "range(n)", "range", "n", "for i in range(n)", "input()", "input", "S=sorted([input() for i in range(n)])", "S", "sorted([input() for i in range(n)])", "sorted", "[input() for i in range(n)]", "for s in S:\n print(s,end=\"\")", "s", "S", "print(s,end=\"\")", "print", "s", "end=\"\"", "end", "\"\"", "n,l=map(int,input().split())", "map(int,input().split())", "n", "l=map(int,input().split())", "map(int,input().split())", "l", "S=sorted([input() for i in range(n)])", "sorted([input() for i in range(n)])", "S" ]

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

[ [ 73, 2 ], [ 73, 11 ], [ 73, 12 ], [ 73, 13 ], [ 76, 15 ], [ 70, 22 ], [ 27, 26 ], [ 59, 30 ], [ 74, 31 ], [ 35, 35 ], [ 37, 37 ], [ 39, 39 ], [ 55, 41 ], [ 45, 44 ], [ 65, 47 ], [ 74, 48 ], [ 56, 52 ], [ 77, 53 ], [ 55, 56 ], [ 73, 59 ], [ 73, 65 ], [ 73, 68 ], [ 70, 71 ], [ 73, 74 ], [ 76, 77 ] ]

[ "h,w,a,b=map(int,input().split());m=10**9+7;f=[1]\nfor i in range(h+w):f+=[f[-1]*(i+1)%m]\ndef comb(a,b,m):return f[a]*pow(f[b],m-2,m)*pow(f[a-b],m-2,m)%m\nx=0\nfor i in range(b,w):x+=comb(h-a+i-1,i,m)*comb(a+w-i-2,a-1,m)%m\nprint(x%m)", "h,w,a,b=map(int,input().split())", "h", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "w", "a", "b", "m=10**9+7", "m", "10**9+7", "10**9", "10", "9", "7", "f=[1]", "f", "[1]", "1", "for i in range(h+w):f+=[f[-1]*(i+1)%m]", "i", "range(h+w)", "range", "h+w", "h", "w", "def comb(a,b,m):return f[a]*pow(f[b],m-2,m)*pow(f[a-b],m-2,m)%m", "comb", "a", "a", "b", "b", "m", "m", "x=0", "x", "0", "for i in range(b,w):x+=comb(h-a+i-1,i,m)*comb(a+w-i-2,a-1,m)%m", "i", "range(b,w)", "range", "b", "w", "print(x%m)", "print", "x%m", "x", "m", "x=0", "0", "x", "h,w,a,b=map(int,input().split())", "map(int,input().split())", "h", "def comb(a,b,m):return f[a]*pow(f[b],m-2,m)*pow(f[a-b],m-2,m)%m", "def comb(a,b,m):return f[a]*pow(f[b],m-2,m)*pow(f[a-b],m-2,m)%m", "comb", "b=map(int,input().split())", "map(int,input().split())", "b", "a,b=map(int,input().split())", "map(int,input().split())", "a", "f=[1]", "[1]", "f", "w,a,b=map(int,input().split())", "map(int,input().split())", "w", "m=10**9+7", "10**9+7", "m" ]

[ 7, 6, 13, 12, 13, 0, 18, 13, 13, 2, 13, 17, 0, 18, 13, 13, 13, 0, 18, 13, 13, 2, 39, 17, 17, 2, 39, 17, 13, 0, 18, 13, 13, 2, 39, 17, 17, 2, 39, 17, 13, 0, 18, 13, 13, 2, 39, 17, 17, 2, 39, 17, 13, 28, 13, 4, 13, 17, 18, 13, 13, 0, 18, 18, 13, 13, 13, 2, 2, 18, 18, 13, 13, 2, 13, 17, 13, 18, 13, 13, 0, 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, 0, 18, 18, 13, 13, 13, 2, 2, 18, 18, 13, 13, 2, 13, 17, 18, 18, 13, 13, 13, 18, 13, 13, 23, 13, 23, 13, 23, 13, 2, 2, 17, 17, 17, 12, 13, 14, 2, 2, 2, 13, 13, 2, 13, 17, 2, 13, 17, 29, 17, 29, 2, 2, 18, 18, 13, 13, 13, 18, 18, 13, 13, 2, 13, 13, 18, 13, 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, 18, 18, 13, 13, 13, 2, 2, 18, 18, 13, 13, 13, 18, 18, 13, 13, 2, 13, 13, 18, 13, 13, 18, 13, 13, 23, 13, 23, 13, 23, 13, 12, 13, 29, 4, 18, 13, 13, 2, 2, 13, 13, 17, 2, 13, 17, 23, 13, 23, 13, 23, 13, 12, 13, 14, 2, 13, 17, 29, 17, 29, 18, 18, 13, 13, 13, 23, 13, 23, 13, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 13, 13, 0, 13, 4, 13, 2, 2, 13, 13, 17, 0, 13, 2, 2, 17, 17, 17, 0, 13, 17, 28, 13, 4, 13, 2, 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, 13, 13, 17, 2, 13, 17, 4, 13, 2, 13, 13, 10, 2, 13, 10, 4, 13, 10, 17, 13, 10, 2, 13, 10, 4, 13, 10, 6, 13, 10, 4, 13, 10, 4, 13, 10, 4, 13 ]

[ [ 9, 6 ], [ 130, 7 ], [ 132, 8 ], [ 132, 10 ], [ 16, 13 ], [ 130, 14 ], [ 134, 15 ], [ 134, 16 ], [ 21, 18 ], [ 130, 19 ], [ 132, 28 ], [ 33, 30 ], [ 130, 31 ], [ 132, 40 ], [ 45, 42 ], [ 130, 43 ], [ 132, 52 ], [ 55, 54 ], [ 6, 58 ], [ 130, 59 ], [ 132, 60 ], [ 67, 62 ], [ 18, 63 ], [ 130, 64 ], [ 54, 66 ], [ 18, 70 ], [ 130, 71 ], [ 54, 74 ], [ 54, 76 ], [ 13, 77 ], [ 130, 78 ], [ 134, 79 ], [ 86, 81 ], [ 42, 82 ], [ 130, 83 ], [ 54, 85 ], [ 42, 90 ], [ 130, 91 ], [ 13, 94 ], [ 130, 95 ], [ 134, 96 ], [ 54, 97 ], [ 13, 99 ], [ 130, 100 ], [ 134, 101 ], [ 54, 102 ], [ 13, 103 ], [ 130, 104 ], [ 134, 105 ], [ 112, 107 ], [ 30, 108 ], [ 130, 109 ], [ 54, 111 ], [ 30, 115 ], [ 130, 116 ], [ 54, 119 ], [ 81, 121 ], [ 42, 122 ], [ 130, 123 ], [ 54, 125 ], [ 13, 126 ], [ 130, 127 ], [ 134, 128 ], [ 130, 130 ], [ 132, 132 ], [ 135, 134 ], [ 177, 146 ], [ 179, 147 ], [ 177, 149 ], [ 179, 152 ], [ 175, 161 ], [ 177, 163 ], [ 175, 166 ], [ 177, 169 ], [ 179, 170 ], [ 175, 172 ], [ 175, 175 ], [ 177, 177 ], [ 179, 179 ], [ 227, 186 ], [ 229, 187 ], [ 227, 189 ], [ 229, 192 ], [ 225, 201 ], [ 227, 203 ], [ 225, 208 ], [ 229, 210 ], [ 225, 213 ], [ 227, 216 ], [ 229, 217 ], [ 225, 219 ], [ 225, 222 ], [ 225, 225 ], [ 227, 227 ], [ 229, 229 ], [ 246, 235 ], [ 181, 236 ], [ 248, 239 ], [ 250, 240 ], [ 248, 243 ], [ 246, 246 ], [ 248, 248 ], [ 250, 250 ], [ 268, 255 ], [ 266, 262 ], [ 268, 264 ], [ 266, 266 ], [ 268, 268 ], [ 372, 270 ], [ 372, 279 ], [ 372, 280 ], [ 372, 281 ], [ 369, 283 ], [ 373, 288 ], [ 352, 289 ], [ 357, 292 ], [ 354, 299 ], [ 303, 302 ], [ 367, 306 ], [ 352, 309 ], [ 348, 312 ], [ 370, 316 ], [ 181, 317 ], [ 373, 321 ], [ 361, 322 ], [ 302, 323 ], [ 302, 326 ], [ 370, 330 ], [ 181, 331 ], [ 361, 335 ], [ 352, 336 ], [ 302, 337 ], [ 361, 340 ], [ 349, 345 ], [ 355, 345 ], [ 358, 346 ], [ 348, 349 ], [ 372, 352 ], [ 354, 355 ], [ 357, 358 ], [ 372, 361 ], [ 372, 367 ], [ 369, 370 ], [ 372, 373 ] ]

[ "class Combination:\n def __init__(self, size, mod=10**9 + 7):\n self.size = size + 2\n self.mod = mod\n self.fact = [1, 1] + [0] * size\n self.factInv = [1, 1] + [0] * size\n self.inv = [0, 1] + [0] * size\n\n for i in range(2, self.size):\n self.fact[i] = self.fact[i - 1] * i % self.mod\n self.inv[i] = -self.inv[self.mod % i] * (self.mod // i) % self.mod\n self.factInv[i] = self.factInv[i - 1] * self.inv[i] % self.mod\n\n def npr(self, n, r):\n if n < r or n < 0 or r < 0:\n return 0\n return self.fact[n] * self.factInv[n - r] % self.mod\n\n def ncr(self, n, r):\n if n < r or n < 0 or r < 0:\n return 0\n return self.fact[n] * (self.factInv[r] * self.factInv[n - r] % self.mod) % self.mod\n\n def nhr(self, n, r): # 重複組合せ\n return self.ncr(n + r - 1, n - 1)\n\n def factN(self, n):\n if n < 0:\n return 0\n return self.fact[n]\n\nH, W, A, B = map(int, input().split())\ncomb = Combination(H + W + 100)\nMOD = 10**9 + 7\n\nans = 0\nfor w in range(B + 1, W + 1):\n ans += comb.ncr(H - A + w - 2, w - 1) * comb.ncr(A + W - w - 1, A - 1)\nprint(ans % MOD)", "class Combination:\n def __init__(self, size, mod=10**9 + 7):\n self.size = size + 2\n self.mod = mod\n self.fact = [1, 1] + [0] * size\n self.factInv = [1, 1] + [0] * size\n self.inv = [0, 1] + [0] * size\n\n for i in range(2, self.size):\n self.fact[i] = self.fact[i - 1] * i % self.mod\n self.inv[i] = -self.inv[self.mod % i] * (self.mod // i) % self.mod\n self.factInv[i] = self.factInv[i - 1] * self.inv[i] % self.mod\n\n def npr(self, n, r):\n if n < r or n < 0 or r < 0:\n return 0\n return self.fact[n] * self.factInv[n - r] % self.mod\n\n def ncr(self, n, r):\n if n < r or n < 0 or r < 0:\n return 0\n return self.fact[n] * (self.factInv[r] * self.factInv[n - r] % self.mod) % self.mod\n\n def nhr(self, n, r): # 重複組合せ\n return self.ncr(n + r - 1, n - 1)\n\n def factN(self, n):\n if n < 0:\n return 0\n return self.fact[n]", "Combination", "def __init__(self, size, mod=10**9 + 7):\n self.size = size + 2\n self.mod = mod\n self.fact = [1, 1] + [0] * size\n self.factInv = [1, 1] + [0] * size\n self.inv = [0, 1] + [0] * size\n\n for i in range(2, self.size):\n self.fact[i] = self.fact[i - 1] * i % self.mod\n self.inv[i] = -self.inv[self.mod % i] * (self.mod // i) % self.mod\n self.factInv[i] = self.factInv[i - 1] * self.inv[i] % self.mod\n\n ", "__init__", "self.size = size + 2", "self.size", "self", "size", "size + 2", "size", "2", "self.mod = mod", "self.mod", "self", "mod", "mod", "self.fact = [1, 1] + [0] * size", "self.fact", "self", "fact", "[1, 1] + [0] * size", "[1, 1]", "1", "1", "[0] * size", "[0]", "0", "size", "self.factInv = [1, 1] + [0] * size", "self.factInv", "self", "factInv", "[1, 1] + [0] * size", "[1, 1]", "1", "1", "[0] * size", "[0]", "0", "size", "self.inv = [0, 1] + [0] * size", "self.inv", "self", "inv", "[0, 1] + [0] * size", "[0, 1]", "0", "1", "[0] * size", "[0]", "0", "size", "for i in range(2, self.size):\n self.fact[i] = self.fact[i - 1] * i % self.mod\n self.inv[i] = -self.inv[self.mod % i] * (self.mod // i) % self.mod\n self.factInv[i] = self.factInv[i - 1] * self.inv[i] % self.mod\n\n ", "i", "range(2, self.size)", "range", "2", "self.size", "self", "size", "self.fact[i] = self.fact[i - 1] * i % self.mod", "self.fact[i]", "self.fact", "self", "fact", "i", "self.fact[i - 1] * i % self.mod", "self.fact[i - 1] * i", "self.fact[i - 1]", "self.fact", "self", "fact", "i - 1", "i", "1", "i", "self.mod", "self", "mod", "self.inv[i] = -self.inv[self.mod % i] * (self.mod // i) % self.mod", "self.inv[i]", "self.inv", "self", "inv", "i", "-self.inv[self.mod % i] * (self.mod // i) % self.mod", "-self.inv[self.mod % i] * (self.mod // i)", "-self.inv[self.mod % i]", "self.inv[self.mod % i]", "self.inv", "self", "inv", "self.mod % i", "self.mod", "self", "mod", "i", "self.mod // i", "self.mod", "self", "mod", "i", "self.mod", "self", "mod", "self.factInv[i] = self.factInv[i - 1] * self.inv[i] % self.mod", "self.factInv[i]", "self.factInv", "self", "factInv", "i", "self.factInv[i - 1] * self.inv[i] % self.mod", "self.factInv[i - 1] * self.inv[i]", "self.factInv[i - 1]", "self.factInv", "self", "factInv", "i - 1", "i", "1", "self.inv[i]", "self.inv", "self", "inv", "i", "self.mod", "self", "mod", "self", "self", "size", "size", "mod=10**9 + 7", "mod", "10**9 + 7", "10**9", "10", "9", "7", "def npr(self, n, r):\n if n < r or n < 0 or r < 0:\n return 0\n return self.fact[n] * self.factInv[n - r] % self.mod\n\n ", "npr", "if n < r or n < 0 or r < 0:\n return 0\n ", "n < r or n < 0 or r < 0", "n < r or n < 0", "n < r", "n", "r", "n < 0", "n", "0", "r < 0", "r", "0", "return 0", "0", "return self.fact[n] * self.factInv[n - r] % self.mod", "self.fact[n] * self.factInv[n - r] % self.mod", "self.fact[n] * self.factInv[n - r]", "self.fact[n]", "self.fact", "self", "fact", "n", "self.factInv[n - r]", "self.factInv", "self", "factInv", "n - r", "n", "r", "self.mod", "self", "mod", "self", "self", "n", "n", "r", "r", "def ncr(self, n, r):\n if n < r or n < 0 or r < 0:\n return 0\n return self.fact[n] * (self.factInv[r] * self.factInv[n - r] % self.mod) % self.mod\n\n ", "ncr", "if n < r or n < 0 or r < 0:\n return 0\n ", "n < r or n < 0 or r < 0", "n < r or n < 0", "n < r", "n", "r", "n < 0", "n", "0", "r < 0", "r", "0", "return 0", "0", "return self.fact[n] * (self.factInv[r] * self.factInv[n - r] % self.mod) % self.mod", "self.fact[n] * (self.factInv[r] * self.factInv[n - r] % self.mod) % self.mod", "self.fact[n] * (self.factInv[r] * self.factInv[n - r] % self.mod)", "self.fact[n]", "self.fact", "self", "fact", "n", "self.factInv[r] * self.factInv[n - r] % self.mod", "self.factInv[r] * self.factInv[n - r]", "self.factInv[r]", "self.factInv", "self", "factInv", "r", "self.factInv[n - r]", "self.factInv", "self", "factInv", "n - r", "n", "r", "self.mod", "self", "mod", "self.mod", "self", "mod", "self", "self", "n", "n", "r", "r", "def nhr(self, n, r): # 重複組合せ\n return self.ncr(n + r - 1, n - 1)\n\n ", "nhr", "return self.ncr(n + r - 1, n - 1)", "self.ncr(n + r - 1, n - 1)", "self.ncr", "self", "ncr", "n + r - 1", "n + r", "n", "r", "1", "n - 1", "n", "1", "self", "self", "n", "n", "r", "r", "def factN(self, n):\n if n < 0:\n return 0\n return self.fact[n]", "factN", "if n < 0:\n return 0\n ", "n < 0", "n", "0", "return 0", "0", "return self.fact[n]", "self.fact[n]", "self.fact", "self", "fact", "n", "self", "self", "n", "n", "H, W, A, B = map(int, input().split())", "H", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "W", "A", "B", "comb = Combination(H + W + 100)", "comb", "Combination(H + W + 100)", "Combination", "H + W + 100", "H + W", "H", "W", "100", "MOD = 10**9 + 7", "MOD", "10**9 + 7", "10**9", "10", "9", "7", "ans = 0", "ans", "0", "for w in range(B + 1, W + 1):\n ans += comb.ncr(H - A + w - 2, w - 1) * comb.ncr(A + W - w - 1, A - 1)", "w", "range(B + 1, W + 1)", "range", "B + 1", "B", "1", "W + 1", "W", "1", "ans += comb.ncr(H - A + w - 2, w - 1) * comb.ncr(A + W - w - 1, A - 1)", "ans", "comb.ncr(H - A + w - 2, w - 1) * comb.ncr(A + W - w - 1, A - 1)", "comb.ncr(H - A + w - 2, w - 1)", "comb.ncr", "comb", "ncr", "H - A + w - 2", "H - A + w", "H - A", "H", "A", "w", "2", "w - 1", "w", "1", "comb.ncr(A + W - w - 1, A - 1)", "comb.ncr", "comb", "ncr", "A + W - w - 1", "A + W - w", "A + W", "A", "W", "w", "1", "A - 1", "A", "1", "print(ans % MOD)", "print", "ans % MOD", "ans", "MOD", "ans += comb.ncr(H - A + w - 2, w - 1) * comb.ncr(A + W - w - 1, A - 1)", "comb.ncr(H - A + w - 2, w - 1) * comb.ncr(A + W - w - 1, A - 1)", "ans", "W, A, B = map(int, input().split())", "map(int, input().split())", "W", "ans = 0", "0", "ans", "MOD = 10**9 + 7", "10**9 + 7", "MOD", "A, B = map(int, input().split())", "map(int, input().split())", "A", "class Combination:\n def __init__(self, size, mod=10**9 + 7):\n self.size = size + 2\n self.mod = mod\n self.fact = [1, 1] + [0] * size\n self.factInv = [1, 1] + [0] * size\n self.inv = [0, 1] + [0] * size\n\n for i in range(2, self.size):\n self.fact[i] = self.fact[i - 1] * i % self.mod\n self.inv[i] = -self.inv[self.mod % i] * (self.mod // i) % self.mod\n self.factInv[i] = self.factInv[i - 1] * self.inv[i] % self.mod\n\n def npr(self, n, r):\n if n < r or n < 0 or r < 0:\n return 0\n return self.fact[n] * self.factInv[n - r] % self.mod\n\n def ncr(self, n, r):\n if n < r or n < 0 or r < 0:\n return 0\n return self.fact[n] * (self.factInv[r] * self.factInv[n - r] % self.mod) % self.mod\n\n def nhr(self, n, r): # 重複組合せ\n return self.ncr(n + r - 1, n - 1)\n\n def factN(self, n):\n if n < 0:\n return 0\n return self.fact[n]", "class Combination:\n def __init__(self, size, mod=10**9 + 7):\n self.size = size + 2\n self.mod = mod\n self.fact = [1, 1] + [0] * size\n self.factInv = [1, 1] + [0] * size\n self.inv = [0, 1] + [0] * size\n\n for i in range(2, self.size):\n self.fact[i] = self.fact[i - 1] * i % self.mod\n self.inv[i] = -self.inv[self.mod % i] * (self.mod // i) % self.mod\n self.factInv[i] = self.factInv[i - 1] * self.inv[i] % self.mod\n\n def npr(self, n, r):\n if n < r or n < 0 or r < 0:\n return 0\n return self.fact[n] * self.factInv[n - r] % self.mod\n\n def ncr(self, n, r):\n if n < r or n < 0 or r < 0:\n return 0\n return self.fact[n] * (self.factInv[r] * self.factInv[n - r] % self.mod) % self.mod\n\n def nhr(self, n, r): # 重複組合せ\n return self.ncr(n + r - 1, n - 1)\n\n def factN(self, n):\n if n < 0:\n return 0\n return self.fact[n]", "Combination", "B = map(int, input().split())", "map(int, input().split())", "B", "comb = Combination(H + W + 100)", "Combination(H + W + 100)", "comb", "H, W, A, B = map(int, input().split())", "map(int, input().split())", "H" ]

[ 7, 41, 28, 13, 4, 18, 4, 13, 13, 4, 4, 13, 13, 0, 13, 13, 13, 13, 13, 0, 13, 2, 2, 17, 17, 17, 0, 13, 2, 13, 13, 12, 13, 0, 13, 17, 42, 40, 13, 17, 14, 2, 13, 17, 0, 13, 2, 2, 13, 13, 13, 0, 13, 2, 2, 13, 13, 13, 0, 13, 2, 13, 17, 29, 13, 23, 13, 23, 13, 0, 13, 2, 39, 17, 2, 39, 17, 13, 0, 13, 2, 39, 17, 2, 39, 17, 13, 28, 13, 4, 13, 17, 2, 13, 17, 0, 18, 13, 13, 2, 2, 18, 13, 2, 13, 17, 13, 13, 0, 18, 13, 13, 2, 2, 18, 13, 2, 13, 17, 4, 13, 13, 2, 13, 17, 13, 12, 13, 14, 2, 2, 13, 17, 2, 13, 17, 29, 17, 14, 2, 2, 13, 13, 2, 13, 17, 29, 17, 0, 13, 2, 2, 18, 13, 2, 13, 13, 18, 13, 13, 13, 29, 2, 2, 13, 18, 13, 13, 13, 23, 13, 23, 13, 14, 2, 2, 13, 13, 2, 2, 13, 13, 17, 0, 13, 17, 28, 13, 4, 13, 2, 13, 13, 0, 13, 2, 4, 13, 2, 2, 13, 17, 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, 4, 13, 2, 2, 2, 13, 17, 13, 17, 2, 13, 17, 28, 13, 4, 13, 13, 0, 13, 2, 4, 13, 2, 2, 2, 13, 13, 17, 13, 13, 4, 13, 2, 2, 2, 2, 13, 17, 13, 17, 13, 2, 13, 17, 0, 13, 13, 4, 13, 13, 10, 13, 13, 10, 13, 13, 10, 2, 13, 10, 13, 13, 10, 2, 13, 10, 13, 13, 10, 13, 13, 10, 2, 13, 10, 17, 13, 10, 2, 13, 10, 12, 13, 10, 13, 13, 10, 12, 13, 10, 2, 13, 10, 4, 13, 10, 2, 13 ]

[ [ 4, 3 ], [ 3, 12 ], [ 311, 14 ], [ 311, 16 ], [ 311, 17 ], [ 311, 18 ], [ 305, 20 ], [ 299, 27 ], [ 288, 29 ], [ 312, 30 ], [ 35, 34 ], [ 68, 38 ], [ 59, 38 ], [ 68, 42 ], [ 59, 42 ], [ 46, 45 ], [ 34, 48 ], [ 45, 48 ], [ 66, 49 ], [ 52, 49 ], [ 306, 50 ], [ 53, 52 ], [ 66, 55 ], [ 52, 55 ], [ 66, 56 ], [ 52, 56 ], [ 306, 57 ], [ 60, 59 ], [ 68, 61 ], [ 59, 61 ], [ 45, 64 ], [ 34, 64 ], [ 66, 66 ], [ 68, 68 ], [ 284, 70 ], [ 300, 77 ], [ 317, 79 ], [ 300, 86 ], [ 89, 88 ], [ 300, 93 ], [ 99, 96 ], [ 285, 97 ], [ 88, 98 ], [ 285, 102 ], [ 88, 104 ], [ 88, 106 ], [ 306, 107 ], [ 112, 109 ], [ 318, 110 ], [ 88, 111 ], [ 318, 115 ], [ 88, 117 ], [ 315, 120 ], [ 88, 121 ], [ 306, 123 ], [ 306, 125 ], [ 170, 131 ], [ 172, 134 ], [ 170, 141 ], [ 172, 142 ], [ 170, 144 ], [ 150, 149 ], [ 318, 153 ], [ 170, 155 ], [ 172, 156 ], [ 318, 158 ], [ 172, 159 ], [ 306, 160 ], [ 149, 164 ], [ 285, 166 ], [ 170, 167 ], [ 306, 168 ], [ 170, 170 ], [ 172, 172 ], [ 297, 176 ], [ 282, 177 ], [ 288, 180 ], [ 312, 181 ], [ 302, 184 ], [ 188, 187 ], [ 288, 191 ], [ 297, 192 ], [ 323, 194 ], [ 309, 197 ], [ 282, 200 ], [ 187, 202 ], [ 187, 203 ], [ 309, 205 ], [ 312, 211 ], [ 282, 212 ], [ 288, 214 ], [ 187, 216 ], [ 288, 219 ], [ 187, 221 ], [ 278, 223 ], [ 306, 224 ], [ 320, 226 ], [ 309, 228 ], [ 288, 232 ], [ 312, 234 ], [ 288, 237 ], [ 241, 240 ], [ 282, 243 ], [ 290, 245 ], [ 309, 248 ], [ 288, 252 ], [ 297, 253 ], [ 240, 255 ], [ 240, 256 ], [ 309, 258 ], [ 297, 263 ], [ 312, 265 ], [ 240, 267 ], [ 297, 269 ], [ 293, 272 ], [ 306, 273 ], [ 294, 276 ], [ 291, 276 ], [ 279, 276 ], [ 324, 276 ], [ 303, 276 ], [ 321, 276 ], [ 306, 278 ], [ 278, 279 ], [ 311, 282 ], [ 284, 285 ], [ 311, 288 ], [ 290, 291 ], [ 306, 293 ], [ 293, 294 ], [ 311, 297 ], [ 299, 300 ], [ 302, 303 ], [ 305, 306 ], [ 311, 312 ], [ 317, 318 ], [ 320, 321 ], [ 323, 324 ] ]

[ "h, w, a, b = [int(item) for item in input().split()]\n\nMOD = 10**9 + 7\nn = h + w \ndef mod_pow(x, n):\n ans = 1\n while(n != 0):\n if n & 1:\n ans = ans * x % MOD\n x = x * x % MOD\n n = n >> 1\n return ans\n\nfac = [1] + [0] * n\nfac_inv = [1] + [0] * n\nfor i in range(1, n+1):\n fac[i] = fac[i-1] * (i) % MOD\n # Fermat's little theorem says\n # a**(p-1) mod p == 1\n # then, a * a**(p-2) mod p == 1\n # it means a**(p-2) is inverse element\n fac_inv[i] = fac_inv[i-1] * mod_pow(i, MOD-2) % MOD\n\ndef mod_nCr(n, r):\n if n == 0 and r == 0:\n return 1\n if n < r or n < 0:\n return 0\n tmp = fac_inv[n-r] * fac_inv[r] % MOD\n return tmp * fac[n] % MOD\n\nif a+b > (h+w)//2:\n ans = 0\n for i in range(h-a):\n ans += mod_nCr(b-1+i, i) * mod_nCr(w-b-1 + h-1-i, h-1-i)\n ans %= MOD\nelse:\n ans = mod_nCr(h-1+w-1, h-1)\n for i in range(b):\n ans -= mod_nCr(h-a-1+i, i) * mod_nCr(a-1 + w-1-i, a-1)\n ans %= MOD\nprint(ans)", "int(item) for item in input().split()", "for item in input().split()", "item", "input().split()", "().split", "()", "input", "split", "for item in input().split()", "int(item)", "int", "item", "h, w, a, b = [int(item) for item in input().split()]", "h", "[int(item) for item 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", "def mod_pow(x, n):\n ans = 1\n while(n != 0):\n if n & 1:\n ans = ans * x % MOD\n x = x * x % MOD\n n = n >> 1\n return ans", "mod_pow", "ans = 1", "ans", "1", "while(n != 0):\n if n & 1:\n ans = ans * x % MOD\n x = x * x % MOD\n n = n >> 1\n ", "n != 0", "n", "0", "if n & 1:\n ans = ans * x % MOD\n ", "n & 1", "n", "1", "ans = ans * x % MOD", "ans", "ans * x % MOD", "ans * x", "ans", "x", "MOD", "x = x * x % MOD", "x", "x * x % MOD", "x * x", "x", "x", "MOD", "n = n >> 1", "n", "n >> 1", "n", "1", "return ans", "ans", "x", "x", "n", "n", "fac = [1] + [0] * n", "fac", "[1] + [0] * n", "[1]", "1", "[0] * n", "[0]", "0", "n", "fac_inv = [1] + [0] * n", "fac_inv", "[1] + [0] * n", "[1]", "1", "[0] * n", "[0]", "0", "n", "for i in range(1, n+1):\n fac[i] = fac[i-1] * (i) % MOD\n # Fermat's little theorem says\n # a**(p-1) mod p == 1\n # then, a * a**(p-2) mod p == 1\n # it means a**(p-2) is inverse element\n fac_inv[i] = fac_inv[i-1] * mod_pow(i, MOD-2) % MOD", "i", "range(1, n+1)", "range", "1", "n+1", "n", "1", "fac[i] = fac[i-1] * (i) % MOD", "fac[i]", "fac", "i", "fac[i-1] * (i) % MOD", "fac[i-1] * (i)", "fac[i-1]", "fac", "i-1", "i", "1", "i", "MOD", "fac_inv[i] = fac_inv[i-1] * mod_pow(i, MOD-2) % MOD", "fac_inv[i]", "fac_inv", "i", "fac_inv[i-1] * mod_pow(i, MOD-2) % MOD", "fac_inv[i-1] * mod_pow(i, MOD-2)", "fac_inv[i-1]", "fac_inv", "i-1", "i", "1", "mod_pow(i, MOD-2)", "mod_pow", "i", "MOD-2", "MOD", "2", "MOD", "def mod_nCr(n, r):\n if n == 0 and r == 0:\n return 1\n if n < r or n < 0:\n return 0\n tmp = fac_inv[n-r] * fac_inv[r] % MOD\n return tmp * fac[n] % MOD", "mod_nCr", "if n == 0 and r == 0:\n return 1\n ", "n == 0 and r == 0", "n == 0", "n", "0", "r == 0", "r", "0", "return 1", "1", "if n < r or n < 0:\n return 0\n ", "n < r or n < 0", "n < r", "n", "r", "n < 0", "n", "0", "return 0", "0", "tmp = fac_inv[n-r] * fac_inv[r] % MOD", "tmp", "fac_inv[n-r] * fac_inv[r] % MOD", "fac_inv[n-r] * fac_inv[r]", "fac_inv[n-r]", "fac_inv", "n-r", "n", "r", "fac_inv[r]", "fac_inv", "r", "MOD", "return tmp * fac[n] % MOD", "tmp * fac[n] % MOD", "tmp * fac[n]", "tmp", "fac[n]", "fac", "n", "MOD", "n", "n", "r", "r", "if a+b > (h+w)//2:\n ans = 0\n for i in range(h-a):\n ans += mod_nCr(b-1+i, i) * mod_nCr(w-b-1 + h-1-i, h-1-i)\n ans %= MOD\nelse:\n ans = mod_nCr(h-1+w-1, h-1)\n for i in range(b):\n ans -= mod_nCr(h-a-1+i, i) * mod_nCr(a-1 + w-1-i, a-1)\n ans %= MOD", "a+b > (h+w)//2", "a+b", "a", "b", "(h+w)//2", "h+w", "h", "w", "2", "ans = 0", "ans", "0", "for i in range(h-a):\n ans += mod_nCr(b-1+i, i) * mod_nCr(w-b-1 + h-1-i, h-1-i)\n ans %= MOD", "i", "range(h-a)", "range", "h-a", "h", "a", "ans += mod_nCr(b-1+i, i) * mod_nCr(w-b-1 + h-1-i, h-1-i)", "ans", "mod_nCr(b-1+i, i) * mod_nCr(w-b-1 + h-1-i, h-1-i)", "mod_nCr(b-1+i, i)", "mod_nCr", "b-1+i", "b-1", "b", "1", "i", "i", "mod_nCr(w-b-1 + h-1-i, h-1-i)", "mod_nCr", "w-b-1 + h-1-i", "w-b-1 + h-1", "w-b-1 + h", "w-b-1", "w-b", "w", "b", "1", "h", "1", "i", "h-1-i", "h-1", "h", "1", "i", "ans %= MOD", "ans", "MOD", "ans = mod_nCr(h-1+w-1, h-1)", "ans", "mod_nCr(h-1+w-1, h-1)", "mod_nCr", "h-1+w-1", "h-1+w", "h-1", "h", "1", "w", "1", "h-1", "h", "1", "for i in range(b):\n ans -= mod_nCr(h-a-1+i, i) * mod_nCr(a-1 + w-1-i, a-1)\n ans %= MOD", "i", "range(b)", "range", "b", "ans -= mod_nCr(h-a-1+i, i) * mod_nCr(a-1 + w-1-i, a-1)", "ans", "mod_nCr(h-a-1+i, i) * mod_nCr(a-1 + w-1-i, a-1)", "mod_nCr(h-a-1+i, i)", "mod_nCr", "h-a-1+i", "h-a-1", "h-a", "h", "a", "1", "i", "i", "mod_nCr(a-1 + w-1-i, a-1)", "mod_nCr", "a-1 + w-1-i", "a-1 + w-1", "a-1 + w", "a-1", "a", "1", "w", "1", "i", "a-1", "a", "1", "ans %= MOD", "ans", "MOD", "print(ans)", "print", "ans", "ans %= MOD", "MOD", "ans", "b = [int(item) for item in input().split()]", "[int(item) for item in input().split()]", "b", "fac = [1] + [0] * n", "[1] + [0] * n", "fac", "h, w, a, b = [int(item) for item in input().split()]", "[int(item) for item in input().split()]", "h", "ans -= mod_nCr(h-a-1+i, i) * mod_nCr(a-1 + w-1-i, a-1)", "mod_nCr(h-a-1+i, i) * mod_nCr(a-1 + w-1-i, a-1)", "ans", "ans %= MOD", "MOD", "ans", "a, b = [int(item) for item in input().split()]", "[int(item) for item in input().split()]", "a", "n = h + w", "h + w", "n", "ans = 0", "0", "ans", "MOD = 10**9 + 7", "10**9 + 7", "MOD", "def mod_nCr(n, r):\n if n == 0 and r == 0:\n return 1\n if n < r or n < 0:\n return 0\n tmp = fac_inv[n-r] * fac_inv[r] % MOD\n return tmp * fac[n] % MOD", "def mod_nCr(n, r):\n if n == 0 and r == 0:\n return 1\n if n < r or n < 0:\n return 0\n tmp = fac_inv[n-r] * fac_inv[r] % MOD\n return tmp * fac[n] % MOD", "mod_nCr", "w, a, b = [int(item) for item in input().split()]", "[int(item) for item in input().split()]", "w", "def mod_pow(x, n):\n ans = 1\n while(n != 0):\n if n & 1:\n ans = ans * x % MOD\n x = x * x % MOD\n n = n >> 1\n return ans", "def mod_pow(x, n):\n ans = 1\n while(n != 0):\n if n & 1:\n ans = ans * x % MOD\n x = x * x % MOD\n n = n >> 1\n return ans", "mod_pow", "fac_inv = [1] + [0] * n", "[1] + [0] * n", "fac_inv", "ans = mod_nCr(h-1+w-1, h-1)", "mod_nCr(h-1+w-1, h-1)", "ans", "ans += mod_nCr(b-1+i, i) * mod_nCr(w-b-1 + h-1-i, h-1-i)", "mod_nCr(b-1+i, i) * mod_nCr(w-b-1 + h-1-i, h-1-i)", "ans" ]

[ 7, 15, 13, 0, 13, 18, 18, 13, 13, 13, 15, 13, 15, 13, 15, 13, 15, 15, 15, 15, 0, 13, 2, 2, 17, 17, 17, 0, 13, 4, 13, 17, 0, 13, 17, 12, 13, 12, 13, 12, 13, 12, 13, 12, 13, 23, 13, 12, 13, 23, 13, 41, 28, 13, 4, 13, 13, 4, 4, 13, 4, 13, 13, 4, 18, 4, 13, 13, 12, 13, 23, 13, 41, 28, 13, 4, 13, 13, 4, 4, 13, 4, 13, 13, 4, 18, 4, 13, 13, 12, 13, 23, 13, 12, 13, 23, 13, 12, 13, 23, 13, 0, 13, 39, 12, 13, 14, 2, 4, 13, 13, 13, 14, 2, 4, 13, 13, 17, 42, 40, 4, 13, 13, 13, 29, 18, 13, 13, 23, 13, 0, 13, 39, 12, 13, 14, 2, 4, 13, 13, 13, 14, 2, 4, 13, 13, 17, 42, 40, 4, 13, 13, 13, 29, 18, 13, 13, 23, 13, 12, 13, 14, 2, 13, 13, 14, 2, 2, 13, 13, 2, 13, 17, 0, 13, 17, 0, 13, 2, 2, 13, 4, 13, 13, 13, 0, 13, 2, 2, 13, 4, 13, 13, 13, 0, 13, 2, 2, 13, 4, 13, 2, 13, 13, 13, 29, 13, 23, 13, 23, 13, 12, 13, 0, 13, 39, 0, 13, 13, 28, 13, 4, 13, 17, 2, 4, 13, 40, 2, 40, 2, 13, 17, 17, 17, 14, 2, 2, 13, 13, 17, 0, 13, 17, 42, 2, 2, 13, 13, 17, 0, 13, 17, 0, 13, 13, 4, 18, 13, 13, 39, 13, 13, 14, 40, 13, 17, 14, 2, 13, 39, 29, 13, 23, 13, 12, 13, 0, 13, 39, 28, 13, 4, 13, 17, 2, 4, 13, 2, 13, 17, 17, 14, 2, 2, 13, 13, 17, 4, 18, 13, 13, 13, 14, 40, 13, 2, 13, 13, 4, 18, 13, 13, 2, 13, 13, 29, 13, 23, 13, 12, 13, 0, 13, 4, 13, 4, 18, 13, 13, 13, 41, 28, 13, 4, 13, 17, 2, 13, 17, 4, 13, 0, 13, 13, 0, 13, 39, 42, 40, 18, 13, 17, 13, 4, 18, 13, 13, 18, 13, 17, 0, 13, 18, 13, 17, 41, 28, 13, 13, 40, 2, 13, 13, 17, 4, 13, 0, 13, 13, 4, 18, 13, 13, 13, 29, 13, 23, 13, 12, 13, 42, 13, 29, 13, 23, 13, 23, 13, 12, 13, 29, 2, 2, 13, 13, 4, 13, 13, 13, 23, 13, 23, 13, 12, 13, 0, 13, 17, 42, 13, 0, 13, 2, 13, 17, 0, 13, 17, 29, 13, 23, 13, 12, 13, 14, 2, 13, 13, 29, 39, 2, 13, 13, 23, 13, 23, 13, 12, 13, 29, 4, 13, 2, 4, 13, 18, 4, 13, 13, 2, 40, 13, 17, 2, 13, 13, 23, 13, 23, 13, 12, 13, 0, 13, 17, 14, 2, 13, 13, 29, 39, 2, 13, 13, 23, 13, 23, 13, 12, 13, 0, 13, 17, 42, 40, 13, 13, 0, 13, 13, 0, 13, 17, 29, 13, 23, 13, 23, 13, 0, 13, 4, 13, 13, 13, 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, 13, 13, 13, 17, 13, 4, 13, 2, 2, 2, 13, 13, 13, 17, 2, 13, 17, 0, 13, 13, 4, 13, 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, 4, 13, 10, 12, 13, 10, 39, 13, 10, 12, 13, 10, 12, 13, 10, 4, 13, 10, 12, 13, 10, 13, 13, 10, 12, 13, 10, 12, 13, 10, 18, 13, 10, 12, 13, 10, 4, 13, 10, 12, 13, 10, 17, 13, 10, 12, 13, 10, 12, 13, 10, 12, 13, 10, 12, 13, 10, 2, 13, 10, 4, 13, 10, 39, 13, 10, 12, 13, 10, 4, 13, 10, 2, 13, 10, 12, 13, 10, 12, 13, 10, 4, 13 ]

[ [ 620, 4 ], [ 647, 21 ], [ 650, 28 ], [ 632, 33 ], [ 46, 46 ], [ 50, 50 ], [ 54, 53 ], [ 621, 66 ], [ 71, 71 ], [ 75, 74 ], [ 621, 87 ], [ 92, 92 ], [ 96, 96 ], [ 100, 100 ], [ 596, 102 ], [ 597, 110 ], [ 129, 111 ], [ 597, 116 ], [ 597, 122 ], [ 129, 123 ], [ 597, 126 ], [ 129, 127 ], [ 129, 129 ], [ 653, 131 ], [ 654, 139 ], [ 158, 140 ], [ 654, 145 ], [ 654, 151 ], [ 158, 152 ], [ 654, 155 ], [ 158, 156 ], [ 158, 158 ], [ 208, 163 ], [ 210, 164 ], [ 208, 168 ], [ 210, 169 ], [ 210, 171 ], [ 175, 174 ], [ 178, 177 ], [ 174, 180 ], [ 639, 182 ], [ 208, 183 ], [ 648, 184 ], [ 187, 186 ], [ 177, 189 ], [ 174, 189 ], [ 645, 191 ], [ 210, 192 ], [ 648, 193 ], [ 196, 195 ], [ 186, 198 ], [ 177, 198 ], [ 174, 198 ], [ 645, 200 ], [ 208, 202 ], [ 210, 203 ], [ 648, 204 ], [ 195, 206 ], [ 186, 206 ], [ 177, 206 ], [ 174, 206 ], [ 208, 208 ], [ 210, 210 ], [ 215, 214 ], [ 218, 217 ], [ 274, 218 ], [ 221, 220 ], [ 274, 231 ], [ 217, 238 ], [ 254, 238 ], [ 220, 239 ], [ 243, 242 ], [ 217, 247 ], [ 254, 247 ], [ 220, 248 ], [ 252, 251 ], [ 255, 254 ], [ 220, 255 ], [ 214, 258 ], [ 254, 265 ], [ 217, 265 ], [ 214, 269 ], [ 214, 272 ], [ 274, 274 ], [ 279, 278 ], [ 282, 281 ], [ 319, 289 ], [ 319, 295 ], [ 281, 296 ], [ 278, 300 ], [ 281, 302 ], [ 281, 305 ], [ 319, 307 ], [ 281, 308 ], [ 278, 311 ], [ 319, 314 ], [ 281, 315 ], [ 278, 317 ], [ 319, 319 ], [ 324, 323 ], [ 388, 330 ], [ 334, 333 ], [ 388, 338 ], [ 333, 341 ], [ 344, 343 ], [ 347, 346 ], [ 343, 351 ], [ 378, 351 ], [ 323, 353 ], [ 346, 356 ], [ 343, 359 ], [ 378, 359 ], [ 363, 362 ], [ 343, 364 ], [ 378, 364 ], [ 369, 368 ], [ 343, 368 ], [ 378, 368 ], [ 368, 372 ], [ 362, 373 ], [ 368, 376 ], [ 379, 378 ], [ 346, 382 ], [ 378, 384 ], [ 343, 384 ], [ 346, 386 ], [ 388, 388 ], [ 396, 394 ], [ 396, 396 ], [ 398, 398 ], [ 411, 404 ], [ 413, 405 ], [ 615, 407 ], [ 411, 408 ], [ 413, 409 ], [ 411, 411 ], [ 413, 413 ], [ 418, 417 ], [ 423, 422 ], [ 432, 424 ], [ 422, 424 ], [ 428, 427 ], [ 427, 430 ], [ 417, 430 ], [ 432, 432 ], [ 445, 437 ], [ 447, 438 ], [ 445, 442 ], [ 447, 443 ], [ 445, 445 ], [ 447, 447 ], [ 468, 459 ], [ 470, 465 ], [ 468, 468 ], [ 470, 470 ], [ 475, 474 ], [ 474, 478 ], [ 486, 478 ], [ 488, 479 ], [ 474, 483 ], [ 486, 483 ], [ 488, 484 ], [ 486, 486 ], [ 488, 488 ], [ 493, 492 ], [ 507, 496 ], [ 499, 496 ], [ 509, 497 ], [ 500, 499 ], [ 509, 500 ], [ 503, 502 ], [ 502, 505 ], [ 492, 505 ], [ 507, 507 ], [ 509, 509 ], [ 671, 511 ], [ 609, 513 ], [ 671, 514 ], [ 671, 515 ], [ 671, 516 ], [ 590, 518 ], [ 636, 520 ], [ 627, 523 ], [ 672, 524 ], [ 627, 527 ], [ 531, 530 ], [ 606, 533 ], [ 662, 535 ], [ 636, 538 ], [ 627, 542 ], [ 660, 543 ], [ 530, 544 ], [ 530, 546 ], [ 636, 548 ], [ 672, 552 ], [ 660, 553 ], [ 530, 554 ], [ 660, 557 ], [ 611, 560 ], [ 648, 561 ], [ 612, 564 ], [ 663, 564 ], [ 591, 564 ], [ 590, 591 ], [ 596, 597 ], [ 671, 606 ], [ 648, 611 ], [ 611, 612 ], [ 620, 621 ], [ 671, 627 ], [ 632, 633 ], [ 647, 648 ], [ 650, 651 ], [ 653, 654 ], [ 671, 660 ], [ 662, 663 ], [ 671, 672 ] ]

[ "# -*- coding: utf-8 -*-\n\n#############\n# Libraries #\n#############\n\nimport sys\ninput = sys.stdin.readline\n\nimport math\n#from math import gcd\nimport bisect\nimport heapq\nfrom collections import defaultdict\nfrom collections import deque\nfrom collections import Counter\nfrom functools import lru_cache\n\n#############\n# Constants #\n#############\n\nMOD = 10**9+7\nINF = float('inf')\nAZ = \"abcdefghijklmnopqrstuvwxyz\"\n\n#############\n# Functions #\n#############\n\n######INPUT######\ndef I(): return int(input().strip())\ndef S(): return input().strip()\ndef IL(): return list(map(int,input().split()))\ndef SL(): return list(map(str,input().split()))\ndef ILs(n): return list(int(input()) for _ in range(n))\ndef SLs(n): return list(input().strip() for _ in range(n))\ndef ILL(n): return [list(map(int, input().split())) for _ in range(n)]\ndef SLL(n): return [list(map(str, input().split())) for _ in range(n)]\n\n\n#####Shorten#####\ndef DD(arg): return defaultdict(arg)\n\n#####Inverse#####\ndef inv(n): return pow(n, MOD-2, MOD)\n\n######Combination######\nkaijo_memo = []\ndef kaijo(n):\n if(len(kaijo_memo) > n): return kaijo_memo[n]\n if(len(kaijo_memo) == 0): kaijo_memo.append(1)\n while(len(kaijo_memo) <= n): kaijo_memo.append(kaijo_memo[-1] * len(kaijo_memo) % MOD)\n return kaijo_memo[n]\n\ngyaku_kaijo_memo = []\ndef gyaku_kaijo(n):\n if(len(gyaku_kaijo_memo) > n): return gyaku_kaijo_memo[n]\n if(len(gyaku_kaijo_memo) == 0): gyaku_kaijo_memo.append(1)\n while(len(gyaku_kaijo_memo) <= n): gyaku_kaijo_memo.append(gyaku_kaijo_memo[-1] * pow(len(gyaku_kaijo_memo),MOD-2,MOD) % MOD)\n return gyaku_kaijo_memo[n]\n\ndef nCr(n,r):\n if n == r: return 1\n if n < r or r < 0: return 0\n ret = 1\n ret = ret * kaijo(n) % MOD\n ret = ret * gyaku_kaijo(r) % MOD\n ret = ret * gyaku_kaijo(n-r) % MOD\n return ret\n\n######Factorization######\ndef factorization(n):\n arr = []\n temp = n\n for i in range(2, int(-(-n**0.5//1))+1):\n if temp%i==0:\n cnt=0\n while temp%i==0: \n cnt+=1 \n temp //= i\n arr.append([i, cnt])\n if temp!=1: arr.append([temp, 1])\n if arr==[]: arr.append([n, 1])\n return arr\n\n#####MakeDivisors######\ndef make_divisors(n):\n divisors = []\n for i in range(1, int(n**0.5)+1):\n if n % i == 0:\n divisors.append(i)\n if i != n // i: \n divisors.append(n//i)\n return divisors\n\n#####MakePrimes######\ndef make_primes(N):\n max = int(math.sqrt(N))\n seachList = [i for i in range(2,N+1)]\n primeNum = []\n while seachList[0] <= max:\n primeNum.append(seachList[0])\n tmp = seachList[0]\n seachList = [i for i in seachList if i % tmp != 0]\n primeNum.extend(seachList)\n return primeNum\n\n#####GCD#####\ndef gcd(a, b):\n while b: a, b = b, a % b\n return a\n\n#####LCM#####\ndef lcm(a, b):\n return a * b // gcd (a, b)\n\n#####BitCount#####\ndef count_bit(n):\n count = 0\n while n:\n n &= n-1\n count += 1\n return count\n\n#####ChangeBase#####\ndef base_10_to_n(X, n):\n if X//n: return base_10_to_n(X//n, n)+[X%n]\n return [X%n]\n\ndef base_n_to_10(X, n):\n return sum(int(str(X)[-i-1])*n**i for i in range(len(str(X))))\n\ndef base_10_to_n_without_0(X, n):\n X -= 1\n if X//n: return base_10_to_n_without_0(X//n, n)+[X%n]\n return [X%n]\n\n#####IntLog#####\ndef int_log(n, a):\n count = 0\n while n>=a:\n n //= a\n count += 1\n return count\n\n#############\n# Main Code #\n#############\n\nH,W,A,B = IL()\nans = nCr(H+W-2,H-1)\nfor i in range(B):\n ans -= nCr(H-A+i-1,i)*nCr(W+A-i-2,A-1)\n ans %= MOD\nprint(ans)", "import sys", "sys", "input = sys.stdin.readline", "input", "sys.stdin.readline", "sys.stdin", "sys", "stdin", "readline", "import math", "math", "import bisect", "bisect", "import heapq", "heapq", "from collections import defaultdict", "from collections import deque", "from collections import Counter", "from functools import lru_cache", "MOD = 10**9+7", "MOD", "10**9+7", "10**9", "10", "9", "7", "INF = float('inf')", "INF", "float('inf')", "float", "'inf'", "AZ = \"abcdefghijklmnopqrstuvwxyz\"", "AZ", "\"abcdefghijklmnopqrstuvwxyz\"", "def I(): return int(input().strip())", "I", "def S(): return input().strip()", "S", "def IL(): return list(map(int,input().split()))", "IL", "def SL(): return list(map(str,input().split()))", "SL", "def ILs(n): return list(int(input()) for _ in range(n))", "ILs", "n", "n", "def SLs(n): return list(input().strip() for _ in range(n))", "SLs", "n", "n", "list(map(int, input().split())) for _ in range(n)", "for _ in range(n)", "_", "range(n)", "range", "n", "for _ in range(n)", "list(map(int, input().split()))", "list", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "def ILL(n): return [list(map(int, input().split())) for _ in range(n)]", "ILL", "n", "n", "list(map(str, input().split())) for _ in range(n)", "for _ in range(n)", "_", "range(n)", "range", "n", "for _ in range(n)", "list(map(str, input().split()))", "list", "map(str, input().split())", "map", "str", "input().split()", "().split", "()", "input", "split", "def SLL(n): return [list(map(str, input().split())) for _ in range(n)]\n\n\n#####Shorten#####", "SLL", "n", "n", "def DD(arg): return defaultdict(arg)\n\n#####Inverse#####", "DD", "arg", "arg", "def inv(n): return pow(n, MOD-2, MOD)\n\n######Combination######", "inv", "n", "n", "kaijo_memo = []", "kaijo_memo", "[]", "def kaijo(n):\n if(len(kaijo_memo) > n): return kaijo_memo[n]\n if(len(kaijo_memo) == 0): kaijo_memo.append(1)\n while(len(kaijo_memo) <= n): kaijo_memo.append(kaijo_memo[-1] * len(kaijo_memo) % MOD)\n return kaijo_memo[n]", "kaijo", "if(len(kaijo_memo) > n): return kaijo_memo[n]\n ", "len(kaijo_memo) > n", "len(kaijo_memo)", "len", "kaijo_memo", "n", "if(len(kaijo_memo) == 0): kaijo_memo.append(1)\n ", "len(kaijo_memo) == 0", "len(kaijo_memo)", "len", "kaijo_memo", "0", "while(len(kaijo_memo) <= n): kaijo_memo.append(kaijo_memo[-1] * len(kaijo_memo) % MOD)\n ", "len(kaijo_memo) <= n", "len(kaijo_memo)", "len", "kaijo_memo", "n", "return kaijo_memo[n]", "kaijo_memo[n]", "kaijo_memo", "n", "n", "n", "gyaku_kaijo_memo = []", "gyaku_kaijo_memo", "[]", "def gyaku_kaijo(n):\n if(len(gyaku_kaijo_memo) > n): return gyaku_kaijo_memo[n]\n if(len(gyaku_kaijo_memo) == 0): gyaku_kaijo_memo.append(1)\n while(len(gyaku_kaijo_memo) <= n): gyaku_kaijo_memo.append(gyaku_kaijo_memo[-1] * pow(len(gyaku_kaijo_memo),MOD-2,MOD) % MOD)\n return gyaku_kaijo_memo[n]", "gyaku_kaijo", "if(len(gyaku_kaijo_memo) > n): return gyaku_kaijo_memo[n]\n ", "len(gyaku_kaijo_memo) > n", "len(gyaku_kaijo_memo)", "len", "gyaku_kaijo_memo", "n", "if(len(gyaku_kaijo_memo) == 0): gyaku_kaijo_memo.append(1)\n ", "len(gyaku_kaijo_memo) == 0", "len(gyaku_kaijo_memo)", "len", "gyaku_kaijo_memo", "0", "while(len(gyaku_kaijo_memo) <= n): gyaku_kaijo_memo.append(gyaku_kaijo_memo[-1] * pow(len(gyaku_kaijo_memo),MOD-2,MOD) % MOD)\n ", "len(gyaku_kaijo_memo) <= n", "len(gyaku_kaijo_memo)", "len", "gyaku_kaijo_memo", "n", "return gyaku_kaijo_memo[n]", "gyaku_kaijo_memo[n]", "gyaku_kaijo_memo", "n", "n", "n", "def nCr(n,r):\n if n == r: return 1\n if n < r or r < 0: return 0\n ret = 1\n ret = ret * kaijo(n) % MOD\n ret = ret * gyaku_kaijo(r) % MOD\n ret = ret * gyaku_kaijo(n-r) % MOD\n return ret\n\n######Factorization######", "nCr", "if n == r: return 1\n ", "n == r", "n", "r", "if n < r or r < 0: return 0\n ", "n < r or r < 0", "n < r", "n", "r", "r < 0", "r", "0", "ret = 1", "ret", "1", "ret = ret * kaijo(n) % MOD", "ret", "ret * kaijo(n) % MOD", "ret * kaijo(n)", "ret", "kaijo(n)", "kaijo", "n", "MOD", "ret = ret * gyaku_kaijo(r) % MOD", "ret", "ret * gyaku_kaijo(r) % MOD", "ret * gyaku_kaijo(r)", "ret", "gyaku_kaijo(r)", "gyaku_kaijo", "r", "MOD", "ret = ret * gyaku_kaijo(n-r) % MOD", "ret", "ret * gyaku_kaijo(n-r) % MOD", "ret * gyaku_kaijo(n-r)", "ret", "gyaku_kaijo(n-r)", "gyaku_kaijo", "n-r", "n", "r", "MOD", "return ret", "ret", "n", "n", "r", "r", "def factorization(n):\n arr = []\n temp = n\n for i in range(2, int(-(-n**0.5//1))+1):\n if temp%i==0:\n cnt=0\n while temp%i==0: \n cnt+=1 \n temp //= i\n arr.append([i, cnt])\n if temp!=1: arr.append([temp, 1])\n if arr==[]: arr.append([n, 1])\n return arr\n\n#####MakeDivisors######", "factorization", "arr = []", "arr", "[]", "temp = n", "temp", "n", "for i in range(2, int(-(-n**0.5//1))+1):\n if temp%i==0:\n cnt=0\n while temp%i==0: \n cnt+=1 \n temp //= i\n arr.append([i, cnt])\n ", "i", "range(2, int(-(-n**0.5//1))+1)", "range", "2", "int(-(-n**0.5//1))+1", "int(-(-n**0.5//1))", "int", "-(-n**0.5//1)", "-n**0.5//1", "-n**0.5", "n**0.5", "n", "0.5", "1", "1", "if temp%i==0:\n cnt=0\n while temp%i==0: \n cnt+=1 \n temp //= i\n arr.append([i, cnt])\n ", "temp%i==0", "temp%i", "temp", "i", "0", "cnt=0", "cnt", "0", "while temp%i==0: \n cnt+=1 \n temp //= i\n ", "temp%i==0", "temp%i", "temp", "i", "0", "cnt+=1", "cnt", "1", "temp //= i", "temp", "i", "arr.append([i, cnt])", "arr.append", "arr", "append", "[i, cnt]", "i", "cnt", "if temp!=1: arr.append([temp, 1])\n ", "temp!=1", "temp", "1", "if arr==[]: arr.append([n, 1])\n ", "arr==[]", "arr", "[]", "return arr", "arr", "n", "n", "def make_divisors(n):\n divisors = []\n for i in range(1, int(n**0.5)+1):\n if n % i == 0:\n divisors.append(i)\n if i != n // i: \n divisors.append(n//i)\n return divisors\n\n#####MakePrimes######", "make_divisors", "divisors = []", "divisors", "[]", "for i in range(1, int(n**0.5)+1):\n if n % i == 0:\n divisors.append(i)\n if i != n // i: \n divisors.append(n//i)\n ", "i", "range(1, int(n**0.5)+1)", "range", "1", "int(n**0.5)+1", "int(n**0.5)", "int", "n**0.5", "n", "0.5", "1", "if n % i == 0:\n divisors.append(i)\n if i != n // i: \n divisors.append(n//i)\n ", "n % i == 0", "n % i", "n", "i", "0", "divisors.append(i)", "divisors.append", "divisors", "append", "i", "if i != n // i: \n divisors.append(n//i)\n ", "i != n // i", "i", "n // i", "n", "i", "divisors.append(n//i)", "divisors.append", "divisors", "append", "n//i", "n", "i", "return divisors", "divisors", "n", "n", "def make_primes(N):\n max = int(math.sqrt(N))\n seachList = [i for i in range(2,N+1)]\n primeNum = []\n while seachList[0] <= max:\n primeNum.append(seachList[0])\n tmp = seachList[0]\n seachList = [i for i in seachList if i % tmp != 0]\n primeNum.extend(seachList)\n return primeNum\n\n#####GCD#####", "make_primes", "max = int(math.sqrt(N))", "max", "int(math.sqrt(N))", "int", "math.sqrt(N)", "math.sqrt", "math", "sqrt", "N", "i for i in range(2,N+1)", "for i in range(2,N+1)", "i", "range(2,N+1)", "range", "2", "N+1", "N", "1", "for i in range(2,N+1)", "i", "seachList = [i for i in range(2,N+1)]", "seachList", "[i for i in range(2,N+1)]", "primeNum = []", "primeNum", "[]", "while seachList[0] <= max:\n primeNum.append(seachList[0])\n tmp = seachList[0]\n seachList = [i for i in seachList if i % tmp != 0]\n ", "seachList[0] <= max", "seachList[0]", "seachList", "0", "max", "primeNum.append(seachList[0])", "primeNum.append", "primeNum", "append", "seachList[0]", "seachList", "0", "tmp = seachList[0]", "tmp", "seachList[0]", "seachList", "0", "i for i in seachList if i % tmp != 0", "for i in seachList if i % tmp != 0", "i", "seachList", "i % tmp != 0", "i % tmp", "i", "tmp", "0", "if i % tmp != 0", "i", "seachList = [i for i in seachList if i % tmp != 0]", "seachList", "[i for i in seachList if i % tmp != 0]", "primeNum.extend(seachList)", "primeNum.extend", "primeNum", "extend", "seachList", "return primeNum", "primeNum", "N", "N", "def gcd(a, b):\n while b: a, b = b, a % b\n return a\n\n#####LCM#####", "gcd", "while b: a, b = b, a % b\n ", "b", "return a", "a", "a", "a", "b", "b", "def lcm(a, b):\n return a * b // gcd (a, b)\n\n#####BitCount#####", "lcm", "return a * b // gcd (a, b)", "a * b // gcd (a, b)", "a * b", "a", "b", "gcd (a, b)", "gcd", "a", "b", "a", "a", "b", "b", "def count_bit(n):\n count = 0\n while n:\n n &= n-1\n count += 1\n return count\n\n#####ChangeBase#####", "count_bit", "count = 0", "count", "0", "while n:\n n &= n-1\n count += 1\n ", "n", "n &= n-1", "n", "n-1", "n", "1", "count += 1", "count", "1", "return count", "count", "n", "n", "def base_10_to_n(X, n):\n if X//n: return base_10_to_n(X//n, n)+[X%n]\n return [X%n]", "base_10_to_n", "if X//n: return base_10_to_n(X//n, n)+[X%n]\n ", "X//n", "X", "n", "return [X%n]", "[X%n]", "X%n", "X", "n", "X", "X", "n", "n", "def base_n_to_10(X, n):\n return sum(int(str(X)[-i-1])*n**i for i in range(len(str(X))))", "base_n_to_10", "return sum(int(str(X)[-i-1])*n**i for i in range(len(str(X))))", "sum(int(str(X)[-i-1])*n**i for i in range(len(str(X))))", "sum", "int(str(X)[-i-1])*n**i", "int(str(X)[-i-1])", "int", "str(X)[-i-1]", "(X)", "str", "X", "-i-1", "-i", "i", "1", "n**i", "n", "i", "X", "X", "n", "n", "def base_10_to_n_without_0(X, n):\n X -= 1\n if X//n: return base_10_to_n_without_0(X//n, n)+[X%n]\n return [X%n]\n\n#####IntLog#####", "base_10_to_n_without_0", "X -= 1", "X", "1", "if X//n: return base_10_to_n_without_0(X//n, n)+[X%n]\n ", "X//n", "X", "n", "return [X%n]", "[X%n]", "X%n", "X", "n", "X", "X", "n", "n", "def int_log(n, a):\n count = 0\n while n>=a:\n n //= a\n count += 1\n return count\n\n#############\n# Main Code #\n#############", "int_log", "count = 0", "count", "0", "while n>=a:\n n //= a\n count += 1\n ", "n>=a", "n", "a", "n //= a", "n", "a", "count += 1", "count", "1", "return count", "count", "n", "n", "a", "a", "H,W,A,B = IL()", "H", "IL()", "IL", "W", "A", "B", "ans = nCr(H+W-2,H-1)", "ans", "nCr(H+W-2,H-1)", "nCr", "H+W-2", "H+W", "H", "W", "2", "H-1", "H", "1", "for i in range(B):\n ans -= nCr(H-A+i-1,i)*nCr(W+A-i-2,A-1)\n ans %= MOD", "i", "range(B)", "range", "B", "ans -= nCr(H-A+i-1,i)*nCr(W+A-i-2,A-1)", "ans", "nCr(H-A+i-1,i)*nCr(W+A-i-2,A-1)", "nCr(H-A+i-1,i)", "nCr", "H-A+i-1", "H-A+i", "H-A", "H", "A", "i", "1", "i", "nCr(W+A-i-2,A-1)", "nCr", "W+A-i-2", "W+A-i", "W+A", "W", "A", "i", "2", "A-1", "A", "1", "ans %= MOD", "ans", "MOD", "print(ans)", "print", "ans", "def DD(arg): return defaultdict(arg)\n\n#####Inverse#####", "def DD(arg): return defaultdict(arg)\n\n#####Inverse#####", "DD", "def SL(): return list(map(str,input().split()))", "def SL(): return list(map(str,input().split()))", "SL", "def ILs(n): return list(int(input()) for _ in range(n))", "def ILs(n): return list(int(input()) for _ in range(n))", "ILs", "def make_primes(N):\n max = int(math.sqrt(N))\n seachList = [i for i in range(2,N+1)]\n primeNum = []\n while seachList[0] <= max:\n primeNum.append(seachList[0])\n tmp = seachList[0]\n seachList = [i for i in seachList if i % tmp != 0]\n primeNum.extend(seachList)\n return primeNum\n\n#####GCD#####", "def make_primes(N):\n max = int(math.sqrt(N))\n seachList = [i for i in range(2,N+1)]\n primeNum = []\n while seachList[0] <= max:\n primeNum.append(seachList[0])\n tmp = seachList[0]\n seachList = [i for i in seachList if i % tmp != 0]\n primeNum.extend(seachList)\n return primeNum\n\n#####GCD#####", "make_primes", "def inv(n): return pow(n, MOD-2, MOD)\n\n######Combination######", "def inv(n): return pow(n, MOD-2, MOD)\n\n######Combination######", "inv", "def base_10_to_n_without_0(X, n):\n X -= 1\n if X//n: return base_10_to_n_without_0(X//n, n)+[X%n]\n return [X%n]\n\n#####IntLog#####", "def base_10_to_n_without_0(X, n):\n X -= 1\n if X//n: return base_10_to_n_without_0(X//n, n)+[X%n]\n return [X%n]\n\n#####IntLog#####", "base_10_to_n_without_0", "def S(): return input().strip()", "def S(): return input().strip()", "S", "def ILL(n): return [list(map(int, input().split())) for _ in range(n)]", "def ILL(n): return [list(map(int, input().split())) for _ in range(n)]", "ILL", "ans = nCr(H+W-2,H-1)", "nCr(H+W-2,H-1)", "ans", "def base_10_to_n(X, n):\n if X//n: return base_10_to_n(X//n, n)+[X%n]\n return [X%n]", "def base_10_to_n(X, n):\n if X//n: return base_10_to_n(X//n, n)+[X%n]\n return [X%n]", "base_10_to_n", "kaijo_memo = []", "[]", "kaijo_memo", "def make_divisors(n):\n divisors = []\n for i in range(1, int(n**0.5)+1):\n if n % i == 0:\n divisors.append(i)\n if i != n // i: \n divisors.append(n//i)\n return divisors\n\n#####MakePrimes######", "def make_divisors(n):\n divisors = []\n for i in range(1, int(n**0.5)+1):\n if n % i == 0:\n divisors.append(i)\n if i != n // i: \n divisors.append(n//i)\n return divisors\n\n#####MakePrimes######", "make_divisors", "def I(): return int(input().strip())", "def I(): return int(input().strip())", "I", "B = IL()", "IL()", "B", "def IL(): return list(map(int,input().split()))", "def IL(): return list(map(int,input().split()))", "IL", "ans %= MOD", "MOD", "ans", "def gcd(a, b):\n while b: a, b = b, a % b\n return a\n\n#####LCM#####", "def gcd(a, b):\n while b: a, b = b, a % b\n return a\n\n#####LCM#####", "gcd", "def SLs(n): return list(input().strip() for _ in range(n))", "def SLs(n): return list(input().strip() for _ in range(n))", "SLs", "input = sys.stdin.readline", "sys.stdin.readline", "input", "def count_bit(n):\n count = 0\n while n:\n n &= n-1\n count += 1\n return count\n\n#####ChangeBase#####", "def count_bit(n):\n count = 0\n while n:\n n &= n-1\n count += 1\n return count\n\n#####ChangeBase#####", "count_bit", "H,W,A,B = IL()", "IL()", "H", "def SLL(n): return [list(map(str, input().split())) for _ in range(n)]\n\n\n#####Shorten#####", "def SLL(n): return [list(map(str, input().split())) for _ in range(n)]\n\n\n#####Shorten#####", "SLL", "AZ = \"abcdefghijklmnopqrstuvwxyz\"", "\"abcdefghijklmnopqrstuvwxyz\"", "AZ", "def nCr(n,r):\n if n == r: return 1\n if n < r or r < 0: return 0\n ret = 1\n ret = ret * kaijo(n) % MOD\n ret = ret * gyaku_kaijo(r) % MOD\n ret = ret * gyaku_kaijo(n-r) % MOD\n return ret\n\n######Factorization######", "def nCr(n,r):\n if n == r: return 1\n if n < r or r < 0: return 0\n ret = 1\n ret = ret * kaijo(n) % MOD\n ret = ret * gyaku_kaijo(r) % MOD\n ret = ret * gyaku_kaijo(n-r) % MOD\n return ret\n\n######Factorization######", "nCr", "def kaijo(n):\n if(len(kaijo_memo) > n): return kaijo_memo[n]\n if(len(kaijo_memo) == 0): kaijo_memo.append(1)\n while(len(kaijo_memo) <= n): kaijo_memo.append(kaijo_memo[-1] * len(kaijo_memo) % MOD)\n return kaijo_memo[n]", "def kaijo(n):\n if(len(kaijo_memo) > n): return kaijo_memo[n]\n if(len(kaijo_memo) == 0): kaijo_memo.append(1)\n while(len(kaijo_memo) <= n): kaijo_memo.append(kaijo_memo[-1] * len(kaijo_memo) % MOD)\n return kaijo_memo[n]", "kaijo", "def factorization(n):\n arr = []\n temp = n\n for i in range(2, int(-(-n**0.5//1))+1):\n if temp%i==0:\n cnt=0\n while temp%i==0: \n cnt+=1 \n temp //= i\n arr.append([i, cnt])\n if temp!=1: arr.append([temp, 1])\n if arr==[]: arr.append([n, 1])\n return arr\n\n#####MakeDivisors######", "def factorization(n):\n arr = []\n temp = n\n for i in range(2, int(-(-n**0.5//1))+1):\n if temp%i==0:\n cnt=0\n while temp%i==0: \n cnt+=1 \n temp //= i\n arr.append([i, cnt])\n if temp!=1: arr.append([temp, 1])\n if arr==[]: arr.append([n, 1])\n return arr\n\n#####MakeDivisors######", "factorization", "def gyaku_kaijo(n):\n if(len(gyaku_kaijo_memo) > n): return gyaku_kaijo_memo[n]\n if(len(gyaku_kaijo_memo) == 0): gyaku_kaijo_memo.append(1)\n while(len(gyaku_kaijo_memo) <= n): gyaku_kaijo_memo.append(gyaku_kaijo_memo[-1] * pow(len(gyaku_kaijo_memo),MOD-2,MOD) % MOD)\n return gyaku_kaijo_memo[n]", "def gyaku_kaijo(n):\n if(len(gyaku_kaijo_memo) > n): return gyaku_kaijo_memo[n]\n if(len(gyaku_kaijo_memo) == 0): gyaku_kaijo_memo.append(1)\n while(len(gyaku_kaijo_memo) <= n): gyaku_kaijo_memo.append(gyaku_kaijo_memo[-1] * pow(len(gyaku_kaijo_memo),MOD-2,MOD) % MOD)\n return gyaku_kaijo_memo[n]", "gyaku_kaijo", "MOD = 10**9+7", "10**9+7", "MOD", "INF = float('inf')", "float('inf')", "INF", "gyaku_kaijo_memo = []", "[]", "gyaku_kaijo_memo", "def int_log(n, a):\n count = 0\n while n>=a:\n n //= a\n count += 1\n return count\n\n#############\n# Main Code #\n#############", "def int_log(n, a):\n count = 0\n while n>=a:\n n //= a\n count += 1\n return count\n\n#############\n# Main Code #\n#############", "int_log", "A,B = IL()", "IL()", "A", "ans -= nCr(H-A+i-1,i)*nCr(W+A-i-2,A-1)", "nCr(H-A+i-1,i)*nCr(W+A-i-2,A-1)", "ans", "def lcm(a, b):\n return a * b // gcd (a, b)\n\n#####BitCount#####", "def lcm(a, b):\n return a * b // gcd (a, b)\n\n#####BitCount#####", "lcm", "def base_n_to_10(X, n):\n return sum(int(str(X)[-i-1])*n**i for i in range(len(str(X))))", "def base_n_to_10(X, n):\n return sum(int(str(X)[-i-1])*n**i for i in range(len(str(X))))", "base_n_to_10", "W,A,B = IL()", "IL()", "W" ]

[ 7, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 13, 13, 12, 13, 29, 2, 2, 2, 2, 18, 13, 13, 18, 13, 2, 13, 13, 13, 18, 13, 13, 13, 23, 13, 23, 13, 0, 13, 2, 2, 17, 17, 17, 0, 13, 2, 13, 17, 0, 13, 2, 2, 13, 13, 17, 0, 13, 2, 39, 17, 2, 13, 17, 0, 13, 2, 39, 17, 2, 13, 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, 28, 13, 4, 13, 17, 2, 13, 17, 0, 18, 13, 13, 4, 13, 18, 13, 13, 13, 13, 0, 13, 17, 28, 13, 4, 13, 17, 2, 2, 13, 13, 17, 0, 13, 2, 2, 4, 13, 2, 2, 13, 13, 17, 2, 13, 17, 4, 13, 2, 2, 2, 2, 13, 13, 13, 17, 13, 2, 13, 13, 13, 0, 13, 2, 13, 13, 4, 13, 4, 13, 13, 10, 2, 13, 10, 4, 13, 10, 2, 13, 10, 4, 13, 10, 4, 13, 10, 12, 13, 10, 4, 13, 10, 2, 13, 10, 17, 13, 10, 2, 13, 10, 2, 13, 10, 2, 13, 10, 2, 13 ]

[ [ 204, 2 ], [ 204, 11 ], [ 204, 12 ], [ 204, 13 ], [ 35, 23 ], [ 35, 27 ], [ 37, 28 ], [ 37, 32 ], [ 35, 35 ], [ 37, 37 ], [ 207, 39 ], [ 186, 46 ], [ 208, 48 ], [ 192, 51 ], [ 205, 54 ], [ 190, 55 ], [ 222, 58 ], [ 193, 63 ], [ 213, 66 ], [ 193, 71 ], [ 82, 74 ], [ 223, 75 ], [ 82, 79 ], [ 223, 80 ], [ 92, 84 ], [ 214, 85 ], [ 92, 89 ], [ 214, 90 ], [ 95, 94 ], [ 193, 99 ], [ 105, 102 ], [ 223, 103 ], [ 94, 104 ], [ 223, 108 ], [ 94, 110 ], [ 94, 112 ], [ 208, 113 ], [ 116, 115 ], [ 193, 120 ], [ 126, 123 ], [ 214, 124 ], [ 115, 125 ], [ 102, 128 ], [ 223, 129 ], [ 115, 130 ], [ 187, 131 ], [ 208, 132 ], [ 210, 134 ], [ 138, 137 ], [ 205, 143 ], [ 199, 144 ], [ 219, 147 ], [ 202, 151 ], [ 196, 154 ], [ 137, 155 ], [ 137, 158 ], [ 202, 161 ], [ 190, 166 ], [ 205, 167 ], [ 196, 168 ], [ 137, 170 ], [ 205, 172 ], [ 137, 173 ], [ 208, 174 ], [ 216, 176 ], [ 220, 178 ], [ 211, 178 ], [ 217, 178 ], [ 208, 179 ], [ 217, 184 ], [ 220, 184 ], [ 211, 184 ], [ 186, 187 ], [ 204, 190 ], [ 192, 193 ], [ 204, 196 ], [ 204, 199 ], [ 204, 205 ], [ 207, 208 ], [ 210, 211 ], [ 213, 214 ], [ 216, 217 ], [ 219, 220 ], [ 222, 223 ] ]

[ "high, width, y, x = map(int, input().split())\n\ndef nCr(n, r):\n return ((((fact[n]*finv[n-r])%mod)*finv[r])%mod)\n\nmod = 10**9 + 7\ninv = mod - 2\nmaxn = high + width - 2\nfact = [0] * (maxn+1)\nfinv = [0] * (maxn+1)\nfact[0] = fact[1] = 1\nfinv[0] = finv[1] = 1\n\n# 階乗を求める\nfor i in range(2, maxn+1):\n fact[i] = (fact[i-1] * i) % mod\n\n# 階乗の逆元を求める\nfor i in range(2, maxn+1):\n finv[i] = pow(fact[i], inv, mod)\n\nroute = 0\nfor i in range(1, high-y+1):\n route += (nCr(x+i-2, i-1) * nCr(width+high-x-1-i, high-i)) % mod\n route = route % mod\nprint(int(route))", "high, width, y, x = map(int, input().split())", "high", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "width", "y", "x", "def nCr(n, r):\n return ((((fact[n]*finv[n-r])%mod)*finv[r])%mod)", "nCr", "return ((((fact[n]*finv[n-r])%mod)*finv[r])%mod)", "(((fact[n]*finv[n-r])%mod)*finv[r])%mod", "((fact[n]*finv[n-r])%mod)*finv[r]", "(fact[n]*finv[n-r])%mod", "fact[n]*finv[n-r]", "fact[n]", "fact", "n", "finv[n-r]", "finv", "n-r", "n", "r", "mod", "finv[r]", "finv", "r", "mod", "n", "n", "r", "r", "mod = 10**9 + 7", "mod", "10**9 + 7", "10**9", "10", "9", "7", "inv = mod - 2", "inv", "mod - 2", "mod", "2", "maxn = high + width - 2", "maxn", "high + width - 2", "high + width", "high", "width", "2", "fact = [0] * (maxn+1)", "fact", "[0] * (maxn+1)", "[0]", "0", "maxn+1", "maxn", "1", "finv = [0] * (maxn+1)", "finv", "[0] * (maxn+1)", "[0]", "0", "maxn+1", "maxn", "1", "fact[0] = fact[1] = 1", "fact[0]", "fact", "0", "1", "= fact[1] = 1", "fact[1]", "fact", "1", "1", "finv[0] = finv[1] = 1", "finv[0]", "finv", "0", "1", "= finv[1] = 1", "finv[1]", "finv", "1", "1", "for i in range(2, maxn+1):\n fact[i] = (fact[i-1] * i) % mod\n\n# 階乗の逆元を求める", "i", "range(2, maxn+1)", "range", "2", "maxn+1", "maxn", "1", "fact[i] = (fact[i-1] * i) % mod", "fact[i]", "fact", "i", "(fact[i-1] * i) % mod", "fact[i-1] * i", "fact[i-1]", "fact", "i-1", "i", "1", "i", "mod", "for i in range(2, maxn+1):\n finv[i] = pow(fact[i], inv, mod)", "i", "range(2, maxn+1)", "range", "2", "maxn+1", "maxn", "1", "finv[i] = pow(fact[i], inv, mod)", "finv[i]", "finv", "i", "pow(fact[i], inv, mod)", "pow", "fact[i]", "fact", "i", "inv", "mod", "route = 0", "route", "0", "for i in range(1, high-y+1):\n route += (nCr(x+i-2, i-1) * nCr(width+high-x-1-i, high-i)) % mod\n route = route % mod", "i", "range(1, high-y+1)", "range", "1", "high-y+1", "high-y", "high", "y", "1", "route += (nCr(x+i-2, i-1) * nCr(width+high-x-1-i, high-i)) % mod", "route", "(nCr(x+i-2, i-1) * nCr(width+high-x-1-i, high-i)) % mod", "nCr(x+i-2, i-1) * nCr(width+high-x-1-i, high-i)", "nCr(x+i-2, i-1)", "nCr", "x+i-2", "x+i", "x", "i", "2", "i-1", "i", "1", "nCr(width+high-x-1-i, high-i)", "nCr", "width+high-x-1-i", "width+high-x-1", "width+high-x", "width+high", "width", "high", "x", "1", "i", "high-i", "high", "i", "mod", "route = route % mod", "route", "route % mod", "route", "mod", "print(int(route))", "print", "int(route)", "int", "route", "inv = mod - 2", "mod - 2", "inv", "width, y, x = map(int, input().split())", "map(int, input().split())", "width", "maxn = high + width - 2", "high + width - 2", "maxn", "x = map(int, input().split())", "map(int, input().split())", "x", "y, x = map(int, input().split())", "map(int, input().split())", "y", "def nCr(n, r):\n return ((((fact[n]*finv[n-r])%mod)*finv[r])%mod)", "def nCr(n, r):\n return ((((fact[n]*finv[n-r])%mod)*finv[r])%mod)", "nCr", "high, width, y, x = map(int, input().split())", "map(int, input().split())", "high", "mod = 10**9 + 7", "10**9 + 7", "mod", "route = 0", "0", "route", "finv = [0] * (maxn+1)", "[0] * (maxn+1)", "finv", "route = route % mod", "route % mod", "route", "route += (nCr(x+i-2, i-1) * nCr(width+high-x-1-i, high-i)) % mod", "(nCr(x+i-2, i-1) * nCr(width+high-x-1-i, high-i)) % mod", "route", "fact = [0] * (maxn+1)", "[0] * (maxn+1)", "fact" ]

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

[ [ 243, 9 ], [ 237, 16 ], [ 24, 23 ], [ 24, 32 ], [ 24, 33 ], [ 24, 34 ], [ 37, 36 ], [ 23, 39 ], [ 32, 40 ], [ 44, 43 ], [ 48, 47 ], [ 36, 52 ], [ 43, 56 ], [ 43, 61 ], [ 47, 63 ], [ 244, 64 ], [ 67, 66 ], [ 36, 71 ], [ 77, 74 ], [ 66, 75 ], [ 43, 80 ], [ 244, 83 ], [ 244, 85 ], [ 88, 87 ], [ 36, 91 ], [ 99, 96 ], [ 66, 97 ], [ 87, 98 ], [ 66, 102 ], [ 87, 104 ], [ 87, 107 ], [ 244, 109 ], [ 112, 111 ], [ 43, 114 ], [ 119, 118 ], [ 43, 133 ], [ 66, 136 ], [ 66, 141 ], [ 244, 143 ], [ 148, 147 ], [ 118, 150 ], [ 167, 166 ], [ 23, 171 ], [ 33, 172 ], [ 32, 174 ], [ 34, 175 ], [ 178, 177 ], [ 32, 178 ], [ 180, 179 ], [ 177, 180 ], [ 23, 180 ], [ 183, 182 ], [ 34, 183 ], [ 185, 184 ], [ 182, 185 ], [ 33, 185 ], [ 188, 187 ], [ 179, 191 ], [ 32, 191 ], [ 184, 192 ], [ 34, 192 ], [ 195, 194 ], [ 184, 197 ], [ 34, 197 ], [ 187, 198 ], [ 202, 201 ], [ 177, 204 ], [ 23, 204 ], [ 182, 205 ], [ 33, 205 ], [ 187, 206 ], [ 209, 208 ], [ 147, 212 ], [ 201, 215 ], [ 194, 216 ], [ 147, 218 ], [ 201, 219 ], [ 194, 220 ], [ 177, 221 ], [ 23, 221 ], [ 179, 222 ], [ 32, 222 ], [ 244, 223 ], [ 226, 225 ], [ 244, 226 ], [ 225, 229 ], [ 208, 229 ], [ 166, 229 ], [ 241, 235 ], [ 237, 238 ], [ 243, 244 ] ]

[ "import sys\nsys.setrecursionlimit(10000000)\nMOD = 10 ** 9 + 7\nINF = 10 ** 15\n\ndef main():\n H,W,A,B = map(int,input().split())\n MAXN = H + W + 3\n factorial = [1]\n for i in range(1,MAXN + 1):\n factorial.append(factorial[-1]*i%MOD)\n inv_factorial = [-1] * (MAXN + 1)\n inv_factorial[-1] = pow(factorial[-1],MOD - 2,MOD)\n for i in range(MAXN - 1,-1,-1):\n inv_factorial[i] = inv_factorial[i + 1]*(i + 1)%MOD\n \n fact = lambda N:factorial[N]\n nck = lambda N,K: 0 if K > N or K < 0 else factorial[N]*inv_factorial[N - K]*inv_factorial[K]%MOD\n dist = lambda sy,sx,gy,gx: nck(gy - sy + gx - sx,gy - sy)\n ans = 0\n if H - A < W - B:\n H,W = W,H\n A,B = B,A\n \n for i in range(W - B):\n x = B + i + 1\n y = H - A - i\n ans += dist(1,1,y,x)*dist(y,x,H,W)%MOD\n ans %= MOD\n print(ans)\nif __name__ == '__main__':\n main()", "import sys", "sys", "sys.setrecursionlimit(10000000)", "sys.setrecursionlimit", "sys", "setrecursionlimit", "10000000", "MOD = 10 ** 9 + 7", "MOD", "10 ** 9 + 7", "10 ** 9", "10", "9", "7", "INF = 10 ** 15", "INF", "10 ** 15", "10", "15", "def main():\n H,W,A,B = map(int,input().split())\n MAXN = H + W + 3\n factorial = [1]\n for i in range(1,MAXN + 1):\n factorial.append(factorial[-1]*i%MOD)\n inv_factorial = [-1] * (MAXN + 1)\n inv_factorial[-1] = pow(factorial[-1],MOD - 2,MOD)\n for i in range(MAXN - 1,-1,-1):\n inv_factorial[i] = inv_factorial[i + 1]*(i + 1)%MOD\n \n fact = lambda N:factorial[N]\n nck = lambda N,K: 0 if K > N or K < 0 else factorial[N]*inv_factorial[N - K]*inv_factorial[K]%MOD\n dist = lambda sy,sx,gy,gx: nck(gy - sy + gx - sx,gy - sy)\n ans = 0\n if H - A < W - B:\n H,W = W,H\n A,B = B,A\n \n for i in range(W - B):\n x = B + i + 1\n y = H - A - i\n ans += dist(1,1,y,x)*dist(y,x,H,W)%MOD\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", "MAXN = H + W + 3", "MAXN", "H + W + 3", "H + W", "H", "W", "3", "factorial = [1]", "factorial", "[1]", "1", "for i in range(1,MAXN + 1):\n factorial.append(factorial[-1]*i%MOD)\n ", "i", "range(1,MAXN + 1)", "range", "1", "MAXN + 1", "MAXN", "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 = [-1] * (MAXN + 1)", "inv_factorial", "[-1] * (MAXN + 1)", "[-1]", "-1", "MAXN + 1", "MAXN", "1", "inv_factorial[-1] = pow(factorial[-1],MOD - 2,MOD)", "inv_factorial[-1]", "inv_factorial", "-1", "pow(factorial[-1],MOD - 2,MOD)", "pow", "factorial[-1]", "factorial", "-1", "MOD - 2", "MOD", "2", "MOD", "for i in range(MAXN - 1,-1,-1):\n inv_factorial[i] = inv_factorial[i + 1]*(i + 1)%MOD\n \n ", "i", "range(MAXN - 1,-1,-1)", "range", "MAXN - 1", "MAXN", "1", "-1", "-1", "inv_factorial[i] = inv_factorial[i + 1]*(i + 1)%MOD", "inv_factorial[i]", "inv_factorial", "i", "inv_factorial[i + 1]*(i + 1)%MOD", "inv_factorial[i + 1]*(i + 1)", "inv_factorial[i + 1]", "inv_factorial", "i + 1", "i", "1", "i + 1", "i", "1", "MOD", "fact = lambda N:factorial[N]", "fact", "lambda N:factorial[N]", "factorial[N]", "factorial", "N", "N", "nck = lambda N,K: 0 if K > N or K < 0 else factorial[N]*inv_factorial[N - K]*inv_factorial[K]%MOD", "nck", "lambda N,K: 0 if K > N or K < 0 else factorial[N]*inv_factorial[N - K]*inv_factorial[K]%MOD", "0 if K > N or K < 0 else factorial[N]*inv_factorial[N - K]*inv_factorial[K]%MOD", "K > N or K < 0", "K > N", "K", "N", "K < 0", "K", "0", "0", "factorial[N]*inv_factorial[N - K]*inv_factorial[K]%MOD", "factorial[N]*inv_factorial[N - K]*inv_factorial[K]", "factorial[N]*inv_factorial[N - K]", "factorial[N]", "factorial", "N", "inv_factorial[N - K]", "inv_factorial", "N - K", "N", "K", "inv_factorial[K]", "inv_factorial", "K", "MOD", "N", "K", "dist = lambda sy,sx,gy,gx: nck(gy - sy + gx - sx,gy - sy)", "dist", "lambda sy,sx,gy,gx: nck(gy - sy + gx - sx,gy - sy)", "nck(gy - sy + gx - sx,gy - sy)", "nck", "gy - sy + gx - sx", "gy - sy + gx", "gy - sy", "gy", "sy", "gx", "sx", "gy - sy", "gy", "sy", "sy", "sx", "gy", "gx", "ans = 0", "ans", "0", "if H - A < W - B:\n H,W = W,H\n A,B = B,A\n \n ", "H - A < W - B", "H - A", "H", "A", "W - B", "W", "B", "H,W = W,H", "H", "W", "W", "H", "A,B = B,A", "A", "B", "B", "A", "for i in range(W - B):\n x = B + i + 1\n y = H - A - i\n ans += dist(1,1,y,x)*dist(y,x,H,W)%MOD\n ans %= MOD\n ", "i", "range(W - B)", "range", "W - B", "W", "B", "x = B + i + 1", "x", "B + i + 1", "B + i", "B", "i", "1", "y = H - A - i", "y", "H - A - i", "H - A", "H", "A", "i", "ans += dist(1,1,y,x)*dist(y,x,H,W)%MOD", "ans", "dist(1,1,y,x)*dist(y,x,H,W)%MOD", "dist(1,1,y,x)*dist(y,x,H,W)", "dist(1,1,y,x)", "dist", "1", "1", "y", "x", "dist(y,x,H,W)", "dist", "y", "x", "H", "W", "MOD", "ans %= MOD", "ans", "MOD", "print(ans)", "print", "ans", "if __name__ == '__main__':\n main()", "__name__ == '__main__'", "__name__", "'__main__'", "main()", "main", "INF = 10 ** 15", "10 ** 15", "INF", "def main():\n H,W,A,B = map(int,input().split())\n MAXN = H + W + 3\n factorial = [1]\n for i in range(1,MAXN + 1):\n factorial.append(factorial[-1]*i%MOD)\n inv_factorial = [-1] * (MAXN + 1)\n inv_factorial[-1] = pow(factorial[-1],MOD - 2,MOD)\n for i in range(MAXN - 1,-1,-1):\n inv_factorial[i] = inv_factorial[i + 1]*(i + 1)%MOD\n \n fact = lambda N:factorial[N]\n nck = lambda N,K: 0 if K > N or K < 0 else factorial[N]*inv_factorial[N - K]*inv_factorial[K]%MOD\n dist = lambda sy,sx,gy,gx: nck(gy - sy + gx - sx,gy - sy)\n ans = 0\n if H - A < W - B:\n H,W = W,H\n A,B = B,A\n \n for i in range(W - B):\n x = B + i + 1\n y = H - A - i\n ans += dist(1,1,y,x)*dist(y,x,H,W)%MOD\n ans %= MOD\n print(ans)", "def main():\n H,W,A,B = map(int,input().split())\n MAXN = H + W + 3\n factorial = [1]\n for i in range(1,MAXN + 1):\n factorial.append(factorial[-1]*i%MOD)\n inv_factorial = [-1] * (MAXN + 1)\n inv_factorial[-1] = pow(factorial[-1],MOD - 2,MOD)\n for i in range(MAXN - 1,-1,-1):\n inv_factorial[i] = inv_factorial[i + 1]*(i + 1)%MOD\n \n fact = lambda N:factorial[N]\n nck = lambda N,K: 0 if K > N or K < 0 else factorial[N]*inv_factorial[N - K]*inv_factorial[K]%MOD\n dist = lambda sy,sx,gy,gx: nck(gy - sy + gx - sx,gy - sy)\n ans = 0\n if H - A < W - B:\n H,W = W,H\n A,B = B,A\n \n for i in range(W - B):\n x = B + i + 1\n y = H - A - i\n ans += dist(1,1,y,x)*dist(y,x,H,W)%MOD\n ans %= MOD\n print(ans)", "main", "MOD = 10 ** 9 + 7", "10 ** 9 + 7", "MOD" ]

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

[ [ 150, 2 ], [ 150, 11 ], [ 150, 12 ], [ 150, 13 ], [ 153, 15 ], [ 141, 22 ], [ 156, 26 ], [ 31, 30 ], [ 148, 36 ], [ 139, 37 ], [ 142, 41 ], [ 142, 46 ], [ 30, 48 ], [ 154, 49 ], [ 157, 52 ], [ 142, 57 ], [ 154, 60 ], [ 154, 62 ], [ 144, 64 ], [ 68, 67 ], [ 148, 71 ], [ 133, 72 ], [ 135, 74 ], [ 142, 82 ], [ 67, 85 ], [ 151, 86 ], [ 157, 89 ], [ 67, 90 ], [ 157, 92 ], [ 151, 94 ], [ 142, 97 ], [ 148, 102 ], [ 139, 103 ], [ 67, 104 ], [ 151, 105 ], [ 157, 108 ], [ 148, 111 ], [ 67, 112 ], [ 157, 115 ], [ 139, 118 ], [ 151, 119 ], [ 154, 121 ], [ 129, 123 ], [ 154, 124 ], [ 130, 127 ], [ 136, 127 ], [ 145, 127 ], [ 154, 129 ], [ 129, 130 ], [ 150, 133 ], [ 135, 136 ], [ 150, 139 ], [ 141, 142 ], [ 144, 145 ], [ 150, 148 ], [ 150, 151 ], [ 153, 154 ], [ 156, 157 ] ]

[ "H, W, A, B = map(int, input().split())\nMOD = 10 ** 9 + 7\n\nfac = [1]\ninv = [1]\n\nfor i in range(1, H+W+1) :\n fac.append(fac[-1] * i % MOD)\n inv.append(pow(fac[-1], MOD - 2, MOD))\n \nret = 0\nfor i in range(H-A) :\n ret += fac[i+B-1]*inv[i]*inv[B-1]*fac[H+W-i-B-2]*inv[H-i-1]*inv[W-B-1]%MOD\n ret %= MOD\n \nprint(ret)", "H, W, A, B = map(int, input().split())", "H", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "W", "A", "B", "MOD = 10 ** 9 + 7", "MOD", "10 ** 9 + 7", "10 ** 9", "10", "9", "7", "fac = [1]", "fac", "[1]", "1", "inv = [1]", "inv", "[1]", "1", "for i in range(1, H+W+1) :\n fac.append(fac[-1] * i % MOD)\n inv.append(pow(fac[-1], MOD - 2, MOD))\n ", "i", "range(1, H+W+1)", "range", "1", "H+W+1", "H+W", "H", "W", "1", "fac.append(fac[-1] * i % MOD)", "fac.append", "fac", "append", "fac[-1] * i % MOD", "fac[-1] * i", "fac[-1]", "fac", "-1", "i", "MOD", "inv.append(pow(fac[-1], MOD - 2, MOD))", "inv.append", "inv", "append", "pow(fac[-1], MOD - 2, MOD)", "pow", "fac[-1]", "fac", "-1", "MOD - 2", "MOD", "2", "MOD", "ret = 0", "ret", "0", "for i in range(H-A) :\n ret += fac[i+B-1]*inv[i]*inv[B-1]*fac[H+W-i-B-2]*inv[H-i-1]*inv[W-B-1]%MOD\n ret %= MOD\n ", "i", "range(H-A)", "range", "H-A", "H", "A", "ret += fac[i+B-1]*inv[i]*inv[B-1]*fac[H+W-i-B-2]*inv[H-i-1]*inv[W-B-1]%MOD", "ret", "fac[i+B-1]*inv[i]*inv[B-1]*fac[H+W-i-B-2]*inv[H-i-1]*inv[W-B-1]%MOD", "fac[i+B-1]*inv[i]*inv[B-1]*fac[H+W-i-B-2]*inv[H-i-1]*inv[W-B-1]", "fac[i+B-1]*inv[i]*inv[B-1]*fac[H+W-i-B-2]*inv[H-i-1]", "fac[i+B-1]*inv[i]*inv[B-1]*fac[H+W-i-B-2]", "fac[i+B-1]*inv[i]*inv[B-1]", "fac[i+B-1]*inv[i]", "fac[i+B-1]", "fac", "i+B-1", "i+B", "i", "B", "1", "inv[i]", "inv", "i", "inv[B-1]", "inv", "B-1", "B", "1", "fac[H+W-i-B-2]", "fac", "H+W-i-B-2", "H+W-i-B", "H+W-i", "H+W", "H", "W", "i", "B", "2", "inv[H-i-1]", "inv", "H-i-1", "H-i", "H", "i", "1", "inv[W-B-1]", "inv", "W-B-1", "W-B", "W", "B", "1", "MOD", "ret %= MOD", "ret", "MOD", "print(ret)", "print", "ret", "ret %= MOD", "MOD", "ret", "A, B = map(int, input().split())", "map(int, input().split())", "A", "ret += fac[i+B-1]*inv[i]*inv[B-1]*fac[H+W-i-B-2]*inv[H-i-1]*inv[W-B-1]%MOD", "fac[i+B-1]*inv[i]*inv[B-1]*fac[H+W-i-B-2]*inv[H-i-1]*inv[W-B-1]%MOD", "ret", "W, A, B = map(int, input().split())", "map(int, input().split())", "W", "fac = [1]", "[1]", "fac", "ret = 0", "0", "ret", "H, W, A, B = map(int, input().split())", "map(int, input().split())", "H", "B = map(int, input().split())", "map(int, input().split())", "B", "MOD = 10 ** 9 + 7", "10 ** 9 + 7", "MOD", "inv = [1]", "[1]", "inv" ]

[ 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, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 12, 13, 0, 13, 17, 0, 13, 13, 28, 13, 4, 13, 17, 14, 2, 13, 13, 0, 13, 13, 0, 13, 13, 0, 13, 13, 0, 13, 13, 29, 13, 23, 13, 0, 13, 2, 39, 17, 2, 13, 13, 28, 13, 4, 13, 17, 2, 13, 13, 0, 18, 13, 13, 2, 2, 18, 13, 2, 13, 17, 13, 13, 0, 13, 17, 28, 13, 4, 13, 2, 13, 13, 0, 13, 2, 2, 18, 13, 2, 2, 13, 17, 13, 4, 13, 18, 13, 2, 13, 17, 4, 13, 18, 13, 13, 0, 13, 2, 2, 18, 13, 2, 2, 2, 13, 13, 17, 2, 2, 13, 17, 13, 4, 13, 18, 13, 2, 2, 13, 13, 17, 4, 13, 18, 13, 2, 2, 13, 17, 13, 0, 13, 2, 2, 13, 13, 13, 4, 13, 2, 13, 13, 10, 2, 13, 10, 4, 13, 10, 39, 13, 10, 2, 13, 10, 2, 13, 10, 17, 13, 10, 2, 13, 10, 4, 13, 10, 12, 13, 10, 4, 13, 10, 4, 13, 10, 2, 13 ]

[ [ 212, 2 ], [ 212, 11 ], [ 212, 12 ], [ 212, 13 ], [ 182, 15 ], [ 188, 22 ], [ 43, 42 ], [ 46, 45 ], [ 71, 46 ], [ 49, 48 ], [ 48, 54 ], [ 189, 55 ], [ 58, 57 ], [ 45, 58 ], [ 66, 58 ], [ 63, 58 ], [ 61, 60 ], [ 183, 61 ], [ 64, 63 ], [ 63, 64 ], [ 45, 64 ], [ 66, 64 ], [ 67, 66 ], [ 183, 67 ], [ 60, 69 ], [ 57, 69 ], [ 42, 69 ], [ 71, 71 ], [ 215, 73 ], [ 186, 78 ], [ 210, 79 ], [ 82, 81 ], [ 186, 86 ], [ 210, 87 ], [ 92, 89 ], [ 216, 90 ], [ 81, 91 ], [ 216, 95 ], [ 81, 97 ], [ 81, 99 ], [ 183, 100 ], [ 197, 102 ], [ 106, 105 ], [ 186, 109 ], [ 213, 110 ], [ 200, 112 ], [ 216, 116 ], [ 204, 119 ], [ 105, 121 ], [ 207, 123 ], [ 216, 125 ], [ 204, 127 ], [ 207, 130 ], [ 89, 131 ], [ 216, 132 ], [ 105, 133 ], [ 191, 135 ], [ 216, 139 ], [ 210, 143 ], [ 204, 144 ], [ 186, 148 ], [ 105, 150 ], [ 207, 152 ], [ 216, 154 ], [ 210, 157 ], [ 204, 158 ], [ 207, 161 ], [ 216, 163 ], [ 186, 166 ], [ 105, 168 ], [ 194, 170 ], [ 201, 173 ], [ 192, 174 ], [ 183, 175 ], [ 195, 179 ], [ 198, 179 ], [ 183, 180 ], [ 182, 183 ], [ 212, 186 ], [ 188, 189 ], [ 191, 192 ], [ 194, 195 ], [ 197, 198 ], [ 200, 201 ], [ 212, 204 ], [ 212, 210 ], [ 212, 213 ], [ 215, 216 ] ]

[ "H,W,A,B = map(int,input().split())\nMOD = (10**9)+7\nD = [0,2, 9, 11, 14, 15, 17, 19, 20, 23, 24, 25, 27, 28, 29]\n\ndef inv(a):\n ans = 1\n hoge = a\n for count in range(31):\n if (count) in D:\n ans *= hoge\n ans %= MOD\n hoge *= hoge\n hoge %= MOD\n return ans\n\ng = [1]*(H+W)\nfor i in range(1,H+W):\n g[i] = (g[i-1]*i%MOD)\nans = 0\nfor i in range(H-A):\n L = g[B-1+i]*inv(g[B-1])*inv(g[i])\n R = g[(W-B-1)+(H-1-i)]*inv(g[(W-B-1)])*inv(g[H-1-i])\n ans += L*R%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", "D = [0,2, 9, 11, 14, 15, 17, 19, 20, 23, 24, 25, 27, 28, 29]", "D", "[0,2, 9, 11, 14, 15, 17, 19, 20, 23, 24, 25, 27, 28, 29]", "0", "2", "9", "11", "14", "15", "17", "19", "20", "23", "24", "25", "27", "28", "29", "def inv(a):\n ans = 1\n hoge = a\n for count in range(31):\n if (count) in D:\n ans *= hoge\n ans %= MOD\n hoge *= hoge\n hoge %= MOD\n return ans", "inv", "ans = 1", "ans", "1", "hoge = a", "hoge", "a", "for count in range(31):\n if (count) in D:\n ans *= hoge\n ans %= MOD\n hoge *= hoge\n hoge %= MOD\n ", "count", "range(31)", "range", "31", "if (count) in D:\n ans *= hoge\n ans %= MOD\n ", "(count) in D", "count", "D", "ans *= hoge", "ans", "hoge", "ans %= MOD", "ans", "MOD", "hoge *= hoge", "hoge", "hoge", "hoge %= MOD", "hoge", "MOD", "return ans", "ans", "a", "a", "g = [1]*(H+W)", "g", "[1]*(H+W)", "[1]", "1", "H+W", "H", "W", "for i in range(1,H+W):\n g[i] = (g[i-1]*i%MOD)", "i", "range(1,H+W)", "range", "1", "H+W", "H", "W", "g[i] = (g[i-1]*i%MOD)", "g[i]", "g", "i", "g[i-1]*i%MOD", "g[i-1]*i", "g[i-1]", "g", "i-1", "i", "1", "i", "MOD", "ans = 0", "ans", "0", "for i in range(H-A):\n L = g[B-1+i]*inv(g[B-1])*inv(g[i])\n R = g[(W-B-1)+(H-1-i)]*inv(g[(W-B-1)])*inv(g[H-1-i])\n ans += L*R%MOD", "i", "range(H-A)", "range", "H-A", "H", "A", "L = g[B-1+i]*inv(g[B-1])*inv(g[i])", "L", "g[B-1+i]*inv(g[B-1])*inv(g[i])", "g[B-1+i]*inv(g[B-1])", "g[B-1+i]", "g", "B-1+i", "B-1", "B", "1", "i", "inv(g[B-1])", "inv", "g[B-1]", "g", "B-1", "B", "1", "inv(g[i])", "inv", "g[i]", "g", "i", "R = g[(W-B-1)+(H-1-i)]*inv(g[(W-B-1)])*inv(g[H-1-i])", "R", "g[(W-B-1)+(H-1-i)]*inv(g[(W-B-1)])*inv(g[H-1-i])", "g[(W-B-1)+(H-1-i)]*inv(g[(W-B-1)])", "g[(W-B-1)+(H-1-i)]", "g", "(W-B-1)+(H-1-i)", "W-B-1", "W-B", "W", "B", "1", "H-1-i", "H-1", "H", "1", "i", "inv(g[(W-B-1)])", "inv", "g[(W-B-1)]", "g", "W-B-1", "W-B", "W", "B", "1", "inv(g[H-1-i])", "inv", "g[H-1-i]", "g", "H-1-i", "H-1", "H", "1", "i", "ans += L*R%MOD", "ans", "L*R%MOD", "L*R", "L", "R", "MOD", "print(ans%MOD)", "print", "ans%MOD", "ans", "MOD", "MOD = (10**9)+7", "(10**9)+7", "MOD", "H,W,A,B = map(int,input().split())", "map(int,input().split())", "H", "D = [0,2, 9, 11, 14, 15, 17, 19, 20, 23, 24, 25, 27, 28, 29]", "[0,2, 9, 11, 14, 15, 17, 19, 20, 23, 24, 25, 27, 28, 29]", "D", "R = g[(W-B-1)+(H-1-i)]*inv(g[(W-B-1)])*inv(g[H-1-i])", "g[(W-B-1)+(H-1-i)]*inv(g[(W-B-1)])*inv(g[H-1-i])", "R", "ans += L*R%MOD", "L*R%MOD", "ans", "ans = 0", "0", "ans", "L = g[B-1+i]*inv(g[B-1])*inv(g[i])", "g[B-1+i]*inv(g[B-1])*inv(g[i])", "L", "B = map(int,input().split())", "map(int,input().split())", "B", "def inv(a):\n ans = 1\n hoge = a\n for count in range(31):\n if (count) in D:\n ans *= hoge\n ans %= MOD\n hoge *= hoge\n hoge %= MOD\n return ans", "def inv(a):\n ans = 1\n hoge = a\n for count in range(31):\n if (count) in D:\n ans *= hoge\n ans %= MOD\n hoge *= hoge\n hoge %= MOD\n return ans", "inv", "W,A,B = map(int,input().split())", "map(int,input().split())", "W", "A,B = map(int,input().split())", "map(int,input().split())", "A", "g = [1]*(H+W)", "[1]*(H+W)", "g" ]

[ 7, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 13, 13, 0, 13, 2, 2, 17, 17, 17, 0, 13, 2, 39, 17, 17, 28, 13, 4, 13, 17, 17, 0, 18, 13, 13, 2, 2, 18, 13, 2, 13, 17, 13, 13, 12, 13, 14, 2, 13, 13, 29, 17, 14, 2, 2, 13, 17, 2, 13, 13, 29, 17, 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, 2, 13, 13, 0, 13, 2, 2, 4, 13, 13, 2, 2, 13, 13, 17, 4, 13, 2, 2, 13, 13, 17, 2, 2, 2, 2, 13, 13, 17, 13, 13, 13, 0, 13, 13, 4, 13, 13, 10, 12, 13, 10, 4, 13, 10, 2, 13, 10, 4, 13, 10, 17, 13, 10, 2, 13, 10, 4, 13, 10, 4, 13, 10, 13, 13, 10, 2, 13 ]

[ [ 163, 2 ], [ 163, 11 ], [ 163, 12 ], [ 163, 13 ], [ 148, 15 ], [ 157, 22 ], [ 29, 28 ], [ 37, 34 ], [ 158, 35 ], [ 28, 36 ], [ 158, 40 ], [ 28, 42 ], [ 28, 44 ], [ 149, 45 ], [ 95, 50 ], [ 93, 51 ], [ 93, 57 ], [ 95, 60 ], [ 93, 61 ], [ 158, 69 ], [ 95, 70 ], [ 158, 74 ], [ 93, 75 ], [ 149, 77 ], [ 149, 79 ], [ 158, 83 ], [ 95, 85 ], [ 93, 86 ], [ 149, 88 ], [ 149, 90 ], [ 149, 91 ], [ 93, 93 ], [ 95, 95 ], [ 154, 97 ], [ 101, 100 ], [ 146, 104 ], [ 152, 105 ], [ 169, 107 ], [ 143, 111 ], [ 100, 112 ], [ 100, 115 ], [ 164, 116 ], [ 143, 119 ], [ 161, 122 ], [ 164, 123 ], [ 161, 129 ], [ 146, 130 ], [ 100, 132 ], [ 164, 133 ], [ 149, 134 ], [ 166, 136 ], [ 149, 137 ], [ 167, 140 ], [ 170, 140 ], [ 155, 140 ], [ 163, 146 ], [ 148, 149 ], [ 163, 152 ], [ 154, 155 ], [ 157, 158 ], [ 163, 161 ], [ 163, 164 ], [ 149, 166 ], [ 166, 167 ], [ 169, 170 ] ]

[ "h, w, a, b = map(int, input().split())\n\nMOD = 10 ** 9 + 7\nf = [1] * 300005\nfor i in range(2, 300005):\n f[i] = (f[i - 1] * i) % MOD\n\ndef comb(k, n):\n if n < k:\n return 0\n if k == 0 or n == k:\n return 1\n return (f[n] * pow(f[k], MOD - 2, MOD) * pow(f[n - k], MOD - 2, MOD)) % MOD\n\nans = 0\nfor i in range(h - a):\n ans += comb(i, i + b - 1) * comb(w - b - 1, w + h - 2 - i - b) % MOD\n ans %= MOD\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", "f = [1] * 300005", "f", "[1] * 300005", "[1]", "1", "300005", "for i in range(2, 300005):\n f[i] = (f[i - 1] * i) % MOD", "i", "range(2, 300005)", "range", "2", "300005", "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", "def comb(k, n):\n if n < k:\n return 0\n if k == 0 or n == k:\n return 1\n return (f[n] * pow(f[k], MOD - 2, MOD) * pow(f[n - k], MOD - 2, MOD)) % MOD", "comb", "if n < k:\n return 0\n ", "n < k", "n", "k", "return 0", "0", "if k == 0 or n == k:\n return 1\n ", "k == 0 or n == k", "k == 0", "k", "0", "n == k", "n", "k", "return 1", "1", "return (f[n] * pow(f[k], MOD - 2, MOD) * pow(f[n - k], MOD - 2, MOD)) % MOD", "(f[n] * pow(f[k], MOD - 2, MOD) * pow(f[n - k], MOD - 2, MOD)) % MOD", "f[n] * pow(f[k], MOD - 2, MOD) * pow(f[n - k], MOD - 2, MOD)", "f[n] * pow(f[k], MOD - 2, MOD)", "f[n]", "f", "n", "pow(f[k], MOD - 2, MOD)", "pow", "f[k]", "f", "k", "MOD - 2", "MOD", "2", "MOD", "pow(f[n - k], MOD - 2, MOD)", "pow", "f[n - k]", "f", "n - k", "n", "k", "MOD - 2", "MOD", "2", "MOD", "MOD", "k", "k", "n", "n", "ans = 0", "ans", "0", "for i in range(h - a):\n ans += comb(i, i + b - 1) * comb(w - b - 1, w + h - 2 - i - b) % MOD\n ans %= MOD", "i", "range(h - a)", "range", "h - a", "h", "a", "ans += comb(i, i + b - 1) * comb(w - b - 1, w + h - 2 - i - b) % MOD", "ans", "comb(i, i + b - 1) * comb(w - b - 1, w + h - 2 - i - b) % MOD", "comb(i, i + b - 1) * comb(w - b - 1, w + h - 2 - i - b)", "comb(i, i + b - 1)", "comb", "i", "i + b - 1", "i + b", "i", "b", "1", "comb(w - b - 1, w + h - 2 - i - b)", "comb", "w - b - 1", "w - b", "w", "b", "1", "w + h - 2 - i - b", "w + h - 2 - i", "w + h - 2", "w + h", "w", "h", "2", "i", "b", "MOD", "ans %= MOD", "ans", "MOD", "print(ans)", "print", "ans", "def comb(k, n):\n if n < k:\n return 0\n if k == 0 or n == k:\n return 1\n return (f[n] * pow(f[k], MOD - 2, MOD) * pow(f[n - k], MOD - 2, MOD)) % MOD", "def comb(k, n):\n if n < k:\n return 0\n if k == 0 or n == k:\n return 1\n return (f[n] * pow(f[k], MOD - 2, MOD) * pow(f[n - k], MOD - 2, MOD)) % MOD", "comb", "h, w, a, b = map(int, input().split())", "map(int, input().split())", "h", "MOD = 10 ** 9 + 7", "10 ** 9 + 7", "MOD", "a, b = map(int, input().split())", "map(int, input().split())", "a", "ans = 0", "0", "ans", "f = [1] * 300005", "[1] * 300005", "f", "w, a, b = map(int, input().split())", "map(int, input().split())", "w", "b = map(int, input().split())", "map(int, input().split())", "b", "ans %= MOD", "MOD", "ans", "ans += comb(i, i + b - 1) * comb(w - b - 1, w + h - 2 - i - b) % MOD", "comb(i, i + b - 1) * comb(w - b - 1, w + h - 2 - i - b) % MOD", "ans" ]

[ 7, 15, 13, 15, 13, 15, 13, 15, 13, 15, 13, 15, 15, 15, 15, 15, 15, 4, 18, 13, 13, 17, 12, 13, 29, 4, 13, 4, 13, 12, 13, 29, 4, 13, 4, 13, 13, 4, 18, 4, 13, 13, 12, 13, 29, 4, 13, 4, 13, 12, 13, 29, 4, 13, 4, 13, 13, 4, 18, 4, 13, 13, 12, 13, 29, 4, 18, 4, 13, 13, 12, 13, 29, 4, 13, 4, 13, 13, 4, 18, 4, 13, 13, 12, 13, 4, 13, 31, 13, 0, 13, 18, 13, 13, 23, 12, 13, 15, 13, 12, 13, 0, 13, 4, 18, 13, 13, 0, 13, 4, 13, 31, 13, 32, 13, 0, 13, 4, 18, 13, 13, 4, 13, 2, 13, 13, 17, 29, 13, 23, 16, 29, 13, 23, 13, 0, 13, 17, 12, 13, 14, 2, 2, 13, 17, 2, 13, 13, 29, 17, 14, 2, 13, 17, 29, 13, 14, 2, 39, 13, 13, 13, 29, 18, 13, 39, 13, 13, 0, 18, 13, 39, 13, 13, 2, 4, 13, 2, 13, 17, 13, 4, 13, 2, 13, 17, 2, 13, 17, 29, 18, 13, 39, 13, 13, 23, 13, 23, 13, 0, 13, 2, 2, 17, 17, 17, 0, 13, 2, 17, 17, 0, 13, 39, 17, 17, 0, 13, 39, 17, 17, 0, 13, 39, 17, 17, 28, 13, 4, 13, 17, 2, 13, 17, 4, 18, 13, 13, 2, 2, 18, 13, 17, 13, 13, 4, 18, 13, 13, 2, 2, 40, 18, 13, 2, 13, 13, 2, 13, 13, 13, 4, 18, 13, 13, 2, 2, 18, 13, 17, 18, 13, 17, 13, 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, 12, 13, 0, 13, 2, 2, 17, 17, 17, 0, 13, 17, 28, 13, 4, 13, 2, 13, 13, 0, 13, 4, 13, 2, 13, 2, 13, 17, 13, 0, 13, 4, 13, 2, 2, 2, 13, 13, 17, 2, 2, 13, 13, 17, 2, 2, 13, 13, 17, 0, 13, 2, 13, 13, 0, 13, 13, 29, 2, 13, 13, 23, 13, 23, 13, 23, 13, 23, 13, 0, 13, 13, 13, 12, 13, 0, 13, 4, 13, 13, 13, 13, 4, 13, 4, 13, 13, 13, 13, 13, 14, 2, 13, 17, 4, 13, 10, 12, 13, 10, 12, 13, 10, 12, 13, 10, 2, 13, 10, 17, 13, 10, 2, 13, 10, 12, 13, 10, 12, 13, 10, 39, 13, 10, 12, 13, 10, 12, 13, 10, 12, 13, 10, 12, 13, 10, 12, 13, 10, 39, 13, 10, 39, 13, 10, 12, 13, 10, 12, 13 ]

[ [ 91, 90 ], [ 103, 102 ], [ 109, 108 ], [ 134, 110 ], [ 117, 116 ], [ 463, 122 ], [ 116, 124 ], [ 102, 125 ], [ 108, 128 ], [ 100, 132 ], [ 134, 134 ], [ 423, 136 ], [ 198, 143 ], [ 198, 146 ], [ 196, 147 ], [ 198, 152 ], [ 196, 155 ], [ 424, 161 ], [ 424, 164 ], [ 174, 169 ], [ 424, 170 ], [ 196, 178 ], [ 198, 180 ], [ 196, 184 ], [ 198, 187 ], [ 424, 191 ], [ 196, 196 ], [ 198, 198 ], [ 420, 200 ], [ 426, 207 ], [ 456, 212 ], [ 435, 217 ], [ 453, 222 ], [ 228, 227 ], [ 427, 232 ], [ 457, 236 ], [ 457, 241 ], [ 227, 243 ], [ 421, 244 ], [ 454, 247 ], [ 454, 253 ], [ 421, 255 ], [ 227, 256 ], [ 421, 258 ], [ 227, 259 ], [ 421, 260 ], [ 436, 263 ], [ 436, 268 ], [ 454, 271 ], [ 421, 273 ], [ 313, 279 ], [ 313, 282 ], [ 311, 283 ], [ 288, 287 ], [ 313, 290 ], [ 311, 292 ], [ 313, 293 ], [ 457, 299 ], [ 311, 300 ], [ 436, 302 ], [ 287, 303 ], [ 313, 303 ], [ 436, 305 ], [ 311, 307 ], [ 287, 308 ], [ 313, 308 ], [ 421, 309 ], [ 311, 311 ], [ 313, 313 ], [ 418, 315 ], [ 318, 317 ], [ 325, 324 ], [ 328, 327 ], [ 378, 331 ], [ 382, 332 ], [ 335, 334 ], [ 415, 336 ], [ 327, 338 ], [ 380, 340 ], [ 327, 342 ], [ 345, 344 ], [ 415, 346 ], [ 378, 350 ], [ 327, 351 ], [ 376, 355 ], [ 380, 356 ], [ 376, 360 ], [ 380, 361 ], [ 365, 364 ], [ 334, 366 ], [ 344, 367 ], [ 370, 369 ], [ 317, 370 ], [ 421, 370 ], [ 369, 373 ], [ 364, 373 ], [ 324, 373 ], [ 317, 374 ], [ 421, 374 ], [ 376, 376 ], [ 378, 378 ], [ 380, 380 ], [ 382, 382 ], [ 418, 384 ], [ 412, 385 ], [ 418, 386 ], [ 391, 390 ], [ 430, 392 ], [ 391, 393 ], [ 391, 394 ], [ 391, 395 ], [ 418, 399 ], [ 390, 400 ], [ 393, 401 ], [ 394, 402 ], [ 395, 403 ], [ 460, 409 ], [ 418, 418 ], [ 420, 421 ], [ 423, 424 ], [ 426, 427 ], [ 435, 436 ], [ 453, 454 ], [ 456, 457 ] ]

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

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

[ [ 326, 2 ], [ 326, 11 ], [ 326, 12 ], [ 326, 13 ], [ 278, 15 ], [ 281, 18 ], [ 296, 21 ], [ 308, 25 ], [ 37, 33 ], [ 37, 34 ], [ 39, 35 ], [ 37, 37 ], [ 39, 39 ], [ 90, 44 ], [ 86, 47 ], [ 50, 49 ], [ 86, 52 ], [ 86, 53 ], [ 279, 54 ], [ 57, 56 ], [ 90, 59 ], [ 57, 61 ], [ 61, 64 ], [ 49, 69 ], [ 88, 70 ], [ 56, 71 ], [ 74, 73 ], [ 49, 77 ], [ 88, 78 ], [ 56, 79 ], [ 86, 80 ], [ 73, 83 ], [ 279, 84 ], [ 86, 86 ], [ 88, 88 ], [ 90, 90 ], [ 96, 95 ], [ 170, 96 ], [ 99, 98 ], [ 103, 102 ], [ 95, 107 ], [ 111, 110 ], [ 98, 114 ], [ 102, 116 ], [ 102, 118 ], [ 279, 119 ], [ 98, 122 ], [ 110, 124 ], [ 127, 126 ], [ 95, 129 ], [ 137, 134 ], [ 126, 135 ], [ 95, 136 ], [ 303, 138 ], [ 98, 140 ], [ 95, 141 ], [ 279, 143 ], [ 147, 146 ], [ 95, 151 ], [ 158, 155 ], [ 126, 156 ], [ 146, 157 ], [ 126, 161 ], [ 146, 163 ], [ 146, 166 ], [ 279, 168 ], [ 170, 170 ], [ 207, 176 ], [ 205, 179 ], [ 207, 180 ], [ 205, 183 ], [ 282, 184 ], [ 187, 186 ], [ 297, 190 ], [ 205, 191 ], [ 309, 193 ], [ 207, 194 ], [ 309, 196 ], [ 205, 198 ], [ 207, 199 ], [ 186, 202 ], [ 279, 203 ], [ 205, 205 ], [ 207, 207 ], [ 306, 209 ], [ 217, 216 ], [ 220, 219 ], [ 285, 223 ], [ 216, 225 ], [ 229, 225 ], [ 219, 226 ], [ 231, 226 ], [ 216, 227 ], [ 229, 227 ], [ 229, 229 ], [ 231, 231 ], [ 317, 233 ], [ 237, 236 ], [ 291, 242 ], [ 294, 243 ], [ 287, 246 ], [ 300, 248 ], [ 236, 249 ], [ 276, 250 ], [ 320, 252 ], [ 300, 254 ], [ 291, 257 ], [ 236, 258 ], [ 327, 261 ], [ 276, 262 ], [ 323, 264 ], [ 288, 266 ], [ 321, 267 ], [ 314, 269 ], [ 279, 270 ], [ 315, 273 ], [ 324, 273 ], [ 318, 273 ], [ 326, 276 ], [ 278, 279 ], [ 281, 282 ], [ 287, 288 ], [ 326, 291 ], [ 326, 294 ], [ 296, 297 ], [ 308, 309 ], [ 279, 314 ], [ 314, 315 ], [ 317, 318 ], [ 320, 321 ], [ 323, 324 ], [ 326, 327 ] ]

[ "#!/usr/bin/env python3.4\n# -*- coding: utf-8 -*-\n\n# arc058_b\n\n# input\nH, W, A, B = map(int, input().split())\nmod = 1000000007\n# fermat\nN = 0\nfac = [1]\ninv = [1]\n\ndef mypow(a, b):\n return _mypow(a, a, b)\n\ndef _mypow(p, a, b):\n if b == 1:\n return p\n n = (p*p) % mod\n c, r = divmod(b, 2)\n if r == 0:\n return _mypow(n, a, c)\n else:\n ret = _mypow(n, a, c) * p\n return ret % mod\n\ndef init_cmb(_N):\n global N, fac, inv\n N=_N\n fac = [1]\n for i in range(1, N+1):\n n = (fac[i-1] * i) % mod\n fac.append(n)\n inv = (N+1) * [1]\n inv[N] = mypow(fac[N], mod-2)\n for i in range(1, N)[::-1]:\n inv[i] = (inv[i+1] * (i+1)) % mod\n\ndef cmb(n, r):\n if (r<0 or n<r): raise Exception(n, r)\n if n>N: raise Exception(n)\n ret = fac[n] * inv[r] * inv[n-r]\n return ret % mod\ninit_cmb(100000*2)\n# getans\ndef calc(h, w):\n h += -1\n w += -1\n return cmb(h+w, h)\nans = 0\nfor y in range(1, H-A+1):\n left = calc(y, B)\n right = calc((H-y+1), (W-B))\n ans += left*right\n ans %= mod\n# output\nprint(ans)", "H, W, A, B = map(int, input().split())", "H", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "W", "A", "B", "mod = 1000000007", "mod", "1000000007", "N = 0", "N", "0", "fac = [1]", "fac", "[1]", "1", "inv = [1]", "inv", "[1]", "1", "def mypow(a, b):\n return _mypow(a, a, b)", "mypow", "return _mypow(a, a, b)", "_mypow(a, a, b)", "_mypow", "a", "a", "b", "a", "a", "b", "b", "def _mypow(p, a, b):\n if b == 1:\n return p\n n = (p*p) % mod\n c, r = divmod(b, 2)\n if r == 0:\n return _mypow(n, a, c)\n else:\n ret = _mypow(n, a, c) * p\n return ret % mod", "_mypow", "if b == 1:\n return p\n ", "b == 1", "b", "1", "return p", "p", "n = (p*p) % mod", "n", "(p*p) % mod", "p*p", "p", "p", "mod", "c, r = divmod(b, 2)", "c", "divmod(b, 2)", "divmod", "b", "2", "r", "if r == 0:\n return _mypow(n, a, c)\n else:\n ret = _mypow(n, a, c) * p\n return ret % mod", "r == 0", "r", "0", "return _mypow(n, a, c)", "_mypow(n, a, c)", "_mypow", "n", "a", "c", "ret = _mypow(n, a, c) * p", "ret", "_mypow(n, a, c) * p", "_mypow(n, a, c)", "_mypow", "n", "a", "c", "p", "return ret % mod", "ret % mod", "ret", "mod", "p", "p", "a", "a", "b", "b", "def init_cmb(_N):\n global N, fac, inv\n N=_N\n fac = [1]\n for i in range(1, N+1):\n n = (fac[i-1] * i) % mod\n fac.append(n)\n inv = (N+1) * [1]\n inv[N] = mypow(fac[N], mod-2)\n for i in range(1, N)[::-1]:\n inv[i] = (inv[i+1] * (i+1)) % mod", "init_cmb", "global N, fac, inv", "N=_N", "N", "_N", "fac = [1]", "fac", "[1]", "1", "for i in range(1, N+1):\n n = (fac[i-1] * i) % mod\n fac.append(n)\n ", "i", "range(1, N+1)", "range", "1", "N+1", "N", "1", "n = (fac[i-1] * i) % mod", "n", "(fac[i-1] * i) % mod", "fac[i-1] * i", "fac[i-1]", "fac", "i-1", "i", "1", "i", "mod", "fac.append(n)", "fac.append", "fac", "append", "n", "inv = (N+1) * [1]", "inv", "(N+1) * [1]", "N+1", "N", "1", "[1]", "1", "inv[N] = mypow(fac[N], mod-2)", "inv[N]", "inv", "N", "mypow(fac[N], mod-2)", "mypow", "fac[N]", "fac", "N", "mod-2", "mod", "2", "for i in range(1, N)[::-1]:\n inv[i] = (inv[i+1] * (i+1)) % mod", "i", "range(1, N)[::-1]", "(1, N)", "range", "1", "N", "::-1", "-1", "inv[i] = (inv[i+1] * (i+1)) % mod", "inv[i]", "inv", "i", "(inv[i+1] * (i+1)) % mod", "inv[i+1] * (i+1)", "inv[i+1]", "inv", "i+1", "i", "1", "i+1", "i", "1", "mod", "_N", "_N", "def cmb(n, r):\n if (r<0 or n<r): raise Exception(n, r)\n if n>N: raise Exception(n)\n ret = fac[n] * inv[r] * inv[n-r]\n return ret % mod", "cmb", "if (r<0 or n<r): raise Exception(n, r)\n ", "r<0 or n<r", "r<0", "r", "0", "n<r", "n", "r", "if n>N: raise Exception(n)\n ", "n>N", "n", "N", "ret = fac[n] * inv[r] * inv[n-r]", "ret", "fac[n] * inv[r] * inv[n-r]", "fac[n] * inv[r]", "fac[n]", "fac", "n", "inv[r]", "inv", "r", "inv[n-r]", "inv", "n-r", "n", "r", "return ret % mod", "ret % mod", "ret", "mod", "n", "n", "r", "r", "init_cmb(100000*2)", "init_cmb", "100000*2", "100000", "2", "def calc(h, w):\n h += -1\n w += -1\n return cmb(h+w, h)", "calc", "h += -1", "h", "-1", "w += -1", "w", "-1", "return cmb(h+w, h)", "cmb(h+w, h)", "cmb", "h+w", "h", "w", "h", "h", "h", "w", "w", "ans = 0", "ans", "0", "for y in range(1, H-A+1):\n left = calc(y, B)\n right = calc((H-y+1), (W-B))\n ans += left*right\n ans %= mod\n# output", "y", "range(1, H-A+1)", "range", "1", "H-A+1", "H-A", "H", "A", "1", "left = calc(y, B)", "left", "calc(y, B)", "calc", "y", "B", "right = calc((H-y+1), (W-B))", "right", "calc((H-y+1), (W-B))", "calc", "H-y+1", "H-y", "H", "y", "1", "W-B", "W", "B", "ans += left*right", "ans", "left*right", "left", "right", "ans %= mod", "ans", "mod", "print(ans)", "print", "ans", "B = map(int, input().split())", "map(int, input().split())", "B", "mod = 1000000007", "1000000007", "mod", "N = 0", "0", "N", "def cmb(n, r):\n if (r<0 or n<r): raise Exception(n, r)\n if n>N: raise Exception(n)\n ret = fac[n] * inv[r] * inv[n-r]\n return ret % mod", "def cmb(n, r):\n if (r<0 or n<r): raise Exception(n, r)\n if n>N: raise Exception(n)\n ret = fac[n] * inv[r] * inv[n-r]\n return ret % mod", "cmb", "left = calc(y, B)", "calc(y, B)", "left", "H, W, A, B = map(int, input().split())", "map(int, input().split())", "H", "A, B = map(int, input().split())", "map(int, input().split())", "A", "fac = [1]", "[1]", "fac", "def calc(h, w):\n h += -1\n w += -1\n return cmb(h+w, h)", "def calc(h, w):\n h += -1\n w += -1\n return cmb(h+w, h)", "calc", "def mypow(a, b):\n return _mypow(a, a, b)", "def mypow(a, b):\n return _mypow(a, a, b)", "mypow", "def init_cmb(_N):\n global N, fac, inv\n N=_N\n fac = [1]\n for i in range(1, N+1):\n n = (fac[i-1] * i) % mod\n fac.append(n)\n inv = (N+1) * [1]\n inv[N] = mypow(fac[N], mod-2)\n for i in range(1, N)[::-1]:\n inv[i] = (inv[i+1] * (i+1)) % mod", "def init_cmb(_N):\n global N, fac, inv\n N=_N\n fac = [1]\n for i in range(1, N+1):\n n = (fac[i-1] * i) % mod\n fac.append(n)\n inv = (N+1) * [1]\n inv[N] = mypow(fac[N], mod-2)\n for i in range(1, N)[::-1]:\n inv[i] = (inv[i+1] * (i+1)) % mod", "init_cmb", "inv = [1]", "[1]", "inv", "def _mypow(p, a, b):\n if b == 1:\n return p\n n = (p*p) % mod\n c, r = divmod(b, 2)\n if r == 0:\n return _mypow(n, a, c)\n else:\n ret = _mypow(n, a, c) * p\n return ret % mod", "def _mypow(p, a, b):\n if b == 1:\n return p\n n = (p*p) % mod\n c, r = divmod(b, 2)\n if r == 0:\n return _mypow(n, a, c)\n else:\n ret = _mypow(n, a, c) * p\n return ret % mod", "_mypow", "ans %= mod", "mod", "ans", "ans = 0", "0", "ans", "right = calc((H-y+1), (W-B))", "calc((H-y+1), (W-B))", "right", "ans += left*right", "left*right", "ans", "W, A, B = map(int, input().split())", "map(int, input().split())", "W" ]

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

[ [ 5, 4 ], [ 8, 7 ], [ 12, 11 ], [ 76, 16 ], [ 20, 19 ], [ 11, 20 ], [ 23, 22 ], [ 78, 23 ], [ 7, 26 ], [ 22, 28 ], [ 19, 28 ], [ 4, 28 ], [ 31, 30 ], [ 22, 33 ], [ 19, 33 ], [ 4, 33 ], [ 78, 35 ], [ 78, 37 ], [ 40, 39 ], [ 76, 44 ], [ 50, 47 ], [ 39, 48 ], [ 76, 49 ], [ 30, 50 ], [ 53, 52 ], [ 76, 55 ], [ 60, 59 ], [ 52, 60 ], [ 63, 62 ], [ 78, 63 ], [ 70, 65 ], [ 39, 66 ], [ 52, 68 ], [ 62, 70 ], [ 59, 70 ], [ 30, 70 ], [ 76, 76 ], [ 78, 78 ], [ 230, 80 ], [ 230, 89 ], [ 230, 90 ], [ 230, 91 ], [ 212, 93 ], [ 206, 100 ], [ 204, 102 ], [ 219, 104 ], [ 222, 105 ], [ 213, 106 ], [ 206, 107 ], [ 209, 109 ], [ 191, 112 ], [ 207, 114 ], [ 195, 116 ], [ 215, 119 ], [ 207, 121 ], [ 222, 124 ], [ 195, 125 ], [ 129, 128 ], [ 219, 132 ], [ 231, 133 ], [ 224, 135 ], [ 198, 140 ], [ 195, 143 ], [ 128, 145 ], [ 192, 146 ], [ 207, 148 ], [ 128, 149 ], [ 213, 150 ], [ 200, 152 ], [ 198, 157 ], [ 219, 163 ], [ 128, 165 ], [ 222, 166 ], [ 195, 167 ], [ 207, 170 ], [ 219, 173 ], [ 128, 175 ], [ 216, 176 ], [ 213, 177 ], [ 227, 179 ], [ 210, 182 ], [ 228, 182 ], [ 225, 184 ], [ 201, 185 ], [ 213, 186 ], [ 228, 189 ], [ 210, 189 ], [ 191, 192 ], [ 230, 195 ], [ 206, 198 ], [ 200, 201 ], [ 206, 207 ], [ 209, 210 ], [ 212, 213 ], [ 215, 216 ], [ 230, 219 ], [ 230, 222 ], [ 224, 225 ], [ 227, 228 ], [ 230, 231 ] ]

[ "def prepare(n, MOD):\n f = 1\n factorials = [1]\n for m in range(1, n + 1):\n f *= m\n f %= MOD\n factorials.append(f)\n inv = pow(f, MOD - 2, MOD)\n invs = [1] * (n + 1)\n invs[n] = inv\n for m in range(n, 1, -1):\n inv *= m\n inv %= MOD\n invs[m - 1] = inv\n return factorials, invs\n\n\nh, w, a, b = map(int, input().split())\nMOD = 10 ** 9 + 7\nfacts, invs = prepare(h + w, MOD)\nans = 0\nib = invs[b - 1]\niwb = invs[w - b - 1]\nfor down in range(h - a):\n left_pattern = facts[b - 1 + down] * ib * invs[down] % MOD\n right_pattern = facts[h - 1 - down + w - b - 1] * invs[h - 1 - down] * iwb % MOD\n ans = (ans + left_pattern * right_pattern) % MOD\nprint(ans)", "def prepare(n, MOD):\n f = 1\n factorials = [1]\n for m in range(1, n + 1):\n f *= m\n f %= MOD\n factorials.append(f)\n inv = pow(f, MOD - 2, MOD)\n invs = [1] * (n + 1)\n invs[n] = inv\n for m in range(n, 1, -1):\n inv *= m\n inv %= MOD\n invs[m - 1] = inv\n return factorials, invs", "prepare", "f = 1", "f", "1", "factorials = [1]", "factorials", "[1]", "1", "for m in range(1, n + 1):\n f *= m\n f %= MOD\n factorials.append(f)\n ", "m", "range(1, n + 1)", "range", "1", "n + 1", "n", "1", "f *= m", "f", "m", "f %= MOD", "f", "MOD", "factorials.append(f)", "factorials.append", "factorials", "append", "f", "inv = pow(f, MOD - 2, MOD)", "inv", "pow(f, MOD - 2, MOD)", "pow", "f", "MOD - 2", "MOD", "2", "MOD", "invs = [1] * (n + 1)", "invs", "[1] * (n + 1)", "[1]", "1", "n + 1", "n", "1", "invs[n] = inv", "invs[n]", "invs", "n", "inv", "for m in range(n, 1, -1):\n inv *= m\n inv %= MOD\n invs[m - 1] = inv\n ", "m", "range(n, 1, -1)", "range", "n", "1", "-1", "inv *= m", "inv", "m", "inv %= MOD", "inv", "MOD", "invs[m - 1] = inv", "invs[m - 1]", "invs", "m - 1", "m", "1", "inv", "return factorials, invs", "return factorials, invs", "factorials", "invs", "n", "n", "MOD", "MOD", "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", "facts, invs = prepare(h + w, MOD)", "facts", "prepare(h + w, MOD)", "prepare", "h + w", "h", "w", "MOD", "invs", "ans = 0", "ans", "0", "ib = invs[b - 1]", "ib", "invs[b - 1]", "invs", "b - 1", "b", "1", "iwb = invs[w - b - 1]", "iwb", "invs[w - b - 1]", "invs", "w - b - 1", "w - b", "w", "b", "1", "for down in range(h - a):\n left_pattern = facts[b - 1 + down] * ib * invs[down] % MOD\n right_pattern = facts[h - 1 - down + w - b - 1] * invs[h - 1 - down] * iwb % MOD\n ans = (ans + left_pattern * right_pattern) % MOD", "down", "range(h - a)", "range", "h - a", "h", "a", "left_pattern = facts[b - 1 + down] * ib * invs[down] % MOD", "left_pattern", "facts[b - 1 + down] * ib * invs[down] % MOD", "facts[b - 1 + down] * ib * invs[down]", "facts[b - 1 + down] * ib", "facts[b - 1 + down]", "facts", "b - 1 + down", "b - 1", "b", "1", "down", "ib", "invs[down]", "invs", "down", "MOD", "right_pattern = facts[h - 1 - down + w - b - 1] * invs[h - 1 - down] * iwb % MOD", "right_pattern", "facts[h - 1 - down + w - b - 1] * invs[h - 1 - down] * iwb % MOD", "facts[h - 1 - down + w - b - 1] * invs[h - 1 - down] * iwb", "facts[h - 1 - down + w - b - 1] * invs[h - 1 - down]", "facts[h - 1 - down + w - b - 1]", "facts", "h - 1 - down + w - b - 1", "h - 1 - down + w - b", "h - 1 - down + w", "h - 1 - down", "h - 1", "h", "1", "down", "w", "b", "1", "invs[h - 1 - down]", "invs", "h - 1 - down", "h - 1", "h", "1", "down", "iwb", "MOD", "ans = (ans + left_pattern * right_pattern) % MOD", "ans", "(ans + left_pattern * right_pattern) % MOD", "ans + left_pattern * right_pattern", "ans", "left_pattern * right_pattern", "left_pattern", "right_pattern", "MOD", "print(ans)", "print", "ans", "ib = invs[b - 1]", "invs[b - 1]", "ib", "b = map(int, input().split())", "map(int, input().split())", "b", "facts, invs = prepare(h + w, MOD)", "prepare(h + w, MOD)", "facts", "right_pattern = facts[h - 1 - down + w - b - 1] * invs[h - 1 - down] * iwb % MOD", "facts[h - 1 - down + w - b - 1] * invs[h - 1 - down] * iwb % MOD", "right_pattern", "def prepare(n, MOD):\n f = 1\n factorials = [1]\n for m in range(1, n + 1):\n f *= m\n f %= MOD\n factorials.append(f)\n inv = pow(f, MOD - 2, MOD)\n invs = [1] * (n + 1)\n invs[n] = inv\n for m in range(n, 1, -1):\n inv *= m\n inv %= MOD\n invs[m - 1] = inv\n return factorials, invs", "def prepare(n, MOD):\n f = 1\n factorials = [1]\n for m in range(1, n + 1):\n f *= m\n f %= MOD\n factorials.append(f)\n inv = pow(f, MOD - 2, MOD)\n invs = [1] * (n + 1)\n invs[n] = inv\n for m in range(n, 1, -1):\n inv *= m\n inv %= MOD\n invs[m - 1] = inv\n return factorials, invs", "prepare", "invs = prepare(h + w, MOD)", "prepare(h + w, MOD)", "invs", "ans = 0", "0", "ans", "MOD = 10 ** 9 + 7", "10 ** 9 + 7", "MOD", "iwb = invs[w - b - 1]", "invs[w - b - 1]", "iwb", "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", "left_pattern = facts[b - 1 + down] * ib * invs[down] % MOD", "facts[b - 1 + down] * ib * invs[down] % MOD", "left_pattern", "ans = (ans + left_pattern * right_pattern) % MOD", "(ans + left_pattern * right_pattern) % MOD", "ans", "a, b = map(int, input().split())", "map(int, input().split())", "a" ]

[ 7, 15, 13, 12, 13, 14, 2, 2, 2, 13, 17, 2, 13, 17, 2, 13, 13, 29, 17, 29, 2, 2, 2, 18, 13, 13, 18, 13, 13, 18, 13, 2, 13, 13, 13, 23, 13, 23, 13, 23, 13, 23, 13, 23, 13, 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, 2, 17, 17, 17, 0, 13, 2, 2, 13, 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, 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, 13, 17, 28, 13, 4, 13, 2, 13, 17, 2, 13, 17, 0, 13, 2, 2, 2, 13, 13, 13, 17, 0, 13, 2, 13, 17, 0, 13, 4, 13, 13, 13, 13, 13, 13, 0, 13, 2, 2, 2, 13, 17, 13, 13, 0, 13, 2, 13, 17, 0, 13, 4, 13, 13, 13, 13, 13, 13, 0, 13, 2, 2, 13, 13, 13, 29, 2, 13, 13, 14, 2, 13, 17, 4, 13, 4, 13, 10, 12, 13, 10, 12, 13 ]

[ [ 36, 9 ], [ 38, 12 ], [ 36, 15 ], [ 38, 16 ], [ 42, 24 ], [ 36, 25 ], [ 44, 27 ], [ 38, 28 ], [ 44, 30 ], [ 36, 32 ], [ 38, 33 ], [ 40, 34 ], [ 36, 36 ], [ 38, 38 ], [ 40, 40 ], [ 42, 42 ], [ 44, 44 ], [ 49, 48 ], [ 56, 55 ], [ 48, 62 ], [ 56, 64 ], [ 56, 65 ], [ 56, 66 ], [ 69, 68 ], [ 76, 75 ], [ 55, 78 ], [ 64, 79 ], [ 83, 82 ], [ 75, 87 ], [ 91, 90 ], [ 75, 95 ], [ 101, 98 ], [ 82, 99 ], [ 90, 100 ], [ 82, 104 ], [ 90, 106 ], [ 90, 108 ], [ 68, 109 ], [ 112, 111 ], [ 75, 116 ], [ 122, 119 ], [ 111, 120 ], [ 75, 121 ], [ 82, 125 ], [ 75, 126 ], [ 68, 128 ], [ 68, 130 ], [ 133, 132 ], [ 75, 136 ], [ 144, 141 ], [ 111, 142 ], [ 132, 143 ], [ 111, 147 ], [ 132, 149 ], [ 132, 152 ], [ 68, 154 ], [ 157, 156 ], [ 160, 159 ], [ 66, 163 ], [ 64, 166 ], [ 170, 169 ], [ 55, 173 ], [ 65, 174 ], [ 159, 175 ], [ 179, 178 ], [ 159, 180 ], [ 184, 183 ], [ 238, 185 ], [ 169, 186 ], [ 178, 187 ], [ 68, 188 ], [ 82, 189 ], [ 111, 190 ], [ 193, 192 ], [ 65, 196 ], [ 64, 198 ], [ 159, 199 ], [ 202, 201 ], [ 65, 203 ], [ 207, 206 ], [ 238, 208 ], [ 192, 209 ], [ 201, 210 ], [ 68, 211 ], [ 82, 212 ], [ 111, 213 ], [ 216, 215 ], [ 183, 218 ], [ 206, 219 ], [ 68, 220 ], [ 215, 223 ], [ 156, 223 ], [ 68, 224 ], [ 235, 232 ] ]

[ "import sys\n\n\ndef comb(n, r, MOD, factrial, fact_inv):\n if n < 0 or r < 0 or n < r:\n return 0\n else:\n return (factrial[n] * fact_inv[r] * fact_inv[n-r]) % MOD\n\ndef main():\n input = sys.stdin.readline\n H, W, A, B = map(int, input().split())\n MOD = 10**9 + 7\n\n n = H + W - 2\n\n factrial = [1] * (n+1)\n for k in range(1, n+1):\n factrial[k] = (factrial[k-1] * k) % MOD\n\n fact_inv = [1] * (n+1)\n fact_inv[n] = pow(factrial[n], MOD - 2, MOD)\n for k in range(n-1, -1, -1):\n fact_inv[k] = (fact_inv[k+1] * (k+1)) % MOD\n \n\n ans = 0\n for w in range(B+1, W+1):\n n_a = H - A + w -2\n r_a = w - 1\n a = comb(n_a, r_a, MOD, factrial, fact_inv)\n\n n_b = A - 1 + W - w\n r_b = A - 1\n b = comb(n_b, r_b, MOD, factrial, fact_inv)\n\n ans += (a * b) % MOD\n\n return ans % MOD\n\n\nif __name__ == '__main__':\n print(main())", "import sys", "sys", "def comb(n, r, MOD, factrial, fact_inv):\n if n < 0 or r < 0 or n < r:\n return 0\n else:\n return (factrial[n] * fact_inv[r] * fact_inv[n-r]) % MOD", "comb", "if n < 0 or r < 0 or n < r:\n return 0\n else:\n return (factrial[n] * fact_inv[r] * fact_inv[n-r]) % MOD", "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 (factrial[n] * fact_inv[r] * fact_inv[n-r]) % MOD", "(factrial[n] * fact_inv[r] * fact_inv[n-r]) % MOD", "factrial[n] * fact_inv[r] * fact_inv[n-r]", "factrial[n] * fact_inv[r]", "factrial[n]", "factrial", "n", "fact_inv[r]", "fact_inv", "r", "fact_inv[n-r]", "fact_inv", "n-r", "n", "r", "MOD", "n", "n", "r", "r", "MOD", "MOD", "factrial", "factrial", "fact_inv", "fact_inv", "def main():\n input = sys.stdin.readline\n H, W, A, B = map(int, input().split())\n MOD = 10**9 + 7\n\n n = H + W - 2\n\n factrial = [1] * (n+1)\n for k in range(1, n+1):\n factrial[k] = (factrial[k-1] * k) % MOD\n\n fact_inv = [1] * (n+1)\n fact_inv[n] = pow(factrial[n], MOD - 2, MOD)\n for k in range(n-1, -1, -1):\n fact_inv[k] = (fact_inv[k+1] * (k+1)) % MOD\n \n\n ans = 0\n for w in range(B+1, W+1):\n n_a = H - A + w -2\n r_a = w - 1\n a = comb(n_a, r_a, MOD, factrial, fact_inv)\n\n n_b = A - 1 + W - w\n r_b = A - 1\n b = comb(n_b, r_b, MOD, factrial, fact_inv)\n\n ans += (a * b) % MOD\n\n return ans % MOD", "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 = 10**9 + 7", "MOD", "10**9 + 7", "10**9", "10", "9", "7", "n = H + W - 2", "n", "H + W - 2", "H + W", "H", "W", "2", "factrial = [1] * (n+1)", "factrial", "[1] * (n+1)", "[1]", "1", "n+1", "n", "1", "for k in range(1, n+1):\n factrial[k] = (factrial[k-1] * k) % MOD\n\n ", "k", "range(1, n+1)", "range", "1", "n+1", "n", "1", "factrial[k] = (factrial[k-1] * k) % MOD", "factrial[k]", "factrial", "k", "(factrial[k-1] * k) % MOD", "factrial[k-1] * k", "factrial[k-1]", "factrial", "k-1", "k", "1", "k", "MOD", "fact_inv = [1] * (n+1)", "fact_inv", "[1] * (n+1)", "[1]", "1", "n+1", "n", "1", "fact_inv[n] = pow(factrial[n], MOD - 2, MOD)", "fact_inv[n]", "fact_inv", "n", "pow(factrial[n], MOD - 2, MOD)", "pow", "factrial[n]", "factrial", "n", "MOD - 2", "MOD", "2", "MOD", "for k in range(n-1, -1, -1):\n fact_inv[k] = (fact_inv[k+1] * (k+1)) % MOD\n \n\n ", "k", "range(n-1, -1, -1)", "range", "n-1", "n", "1", "-1", "-1", "fact_inv[k] = (fact_inv[k+1] * (k+1)) % MOD", "fact_inv[k]", "fact_inv", "k", "(fact_inv[k+1] * (k+1)) % MOD", "fact_inv[k+1] * (k+1)", "fact_inv[k+1]", "fact_inv", "k+1", "k", "1", "k+1", "k", "1", "MOD", "ans = 0", "ans", "0", "for w in range(B+1, W+1):\n n_a = H - A + w -2\n r_a = w - 1\n a = comb(n_a, r_a, MOD, factrial, fact_inv)\n\n n_b = A - 1 + W - w\n r_b = A - 1\n b = comb(n_b, r_b, MOD, factrial, fact_inv)\n\n ans += (a * b) % MOD\n\n ", "w", "range(B+1, W+1)", "range", "B+1", "B", "1", "W+1", "W", "1", "n_a = H - A + w -2", "n_a", "H - A + w -2", "H - A + w", "H - A", "H", "A", "w", "2", "r_a = w - 1", "r_a", "w - 1", "w", "1", "a = comb(n_a, r_a, MOD, factrial, fact_inv)", "a", "comb(n_a, r_a, MOD, factrial, fact_inv)", "comb", "n_a", "r_a", "MOD", "factrial", "fact_inv", "n_b = A - 1 + W - w", "n_b", "A - 1 + W - w", "A - 1 + W", "A - 1", "A", "1", "W", "w", "r_b = A - 1", "r_b", "A - 1", "A", "1", "b = comb(n_b, r_b, MOD, factrial, fact_inv)", "b", "comb(n_b, r_b, MOD, factrial, fact_inv)", "comb", "n_b", "r_b", "MOD", "factrial", "fact_inv", "ans += (a * b) % MOD", "ans", "(a * b) % MOD", "a * b", "a", "b", "MOD", "return ans % MOD", "ans % MOD", "ans", "MOD", "if __name__ == '__main__':\n print(main())", "__name__ == '__main__'", "__name__", "'__main__'", "print(main())", "print", "main()", "main", "def main():\n input = sys.stdin.readline\n H, W, A, B = map(int, input().split())\n MOD = 10**9 + 7\n\n n = H + W - 2\n\n factrial = [1] * (n+1)\n for k in range(1, n+1):\n factrial[k] = (factrial[k-1] * k) % MOD\n\n fact_inv = [1] * (n+1)\n fact_inv[n] = pow(factrial[n], MOD - 2, MOD)\n for k in range(n-1, -1, -1):\n fact_inv[k] = (fact_inv[k+1] * (k+1)) % MOD\n \n\n ans = 0\n for w in range(B+1, W+1):\n n_a = H - A + w -2\n r_a = w - 1\n a = comb(n_a, r_a, MOD, factrial, fact_inv)\n\n n_b = A - 1 + W - w\n r_b = A - 1\n b = comb(n_b, r_b, MOD, factrial, fact_inv)\n\n ans += (a * b) % MOD\n\n return ans % MOD", "def main():\n input = sys.stdin.readline\n H, W, A, B = map(int, input().split())\n MOD = 10**9 + 7\n\n n = H + W - 2\n\n factrial = [1] * (n+1)\n for k in range(1, n+1):\n factrial[k] = (factrial[k-1] * k) % MOD\n\n fact_inv = [1] * (n+1)\n fact_inv[n] = pow(factrial[n], MOD - 2, MOD)\n for k in range(n-1, -1, -1):\n fact_inv[k] = (fact_inv[k+1] * (k+1)) % MOD\n \n\n ans = 0\n for w in range(B+1, W+1):\n n_a = H - A + w -2\n r_a = w - 1\n a = comb(n_a, r_a, MOD, factrial, fact_inv)\n\n n_b = A - 1 + W - w\n r_b = A - 1\n b = comb(n_b, r_b, MOD, factrial, fact_inv)\n\n ans += (a * b) % MOD\n\n return ans % MOD", "main", "def comb(n, r, MOD, factrial, fact_inv):\n if n < 0 or r < 0 or n < r:\n return 0\n else:\n return (factrial[n] * fact_inv[r] * fact_inv[n-r]) % MOD", "def comb(n, r, MOD, factrial, fact_inv):\n if n < 0 or r < 0 or n < r:\n return 0\n else:\n return (factrial[n] * fact_inv[r] * fact_inv[n-r]) % MOD", "comb" ]

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

[ [ 245, 2 ], [ 245, 12 ], [ 245, 13 ], [ 245, 14 ], [ 227, 16 ], [ 206, 23 ], [ 234, 26 ], [ 240, 27 ], [ 242, 30 ], [ 207, 34 ], [ 209, 36 ], [ 207, 40 ], [ 224, 42 ], [ 207, 46 ], [ 52, 48 ], [ 243, 49 ], [ 60, 56 ], [ 210, 57 ], [ 68, 64 ], [ 225, 65 ], [ 73, 72 ], [ 207, 76 ], [ 81, 78 ], [ 243, 79 ], [ 72, 80 ], [ 243, 84 ], [ 72, 86 ], [ 72, 88 ], [ 228, 89 ], [ 94, 91 ], [ 225, 92 ], [ 72, 93 ], [ 225, 98 ], [ 228, 100 ], [ 72, 101 ], [ 228, 103 ], [ 72, 104 ], [ 228, 105 ], [ 110, 107 ], [ 210, 108 ], [ 72, 109 ], [ 210, 113 ], [ 72, 115 ], [ 91, 117 ], [ 225, 118 ], [ 72, 119 ], [ 228, 120 ], [ 221, 122 ], [ 126, 125 ], [ 231, 128 ], [ 240, 129 ], [ 215, 131 ], [ 234, 134 ], [ 246, 135 ], [ 218, 138 ], [ 243, 144 ], [ 125, 146 ], [ 216, 147 ], [ 210, 149 ], [ 125, 150 ], [ 228, 151 ], [ 210, 153 ], [ 216, 154 ], [ 228, 155 ], [ 236, 157 ], [ 243, 163 ], [ 234, 168 ], [ 240, 169 ], [ 125, 170 ], [ 216, 171 ], [ 210, 174 ], [ 240, 177 ], [ 125, 178 ], [ 228, 180 ], [ 210, 182 ], [ 234, 185 ], [ 216, 186 ], [ 228, 188 ], [ 212, 190 ], [ 219, 194 ], [ 228, 195 ], [ 237, 197 ], [ 228, 198 ], [ 228, 199 ], [ 213, 203 ], [ 222, 203 ], [ 228, 204 ], [ 206, 207 ], [ 209, 210 ], [ 212, 213 ], [ 215, 216 ], [ 218, 219 ], [ 221, 222 ], [ 224, 225 ], [ 227, 228 ], [ 245, 231 ], [ 245, 234 ], [ 236, 237 ], [ 245, 240 ], [ 242, 243 ], [ 245, 246 ] ]

[ "h, w, a, b = map(int, input().split(\" \"))\ndiv = 10 ** 9 + 7\nsize = h + w - 1\n\nfact = [0] * size\ninverse = [0] * size\ninv_calced = [0] * size\nfact[:2] = [1, 1]\ninverse[:2] = [1, 1]\ninv_calced[:2] = [0, 1]\n\nfor i in range(2, size):\n fact[i] = fact[i - 1] * i % div\n inv_calced[i] = -inv_calced[div % i] * (div // i) % div\n inverse[i] = inverse[i - 1] * inv_calced[i] % div\n \nresult = 0\nfor x in range(b, w):\n y = h - a - 1\n temp_1 = (fact[x+y] * inverse[x] % div) * inverse[y] % div\n temp_2 = (fact[h+w-x-y-3] * inverse[w-x-1] % div) * inverse[h-y-2] % div\n result += ((temp_1 % div) * (temp_2 % div)) % div\n\nprint(result % div)", "h, w, a, b = map(int, input().split(\" \"))", "h", "map(int, input().split(\" \"))", "map", "int", "input().split(\" \")", "().split", "()", "input", "split", "\" \"", "w", "a", "b", "div = 10 ** 9 + 7", "div", "10 ** 9 + 7", "10 ** 9", "10", "9", "7", "size = h + w - 1", "size", "h + w - 1", "h + w", "h", "w", "1", "fact = [0] * size", "fact", "[0] * size", "[0]", "0", "size", "inverse = [0] * size", "inverse", "[0] * size", "[0]", "0", "size", "inv_calced = [0] * size", "inv_calced", "[0] * size", "[0]", "0", "size", "fact[:2] = [1, 1]", "fact[:2]", "fact", ":2", "2", "[1, 1]", "1", "1", "inverse[:2] = [1, 1]", "inverse[:2]", "inverse", ":2", "2", "[1, 1]", "1", "1", "inv_calced[:2] = [0, 1]", "inv_calced[:2]", "inv_calced", ":2", "2", "[0, 1]", "0", "1", "for i in range(2, size):\n fact[i] = fact[i - 1] * i % div\n inv_calced[i] = -inv_calced[div % i] * (div // i) % div\n inverse[i] = inverse[i - 1] * inv_calced[i] % div\n ", "i", "range(2, size)", "range", "2", "size", "fact[i] = fact[i - 1] * i % div", "fact[i]", "fact", "i", "fact[i - 1] * i % div", "fact[i - 1] * i", "fact[i - 1]", "fact", "i - 1", "i", "1", "i", "div", "inv_calced[i] = -inv_calced[div % i] * (div // i) % div", "inv_calced[i]", "inv_calced", "i", "-inv_calced[div % i] * (div // i) % div", "-inv_calced[div % i] * (div // i)", "-inv_calced[div % i]", "inv_calced[div % i]", "inv_calced", "div % i", "div", "i", "div // i", "div", "i", "div", "inverse[i] = inverse[i - 1] * inv_calced[i] % div", "inverse[i]", "inverse", "i", "inverse[i - 1] * inv_calced[i] % div", "inverse[i - 1] * inv_calced[i]", "inverse[i - 1]", "inverse", "i - 1", "i", "1", "inv_calced[i]", "inv_calced", "i", "div", "result = 0", "result", "0", "for x in range(b, w):\n y = h - a - 1\n temp_1 = (fact[x+y] * inverse[x] % div) * inverse[y] % div\n temp_2 = (fact[h+w-x-y-3] * inverse[w-x-1] % div) * inverse[h-y-2] % div\n result += ((temp_1 % div) * (temp_2 % div)) % div", "x", "range(b, w)", "range", "b", "w", "y = h - a - 1", "y", "h - a - 1", "h - a", "h", "a", "1", "temp_1 = (fact[x+y] * inverse[x] % div) * inverse[y] % div", "temp_1", "(fact[x+y] * inverse[x] % div) * inverse[y] % div", "(fact[x+y] * inverse[x] % div) * inverse[y]", "fact[x+y] * inverse[x] % div", "fact[x+y] * inverse[x]", "fact[x+y]", "fact", "x+y", "x", "y", "inverse[x]", "inverse", "x", "div", "inverse[y]", "inverse", "y", "div", "temp_2 = (fact[h+w-x-y-3] * inverse[w-x-1] % div) * inverse[h-y-2] % div", "temp_2", "(fact[h+w-x-y-3] * inverse[w-x-1] % div) * inverse[h-y-2] % div", "(fact[h+w-x-y-3] * inverse[w-x-1] % div) * inverse[h-y-2]", "fact[h+w-x-y-3] * inverse[w-x-1] % div", "fact[h+w-x-y-3] * inverse[w-x-1]", "fact[h+w-x-y-3]", "fact", "h+w-x-y-3", "h+w-x-y", "h+w-x", "h+w", "h", "w", "x", "y", "3", "inverse[w-x-1]", "inverse", "w-x-1", "w-x", "w", "x", "1", "div", "inverse[h-y-2]", "inverse", "h-y-2", "h-y", "h", "y", "2", "div", "result += ((temp_1 % div) * (temp_2 % div)) % div", "result", "((temp_1 % div) * (temp_2 % div)) % div", "(temp_1 % div) * (temp_2 % div)", "temp_1 % div", "temp_1", "div", "temp_2 % div", "temp_2", "div", "div", "print(result % div)", "print", "result % div", "result", "div", "size = h + w - 1", "h + w - 1", "size", "inverse = [0] * size", "[0] * size", "inverse", "result += ((temp_1 % div) * (temp_2 % div)) % div", "((temp_1 % div) * (temp_2 % div)) % div", "result", "y = h - a - 1", "h - a - 1", "y", "temp_1 = (fact[x+y] * inverse[x] % div) * inverse[y] % div", "(fact[x+y] * inverse[x] % div) * inverse[y] % div", "temp_1", "result = 0", "0", "result", "inv_calced = [0] * size", "[0] * size", "inv_calced", "div = 10 ** 9 + 7", "10 ** 9 + 7", "div", "b = map(int, input().split(\" \"))", "map(int, input().split(\" \"))", "b", "h, w, a, b = map(int, input().split(\" \"))", "map(int, input().split(\" \"))", "h", "temp_2 = (fact[h+w-x-y-3] * inverse[w-x-1] % div) * inverse[h-y-2] % div", "(fact[h+w-x-y-3] * inverse[w-x-1] % div) * inverse[h-y-2] % div", "temp_2", "w, a, b = map(int, input().split(\" \"))", "map(int, input().split(\" \"))", "w", "fact = [0] * size", "[0] * size", "fact", "a, b = map(int, input().split(\" \"))", "map(int, input().split(\" \"))", "a" ]

[ 7, 15, 15, 15, 13, 15, 15, 13, 15, 13, 15, 13, 15, 13, 15, 13, 15, 13, 12, 13, 29, 4, 13, 4, 13, 12, 13, 29, 4, 13, 13, 4, 18, 4, 13, 13, 12, 13, 41, 28, 13, 4, 18, 4, 13, 13, 4, 4, 13, 13, 29, 13, 12, 13, 41, 28, 13, 4, 18, 4, 13, 13, 4, 2, 4, 13, 13, 17, 29, 13, 12, 13, 41, 28, 13, 4, 13, 4, 2, 4, 13, 13, 17, 29, 13, 12, 13, 29, 4, 13, 2, 13, 17, 23, 13, 12, 13, 29, 4, 18, 17, 13, 4, 13, 2, 13, 17, 23, 13, 12, 13, 0, 13, 39, 41, 28, 13, 4, 13, 13, 4, 39, 0, 13, 13, 28, 13, 4, 13, 13, 0, 13, 4, 13, 4, 18, 13, 13, 13, 14, 2, 13, 17, 0, 18, 13, 17, 17, 0, 18, 13, 17, 17, 14, 2, 4, 13, 13, 17, 0, 13, 13, 13, 4, 18, 18, 13, 13, 13, 13, 14, 40, 13, 4, 18, 18, 13, 13, 13, 13, 14, 2, 4, 13, 13, 17, 0, 13, 13, 13, 13, 0, 13, 39, 18, 13, 17, 18, 13, 17, 0, 13, 39, 18, 13, 17, 18, 13, 17, 4, 18, 18, 13, 13, 13, 13, 14, 40, 13, 4, 18, 18, 13, 13, 13, 13, 29, 39, 13, 13, 23, 13, 23, 13, 23, 13, 17, 23, 13, 17, 12, 13, 0, 13, 39, 28, 13, 4, 13, 2, 13, 13, 41, 28, 13, 4, 13, 13, 4, 2, 2, 13, 2, 13, 13, 13, 0, 13, 13, 0, 13, 39, 13, 29, 13, 23, 13, 23, 13, 17, 12, 13, 14, 13, 4, 13, 31, 13, 0, 13, 13, 23, 13, 17, 23, 0, 13, 39, 17, 17, 0, 13, 2, 2, 17, 17, 17, 0, 13, 4, 13, 17, 0, 13, 18, 13, 13, 0, 13, 18, 13, 13, 0, 13, 4, 18, 13, 13, 0, 13, 12, 4, 18, 4, 18, 18, 13, 13, 13, 13, 12, 13, 15, 13, 0, 13, 4, 18, 13, 13, 17, 17, 0, 13, 17, 13, 17, 41, 28, 13, 4, 13, 13, 4, 4, 18, 13, 13, 13, 13, 0, 13, 13, 29, 39, 13, 13, 6, 13, 12, 13, 0, 18, 13, 13, 2, 39, 17, 2, 13, 17, 0, 18, 13, 13, 2, 39, 17, 2, 13, 17, 0, 18, 18, 13, 13, 17, 17, 4, 18, 13, 13, 13, 28, 13, 4, 13, 17, 2, 13, 17, 0, 18, 18, 13, 13, 13, 2, 2, 13, 18, 18, 13, 13, 2, 13, 17, 13, 0, 18, 18, 13, 13, 13, 13, 0, 18, 18, 13, 13, 13, 13, 0, 18, 18, 13, 13, 13, 4, 13, 18, 18, 13, 13, 13, 2, 13, 17, 13, 28, 13, 4, 13, 17, 13, 0, 18, 18, 13, 13, 2, 13, 13, 2, 2, 18, 18, 13, 13, 2, 2, 13, 13, 17, 2, 2, 13, 13, 17, 13, 29, 23, 13, 23, 13, 23, 13, 2, 2, 17, 17, 17, 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, 13, 13, 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, 0, 13, 17, 0, 13, 17, 0, 13, 4, 13, 13, 13, 13, 0, 13, 4, 13, 2, 17, 2, 17, 17, 13, 28, 13, 4, 13, 2, 13, 13, 4, 13, 13, 39, 2, 2, 2, 2, 13, 13, 13, 13, 17, 2, 2, 13, 13, 17, 39, 2, 2, 2, 2, 2, 13, 17, 13, 13, 17, 13, 2, 13, 17, 4, 13, 4, 18, 13, 13, 2, 2, 2, 2, 13, 13, 13, 13, 17, 2, 2, 13, 13, 17, 4, 18, 13, 13, 2, 2, 2, 2, 2, 13, 17, 13, 13, 17, 13, 2, 13, 17, 0, 13, 2, 4, 18, 13, 13, 2, 2, 2, 2, 13, 13, 13, 13, 17, 2, 2, 13, 13, 17, 4, 18, 13, 13, 2, 2, 2, 2, 2, 13, 17, 13, 13, 17, 13, 2, 13, 17, 0, 13, 13, 4, 13, 13, 10, 39, 13, 10, 12, 13, 10, 12, 13, 10, 13, 13, 10, 18, 13, 10, 4, 13, 10, 12, 13, 10, 12, 13, 10, 12, 13, 10, 4, 13, 10, 12, 13, 10, 17, 13, 10, 12, 13, 10, 17, 13, 10, 18, 13, 10, 12, 13, 10, 12, 13, 10, 2, 13, 10, 12, 13, 10, 4, 13, 10, 12, 13, 10, 4, 13, 10, 4, 13, 10, 12, 13, 10, 6, 13, 10, 4, 13, 10, 4, 13, 10, 2, 13 ]

[ [ 41, 40 ], [ 40, 49 ], [ 57, 56 ], [ 56, 66 ], [ 75, 74 ], [ 74, 81 ], [ 94, 91 ], [ 94, 94 ], [ 108, 108 ], [ 113, 112 ], [ 117, 116 ], [ 124, 123 ], [ 127, 126 ], [ 233, 129 ], [ 132, 131 ], [ 769, 133 ], [ 112, 136 ], [ 131, 138 ], [ 238, 141 ], [ 147, 144 ], [ 131, 145 ], [ 152, 149 ], [ 131, 150 ], [ 131, 157 ], [ 161, 160 ], [ 131, 161 ], [ 161, 162 ], [ 123, 166 ], [ 160, 167 ], [ 187, 167 ], [ 162, 169 ], [ 189, 169 ], [ 235, 172 ], [ 123, 176 ], [ 162, 177 ], [ 189, 177 ], [ 160, 179 ], [ 187, 179 ], [ 131, 184 ], [ 188, 187 ], [ 131, 188 ], [ 188, 189 ], [ 188, 190 ], [ 193, 192 ], [ 131, 195 ], [ 131, 198 ], [ 202, 201 ], [ 131, 204 ], [ 131, 207 ], [ 123, 212 ], [ 187, 213 ], [ 160, 213 ], [ 201, 215 ], [ 235, 218 ], [ 123, 222 ], [ 189, 223 ], [ 162, 223 ], [ 192, 225 ], [ 231, 231 ], [ 233, 233 ], [ 236, 235 ], [ 239, 238 ], [ 244, 243 ], [ 247, 246 ], [ 278, 250 ], [ 276, 251 ], [ 255, 254 ], [ 276, 257 ], [ 246, 261 ], [ 278, 263 ], [ 254, 264 ], [ 278, 265 ], [ 268, 267 ], [ 271, 270 ], [ 270, 274 ], [ 243, 274 ], [ 276, 276 ], [ 279, 278 ], [ 290, 289 ], [ 289, 290 ], [ 292, 290 ], [ 293, 292 ], [ 723, 296 ], [ 774, 301 ], [ 786, 308 ], [ 765, 313 ], [ 735, 318 ], [ 780, 323 ], [ 741, 329 ], [ 346, 345 ], [ 354, 353 ], [ 356, 355 ], [ 360, 359 ], [ 345, 362 ], [ 353, 368 ], [ 355, 369 ], [ 372, 371 ], [ 385, 382 ], [ 502, 383 ], [ 504, 389 ], [ 395, 392 ], [ 502, 393 ], [ 504, 399 ], [ 407, 402 ], [ 382, 403 ], [ 502, 404 ], [ 502, 410 ], [ 504, 412 ], [ 415, 414 ], [ 504, 419 ], [ 427, 422 ], [ 382, 423 ], [ 502, 424 ], [ 414, 426 ], [ 414, 429 ], [ 382, 431 ], [ 502, 432 ], [ 414, 435 ], [ 506, 437 ], [ 444, 439 ], [ 392, 440 ], [ 502, 441 ], [ 504, 443 ], [ 414, 444 ], [ 451, 446 ], [ 392, 447 ], [ 502, 448 ], [ 504, 450 ], [ 506, 451 ], [ 458, 453 ], [ 392, 454 ], [ 502, 455 ], [ 504, 457 ], [ 446, 460 ], [ 439, 460 ], [ 392, 461 ], [ 502, 462 ], [ 504, 464 ], [ 506, 466 ], [ 506, 468 ], [ 471, 470 ], [ 504, 474 ], [ 483, 476 ], [ 392, 477 ], [ 502, 478 ], [ 504, 481 ], [ 470, 482 ], [ 392, 486 ], [ 502, 487 ], [ 504, 491 ], [ 470, 492 ], [ 504, 496 ], [ 470, 497 ], [ 506, 499 ], [ 502, 502 ], [ 504, 504 ], [ 507, 506 ], [ 521, 517 ], [ 523, 519 ], [ 521, 521 ], [ 523, 523 ], [ 533, 529 ], [ 535, 531 ], [ 533, 533 ], [ 535, 535 ], [ 575, 541 ], [ 575, 544 ], [ 573, 545 ], [ 571, 554 ], [ 573, 556 ], [ 571, 559 ], [ 573, 562 ], [ 575, 563 ], [ 571, 566 ], [ 575, 568 ], [ 775, 569 ], [ 571, 571 ], [ 573, 573 ], [ 575, 575 ], [ 762, 577 ], [ 756, 580 ], [ 801, 583 ], [ 769, 585 ], [ 801, 586 ], [ 801, 587 ], [ 801, 588 ], [ 789, 590 ], [ 775, 598 ], [ 601, 600 ], [ 799, 604 ], [ 739, 605 ], [ 748, 607 ], [ 600, 608 ], [ 751, 614 ], [ 802, 615 ], [ 739, 616 ], [ 600, 617 ], [ 751, 621 ], [ 802, 622 ], [ 802, 630 ], [ 799, 632 ], [ 739, 633 ], [ 600, 635 ], [ 802, 637 ], [ 748, 640 ], [ 790, 643 ], [ 537, 644 ], [ 751, 649 ], [ 802, 650 ], [ 739, 651 ], [ 600, 652 ], [ 751, 656 ], [ 802, 657 ], [ 790, 661 ], [ 537, 662 ], [ 802, 668 ], [ 799, 670 ], [ 739, 671 ], [ 600, 673 ], [ 802, 675 ], [ 804, 678 ], [ 790, 682 ], [ 537, 683 ], [ 751, 688 ], [ 802, 689 ], [ 739, 690 ], [ 600, 691 ], [ 751, 695 ], [ 802, 696 ], [ 790, 700 ], [ 537, 701 ], [ 802, 707 ], [ 799, 709 ], [ 739, 710 ], [ 600, 712 ], [ 802, 714 ], [ 732, 717 ], [ 775, 718 ], [ 733, 721 ], [ 805, 721 ], [ 757, 721 ], [ 723, 724 ], [ 775, 732 ], [ 732, 733 ], [ 735, 736 ], [ 801, 739 ], [ 741, 742 ], [ 801, 751 ], [ 756, 757 ], [ 762, 763 ], [ 765, 766 ], [ 774, 775 ], [ 780, 781 ], [ 786, 787 ], [ 789, 790 ], [ 801, 799 ], [ 801, 802 ], [ 804, 805 ] ]

[ "from heapq import heappush,heappop,heapify\nfrom collections import deque,defaultdict,Counter\nimport itertools\nfrom itertools import permutations,combinations\nimport sys\nimport bisect\nimport string\nimport math\nimport time\nimport random\ndef I():\n return int(input())\ndef MI():\n return map(int,input().split())\ndef LI():\n return [int(i) for i in input().split()]\ndef LI_():\n return [int(i)-1 for i in input().split()]\ndef StoI():\n return [ord(i)-97 for i in input()]\ndef ItoS(nn):\n return chr(nn+97)\ndef LtoS(ls):\n return ''.join(chr(i+97) for i in ls)\ndef GI(V,E,Directed=False,index=0):\n org_inp=[]\n g=[[] for i in range(n)]\n for i in range(E):\n inp=LI()\n org_inp.append(inp)\n if index==0:\n inp[0]-=1\n inp[1]-=1\n if len(inp)==2:\n a,b=inp\n g[a].append(b)\n if not Directed:\n g[b].append(a)\n elif len(inp)==3:\n a,b,c=inp\n aa=(inp[0],inp[2])\n bb=(inp[1],inp[2])\n g[a].append(bb)\n if not Directed:\n g[b].append(aa)\n return g,org_inp\ndef bit_combination(k,n=2):\n rt=[]\n for tb in range(n**k):\n s=[tb//(n**bt)%n for bt in range(k)]\n rt+=[s]\n return rt\ndef show(*inp,end='\\n'):\n if show_flg:\n print(*inp,end=end)\nYN=['Yes','No']\nmo=10**9+7\ninf=float('inf')\nl_alp=string.ascii_lowercase\nu_alp=string.ascii_uppercase\nts=time.time()\n#sys.setrecursionlimit(10**5)\ninput=lambda: sys.stdin.readline().rstrip()\n\ndef ran_input():\n import random\n n=random.randint(4,16)\n rmin,rmax=1,10\n a=[random.randint(rmin,rmax) for _ in range(n)]\n return n,a\n\nclass Comb:\n def __init__(self,n,mo=10**9+7):\n self.fac=[0]*(n+1)\n self.inv=[1]*(n+1)\n self.fac[0]=1\n self.fact(n)\n for i in range(1,n+1):\n self.fac[i]=i*self.fac[i-1]%mo\n self.inv[n]*=i\n self.inv[n]%=mo\n self.inv[n]=pow(self.inv[n],mo-2,mo)\n for i in range(1,n):\n self.inv[n-i]=self.inv[n-i+1]*(n-i+1)%mo\n return\n \n def fact(self,n):\n return self.fac[n]\n \n def invf(self,n):\n return self.inv[n]\n\n def comb(self,x,y):\n if y<0 or y>x:\n return 0\n return self.fac[x]*self.inv[x-y]*self.inv[y]%mo\n \nshow_flg=False\n#show_flg=True\n\nans=0\n\nh,w,a,b=LI()\n\ncm=Comb(3*10**5,mo)\n\nfor i in range(w-b):\n show(i,(h-a+b +i-1,h-a-1),(a-1+w-b-1 -i,a-1))\n show(cm.comb(h-a+b +i-1,h-a-1),cm.comb(a-1+w-b-1 -i,a-1))\n ans+=cm.comb(h-a+b +i-1,h-a-1)*cm.comb(a-1+w-b-1 -i,a-1)\n ans%=mo\n\nprint(ans)", "from heapq import heappush,heappop,heapify", "from collections import deque,defaultdict,Counter", "import itertools", "itertools", "from itertools import permutations,combinations", "import sys", "sys", "import bisect", "bisect", "import string", "string", "import math", "math", "import time", "time", "import random", "random", "def I():\n return int(input())", "I", "return int(input())", "int(input())", "int", "input()", "input", "def MI():\n return map(int,input().split())", "MI", "return map(int,input().split())", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "def LI():\n return [int(i) for i in input().split()]", "LI", "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", "return [int(i) for i in input().split()]", "[int(i) for i in input().split()]", "def LI_():\n return [int(i)-1 for i in input().split()]", "LI_", "int(i)-1 for i in input().split()", "for i in input().split()", "i", "input().split()", "().split", "()", "input", "split", "for i in input().split()", "int(i)-1", "int(i)", "int", "i", "1", "return [int(i)-1 for i in input().split()]", "[int(i)-1 for i in input().split()]", "def StoI():\n return [ord(i)-97 for i in input()]", "StoI", "ord(i)-97 for i in input()", "for i in input()", "i", "input()", "input", "for i in input()", "ord(i)-97", "ord(i)", "ord", "i", "97", "return [ord(i)-97 for i in input()]", "[ord(i)-97 for i in input()]", "def ItoS(nn):\n return chr(nn+97)", "ItoS", "return chr(nn+97)", "chr(nn+97)", "chr", "nn+97", "nn", "97", "nn", "nn", "def LtoS(ls):\n return ''.join(chr(i+97) for i in ls)", "LtoS", "return ''.join(chr(i+97) for i in ls)", "''.join(chr(i+97) for i in ls)", "''.join", "''", "join", "chr(i+97)", "chr", "i+97", "i", "97", "ls", "ls", "def GI(V,E,Directed=False,index=0):\n org_inp=[]\n g=[[] for i in range(n)]\n for i in range(E):\n inp=LI()\n org_inp.append(inp)\n if index==0:\n inp[0]-=1\n inp[1]-=1\n if len(inp)==2:\n a,b=inp\n g[a].append(b)\n if not Directed:\n g[b].append(a)\n elif len(inp)==3:\n a,b,c=inp\n aa=(inp[0],inp[2])\n bb=(inp[1],inp[2])\n g[a].append(bb)\n if not Directed:\n g[b].append(aa)\n return g,org_inp", "GI", "org_inp=[]", "org_inp", "[]", "[] for i in range(n)", "for i in range(n)", "i", "range(n)", "range", "n", "for i in range(n)", "[]", "g=[[] for i in range(n)]", "g", "[[] for i in range(n)]", "for i in range(E):\n inp=LI()\n org_inp.append(inp)\n if index==0:\n inp[0]-=1\n inp[1]-=1\n if len(inp)==2:\n a,b=inp\n g[a].append(b)\n if not Directed:\n g[b].append(a)\n elif len(inp)==3:\n a,b,c=inp\n aa=(inp[0],inp[2])\n bb=(inp[1],inp[2])\n g[a].append(bb)\n if not Directed:\n g[b].append(aa)\n ", "i", "range(E)", "range", "E", "inp=LI()", "inp", "LI()", "LI", "org_inp.append(inp)", "org_inp.append", "org_inp", "append", "inp", "if index==0:\n inp[0]-=1\n inp[1]-=1\n ", "index==0", "index", "0", "inp[0]-=1", "inp[0]", "inp", "0", "1", "inp[1]-=1", "inp[1]", "inp", "1", "1", "if len(inp)==2:\n a,b=inp\n g[a].append(b)\n if not Directed:\n g[b].append(a)\n elif len(inp)==3:\n a,b,c=inp\n aa=(inp[0],inp[2])\n bb=(inp[1],inp[2])\n g[a].append(bb)\n if not Directed:\n g[b].append(aa)\n ", "len(inp)==2", "len(inp)", "len", "inp", "2", "a,b=inp", "a", "inp", "b", "g[a].append(b)", "[a].append", "[a]", "g", "a", "append", "b", "if not Directed:\n g[b].append(a)\n ", "not Directed", "Directed", "g[b].append(a)", "[b].append", "[b]", "g", "b", "append", "a", "elif len(inp)==3:\n a,b,c=inp\n aa=(inp[0],inp[2])\n bb=(inp[1],inp[2])\n g[a].append(bb)\n if not Directed:\n g[b].append(aa)\n ", "len(inp)==3", "len(inp)", "len", "inp", "3", "a,b,c=inp", "a", "inp", "b", "c", "aa=(inp[0],inp[2])", "aa", "(inp[0],inp[2])", "inp[0]", "inp", "0", "inp[2]", "inp", "2", "bb=(inp[1],inp[2])", "bb", "(inp[1],inp[2])", "inp[1]", "inp", "1", "inp[2]", "inp", "2", "g[a].append(bb)", "[a].append", "[a]", "g", "a", "append", "bb", "if not Directed:\n g[b].append(aa)\n ", "not Directed", "Directed", "g[b].append(aa)", "[b].append", "[b]", "g", "b", "append", "aa", "return g,org_inp", "return g,org_inp", "g", "org_inp", "V", "V", "E", "E", "Directed=False", "Directed", "False", "index=0", "index", "0", "def bit_combination(k,n=2):\n rt=[]\n for tb in range(n**k):\n s=[tb//(n**bt)%n for bt in range(k)]\n rt+=[s]\n return rt", "bit_combination", "rt=[]", "rt", "[]", "for tb in range(n**k):\n s=[tb//(n**bt)%n for bt in range(k)]\n rt+=[s]\n ", "tb", "range(n**k)", "range", "n**k", "n", "k", "tb//(n**bt)%n for bt in range(k)", "for bt in range(k)", "bt", "range(k)", "range", "k", "for bt in range(k)", "tb//(n**bt)%n", "tb//(n**bt)", "tb", "n**bt", "n", "bt", "n", "s=[tb//(n**bt)%n for bt in range(k)]", "s", "[tb//(n**bt)%n for bt in range(k)]", "rt+=[s]", "rt", "[s]", "s", "return rt", "rt", "k", "k", "n=2", "n", "2", "def show(*inp,end='\\n'):\n if show_flg:\n print(*inp,end=end)", "show", "if show_flg:\n print(*inp,end=end)", "show_flg", "print(*inp,end=end)", "print", "*inp", "inp", "end=end", "end", "end", "end='\\n'", "end", "'\\n'", "*inp", "YN=['Yes','No']", "YN", "['Yes','No']", "'Yes'", "'No'", "mo=10**9+7", "mo", "10**9+7", "10**9", "10", "9", "7", "inf=float('inf')", "inf", "float('inf')", "float", "'inf'", "l_alp=string.ascii_lowercase", "l_alp", "string.ascii_lowercase", "string", "ascii_lowercase", "u_alp=string.ascii_uppercase", "u_alp", "string.ascii_uppercase", "string", "ascii_uppercase", "ts=time.time()", "ts", "time.time()", "time.time", "time", "time", "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", "def ran_input():\n import random\n n=random.randint(4,16)\n rmin,rmax=1,10\n a=[random.randint(rmin,rmax) for _ in range(n)]\n return n,a", "ran_input", "import random", "random", "n=random.randint(4,16)", "n", "random.randint(4,16)", "random.randint", "random", "randint", "4", "16", "rmin,rmax=1,10", "rmin", "1", "rmax", "10", "random.randint(rmin,rmax) for _ in range(n)", "for _ in range(n)", "_", "range(n)", "range", "n", "for _ in range(n)", "random.randint(rmin,rmax)", "random.randint", "random", "randint", "rmin", "rmax", "a=[random.randint(rmin,rmax) for _ in range(n)]", "a", "[random.randint(rmin,rmax) for _ in range(n)]", "return n,a", "return n,a", "n", "a", "class Comb:\n def __init__(self,n,mo=10**9+7):\n self.fac=[0]*(n+1)\n self.inv=[1]*(n+1)\n self.fac[0]=1\n self.fact(n)\n for i in range(1,n+1):\n self.fac[i]=i*self.fac[i-1]%mo\n self.inv[n]*=i\n self.inv[n]%=mo\n self.inv[n]=pow(self.inv[n],mo-2,mo)\n for i in range(1,n):\n self.inv[n-i]=self.inv[n-i+1]*(n-i+1)%mo\n return\n \n def fact(self,n):\n return self.fac[n]\n \n def invf(self,n):\n return self.inv[n]\n\n def comb(self,x,y):\n if y<0 or y>x:\n return 0\n return self.fac[x]*self.inv[x-y]*self.inv[y]%mo\n ", "Comb", "def __init__(self,n,mo=10**9+7):\n self.fac=[0]*(n+1)\n self.inv=[1]*(n+1)\n self.fac[0]=1\n self.fact(n)\n for i in range(1,n+1):\n self.fac[i]=i*self.fac[i-1]%mo\n self.inv[n]*=i\n self.inv[n]%=mo\n self.inv[n]=pow(self.inv[n],mo-2,mo)\n for i in range(1,n):\n self.inv[n-i]=self.inv[n-i+1]*(n-i+1)%mo\n return\n \n ", "__init__", "self.fac=[0]*(n+1)", "self.fac", "self", "fac", "[0]*(n+1)", "[0]", "0", "n+1", "n", "1", "self.inv=[1]*(n+1)", "self.inv", "self", "inv", "[1]*(n+1)", "[1]", "1", "n+1", "n", "1", "self.fac[0]=1", "self.fac[0]", "self.fac", "self", "fac", "0", "1", "self.fact(n)", "self.fact", "self", "fact", "n", "for i in range(1,n+1):\n self.fac[i]=i*self.fac[i-1]%mo\n self.inv[n]*=i\n self.inv[n]%=mo\n ", "i", "range(1,n+1)", "range", "1", "n+1", "n", "1", "self.fac[i]=i*self.fac[i-1]%mo", "self.fac[i]", "self.fac", "self", "fac", "i", "i*self.fac[i-1]%mo", "i*self.fac[i-1]", "i", "self.fac[i-1]", "self.fac", "self", "fac", "i-1", "i", "1", "mo", "self.inv[n]*=i", "self.inv[n]", "self.inv", "self", "inv", "n", "i", "self.inv[n]%=mo", "self.inv[n]", "self.inv", "self", "inv", "n", "mo", "self.inv[n]=pow(self.inv[n],mo-2,mo)", "self.inv[n]", "self.inv", "self", "inv", "n", "pow(self.inv[n],mo-2,mo)", "pow", "self.inv[n]", "self.inv", "self", "inv", "n", "mo-2", "mo", "2", "mo", "for i in range(1,n):\n self.inv[n-i]=self.inv[n-i+1]*(n-i+1)%mo\n ", "i", "range(1,n)", "range", "1", "n", "self.inv[n-i]=self.inv[n-i+1]*(n-i+1)%mo", "self.inv[n-i]", "self.inv", "self", "inv", "n-i", "n", "i", "self.inv[n-i+1]*(n-i+1)%mo", "self.inv[n-i+1]*(n-i+1)", "self.inv[n-i+1]", "self.inv", "self", "inv", "n-i+1", "n-i", "n", "i", "1", "n-i+1", "n-i", "n", "i", "1", "mo", "return", "self", "self", "n", "n", "mo=10**9+7", "mo", "10**9+7", "10**9", "10", "9", "7", "def fact(self,n):\n return self.fac[n]\n \n ", "fact", "return self.fac[n]", "self.fac[n]", "self.fac", "self", "fac", "n", "self", "self", "n", "n", "def invf(self,n):\n return self.inv[n]\n\n ", "invf", "return self.inv[n]", "self.inv[n]", "self.inv", "self", "inv", "n", "self", "self", "n", "n", "def comb(self,x,y):\n if y<0 or y>x:\n return 0\n return self.fac[x]*self.inv[x-y]*self.inv[y]%mo\n ", "comb", "if y<0 or y>x:\n return 0\n ", "y<0 or y>x", "y<0", "y", "0", "y>x", "y", "x", "return 0", "0", "return self.fac[x]*self.inv[x-y]*self.inv[y]%mo", "self.fac[x]*self.inv[x-y]*self.inv[y]%mo", "self.fac[x]*self.inv[x-y]*self.inv[y]", "self.fac[x]*self.inv[x-y]", "self.fac[x]", "self.fac", "self", "fac", "x", "self.inv[x-y]", "self.inv", "self", "inv", "x-y", "x", "y", "self.inv[y]", "self.inv", "self", "inv", "y", "mo", "self", "self", "x", "x", "y", "y", "show_flg=False", "show_flg", "False", "ans=0", "ans", "0", "h,w,a,b=LI()", "h", "LI()", "LI", "w", "a", "b", "cm=Comb(3*10**5,mo)", "cm", "Comb(3*10**5,mo)", "Comb", "3*10**5", "3", "10**5", "10", "5", "mo", "for i in range(w-b):\n show(i,(h-a+b +i-1,h-a-1),(a-1+w-b-1 -i,a-1))\n show(cm.comb(h-a+b +i-1,h-a-1),cm.comb(a-1+w-b-1 -i,a-1))\n ans+=cm.comb(h-a+b +i-1,h-a-1)*cm.comb(a-1+w-b-1 -i,a-1)\n ans%=mo", "i", "range(w-b)", "range", "w-b", "w", "b", "show(i,(h-a+b +i-1,h-a-1),(a-1+w-b-1 -i,a-1))", "show", "i", "(h-a+b +i-1,h-a-1)", "h-a+b +i-1", "h-a+b +i", "h-a+b", "h-a", "h", "a", "b", "i", "1", "h-a-1", "h-a", "h", "a", "1", "(a-1+w-b-1 -i,a-1)", "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", "show(cm.comb(h-a+b +i-1,h-a-1),cm.comb(a-1+w-b-1 -i,a-1))", "show", "cm.comb(h-a+b +i-1,h-a-1)", "cm.comb", "cm", "comb", "h-a+b +i-1", "h-a+b +i", "h-a+b", "h-a", "h", "a", "b", "i", "1", "h-a-1", "h-a", "h", "a", "1", "cm.comb(a-1+w-b-1 -i,a-1)", "cm.comb", "cm", "comb", "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", "ans+=cm.comb(h-a+b +i-1,h-a-1)*cm.comb(a-1+w-b-1 -i,a-1)", "ans", "cm.comb(h-a+b +i-1,h-a-1)*cm.comb(a-1+w-b-1 -i,a-1)", "cm.comb(h-a+b +i-1,h-a-1)", "cm.comb", "cm", "comb", "h-a+b +i-1", "h-a+b +i", "h-a+b", "h-a", "h", "a", "b", "i", "1", "h-a-1", "h-a", "h", "a", "1", "cm.comb(a-1+w-b-1 -i,a-1)", "cm.comb", "cm", "comb", "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", "ans%=mo", "ans", "mo", "print(ans)", "print", "ans", "YN=['Yes','No']", "['Yes','No']", "YN", "def ItoS(nn):\n return chr(nn+97)", "def ItoS(nn):\n return chr(nn+97)", "ItoS", "def MI():\n return map(int,input().split())", "def MI():\n return map(int,input().split())", "MI", "ans%=mo", "mo", "ans", "u_alp=string.ascii_uppercase", "string.ascii_uppercase", "u_alp", "b=LI()", "LI()", "b", "input=lambda: sys.stdin.readline().rstrip()", "lambda: sys.stdin.readline().rstrip()", "input", "def ran_input():\n import random\n n=random.randint(4,16)\n rmin,rmax=1,10\n a=[random.randint(rmin,rmax) for _ in range(n)]\n return n,a", "def ran_input():\n import random\n n=random.randint(4,16)\n rmin,rmax=1,10\n a=[random.randint(rmin,rmax) for _ in range(n)]\n return n,a", "ran_input", "def show(*inp,end='\\n'):\n if show_flg:\n print(*inp,end=end)", "def show(*inp,end='\\n'):\n if show_flg:\n print(*inp,end=end)", "show", "h,w,a,b=LI()", "LI()", "h", "def GI(V,E,Directed=False,index=0):\n org_inp=[]\n g=[[] for i in range(n)]\n for i in range(E):\n inp=LI()\n org_inp.append(inp)\n if index==0:\n inp[0]-=1\n inp[1]-=1\n if len(inp)==2:\n a,b=inp\n g[a].append(b)\n if not Directed:\n g[b].append(a)\n elif len(inp)==3:\n a,b,c=inp\n aa=(inp[0],inp[2])\n bb=(inp[1],inp[2])\n g[a].append(bb)\n if not Directed:\n g[b].append(aa)\n return g,org_inp", "def GI(V,E,Directed=False,index=0):\n org_inp=[]\n g=[[] for i in range(n)]\n for i in range(E):\n inp=LI()\n org_inp.append(inp)\n if index==0:\n inp[0]-=1\n inp[1]-=1\n if len(inp)==2:\n a,b=inp\n g[a].append(b)\n if not Directed:\n g[b].append(a)\n elif len(inp)==3:\n a,b,c=inp\n aa=(inp[0],inp[2])\n bb=(inp[1],inp[2])\n g[a].append(bb)\n if not Directed:\n g[b].append(aa)\n return g,org_inp", "GI", "ans=0", "0", "ans", "def bit_combination(k,n=2):\n rt=[]\n for tb in range(n**k):\n s=[tb//(n**bt)%n for bt in range(k)]\n rt+=[s]\n return rt", "def bit_combination(k,n=2):\n rt=[]\n for tb in range(n**k):\n s=[tb//(n**bt)%n for bt in range(k)]\n rt+=[s]\n return rt", "bit_combination", "show_flg=False", "False", "show_flg", "l_alp=string.ascii_lowercase", "string.ascii_lowercase", "l_alp", "def LI():\n return [int(i) for i in input().split()]", "def LI():\n return [int(i) for i in input().split()]", "LI", "def LtoS(ls):\n return ''.join(chr(i+97) for i in ls)", "def LtoS(ls):\n return ''.join(chr(i+97) for i in ls)", "LtoS", "mo=10**9+7", "10**9+7", "mo", "def I():\n return int(input())", "def I():\n return int(input())", "I", "ts=time.time()", "time.time()", "ts", "def LI_():\n return [int(i)-1 for i in input().split()]", "def LI_():\n return [int(i)-1 for i in input().split()]", "LI_", "inf=float('inf')", "float('inf')", "inf", "cm=Comb(3*10**5,mo)", "Comb(3*10**5,mo)", "cm", "def StoI():\n return [ord(i)-97 for i in input()]", "def StoI():\n return [ord(i)-97 for i in input()]", "StoI", "class Comb:\n def __init__(self,n,mo=10**9+7):\n self.fac=[0]*(n+1)\n self.inv=[1]*(n+1)\n self.fac[0]=1\n self.fact(n)\n for i in range(1,n+1):\n self.fac[i]=i*self.fac[i-1]%mo\n self.inv[n]*=i\n self.inv[n]%=mo\n self.inv[n]=pow(self.inv[n],mo-2,mo)\n for i in range(1,n):\n self.inv[n-i]=self.inv[n-i+1]*(n-i+1)%mo\n return\n \n def fact(self,n):\n return self.fac[n]\n \n def invf(self,n):\n return self.inv[n]\n\n def comb(self,x,y):\n if y<0 or y>x:\n return 0\n return self.fac[x]*self.inv[x-y]*self.inv[y]%mo\n ", "class Comb:\n def __init__(self,n,mo=10**9+7):\n self.fac=[0]*(n+1)\n self.inv=[1]*(n+1)\n self.fac[0]=1\n self.fact(n)\n for i in range(1,n+1):\n self.fac[i]=i*self.fac[i-1]%mo\n self.inv[n]*=i\n self.inv[n]%=mo\n self.inv[n]=pow(self.inv[n],mo-2,mo)\n for i in range(1,n):\n self.inv[n-i]=self.inv[n-i+1]*(n-i+1)%mo\n return\n \n def fact(self,n):\n return self.fac[n]\n \n def invf(self,n):\n return self.inv[n]\n\n def comb(self,x,y):\n if y<0 or y>x:\n return 0\n return self.fac[x]*self.inv[x-y]*self.inv[y]%mo\n ", "Comb", "w,a,b=LI()", "LI()", "w", "a,b=LI()", "LI()", "a", "ans+=cm.comb(h-a+b +i-1,h-a-1)*cm.comb(a-1+w-b-1 -i,a-1)", "cm.comb(h-a+b +i-1,h-a-1)*cm.comb(a-1+w-b-1 -i,a-1)", "ans" ]

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

[ [ 337, 2 ], [ 328, 5 ], [ 328, 14 ], [ 328, 15 ], [ 328, 16 ], [ 21, 20 ], [ 65, 25 ], [ 31, 28 ], [ 20, 29 ], [ 36, 33 ], [ 20, 34 ], [ 39, 38 ], [ 65, 43 ], [ 49, 46 ], [ 20, 47 ], [ 38, 48 ], [ 20, 52 ], [ 38, 54 ], [ 38, 56 ], [ 20, 63 ], [ 65, 65 ], [ 70, 69 ], [ 332, 71 ], [ 199, 72 ], [ 75, 74 ], [ 69, 76 ], [ 80, 79 ], [ 83, 82 ], [ 199, 87 ], [ 91, 90 ], [ 99, 96 ], [ 90, 97 ], [ 74, 99 ], [ 104, 101 ], [ 90, 102 ], [ 74, 105 ], [ 109, 108 ], [ 118, 113 ], [ 90, 114 ], [ 108, 116 ], [ 90, 121 ], [ 108, 123 ], [ 133, 132 ], [ 143, 142 ], [ 132, 149 ], [ 329, 149 ], [ 142, 152 ], [ 156, 155 ], [ 79, 158 ], [ 155, 158 ], [ 90, 160 ], [ 142, 161 ], [ 171, 168 ], [ 82, 169 ], [ 199, 170 ], [ 155, 171 ], [ 79, 171 ], [ 174, 173 ], [ 199, 176 ], [ 185, 180 ], [ 82, 181 ], [ 173, 183 ], [ 82, 188 ], [ 173, 189 ], [ 173, 190 ], [ 82, 197 ], [ 199, 199 ], [ 340, 201 ], [ 332, 203 ], [ 317, 206 ], [ 326, 207 ], [ 313, 210 ], [ 320, 212 ], [ 317, 215 ], [ 326, 216 ], [ 222, 221 ], [ 341, 222 ], [ 225, 224 ], [ 314, 225 ], [ 257, 228 ], [ 259, 229 ], [ 257, 234 ], [ 259, 235 ], [ 221, 241 ], [ 329, 241 ], [ 257, 242 ], [ 224, 244 ], [ 311, 244 ], [ 259, 245 ], [ 224, 247 ], [ 311, 247 ], [ 257, 249 ], [ 259, 250 ], [ 257, 257 ], [ 259, 259 ], [ 262, 261 ], [ 317, 265 ], [ 329, 266 ], [ 322, 268 ], [ 335, 272 ], [ 311, 275 ], [ 261, 276 ], [ 261, 278 ], [ 335, 280 ], [ 326, 285 ], [ 317, 286 ], [ 311, 288 ], [ 261, 289 ], [ 317, 292 ], [ 261, 294 ], [ 323, 303 ], [ 338, 303 ], [ 328, 311 ], [ 313, 314 ], [ 328, 317 ], [ 322, 323 ], [ 328, 326 ], [ 328, 329 ], [ 337, 338 ], [ 340, 341 ] ]

[ "# D　イロハちゃんと升目\ncnt=0\nh,w,a,b=map(int,input().split())\ndef find_power(n):\n # 0!からn!までのびっくりを出してくれる関数\n powlist=[0]*(n+1)\n powlist[0]=1\n powlist[1]=1\n for i in range(2,n+1):\n powlist[i]=powlist[i-1]*i%(10**9+7)\n return powlist\n\ndef find_inv_power(n):\n #0!からn!までの逆元を10**9+7で割ったあまりリストを作る関数\n powlist=find_power(n)\n check=powlist[-1]\n first=1\n uselist=[0]*(n+1)\n secondlist=[0]*30\n secondlist[0]=check\n secondlist[1]=check**2\n for i in range(28):\n secondlist[i+2]=(secondlist[i+1]**2)%(10**9+7)\n a=format(10**9+5,\"b\")\n for j in range(30):\n if a[29-j]==\"1\":\n first=(first*secondlist[j])%(10**9+7)\n uselist[n]=first\n for i in range(n,0,-1):\n uselist[i-1]=(uselist[i]*i)%(10**9+7)\n return uselist\n\npowlist=find_power(h+w+1)\ninvlist=find_inv_power(h+w+1)\ndef combi(n,r):\n a=powlist\n b=invlist\n if n<r:\n return 0\n elif n>=r:\n return (a[n]*b[r]*b[n-r])%(10**9+7)\n\nfor i in range(h-a):\n cnt+=(combi(b+i-1,i)*combi(w+h-2-b-i,h-1-i))%(10**9+7)\nprint(cnt%(10**9+7))\n ", "cnt=0", "cnt", "0", "h,w,a,b=map(int,input().split())", "h", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "w", "a", "b", "def find_power(n):\n # 0!からn!までのびっくりを出してくれる関数\n powlist=[0]*(n+1)\n powlist[0]=1\n powlist[1]=1\n for i in range(2,n+1):\n powlist[i]=powlist[i-1]*i%(10**9+7)\n return powlist", "find_power", "powlist=[0]*(n+1)", "powlist", "[0]*(n+1)", "[0]", "0", "n+1", "n", "1", "powlist[0]=1", "powlist[0]", "powlist", "0", "1", "powlist[1]=1", "powlist[1]", "powlist", "1", "1", "for i in range(2,n+1):\n powlist[i]=powlist[i-1]*i%(10**9+7)\n ", "i", "range(2,n+1)", "range", "2", "n+1", "n", "1", "powlist[i]=powlist[i-1]*i%(10**9+7)", "powlist[i]", "powlist", "i", "powlist[i-1]*i%(10**9+7)", "powlist[i-1]*i", "powlist[i-1]", "powlist", "i-1", "i", "1", "i", "10**9+7", "10**9", "10", "9", "7", "return powlist", "powlist", "n", "n", "def find_inv_power(n):\n #0!からn!までの逆元を10**9+7で割ったあまりリストを作る関数\n powlist=find_power(n)\n check=powlist[-1]\n first=1\n uselist=[0]*(n+1)\n secondlist=[0]*30\n secondlist[0]=check\n secondlist[1]=check**2\n for i in range(28):\n secondlist[i+2]=(secondlist[i+1]**2)%(10**9+7)\n a=format(10**9+5,\"b\")\n for j in range(30):\n if a[29-j]==\"1\":\n first=(first*secondlist[j])%(10**9+7)\n uselist[n]=first\n for i in range(n,0,-1):\n uselist[i-1]=(uselist[i]*i)%(10**9+7)\n return uselist", "find_inv_power", "powlist=find_power(n)", "powlist", "find_power(n)", "find_power", "n", "check=powlist[-1]", "check", "powlist[-1]", "powlist", "-1", "first=1", "first", "1", "uselist=[0]*(n+1)", "uselist", "[0]*(n+1)", "[0]", "0", "n+1", "n", "1", "secondlist=[0]*30", "secondlist", "[0]*30", "[0]", "0", "30", "secondlist[0]=check", "secondlist[0]", "secondlist", "0", "check", "secondlist[1]=check**2", "secondlist[1]", "secondlist", "1", "check**2", "check", "2", "for i in range(28):\n secondlist[i+2]=(secondlist[i+1]**2)%(10**9+7)\n ", "i", "range(28)", "range", "28", "secondlist[i+2]=(secondlist[i+1]**2)%(10**9+7)", "secondlist[i+2]", "secondlist", "i+2", "i", "2", "(secondlist[i+1]**2)%(10**9+7)", "secondlist[i+1]**2", "secondlist[i+1]", "secondlist", "i+1", "i", "1", "2", "10**9+7", "10**9", "10", "9", "7", "a=format(10**9+5,\"b\")", "a", "format(10**9+5,\"b\")", "format", "10**9+5", "10**9", "10", "9", "5", "\"b\"", "for j in range(30):\n if a[29-j]==\"1\":\n first=(first*secondlist[j])%(10**9+7)\n ", "j", "range(30)", "range", "30", "if a[29-j]==\"1\":\n first=(first*secondlist[j])%(10**9+7)\n ", "a[29-j]==\"1\"", "a[29-j]", "a", "29-j", "29", "j", "\"1\"", "first=(first*secondlist[j])%(10**9+7)", "first", "(first*secondlist[j])%(10**9+7)", "first*secondlist[j]", "first", "secondlist[j]", "secondlist", "j", "10**9+7", "10**9", "10", "9", "7", "uselist[n]=first", "uselist[n]", "uselist", "n", "first", "for i in range(n,0,-1):\n uselist[i-1]=(uselist[i]*i)%(10**9+7)\n ", "i", "range(n,0,-1)", "range", "n", "0", "-1", "uselist[i-1]=(uselist[i]*i)%(10**9+7)", "uselist[i-1]", "uselist", "i-1", "i", "1", "(uselist[i]*i)%(10**9+7)", "uselist[i]*i", "uselist[i]", "uselist", "i", "i", "10**9+7", "10**9", "10", "9", "7", "return uselist", "uselist", "n", "n", "powlist=find_power(h+w+1)", "powlist", "find_power(h+w+1)", "find_power", "h+w+1", "h+w", "h", "w", "1", "invlist=find_inv_power(h+w+1)", "invlist", "find_inv_power(h+w+1)", "find_inv_power", "h+w+1", "h+w", "h", "w", "1", "def combi(n,r):\n a=powlist\n b=invlist\n if n<r:\n return 0\n elif n>=r:\n return (a[n]*b[r]*b[n-r])%(10**9+7)", "combi", "a=powlist", "a", "powlist", "b=invlist", "b", "invlist", "if n<r:\n return 0\n elif n>=r:\n return (a[n]*b[r]*b[n-r])%(10**9+7)", "n<r", "n", "r", "return 0", "0", "elif n>=r:\n return (a[n]*b[r]*b[n-r])%(10**9+7)", "n>=r", "n", "r", "return (a[n]*b[r]*b[n-r])%(10**9+7)", "(a[n]*b[r]*b[n-r])%(10**9+7)", "a[n]*b[r]*b[n-r]", "a[n]*b[r]", "a[n]", "a", "n", "b[r]", "b", "r", "b[n-r]", "b", "n-r", "n", "r", "10**9+7", "10**9", "10", "9", "7", "n", "n", "r", "r", "for i in range(h-a):\n cnt+=(combi(b+i-1,i)*combi(w+h-2-b-i,h-1-i))%(10**9+7)", "i", "range(h-a)", "range", "h-a", "h", "a", "cnt+=(combi(b+i-1,i)*combi(w+h-2-b-i,h-1-i))%(10**9+7)", "cnt", "(combi(b+i-1,i)*combi(w+h-2-b-i,h-1-i))%(10**9+7)", "combi(b+i-1,i)*combi(w+h-2-b-i,h-1-i)", "combi(b+i-1,i)", "combi", "b+i-1", "b+i", "b", "i", "1", "i", "combi(w+h-2-b-i,h-1-i)", "combi", "w+h-2-b-i", "w+h-2-b", "w+h-2", "w+h", "w", "h", "2", "b", "i", "h-1-i", "h-1", "h", "1", "i", "10**9+7", "10**9", "10", "9", "7", "print(cnt%(10**9+7))", "print", "cnt%(10**9+7)", "cnt", "10**9+7", "10**9", "10", "9", "7", "b=map(int,input().split())", "map(int,input().split())", "b", "invlist=find_inv_power(h+w+1)", "find_inv_power(h+w+1)", "invlist", "h,w,a,b=map(int,input().split())", "map(int,input().split())", "h", "def find_inv_power(n):\n #0!からn!までの逆元を10**9+7で割ったあまりリストを作る関数\n powlist=find_power(n)\n check=powlist[-1]\n first=1\n uselist=[0]*(n+1)\n secondlist=[0]*30\n secondlist[0]=check\n secondlist[1]=check**2\n for i in range(28):\n secondlist[i+2]=(secondlist[i+1]**2)%(10**9+7)\n a=format(10**9+5,\"b\")\n for j in range(30):\n if a[29-j]==\"1\":\n first=(first*secondlist[j])%(10**9+7)\n uselist[n]=first\n for i in range(n,0,-1):\n uselist[i-1]=(uselist[i]*i)%(10**9+7)\n return uselist", "def find_inv_power(n):\n #0!からn!までの逆元を10**9+7で割ったあまりリストを作る関数\n powlist=find_power(n)\n check=powlist[-1]\n first=1\n uselist=[0]*(n+1)\n secondlist=[0]*30\n secondlist[0]=check\n secondlist[1]=check**2\n for i in range(28):\n secondlist[i+2]=(secondlist[i+1]**2)%(10**9+7)\n a=format(10**9+5,\"b\")\n for j in range(30):\n if a[29-j]==\"1\":\n first=(first*secondlist[j])%(10**9+7)\n uselist[n]=first\n for i in range(n,0,-1):\n uselist[i-1]=(uselist[i]*i)%(10**9+7)\n return uselist", "find_inv_power", "cnt+=(combi(b+i-1,i)*combi(w+h-2-b-i,h-1-i))%(10**9+7)", "(combi(b+i-1,i)*combi(w+h-2-b-i,h-1-i))%(10**9+7)", "cnt", "w,a,b=map(int,input().split())", "map(int,input().split())", "w", "a,b=map(int,input().split())", "map(int,input().split())", "a", "def find_power(n):\n # 0!からn!までのびっくりを出してくれる関数\n powlist=[0]*(n+1)\n powlist[0]=1\n powlist[1]=1\n for i in range(2,n+1):\n powlist[i]=powlist[i-1]*i%(10**9+7)\n return powlist", "def find_power(n):\n # 0!からn!までのびっくりを出してくれる関数\n powlist=[0]*(n+1)\n powlist[0]=1\n powlist[1]=1\n for i in range(2,n+1):\n powlist[i]=powlist[i-1]*i%(10**9+7)\n return powlist", "find_power", "def combi(n,r):\n a=powlist\n b=invlist\n if n<r:\n return 0\n elif n>=r:\n return (a[n]*b[r]*b[n-r])%(10**9+7)", "def combi(n,r):\n a=powlist\n b=invlist\n if n<r:\n return 0\n elif n>=r:\n return (a[n]*b[r]*b[n-r])%(10**9+7)", "combi", "cnt=0", "0", "cnt", "powlist=find_power(h+w+1)", "find_power(h+w+1)", "powlist" ]

[ 7, 6, 13, 12, 13, 0, 18, 13, 13, 17, 0, 18, 13, 13, 17, 23, 13, 6, 13, 12, 13, 41, 28, 13, 4, 13, 2, 13, 17, 4, 4, 13, 0, 18, 13, 13, 13, 0, 18, 13, 13, 13, 28, 13, 4, 13, 17, 2, 13, 17, 0, 18, 18, 18, 13, 13, 13, 13, 2, 2, 18, 18, 18, 13, 13, 2, 13, 17, 13, 13, 18, 13, 13, 0, 18, 18, 18, 13, 13, 13, 13, 4, 13, 18, 18, 18, 13, 13, 13, 13, 2, 18, 13, 13, 17, 18, 13, 13, 28, 13, 4, 13, 13, 17, 17, 0, 18, 18, 18, 13, 13, 2, 13, 17, 13, 2, 2, 18, 18, 18, 13, 13, 13, 13, 13, 18, 13, 13, 23, 13, 23, 13, 23, 13, 12, 13, 14, 2, 13, 13, 29, 17, 29, 2, 2, 2, 18, 18, 18, 13, 13, 13, 13, 18, 18, 18, 13, 13, 2, 13, 13, 13, 18, 18, 18, 13, 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, 17, 0, 13, 2, 2, 17, 17, 17, 0, 13, 4, 13, 2, 2, 13, 13, 17, 13, 28, 13, 4, 13, 2, 13, 13, 0, 13, 2, 2, 4, 18, 13, 13, 2, 2, 13, 13, 17, 13, 4, 18, 13, 13, 2, 2, 2, 2, 13, 13, 17, 13, 13, 2, 2, 13, 17, 13, 13, 4, 13, 2, 13, 13, 10, 17, 13, 10, 2, 13, 10, 4, 13, 10, 6, 13, 10, 6, 13, 10, 4, 13, 10, 4, 13, 10, 4, 13, 10, 4, 13, 10, 2, 13 ]

[ [ 9, 6 ], [ 16, 7 ], [ 14, 11 ], [ 16, 12 ], [ 16, 16 ], [ 24, 23 ], [ 131, 27 ], [ 36, 33 ], [ 129, 34 ], [ 41, 38 ], [ 129, 39 ], [ 133, 40 ], [ 133, 41 ], [ 44, 43 ], [ 131, 48 ], [ 58, 51 ], [ 33, 53 ], [ 129, 54 ], [ 43, 56 ], [ 33, 62 ], [ 129, 63 ], [ 43, 66 ], [ 43, 69 ], [ 38, 70 ], [ 129, 71 ], [ 133, 72 ], [ 81, 74 ], [ 33, 76 ], [ 129, 77 ], [ 131, 79 ], [ 33, 85 ], [ 129, 86 ], [ 131, 88 ], [ 38, 91 ], [ 129, 92 ], [ 133, 93 ], [ 38, 95 ], [ 129, 96 ], [ 133, 97 ], [ 100, 99 ], [ 131, 102 ], [ 115, 106 ], [ 33, 108 ], [ 129, 109 ], [ 99, 112 ], [ 33, 119 ], [ 129, 120 ], [ 99, 122 ], [ 99, 124 ], [ 38, 125 ], [ 129, 126 ], [ 133, 127 ], [ 129, 129 ], [ 131, 131 ], [ 133, 133 ], [ 175, 138 ], [ 177, 139 ], [ 173, 149 ], [ 175, 151 ], [ 173, 156 ], [ 175, 159 ], [ 177, 160 ], [ 173, 165 ], [ 177, 167 ], [ 173, 170 ], [ 173, 173 ], [ 175, 175 ], [ 177, 177 ], [ 281, 179 ], [ 281, 188 ], [ 281, 189 ], [ 281, 190 ], [ 257, 192 ], [ 260, 195 ], [ 275, 202 ], [ 279, 207 ], [ 273, 208 ], [ 261, 210 ], [ 213, 212 ], [ 273, 216 ], [ 264, 217 ], [ 284, 219 ], [ 276, 224 ], [ 135, 225 ], [ 282, 228 ], [ 212, 229 ], [ 212, 231 ], [ 276, 234 ], [ 135, 235 ], [ 279, 240 ], [ 273, 241 ], [ 282, 243 ], [ 212, 244 ], [ 273, 247 ], [ 212, 249 ], [ 261, 250 ], [ 285, 254 ], [ 258, 254 ], [ 261, 255 ], [ 257, 258 ], [ 260, 261 ], [ 281, 264 ], [ 281, 273 ], [ 275, 276 ], [ 281, 279 ], [ 281, 282 ], [ 284, 285 ] ]

[ "#ライブラリの点検\nclass Data():\n def __init__(self):\n self.power=1\n self.rev=1 \nclass Combi():\n def __init__(self,N,mod):\n self.lists=[Data() for _ in range(N+1)]\n self.mod=mod \n for i in range(2,N+1):\n self.lists[i].power=((self.lists[i-1].power)*i)%self.mod\n self.lists[N].rev=pow(self.lists[N].power,self.mod-2,self.mod)\n for j in range(N,0,-1):\n self.lists[j-1].rev=((self.lists[j].rev)*j)%self.mod\n\n def combi(self,K,R):\n if K<R:\n return 0\n else:\n return ((self.lists[K].power)*(self.lists[K-R].rev)*(self.lists[R].rev))%self.mod\n\n######################\nh,w,a,b=map(int,input().split())\nans=0\nmod=10**9+7\nC=Combi(w+h+2,mod)\nfor i in range(h-a):\n ans+=C.combi(b+i-1,i)*C.combi(w+h-2-b-i,h-1-i)%mod\nprint(ans%mod)\n######################", "class Data():\n def __init__(self):\n self.power=1\n self.rev=1 ", "Data", "def __init__(self):\n self.power=1\n self.rev=1 ", "__init__", "self.power=1", "self.power", "self", "power", "1", "self.rev=1", "self.rev", "self", "rev", "1", "self", "self", "class Combi():\n def __init__(self,N,mod):\n self.lists=[Data() for _ in range(N+1)]\n self.mod=mod \n for i in range(2,N+1):\n self.lists[i].power=((self.lists[i-1].power)*i)%self.mod\n self.lists[N].rev=pow(self.lists[N].power,self.mod-2,self.mod)\n for j in range(N,0,-1):\n self.lists[j-1].rev=((self.lists[j].rev)*j)%self.mod\n\n def combi(self,K,R):\n if K<R:\n return 0\n else:\n return ((self.lists[K].power)*(self.lists[K-R].rev)*(self.lists[R].rev))%self.mod\n\n######################", "Combi", "def __init__(self,N,mod):\n self.lists=[Data() for _ in range(N+1)]\n self.mod=mod \n for i in range(2,N+1):\n self.lists[i].power=((self.lists[i-1].power)*i)%self.mod\n self.lists[N].rev=pow(self.lists[N].power,self.mod-2,self.mod)\n for j in range(N,0,-1):\n self.lists[j-1].rev=((self.lists[j].rev)*j)%self.mod\n\n ", "__init__", "Data() for _ in range(N+1)", "for _ in range(N+1)", "_", "range(N+1)", "range", "N+1", "N", "1", "for _ in range(N+1)", "Data()", "Data", "self.lists=[Data() for _ in range(N+1)]", "self.lists", "self", "lists", "[Data() for _ in range(N+1)]", "self.mod=mod", "self.mod", "self", "mod", "mod", "for i in range(2,N+1):\n self.lists[i].power=((self.lists[i-1].power)*i)%self.mod\n ", "i", "range(2,N+1)", "range", "2", "N+1", "N", "1", "self.lists[i].power=((self.lists[i-1].power)*i)%self.mod", "self.lists[i].power", "self.lists[i]", "self.lists", "self", "lists", "i", "power", "((self.lists[i-1].power)*i)%self.mod", "(self.lists[i-1].power)*i", "self.lists[i-1].power", "self.lists[i-1]", "self.lists", "self", "lists", "i-1", "i", "1", "power", "i", "self.mod", "self", "mod", "self.lists[N].rev=pow(self.lists[N].power,self.mod-2,self.mod)", "self.lists[N].rev", "self.lists[N]", "self.lists", "self", "lists", "N", "rev", "pow(self.lists[N].power,self.mod-2,self.mod)", "pow", "self.lists[N].power", "self.lists[N]", "self.lists", "self", "lists", "N", "power", "self.mod-2", "self.mod", "self", "mod", "2", "self.mod", "self", "mod", "for j in range(N,0,-1):\n self.lists[j-1].rev=((self.lists[j].rev)*j)%self.mod\n\n ", "j", "range(N,0,-1)", "range", "N", "0", "-1", "self.lists[j-1].rev=((self.lists[j].rev)*j)%self.mod", "self.lists[j-1].rev", "self.lists[j-1]", "self.lists", "self", "lists", "j-1", "j", "1", "rev", "((self.lists[j].rev)*j)%self.mod", "(self.lists[j].rev)*j", "self.lists[j].rev", "self.lists[j]", "self.lists", "self", "lists", "j", "rev", "j", "self.mod", "self", "mod", "self", "self", "N", "N", "mod", "mod", "def combi(self,K,R):\n if K<R:\n return 0\n else:\n return ((self.lists[K].power)*(self.lists[K-R].rev)*(self.lists[R].rev))%self.mod\n\n######################", "combi", "if K<R:\n return 0\n else:\n return ((self.lists[K].power)*(self.lists[K-R].rev)*(self.lists[R].rev))%self.mod\n\n######################", "K<R", "K", "R", "return 0", "0", "return ((self.lists[K].power)*(self.lists[K-R].rev)*(self.lists[R].rev))%self.mod", "((self.lists[K].power)*(self.lists[K-R].rev)*(self.lists[R].rev))%self.mod", "(self.lists[K].power)*(self.lists[K-R].rev)*(self.lists[R].rev)", "(self.lists[K].power)*(self.lists[K-R].rev)", "self.lists[K].power", "self.lists[K]", "self.lists", "self", "lists", "K", "power", "self.lists[K-R].rev", "self.lists[K-R]", "self.lists", "self", "lists", "K-R", "K", "R", "rev", "self.lists[R].rev", "self.lists[R]", "self.lists", "self", "lists", "R", "rev", "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", "ans=0", "ans", "0", "mod=10**9+7", "mod", "10**9+7", "10**9", "10", "9", "7", "C=Combi(w+h+2,mod)", "C", "Combi(w+h+2,mod)", "Combi", "w+h+2", "w+h", "w", "h", "2", "mod", "for i in range(h-a):\n ans+=C.combi(b+i-1,i)*C.combi(w+h-2-b-i,h-1-i)%mod", "i", "range(h-a)", "range", "h-a", "h", "a", "ans+=C.combi(b+i-1,i)*C.combi(w+h-2-b-i,h-1-i)%mod", "ans", "C.combi(b+i-1,i)*C.combi(w+h-2-b-i,h-1-i)%mod", "C.combi(b+i-1,i)*C.combi(w+h-2-b-i,h-1-i)", "C.combi(b+i-1,i)", "C.combi", "C", "combi", "b+i-1", "b+i", "b", "i", "1", "i", "C.combi(w+h-2-b-i,h-1-i)", "C.combi", "C", "combi", "w+h-2-b-i", "w+h-2-b", "w+h-2", "w+h", "w", "h", "2", "b", "i", "h-1-i", "h-1", "h", "1", "i", "mod", "print(ans%mod)", "print", "ans%mod", "ans", "mod", "ans=0", "0", "ans", "mod=10**9+7", "10**9+7", "mod", "a,b=map(int,input().split())", "map(int,input().split())", "a", "class Data():\n def __init__(self):\n self.power=1\n self.rev=1 ", "class Data():\n def __init__(self):\n self.power=1\n self.rev=1 ", "Data", "class Combi():\n def __init__(self,N,mod):\n self.lists=[Data() for _ in range(N+1)]\n self.mod=mod \n for i in range(2,N+1):\n self.lists[i].power=((self.lists[i-1].power)*i)%self.mod\n self.lists[N].rev=pow(self.lists[N].power,self.mod-2,self.mod)\n for j in range(N,0,-1):\n self.lists[j-1].rev=((self.lists[j].rev)*j)%self.mod\n\n def combi(self,K,R):\n if K<R:\n return 0\n else:\n return ((self.lists[K].power)*(self.lists[K-R].rev)*(self.lists[R].rev))%self.mod\n\n######################", "class Combi():\n def __init__(self,N,mod):\n self.lists=[Data() for _ in range(N+1)]\n self.mod=mod \n for i in range(2,N+1):\n self.lists[i].power=((self.lists[i-1].power)*i)%self.mod\n self.lists[N].rev=pow(self.lists[N].power,self.mod-2,self.mod)\n for j in range(N,0,-1):\n self.lists[j-1].rev=((self.lists[j].rev)*j)%self.mod\n\n def combi(self,K,R):\n if K<R:\n return 0\n else:\n return ((self.lists[K].power)*(self.lists[K-R].rev)*(self.lists[R].rev))%self.mod\n\n######################", "Combi", "h,w,a,b=map(int,input().split())", "map(int,input().split())", "h", "C=Combi(w+h+2,mod)", "Combi(w+h+2,mod)", "C", "w,a,b=map(int,input().split())", "map(int,input().split())", "w", "b=map(int,input().split())", "map(int,input().split())", "b", "ans+=C.combi(b+i-1,i)*C.combi(w+h-2-b-i,h-1-i)%mod", "C.combi(b+i-1,i)*C.combi(w+h-2-b-i,h-1-i)%mod", "ans" ]

[ 7, 12, 13, 41, 29, 2, 2, 2, 18, 13, 13, 18, 13, 2, 13, 13, 18, 13, 13, 13, 23, 13, 23, 13, 0, 13, 17, 0, 13, 17, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 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, 0, 13, 17, 28, 13, 4, 13, 2, 13, 13, 0, 13, 2, 4, 13, 2, 2, 13, 17, 13, 2, 13, 17, 4, 13, 2, 2, 2, 2, 2, 13, 17, 13, 13, 17, 13, 2, 2, 13, 17, 13, 0, 13, 2, 2, 13, 13, 13, 4, 13, 13, 10, 17, 13, 10, 4, 13, 10, 2, 13, 10, 2, 13, 10, 4, 13, 10, 13, 13, 10, 4, 13, 10, 17, 13, 10, 17, 13, 10, 4, 13, 10, 12, 13, 10, 13, 13 ]

[ [ 21, 10 ], [ 21, 14 ], [ 23, 15 ], [ 23, 18 ], [ 21, 21 ], [ 23, 23 ], [ 173, 25 ], [ 149, 28 ], [ 176, 31 ], [ 176, 40 ], [ 176, 41 ], [ 176, 42 ], [ 46, 45 ], [ 150, 48 ], [ 182, 52 ], [ 57, 56 ], [ 150, 59 ], [ 164, 63 ], [ 67, 66 ], [ 150, 70 ], [ 75, 72 ], [ 183, 73 ], [ 66, 74 ], [ 183, 78 ], [ 66, 80 ], [ 66, 82 ], [ 174, 83 ], [ 88, 85 ], [ 165, 86 ], [ 66, 87 ], [ 72, 90 ], [ 183, 91 ], [ 66, 92 ], [ 174, 94 ], [ 174, 96 ], [ 170, 98 ], [ 102, 101 ], [ 168, 105 ], [ 177, 106 ], [ 158, 108 ], [ 180, 111 ], [ 153, 114 ], [ 101, 116 ], [ 153, 118 ], [ 180, 121 ], [ 162, 127 ], [ 153, 129 ], [ 168, 130 ], [ 101, 132 ], [ 162, 135 ], [ 153, 137 ], [ 155, 139 ], [ 171, 142 ], [ 156, 142 ], [ 159, 143 ], [ 174, 144 ], [ 156, 147 ], [ 171, 147 ], [ 149, 150 ], [ 176, 153 ], [ 155, 156 ], [ 158, 159 ], [ 176, 162 ], [ 164, 165 ], [ 176, 168 ], [ 170, 171 ], [ 173, 174 ], [ 176, 177 ], [ 182, 183 ] ]

[ "def nCr(n, r):\n\tglobal fact, inv, MOD\n\treturn (fact[n] * inv[n-r] * inv[r]) % MOD\n\nMOD = 1000000007\nMAX = 200001\n\nh, w, a, b = map(int, input().split())\n\nfact = [1 for i in range(MAX)]\ninv = [1 for i in range(MAX)]\n\nfor i in range(1, MAX):\n\tfact[i] = (fact[i-1] * i) % MOD\n\tinv[i] = pow(fact[i], MOD-2, MOD)\n\nans = 0\nfor i in range(h - a):\n\tt = nCr(b-1+i, b-1) * nCr(w-1-b + h-1-i, w-1-b)\n\tans = (ans + t) % MOD\n\nprint(ans)", "def nCr(n, r):\n\tglobal fact, inv, MOD\n\treturn (fact[n] * inv[n-r] * inv[r]) % MOD", "nCr", "global fact, inv, MOD", "return (fact[n] * inv[n-r] * inv[r]) % MOD", "(fact[n] * inv[n-r] * inv[r]) % MOD", "fact[n] * inv[n-r] * inv[r]", "fact[n] * inv[n-r]", "fact[n]", "fact", "n", "inv[n-r]", "inv", "n-r", "n", "r", "inv[r]", "inv", "r", "MOD", "n", "n", "r", "r", "MOD = 1000000007", "MOD", "1000000007", "MAX = 200001", "MAX", "200001", "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(MAX)", "for i in range(MAX)", "i", "range(MAX)", "range", "MAX", "for i in range(MAX)", "1", "fact = [1 for i in range(MAX)]", "fact", "[1 for i in range(MAX)]", "1 for i in range(MAX)", "for i in range(MAX)", "i", "range(MAX)", "range", "MAX", "for i in range(MAX)", "1", "inv = [1 for i in range(MAX)]", "inv", "[1 for i in range(MAX)]", "for i in range(1, MAX):\n\tfact[i] = (fact[i-1] * i) % MOD\n\tinv[i] = pow(fact[i], MOD-2, MOD)", "i", "range(1, MAX)", "range", "1", "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] = pow(fact[i], MOD-2, MOD)", "inv[i]", "inv", "i", "pow(fact[i], MOD-2, MOD)", "pow", "fact[i]", "fact", "i", "MOD-2", "MOD", "2", "MOD", "ans = 0", "ans", "0", "for i in range(h - a):\n\tt = nCr(b-1+i, b-1) * nCr(w-1-b + h-1-i, w-1-b)\n\tans = (ans + t) % MOD", "i", "range(h - a)", "range", "h - a", "h", "a", "t = nCr(b-1+i, b-1) * nCr(w-1-b + h-1-i, w-1-b)", "t", "nCr(b-1+i, b-1) * nCr(w-1-b + h-1-i, w-1-b)", "nCr(b-1+i, b-1)", "nCr", "b-1+i", "b-1", "b", "1", "i", "b-1", "b", "1", "nCr(w-1-b + h-1-i, w-1-b)", "nCr", "w-1-b + h-1-i", "w-1-b + h-1", "w-1-b + h", "w-1-b", "w-1", "w", "1", "b", "h", "1", "i", "w-1-b", "w-1", "w", "1", "b", "ans = (ans + t) % MOD", "ans", "(ans + t) % MOD", "ans + t", "ans", "t", "MOD", "print(ans)", "print", "ans", "MAX = 200001", "200001", "MAX", "b = map(int, input().split())", "map(int, input().split())", "b", "ans = (ans + t) % MOD", "(ans + t) % MOD", "ans", "t = nCr(b-1+i, b-1) * nCr(w-1-b + h-1-i, w-1-b)", "nCr(b-1+i, b-1) * nCr(w-1-b + h-1-i, w-1-b)", "t", "w, a, b = map(int, input().split())", "map(int, input().split())", "w", "inv = [1 for i in range(MAX)]", "[1 for i in range(MAX)]", "inv", "h, w, a, b = map(int, input().split())", "map(int, input().split())", "h", "ans = 0", "0", "ans", "MOD = 1000000007", "1000000007", "MOD", "a, b = map(int, input().split())", "map(int, input().split())", "a", "def nCr(n, r):\n\tglobal fact, inv, MOD\n\treturn (fact[n] * inv[n-r] * inv[r]) % MOD", "def nCr(n, r):\n\tglobal fact, inv, MOD\n\treturn (fact[n] * inv[n-r] * inv[r]) % MOD", "nCr", "fact = [1 for i in range(MAX)]", "[1 for i in range(MAX)]", "fact" ]

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

[ [ 10, 7 ], [ 24, 8 ], [ 28, 9 ], [ 28, 10 ], [ 15, 12 ], [ 24, 13 ], [ 24, 17 ], [ 26, 19 ], [ 15, 20 ], [ 24, 21 ], [ 24, 24 ], [ 26, 26 ], [ 29, 28 ], [ 85, 39 ], [ 85, 42 ], [ 83, 43 ], [ 48, 47 ], [ 81, 52 ], [ 83, 54 ], [ 81, 57 ], [ 85, 59 ], [ 81, 61 ], [ 65, 64 ], [ 47, 67 ], [ 81, 70 ], [ 83, 73 ], [ 85, 74 ], [ 81, 76 ], [ 64, 79 ], [ 47, 79 ], [ 81, 81 ], [ 83, 83 ], [ 85, 85 ], [ 90, 89 ], [ 170, 94 ], [ 98, 97 ], [ 170, 102 ], [ 106, 105 ], [ 168, 107 ], [ 111, 110 ], [ 170, 115 ], [ 121, 118 ], [ 89, 119 ], [ 110, 120 ], [ 89, 124 ], [ 110, 126 ], [ 110, 128 ], [ 105, 129 ], [ 134, 131 ], [ 97, 132 ], [ 170, 133 ], [ 89, 137 ], [ 170, 138 ], [ 105, 140 ], [ 105, 142 ], [ 145, 144 ], [ 170, 147 ], [ 156, 151 ], [ 97, 152 ], [ 144, 154 ], [ 97, 159 ], [ 144, 160 ], [ 144, 161 ], [ 105, 162 ], [ 168, 168 ], [ 170, 170 ], [ 315, 176 ], [ 315, 185 ], [ 315, 186 ], [ 315, 187 ], [ 297, 189 ], [ 300, 196 ], [ 298, 206 ], [ 306, 208 ], [ 303, 211 ], [ 316, 213 ], [ 295, 214 ], [ 282, 216 ], [ 310, 218 ], [ 304, 223 ], [ 286, 223 ], [ 283, 226 ], [ 292, 226 ], [ 277, 227 ], [ 288, 229 ], [ 301, 231 ], [ 304, 234 ], [ 286, 234 ], [ 283, 235 ], [ 292, 235 ], [ 304, 238 ], [ 286, 238 ], [ 279, 241 ], [ 301, 243 ], [ 316, 247 ], [ 304, 248 ], [ 286, 248 ], [ 277, 249 ], [ 283, 250 ], [ 292, 250 ], [ 316, 252 ], [ 304, 253 ], [ 286, 253 ], [ 312, 255 ], [ 307, 258 ], [ 313, 258 ], [ 289, 260 ], [ 280, 261 ], [ 298, 262 ], [ 285, 264 ], [ 291, 267 ], [ 313, 271 ], [ 307, 271 ], [ 315, 277 ], [ 279, 280 ], [ 282, 283 ], [ 285, 286 ], [ 288, 289 ], [ 291, 292 ], [ 315, 295 ], [ 297, 298 ], [ 300, 301 ], [ 303, 304 ], [ 306, 307 ], [ 315, 310 ], [ 312, 313 ], [ 315, 316 ] ]

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

[ 7, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 13, 13, 0, 13, 2, 2, 17, 17, 17, 0, 13, 39, 17, 28, 13, 4, 13, 17, 2, 2, 13, 13, 17, 4, 18, 13, 13, 2, 2, 18, 13, 17, 13, 13, 0, 13, 39, 28, 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, 0, 13, 2, 39, 17, 13, 28, 13, 4, 13, 13, 13, 0, 18, 13, 13, 4, 13, 2, 2, 2, 13, 13, 17, 13, 2, 2, 13, 13, 17, 0, 13, 17, 28, 13, 4, 13, 13, 13, 0, 13, 2, 4, 13, 2, 2, 2, 13, 13, 13, 17, 2, 13, 17, 18, 13, 13, 0, 13, 13, 4, 13, 13, 10, 13, 13, 10, 17, 13, 10, 2, 13, 10, 2, 13, 10, 39, 13, 10, 4, 13, 10, 4, 13, 10, 12, 13, 10, 2, 13, 10, 39, 13, 10, 4, 13, 10, 4, 13 ]

[ [ 182, 2 ], [ 182, 11 ], [ 182, 12 ], [ 182, 13 ], [ 158, 15 ], [ 161, 22 ], [ 27, 26 ], [ 180, 32 ], [ 168, 33 ], [ 162, 37 ], [ 162, 42 ], [ 26, 44 ], [ 159, 45 ], [ 176, 47 ], [ 51, 50 ], [ 162, 50 ], [ 177, 54 ], [ 50, 58 ], [ 159, 60 ], [ 159, 62 ], [ 162, 70 ], [ 82, 71 ], [ 177, 73 ], [ 84, 74 ], [ 177, 76 ], [ 82, 78 ], [ 84, 79 ], [ 159, 80 ], [ 82, 82 ], [ 84, 84 ], [ 173, 86 ], [ 168, 90 ], [ 93, 92 ], [ 183, 95 ], [ 168, 96 ], [ 101, 98 ], [ 174, 99 ], [ 92, 100 ], [ 171, 102 ], [ 180, 106 ], [ 165, 107 ], [ 92, 109 ], [ 180, 112 ], [ 165, 113 ], [ 152, 116 ], [ 120, 119 ], [ 183, 122 ], [ 168, 123 ], [ 155, 125 ], [ 171, 128 ], [ 165, 132 ], [ 168, 133 ], [ 119, 134 ], [ 165, 137 ], [ 98, 139 ], [ 174, 140 ], [ 119, 141 ], [ 149, 143 ], [ 159, 144 ], [ 150, 147 ], [ 156, 147 ], [ 153, 147 ], [ 159, 149 ], [ 149, 150 ], [ 152, 153 ], [ 155, 156 ], [ 158, 159 ], [ 161, 162 ], [ 182, 165 ], [ 182, 168 ], [ 173, 174 ], [ 176, 177 ], [ 182, 180 ], [ 182, 183 ] ]

[ "h, w, a, b = map(int, input().split())\n\nmodulo = 10 ** 9 + 7\n\nfactorials = [1]\nfor i in range(1, h + w + 1):\n factorials.append((factorials[-1] * i) % modulo)\n\n\ninverses = []\nfor f in factorials:\n inverses.append(pow(f, modulo - 2, modulo))\n\ndef cnk(n, k):\n return (factorials[n] * inverses[k] * inverses[n - k]) % modulo\n\n\nline_before = [0] * w\n\nfor j in range(b, w):\n line_before[j] = cnk(h - a - 1 + j, h - a - 1)\n\n\ns = 0\nfor j in range(b, w):\n s += cnk(a + w - j - 2, a - 1) * line_before[j]\n s %= modulo\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", "modulo = 10 ** 9 + 7", "modulo", "10 ** 9 + 7", "10 ** 9", "10", "9", "7", "factorials = [1]", "factorials", "[1]", "1", "for i in range(1, h + w + 1):\n factorials.append((factorials[-1] * i) % modulo)", "i", "range(1, h + w + 1)", "range", "1", "h + w + 1", "h + w", "h", "w", "1", "factorials.append((factorials[-1] * i) % modulo)", "factorials.append", "factorials", "append", "(factorials[-1] * i) % modulo", "factorials[-1] * i", "factorials[-1]", "factorials", "-1", "i", "modulo", "inverses = []", "inverses", "[]", "for f in factorials:\n inverses.append(pow(f, modulo - 2, modulo))", "f", "factorials", "inverses.append(pow(f, modulo - 2, modulo))", "inverses.append", "inverses", "append", "pow(f, modulo - 2, modulo)", "pow", "f", "modulo - 2", "modulo", "2", "modulo", "def cnk(n, k):\n return (factorials[n] * inverses[k] * inverses[n - k]) % modulo", "cnk", "return (factorials[n] * inverses[k] * inverses[n - k]) % modulo", "(factorials[n] * inverses[k] * inverses[n - k]) % modulo", "factorials[n] * inverses[k] * inverses[n - k]", "factorials[n] * inverses[k]", "factorials[n]", "factorials", "n", "inverses[k]", "inverses", "k", "inverses[n - k]", "inverses", "n - k", "n", "k", "modulo", "n", "n", "k", "k", "line_before = [0] * w", "line_before", "[0] * w", "[0]", "0", "w", "for j in range(b, w):\n line_before[j] = cnk(h - a - 1 + j, h - a - 1)", "j", "range(b, w)", "range", "b", "w", "line_before[j] = cnk(h - a - 1 + j, h - a - 1)", "line_before[j]", "line_before", "j", "cnk(h - a - 1 + j, h - a - 1)", "cnk", "h - a - 1 + j", "h - a - 1", "h - a", "h", "a", "1", "j", "h - a - 1", "h - a", "h", "a", "1", "s = 0", "s", "0", "for j in range(b, w):\n s += cnk(a + w - j - 2, a - 1) * line_before[j]\n s %= modulo", "j", "range(b, w)", "range", "b", "w", "s += cnk(a + w - j - 2, a - 1) * line_before[j]", "s", "cnk(a + w - j - 2, a - 1) * line_before[j]", "cnk(a + w - j - 2, a - 1)", "cnk", "a + w - j - 2", "a + w - j", "a + w", "a", "w", "j", "2", "a - 1", "a", "1", "line_before[j]", "line_before", "j", "s %= modulo", "s", "modulo", "print(s)", "print", "s", "s %= modulo", "modulo", "s", "s = 0", "0", "s", "s += cnk(a + w - j - 2, a - 1) * line_before[j]", "cnk(a + w - j - 2, a - 1) * line_before[j]", "s", "modulo = 10 ** 9 + 7", "10 ** 9 + 7", "modulo", "factorials = [1]", "[1]", "factorials", "a, b = map(int, input().split())", "map(int, input().split())", "a", "w, a, b = map(int, input().split())", "map(int, input().split())", "w", "def cnk(n, k):\n return (factorials[n] * inverses[k] * inverses[n - k]) % modulo", "def cnk(n, k):\n return (factorials[n] * inverses[k] * inverses[n - k]) % modulo", "cnk", "line_before = [0] * w", "[0] * w", "line_before", "inverses = []", "[]", "inverses", "h, w, a, b = map(int, input().split())", "map(int, input().split())", "h", "b = map(int, input().split())", "map(int, input().split())", "b" ]

[ 7, 0, 13, 2, 2, 17, 17, 17, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 13, 13, 0, 13, 2, 13, 13, 0, 13, 2, 39, 17, 2, 13, 17, 0, 13, 2, 39, 17, 2, 13, 17, 28, 13, 4, 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, 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, 2, 2, 2, 18, 13, 13, 2, 18, 13, 13, 18, 13, 2, 13, 13, 13, 13, 29, 13, 23, 13, 23, 13, 0, 13, 17, 28, 13, 4, 13, 2, 13, 13, 0, 13, 2, 2, 4, 13, 2, 2, 2, 2, 13, 13, 17, 13, 13, 2, 13, 13, 4, 13, 2, 2, 13, 17, 2, 2, 2, 13, 13, 13, 17, 2, 13, 17, 13, 0, 13, 13, 4, 13, 13, 10, 2, 13, 10, 2, 13, 10, 2, 13, 10, 2, 13, 10, 4, 13, 10, 4, 13, 10, 4, 13, 10, 2, 13, 10, 4, 13, 10, 12, 13, 10, 13, 13, 10, 17, 13 ]

[ [ 187, 2 ], [ 208, 9 ], [ 208, 18 ], [ 208, 19 ], [ 208, 20 ], [ 205, 22 ], [ 209, 24 ], [ 203, 25 ], [ 190, 27 ], [ 206, 32 ], [ 193, 35 ], [ 206, 40 ], [ 44, 43 ], [ 206, 46 ], [ 53, 48 ], [ 191, 49 ], [ 43, 51 ], [ 191, 56 ], [ 43, 57 ], [ 43, 59 ], [ 188, 61 ], [ 66, 63 ], [ 194, 64 ], [ 191, 69 ], [ 188, 72 ], [ 188, 74 ], [ 77, 76 ], [ 206, 79 ], [ 88, 83 ], [ 194, 84 ], [ 76, 86 ], [ 194, 91 ], [ 76, 92 ], [ 76, 93 ], [ 188, 94 ], [ 131, 100 ], [ 131, 103 ], [ 129, 104 ], [ 109, 108 ], [ 191, 113 ], [ 129, 114 ], [ 194, 117 ], [ 131, 118 ], [ 194, 120 ], [ 129, 122 ], [ 131, 123 ], [ 188, 124 ], [ 188, 125 ], [ 108, 127 ], [ 129, 129 ], [ 131, 131 ], [ 217, 133 ], [ 137, 136 ], [ 203, 140 ], [ 200, 141 ], [ 184, 143 ], [ 212, 147 ], [ 209, 152 ], [ 197, 153 ], [ 200, 155 ], [ 136, 156 ], [ 200, 158 ], [ 136, 159 ], [ 212, 161 ], [ 197, 164 ], [ 203, 169 ], [ 200, 170 ], [ 136, 171 ], [ 197, 174 ], [ 188, 176 ], [ 214, 178 ], [ 188, 179 ], [ 215, 182 ], [ 185, 182 ], [ 218, 182 ], [ 184, 185 ], [ 187, 188 ], [ 190, 191 ], [ 193, 194 ], [ 208, 197 ], [ 208, 200 ], [ 208, 203 ], [ 205, 206 ], [ 208, 209 ], [ 188, 214 ], [ 214, 215 ], [ 217, 218 ] ]

[ "MOD = 10**9+7\n\nh,w,a,b = map(int,input().split())\n\nn = h+w\nfac = [1]*(n+1)\nfac_inv = [0]*(n+1)\n\nfor i in range(n):\n fac[i+1] = (fac[i] * (i+1)) %MOD\nfac_inv[-1] = pow(fac[-1],MOD-2,MOD)\nfor i in range(n,0,-1):\n fac_inv[i-1] = (fac_inv[i] * i) % MOD\n \ndef comb(n,k):\n if k<0 or k>n:\n return 0\n x = (fac[n] * (fac_inv[k] * fac_inv[n-k])%MOD)%MOD\n return x\n\nans = 0\n\nfor i in range(w-b):\n \n ans += comb((h-a-1) + b+i, b+i) * comb((a-1) + (w - b-i-1), a-1) %MOD\n ans %= MOD\n \nprint(ans)", "MOD = 10**9+7", "MOD", "10**9+7", "10**9", "10", "9", "7", "h,w,a,b = map(int,input().split())", "h", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "w", "a", "b", "n = h+w", "n", "h+w", "h", "w", "fac = [1]*(n+1)", "fac", "[1]*(n+1)", "[1]", "1", "n+1", "n", "1", "fac_inv = [0]*(n+1)", "fac_inv", "[0]*(n+1)", "[0]", "0", "n+1", "n", "1", "for i in range(n):\n fac[i+1] = (fac[i] * (i+1)) %MOD", "i", "range(n)", "range", "n", "fac[i+1] = (fac[i] * (i+1)) %MOD", "fac[i+1]", "fac", "i+1", "i", "1", "(fac[i] * (i+1)) %MOD", "fac[i] * (i+1)", "fac[i]", "fac", "i", "i+1", "i", "1", "MOD", "fac_inv[-1] = pow(fac[-1],MOD-2,MOD)", "fac_inv[-1]", "fac_inv", "-1", "pow(fac[-1],MOD-2,MOD)", "pow", "fac[-1]", "fac", "-1", "MOD-2", "MOD", "2", "MOD", "for i in range(n,0,-1):\n fac_inv[i-1] = (fac_inv[i] * i) % MOD\n ", "i", "range(n,0,-1)", "range", "n", "0", "-1", "fac_inv[i-1] = (fac_inv[i] * i) % MOD", "fac_inv[i-1]", "fac_inv", "i-1", "i", "1", "(fac_inv[i] * i) % MOD", "fac_inv[i] * i", "fac_inv[i]", "fac_inv", "i", "i", "MOD", "def comb(n,k):\n if k<0 or k>n:\n return 0\n x = (fac[n] * (fac_inv[k] * fac_inv[n-k])%MOD)%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 = (fac[n] * (fac_inv[k] * fac_inv[n-k])%MOD)%MOD", "x", "(fac[n] * (fac_inv[k] * fac_inv[n-k])%MOD)%MOD", "fac[n] * (fac_inv[k] * fac_inv[n-k])%MOD", "fac[n] * (fac_inv[k] * fac_inv[n-k])", "fac[n]", "fac", "n", "fac_inv[k] * fac_inv[n-k]", "fac_inv[k]", "fac_inv", "k", "fac_inv[n-k]", "fac_inv", "n-k", "n", "k", "MOD", "MOD", "return x", "x", "n", "n", "k", "k", "ans = 0", "ans", "0", "for i in range(w-b):\n \n ans += comb((h-a-1) + b+i, b+i) * comb((a-1) + (w - b-i-1), a-1) %MOD\n ans %= MOD\n ", "i", "range(w-b)", "range", "w-b", "w", "b", "ans += comb((h-a-1) + b+i, b+i) * comb((a-1) + (w - b-i-1), a-1) %MOD", "ans", "comb((h-a-1) + b+i, b+i) * comb((a-1) + (w - b-i-1), a-1) %MOD", "comb((h-a-1) + b+i, b+i) * comb((a-1) + (w - b-i-1), 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((a-1) + (w - b-i-1), a-1)", "comb", "(a-1) + (w - b-i-1)", "a-1", "a", "1", "w - b-i-1", "w - b-i", "w - b", "w", "b", "i", "1", "a-1", "a", "1", "MOD", "ans %= MOD", "ans", "MOD", "print(ans)", "print", "ans", "ans += comb((h-a-1) + b+i, b+i) * comb((a-1) + (w - b-i-1), a-1) %MOD", "comb((h-a-1) + b+i, b+i) * comb((a-1) + (w - b-i-1), a-1) %MOD", "ans", "MOD = 10**9+7", "10**9+7", "MOD", "fac = [1]*(n+1)", "[1]*(n+1)", "fac", "fac_inv = [0]*(n+1)", "[0]*(n+1)", "fac_inv", "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", "n = h+w", "h+w", "n", "h,w,a,b = map(int,input().split())", "map(int,input().split())", "h", "def comb(n,k):\n if k<0 or k>n:\n return 0\n x = (fac[n] * (fac_inv[k] * fac_inv[n-k])%MOD)%MOD\n return x", "def comb(n,k):\n if k<0 or k>n:\n return 0\n x = (fac[n] * (fac_inv[k] * fac_inv[n-k])%MOD)%MOD\n return x", "comb", "ans %= MOD", "MOD", "ans", "ans = 0", "0", "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, 12, 13, 14, 2, 13, 17, 29, 39, 17, 17, 0, 13, 2, 13, 13, 13, 2, 13, 13, 0, 13, 4, 13, 13, 13, 13, 29, 39, 2, 13, 2, 13, 13, 13, 23, 13, 23, 13, 14, 2, 13, 17, 0, 13, 13, 29, 2, 18, 4, 13, 13, 13, 17, 13, 23, 13, 23, 13, 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, 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, 2, 2, 18, 13, 2, 13, 17, 4, 13, 13, 13, 0, 13, 17, 28, 13, 4, 13, 2, 13, 13, 0, 13, 2, 2, 4, 13, 2, 2, 13, 13, 17, 13, 4, 13, 2, 2, 2, 2, 2, 13, 13, 17, 13, 13, 17, 2, 2, 13, 13, 17, 13, 4, 13, 2, 13, 13, 10, 2, 13, 10, 2, 13, 10, 2, 13, 10, 4, 13, 10, 17, 13, 10, 4, 13, 10, 4, 13, 10, 4, 13, 10, 12, 13, 10, 12, 13, 10, 2, 13, 10, 2, 13 ]

[ [ 239, 2 ], [ 239, 11 ], [ 239, 12 ], [ 239, 13 ], [ 224, 15 ], [ 234, 17 ], [ 237, 18 ], [ 248, 20 ], [ 63, 32 ], [ 40, 39 ], [ 65, 41 ], [ 63, 42 ], [ 44, 43 ], [ 65, 45 ], [ 63, 46 ], [ 49, 48 ], [ 43, 51 ], [ 63, 52 ], [ 49, 53 ], [ 53, 57 ], [ 39, 59 ], [ 48, 60 ], [ 63, 63 ], [ 65, 65 ], [ 85, 68 ], [ 72, 71 ], [ 85, 72 ], [ 29, 77 ], [ 71, 78 ], [ 83, 78 ], [ 85, 79 ], [ 85, 81 ], [ 83, 83 ], [ 86, 85 ], [ 118, 92 ], [ 118, 95 ], [ 116, 96 ], [ 116, 105 ], [ 118, 108 ], [ 116, 112 ], [ 118, 113 ], [ 249, 114 ], [ 116, 116 ], [ 118, 118 ], [ 251, 120 ], [ 225, 125 ], [ 218, 128 ], [ 225, 133 ], [ 137, 136 ], [ 225, 141 ], [ 147, 144 ], [ 252, 145 ], [ 136, 146 ], [ 252, 150 ], [ 136, 152 ], [ 136, 154 ], [ 249, 155 ], [ 160, 157 ], [ 219, 158 ], [ 136, 159 ], [ 219, 163 ], [ 136, 165 ], [ 243, 168 ], [ 136, 169 ], [ 249, 170 ], [ 230, 172 ], [ 176, 175 ], [ 234, 179 ], [ 228, 180 ], [ 221, 182 ], [ 246, 186 ], [ 175, 189 ], [ 240, 190 ], [ 175, 192 ], [ 246, 194 ], [ 237, 200 ], [ 240, 201 ], [ 234, 203 ], [ 175, 204 ], [ 234, 208 ], [ 175, 209 ], [ 249, 211 ], [ 222, 215 ], [ 231, 215 ], [ 249, 216 ], [ 218, 219 ], [ 221, 222 ], [ 224, 225 ], [ 239, 228 ], [ 230, 231 ], [ 239, 234 ], [ 239, 237 ], [ 239, 240 ], [ 248, 249 ], [ 251, 252 ] ]

[ "h,w,a,b=map(int,input().split())\nn=h+w\nMOD = 10**9+7\n\ndef inv_mod(a, p=MOD):\n def inv_mod_sub(a, p):\n if a == 1:\n return 1, 0\n else:\n d, r = p//a, p%a\n x, y = inv_mod_sub(r, a)\n return y-d*x, x\n if p < 0: p = -p\n a %= p\n return inv_mod_sub(a,p)[0] % p\n\ndef comb_mod(n, k):\n if k < 0 or k > n:\n return 0\n else:\n return f_mod[n]*f_mod_inverse[k]*f_mod_inverse[n-k] % MOD\nf_mod=[1]*(n+1)\nf_mod_inverse=[1]*(n+1)\nfor i in range(1,n+1):\n f_mod[i]=f_mod[i-1]*i%MOD\n f_mod_inverse[i]=f_mod_inverse[i-1]*inv_mod(i)%MOD\n\nans=0\nfor i in range(h-a):\n ans+=(comb_mod(i+b-1,i)*comb_mod(w-b-1+h-i-1,h-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", "n=h+w", "n", "h+w", "h", "w", "MOD = 10**9+7", "MOD", "10**9+7", "10**9", "10", "9", "7", "def inv_mod(a, p=MOD):\n def inv_mod_sub(a, p):\n if a == 1:\n return 1, 0\n else:\n d, r = p//a, p%a\n x, y = inv_mod_sub(r, a)\n return y-d*x, x\n if p < 0: p = -p\n a %= p\n return inv_mod_sub(a,p)[0] % p", "inv_mod", "def inv_mod_sub(a, p):\n if a == 1:\n return 1, 0\n else:\n d, r = p//a, p%a\n x, y = inv_mod_sub(r, a)\n return y-d*x, x\n ", "inv_mod_sub", "if a == 1:\n return 1, 0\n else:\n d, r = p//a, p%a\n x, y = inv_mod_sub(r, a)\n return y-d*x, x\n ", "a == 1", "a", "1", "return 1, 0", "return 1, 0", "1", "0", "d, r = p//a, p%a", "d", "p//a", "p", "a", "r", "p%a", "p", "a", "x, y = inv_mod_sub(r, a)", "x", "inv_mod_sub(r, a)", "inv_mod_sub", "r", "a", "y", "return y-d*x, x", "return y-d*x, x", "y-d*x", "y", "d*x", "d", "x", "x", "a", "a", "p", "p", "if p < 0: p = -p\n ", "p < 0", "p", "0", "a %= p", "a", "p", "return inv_mod_sub(a,p)[0] % p", "inv_mod_sub(a,p)[0] % p", "inv_mod_sub(a,p)[0]", "(a,p)", "inv_mod_sub", "a", "p", "0", "p", "a", "a", "p=MOD", "p", "MOD", "def comb_mod(n, k):\n if k < 0 or k > n:\n return 0\n else:\n return f_mod[n]*f_mod_inverse[k]*f_mod_inverse[n-k] % MOD", "comb_mod", "if k < 0 or k > n:\n return 0\n else:\n return f_mod[n]*f_mod_inverse[k]*f_mod_inverse[n-k] % MOD", "k < 0 or k > n", "k < 0", "k", "0", "k > n", "k", "n", "return 0", "0", "return f_mod[n]*f_mod_inverse[k]*f_mod_inverse[n-k] % MOD", "f_mod[n]*f_mod_inverse[k]*f_mod_inverse[n-k] % MOD", "f_mod[n]*f_mod_inverse[k]*f_mod_inverse[n-k]", "f_mod[n]*f_mod_inverse[k]", "f_mod[n]", "f_mod", "n", "f_mod_inverse[k]", "f_mod_inverse", "k", "f_mod_inverse[n-k]", "f_mod_inverse", "n-k", "n", "k", "MOD", "n", "n", "k", "k", "f_mod=[1]*(n+1)", "f_mod", "[1]*(n+1)", "[1]", "1", "n+1", "n", "1", "f_mod_inverse=[1]*(n+1)", "f_mod_inverse", "[1]*(n+1)", "[1]", "1", "n+1", "n", "1", "for i in range(1,n+1):\n f_mod[i]=f_mod[i-1]*i%MOD\n f_mod_inverse[i]=f_mod_inverse[i-1]*inv_mod(i)%MOD", "i", "range(1,n+1)", "range", "1", "n+1", "n", "1", "f_mod[i]=f_mod[i-1]*i%MOD", "f_mod[i]", "f_mod", "i", "f_mod[i-1]*i%MOD", "f_mod[i-1]*i", "f_mod[i-1]", "f_mod", "i-1", "i", "1", "i", "MOD", "f_mod_inverse[i]=f_mod_inverse[i-1]*inv_mod(i)%MOD", "f_mod_inverse[i]", "f_mod_inverse", "i", "f_mod_inverse[i-1]*inv_mod(i)%MOD", "f_mod_inverse[i-1]*inv_mod(i)", "f_mod_inverse[i-1]", "f_mod_inverse", "i-1", "i", "1", "inv_mod(i)", "inv_mod", "i", "MOD", "ans=0", "ans", "0", "for i in range(h-a):\n ans+=(comb_mod(i+b-1,i)*comb_mod(w-b-1+h-i-1,h-i-1))%MOD", "i", "range(h-a)", "range", "h-a", "h", "a", "ans+=(comb_mod(i+b-1,i)*comb_mod(w-b-1+h-i-1,h-i-1))%MOD", "ans", "(comb_mod(i+b-1,i)*comb_mod(w-b-1+h-i-1,h-i-1))%MOD", "comb_mod(i+b-1,i)*comb_mod(w-b-1+h-i-1,h-i-1)", "comb_mod(i+b-1,i)", "comb_mod", "i+b-1", "i+b", "i", "b", "1", "i", "comb_mod(w-b-1+h-i-1,h-i-1)", "comb_mod", "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", "MOD", "print(ans%MOD)", "print", "ans%MOD", "ans", "MOD", "f_mod_inverse=[1]*(n+1)", "[1]*(n+1)", "f_mod_inverse", "ans+=(comb_mod(i+b-1,i)*comb_mod(w-b-1+h-i-1,h-i-1))%MOD", "(comb_mod(i+b-1,i)*comb_mod(w-b-1+h-i-1,h-i-1))%MOD", "ans", "n=h+w", "h+w", "n", "a,b=map(int,input().split())", "map(int,input().split())", "a", "ans=0", "0", "ans", "h,w,a,b=map(int,input().split())", "map(int,input().split())", "h", "w,a,b=map(int,input().split())", "map(int,input().split())", "w", "b=map(int,input().split())", "map(int,input().split())", "b", "def inv_mod(a, p=MOD):\n def inv_mod_sub(a, p):\n if a == 1:\n return 1, 0\n else:\n d, r = p//a, p%a\n x, y = inv_mod_sub(r, a)\n return y-d*x, x\n if p < 0: p = -p\n a %= p\n return inv_mod_sub(a,p)[0] % p", "def inv_mod(a, p=MOD):\n def inv_mod_sub(a, p):\n if a == 1:\n return 1, 0\n else:\n d, r = p//a, p%a\n x, y = inv_mod_sub(r, a)\n return y-d*x, x\n if p < 0: p = -p\n a %= p\n return inv_mod_sub(a,p)[0] % p", "inv_mod", "def comb_mod(n, k):\n if k < 0 or k > n:\n return 0\n else:\n return f_mod[n]*f_mod_inverse[k]*f_mod_inverse[n-k] % MOD", "def comb_mod(n, k):\n if k < 0 or k > n:\n return 0\n else:\n return f_mod[n]*f_mod_inverse[k]*f_mod_inverse[n-k] % MOD", "comb_mod", "MOD = 10**9+7", "10**9+7", "MOD", "f_mod=[1]*(n+1)", "[1]*(n+1)", "f_mod" ]

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

[ [ 365, 2 ], [ 365, 11 ], [ 365, 12 ], [ 365, 13 ], [ 18, 17 ], [ 58, 22 ], [ 28, 25 ], [ 17, 26 ], [ 33, 30 ], [ 17, 31 ], [ 36, 35 ], [ 58, 40 ], [ 46, 43 ], [ 17, 44 ], [ 35, 45 ], [ 17, 49 ], [ 35, 51 ], [ 35, 53 ], [ 60, 54 ], [ 17, 56 ], [ 58, 58 ], [ 61, 60 ], [ 70, 69 ], [ 351, 71 ], [ 199, 72 ], [ 75, 74 ], [ 69, 76 ], [ 80, 79 ], [ 83, 82 ], [ 199, 87 ], [ 91, 90 ], [ 99, 96 ], [ 90, 97 ], [ 74, 99 ], [ 104, 101 ], [ 90, 102 ], [ 74, 105 ], [ 109, 108 ], [ 118, 113 ], [ 90, 114 ], [ 108, 116 ], [ 90, 121 ], [ 108, 123 ], [ 133, 132 ], [ 143, 142 ], [ 132, 149 ], [ 333, 149 ], [ 142, 152 ], [ 156, 155 ], [ 79, 158 ], [ 155, 158 ], [ 90, 160 ], [ 142, 161 ], [ 171, 168 ], [ 82, 169 ], [ 199, 170 ], [ 155, 171 ], [ 79, 171 ], [ 174, 173 ], [ 199, 176 ], [ 185, 180 ], [ 82, 181 ], [ 173, 183 ], [ 82, 188 ], [ 173, 189 ], [ 173, 190 ], [ 82, 197 ], [ 199, 199 ], [ 323, 201 ], [ 329, 208 ], [ 351, 210 ], [ 324, 218 ], [ 341, 220 ], [ 357, 222 ], [ 259, 234 ], [ 261, 235 ], [ 259, 240 ], [ 261, 241 ], [ 330, 247 ], [ 259, 248 ], [ 342, 250 ], [ 261, 251 ], [ 342, 253 ], [ 259, 255 ], [ 261, 256 ], [ 263, 257 ], [ 259, 259 ], [ 261, 261 ], [ 264, 263 ], [ 326, 270 ], [ 274, 273 ], [ 339, 277 ], [ 333, 278 ], [ 353, 280 ], [ 348, 282 ], [ 273, 285 ], [ 363, 286 ], [ 273, 288 ], [ 344, 290 ], [ 348, 292 ], [ 339, 297 ], [ 366, 298 ], [ 363, 299 ], [ 273, 301 ], [ 339, 304 ], [ 273, 305 ], [ 335, 308 ], [ 354, 310 ], [ 345, 311 ], [ 359, 313 ], [ 360, 321 ], [ 336, 321 ], [ 327, 321 ], [ 323, 324 ], [ 326, 327 ], [ 329, 330 ], [ 365, 333 ], [ 335, 336 ], [ 365, 339 ], [ 341, 342 ], [ 344, 345 ], [ 353, 354 ], [ 359, 360 ], [ 365, 363 ], [ 365, 366 ] ]

[ "h,w,a,b = map(int, input().split())\ndef find_power(n,mod=10**9+7):\n powlist=[0]*(n+1)\n powlist[0]=1\n powlist[1]=1\n for i in range(2,n+1):\n powlist[i]=powlist[i-1]*i%(mod)\n return powlist\ndef find_inv_power(n):\n powlist=find_power(n)\n check=powlist[-1]\n first=1\n uselist=[0]*(n+1)\n secondlist=[0]*30\n secondlist[0]=check\n secondlist[1]=check**2\n for i in range(28):\n secondlist[i+2]=(secondlist[i+1]**2)%(10**9+7)\n a=format(10**9+5,\"b\")\n for j in range(30):\n if a[29-j]==\"1\":\n first=(first*secondlist[j])%(10**9+7)\n uselist[n]=first\n for i in range(n,0,-1):\n uselist[i-1]=(uselist[i]*i)%(10**9+7)\n return uselist\nmod = 10**9+7\np_lis=find_power(4*10**5+100,mod)\nip_lis=find_inv_power(4*10**5+100)\n\ndef comb(n,r,mod=10**9+7):\n if n<r:\n return 0\n elif n>=r:\n return (p_lis[n]*ip_lis[r]*ip_lis[n-r])%(mod)\nans=0\nfor i in range(h-a):\n pre=comb(i+b-1,i)\n post=comb(h+w-b-2-i,h-i-1)\n ans+=pre*post\n ans%=10**9+7\nprint(ans)", "h,w,a,b = map(int, input().split())", "h", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "w", "a", "b", "def find_power(n,mod=10**9+7):\n powlist=[0]*(n+1)\n powlist[0]=1\n powlist[1]=1\n for i in range(2,n+1):\n powlist[i]=powlist[i-1]*i%(mod)\n return powlist", "find_power", "powlist=[0]*(n+1)", "powlist", "[0]*(n+1)", "[0]", "0", "n+1", "n", "1", "powlist[0]=1", "powlist[0]", "powlist", "0", "1", "powlist[1]=1", "powlist[1]", "powlist", "1", "1", "for i in range(2,n+1):\n powlist[i]=powlist[i-1]*i%(mod)\n ", "i", "range(2,n+1)", "range", "2", "n+1", "n", "1", "powlist[i]=powlist[i-1]*i%(mod)", "powlist[i]", "powlist", "i", "powlist[i-1]*i%(mod)", "powlist[i-1]*i", "powlist[i-1]", "powlist", "i-1", "i", "1", "i", "mod", "return powlist", "powlist", "n", "n", "mod=10**9+7", "mod", "10**9+7", "10**9", "10", "9", "7", "def find_inv_power(n):\n powlist=find_power(n)\n check=powlist[-1]\n first=1\n uselist=[0]*(n+1)\n secondlist=[0]*30\n secondlist[0]=check\n secondlist[1]=check**2\n for i in range(28):\n secondlist[i+2]=(secondlist[i+1]**2)%(10**9+7)\n a=format(10**9+5,\"b\")\n for j in range(30):\n if a[29-j]==\"1\":\n first=(first*secondlist[j])%(10**9+7)\n uselist[n]=first\n for i in range(n,0,-1):\n uselist[i-1]=(uselist[i]*i)%(10**9+7)\n return uselist", "find_inv_power", "powlist=find_power(n)", "powlist", "find_power(n)", "find_power", "n", "check=powlist[-1]", "check", "powlist[-1]", "powlist", "-1", "first=1", "first", "1", "uselist=[0]*(n+1)", "uselist", "[0]*(n+1)", "[0]", "0", "n+1", "n", "1", "secondlist=[0]*30", "secondlist", "[0]*30", "[0]", "0", "30", "secondlist[0]=check", "secondlist[0]", "secondlist", "0", "check", "secondlist[1]=check**2", "secondlist[1]", "secondlist", "1", "check**2", "check", "2", "for i in range(28):\n secondlist[i+2]=(secondlist[i+1]**2)%(10**9+7)\n ", "i", "range(28)", "range", "28", "secondlist[i+2]=(secondlist[i+1]**2)%(10**9+7)", "secondlist[i+2]", "secondlist", "i+2", "i", "2", "(secondlist[i+1]**2)%(10**9+7)", "secondlist[i+1]**2", "secondlist[i+1]", "secondlist", "i+1", "i", "1", "2", "10**9+7", "10**9", "10", "9", "7", "a=format(10**9+5,\"b\")", "a", "format(10**9+5,\"b\")", "format", "10**9+5", "10**9", "10", "9", "5", "\"b\"", "for j in range(30):\n if a[29-j]==\"1\":\n first=(first*secondlist[j])%(10**9+7)\n ", "j", "range(30)", "range", "30", "if a[29-j]==\"1\":\n first=(first*secondlist[j])%(10**9+7)\n ", "a[29-j]==\"1\"", "a[29-j]", "a", "29-j", "29", "j", "\"1\"", "first=(first*secondlist[j])%(10**9+7)", "first", "(first*secondlist[j])%(10**9+7)", "first*secondlist[j]", "first", "secondlist[j]", "secondlist", "j", "10**9+7", "10**9", "10", "9", "7", "uselist[n]=first", "uselist[n]", "uselist", "n", "first", "for i in range(n,0,-1):\n uselist[i-1]=(uselist[i]*i)%(10**9+7)\n ", "i", "range(n,0,-1)", "range", "n", "0", "-1", "uselist[i-1]=(uselist[i]*i)%(10**9+7)", "uselist[i-1]", "uselist", "i-1", "i", "1", "(uselist[i]*i)%(10**9+7)", "uselist[i]*i", "uselist[i]", "uselist", "i", "i", "10**9+7", "10**9", "10", "9", "7", "return uselist", "uselist", "n", "n", "mod = 10**9+7", "mod", "10**9+7", "10**9", "10", "9", "7", "p_lis=find_power(4*10**5+100,mod)", "p_lis", "find_power(4*10**5+100,mod)", "find_power", "4*10**5+100", "4*10**5", "4", "10**5", "10", "5", "100", "mod", "ip_lis=find_inv_power(4*10**5+100)", "ip_lis", "find_inv_power(4*10**5+100)", "find_inv_power", "4*10**5+100", "4*10**5", "4", "10**5", "10", "5", "100", "def comb(n,r,mod=10**9+7):\n if n<r:\n return 0\n elif n>=r:\n return (p_lis[n]*ip_lis[r]*ip_lis[n-r])%(mod)", "comb", "if n<r:\n return 0\n elif n>=r:\n return (p_lis[n]*ip_lis[r]*ip_lis[n-r])%(mod)", "n<r", "n", "r", "return 0", "0", "elif n>=r:\n return (p_lis[n]*ip_lis[r]*ip_lis[n-r])%(mod)", "n>=r", "n", "r", "return (p_lis[n]*ip_lis[r]*ip_lis[n-r])%(mod)", "(p_lis[n]*ip_lis[r]*ip_lis[n-r])%(mod)", "p_lis[n]*ip_lis[r]*ip_lis[n-r]", "p_lis[n]*ip_lis[r]", "p_lis[n]", "p_lis", "n", "ip_lis[r]", "ip_lis", "r", "ip_lis[n-r]", "ip_lis", "n-r", "n", "r", "mod", "n", "n", "r", "r", "mod=10**9+7", "mod", "10**9+7", "10**9", "10", "9", "7", "ans=0", "ans", "0", "for i in range(h-a):\n pre=comb(i+b-1,i)\n post=comb(h+w-b-2-i,h-i-1)\n ans+=pre*post\n ans%=10**9+7", "i", "range(h-a)", "range", "h-a", "h", "a", "pre=comb(i+b-1,i)", "pre", "comb(i+b-1,i)", "comb", "i+b-1", "i+b", "i", "b", "1", "i", "post=comb(h+w-b-2-i,h-i-1)", "post", "comb(h+w-b-2-i,h-i-1)", "comb", "h+w-b-2-i", "h+w-b-2", "h+w-b", "h+w", "h", "w", "b", "2", "i", "h-i-1", "h-i", "h", "i", "1", "ans+=pre*post", "ans", "pre*post", "pre", "post", "ans%=10**9+7", "ans", "10**9+7", "10**9", "10", "9", "7", "print(ans)", "print", "ans", "mod = 10**9+7", "10**9+7", "mod", "ans=0", "0", "ans", "p_lis=find_power(4*10**5+100,mod)", "find_power(4*10**5+100,mod)", "p_lis", "a,b = map(int, input().split())", "map(int, input().split())", "a", "ans+=pre*post", "pre*post", "ans", "h,w,a,b = map(int, input().split())", "map(int, input().split())", "h", "ip_lis=find_inv_power(4*10**5+100)", "find_inv_power(4*10**5+100)", "ip_lis", "post=comb(h+w-b-2-i,h-i-1)", "comb(h+w-b-2-i,h-i-1)", "post", "def comb(n,r,mod=10**9+7):\n if n<r:\n return 0\n elif n>=r:\n return (p_lis[n]*ip_lis[r]*ip_lis[n-r])%(mod)", "def comb(n,r,mod=10**9+7):\n if n<r:\n return 0\n elif n>=r:\n return (p_lis[n]*ip_lis[r]*ip_lis[n-r])%(mod)", "comb", "def find_power(n,mod=10**9+7):\n powlist=[0]*(n+1)\n powlist[0]=1\n powlist[1]=1\n for i in range(2,n+1):\n powlist[i]=powlist[i-1]*i%(mod)\n return powlist", "def find_power(n,mod=10**9+7):\n powlist=[0]*(n+1)\n powlist[0]=1\n powlist[1]=1\n for i in range(2,n+1):\n powlist[i]=powlist[i-1]*i%(mod)\n return powlist", "find_power", "pre=comb(i+b-1,i)", "comb(i+b-1,i)", "pre", "def find_inv_power(n):\n powlist=find_power(n)\n check=powlist[-1]\n first=1\n uselist=[0]*(n+1)\n secondlist=[0]*30\n secondlist[0]=check\n secondlist[1]=check**2\n for i in range(28):\n secondlist[i+2]=(secondlist[i+1]**2)%(10**9+7)\n a=format(10**9+5,\"b\")\n for j in range(30):\n if a[29-j]==\"1\":\n first=(first*secondlist[j])%(10**9+7)\n uselist[n]=first\n for i in range(n,0,-1):\n uselist[i-1]=(uselist[i]*i)%(10**9+7)\n return uselist", "def find_inv_power(n):\n powlist=find_power(n)\n check=powlist[-1]\n first=1\n uselist=[0]*(n+1)\n secondlist=[0]*30\n secondlist[0]=check\n secondlist[1]=check**2\n for i in range(28):\n secondlist[i+2]=(secondlist[i+1]**2)%(10**9+7)\n a=format(10**9+5,\"b\")\n for j in range(30):\n if a[29-j]==\"1\":\n first=(first*secondlist[j])%(10**9+7)\n uselist[n]=first\n for i in range(n,0,-1):\n uselist[i-1]=(uselist[i]*i)%(10**9+7)\n return uselist", "find_inv_power", "ans%=10**9+7", "10**9+7", "ans", "b = map(int, input().split())", "map(int, input().split())", "b", "w,a,b = map(int, input().split())", "map(int, input().split())", "w" ]

[ 7, 15, 13, 12, 13, 29, 2, 2, 2, 18, 13, 13, 18, 13, 2, 13, 13, 18, 13, 13, 13, 23, 13, 23, 13, 23, 13, 23, 13, 23, 13, 12, 13, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 13, 13, 0, 13, 2, 17, 2, 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, 2, 2, 13, 13, 17, 4, 13, 18, 13, 2, 2, 13, 13, 17, 2, 13, 17, 13, 28, 13, 4, 13, 4, 13, 17, 2, 2, 13, 13, 17, 0, 13, 17, 28, 13, 4, 13, 2, 13, 17, 2, 13, 17, 0, 13, 4, 13, 2, 2, 2, 13, 13, 13, 17, 2, 13, 17, 13, 13, 13, 0, 13, 4, 13, 2, 2, 2, 13, 13, 13, 17, 2, 13, 17, 13, 13, 13, 0, 13, 2, 2, 13, 13, 13, 0, 13, 13, 4, 13, 13, 29, 17, 14, 2, 13, 17, 4, 13, 10, 12, 13, 10, 12, 13 ]

[ [ 26, 10 ], [ 22, 11 ], [ 28, 13 ], [ 22, 15 ], [ 24, 16 ], [ 28, 18 ], [ 24, 19 ], [ 30, 20 ], [ 22, 22 ], [ 24, 24 ], [ 26, 26 ], [ 28, 28 ], [ 30, 30 ], [ 35, 34 ], [ 35, 43 ], [ 35, 44 ], [ 35, 45 ], [ 48, 47 ], [ 55, 54 ], [ 34, 60 ], [ 43, 61 ], [ 65, 64 ], [ 34, 70 ], [ 43, 71 ], [ 75, 74 ], [ 34, 80 ], [ 43, 81 ], [ 91, 84 ], [ 64, 85 ], [ 34, 88 ], [ 43, 89 ], [ 54, 94 ], [ 34, 97 ], [ 43, 98 ], [ 47, 101 ], [ 47, 103 ], [ 106, 105 ], [ 34, 113 ], [ 43, 114 ], [ 118, 117 ], [ 121, 120 ], [ 45, 124 ], [ 43, 127 ], [ 131, 130 ], [ 186, 132 ], [ 34, 136 ], [ 44, 137 ], [ 120, 138 ], [ 120, 141 ], [ 54, 143 ], [ 64, 144 ], [ 47, 145 ], [ 148, 147 ], [ 186, 149 ], [ 44, 153 ], [ 43, 154 ], [ 120, 155 ], [ 44, 158 ], [ 54, 160 ], [ 64, 161 ], [ 47, 162 ], [ 165, 164 ], [ 130, 167 ], [ 147, 168 ], [ 47, 169 ], [ 172, 171 ], [ 47, 172 ], [ 171, 175 ], [ 164, 175 ], [ 117, 175 ], [ 189, 183 ] ]

[ "import sys\n\ndef comb(n, r, fact, revfact, mod):\n return (fact[n] * revfact[n-r] * revfact[r]) % mod\n\ndef solve():\n H, W, A, B = map(int, input().split())\n mod = 7 + 10 ** 9\n fact = [1] * (H + W + 4)\n revfact = [1] * (H + W + 4)\n for i in range(1, H + W + 4): fact[i] = (i * fact[i-1]) % mod\n revfact[H + W + 3] = pow(fact[H + W + 3], mod - 2, mod)\n for i in reversed(range(1, H + W + 3)): revfact[i] = ((i + 1) * revfact[i + 1]) % mod\n\n ans = 0\n for j in range(B + 1, W + 1):\n up = comb(H - A + j - 2, j - 1, fact, revfact, mod)\n down = comb(A + W - j - 1, A - 1, fact, revfact, mod)\n ans += (up * down) % mod\n ans %= mod\n print(ans)\n\n return 0\n\nif __name__ == \"__main__\":\n solve()", "import sys", "sys", "def comb(n, r, fact, revfact, mod):\n return (fact[n] * revfact[n-r] * revfact[r]) % mod", "comb", "return (fact[n] * revfact[n-r] * revfact[r]) % mod", "(fact[n] * revfact[n-r] * revfact[r]) % mod", "fact[n] * revfact[n-r] * revfact[r]", "fact[n] * revfact[n-r]", "fact[n]", "fact", "n", "revfact[n-r]", "revfact", "n-r", "n", "r", "revfact[r]", "revfact", "r", "mod", "n", "n", "r", "r", "fact", "fact", "revfact", "revfact", "mod", "mod", "def solve():\n H, W, A, B = map(int, input().split())\n mod = 7 + 10 ** 9\n fact = [1] * (H + W + 4)\n revfact = [1] * (H + W + 4)\n for i in range(1, H + W + 4): fact[i] = (i * fact[i-1]) % mod\n revfact[H + W + 3] = pow(fact[H + W + 3], mod - 2, mod)\n for i in reversed(range(1, H + W + 3)): revfact[i] = ((i + 1) * revfact[i + 1]) % mod\n\n ans = 0\n for j in range(B + 1, W + 1):\n up = comb(H - A + j - 2, j - 1, fact, revfact, mod)\n down = comb(A + W - j - 1, A - 1, fact, revfact, mod)\n ans += (up * down) % mod\n ans %= mod\n print(ans)\n\n return 0", "solve", "H, W, A, B = map(int, input().split())", "H", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "W", "A", "B", "mod = 7 + 10 ** 9", "mod", "7 + 10 ** 9", "7", "10 ** 9", "10", "9", "fact = [1] * (H + W + 4)", "fact", "[1] * (H + W + 4)", "[1]", "1", "H + W + 4", "H + W", "H", "W", "4", "revfact = [1] * (H + W + 4)", "revfact", "[1] * (H + W + 4)", "[1]", "1", "H + W + 4", "H + W", "H", "W", "4", "for i in range(1, H + W + 4): fact[i] = (i * fact[i-1]) % mod\n ", "i", "range(1, H + W + 4)", "range", "1", "H + W + 4", "H + W", "H", "W", "4", "revfact[H + W + 3] = pow(fact[H + W + 3], mod - 2, mod)", "revfact[H + W + 3]", "revfact", "H + W + 3", "H + W", "H", "W", "3", "pow(fact[H + W + 3], mod - 2, mod)", "pow", "fact[H + W + 3]", "fact", "H + W + 3", "H + W", "H", "W", "3", "mod - 2", "mod", "2", "mod", "for i in reversed(range(1, H + W + 3)): revfact[i] = ((i + 1) * revfact[i + 1]) % mod\n\n ", "i", "reversed(range(1, H + W + 3))", "reversed", "range(1, H + W + 3)", "range", "1", "H + W + 3", "H + W", "H", "W", "3", "ans = 0", "ans", "0", "for j in range(B + 1, W + 1):\n up = comb(H - A + j - 2, j - 1, fact, revfact, mod)\n down = comb(A + W - j - 1, A - 1, fact, revfact, mod)\n ans += (up * down) % mod\n ans %= mod\n ", "j", "range(B + 1, W + 1)", "range", "B + 1", "B", "1", "W + 1", "W", "1", "up = comb(H - A + j - 2, j - 1, fact, revfact, mod)", "up", "comb(H - A + j - 2, j - 1, fact, revfact, mod)", "comb", "H - A + j - 2", "H - A + j", "H - A", "H", "A", "j", "2", "j - 1", "j", "1", "fact", "revfact", "mod", "down = comb(A + W - j - 1, A - 1, fact, revfact, mod)", "down", "comb(A + W - j - 1, A - 1, fact, revfact, mod)", "comb", "A + W - j - 1", "A + W - j", "A + W", "A", "W", "j", "1", "A - 1", "A", "1", "fact", "revfact", "mod", "ans += (up * down) % mod", "ans", "(up * down) % mod", "up * down", "up", "down", "mod", "ans %= mod", "ans", "mod", "print(ans)", "print", "ans", "return 0", "0", "if __name__ == \"__main__\":\n solve()", "__name__ == \"__main__\"", "__name__", "\"__main__\"", "solve()", "solve", "def comb(n, r, fact, revfact, mod):\n return (fact[n] * revfact[n-r] * revfact[r]) % mod", "def comb(n, r, fact, revfact, mod):\n return (fact[n] * revfact[n-r] * revfact[r]) % mod", "comb", "def solve():\n H, W, A, B = map(int, input().split())\n mod = 7 + 10 ** 9\n fact = [1] * (H + W + 4)\n revfact = [1] * (H + W + 4)\n for i in range(1, H + W + 4): fact[i] = (i * fact[i-1]) % mod\n revfact[H + W + 3] = pow(fact[H + W + 3], mod - 2, mod)\n for i in reversed(range(1, H + W + 3)): revfact[i] = ((i + 1) * revfact[i + 1]) % mod\n\n ans = 0\n for j in range(B + 1, W + 1):\n up = comb(H - A + j - 2, j - 1, fact, revfact, mod)\n down = comb(A + W - j - 1, A - 1, fact, revfact, mod)\n ans += (up * down) % mod\n ans %= mod\n print(ans)\n\n return 0", "def solve():\n H, W, A, B = map(int, input().split())\n mod = 7 + 10 ** 9\n fact = [1] * (H + W + 4)\n revfact = [1] * (H + W + 4)\n for i in range(1, H + W + 4): fact[i] = (i * fact[i-1]) % mod\n revfact[H + W + 3] = pow(fact[H + W + 3], mod - 2, mod)\n for i in reversed(range(1, H + W + 3)): revfact[i] = ((i + 1) * revfact[i + 1]) % mod\n\n ans = 0\n for j in range(B + 1, W + 1):\n up = comb(H - A + j - 2, j - 1, fact, revfact, mod)\n down = comb(A + W - j - 1, A - 1, fact, revfact, mod)\n ans += (up * down) % mod\n ans %= mod\n print(ans)\n\n return 0", "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, 17, 2, 17, 17, 0, 13, 2, 39, 17, 2, 13, 17, 28, 13, 4, 13, 17, 2, 13, 17, 0, 18, 13, 13, 2, 2, 18, 13, 2, 13, 17, 13, 13, 0, 13, 2, 39, 17, 2, 13, 17, 28, 13, 4, 13, 17, 2, 13, 17, 0, 18, 13, 13, 2, 2, 18, 13, 2, 13, 13, 2, 13, 2, 13, 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, 18, 13, 13, 13, 12, 13, 14, 2, 13, 13, 29, 17, 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, 2, 4, 13, 2, 2, 2, 13, 13, 13, 17, 2, 2, 13, 13, 17, 4, 13, 2, 2, 2, 13, 13, 13, 17, 2, 13, 17, 13, 0, 13, 13, 4, 13, 13, 10, 4, 13, 10, 4, 13, 10, 12, 13, 10, 4, 13, 10, 13, 13, 10, 2, 13, 10, 4, 13, 10, 2, 13, 10, 2, 13, 10, 2, 13, 10, 17, 13, 10, 2, 13, 10, 2, 13 ]

[ [ 218, 2 ], [ 218, 11 ], [ 218, 12 ], [ 218, 13 ], [ 224, 15 ], [ 215, 22 ], [ 236, 29 ], [ 216, 34 ], [ 38, 37 ], [ 216, 42 ], [ 48, 45 ], [ 237, 46 ], [ 37, 47 ], [ 237, 51 ], [ 37, 53 ], [ 37, 55 ], [ 225, 56 ], [ 227, 58 ], [ 216, 63 ], [ 67, 66 ], [ 216, 71 ], [ 77, 74 ], [ 228, 75 ], [ 66, 76 ], [ 228, 80 ], [ 225, 82 ], [ 66, 83 ], [ 225, 85 ], [ 225, 87 ], [ 66, 88 ], [ 225, 89 ], [ 233, 91 ], [ 216, 96 ], [ 100, 99 ], [ 216, 104 ], [ 110, 107 ], [ 234, 108 ], [ 99, 109 ], [ 234, 113 ], [ 99, 115 ], [ 74, 117 ], [ 228, 118 ], [ 99, 119 ], [ 225, 120 ], [ 146, 125 ], [ 148, 126 ], [ 237, 134 ], [ 146, 135 ], [ 234, 137 ], [ 146, 139 ], [ 148, 140 ], [ 234, 142 ], [ 148, 143 ], [ 225, 144 ], [ 146, 146 ], [ 148, 148 ], [ 230, 150 ], [ 154, 153 ], [ 201, 157 ], [ 210, 160 ], [ 221, 163 ], [ 207, 167 ], [ 153, 171 ], [ 219, 172 ], [ 204, 173 ], [ 219, 177 ], [ 204, 178 ], [ 207, 181 ], [ 210, 185 ], [ 153, 186 ], [ 204, 187 ], [ 204, 190 ], [ 225, 192 ], [ 212, 194 ], [ 225, 195 ], [ 213, 198 ], [ 222, 198 ], [ 231, 198 ], [ 218, 201 ], [ 218, 204 ], [ 218, 210 ], [ 225, 212 ], [ 212, 213 ], [ 215, 216 ], [ 218, 219 ], [ 221, 222 ], [ 224, 225 ], [ 227, 228 ], [ 230, 231 ], [ 233, 234 ], [ 236, 237 ] ]

[ "h,w,a,b = map(int,input().split())\nmod = 10**9+7\n\nMAX = 2*10**5\nfact = [1]*(MAX+1)\nfor i in range(1, MAX+1):\n fact[i] = (fact[i-1]*i) % mod\n\ninv = [1]*(MAX+1)\nfor i in range(2, MAX+1):\n inv[i] = inv[mod % i]*(mod-mod//i) % mod\n\nfact_inv = [1]*(MAX+1)\nfor i in range(1, MAX+1):\n fact_inv[i] = fact_inv[i-1] * inv[i] % mod\n\ndef comb(n, k):\n if n < k:\n return 0\n return fact[n] * fact_inv[n-k] * fact_inv[k] % mod\n \nans = 0\nfor k in range(b+1,w+1):\n ans += comb(k+h-a-2,h-a-1)*comb(w-k+a-1,a-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 = 2*10**5", "MAX", "2*10**5", "2", "10**5", "10", "5", "fact = [1]*(MAX+1)", "fact", "[1]*(MAX+1)", "[1]", "1", "MAX+1", "MAX", "1", "for i in range(1, MAX+1):\n fact[i] = (fact[i-1]*i) % mod", "i", "range(1, MAX+1)", "range", "1", "MAX+1", "MAX", "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]*(MAX+1)", "inv", "[1]*(MAX+1)", "[1]", "1", "MAX+1", "MAX", "1", "for i in range(2, MAX+1):\n inv[i] = inv[mod % i]*(mod-mod//i) % mod", "i", "range(2, MAX+1)", "range", "2", "MAX+1", "MAX", "1", "inv[i] = inv[mod % i]*(mod-mod//i) % mod", "inv[i]", "inv", "i", "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", "fact_inv = [1]*(MAX+1)", "fact_inv", "[1]*(MAX+1)", "[1]", "1", "MAX+1", "MAX", "1", "for i in range(1, MAX+1):\n fact_inv[i] = fact_inv[i-1] * inv[i] % mod", "i", "range(1, MAX+1)", "range", "1", "MAX+1", "MAX", "1", "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, k):\n if n < k:\n return 0\n return fact[n] * fact_inv[n-k] * fact_inv[k] % mod\n ", "comb", "if n < k:\n return 0\n ", "n < k", "n", "k", "return 0", "0", "return fact[n] * fact_inv[n-k] * fact_inv[k] % mod", "fact[n] * fact_inv[n-k] * fact_inv[k] % mod", "fact[n] * fact_inv[n-k] * fact_inv[k]", "fact[n] * fact_inv[n-k]", "fact[n]", "fact", "n", "fact_inv[n-k]", "fact_inv", "n-k", "n", "k", "fact_inv[k]", "fact_inv", "k", "mod", "n", "n", "k", "k", "ans = 0", "ans", "0", "for k in range(b+1,w+1):\n ans += comb(k+h-a-2,h-a-1)*comb(w-k+a-1,a-1)%mod\n ans %= mod", "k", "range(b+1,w+1)", "range", "b+1", "b", "1", "w+1", "w", "1", "ans += comb(k+h-a-2,h-a-1)*comb(w-k+a-1,a-1)%mod", "ans", "comb(k+h-a-2,h-a-1)*comb(w-k+a-1,a-1)%mod", "comb(k+h-a-2,h-a-1)*comb(w-k+a-1,a-1)", "comb(k+h-a-2,h-a-1)", "comb", "k+h-a-2", "k+h-a", "k+h", "k", "h", "a", "2", "h-a-1", "h-a", "h", "a", "1", "comb(w-k+a-1,a-1)", "comb", "w-k+a-1", "w-k+a", "w-k", "w", "k", "a", "1", "a-1", "a", "1", "mod", "ans %= mod", "ans", "mod", "print(ans)", "print", "ans", "b = map(int,input().split())", "map(int,input().split())", "b", "a,b = map(int,input().split())", "map(int,input().split())", "a", "def comb(n, k):\n if n < k:\n return 0\n return fact[n] * fact_inv[n-k] * fact_inv[k] % mod\n ", "def comb(n, k):\n if n < k:\n return 0\n return fact[n] * fact_inv[n-k] * fact_inv[k] % mod\n ", "comb", "w,a,b = map(int,input().split())", "map(int,input().split())", "w", "ans %= mod", "mod", "ans", "MAX = 2*10**5", "2*10**5", "MAX", "h,w,a,b = map(int,input().split())", "map(int,input().split())", "h", "ans += comb(k+h-a-2,h-a-1)*comb(w-k+a-1,a-1)%mod", "comb(k+h-a-2,h-a-1)*comb(w-k+a-1,a-1)%mod", "ans", "mod = 10**9+7", "10**9+7", "mod", "inv = [1]*(MAX+1)", "[1]*(MAX+1)", "inv", "ans = 0", "0", "ans", "fact_inv = [1]*(MAX+1)", "[1]*(MAX+1)", "fact_inv", "fact = [1]*(MAX+1)", "[1]*(MAX+1)", "fact" ]

[ 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, 17, 4, 17, 0, 13, 13, 41, 28, 13, 4, 13, 17, 4, 17, 0, 13, 13, 41, 28, 13, 4, 13, 17, 4, 17, 0, 13, 13, 28, 13, 4, 13, 17, 17, 0, 18, 13, 13, 2, 2, 18, 13, 2, 13, 17, 13, 13, 0, 18, 13, 13, 2, 2, 13, 2, 18, 13, 2, 13, 13, 2, 13, 13, 13, 0, 18, 13, 13, 2, 2, 18, 13, 2, 13, 17, 18, 13, 13, 13, 12, 13, 29, 2, 2, 2, 18, 13, 13, 18, 13, 13, 18, 13, 2, 13, 13, 13, 23, 13, 23, 13, 0, 13, 17, 0, 13, 17, 42, 2, 40, 2, 13, 13, 13, 2, 2, 2, 2, 13, 13, 13, 17, 17, 0, 13, 2, 4, 13, 2, 2, 2, 13, 13, 17, 2, 2, 13, 13, 13, 2, 2, 13, 13, 17, 4, 13, 2, 2, 2, 13, 2, 13, 13, 13, 2, 2, 2, 13, 13, 13, 17, 2, 13, 2, 2, 2, 13, 13, 13, 17, 0, 13, 13, 0, 13, 17, 4, 13, 13, 10, 13, 13, 10, 4, 13, 10, 13, 13, 10, 4, 13, 10, 17, 13, 10, 13, 13, 10, 17, 13, 10, 2, 13, 10, 13, 13, 10, 4, 13, 10, 4, 13, 10, 12, 13, 10, 2, 13, 10, 17, 13 ]

[ [ 236, 2 ], [ 236, 11 ], [ 236, 12 ], [ 236, 13 ], [ 227, 15 ], [ 24, 23 ], [ 230, 30 ], [ 35, 34 ], [ 221, 41 ], [ 46, 45 ], [ 212, 52 ], [ 56, 55 ], [ 64, 61 ], [ 231, 62 ], [ 55, 63 ], [ 231, 67 ], [ 55, 69 ], [ 55, 71 ], [ 228, 72 ], [ 77, 74 ], [ 222, 75 ], [ 55, 76 ], [ 228, 79 ], [ 222, 82 ], [ 228, 84 ], [ 55, 85 ], [ 228, 87 ], [ 55, 88 ], [ 228, 89 ], [ 94, 91 ], [ 213, 92 ], [ 55, 93 ], [ 213, 97 ], [ 55, 99 ], [ 74, 101 ], [ 222, 102 ], [ 55, 103 ], [ 228, 104 ], [ 231, 112 ], [ 124, 113 ], [ 213, 115 ], [ 126, 116 ], [ 213, 118 ], [ 124, 120 ], [ 126, 121 ], [ 228, 122 ], [ 124, 124 ], [ 126, 126 ], [ 224, 128 ], [ 218, 131 ], [ 210, 137 ], [ 225, 138 ], [ 246, 138 ], [ 216, 139 ], [ 234, 144 ], [ 237, 145 ], [ 225, 146 ], [ 246, 146 ], [ 242, 150 ], [ 240, 153 ], [ 210, 157 ], [ 225, 158 ], [ 246, 158 ], [ 234, 162 ], [ 237, 163 ], [ 225, 164 ], [ 246, 164 ], [ 210, 167 ], [ 225, 168 ], [ 246, 168 ], [ 240, 171 ], [ 216, 175 ], [ 210, 177 ], [ 225, 178 ], [ 246, 178 ], [ 234, 179 ], [ 234, 183 ], [ 237, 184 ], [ 225, 185 ], [ 246, 185 ], [ 234, 188 ], [ 234, 192 ], [ 237, 193 ], [ 225, 194 ], [ 246, 194 ], [ 206, 197 ], [ 228, 198 ], [ 245, 200 ], [ 207, 204 ], [ 243, 204 ], [ 219, 204 ], [ 228, 206 ], [ 206, 207 ], [ 236, 210 ], [ 212, 213 ], [ 236, 216 ], [ 218, 219 ], [ 221, 222 ], [ 224, 225 ], [ 227, 228 ], [ 230, 231 ], [ 236, 234 ], [ 236, 237 ], [ 242, 243 ], [ 245, 246 ] ]

[ "H, W, A, B = map(int,input().split())\nMOD = 10**9 + 7\n\nfac = [1 for k in range(200010)]\ninv = [1 for k in range(200010)]\nfinv = [1 for k in range(200010)]\n\nfor k in range(2,200010):\n fac[k] = (fac[k-1]*k)%MOD\n inv[k] = (MOD - inv[MOD%k] * (MOD // k))%MOD\n finv[k] = (finv[k - 1] * inv[k]) % MOD;\n\ndef nCr(n,r):\n return (fac[n]*finv[r]*finv[n-r])%MOD\n\nk = 1\nans = 0\nwhile B+k <= W and H-A-k+1 > 0:\n ans += nCr(B+k-1+(H-A-k),B+k-1) * nCr(W-(B+k) + H-(H-A-k+1),H-(H-A-k+1))\n ans %= MOD\n k += 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", "1 for k in range(200010)", "for k in range(200010)", "k", "range(200010)", "range", "200010", "for k in range(200010)", "1", "fac = [1 for k in range(200010)]", "fac", "[1 for k in range(200010)]", "1 for k in range(200010)", "for k in range(200010)", "k", "range(200010)", "range", "200010", "for k in range(200010)", "1", "inv = [1 for k in range(200010)]", "inv", "[1 for k in range(200010)]", "1 for k in range(200010)", "for k in range(200010)", "k", "range(200010)", "range", "200010", "for k in range(200010)", "1", "finv = [1 for k in range(200010)]", "finv", "[1 for k in range(200010)]", "for k in range(2,200010):\n fac[k] = (fac[k-1]*k)%MOD\n inv[k] = (MOD - inv[MOD%k] * (MOD // k))%MOD\n finv[k] = (finv[k - 1] * inv[k]) % MOD;", "k", "range(2,200010)", "range", "2", "200010", "fac[k] = (fac[k-1]*k)%MOD", "fac[k]", "fac", "k", "(fac[k-1]*k)%MOD", "fac[k-1]*k", "fac[k-1]", "fac", "k-1", "k", "1", "k", "MOD", "inv[k] = (MOD - inv[MOD%k] * (MOD // k))%MOD", "inv[k]", "inv", "k", "(MOD - inv[MOD%k] * (MOD // k))%MOD", "MOD - inv[MOD%k] * (MOD // k)", "MOD", "inv[MOD%k] * (MOD // k)", "inv[MOD%k]", "inv", "MOD%k", "MOD", "k", "MOD // k", "MOD", "k", "MOD", "finv[k] = (finv[k - 1] * inv[k]) % MOD", "finv[k]", "finv", "k", "(finv[k - 1] * inv[k]) % MOD", "finv[k - 1] * inv[k]", "finv[k - 1]", "finv", "k - 1", "k", "1", "inv[k]", "inv", "k", "MOD", "def nCr(n,r):\n return (fac[n]*finv[r]*finv[n-r])%MOD", "nCr", "return (fac[n]*finv[r]*finv[n-r])%MOD", "(fac[n]*finv[r]*finv[n-r])%MOD", "fac[n]*finv[r]*finv[n-r]", "fac[n]*finv[r]", "fac[n]", "fac", "n", "finv[r]", "finv", "r", "finv[n-r]", "finv", "n-r", "n", "r", "MOD", "n", "n", "r", "r", "k = 1", "k", "1", "ans = 0", "ans", "0", "while B+k <= W and H-A-k+1 > 0:\n ans += nCr(B+k-1+(H-A-k),B+k-1) * nCr(W-(B+k) + H-(H-A-k+1),H-(H-A-k+1))\n ans %= MOD\n k += 1", "B+k <= W and H-A-k+1 > 0", "B+k <= W", "B+k", "B", "k", "W", "H-A-k+1 > 0", "H-A-k+1", "H-A-k", "H-A", "H", "A", "k", "1", "0", "ans += nCr(B+k-1+(H-A-k),B+k-1) * nCr(W-(B+k) + H-(H-A-k+1),H-(H-A-k+1))", "ans", "nCr(B+k-1+(H-A-k),B+k-1) * nCr(W-(B+k) + H-(H-A-k+1),H-(H-A-k+1))", "nCr(B+k-1+(H-A-k),B+k-1)", "nCr", "B+k-1+(H-A-k)", "B+k-1", "B+k", "B", "k", "1", "H-A-k", "H-A", "H", "A", "k", "B+k-1", "B+k", "B", "k", "1", "nCr(W-(B+k) + H-(H-A-k+1),H-(H-A-k+1))", "nCr", "W-(B+k) + H-(H-A-k+1)", "W-(B+k) + H", "W-(B+k)", "W", "B+k", "B", "k", "H", "H-A-k+1", "H-A-k", "H-A", "H", "A", "k", "1", "H-(H-A-k+1)", "H", "H-A-k+1", "H-A-k", "H-A", "H", "A", "k", "1", "ans %= MOD", "ans", "MOD", "k += 1", "k", "1", "print(ans)", "print", "ans", "ans %= MOD", "MOD", "ans", "B = map(int,input().split())", "map(int,input().split())", "B", "finv = [1 for k in range(200010)]", "[1 for k in range(200010)]", "finv", "W, A, B = map(int,input().split())", "map(int,input().split())", "W", "ans = 0", "0", "ans", "inv = [1 for k in range(200010)]", "[1 for k in range(200010)]", "inv", "k = 1", "1", "k", "MOD = 10**9 + 7", "10**9 + 7", "MOD", "fac = [1 for k in range(200010)]", "[1 for k in range(200010)]", "fac", "H, W, A, B = map(int,input().split())", "map(int,input().split())", "H", "A, B = map(int,input().split())", "map(int,input().split())", "A", "def nCr(n,r):\n return (fac[n]*finv[r]*finv[n-r])%MOD", "def nCr(n,r):\n return (fac[n]*finv[r]*finv[n-r])%MOD", "nCr", "ans += nCr(B+k-1+(H-A-k),B+k-1) * nCr(W-(B+k) + H-(H-A-k+1),H-(H-A-k+1))", "nCr(B+k-1+(H-A-k),B+k-1) * nCr(W-(B+k) + H-(H-A-k+1),H-(H-A-k+1))", "ans", "k += 1", "1", "k" ]

[ 7, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 13, 13, 0, 13, 17, 0, 13, 2, 2, 17, 17, 17, 0, 13, 2, 2, 13, 13, 17, 0, 13, 2, 39, 17, 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, 18, 13, 2, 13, 17, 4, 13, 18, 13, 2, 13, 17, 2, 13, 17, 13, 28, 13, 4, 13, 2, 13, 17, 17, 17, 0, 18, 13, 2, 13, 17, 2, 2, 18, 13, 13, 13, 13, 12, 13, 0, 13, 2, 2, 2, 18, 13, 2, 13, 13, 18, 13, 13, 18, 13, 13, 13, 29, 13, 23, 13, 23, 13, 28, 13, 4, 13, 13, 13, 0, 13, 2, 4, 13, 13, 2, 2, 13, 13, 17, 4, 13, 2, 2, 13, 17, 13, 2, 13, 17, 0, 13, 13, 4, 13, 2, 13, 13, 10, 4, 13, 10, 2, 13, 10, 13, 13, 10, 4, 13, 10, 4, 13, 10, 17, 13, 10, 4, 13, 10, 2, 13, 10, 2, 13, 10, 2, 13, 10, 2, 13, 10, 12, 13 ]

[ [ 180, 2 ], [ 180, 11 ], [ 180, 12 ], [ 180, 13 ], [ 177, 15 ], [ 192, 18 ], [ 165, 25 ], [ 175, 28 ], [ 172, 29 ], [ 183, 32 ], [ 166, 36 ], [ 186, 38 ], [ 166, 42 ], [ 45, 44 ], [ 166, 48 ], [ 53, 50 ], [ 184, 51 ], [ 44, 52 ], [ 184, 56 ], [ 44, 58 ], [ 44, 60 ], [ 193, 61 ], [ 68, 63 ], [ 187, 64 ], [ 166, 66 ], [ 184, 71 ], [ 166, 73 ], [ 193, 76 ], [ 193, 78 ], [ 81, 80 ], [ 166, 84 ], [ 94, 89 ], [ 187, 90 ], [ 80, 92 ], [ 187, 97 ], [ 80, 98 ], [ 80, 99 ], [ 193, 100 ], [ 105, 104 ], [ 184, 109 ], [ 123, 111 ], [ 125, 112 ], [ 187, 114 ], [ 123, 115 ], [ 187, 117 ], [ 125, 118 ], [ 193, 119 ], [ 104, 121 ], [ 178, 121 ], [ 123, 123 ], [ 125, 125 ], [ 128, 127 ], [ 163, 130 ], [ 172, 131 ], [ 189, 133 ], [ 196, 136 ], [ 127, 137 ], [ 175, 140 ], [ 181, 141 ], [ 196, 144 ], [ 172, 147 ], [ 127, 149 ], [ 181, 151 ], [ 168, 154 ], [ 193, 155 ], [ 169, 159 ], [ 190, 159 ], [ 178, 159 ], [ 193, 160 ], [ 180, 163 ], [ 165, 166 ], [ 193, 168 ], [ 168, 169 ], [ 180, 172 ], [ 180, 175 ], [ 177, 178 ], [ 180, 181 ], [ 183, 184 ], [ 186, 187 ], [ 189, 190 ], [ 192, 193 ] ]

[ "H, W, A, B = map(int, input().split())\n\nans = 0 \nMOD = 10**9 + 7\nN = H + W - 2\nfac = [1] * N\ninv = [1] * N\n\n# 階乗\nfor i in range(1, N):\n fac[i] = (fac[i - 1] * i) % MOD\n \n# 高速な逆元テーブル　最初にN-1を求めておくことであとはiをかけるだけで残りの逆元が算出できる\ninv[N - 1] = pow(fac[N - 1], MOD - 2, MOD)\nfor i in range(N - 1, 0, -1):\n inv[i - 1] = (inv[i] * i) % MOD\n \n \ndef f(x, y):\n ans = fac[x + y] * inv[x] * inv[y] % MOD\n return ans\n \n\nfor x in range(B, W):\n ans += f(x, H - A - 1) * f(W - 1 - x, A - 1)\n ans %= MOD\n \nprint(ans % MOD)", "H, W, A, B = map(int, input().split())", "H", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "W", "A", "B", "ans = 0", "ans", "0", "MOD = 10**9 + 7", "MOD", "10**9 + 7", "10**9", "10", "9", "7", "N = H + W - 2", "N", "H + W - 2", "H + W", "H", "W", "2", "fac = [1] * N", "fac", "[1] * N", "[1]", "1", "N", "inv = [1] * N", "inv", "[1] * N", "[1]", "1", "N", "for i in range(1, N):\n fac[i] = (fac[i - 1] * i) % MOD\n \n# 高速な逆元テーブル　最初にN-1を求めておくことであとはiをかけるだけで残りの逆元が算出できる", "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", "inv[N - 1] = pow(fac[N - 1], MOD - 2, MOD)", "inv[N - 1]", "inv", "N - 1", "N", "1", "pow(fac[N - 1], MOD - 2, MOD)", "pow", "fac[N - 1]", "fac", "N - 1", "N", "1", "MOD - 2", "MOD", "2", "MOD", "for i in range(N - 1, 0, -1):\n inv[i - 1] = (inv[i] * i) % MOD\n \n ", "i", "range(N - 1, 0, -1)", "range", "N - 1", "N", "1", "0", "-1", "inv[i - 1] = (inv[i] * i) % MOD", "inv[i - 1]", "inv", "i - 1", "i", "1", "(inv[i] * i) % MOD", "inv[i] * i", "inv[i]", "inv", "i", "i", "MOD", "def f(x, y):\n ans = fac[x + y] * inv[x] * inv[y] % MOD\n return ans\n ", "f", "ans = fac[x + y] * inv[x] * inv[y] % MOD", "ans", "fac[x + y] * inv[x] * inv[y] % MOD", "fac[x + y] * inv[x] * inv[y]", "fac[x + y] * inv[x]", "fac[x + y]", "fac", "x + y", "x", "y", "inv[x]", "inv", "x", "inv[y]", "inv", "y", "MOD", "return ans", "ans", "x", "x", "y", "y", "for x in range(B, W):\n ans += f(x, H - A - 1) * f(W - 1 - x, A - 1)\n ans %= MOD\n ", "x", "range(B, W)", "range", "B", "W", "ans += f(x, H - A - 1) * f(W - 1 - x, A - 1)", "ans", "f(x, H - A - 1) * f(W - 1 - x, A - 1)", "f(x, H - A - 1)", "f", "x", "H - A - 1", "H - A", "H", "A", "1", "f(W - 1 - x, A - 1)", "f", "W - 1 - x", "W - 1", "W", "1", "x", "A - 1", "A", "1", "ans %= MOD", "ans", "MOD", "print(ans % MOD)", "print", "ans % MOD", "ans", "MOD", "B = map(int, input().split())", "map(int, input().split())", "B", "N = H + W - 2", "H + W - 2", "N", "ans %= MOD", "MOD", "ans", "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] * N", "[1] * N", "fac", "inv = [1] * N", "[1] * N", "inv", "ans += f(x, H - A - 1) * f(W - 1 - x, A - 1)", "f(x, H - A - 1) * f(W - 1 - x, A - 1)", "ans", "MOD = 10**9 + 7", "10**9 + 7", "MOD", "def f(x, y):\n ans = fac[x + y] * inv[x] * inv[y] % MOD\n return ans\n ", "def f(x, y):\n ans = fac[x + y] * inv[x] * inv[y] % MOD\n return ans\n ", "f" ]

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

[ [ 250, 4 ], [ 14, 13 ], [ 16, 15 ], [ 18, 17 ], [ 20, 19 ], [ 62, 23 ], [ 32, 23 ], [ 27, 26 ], [ 60, 28 ], [ 30, 28 ], [ 62, 29 ], [ 32, 29 ], [ 31, 30 ], [ 62, 31 ], [ 32, 31 ], [ 33, 32 ], [ 30, 34 ], [ 60, 34 ], [ 62, 35 ], [ 32, 35 ], [ 38, 37 ], [ 17, 38 ], [ 39, 38 ], [ 40, 39 ], [ 37, 41 ], [ 13, 41 ], [ 26, 43 ], [ 17, 44 ], [ 39, 44 ], [ 47, 46 ], [ 19, 47 ], [ 48, 47 ], [ 49, 48 ], [ 46, 50 ], [ 15, 50 ], [ 26, 52 ], [ 19, 53 ], [ 48, 53 ], [ 60, 60 ], [ 62, 62 ], [ 67, 66 ], [ 257, 68 ], [ 78, 69 ], [ 251, 70 ], [ 67, 71 ], [ 67, 72 ], [ 71, 75 ], [ 251, 76 ], [ 78, 78 ], [ 268, 80 ], [ 87, 86 ], [ 95, 92 ], [ 269, 93 ], [ 86, 94 ], [ 269, 98 ], [ 86, 100 ], [ 86, 102 ], [ 251, 103 ], [ 108, 107 ], [ 111, 110 ], [ 269, 118 ], [ 107, 120 ], [ 135, 120 ], [ 110, 121 ], [ 137, 121 ], [ 290, 123 ], [ 269, 125 ], [ 107, 126 ], [ 135, 126 ], [ 251, 127 ], [ 290, 129 ], [ 269, 131 ], [ 110, 132 ], [ 137, 132 ], [ 251, 133 ], [ 135, 135 ], [ 137, 137 ], [ 271, 139 ], [ 271, 148 ], [ 271, 149 ], [ 271, 150 ], [ 260, 153 ], [ 266, 155 ], [ 283, 158 ], [ 162, 161 ], [ 266, 167 ], [ 260, 168 ], [ 247, 171 ], [ 275, 175 ], [ 161, 176 ], [ 272, 177 ], [ 275, 179 ], [ 266, 182 ], [ 161, 184 ], [ 254, 186 ], [ 272, 187 ], [ 251, 188 ], [ 248, 191 ], [ 284, 191 ], [ 287, 191 ], [ 251, 192 ], [ 286, 194 ], [ 251, 195 ], [ 287, 198 ], [ 248, 198 ], [ 284, 198 ], [ 280, 200 ], [ 275, 202 ], [ 266, 203 ], [ 254, 204 ], [ 207, 206 ], [ 266, 211 ], [ 260, 212 ], [ 266, 215 ], [ 277, 218 ], [ 275, 222 ], [ 206, 223 ], [ 272, 224 ], [ 275, 226 ], [ 266, 229 ], [ 206, 231 ], [ 254, 233 ], [ 272, 234 ], [ 251, 235 ], [ 278, 238 ], [ 281, 238 ], [ 263, 238 ], [ 287, 238 ], [ 248, 238 ], [ 284, 238 ], [ 262, 241 ], [ 251, 242 ], [ 263, 245 ], [ 278, 245 ], [ 287, 245 ], [ 248, 245 ], [ 284, 245 ], [ 281, 245 ], [ 247, 248 ], [ 250, 251 ], [ 271, 254 ], [ 271, 260 ], [ 251, 262 ], [ 262, 263 ], [ 271, 266 ], [ 268, 269 ], [ 271, 272 ], [ 277, 278 ], [ 280, 281 ], [ 283, 284 ], [ 251, 286 ], [ 286, 287 ] ]

[ "import math\n\nMOD = 10**9+7\n\n\ndef xgcd(a, b):\n x0, y0, x1, y1 = 1, 0, 0, 1\n while b != 0:\n q, a, b = a // b, b, a % b\n x0, x1 = x1, x0 - q * x1\n y0, y1 = y1, y0 - q * y1\n return a, x0, y0\n\n\ndef modinv(a):\n g, x, y = xgcd(a, MOD)\n return x % MOD\n\n\nfact = [1] * 200100\nfor i in range(1, 200100):\n fact[i] = fact[i-1] * i % MOD\n\n\ndef calc(h, w):\n h -= 1\n w -= 1\n return (fact[h+w]*modinv(fact[h]) % MOD)*modinv(fact[w]) % MOD\n\n\nh, w, a, b = map(int, input().split())\nif a >= h // 2:\n ans = 0\n for i in range(1, h - a + 1):\n ans += calc(i, b) * calc(h + 1 - i, w - b) % MOD\n if ans >= MOD:\n ans -= MOD\n print(ans)\n\nelse:\n ans = calc(h, w)\n for i in range(h-a+1, h + 1):\n ans -= calc(i, b) * calc(h + 1 - i, w - b) % MOD\n if ans < 0:\n ans += MOD\n print(ans)", "import math", "math", "MOD = 10**9+7", "MOD", "10**9+7", "10**9", "10", "9", "7", "def xgcd(a, b):\n x0, y0, x1, y1 = 1, 0, 0, 1\n while b != 0:\n q, a, b = a // b, b, a % b\n x0, x1 = x1, x0 - q * x1\n y0, y1 = y1, y0 - q * y1\n return a, x0, y0", "xgcd", "x0, y0, x1, y1 = 1, 0, 0, 1", "x0", "1", "y0", "0", "x1", "0", "y1", "1", "while b != 0:\n q, a, b = a // b, b, a % b\n x0, x1 = x1, x0 - q * x1\n y0, y1 = y1, y0 - q * y1\n ", "b != 0", "b", "0", "q, a, b = a // b, b, a % b", "q", "a // b", "a", "b", "a", "b", "b", "a % b", "a", "b", "x0, x1 = x1, x0 - q * x1", "x0", "x1", "x1", "x0 - q * x1", "x0", "q * x1", "q", "x1", "y0, y1 = y1, y0 - q * y1", "y0", "y1", "y1", "y0 - q * y1", "y0", "q * y1", "q", "y1", "return a, x0, y0", "return a, x0, y0", "a", "x0", "y0", "a", "a", "b", "b", "def modinv(a):\n g, x, y = xgcd(a, MOD)\n return x % MOD", "modinv", "g, x, y = xgcd(a, MOD)", "g", "xgcd(a, MOD)", "xgcd", "a", "MOD", "x", "y", "return x % MOD", "x % MOD", "x", "MOD", "a", "a", "fact = [1] * 200100", "fact", "[1] * 200100", "[1]", "1", "200100", "for i in range(1, 200100):\n fact[i] = fact[i-1] * i % MOD", "i", "range(1, 200100)", "range", "1", "200100", "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 calc(h, w):\n h -= 1\n w -= 1\n return (fact[h+w]*modinv(fact[h]) % MOD)*modinv(fact[w]) % MOD", "calc", "h -= 1", "h", "1", "w -= 1", "w", "1", "return (fact[h+w]*modinv(fact[h]) % MOD)*modinv(fact[w]) % MOD", "(fact[h+w]*modinv(fact[h]) % MOD)*modinv(fact[w]) % MOD", "(fact[h+w]*modinv(fact[h]) % MOD)*modinv(fact[w])", "fact[h+w]*modinv(fact[h]) % MOD", "fact[h+w]*modinv(fact[h])", "fact[h+w]", "fact", "h+w", "h", "w", "modinv(fact[h])", "modinv", "fact[h]", "fact", "h", "MOD", "modinv(fact[w])", "modinv", "fact[w]", "fact", "w", "MOD", "h", "h", "w", "w", "h, w, a, b = map(int, input().split())", "h", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "w", "a", "b", "if a >= h // 2:\n ans = 0\n for i in range(1, h - a + 1):\n ans += calc(i, b) * calc(h + 1 - i, w - b) % MOD\n if ans >= MOD:\n ans -= MOD\n print(ans)\n\nelse:\n ans = calc(h, w)\n for i in range(h-a+1, h + 1):\n ans -= calc(i, b) * calc(h + 1 - i, w - b) % MOD\n if ans < 0:\n ans += MOD\n print(ans)", "a >= h // 2", "a", "h // 2", "h", "2", "ans = 0", "ans", "0", "for i in range(1, h - a + 1):\n ans += calc(i, b) * calc(h + 1 - i, w - b) % MOD\n if ans >= MOD:\n ans -= MOD\n ", "i", "range(1, h - a + 1)", "range", "1", "h - a + 1", "h - a", "h", "a", "1", "ans += calc(i, b) * calc(h + 1 - i, w - b) % MOD", "ans", "calc(i, b) * calc(h + 1 - i, w - b) % MOD", "calc(i, b) * calc(h + 1 - i, w - b)", "calc(i, b)", "calc", "i", "b", "calc(h + 1 - i, w - b)", "calc", "h + 1 - i", "h + 1", "h", "1", "i", "w - b", "w", "b", "MOD", "if ans >= MOD:\n ans -= MOD\n ", "ans >= MOD", "ans", "MOD", "ans -= MOD", "ans", "MOD", "print(ans)", "print", "ans", "ans = calc(h, w)", "ans", "calc(h, w)", "calc", "h", "w", "for i in range(h-a+1, h + 1):\n ans -= calc(i, b) * calc(h + 1 - i, w - b) % MOD\n if ans < 0:\n ans += MOD\n ", "i", "range(h-a+1, h + 1)", "range", "h-a+1", "h-a", "h", "a", "1", "h + 1", "h", "1", "ans -= calc(i, b) * calc(h + 1 - i, w - b) % MOD", "ans", "calc(i, b) * calc(h + 1 - i, w - b) % MOD", "calc(i, b) * calc(h + 1 - i, w - b)", "calc(i, b)", "calc", "i", "b", "calc(h + 1 - i, w - b)", "calc", "h + 1 - i", "h + 1", "h", "1", "i", "w - b", "w", "b", "MOD", "if ans < 0:\n ans += MOD\n ", "ans < 0", "ans", "0", "ans += MOD", "ans", "MOD", "print(ans)", "print", "ans", "ans += calc(i, b) * calc(h + 1 - i, w - b) % MOD", "calc(i, b) * calc(h + 1 - i, w - b) % MOD", "ans", "MOD = 10**9+7", "10**9+7", "MOD", "w, a, b = map(int, input().split())", "map(int, input().split())", "w", "def xgcd(a, b):\n x0, y0, x1, y1 = 1, 0, 0, 1\n while b != 0:\n q, a, b = a // b, b, a % b\n x0, x1 = x1, x0 - q * x1\n y0, y1 = y1, y0 - q * y1\n return a, x0, y0", "def xgcd(a, b):\n x0, y0, x1, y1 = 1, 0, 0, 1\n while b != 0:\n q, a, b = a // b, b, a % b\n x0, x1 = x1, x0 - q * x1\n y0, y1 = y1, y0 - q * y1\n return a, x0, y0", "xgcd", "a, b = map(int, input().split())", "map(int, input().split())", "a", "ans += MOD", "MOD", "ans", "h, w, a, b = map(int, input().split())", "map(int, input().split())", "h", "fact = [1] * 200100", "[1] * 200100", "fact", "b = map(int, input().split())", "map(int, input().split())", "b", "def calc(h, w):\n h -= 1\n w -= 1\n return (fact[h+w]*modinv(fact[h]) % MOD)*modinv(fact[w]) % MOD", "def calc(h, w):\n h -= 1\n w -= 1\n return (fact[h+w]*modinv(fact[h]) % MOD)*modinv(fact[w]) % MOD", "calc", "ans -= calc(i, b) * calc(h + 1 - i, w - b) % MOD", "calc(i, b) * calc(h + 1 - i, w - b) % MOD", "ans", "ans = calc(h, w)", "calc(h, w)", "ans", "ans = 0", "0", "ans", "ans -= MOD", "MOD", "ans", "def modinv(a):\n g, x, y = xgcd(a, MOD)\n return x % MOD", "def modinv(a):\n g, x, y = xgcd(a, MOD)\n return x % MOD", "modinv" ]

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

[ [ 19, 18 ], [ 18, 28 ], [ 36, 35 ], [ 47, 38 ], [ 47, 47 ], [ 72, 71 ], [ 80, 79 ], [ 113, 83 ], [ 88, 85 ], [ 79, 86 ], [ 91, 90 ], [ 79, 96 ], [ 101, 98 ], [ 79, 99 ], [ 90, 100 ], [ 79, 104 ], [ 90, 106 ], [ 90, 108 ], [ 115, 109 ], [ 79, 111 ], [ 113, 113 ], [ 115, 115 ], [ 280, 117 ], [ 268, 124 ], [ 257, 126 ], [ 281, 128 ], [ 140, 134 ], [ 142, 136 ], [ 142, 138 ], [ 140, 140 ], [ 142, 142 ], [ 269, 149 ], [ 161, 150 ], [ 272, 152 ], [ 269, 154 ], [ 161, 156 ], [ 163, 157 ], [ 165, 158 ], [ 165, 159 ], [ 161, 161 ], [ 163, 163 ], [ 165, 165 ], [ 245, 171 ], [ 182, 172 ], [ 184, 173 ], [ 186, 174 ], [ 272, 176 ], [ 269, 178 ], [ 184, 179 ], [ 186, 180 ], [ 182, 182 ], [ 184, 184 ], [ 186, 186 ], [ 286, 188 ], [ 260, 190 ], [ 286, 191 ], [ 286, 192 ], [ 286, 193 ], [ 274, 195 ], [ 199, 198 ], [ 284, 202 ], [ 287, 203 ], [ 241, 205 ], [ 251, 209 ], [ 266, 212 ], [ 198, 213 ], [ 198, 215 ], [ 281, 216 ], [ 251, 218 ], [ 278, 223 ], [ 266, 224 ], [ 284, 225 ], [ 198, 226 ], [ 284, 230 ], [ 198, 231 ], [ 281, 233 ], [ 281, 234 ], [ 242, 238 ], [ 275, 238 ], [ 281, 239 ], [ 241, 242 ], [ 286, 266 ], [ 268, 269 ], [ 274, 275 ], [ 286, 278 ], [ 280, 281 ], [ 286, 284 ], [ 286, 287 ] ]

[ "import math\nfrom functools import reduce\nfrom collections import deque\nimport sys\nsys.setrecursionlimit(10**7)\n\n# スペース区切りの入力を読み込んで数値リストにして返します。\ndef get_nums_l():\n return [ int(s) for s in input().split(\" \")]\n\n# 改行区切りの入力をn行読み込んで数値リストにして返します。\ndef get_nums_n(n):\n return [ int(input()) for _ in range(n)]\n\n# 改行またはスペース区切りの入力をすべて読み込んでイテレータを返します。\ndef get_all_int():\n return map(int, open(0).read().split())\n\ndef log(*args):\n print(\"DEBUG:\", *args, file=sys.stderr)\n\ndef init_kaijo(MAX, MOD):\n kaijo = [0] * MAX\n kaijo[0] = 1\n for i in range(1, len(kaijo)):\n kaijo[i] = kaijo[i-1] * i % MOD\n return kaijo\nMOD = 10**9+7\nkaijo = init_kaijo(500000, MOD)\n\ndef inv(x, MOD):\n return pow(x, MOD-2, MOD)\n\ndef nPk(n, k, MOD):\n return kaijo[n] * inv(kaijo[n-k], MOD) % MOD\n\ndef nCk(n, k, MOD):\n # log(\"{}C{} = {}\".format(n,k,nPk(n,k, MOD) * inv(kaijo[k], MOD)))\n return nPk(n,k, MOD) * inv(kaijo[k], MOD)\n\nh, w, a, b = get_nums_l()\n\nans = 0\nfor i in range(h-a):\n # (0,0)から(b-1, i)に到着するパターン数 * (b,i)から(W-1, H-1)に到着するパターン数\n # log(nCk(b+i-1, i, MOD), nCk(w-b+h-i-2, h-i-1, MOD))\n ans += nCk(b+i-1, i, MOD) * nCk(w-b+h-i-2, h-i-1, MOD) % MOD\n\nprint(ans % MOD)", "import math", "math", "from functools import reduce", "from collections import deque", "import sys", "sys", "sys.setrecursionlimit(10**7)", "sys.setrecursionlimit", "sys", "setrecursionlimit", "10**7", "10", "7", "def get_nums_l():\n return [ int(s) for s in input().split(\" \")]\n\n# 改行区切りの入力をn行読み込んで数値リストにして返します。", "get_nums_l", "int(s) for s in input().split(\" \")", "for s in input().split(\" \")", "s", "input().split(\" \")", "().split", "()", "input", "split", "\" \"", "for s in input().split(\" \")", "int(s)", "int", "s", "return [ int(s) for s in input().split(\" \")]", "[ int(s) for s in input().split(\" \")]", "def get_nums_n(n):\n return [ int(input()) for _ in range(n)]\n\n# 改行またはスペース区切りの入力をすべて読み込んでイテレータを返します。", "get_nums_n", "int(input()) for _ in range(n)", "for _ in range(n)", "_", "range(n)", "range", "n", "for _ in range(n)", "int(input())", "int", "input()", "input", "return [ int(input()) for _ in range(n)]", "[ int(input()) for _ in range(n)]", "n", "n", "def get_all_int():\n return map(int, open(0).read().split())", "get_all_int", "return map(int, open(0).read().split())", "map(int, open(0).read().split())", "map", "int", "open(0).read().split()", "(0).read().split", "(0).read()", "(0).read", "(0)", "open", "0", "read", "split", "def log(*args):\n print(\"DEBUG:\", *args, file=sys.stderr)", "log", "print(\"DEBUG:\", *args, file=sys.stderr)", "print", "\"DEBUG:\"", "*args", "args", "file=sys.stderr", "file", "sys.stderr", "sys", "stderr", "*args", "def init_kaijo(MAX, MOD):\n kaijo = [0] * MAX\n kaijo[0] = 1\n for i in range(1, len(kaijo)):\n kaijo[i] = kaijo[i-1] * i % MOD\n return kaijo", "init_kaijo", "kaijo = [0] * MAX", "kaijo", "[0] * MAX", "[0]", "0", "MAX", "kaijo[0] = 1", "kaijo[0]", "kaijo", "0", "1", "for i in range(1, len(kaijo)):\n kaijo[i] = kaijo[i-1] * i % MOD\n ", "i", "range(1, len(kaijo))", "range", "1", "len(kaijo)", "len", "kaijo", "kaijo[i] = kaijo[i-1] * i % MOD", "kaijo[i]", "kaijo", "i", "kaijo[i-1] * i % MOD", "kaijo[i-1] * i", "kaijo[i-1]", "kaijo", "i-1", "i", "1", "i", "MOD", "return kaijo", "kaijo", "MAX", "MAX", "MOD", "MOD", "MOD = 10**9+7", "MOD", "10**9+7", "10**9", "10", "9", "7", "kaijo = init_kaijo(500000, MOD)", "kaijo", "init_kaijo(500000, MOD)", "init_kaijo", "500000", "MOD", "def inv(x, MOD):\n return pow(x, MOD-2, MOD)", "inv", "return pow(x, MOD-2, MOD)", "pow(x, MOD-2, MOD)", "pow", "x", "MOD-2", "MOD", "2", "MOD", "x", "x", "MOD", "MOD", "def nPk(n, k, MOD):\n return kaijo[n] * inv(kaijo[n-k], MOD) % MOD", "nPk", "return kaijo[n] * inv(kaijo[n-k], MOD) % MOD", "kaijo[n] * inv(kaijo[n-k], MOD) % MOD", "kaijo[n] * inv(kaijo[n-k], MOD)", "kaijo[n]", "kaijo", "n", "inv(kaijo[n-k], MOD)", "inv", "kaijo[n-k]", "kaijo", "n-k", "n", "k", "MOD", "MOD", "n", "n", "k", "k", "MOD", "MOD", "def nCk(n, k, MOD):\n # log(\"{}C{} = {}\".format(n,k,nPk(n,k, MOD) * inv(kaijo[k], MOD)))\n return nPk(n,k, MOD) * inv(kaijo[k], MOD)", "nCk", "return nPk(n,k, MOD) * inv(kaijo[k], MOD)", "nPk(n,k, MOD) * inv(kaijo[k], MOD)", "nPk(n,k, MOD)", "nPk", "n", "k", "MOD", "inv(kaijo[k], MOD)", "inv", "kaijo[k]", "kaijo", "k", "MOD", "n", "n", "k", "k", "MOD", "MOD", "h, w, a, b = get_nums_l()", "h", "get_nums_l()", "get_nums_l", "w", "a", "b", "ans = 0", "ans", "0", "for i in range(h-a):\n # (0,0)から(b-1, i)に到着するパターン数 * (b,i)から(W-1, H-1)に到着するパターン数\n # log(nCk(b+i-1, i, MOD), nCk(w-b+h-i-2, h-i-1, MOD))\n ans += nCk(b+i-1, i, MOD) * nCk(w-b+h-i-2, h-i-1, MOD) % MOD", "i", "range(h-a)", "range", "h-a", "h", "a", "ans += nCk(b+i-1, i, MOD) * nCk(w-b+h-i-2, h-i-1, MOD) % MOD", "ans", "nCk(b+i-1, i, MOD) * nCk(w-b+h-i-2, h-i-1, MOD) % MOD", "nCk(b+i-1, i, MOD) * nCk(w-b+h-i-2, h-i-1, MOD)", "nCk(b+i-1, i, MOD)", "nCk", "b+i-1", "b+i", "b", "i", "1", "i", "MOD", "nCk(w-b+h-i-2, h-i-1, MOD)", "nCk", "w-b+h-i-2", "w-b+h-i", "w-b+h", "w-b", "w", "b", "h", "i", "2", "h-i-1", "h-i", "h", "i", "1", "MOD", "MOD", "print(ans % MOD)", "print", "ans % MOD", "ans", "MOD", "ans += nCk(b+i-1, i, MOD) * nCk(w-b+h-i-2, h-i-1, MOD) % MOD", "nCk(b+i-1, i, MOD) * nCk(w-b+h-i-2, h-i-1, MOD) % MOD", "ans", "def nPk(n, k, MOD):\n return kaijo[n] * inv(kaijo[n-k], MOD) % MOD", "def nPk(n, k, MOD):\n return kaijo[n] * inv(kaijo[n-k], MOD) % MOD", "nPk", "def log(*args):\n print(\"DEBUG:\", *args, file=sys.stderr)", "def log(*args):\n print(\"DEBUG:\", *args, file=sys.stderr)", "log", "def nCk(n, k, MOD):\n # log(\"{}C{} = {}\".format(n,k,nPk(n,k, MOD) * inv(kaijo[k], MOD)))\n return nPk(n,k, MOD) * inv(kaijo[k], MOD)", "def nCk(n, k, MOD):\n # log(\"{}C{} = {}\".format(n,k,nPk(n,k, MOD) * inv(kaijo[k], MOD)))\n return nPk(n,k, MOD) * inv(kaijo[k], MOD)", "nCk", "def get_all_int():\n return map(int, open(0).read().split())", "def get_all_int():\n return map(int, open(0).read().split())", "get_all_int", "def init_kaijo(MAX, MOD):\n kaijo = [0] * MAX\n kaijo[0] = 1\n for i in range(1, len(kaijo)):\n kaijo[i] = kaijo[i-1] * i % MOD\n return kaijo", "def init_kaijo(MAX, MOD):\n kaijo = [0] * MAX\n kaijo[0] = 1\n for i in range(1, len(kaijo)):\n kaijo[i] = kaijo[i-1] * i % MOD\n return kaijo", "init_kaijo", "def get_nums_l():\n return [ int(s) for s in input().split(\" \")]\n\n# 改行区切りの入力をn行読み込んで数値リストにして返します。", "def get_nums_l():\n return [ int(s) for s in input().split(\" \")]\n\n# 改行区切りの入力をn行読み込んで数値リストにして返します。", "get_nums_l", "def get_nums_n(n):\n return [ int(input()) for _ in range(n)]\n\n# 改行またはスペース区切りの入力をすべて読み込んでイテレータを返します。", "def get_nums_n(n):\n return [ int(input()) for _ in range(n)]\n\n# 改行またはスペース区切りの入力をすべて読み込んでイテレータを返します。", "get_nums_n", "b = get_nums_l()", "get_nums_l()", "b", "kaijo = init_kaijo(500000, MOD)", "init_kaijo(500000, MOD)", "kaijo", "def inv(x, MOD):\n return pow(x, MOD-2, MOD)", "def inv(x, MOD):\n return pow(x, MOD-2, MOD)", "inv", "ans = 0", "0", "ans", "w, a, b = get_nums_l()", "get_nums_l()", "w", "MOD = 10**9+7", "10**9+7", "MOD", "h, w, a, b = get_nums_l()", "get_nums_l()", "h", "a, b = get_nums_l()", "get_nums_l()", "a" ]

[ 7, 0, 13, 2, 2, 17, 17, 17, 12, 13, 0, 13, 13, 0, 13, 17, 0, 13, 17, 42, 13, 0, 13, 2, 13, 13, 0, 13, 2, 13, 13, 0, 13, 13, 13, 13, 0, 13, 2, 13, 13, 0, 13, 13, 13, 13, 0, 13, 13, 14, 2, 13, 17, 0, 13, 13, 29, 13, 23, 13, 23, 13, 0, 13, 2, 39, 17, 17, 0, 13, 2, 39, 17, 17, 0, 13, 17, 28, 13, 4, 13, 17, 17, 0, 13, 2, 2, 13, 13, 13, 0, 18, 13, 13, 13, 0, 18, 13, 13, 4, 13, 13, 13, 15, 13, 12, 13, 29, 2, 2, 2, 18, 13, 13, 18, 13, 13, 18, 13, 13, 13, 23, 13, 23, 13, 23, 13, 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, 17, 0, 13, 2, 13, 17, 0, 13, 2, 2, 13, 13, 17, 0, 13, 17, 0, 13, 13, 0, 13, 13, 0, 13, 13, 0, 13, 17, 28, 13, 4, 13, 13, 0, 13, 2, 4, 13, 2, 13, 13, 13, 13, 4, 13, 2, 2, 13, 13, 13, 2, 13, 13, 13, 4, 13, 2, 13, 13, 10, 2, 13, 10, 13, 13, 10, 13, 13, 10, 13, 13, 10, 13, 13, 10, 12, 13, 10, 2, 13, 10, 17, 13, 10, 2, 13, 10, 2, 13, 10, 13, 13, 10, 13, 13, 10, 2, 13, 10, 2, 13, 10, 12, 13, 10, 17, 13, 10, 13, 13, 10, 2, 13, 10, 2, 13, 10, 2, 13, 10, 17, 13 ]

[ [ 253, 2 ], [ 12, 11 ], [ 61, 12 ], [ 15, 14 ], [ 18, 17 ], [ 23, 22 ], [ 59, 24 ], [ 32, 24 ], [ 27, 24 ], [ 11, 25 ], [ 34, 25 ], [ 28, 27 ], [ 22, 29 ], [ 11, 30 ], [ 34, 30 ], [ 33, 32 ], [ 11, 33 ], [ 34, 33 ], [ 35, 34 ], [ 32, 35 ], [ 27, 35 ], [ 59, 35 ], [ 38, 37 ], [ 22, 39 ], [ 17, 40 ], [ 44, 40 ], [ 43, 42 ], [ 17, 43 ], [ 44, 43 ], [ 45, 44 ], [ 42, 45 ], [ 37, 45 ], [ 14, 45 ], [ 48, 47 ], [ 61, 48 ], [ 47, 51 ], [ 42, 51 ], [ 37, 51 ], [ 14, 51 ], [ 55, 54 ], [ 61, 55 ], [ 54, 57 ], [ 47, 57 ], [ 42, 57 ], [ 37, 57 ], [ 14, 57 ], [ 59, 59 ], [ 61, 61 ], [ 271, 63 ], [ 268, 69 ], [ 274, 75 ], [ 79, 78 ], [ 232, 84 ], [ 275, 87 ], [ 233, 87 ], [ 78, 88 ], [ 254, 89 ], [ 94, 91 ], [ 272, 92 ], [ 78, 93 ], [ 233, 94 ], [ 275, 94 ], [ 99, 96 ], [ 269, 97 ], [ 78, 98 ], [ 230, 100 ], [ 233, 101 ], [ 275, 101 ], [ 254, 102 ], [ 272, 112 ], [ 122, 113 ], [ 269, 115 ], [ 124, 116 ], [ 269, 118 ], [ 126, 119 ], [ 254, 120 ], [ 122, 122 ], [ 124, 124 ], [ 126, 126 ], [ 130, 129 ], [ 129, 138 ], [ 262, 140 ], [ 262, 142 ], [ 262, 143 ], [ 262, 144 ], [ 238, 146 ], [ 263, 148 ], [ 218, 149 ], [ 241, 151 ], [ 221, 153 ], [ 214, 156 ], [ 263, 158 ], [ 265, 161 ], [ 227, 164 ], [ 221, 165 ], [ 235, 168 ], [ 247, 171 ], [ 242, 172 ], [ 244, 174 ], [ 215, 175 ], [ 223, 177 ], [ 266, 178 ], [ 259, 180 ], [ 184, 183 ], [ 239, 186 ], [ 250, 188 ], [ 257, 191 ], [ 242, 193 ], [ 183, 194 ], [ 242, 195 ], [ 183, 196 ], [ 257, 198 ], [ 215, 201 ], [ 266, 202 ], [ 183, 203 ], [ 215, 205 ], [ 183, 206 ], [ 266, 207 ], [ 251, 211 ], [ 260, 211 ], [ 254, 212 ], [ 214, 215 ], [ 262, 218 ], [ 262, 221 ], [ 266, 223 ], [ 223, 224 ], [ 262, 227 ], [ 232, 233 ], [ 235, 236 ], [ 238, 239 ], [ 241, 242 ], [ 215, 244 ], [ 244, 245 ], [ 242, 247 ], [ 247, 248 ], [ 250, 251 ], [ 253, 254 ], [ 259, 260 ], [ 262, 263 ], [ 265, 266 ], [ 268, 269 ], [ 271, 272 ], [ 274, 275 ] ]

[ "MODD = 10**9 + 7 \n\ndef modinv(a,m)-> int:\n b = m\n u = 1\n v = 0\n while (b):\n t = a // b\n a -= t * b\n a,b= b,a\n u -= t * v\n u,v= v,u\n u %= m\n if (u < 0):\n u += m\n return u\n\n\nfac=[1]*200001\ninfac=[1]*200001\naaa=1\nfor i in range(1,200001):\n aaa=(aaa*i)%MODD\n fac[i]=aaa\n infac[i]=modinv(aaa,MODD)\n #print(fac[i])\n\nimport math as m\n\ndef perm(x,y,z) -> int:\n #print(fac[x]//(fac[y]*fac[z])) \n return ((fac[x]*infac[y]*infac[z])%MODD)\n\nh,w,a,b= [int(x) for x in input().split()]\nA = h-a\nB = b-1\nC = h-1\nD = w-b-1\nj=0\nk=B\nkl = C\njl = D\nans = 0\nfor i in range(A):\n ans+=perm(B+i,B,i)*perm(C+D-i,C-i,D)\nprint(ans%MODD)", "MODD = 10**9 + 7", "MODD", "10**9 + 7", "10**9", "10", "9", "7", "def modinv(a,m)-> int:\n b = m\n u = 1\n v = 0\n while (b):\n t = a // b\n a -= t * b\n a,b= b,a\n u -= t * v\n u,v= v,u\n u %= m\n if (u < 0):\n u += m\n return u", "modinv", "b = m", "b", "m", "u = 1", "u", "1", "v = 0", "v", "0", "while (b):\n t = a // b\n a -= t * b\n a,b= b,a\n u -= t * v\n u,v= v,u\n ", "b", "t = a // b", "t", "a // b", "a", "b", "a -= t * b", "a", "t * b", "t", "b", "a,b= b,a", "a", "b", "b", "a", "u -= t * v", "u", "t * v", "t", "v", "u,v= v,u", "u", "v", "v", "u", "u %= m", "u", "m", "if (u < 0):\n u += m\n ", "u < 0", "u", "0", "u += m", "u", "m", "return u", "u", "a", "a", "m", "m", "fac=[1]*200001", "fac", "[1]*200001", "[1]", "1", "200001", "infac=[1]*200001", "infac", "[1]*200001", "[1]", "1", "200001", "aaa=1", "aaa", "1", "for i in range(1,200001):\n aaa=(aaa*i)%MODD\n fac[i]=aaa\n infac[i]=modinv(aaa,MODD)\n #print(fac[i])", "i", "range(1,200001)", "range", "1", "200001", "aaa=(aaa*i)%MODD", "aaa", "(aaa*i)%MODD", "aaa*i", "aaa", "i", "MODD", "fac[i]=aaa", "fac[i]", "fac", "i", "aaa", "infac[i]=modinv(aaa,MODD)", "infac[i]", "infac", "i", "modinv(aaa,MODD)", "modinv", "aaa", "MODD", "import math as m", "math", "def perm(x,y,z) -> int:\n #print(fac[x]//(fac[y]*fac[z])) \n return ((fac[x]*infac[y]*infac[z])%MODD)", "perm", "return ((fac[x]*infac[y]*infac[z])%MODD)", "(fac[x]*infac[y]*infac[z])%MODD", "fac[x]*infac[y]*infac[z]", "fac[x]*infac[y]", "fac[x]", "fac", "x", "infac[y]", "infac", "y", "infac[z]", "infac", "z", "MODD", "x", "x", "y", "y", "z", "z", "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", "A = h-a", "A", "h-a", "h", "a", "B = b-1", "B", "b-1", "b", "1", "C = h-1", "C", "h-1", "h", "1", "D = w-b-1", "D", "w-b-1", "w-b", "w", "b", "1", "j=0", "j", "0", "k=B", "k", "B", "kl = C", "kl", "C", "jl = D", "jl", "D", "ans = 0", "ans", "0", "for i in range(A):\n ans+=perm(B+i,B,i)*perm(C+D-i,C-i,D)", "i", "range(A)", "range", "A", "ans+=perm(B+i,B,i)*perm(C+D-i,C-i,D)", "ans", "perm(B+i,B,i)*perm(C+D-i,C-i,D)", "perm(B+i,B,i)", "perm", "B+i", "B", "i", "B", "i", "perm(C+D-i,C-i,D)", "perm", "C+D-i", "C+D", "C", "D", "i", "C-i", "C", "i", "D", "print(ans%MODD)", "print", "ans%MODD", "ans", "MODD", "C = h-1", "h-1", "C", "a,b= [int(x) for x in input().split()]", "[int(x) for x in input().split()]", "a", "b= [int(x) for x in input().split()]", "[int(x) for x in input().split()]", "b", "jl = D", "D", "jl", "w,a,b= [int(x) for x in input().split()]", "[int(x) for x in input().split()]", "w", "def modinv(a,m)-> int:\n b = m\n u = 1\n v = 0\n while (b):\n t = a // b\n a -= t * b\n a,b= b,a\n u -= t * v\n u,v= v,u\n u %= m\n if (u < 0):\n u += m\n return u", "def modinv(a,m)-> int:\n b = m\n u = 1\n v = 0\n while (b):\n t = a // b\n a -= t * b\n a,b= b,a\n u -= t * v\n u,v= v,u\n u %= m\n if (u < 0):\n u += m\n return u", "modinv", "aaa=(aaa*i)%MODD", "(aaa*i)%MODD", "aaa", "j=0", "0", "j", "A = h-a", "h-a", "A", "B = b-1", "b-1", "B", "kl = C", "C", "kl", "k=B", "B", "k", "ans+=perm(B+i,B,i)*perm(C+D-i,C-i,D)", "perm(B+i,B,i)*perm(C+D-i,C-i,D)", "ans", "MODD = 10**9 + 7", "10**9 + 7", "MODD", "def perm(x,y,z) -> int:\n #print(fac[x]//(fac[y]*fac[z])) \n return ((fac[x]*infac[y]*infac[z])%MODD)", "def perm(x,y,z) -> int:\n #print(fac[x]//(fac[y]*fac[z])) \n return ((fac[x]*infac[y]*infac[z])%MODD)", "perm", "ans = 0", "0", "ans", "h,w,a,b= [int(x) for x in input().split()]", "[int(x) for x in input().split()]", "h", "D = w-b-1", "w-b-1", "D", "infac=[1]*200001", "[1]*200001", "infac", "fac=[1]*200001", "[1]*200001", "fac", "aaa=1", "1", "aaa" ]

[ 7, 15, 15, 15, 15, 15, 15, 15, 15, 13, 4, 18, 13, 13, 17, 0, 13, 4, 13, 17, 0, 13, 17, 13, 17, 13, 17, 13, 17, 13, 17, 13, 17, 0, 13, 39, 17, 17, 17, 17, 13, 39, 17, 17, 17, 17, 0, 13, 39, 17, 17, 17, 17, 17, 17, 17, 17, 13, 39, 17, 17, 17, 17, 17, 17, 17, 17, 12, 13, 29, 2, 2, 40, 17, 13, 13, 2, 40, 17, 13, 13, 23, 13, 23, 13, 23, 13, 23, 13, 12, 13, 29, 2, 2, 2, 13, 13, 17, 13, 23, 13, 23, 13, 6, 13, 12, 13, 4, 2, 17, 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, 4, 13, 18, 13, 13, 0, 18, 18, 13, 13, 13, 2, 2, 13, 18, 18, 13, 13, 2, 13, 17, 18, 13, 13, 0, 18, 18, 13, 13, 13, 4, 13, 18, 18, 13, 13, 13, 2, 18, 13, 13, 17, 18, 13, 13, 23, 13, 23, 13, 23, 13, 12, 13, 14, 2, 2, 13, 17, 2, 13, 17, 29, 17, 4, 2, 2, 40, 17, 13, 4, 13, 18, 13, 13, 40, 17, 13, 0, 13, 18, 18, 13, 13, 13, 0, 13, 2, 2, 18, 18, 13, 13, 13, 18, 18, 13, 13, 2, 13, 13, 18, 13, 13, 29, 2, 2, 13, 13, 18, 13, 13, 23, 13, 23, 13, 23, 13, 12, 13, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 13, 13, 0, 13, 2, 2, 17, 17, 17, 0, 13, 4, 13, 2, 2, 17, 17, 17, 13, 0, 13, 17, 28, 13, 4, 13, 2, 13, 17, 2, 13, 17, 0, 13, 2, 2, 13, 13, 17, 13, 2, 13, 17, 0, 13, 2, 4, 18, 13, 13, 2, 13, 13, 13, 13, 0, 13, 2, 13, 17, 13, 2, 13, 13, 0, 13, 2, 4, 18, 13, 13, 2, 13, 13, 13, 13, 0, 13, 2, 2, 13, 13, 13, 0, 13, 13, 4, 13, 13, 14, 2, 13, 17, 4, 13, 10, 12, 13, 10, 4, 13, 10, 17, 13, 10, 17, 13, 10, 12, 13, 10, 12, 13, 10, 6, 13, 10, 17, 13, 10, 17, 13, 10, 39, 13, 10, 39, 13, 10, 17, 13, 10, 17, 13, 10, 39, 13, 10, 39, 13 ]

[ [ 370, 16 ], [ 388, 21 ], [ 400, 23 ], [ 373, 25 ], [ 403, 27 ], [ 376, 29 ], [ 391, 31 ], [ 394, 34 ], [ 409, 40 ], [ 397, 47 ], [ 406, 57 ], [ 82, 74 ], [ 86, 75 ], [ 84, 79 ], [ 88, 80 ], [ 82, 82 ], [ 84, 84 ], [ 86, 86 ], [ 88, 88 ], [ 100, 95 ], [ 102, 96 ], [ 102, 98 ], [ 100, 100 ], [ 102, 102 ], [ 189, 110 ], [ 115, 112 ], [ 187, 113 ], [ 191, 114 ], [ 191, 115 ], [ 120, 117 ], [ 187, 118 ], [ 189, 124 ], [ 130, 127 ], [ 187, 128 ], [ 189, 134 ], [ 138, 137 ], [ 117, 143 ], [ 187, 144 ], [ 152, 147 ], [ 117, 148 ], [ 187, 149 ], [ 137, 151 ], [ 137, 154 ], [ 117, 156 ], [ 187, 157 ], [ 137, 160 ], [ 112, 162 ], [ 187, 163 ], [ 191, 164 ], [ 171, 166 ], [ 127, 167 ], [ 187, 168 ], [ 137, 170 ], [ 147, 173 ], [ 117, 174 ], [ 187, 175 ], [ 137, 177 ], [ 112, 179 ], [ 187, 180 ], [ 191, 181 ], [ 112, 183 ], [ 187, 184 ], [ 191, 185 ], [ 187, 187 ], [ 189, 189 ], [ 191, 191 ], [ 255, 197 ], [ 257, 200 ], [ 255, 209 ], [ 253, 213 ], [ 257, 217 ], [ 220, 219 ], [ 253, 222 ], [ 255, 224 ], [ 227, 226 ], [ 253, 231 ], [ 257, 233 ], [ 253, 236 ], [ 255, 239 ], [ 257, 240 ], [ 253, 242 ], [ 219, 247 ], [ 226, 248 ], [ 253, 250 ], [ 253, 253 ], [ 255, 255 ], [ 257, 257 ], [ 262, 261 ], [ 262, 270 ], [ 262, 271 ], [ 262, 272 ], [ 275, 274 ], [ 282, 281 ], [ 274, 289 ], [ 292, 291 ], [ 295, 294 ], [ 272, 298 ], [ 270, 301 ], [ 305, 304 ], [ 261, 307 ], [ 271, 308 ], [ 311, 310 ], [ 294, 312 ], [ 316, 315 ], [ 281, 319 ], [ 193, 320 ], [ 304, 322 ], [ 327, 322 ], [ 310, 323 ], [ 331, 323 ], [ 310, 324 ], [ 331, 324 ], [ 274, 325 ], [ 328, 327 ], [ 271, 329 ], [ 332, 331 ], [ 270, 333 ], [ 294, 334 ], [ 337, 336 ], [ 281, 340 ], [ 193, 341 ], [ 327, 343 ], [ 304, 343 ], [ 331, 344 ], [ 310, 344 ], [ 331, 345 ], [ 310, 345 ], [ 274, 346 ], [ 349, 348 ], [ 315, 351 ], [ 336, 352 ], [ 274, 353 ], [ 356, 355 ], [ 274, 356 ], [ 355, 359 ], [ 348, 359 ], [ 291, 359 ], [ 380, 365 ], [ 370, 371 ], [ 373, 374 ], [ 376, 377 ], [ 388, 389 ], [ 391, 392 ], [ 394, 395 ], [ 397, 398 ], [ 400, 401 ], [ 403, 404 ], [ 406, 407 ], [ 409, 410 ] ]

[ "from collections import defaultdict, Counter\nfrom itertools import product, groupby, count, permutations, combinations\nfrom math import pi, sqrt\nfrom collections import deque\nfrom bisect import bisect, bisect_left, bisect_right\nfrom string import ascii_lowercase\nfrom functools import lru_cache\nimport sys\nsys.setrecursionlimit(10000)\nINF = float(\"inf\")\nYES, Yes, yes, NO, No, no = \"YES\", \"Yes\", \"yes\", \"NO\", \"No\", \"no\"\ndy4, dx4 = [0, 1, 0, -1], [1, 0, -1, 0]\ndy8, dx8 = [0, -1, 0, 1, 1, -1, -1, 1], [1, 0, -1, 0, 1, 1, -1, -1]\n\n\ndef inside(y, x, H, W):\n return 0 <= y < H and 0 <= x < W\n\n\ndef ceil(a, b):\n return (a + b - 1) // b\n\n\nclass Combination:\n def __init__(self, n, mod):\n assert 0 < n\n self.mod = mod\n self.fact = [1] * (n + 1)\n self.inv = [1] * (n + 1)\n for i in range(1, len(self.fact)):\n self.fact[i] = (i * self.fact[i - 1]) % self.mod\n self.inv[i] = pow(self.fact[i], self.mod - 2, self.mod)\n\n def nCr(self, n, k):\n if n == 0 and k == 0:\n return 1\n assert 0 <= n < len(self.fact) and 0 <= k\n a = self.fact[n]\n b = (self.inv[k] * self.inv[n - k]) % self.mod\n return a * b % self.mod\n\n\ndef main():\n H, W, A, B = map(int, input().split())\n MOD = 10 ** 9 + 7\n\n comb = Combination(100000 * 2 + 10, MOD)\n\n ans = 0\n for i in range(B + 1, W + 1):\n h, w = H - A - 1, i - 1\n s = comb.nCr(h + w, w) % MOD\n\n h, w = A - 1, W - i\n t = comb.nCr(h + w, w) % MOD\n\n ans += (s * t) % MOD\n ans %= MOD\n print(ans)\n\n\n\nif __name__ == '__main__':\n main()", "from collections import defaultdict, Counter", "from itertools import product, groupby, count, permutations, combinations", "from math import pi, sqrt", "from collections import deque", "from bisect import bisect, bisect_left, bisect_right", "from string import ascii_lowercase", "from functools import lru_cache", "import sys", "sys", "sys.setrecursionlimit(10000)", "sys.setrecursionlimit", "sys", "setrecursionlimit", "10000", "INF = float(\"inf\")", "INF", "float(\"inf\")", "float", "\"inf\"", "YES, Yes, yes, NO, No, no = \"YES\", \"Yes\", \"yes\", \"NO\", \"No\", \"no\"", "YES", "\"YES\"", "Yes", "\"Yes\"", "yes", "\"yes\"", "NO", "\"NO\"", "No", "\"No\"", "no", "\"no\"", "dy4, dx4 = [0, 1, 0, -1], [1, 0, -1, 0]", "dy4", "[0, 1, 0, -1]", "0", "1", "0", "-1", "dx4", "[1, 0, -1, 0]", "1", "0", "-1", "0", "dy8, dx8 = [0, -1, 0, 1, 1, -1, -1, 1], [1, 0, -1, 0, 1, 1, -1, -1]", "dy8", "[0, -1, 0, 1, 1, -1, -1, 1]", "0", "-1", "0", "1", "1", "-1", "-1", "1", "dx8", "[1, 0, -1, 0, 1, 1, -1, -1]", "1", "0", "-1", "0", "1", "1", "-1", "-1", "def inside(y, x, H, W):\n return 0 <= y < H and 0 <= x < W", "inside", "return 0 <= y < H and 0 <= x < W", "0 <= y < H and 0 <= x < W", "0 <= y < H", "0 <= y", "0", "y", "H", "0 <= x < W", "0 <= x", "0", "x", "W", "y", "y", "x", "x", "H", "H", "W", "W", "def ceil(a, b):\n return (a + b - 1) // b", "ceil", "return (a + b - 1) // b", "(a + b - 1) // b", "a + b - 1", "a + b", "a", "b", "1", "b", "a", "a", "b", "b", "class Combination:\n def __init__(self, n, mod):\n assert 0 < n\n self.mod = mod\n self.fact = [1] * (n + 1)\n self.inv = [1] * (n + 1)\n for i in range(1, len(self.fact)):\n self.fact[i] = (i * self.fact[i - 1]) % self.mod\n self.inv[i] = pow(self.fact[i], self.mod - 2, self.mod)\n\n def nCr(self, n, k):\n if n == 0 and k == 0:\n return 1\n assert 0 <= n < len(self.fact) and 0 <= k\n a = self.fact[n]\n b = (self.inv[k] * self.inv[n - k]) % self.mod\n return a * b % self.mod", "Combination", "def __init__(self, n, mod):\n assert 0 < n\n self.mod = mod\n self.fact = [1] * (n + 1)\n self.inv = [1] * (n + 1)\n for i in range(1, len(self.fact)):\n self.fact[i] = (i * self.fact[i - 1]) % self.mod\n self.inv[i] = pow(self.fact[i], self.mod - 2, self.mod)\n\n ", "__init__", "assert 0 < n", "0 < n", "0", "n", "self.mod = mod", "self.mod", "self", "mod", "mod", "self.fact = [1] * (n + 1)", "self.fact", "self", "fact", "[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 i in range(1, len(self.fact)):\n self.fact[i] = (i * self.fact[i - 1]) % self.mod\n self.inv[i] = pow(self.fact[i], self.mod - 2, self.mod)\n\n ", "i", "range(1, len(self.fact))", "range", "1", "len(self.fact)", "len", "self.fact", "self", "fact", "self.fact[i] = (i * self.fact[i - 1]) % self.mod", "self.fact[i]", "self.fact", "self", "fact", "i", "(i * self.fact[i - 1]) % self.mod", "i * self.fact[i - 1]", "i", "self.fact[i - 1]", "self.fact", "self", "fact", "i - 1", "i", "1", "self.mod", "self", "mod", "self.inv[i] = pow(self.fact[i], self.mod - 2, self.mod)", "self.inv[i]", "self.inv", "self", "inv", "i", "pow(self.fact[i], self.mod - 2, self.mod)", "pow", "self.fact[i]", "self.fact", "self", "fact", "i", "self.mod - 2", "self.mod", "self", "mod", "2", "self.mod", "self", "mod", "self", "self", "n", "n", "mod", "mod", "def nCr(self, n, k):\n if n == 0 and k == 0:\n return 1\n assert 0 <= n < len(self.fact) and 0 <= k\n a = self.fact[n]\n b = (self.inv[k] * self.inv[n - k]) % self.mod\n return a * b % self.mod", "nCr", "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", "assert 0 <= n < len(self.fact) and 0 <= k", "0 <= n < len(self.fact) and 0 <= k", "0 <= n < len(self.fact)", "0 <= n", "0", "n", "len(self.fact)", "len", "self.fact", "self", "fact", "0 <= k", "0", "k", "a = self.fact[n]", "a", "self.fact[n]", "self.fact", "self", "fact", "n", "b = (self.inv[k] * self.inv[n - k]) % self.mod", "b", "(self.inv[k] * self.inv[n - k]) % self.mod", "self.inv[k] * self.inv[n - k]", "self.inv[k]", "self.inv", "self", "inv", "k", "self.inv[n - k]", "self.inv", "self", "inv", "n - k", "n", "k", "self.mod", "self", "mod", "return a * b % self.mod", "a * b % self.mod", "a * b", "a", "b", "self.mod", "self", "mod", "self", "self", "n", "n", "k", "k", "def main():\n H, W, A, B = map(int, input().split())\n MOD = 10 ** 9 + 7\n\n comb = Combination(100000 * 2 + 10, MOD)\n\n ans = 0\n for i in range(B + 1, W + 1):\n h, w = H - A - 1, i - 1\n s = comb.nCr(h + w, w) % MOD\n\n h, w = A - 1, W - i\n t = comb.nCr(h + w, w) % MOD\n\n ans += (s * t) % MOD\n ans %= MOD\n print(ans)", "main", "H, W, A, B = map(int, input().split())", "H", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "W", "A", "B", "MOD = 10 ** 9 + 7", "MOD", "10 ** 9 + 7", "10 ** 9", "10", "9", "7", "comb = Combination(100000 * 2 + 10, MOD)", "comb", "Combination(100000 * 2 + 10, MOD)", "Combination", "100000 * 2 + 10", "100000 * 2", "100000", "2", "10", "MOD", "ans = 0", "ans", "0", "for i in range(B + 1, W + 1):\n h, w = H - A - 1, i - 1\n s = comb.nCr(h + w, w) % MOD\n\n h, w = A - 1, W - i\n t = comb.nCr(h + w, w) % MOD\n\n ans += (s * t) % MOD\n ans %= MOD\n ", "i", "range(B + 1, W + 1)", "range", "B + 1", "B", "1", "W + 1", "W", "1", "h, w = H - A - 1, i - 1", "h", "H - A - 1", "H - A", "H", "A", "1", "w", "i - 1", "i", "1", "s = comb.nCr(h + w, w) % MOD", "s", "comb.nCr(h + w, w) % MOD", "comb.nCr(h + w, w)", "comb.nCr", "comb", "nCr", "h + w", "h", "w", "w", "MOD", "h, w = A - 1, W - i", "h", "A - 1", "A", "1", "w", "W - i", "W", "i", "t = comb.nCr(h + w, w) % MOD", "t", "comb.nCr(h + w, w) % MOD", "comb.nCr(h + w, w)", "comb.nCr", "comb", "nCr", "h + w", "h", "w", "w", "MOD", "ans += (s * t) % MOD", "ans", "(s * t) % MOD", "s * t", "s", "t", "MOD", "ans %= MOD", "ans", "MOD", "print(ans)", "print", "ans", "if __name__ == '__main__':\n main()", "__name__ == '__main__'", "__name__", "'__main__'", "main()", "main", "def ceil(a, b):\n return (a + b - 1) // b", "def ceil(a, b):\n return (a + b - 1) // b", "ceil", "INF = float(\"inf\")", "float(\"inf\")", "INF", "yes, NO, No, no = \"YES\", \"Yes\", \"yes\", \"NO\", \"No\", \"no\"", "\"yes\"", "yes", "No, no = \"YES\", \"Yes\", \"yes\", \"NO\", \"No\", \"no\"", "\"No\"", "No", "def main():\n H, W, A, B = map(int, input().split())\n MOD = 10 ** 9 + 7\n\n comb = Combination(100000 * 2 + 10, MOD)\n\n ans = 0\n for i in range(B + 1, W + 1):\n h, w = H - A - 1, i - 1\n s = comb.nCr(h + w, w) % MOD\n\n h, w = A - 1, W - i\n t = comb.nCr(h + w, w) % MOD\n\n ans += (s * t) % MOD\n ans %= MOD\n print(ans)", "def main():\n H, W, A, B = map(int, input().split())\n MOD = 10 ** 9 + 7\n\n comb = Combination(100000 * 2 + 10, MOD)\n\n ans = 0\n for i in range(B + 1, W + 1):\n h, w = H - A - 1, i - 1\n s = comb.nCr(h + w, w) % MOD\n\n h, w = A - 1, W - i\n t = comb.nCr(h + w, w) % MOD\n\n ans += (s * t) % MOD\n ans %= MOD\n print(ans)", "main", "def inside(y, x, H, W):\n return 0 <= y < H and 0 <= x < W", "def inside(y, x, H, W):\n return 0 <= y < H and 0 <= x < W", "inside", "class Combination:\n def __init__(self, n, mod):\n assert 0 < n\n self.mod = mod\n self.fact = [1] * (n + 1)\n self.inv = [1] * (n + 1)\n for i in range(1, len(self.fact)):\n self.fact[i] = (i * self.fact[i - 1]) % self.mod\n self.inv[i] = pow(self.fact[i], self.mod - 2, self.mod)\n\n def nCr(self, n, k):\n if n == 0 and k == 0:\n return 1\n assert 0 <= n < len(self.fact) and 0 <= k\n a = self.fact[n]\n b = (self.inv[k] * self.inv[n - k]) % self.mod\n return a * b % self.mod", "class Combination:\n def __init__(self, n, mod):\n assert 0 < n\n self.mod = mod\n self.fact = [1] * (n + 1)\n self.inv = [1] * (n + 1)\n for i in range(1, len(self.fact)):\n self.fact[i] = (i * self.fact[i - 1]) % self.mod\n self.inv[i] = pow(self.fact[i], self.mod - 2, self.mod)\n\n def nCr(self, n, k):\n if n == 0 and k == 0:\n return 1\n assert 0 <= n < len(self.fact) and 0 <= k\n a = self.fact[n]\n b = (self.inv[k] * self.inv[n - k]) % self.mod\n return a * b % self.mod", "Combination", "YES, Yes, yes, NO, No, no = \"YES\", \"Yes\", \"yes\", \"NO\", \"No\", \"no\"", "\"YES\"", "YES", "no = \"YES\", \"Yes\", \"yes\", \"NO\", \"No\", \"no\"", "\"no\"", "no", "dy4, dx4 = [0, 1, 0, -1], [1, 0, -1, 0]", "[0, 1, 0, -1]", "dy4", "dy8, dx8 = [0, -1, 0, 1, 1, -1, -1, 1], [1, 0, -1, 0, 1, 1, -1, -1]", "[0, -1, 0, 1, 1, -1, -1, 1]", "dy8", "Yes, yes, NO, No, no = \"YES\", \"Yes\", \"yes\", \"NO\", \"No\", \"no\"", "\"Yes\"", "Yes", "NO, No, no = \"YES\", \"Yes\", \"yes\", \"NO\", \"No\", \"no\"", "\"NO\"", "NO", "dx8 = [0, -1, 0, 1, 1, -1, -1, 1], [1, 0, -1, 0, 1, 1, -1, -1]", "[1, 0, -1, 0, 1, 1, -1, -1]", "dx8", "dx4 = [0, 1, 0, -1], [1, 0, -1, 0]", "[1, 0, -1, 0]", "dx4" ]

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

[ [ 5, 4 ], [ 54, 5 ], [ 8, 7 ], [ 11, 10 ], [ 16, 15 ], [ 52, 17 ], [ 25, 17 ], [ 20, 17 ], [ 4, 18 ], [ 27, 18 ], [ 21, 20 ], [ 15, 22 ], [ 4, 23 ], [ 27, 23 ], [ 26, 25 ], [ 4, 26 ], [ 27, 26 ], [ 28, 27 ], [ 25, 28 ], [ 20, 28 ], [ 52, 28 ], [ 31, 30 ], [ 15, 32 ], [ 10, 33 ], [ 37, 33 ], [ 36, 35 ], [ 10, 36 ], [ 37, 36 ], [ 38, 37 ], [ 35, 38 ], [ 30, 38 ], [ 7, 38 ], [ 41, 40 ], [ 54, 41 ], [ 40, 44 ], [ 35, 44 ], [ 30, 44 ], [ 7, 44 ], [ 48, 47 ], [ 54, 48 ], [ 47, 50 ], [ 40, 50 ], [ 35, 50 ], [ 30, 50 ], [ 7, 50 ], [ 52, 52 ], [ 54, 54 ], [ 232, 56 ], [ 232, 65 ], [ 232, 66 ], [ 232, 67 ], [ 229, 69 ], [ 235, 76 ], [ 80, 79 ], [ 227, 84 ], [ 215, 85 ], [ 79, 88 ], [ 220, 91 ], [ 236, 95 ], [ 221, 97 ], [ 224, 97 ], [ 223, 100 ], [ 221, 104 ], [ 224, 104 ], [ 203, 107 ], [ 79, 108 ], [ 197, 111 ], [ 79, 112 ], [ 230, 113 ], [ 230, 114 ], [ 236, 117 ], [ 224, 119 ], [ 221, 119 ], [ 217, 121 ], [ 125, 124 ], [ 227, 128 ], [ 124, 131 ], [ 205, 134 ], [ 218, 138 ], [ 206, 140 ], [ 224, 140 ], [ 221, 140 ], [ 209, 140 ], [ 208, 143 ], [ 206, 147 ], [ 224, 147 ], [ 221, 147 ], [ 209, 147 ], [ 233, 151 ], [ 203, 152 ], [ 124, 153 ], [ 197, 156 ], [ 124, 157 ], [ 230, 158 ], [ 230, 159 ], [ 218, 162 ], [ 209, 164 ], [ 206, 164 ], [ 224, 164 ], [ 221, 164 ], [ 211, 166 ], [ 170, 169 ], [ 227, 173 ], [ 215, 174 ], [ 199, 176 ], [ 212, 179 ], [ 200, 179 ], [ 236, 182 ], [ 169, 183 ], [ 218, 185 ], [ 227, 188 ], [ 169, 190 ], [ 230, 191 ], [ 200, 194 ], [ 212, 194 ], [ 199, 200 ], [ 232, 203 ], [ 205, 206 ], [ 208, 209 ], [ 211, 212 ], [ 232, 215 ], [ 217, 218 ], [ 220, 221 ], [ 223, 224 ], [ 232, 227 ], [ 229, 230 ], [ 232, 233 ], [ 235, 236 ] ]

[ "\ndef modinv(a, m): #mod. m でのaの逆元 a^{-1}を計算する\n b = m\n u = 1\n v = 0\n while b:\n t = a//b\n a -= t * b\n a, b = b, a\n u -= t * v\n u, v = v, u\n \n u %= m\n if u < 0:\n u += m\n return u\n\nH, W, A, B = map(int, input().split())\n\nMOD = 10 ** 9 + 7\n\n#O(N)\nfirst = []\nfor i in range(0, H - A):\n if i == 0:\n tmp = 1\n first.append(tmp)\n continue\n tmp = (tmp * (B + i - 1) * modinv(i, MOD)) % MOD\n first.append(tmp)\n\n# print (first)\n\n#O(N)\nsecond = []\nfor i in range(0, H):\n if i == 0:\n tmp = 1\n second.append(tmp)\n continue\n tmp = (tmp * ((W - B) + i - 1) * modinv(i, MOD)) % MOD\n second.append(tmp)\n\n# print (second)\n\n#O(N)\nans = 0\nfor i in range(H - A):\n ans = (ans + first[i] * second[H - 1 -i]) % MOD\n\nprint (ans)\n#total O(3 * N) --> O(N)", "def modinv(a, m): #mod. m でのaの逆元 a^{-1}を計算する\n b = m\n u = 1\n v = 0\n while b:\n t = a//b\n a -= t * b\n a, b = b, a\n u -= t * v\n u, v = v, u\n \n u %= m\n if u < 0:\n u += m\n return u", "modinv", "b = m", "b", "m", "u = 1", "u", "1", "v = 0", "v", "0", "while b:\n t = a//b\n a -= t * b\n a, b = b, a\n u -= t * v\n u, v = v, u\n \n ", "b", "t = a//b", "t", "a//b", "a", "b", "a -= t * b", "a", "t * b", "t", "b", "a, b = b, a", "a", "b", "b", "a", "u -= t * v", "u", "t * v", "t", "v", "u, v = v, u", "u", "v", "v", "u", "u %= m", "u", "m", "if u < 0:\n u += m\n ", "u < 0", "u", "0", "u += m", "u", "m", "return u", "u", "a", "a", "m", "m", "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", "first = []", "first", "[]", "for i in range(0, H - A):\n if i == 0:\n tmp = 1\n first.append(tmp)\n continue\n tmp = (tmp * (B + i - 1) * modinv(i, MOD)) % MOD\n first.append(tmp)\n\n# print (first)\n\n#O(N)", "i", "range(0, H - A)", "range", "0", "H - A", "H", "A", "if i == 0:\n tmp = 1\n first.append(tmp)\n continue\n ", "i == 0", "i", "0", "tmp = 1", "tmp", "1", "first.append(tmp)", "first.append", "first", "append", "tmp", "continue", "tmp = (tmp * (B + i - 1) * modinv(i, MOD)) % MOD", "tmp", "(tmp * (B + i - 1) * modinv(i, MOD)) % MOD", "tmp * (B + i - 1) * modinv(i, MOD)", "tmp * (B + i - 1)", "tmp", "B + i - 1", "B + i", "B", "i", "1", "modinv(i, MOD)", "modinv", "i", "MOD", "MOD", "first.append(tmp)", "first.append", "first", "append", "tmp", "second = []", "second", "[]", "for i in range(0, H):\n if i == 0:\n tmp = 1\n second.append(tmp)\n continue\n tmp = (tmp * ((W - B) + i - 1) * modinv(i, MOD)) % MOD\n second.append(tmp)\n\n# print (second)\n\n#O(N)", "i", "range(0, H)", "range", "0", "H", "if i == 0:\n tmp = 1\n second.append(tmp)\n continue\n ", "i == 0", "i", "0", "tmp = 1", "tmp", "1", "second.append(tmp)", "second.append", "second", "append", "tmp", "continue", "tmp = (tmp * ((W - B) + i - 1) * modinv(i, MOD)) % MOD", "tmp", "(tmp * ((W - B) + i - 1) * modinv(i, MOD)) % MOD", "tmp * ((W - B) + i - 1) * modinv(i, MOD)", "tmp * ((W - B) + i - 1)", "tmp", "(W - B) + i - 1", "(W - B) + i", "W - B", "W", "B", "i", "1", "modinv(i, MOD)", "modinv", "i", "MOD", "MOD", "second.append(tmp)", "second.append", "second", "append", "tmp", "ans = 0", "ans", "0", "for i in range(H - A):\n ans = (ans + first[i] * second[H - 1 -i]) % MOD", "i", "range(H - A)", "range", "H - A", "H", "A", "ans = (ans + first[i] * second[H - 1 -i]) % MOD", "ans", "(ans + first[i] * second[H - 1 -i]) % MOD", "ans + first[i] * second[H - 1 -i]", "ans", "first[i] * second[H - 1 -i]", "first[i]", "first", "i", "second[H - 1 -i]", "second", "H - 1 -i", "H - 1", "H", "1", "i", "MOD", "print (ans)", "print", "ans", "def modinv(a, m): #mod. m でのaの逆元 a^{-1}を計算する\n b = m\n u = 1\n v = 0\n while b:\n t = a//b\n a -= t * b\n a, b = b, a\n u -= t * v\n u, v = v, u\n \n u %= m\n if u < 0:\n u += m\n return u", "def modinv(a, m): #mod. m でのaの逆元 a^{-1}を計算する\n b = m\n u = 1\n v = 0\n while b:\n t = a//b\n a -= t * b\n a, b = b, a\n u -= t * v\n u, v = v, u\n \n u %= m\n if u < 0:\n u += m\n return u", "modinv", "ans = (ans + first[i] * second[H - 1 -i]) % MOD", "(ans + first[i] * second[H - 1 -i]) % MOD", "ans", "B = map(int, input().split())", "map(int, input().split())", "B", "tmp = 1", "1", "tmp", "tmp = (tmp * ((W - B) + i - 1) * modinv(i, MOD)) % MOD", "(tmp * ((W - B) + i - 1) * modinv(i, MOD)) % MOD", "tmp", "ans = 0", "0", "ans", "A, B = map(int, input().split())", "map(int, input().split())", "A", "second = []", "[]", "second", "tmp = 1", "1", "tmp", "tmp = (tmp * (B + i - 1) * modinv(i, MOD)) % MOD", "(tmp * (B + i - 1) * modinv(i, MOD)) % MOD", "tmp", "H, W, A, B = map(int, input().split())", "map(int, input().split())", "H", "MOD = 10 ** 9 + 7", "10 ** 9 + 7", "MOD", "W, A, B = map(int, input().split())", "map(int, input().split())", "W", "first = []", "[]", "first" ]

[ 7, 15, 13, 0, 13, 4, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 13, 13, 0, 13, 2, 2, 17, 17, 17, 12, 13, 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, 23, 13, 23, 13, 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, 0, 13, 4, 13, 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, 13, 13, 13, 0, 13, 4, 13, 2, 2, 2, 2, 13, 17, 13, 17, 13, 2, 13, 17, 13, 13, 13, 0, 13, 2, 13, 2, 13, 13, 4, 13, 2, 13, 13, 10, 4, 13, 10, 4, 13, 10, 2, 13, 10, 4, 13, 10, 12, 13, 10, 2, 13, 10, 4, 13, 10, 4, 13, 10, 12, 13, 10, 4, 13, 10, 4, 13, 10, 4, 13, 10, 17, 13 ]

[ [ 236, 4 ], [ 236, 15 ], [ 236, 16 ], [ 236, 17 ], [ 218, 19 ], [ 30, 29 ], [ 55, 32 ], [ 53, 34 ], [ 55, 35 ], [ 59, 41 ], [ 53, 42 ], [ 61, 44 ], [ 29, 45 ], [ 55, 45 ], [ 61, 47 ], [ 53, 49 ], [ 29, 50 ], [ 55, 50 ], [ 57, 51 ], [ 53, 53 ], [ 55, 55 ], [ 57, 57 ], [ 59, 59 ], [ 61, 61 ], [ 67, 66 ], [ 72, 71 ], [ 77, 76 ], [ 82, 81 ], [ 135, 86 ], [ 66, 90 ], [ 66, 95 ], [ 81, 97 ], [ 133, 98 ], [ 76, 101 ], [ 76, 107 ], [ 133, 109 ], [ 81, 110 ], [ 133, 112 ], [ 81, 113 ], [ 133, 114 ], [ 71, 117 ], [ 71, 122 ], [ 76, 125 ], [ 133, 127 ], [ 133, 133 ], [ 135, 135 ], [ 230, 137 ], [ 216, 139 ], [ 219, 140 ], [ 225, 143 ], [ 237, 144 ], [ 230, 146 ], [ 239, 148 ], [ 152, 151 ], [ 234, 154 ], [ 237, 155 ], [ 206, 157 ], [ 228, 159 ], [ 225, 163 ], [ 213, 164 ], [ 151, 166 ], [ 151, 167 ], [ 219, 168 ], [ 204, 169 ], [ 231, 170 ], [ 221, 172 ], [ 228, 174 ], [ 213, 179 ], [ 237, 181 ], [ 151, 183 ], [ 213, 185 ], [ 219, 187 ], [ 204, 188 ], [ 231, 189 ], [ 209, 191 ], [ 240, 193 ], [ 210, 193 ], [ 207, 195 ], [ 222, 196 ], [ 210, 200 ], [ 240, 200 ], [ 219, 201 ], [ 230, 204 ], [ 206, 207 ], [ 209, 210 ], [ 236, 213 ], [ 218, 219 ], [ 221, 222 ], [ 236, 225 ], [ 230, 231 ], [ 236, 234 ], [ 236, 237 ], [ 239, 240 ] ]

[ "# 練習\nimport math\nh,w,a,b = list(map(int, input().split()))\np = 10**9+7\n# 方針\n# (0,0) ~ (0,w-1)\n# (h-1,0 )~ (h-1,w-1)で考える\n# 通れないのは(h-a) ~ (h-1)行かつ(0) ~ (b-1) 列のところ\n# b <= i <= w-1 のiについて1,2,3の組み合わせはそれぞれ以下の通り \n# 1, (0,0) ~ (h-a-1,i) (h-a-1+i)! /(h-a-1)! * i!\n# 2, (h-a-1,i )~(h-a,i)　 1\n# 3, (h-a,i) ~ (h-1,w-1) (a-1+w-1-i)! /(a-1)! * (w-1-i)!\ndef cmb(n, k, mod, fac, ifac):\n \"\"\"\n nCkを計算する\n \"\"\"\n k = min(k, n-k)\n return fac[n] * ifac[k] * ifac[n-k] % mod\n\n\ndef make_tables(mod, n):\n \"\"\"\n 階乗テーブル、逆元の階乗テーブルを作成する\n \"\"\"\n fac = [1, 1] # 階乗テーブル・・・(1)\n ifac = [1, 1] #逆元の階乗テーブル・・・(2)\n inverse = [0, 1] #逆元テーブル・・・(3)\n\n for i in range(2, n+1):\n fac.append((fac[-1] * i) % mod)\n inverse.append((-inverse[mod % i] * (mod//i)) % mod)\n ifac.append((ifac[-1] * inverse[-1]) % mod)\n return fac, ifac\n\nfac, ifac = make_tables(p, h+w-2)\ntotal = 0\nfor i in range(b, w):\n r1 = cmb(h-a-1+i,i,p,fac, ifac)\n r3 = cmb(a-1+w-1-i, a-1,p,fac, ifac)\n \n total = total +( r1*r3)\nprint(total%p) ", "import math", "math", "h,w,a,b = list(map(int, input().split()))", "h", "list(map(int, input().split()))", "list", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "w", "a", "b", "p = 10**9+7", "p", "10**9+7", "10**9", "10", "9", "7", "def cmb(n, k, mod, fac, ifac):\n \"\"\"\n nCkを計算する\n \"\"\"\n k = min(k, n-k)\n return fac[n] * ifac[k] * ifac[n-k] % mod", "cmb", "\"\"\"\n nCkを計算する\n \"\"\"", "k = min(k, n-k)", "k", "min(k, n-k)", "min", "k", "n-k", "n", "k", "return fac[n] * ifac[k] * ifac[n-k] % mod", "fac[n] * ifac[k] * ifac[n-k] % mod", "fac[n] * ifac[k] * ifac[n-k]", "fac[n] * ifac[k]", "fac[n]", "fac", "n", "ifac[k]", "ifac", "k", "ifac[n-k]", "ifac", "n-k", "n", "k", "mod", "n", "n", "k", "k", "mod", "mod", "fac", "fac", "ifac", "ifac", "def make_tables(mod, n):\n \"\"\"\n 階乗テーブル、逆元の階乗テーブルを作成する\n \"\"\"\n fac = [1, 1] # 階乗テーブル・・・(1)\n ifac = [1, 1] #逆元の階乗テーブル・・・(2)\n inverse = [0, 1] #逆元テーブル・・・(3)\n\n for i in range(2, n+1):\n fac.append((fac[-1] * i) % mod)\n inverse.append((-inverse[mod % i] * (mod//i)) % mod)\n ifac.append((ifac[-1] * inverse[-1]) % mod)\n return fac, ifac", "make_tables", "\"\"\"\n 階乗テーブル、逆元の階乗テーブルを作成する\n \"\"\"", "fac = [1, 1]", "fac", "[1, 1]", "1", "1", "ifac = [1, 1]", "ifac", "[1, 1]", "1", "1", "inverse = [0, 1]", "inverse", "[0, 1]", "0", "1", "for i in range(2, n+1):\n fac.append((fac[-1] * i) % mod)\n inverse.append((-inverse[mod % i] * (mod//i)) % mod)\n ifac.append((ifac[-1] * inverse[-1]) % mod)\n ", "i", "range(2, n+1)", "range", "2", "n+1", "n", "1", "fac.append((fac[-1] * i) % mod)", "fac.append", "fac", "append", "(fac[-1] * i) % mod", "fac[-1] * i", "fac[-1]", "fac", "-1", "i", "mod", "inverse.append((-inverse[mod % i] * (mod//i)) % mod)", "inverse.append", "inverse", "append", "(-inverse[mod % i] * (mod//i)) % mod", "-inverse[mod % i] * (mod//i)", "-inverse[mod % i]", "inverse[mod % i]", "inverse", "mod % i", "mod", "i", "mod//i", "mod", "i", "mod", "ifac.append((ifac[-1] * inverse[-1]) % mod)", "ifac.append", "ifac", "append", "(ifac[-1] * inverse[-1]) % mod", "ifac[-1] * inverse[-1]", "ifac[-1]", "ifac", "-1", "inverse[-1]", "inverse", "-1", "mod", "return fac, ifac", "return fac, ifac", "fac", "ifac", "mod", "mod", "n", "n", "fac, ifac = make_tables(p, h+w-2)", "fac", "make_tables(p, h+w-2)", "make_tables", "p", "h+w-2", "h+w", "h", "w", "2", "ifac", "total = 0", "total", "0", "for i in range(b, w):\n r1 = cmb(h-a-1+i,i,p,fac, ifac)\n r3 = cmb(a-1+w-1-i, a-1,p,fac, ifac)\n \n total = total +( r1*r3)", "i", "range(b, w)", "range", "b", "w", "r1 = cmb(h-a-1+i,i,p,fac, ifac)", "r1", "cmb(h-a-1+i,i,p,fac, ifac)", "cmb", "h-a-1+i", "h-a-1", "h-a", "h", "a", "1", "i", "i", "p", "fac", "ifac", "r3 = cmb(a-1+w-1-i, a-1,p,fac, ifac)", "r3", "cmb(a-1+w-1-i, a-1,p,fac, ifac)", "cmb", "a-1+w-1-i", "a-1+w-1", "a-1+w", "a-1", "a", "1", "w", "1", "i", "a-1", "a", "1", "p", "fac", "ifac", "total = total +( r1*r3)", "total", "total +( r1*r3)", "total", "r1*r3", "r1", "r3", "print(total%p)", "print", "total%p", "total", "p", "fac, ifac = make_tables(p, h+w-2)", "make_tables(p, h+w-2)", "fac", "r1 = cmb(h-a-1+i,i,p,fac, ifac)", "cmb(h-a-1+i,i,p,fac, ifac)", "r1", "total = total +( r1*r3)", "total +( r1*r3)", "total", "a,b = list(map(int, input().split()))", "list(map(int, input().split()))", "a", "def make_tables(mod, n):\n \"\"\"\n 階乗テーブル、逆元の階乗テーブルを作成する\n \"\"\"\n fac = [1, 1] # 階乗テーブル・・・(1)\n ifac = [1, 1] #逆元の階乗テーブル・・・(2)\n inverse = [0, 1] #逆元テーブル・・・(3)\n\n for i in range(2, n+1):\n fac.append((fac[-1] * i) % mod)\n inverse.append((-inverse[mod % i] * (mod//i)) % mod)\n ifac.append((ifac[-1] * inverse[-1]) % mod)\n return fac, ifac", "def make_tables(mod, n):\n \"\"\"\n 階乗テーブル、逆元の階乗テーブルを作成する\n \"\"\"\n fac = [1, 1] # 階乗テーブル・・・(1)\n ifac = [1, 1] #逆元の階乗テーブル・・・(2)\n inverse = [0, 1] #逆元テーブル・・・(3)\n\n for i in range(2, n+1):\n fac.append((fac[-1] * i) % mod)\n inverse.append((-inverse[mod % i] * (mod//i)) % mod)\n ifac.append((ifac[-1] * inverse[-1]) % mod)\n return fac, ifac", "make_tables", "p = 10**9+7", "10**9+7", "p", "r3 = cmb(a-1+w-1-i, a-1,p,fac, ifac)", "cmb(a-1+w-1-i, a-1,p,fac, ifac)", "r3", "h,w,a,b = list(map(int, input().split()))", "list(map(int, input().split()))", "h", "def cmb(n, k, mod, fac, ifac):\n \"\"\"\n nCkを計算する\n \"\"\"\n k = min(k, n-k)\n return fac[n] * ifac[k] * ifac[n-k] % mod", "def cmb(n, k, mod, fac, ifac):\n \"\"\"\n nCkを計算する\n \"\"\"\n k = min(k, n-k)\n return fac[n] * ifac[k] * ifac[n-k] % mod", "cmb", "ifac = make_tables(p, h+w-2)", "make_tables(p, h+w-2)", "ifac", "b = list(map(int, input().split()))", "list(map(int, input().split()))", "b", "w,a,b = list(map(int, input().split()))", "list(map(int, input().split()))", "w", "total = 0", "0", "total" ]

[ 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, 4, 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, 2, 13, 13, 0, 13, 2, 4, 13, 2, 2, 2, 2, 13, 13, 13, 17, 13, 2, 13, 13, 13, 4, 13, 2, 2, 2, 2, 13, 13, 13, 17, 13, 2, 13, 17, 13, 0, 13, 13, 0, 13, 13, 4, 13, 13, 10, 39, 13, 10, 13, 13, 10, 2, 13, 10, 4, 13, 10, 13, 13, 10, 39, 13, 10, 4, 13, 10, 12, 13, 10, 4, 13, 10, 2, 13, 10, 4, 13, 10, 39, 13, 10, 17, 13, 10, 4, 13 ]

[ [ 225, 2 ], [ 225, 11 ], [ 225, 12 ], [ 225, 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 ], [ 210, 57 ], [ 192, 66 ], [ 219, 71 ], [ 186, 76 ], [ 201, 81 ], [ 87, 86 ], [ 193, 91 ], [ 220, 95 ], [ 220, 100 ], [ 86, 102 ], [ 211, 103 ], [ 202, 106 ], [ 202, 112 ], [ 211, 114 ], [ 86, 115 ], [ 211, 117 ], [ 86, 118 ], [ 211, 119 ], [ 187, 122 ], [ 187, 127 ], [ 202, 130 ], [ 211, 132 ], [ 222, 134 ], [ 138, 137 ], [ 217, 141 ], [ 205, 142 ], [ 213, 144 ], [ 208, 147 ], [ 226, 152 ], [ 196, 153 ], [ 205, 154 ], [ 137, 156 ], [ 205, 158 ], [ 137, 159 ], [ 211, 160 ], [ 208, 162 ], [ 217, 167 ], [ 205, 168 ], [ 196, 169 ], [ 137, 171 ], [ 196, 173 ], [ 211, 175 ], [ 189, 177 ], [ 214, 178 ], [ 198, 180 ], [ 211, 181 ], [ 199, 184 ], [ 190, 184 ], [ 223, 184 ], [ 186, 187 ], [ 214, 189 ], [ 189, 190 ], [ 192, 193 ], [ 225, 196 ], [ 211, 198 ], [ 198, 199 ], [ 201, 202 ], [ 225, 205 ], [ 210, 211 ], [ 213, 214 ], [ 225, 217 ], [ 219, 220 ], [ 222, 223 ], [ 225, 226 ] ]

[ "H, W, A, B = map(int, input().split())\n\ndef cmb(n, r, mod):\n if ( r<0 or r>n ):\n return 0\n r = min(r, n-r)\n return g1[n] * g2[r] * g2[n-r] % mod\n\nmod = int(10**9+7) #出力の制限\nNN = 10**6 # 使うデータによって変える\ng1 = [1, 1] # 元テーブル\ng2 = [1, 1] #逆元テーブル\ninverse = [0, 1] #逆元テーブル計算用テーブル\n\nfor i in range( 2, NN + 1 ):\n g1.append( ( g1[-1] * i ) % mod )\n inverse.append( ( -inverse[mod % i] * (mod//i) ) % mod )\n g2.append( (g2[-1] * inverse[-1]) % mod )\n\n\nans = 0\nfor i in range(W-B):\n a = cmb(H-A+B-1+i, B+i, mod)* cmb(W-B+A-2-i, A-1, mod)\n ans += a\n ans %= mod\nprint(ans)", "H, W, A, B = map(int, input().split())", "H", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "W", "A", "B", "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 = int(10**9+7)", "mod", "int(10**9+7)", "int", "10**9+7", "10**9", "10", "9", "7", "NN = 10**6", "NN", "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, NN + 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, NN + 1 )", "range", "2", "NN + 1", "NN", "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(W-B):\n a = cmb(H-A+B-1+i, B+i, mod)* cmb(W-B+A-2-i, A-1, mod)\n ans += a\n ans %= mod", "i", "range(W-B)", "range", "W-B", "W", "B", "a = cmb(H-A+B-1+i, B+i, mod)* cmb(W-B+A-2-i, A-1, mod)", "a", "cmb(H-A+B-1+i, B+i, mod)* cmb(W-B+A-2-i, A-1, mod)", "cmb(H-A+B-1+i, B+i, mod)", "cmb", "H-A+B-1+i", "H-A+B-1", "H-A+B", "H-A", "H", "A", "B", "1", "i", "B+i", "B", "i", "mod", "cmb(W-B+A-2-i, A-1, mod)", "cmb", "W-B+A-2-i", "W-B+A-2", "W-B+A", "W-B", "W", "B", "A", "2", "i", "A-1", "A", "1", "mod", "ans += a", "ans", "a", "ans %= mod", "ans", "mod", "print(ans)", "print", "ans", "g2 = [1, 1]", "[1, 1]", "g2", "ans += a", "a", "ans", "NN = 10**6", "10**6", "NN", "A, B = map(int, input().split())", "map(int, input().split())", "A", "ans %= mod", "mod", "ans", "inverse = [0, 1]", "[0, 1]", "inverse", "B = map(int, input().split())", "map(int, input().split())", "B", "def cmb(n, r, mod):\n if ( r<0 or r>n ):\n return 0\n r = min(r, n-r)\n return g1[n] * g2[r] * g2[n-r] % mod", "def cmb(n, r, mod):\n if ( r<0 or r>n ):\n return 0\n r = min(r, n-r)\n return g1[n] * g2[r] * g2[n-r] % mod", "cmb", "mod = int(10**9+7)", "int(10**9+7)", "mod", "a = cmb(H-A+B-1+i, B+i, mod)* cmb(W-B+A-2-i, A-1, mod)", "cmb(H-A+B-1+i, B+i, mod)* cmb(W-B+A-2-i, A-1, mod)", "a", "W, A, B = map(int, input().split())", "map(int, input().split())", "W", "g1 = [1, 1]", "[1, 1]", "g1", "ans = 0", "0", "ans", "H, W, A, B = map(int, input().split())", "map(int, input().split())", "H" ]

[ 7, 15, 15, 15, 13, 15, 13, 15, 13, 15, 15, 13, 15, 13, 15, 15, 15, 15, 4, 18, 13, 13, 2, 17, 17, 0, 13, 4, 13, 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, 0, 13, 17, 0, 13, 4, 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, 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, 12, 13, 14, 2, 2, 2, 13, 13, 2, 13, 17, 2, 13, 17, 29, 17, 29, 2, 2, 2, 18, 13, 13, 18, 13, 2, 13, 13, 18, 13, 13, 13, 23, 13, 23, 13, 0, 13, 4, 13, 2, 2, 2, 13, 13, 17, 13, 2, 13, 17, 0, 13, 17, 28, 13, 4, 13, 17, 2, 13, 13, 0, 13, 2, 2, 2, 4, 13, 2, 13, 13, 13, 13, 4, 13, 2, 2, 2, 2, 13, 13, 17, 13, 13, 2, 2, 13, 17, 13, 13, 0, 13, 13, 0, 13, 4, 13, 2, 13, 13, 13, 4, 13, 13, 10, 4, 13, 10, 12, 13, 10, 12, 13, 10, 4, 13, 10, 12, 13, 10, 4, 13, 10, 2, 13, 10, 4, 13, 10, 12, 13, 10, 12, 13, 10, 4, 13, 10, 12, 13, 10, 12, 13, 10, 12, 13, 10, 17, 13, 10, 13, 13, 10, 12, 13, 10, 4, 13, 10, 4, 13, 10, 2, 13, 10, 17, 13, 10, 2, 13, 10, 12, 13, 10, 12, 13, 10, 2, 13 ]

[ [ 320, 26 ], [ 41, 40 ], [ 324, 46 ], [ 50, 50 ], [ 54, 53 ], [ 360, 59 ], [ 63, 63 ], [ 67, 66 ], [ 351, 72 ], [ 76, 76 ], [ 80, 79 ], [ 336, 85 ], [ 89, 89 ], [ 93, 92 ], [ 351, 100 ], [ 104, 104 ], [ 108, 107 ], [ 116, 116 ], [ 353, 118 ], [ 365, 121 ], [ 360, 123 ], [ 365, 124 ], [ 365, 125 ], [ 365, 126 ], [ 383, 128 ], [ 363, 130 ], [ 366, 131 ], [ 329, 133 ], [ 384, 138 ], [ 368, 141 ], [ 384, 146 ], [ 150, 149 ], [ 384, 154 ], [ 160, 157 ], [ 330, 158 ], [ 149, 159 ], [ 330, 163 ], [ 149, 165 ], [ 149, 167 ], [ 354, 168 ], [ 173, 170 ], [ 369, 171 ], [ 384, 172 ], [ 330, 176 ], [ 384, 177 ], [ 354, 179 ], [ 354, 181 ], [ 184, 183 ], [ 384, 187 ], [ 195, 192 ], [ 369, 193 ], [ 183, 194 ], [ 369, 198 ], [ 183, 200 ], [ 183, 203 ], [ 354, 205 ], [ 241, 212 ], [ 239, 213 ], [ 239, 215 ], [ 241, 218 ], [ 330, 227 ], [ 239, 228 ], [ 369, 230 ], [ 239, 232 ], [ 241, 233 ], [ 369, 235 ], [ 241, 236 ], [ 354, 237 ], [ 239, 239 ], [ 241, 241 ], [ 341, 243 ], [ 378, 245 ], [ 366, 249 ], [ 363, 250 ], [ 333, 252 ], [ 363, 254 ], [ 371, 257 ], [ 261, 260 ], [ 363, 265 ], [ 327, 266 ], [ 374, 268 ], [ 378, 273 ], [ 333, 275 ], [ 260, 276 ], [ 260, 277 ], [ 372, 278 ], [ 312, 278 ], [ 378, 280 ], [ 366, 285 ], [ 363, 286 ], [ 333, 288 ], [ 260, 289 ], [ 363, 292 ], [ 260, 294 ], [ 354, 295 ], [ 356, 297 ], [ 354, 298 ], [ 311, 300 ], [ 378, 302 ], [ 333, 304 ], [ 260, 305 ], [ 260, 306 ], [ 357, 309 ], [ 375, 309 ], [ 342, 309 ], [ 311, 312 ], [ 320, 321 ], [ 365, 327 ], [ 329, 330 ], [ 365, 333 ], [ 341, 342 ], [ 353, 354 ], [ 354, 356 ], [ 356, 357 ], [ 365, 363 ], [ 365, 366 ], [ 368, 369 ], [ 371, 372 ], [ 374, 375 ], [ 383, 384 ] ]

[ "from collections import defaultdict, deque, Counter\nfrom heapq import heappush, heappop, heapify\nimport math\nimport bisect\nimport random\nfrom itertools import permutations, accumulate, combinations, product\nimport sys\nimport string\nfrom bisect import bisect_left, bisect_right\nfrom math import factorial, ceil, floor, atan2, degrees\nfrom operator import mul\nfrom functools import reduce\nsys.setrecursionlimit(10**8)\n\nINF = float('inf')\ndef LI(): return list(map(int, sys.stdin.readline().split()))\ndef I(): return int(sys.stdin.readline())\ndef LS(): return sys.stdin.readline().split()\ndef S(): return sys.stdin.readline().strip()\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)]\nmod = 1000000007\n\n\nh, w, a, b = LI()\nn = h + w\n\nfac = [1] * (n + 1)\ninv = [1] * (n + 1)\nfor j in range(1, n + 1):\n fac[j] = fac[j-1] * j % mod\n\n\ninv[n] = pow(fac[n], mod-2, mod)\nfor j in range(n-1, -1, -1):\n inv[j] = inv[j+1] * (j+1) % mod\n\n\ndef comb(n, r):\n if r > n or n < 0 or r < 0:\n return 0\n return fac[n] * inv[n - r] * inv[r] % mod\n\n\nans = comb(w + h - 2 - b, h - 1)\npre = 1\nfor i in range(1, h - a):\n ans += (comb(b + i, i) - pre) * comb(w + h - 2 - b - i, h - 1 - i) % mod\n ans %= mod\n pre = comb(b + i, i)\n\n\nprint(ans)", "from collections import defaultdict, deque, Counter", "from heapq import heappush, heappop, heapify", "import math", "math", "import bisect", "bisect", "import random", "random", "from itertools import permutations, accumulate, combinations, product", "import sys", "sys", "import string", "string", "from bisect import bisect_left, bisect_right", "from math import factorial, ceil, floor, atan2, degrees", "from operator import mul", "from functools import reduce", "sys.setrecursionlimit(10**8)", "sys.setrecursionlimit", "sys", "setrecursionlimit", "10**8", "10", "8", "INF = float('inf')", "INF", "float('inf')", "float", "'inf'", "def LI(): return list(map(int, sys.stdin.readline().split()))", "LI", "def I(): return int(sys.stdin.readline())", "I", "def LS(): return sys.stdin.readline().split()", "LS", "def S(): return sys.stdin.readline().strip()", "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", "mod = 1000000007", "mod", "1000000007", "h, w, a, b = LI()", "h", "LI()", "LI", "w", "a", "b", "n = h + w", "n", "h + w", "h", "w", "fac = [1] * (n + 1)", "fac", "[1] * (n + 1)", "[1]", "1", "n + 1", "n", "1", "inv = [1] * (n + 1)", "inv", "[1] * (n + 1)", "[1]", "1", "n + 1", "n", "1", "for j in range(1, n + 1):\n fac[j] = fac[j-1] * j % mod", "j", "range(1, n + 1)", "range", "1", "n + 1", "n", "1", "fac[j] = fac[j-1] * j % mod", "fac[j]", "fac", "j", "fac[j-1] * j % mod", "fac[j-1] * j", "fac[j-1]", "fac", "j-1", "j", "1", "j", "mod", "inv[n] = pow(fac[n], mod-2, mod)", "inv[n]", "inv", "n", "pow(fac[n], mod-2, mod)", "pow", "fac[n]", "fac", "n", "mod-2", "mod", "2", "mod", "for j in range(n-1, -1, -1):\n inv[j] = inv[j+1] * (j+1) % mod", "j", "range(n-1, -1, -1)", "range", "n-1", "n", "1", "-1", "-1", "inv[j] = inv[j+1] * (j+1) % mod", "inv[j]", "inv", "j", "inv[j+1] * (j+1) % mod", "inv[j+1] * (j+1)", "inv[j+1]", "inv", "j+1", "j", "1", "j+1", "j", "1", "mod", "def comb(n, r):\n if r > n or n < 0 or r < 0:\n return 0\n return fac[n] * inv[n - r] * inv[r] % mod", "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 fac[n] * inv[n - r] * inv[r] % mod", "fac[n] * inv[n - r] * inv[r] % mod", "fac[n] * inv[n - r] * inv[r]", "fac[n] * inv[n - r]", "fac[n]", "fac", "n", "inv[n - r]", "inv", "n - r", "n", "r", "inv[r]", "inv", "r", "mod", "n", "n", "r", "r", "ans = comb(w + h - 2 - b, h - 1)", "ans", "comb(w + h - 2 - b, h - 1)", "comb", "w + h - 2 - b", "w + h - 2", "w + h", "w", "h", "2", "b", "h - 1", "h", "1", "pre = 1", "pre", "1", "for i in range(1, h - a):\n ans += (comb(b + i, i) - pre) * comb(w + h - 2 - b - i, h - 1 - i) % mod\n ans %= mod\n pre = comb(b + i, i)", "i", "range(1, h - a)", "range", "1", "h - a", "h", "a", "ans += (comb(b + i, i) - pre) * comb(w + h - 2 - b - i, h - 1 - i) % mod", "ans", "(comb(b + i, i) - pre) * comb(w + h - 2 - b - i, h - 1 - i) % mod", "(comb(b + i, i) - pre) * comb(w + h - 2 - b - i, h - 1 - i)", "comb(b + i, i) - pre", "comb(b + i, i)", "comb", "b + i", "b", "i", "i", "pre", "comb(w + h - 2 - b - i, h - 1 - i)", "comb", "w + h - 2 - b - i", "w + h - 2 - b", "w + h - 2", "w + h", "w", "h", "2", "b", "i", "h - 1 - i", "h - 1", "h", "1", "i", "mod", "ans %= mod", "ans", "mod", "pre = comb(b + i, i)", "pre", "comb(b + i, i)", "comb", "b + i", "b", "i", "i", "print(ans)", "print", "ans", "pre = comb(b + i, i)", "comb(b + i, i)", "pre", "def SRL(n): return [list(S()) for i in range(n)]", "def SRL(n): return [list(S()) for i in range(n)]", "SRL", "def SR(n): return [S() for i in range(n)]", "def SR(n): return [S() for i in range(n)]", "SR", "INF = float('inf')", "float('inf')", "INF", "def I(): return int(sys.stdin.readline())", "def I(): return int(sys.stdin.readline())", "I", "a, b = LI()", "LI()", "a", "fac = [1] * (n + 1)", "[1] * (n + 1)", "fac", "b = LI()", "LI()", "b", "def LS(): return sys.stdin.readline().split()", "def LS(): return sys.stdin.readline().split()", "LS", "def IR(n): return [I() for i in range(n)]", "def IR(n): return [I() for i in range(n)]", "IR", "ans = comb(w + h - 2 - b, h - 1)", "comb(w + h - 2 - b, h - 1)", "ans", "def LSR(n): return [LS() for i in range(n)]", "def LSR(n): return [LS() for i in range(n)]", "LSR", "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 S(): return sys.stdin.readline().strip()", "def S(): return sys.stdin.readline().strip()", "S", "mod = 1000000007", "1000000007", "mod", "ans %= mod", "mod", "ans", "def LI(): return list(map(int, sys.stdin.readline().split()))", "def LI(): return list(map(int, sys.stdin.readline().split()))", "LI", "h, w, a, b = LI()", "LI()", "h", "w, a, b = LI()", "LI()", "w", "inv = [1] * (n + 1)", "[1] * (n + 1)", "inv", "pre = 1", "1", "pre", "ans += (comb(b + i, i) - pre) * comb(w + h - 2 - b - i, h - 1 - i) % mod", "(comb(b + i, i) - pre) * comb(w + h - 2 - b - i, h - 1 - i) % mod", "ans", "def comb(n, r):\n if r > n or n < 0 or r < 0:\n return 0\n return fac[n] * inv[n - r] * inv[r] % mod", "def comb(n, r):\n if r > n or n < 0 or r < 0:\n return 0\n return fac[n] * inv[n - r] * inv[r] % mod", "comb", "def LIR(n): return [LI() for i in range(n)]", "def LIR(n): return [LI() for i in range(n)]", "LIR", "n = h + w", "h + w", "n" ]

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

[ [ 167, 2 ], [ 167, 11 ], [ 167, 12 ], [ 167, 13 ], [ 155, 15 ], [ 143, 22 ], [ 158, 26 ], [ 31, 30 ], [ 150, 36 ], [ 162, 37 ], [ 144, 41 ], [ 144, 46 ], [ 30, 48 ], [ 30, 50 ], [ 156, 51 ], [ 159, 54 ], [ 144, 59 ], [ 156, 62 ], [ 156, 64 ], [ 144, 71 ], [ 82, 72 ], [ 159, 74 ], [ 82, 76 ], [ 84, 77 ], [ 159, 79 ], [ 84, 80 ], [ 82, 82 ], [ 84, 84 ], [ 146, 86 ], [ 90, 89 ], [ 150, 93 ], [ 153, 94 ], [ 173, 96 ], [ 171, 99 ], [ 89, 102 ], [ 168, 103 ], [ 89, 107 ], [ 168, 109 ], [ 171, 112 ], [ 150, 118 ], [ 89, 119 ], [ 162, 121 ], [ 168, 122 ], [ 150, 128 ], [ 89, 129 ], [ 162, 133 ], [ 168, 134 ], [ 164, 137 ], [ 156, 138 ], [ 165, 141 ], [ 174, 141 ], [ 147, 141 ], [ 143, 144 ], [ 146, 147 ], [ 167, 150 ], [ 167, 153 ], [ 155, 156 ], [ 158, 159 ], [ 167, 162 ], [ 156, 164 ], [ 164, 165 ], [ 167, 168 ], [ 173, 174 ] ]

[ "H,W,A,B = map(int,input().split())\nMOD = 10**9 + 7\nFAC = [1]\nINV = [1]\nfor i in range(1,H+W+1):\n FAC.append((FAC[i-1]*i) % MOD)\n INV.append(pow(FAC[-1],MOD-2,MOD))\n#print(FAC)\n#print(INV)\n\ndef nCr(n,r):\n return FAC[n]*INV[n-r]*INV[r]\n\nans = 0\nfor i in range(H-A):\n ans += nCr(i+B-1,min(i,B-1)) * nCr(H-i-1+W-B-1,min(H-i-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", "MOD = 10**9 + 7", "MOD", "10**9 + 7", "10**9", "10", "9", "7", "FAC = [1]", "FAC", "[1]", "1", "INV = [1]", "INV", "[1]", "1", "for i in range(1,H+W+1):\n FAC.append((FAC[i-1]*i) % MOD)\n INV.append(pow(FAC[-1],MOD-2,MOD))\n#print(FAC)\n#print(INV)", "i", "range(1,H+W+1)", "range", "1", "H+W+1", "H+W", "H", "W", "1", "FAC.append((FAC[i-1]*i) % MOD)", "FAC.append", "FAC", "append", "(FAC[i-1]*i) % MOD", "FAC[i-1]*i", "FAC[i-1]", "FAC", "i-1", "i", "1", "i", "MOD", "INV.append(pow(FAC[-1],MOD-2,MOD))", "INV.append", "INV", "append", "pow(FAC[-1],MOD-2,MOD)", "pow", "FAC[-1]", "FAC", "-1", "MOD-2", "MOD", "2", "MOD", "def nCr(n,r):\n return FAC[n]*INV[n-r]*INV[r]", "nCr", "return FAC[n]*INV[n-r]*INV[r]", "FAC[n]*INV[n-r]*INV[r]", "FAC[n]*INV[n-r]", "FAC[n]", "FAC", "n", "INV[n-r]", "INV", "n-r", "n", "r", "INV[r]", "INV", "r", "n", "n", "r", "r", "ans = 0", "ans", "0", "for i in range(H-A):\n ans += nCr(i+B-1,min(i,B-1)) * nCr(H-i-1+W-B-1,min(H-i-1,W-B-1))\n ans %= MOD", "i", "range(H-A)", "range", "H-A", "H", "A", "ans += nCr(i+B-1,min(i,B-1)) * nCr(H-i-1+W-B-1,min(H-i-1,W-B-1))", "ans", "nCr(i+B-1,min(i,B-1)) * nCr(H-i-1+W-B-1,min(H-i-1,W-B-1))", "nCr(i+B-1,min(i,B-1))", "nCr", "i+B-1", "i+B", "i", "B", "1", "min(i,B-1)", "min", "i", "B-1", "B", "1", "nCr(H-i-1+W-B-1,min(H-i-1,W-B-1))", "nCr", "H-i-1+W-B-1", "H-i-1+W-B", "H-i-1+W", "H-i-1", "H-i", "H", "i", "1", "W", "B", "1", "min(H-i-1,W-B-1)", "min", "H-i-1", "H-i", "H", "i", "1", "W-B-1", "W-B", "W", "B", "1", "ans %= MOD", "ans", "MOD", "print(ans)", "print", "ans", "FAC = [1]", "[1]", "FAC", "ans = 0", "0", "ans", "H,W,A,B = map(int,input().split())", "map(int,input().split())", "H", "A,B = map(int,input().split())", "map(int,input().split())", "A", "MOD = 10**9 + 7", "10**9 + 7", "MOD", "INV = [1]", "[1]", "INV", "W,A,B = map(int,input().split())", "map(int,input().split())", "W", "ans %= MOD", "MOD", "ans", "B = map(int,input().split())", "map(int,input().split())", "B", "def nCr(n,r):\n return FAC[n]*INV[n-r]*INV[r]", "def nCr(n,r):\n return FAC[n]*INV[n-r]*INV[r]", "nCr", "ans += nCr(i+B-1,min(i,B-1)) * nCr(H-i-1+W-B-1,min(H-i-1,W-B-1))", "nCr(i+B-1,min(i,B-1)) * nCr(H-i-1+W-B-1,min(H-i-1,W-B-1))", "ans" ]