from typing import Any, overload, Literal, Union


@overload
def func(x: Literal[0], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[1], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[2], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[3], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[4], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[5], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[6], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[7], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[8], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[9], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[10], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[11], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[12], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[13], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[14], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[15], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[16], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[17], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[18], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[19], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[20], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[21], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[22], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[23], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[24], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[25], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[26], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[27], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[28], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[29], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[30], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[31], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[32], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[33], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[34], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[35], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[36], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[37], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[38], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[39], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[40], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[41], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[42], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[43], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[44], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[45], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[46], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[47], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[48], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[49], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[50], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[51], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[52], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[53], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[54], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[55], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[56], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[57], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[58], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[59], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[60], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[61], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[62], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[63], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[64], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[65], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[66], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[67], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[68], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[69], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[70], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[71], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[72], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[73], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[74], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[75], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[76], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[77], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[78], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[79], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[80], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[81], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[82], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[83], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[84], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[85], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[86], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[87], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[88], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[89], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[90], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[91], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[92], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[93], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[94], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[95], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[96], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[97], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[98], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[99], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[100], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[101], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[102], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[103], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[104], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[105], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[106], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[107], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[108], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[109], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[110], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[111], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[112], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[113], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[114], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[115], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[116], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[117], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[118], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[119], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[120], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[121], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[122], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[123], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[124], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[125], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[126], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[127], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[128], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[129], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[130], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[131], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[132], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[133], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[134], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[135], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[136], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[137], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[138], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[139], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[140], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[141], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[142], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[143], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[144], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[145], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[146], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[147], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[148], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[149], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[150], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[151], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[152], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[153], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[154], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[155], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[156], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[157], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[158], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[159], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[160], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[161], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[162], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[163], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[164], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[165], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[166], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[167], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[168], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[169], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[170], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[171], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[172], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[173], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[174], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[175], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[176], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[177], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[178], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[179], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[180], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[181], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[182], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[183], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[184], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[185], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[186], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[187], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[188], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[189], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[190], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[191], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[192], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[193], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[194], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[195], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[196], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[197], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[198], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[199], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[200], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[201], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[202], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[203], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[204], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[205], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[206], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[207], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[208], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[209], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[210], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[211], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[212], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[213], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[214], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[215], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[216], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[217], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[218], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[219], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[220], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[221], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[222], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[223], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[224], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[225], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[226], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[227], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[228], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[229], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[230], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[231], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[232], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[233], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[234], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[235], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[236], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[237], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[238], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[239], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[240], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[241], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[242], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[243], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[244], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[245], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[246], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[247], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[248], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[249], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[250], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[251], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[252], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[253], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[254], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[255], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[256], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[257], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[258], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[259], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[260], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[261], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[262], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[263], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[264], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[265], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[266], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[267], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[268], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[269], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[270], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[271], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[272], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[273], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[274], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[275], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[276], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[277], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[278], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[279], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[280], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[281], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[282], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[283], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[284], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[285], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[286], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[287], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[288], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[289], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[290], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[291], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[292], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[293], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[294], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[295], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[296], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[297], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[298], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[299], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[300], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[301], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[302], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[303], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[304], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[305], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[306], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[307], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[308], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[309], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[310], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[311], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[312], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[313], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[314], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[315], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[316], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[317], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[318], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[319], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[320], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[321], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[322], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[323], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[324], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[325], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[326], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[327], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[328], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[329], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[330], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[331], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[332], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[333], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[334], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[335], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[336], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[337], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[338], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[339], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[340], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[341], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[342], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[343], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[344], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[345], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[346], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[347], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[348], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[349], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[350], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[351], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[352], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[353], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[354], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[355], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[356], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[357], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[358], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[359], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[360], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[361], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[362], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[363], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[364], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[365], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[366], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[367], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[368], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[369], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[370], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[371], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[372], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[373], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[374], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[375], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[376], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[377], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[378], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[379], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[380], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[381], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[382], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[383], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[384], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[385], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[386], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[387], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[388], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[389], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[390], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[391], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[392], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[393], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[394], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[395], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[396], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[397], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[398], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[399], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[400], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[401], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[402], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[403], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[404], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[405], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[406], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[407], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[408], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[409], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[410], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[411], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[412], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[413], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[414], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[415], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[416], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[417], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[418], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[419], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[420], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[421], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[422], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[423], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[424], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[425], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[426], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[427], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[428], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[429], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[430], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[431], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[432], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[433], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[434], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[435], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[436], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[437], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[438], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[439], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[440], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[441], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[442], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[443], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[444], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[445], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[446], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[447], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[448], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[449], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[450], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[451], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[452], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[453], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[454], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[455], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[456], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[457], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[458], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[459], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[460], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[461], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[462], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[463], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[464], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[465], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[466], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[467], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[468], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[469], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[470], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[471], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[472], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[473], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[474], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[475], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[476], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[477], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[478], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[479], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[480], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[481], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[482], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[483], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[484], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[485], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[486], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[487], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[488], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[489], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[490], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[491], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[492], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[493], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[494], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[495], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[496], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[497], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[498], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[499], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[500], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[501], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[502], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[503], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[504], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[505], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[506], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[507], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[508], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[509], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[510], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[511], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[512], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[513], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[514], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[515], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[516], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[517], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[518], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[519], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[520], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[521], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[522], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[523], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[524], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[525], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[526], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[527], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[528], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[529], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[530], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[531], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[532], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[533], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[534], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[535], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[536], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[537], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[538], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[539], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[540], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[541], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[542], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[543], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[544], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[545], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[546], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[547], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[548], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[549], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[550], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[551], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[552], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[553], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[554], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[555], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[556], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[557], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[558], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[559], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[560], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[561], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[562], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[563], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[564], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[565], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[566], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[567], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[568], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[569], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[570], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[571], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[572], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[573], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[574], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[575], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[576], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[577], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[578], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[579], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[580], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[581], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[582], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[583], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[584], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[585], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[586], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[587], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[588], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[589], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[590], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[591], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[592], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[593], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[594], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[595], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[596], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[597], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[598], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[599], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[600], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[601], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[602], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[603], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[604], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[605], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[606], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[607], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[608], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[609], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[610], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[611], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[612], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[613], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[614], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[615], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[616], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[617], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[618], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[619], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[620], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[621], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[622], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[623], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[624], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[625], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[626], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[627], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[628], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[629], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[630], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[631], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[632], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[633], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[634], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[635], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[636], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[637], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[638], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[639], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[640], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[641], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[642], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[643], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[644], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[645], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[646], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[647], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[648], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[649], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[650], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[651], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[652], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[653], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[654], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[655], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[656], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[657], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[658], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[659], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[660], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[661], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[662], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[663], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[664], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[665], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[666], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[667], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[668], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[669], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[670], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[671], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[672], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[673], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[674], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[675], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[676], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[677], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[678], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[679], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[680], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[681], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[682], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[683], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[684], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[685], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[686], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[687], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[688], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[689], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[690], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[691], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[692], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[693], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[694], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[695], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[696], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[697], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[698], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[699], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[700], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[701], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[702], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[703], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[704], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[705], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[706], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[707], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[708], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[709], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[710], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[711], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[712], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[713], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[714], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[715], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[716], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[717], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[718], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[719], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[720], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[721], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[722], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[723], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[724], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[725], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[726], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[727], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[728], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[729], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[730], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[731], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[732], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[733], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[734], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[735], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[736], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[737], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[738], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[739], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[740], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[741], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[742], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[743], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[744], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[745], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[746], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[747], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[748], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[749], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[750], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[751], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[752], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[753], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[754], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[755], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[756], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[757], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[758], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[759], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[760], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[761], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[762], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[763], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[764], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[765], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[766], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[767], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[768], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[769], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[770], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[771], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[772], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[773], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[774], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[775], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[776], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[777], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[778], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[779], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[780], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[781], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[782], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[783], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[784], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[785], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[786], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[787], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[788], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[789], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[790], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[791], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[792], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[793], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[794], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[795], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[796], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[797], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[798], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[799], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[800], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[801], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[802], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[803], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[804], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[805], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[806], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[807], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[808], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[809], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[810], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[811], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[812], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[813], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[814], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[815], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[816], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[817], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[818], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[819], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[820], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[821], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[822], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[823], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[824], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[825], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[826], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[827], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[828], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[829], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[830], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[831], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[832], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[833], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[834], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[835], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[836], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[837], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[838], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[839], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[840], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[841], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[842], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[843], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[844], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[845], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[846], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[847], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[848], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[849], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[850], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[851], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[852], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[853], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[854], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[855], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[856], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[857], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[858], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[859], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[860], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[861], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[862], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[863], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[864], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[865], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[866], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[867], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[868], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[869], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[870], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[871], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[872], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[873], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[874], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[875], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[876], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[877], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[878], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[879], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[880], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[881], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[882], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[883], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[884], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[885], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[886], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[887], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[888], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[889], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[890], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[891], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[892], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[893], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[894], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[895], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[896], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[897], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[898], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[899], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[900], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[901], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[902], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[903], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[904], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[905], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[906], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[907], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[908], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[909], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[910], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[911], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[912], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[913], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[914], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[915], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[916], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[917], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[918], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[919], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[920], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[921], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[922], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[923], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[924], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[925], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[926], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[927], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[928], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[929], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[930], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[931], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[932], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[933], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[934], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[935], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[936], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[937], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[938], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[939], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[940], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[941], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[942], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[943], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[944], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[945], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[946], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[947], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[948], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[949], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[950], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[951], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[952], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[953], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[954], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[955], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[956], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[957], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[958], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[959], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[960], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[961], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[962], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[963], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[964], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[965], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[966], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[967], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[968], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[969], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[970], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[971], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[972], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[973], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[974], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[975], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[976], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[977], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[978], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[979], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[980], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[981], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[982], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[983], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[984], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[985], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[986], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[987], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[988], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[989], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[990], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[991], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[992], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[993], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[994], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[995], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[996], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[997], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[998], y: Union[str, bytes]) -> Any:
    pass


@overload
def func(x: Literal[999], y: Union[str, bytes]) -> int:
    pass
