text
stringlengths 1
22.8M
|
|---|
The Jeu de l'année (French for Game of the Year) was a French games award, given by the Association de Promotion et d'Evaluation des Jeux in October to outstanding parlour games
published during the previous year
published in the French language
available in sufficiently many stores
In 2005 the Jeu de l'année merged with the As d'Or. The 2020 edition took place on Thursday, February 20 and the nominees were announced at the end of January.
Previous awards
2004
Winner
Squad Seven - Roberto Fraga, TF1 Games/Fox Mind Games
Finalists
Crazy Circus - Dominique Ehrhard, Fox Mind Games
Queen's Necklace (Le Collier de la Reine) - Bruno Cathala and Bruno Faidutti
Gobblet - Thierry Denoual, Gigamic
Composio - Jean Fin, TF1 Games
Serengeti - Michael Schacht
Mare Nostrum - Serge Laget, Eurogames
2003
Winner
War of the Sheep (La Guerre des Moutons) - Philippe des Pallières, Asmodée
Finalists
Evo - Philippe Keyaerts, Eurogames
Werewolf (Les Loups-Garous de Thiercelieux) - Philippe des Pallières and Hervé Marly, Lui-Même
Medina - Stefan Dorra, Hans im Glück
San Marco - Alan R. Moon and Aaron Weissblum, Ravensburger
Mexica - Michael Kiesling and Wolfgang Kramer, Ravensburger
See also
Spiel des Jahres
References
External links
Jeu de l'année home page (in French)
Game awards
French awards
Awards established in 2003
Awards disestablished in 2005
fr:As d'Or Jeu de l'année
|
Stanley Hot Springs is a series of thermal springs located in the Selway–Bitterroot Wilderness in Idaho County, Idaho, United States.
Location
From Lewiston, Idaho, take U.S. Route 12 east toward Lolo Pass. Once past the town of Lowell drive approximately to the Wilderness Gateway Campground. Trailhead parking is located past the 'A' and 'B' loops. There is no parking fee. Access to the hot springs is via Trail #211.
Seasonal note
The bridge crossing Boulder Creek washed away in the winter of 1998–99. The USFS has not yet expressed intent to rebuild it. , the hot springs are accessed as follows:
Ford the creek and head for the log jam, located a little downriver from the trail site. The logs are well stuck in place and make a bridge across the river. Follow the logs zig zagging across the river to the center island. There is a log with a rope strung into a makeshift bridge which can be used to cross over the last half of the creek.
The optimal times to visit are after the spring runoff and before heavy snowfall, although it is possible to snowshoe into the hot springs.
Water profile
The geothermally heated water emerges at 106°F / 41°C.
References
External links
Hot springs of Idaho
Protected areas of Idaho County, Idaho
Bodies of water of Idaho County, Idaho
|
```go
// Code generated by running "go generate" in golang.org/x/text. DO NOT EDIT.
//go:build go1.21
package idna
// UnicodeVersion is the Unicode version from which the tables in this package are derived.
const UnicodeVersion = "15.0.0"
var mappings string = "" + // Size: 6704 bytes
" a 23 1o141234ilnsdhjrwy lx ; " +
"" +
"bdegikmnptuvcf" +
"zss" +
" `!!???!!?" +
"0456789+=()rsnoqsmtm17191101323152535451656183" +
"858781iiivviviiiixxi031011121314151617181920(10)(11)(12" +
")(13)(14)(15)(16)(17)(18)(19)(20)==. ()()()()()()" +
"()()()()()()()()()()()()()()()()()()()()()()()(" +
")()()()()()()()()()()()()()()()()()()()()()()()(" +
")()()()()()()()()()()()()()21222324252627282930313233343" +
"5363738394041424344454647484950123456789101112hgev" +
"" +
"" +
"" +
"" +
"01234567891011121314151617181920" +
"21222324daauovpcdmiupanamakakbmbgbkcalpfnfmgkghzmldlk" +
"lfmnmmmcmkmm2m3msms2radsrads2psnsmspvnvmvkvpwnwmwkwbqcccdckgdbgyhah" +
"pinkkktlmlnlxphprsrsvwbvmam12345678910111213141516171" +
"819202122232425262728293031fffiflst" +
"" +
"" +
"" +
"" +
" " +
"" +
"" +
"" +
"" +
"" +
"" +
" ,:!?_{}[]#&*-<>\\$%@" +
"\x22'/^|~" +
"" +
"0,1,2,3,4,5,6,7,8,9,(a" +
")(b)(c)(d)(e)(f)(g)(h)(i)(j)(k)(l)(m)(n)(o)(p)(q)(r)(s)(t)(u)(v)(w)(x)(y" +
")(z)swzhvsdppvwcmcmdmrdj" +
"" +
"" +
"" +
"" +
"" +
"" +
""
var mappingIndex = []uint16{ // 1729 elements
// Entry 0 - 3F
0x0000, 0x0000, 0x0001, 0x0004, 0x0005, 0x0008, 0x0009, 0x000a,
0x000d, 0x0010, 0x0011, 0x0012, 0x0017, 0x001c, 0x0021, 0x0024,
0x0027, 0x002a, 0x002b, 0x002e, 0x0031, 0x0034, 0x0035, 0x0036,
0x0037, 0x0038, 0x0039, 0x003c, 0x003f, 0x0042, 0x0045, 0x0048,
0x004b, 0x004c, 0x004d, 0x0051, 0x0054, 0x0055, 0x005a, 0x005e,
0x0062, 0x0066, 0x006a, 0x006e, 0x0074, 0x007a, 0x0080, 0x0086,
0x008c, 0x0092, 0x0098, 0x009e, 0x00a4, 0x00aa, 0x00b0, 0x00b6,
0x00bc, 0x00c2, 0x00c8, 0x00ce, 0x00d4, 0x00da, 0x00e0, 0x00e6,
// Entry 40 - 7F
0x00ec, 0x00f2, 0x00f8, 0x00fe, 0x0104, 0x010a, 0x0110, 0x0116,
0x011c, 0x0122, 0x0128, 0x012e, 0x0137, 0x013d, 0x0146, 0x014c,
0x0152, 0x0158, 0x015e, 0x0164, 0x016a, 0x0170, 0x0172, 0x0174,
0x0176, 0x0178, 0x017a, 0x017c, 0x017e, 0x0180, 0x0181, 0x0182,
0x0183, 0x0185, 0x0186, 0x0187, 0x0188, 0x0189, 0x018a, 0x018c,
0x018d, 0x018e, 0x018f, 0x0191, 0x0193, 0x0195, 0x0197, 0x0199,
0x019b, 0x019d, 0x019f, 0x01a0, 0x01a2, 0x01a4, 0x01a6, 0x01a8,
0x01aa, 0x01ac, 0x01ae, 0x01b0, 0x01b1, 0x01b3, 0x01b5, 0x01b6,
// Entry 80 - BF
0x01b8, 0x01ba, 0x01bc, 0x01be, 0x01c0, 0x01c2, 0x01c4, 0x01c6,
0x01c8, 0x01ca, 0x01cc, 0x01ce, 0x01d0, 0x01d2, 0x01d4, 0x01d6,
0x01d8, 0x01da, 0x01dc, 0x01de, 0x01e0, 0x01e2, 0x01e4, 0x01e5,
0x01e7, 0x01e9, 0x01eb, 0x01ed, 0x01ef, 0x01f1, 0x01f3, 0x01f5,
0x01f7, 0x01f9, 0x01fb, 0x01fd, 0x0202, 0x0207, 0x020c, 0x0211,
0x0216, 0x021b, 0x0220, 0x0225, 0x022a, 0x022f, 0x0234, 0x0239,
0x023e, 0x0243, 0x0248, 0x024d, 0x0252, 0x0257, 0x025c, 0x0261,
0x0266, 0x026b, 0x0270, 0x0275, 0x027a, 0x027e, 0x0282, 0x0287,
// Entry C0 - FF
0x0289, 0x028e, 0x0293, 0x0297, 0x029b, 0x02a0, 0x02a5, 0x02aa,
0x02af, 0x02b1, 0x02b6, 0x02bb, 0x02c0, 0x02c2, 0x02c7, 0x02c8,
0x02cd, 0x02d1, 0x02d5, 0x02da, 0x02e0, 0x02e9, 0x02ef, 0x02f8,
0x02fa, 0x02fc, 0x02fe, 0x0300, 0x030c, 0x030d, 0x030e, 0x030f,
0x0310, 0x0311, 0x0312, 0x0313, 0x0314, 0x0315, 0x0316, 0x0317,
0x0319, 0x031b, 0x031d, 0x031e, 0x0320, 0x0322, 0x0324, 0x0326,
0x0328, 0x032a, 0x032c, 0x032e, 0x0330, 0x0335, 0x033a, 0x0340,
0x0345, 0x034a, 0x034f, 0x0354, 0x0359, 0x035e, 0x0363, 0x0368,
// Entry 100 - 13F
0x036d, 0x0372, 0x0377, 0x037c, 0x0380, 0x0382, 0x0384, 0x0386,
0x038a, 0x038c, 0x038e, 0x0393, 0x0399, 0x03a2, 0x03a8, 0x03b1,
0x03b3, 0x03b5, 0x03b7, 0x03b9, 0x03bb, 0x03bd, 0x03bf, 0x03c1,
0x03c3, 0x03c5, 0x03c7, 0x03cb, 0x03cf, 0x03d3, 0x03d7, 0x03db,
0x03df, 0x03e3, 0x03e7, 0x03eb, 0x03ef, 0x03f3, 0x03ff, 0x0401,
0x0406, 0x0408, 0x040a, 0x040c, 0x040e, 0x040f, 0x0413, 0x0417,
0x041d, 0x0423, 0x0428, 0x042d, 0x0432, 0x0437, 0x043c, 0x0441,
0x0446, 0x044b, 0x0450, 0x0455, 0x045a, 0x045f, 0x0464, 0x0469,
// Entry 140 - 17F
0x046e, 0x0473, 0x0478, 0x047d, 0x0482, 0x0487, 0x048c, 0x0491,
0x0496, 0x049b, 0x04a0, 0x04a5, 0x04aa, 0x04af, 0x04b4, 0x04bc,
0x04c4, 0x04c9, 0x04ce, 0x04d3, 0x04d8, 0x04dd, 0x04e2, 0x04e7,
0x04ec, 0x04f1, 0x04f6, 0x04fb, 0x0500, 0x0505, 0x050a, 0x050f,
0x0514, 0x0519, 0x051e, 0x0523, 0x0528, 0x052d, 0x0532, 0x0537,
0x053c, 0x0541, 0x0546, 0x054b, 0x0550, 0x0555, 0x055a, 0x055f,
0x0564, 0x0569, 0x056e, 0x0573, 0x0578, 0x057a, 0x057c, 0x057e,
0x0580, 0x0582, 0x0584, 0x0586, 0x0588, 0x058a, 0x058c, 0x058e,
// Entry 180 - 1BF
0x0590, 0x0592, 0x0594, 0x0596, 0x059c, 0x05a2, 0x05a4, 0x05a6,
0x05a8, 0x05aa, 0x05ac, 0x05ae, 0x05b0, 0x05b2, 0x05b4, 0x05b6,
0x05b8, 0x05ba, 0x05bc, 0x05be, 0x05c0, 0x05c4, 0x05c8, 0x05cc,
0x05d0, 0x05d4, 0x05d8, 0x05dc, 0x05e0, 0x05e4, 0x05e9, 0x05ee,
0x05f3, 0x05f5, 0x05f7, 0x05fd, 0x0609, 0x0615, 0x0621, 0x062a,
0x0636, 0x063f, 0x0648, 0x0657, 0x0663, 0x066c, 0x0675, 0x067e,
0x068a, 0x0696, 0x069f, 0x06a8, 0x06ae, 0x06b7, 0x06c3, 0x06cf,
0x06d5, 0x06e4, 0x06f6, 0x0705, 0x070e, 0x071d, 0x072c, 0x0738,
// Entry 1C0 - 1FF
0x0741, 0x074a, 0x0753, 0x075f, 0x076e, 0x077a, 0x0783, 0x078c,
0x0795, 0x079b, 0x07a1, 0x07a7, 0x07ad, 0x07b6, 0x07bf, 0x07ce,
0x07d7, 0x07e3, 0x07f2, 0x07fb, 0x0801, 0x0807, 0x0816, 0x0822,
0x0831, 0x083a, 0x0849, 0x084f, 0x0858, 0x0861, 0x086a, 0x0873,
0x087c, 0x0888, 0x0891, 0x0897, 0x08a0, 0x08a9, 0x08b2, 0x08be,
0x08c7, 0x08d0, 0x08d9, 0x08e8, 0x08f4, 0x08fa, 0x0909, 0x090f,
0x091b, 0x0927, 0x0930, 0x0939, 0x0942, 0x094e, 0x0954, 0x095d,
0x0969, 0x096f, 0x097e, 0x0987, 0x098b, 0x098f, 0x0993, 0x0997,
// Entry 200 - 23F
0x099b, 0x099f, 0x09a3, 0x09a7, 0x09ab, 0x09af, 0x09b4, 0x09b9,
0x09be, 0x09c3, 0x09c8, 0x09cd, 0x09d2, 0x09d7, 0x09dc, 0x09e1,
0x09e6, 0x09eb, 0x09f0, 0x09f5, 0x09fa, 0x09fc, 0x09fe, 0x0a00,
0x0a02, 0x0a04, 0x0a06, 0x0a0c, 0x0a12, 0x0a18, 0x0a1e, 0x0a2a,
0x0a2c, 0x0a2e, 0x0a30, 0x0a32, 0x0a34, 0x0a36, 0x0a38, 0x0a3c,
0x0a3e, 0x0a40, 0x0a42, 0x0a44, 0x0a46, 0x0a48, 0x0a4a, 0x0a4c,
0x0a4e, 0x0a50, 0x0a52, 0x0a54, 0x0a56, 0x0a58, 0x0a5a, 0x0a5f,
0x0a65, 0x0a6c, 0x0a74, 0x0a76, 0x0a78, 0x0a7a, 0x0a7c, 0x0a7e,
// Entry 240 - 27F
0x0a80, 0x0a82, 0x0a84, 0x0a86, 0x0a88, 0x0a8a, 0x0a8c, 0x0a8e,
0x0a90, 0x0a96, 0x0a98, 0x0a9a, 0x0a9c, 0x0a9e, 0x0aa0, 0x0aa2,
0x0aa4, 0x0aa6, 0x0aa8, 0x0aaa, 0x0aac, 0x0aae, 0x0ab0, 0x0ab2,
0x0ab4, 0x0ab9, 0x0abe, 0x0ac2, 0x0ac6, 0x0aca, 0x0ace, 0x0ad2,
0x0ad6, 0x0ada, 0x0ade, 0x0ae2, 0x0ae7, 0x0aec, 0x0af1, 0x0af6,
0x0afb, 0x0b00, 0x0b05, 0x0b0a, 0x0b0f, 0x0b14, 0x0b19, 0x0b1e,
0x0b23, 0x0b28, 0x0b2d, 0x0b32, 0x0b37, 0x0b3c, 0x0b41, 0x0b46,
0x0b4b, 0x0b50, 0x0b52, 0x0b54, 0x0b56, 0x0b58, 0x0b5a, 0x0b5c,
// Entry 280 - 2BF
0x0b5e, 0x0b62, 0x0b66, 0x0b6a, 0x0b6e, 0x0b72, 0x0b76, 0x0b7a,
0x0b7c, 0x0b7e, 0x0b80, 0x0b82, 0x0b86, 0x0b8a, 0x0b8e, 0x0b92,
0x0b96, 0x0b9a, 0x0b9e, 0x0ba0, 0x0ba2, 0x0ba4, 0x0ba6, 0x0ba8,
0x0baa, 0x0bac, 0x0bb0, 0x0bb4, 0x0bba, 0x0bc0, 0x0bc4, 0x0bc8,
0x0bcc, 0x0bd0, 0x0bd4, 0x0bd8, 0x0bdc, 0x0be0, 0x0be4, 0x0be8,
0x0bec, 0x0bf0, 0x0bf4, 0x0bf8, 0x0bfc, 0x0c00, 0x0c04, 0x0c08,
0x0c0c, 0x0c10, 0x0c14, 0x0c18, 0x0c1c, 0x0c20, 0x0c24, 0x0c28,
0x0c2c, 0x0c30, 0x0c34, 0x0c36, 0x0c38, 0x0c3a, 0x0c3c, 0x0c3e,
// Entry 2C0 - 2FF
0x0c40, 0x0c42, 0x0c44, 0x0c46, 0x0c48, 0x0c4a, 0x0c4c, 0x0c4e,
0x0c50, 0x0c52, 0x0c54, 0x0c56, 0x0c58, 0x0c5a, 0x0c5c, 0x0c5e,
0x0c60, 0x0c62, 0x0c64, 0x0c66, 0x0c68, 0x0c6a, 0x0c6c, 0x0c6e,
0x0c70, 0x0c72, 0x0c74, 0x0c76, 0x0c78, 0x0c7a, 0x0c7c, 0x0c7e,
0x0c80, 0x0c82, 0x0c86, 0x0c8a, 0x0c8e, 0x0c92, 0x0c96, 0x0c9a,
0x0c9e, 0x0ca2, 0x0ca4, 0x0ca8, 0x0cac, 0x0cb0, 0x0cb4, 0x0cb8,
0x0cbc, 0x0cc0, 0x0cc4, 0x0cc8, 0x0ccc, 0x0cd0, 0x0cd4, 0x0cd8,
0x0cdc, 0x0ce0, 0x0ce4, 0x0ce8, 0x0cec, 0x0cf0, 0x0cf4, 0x0cf8,
// Entry 300 - 33F
0x0cfc, 0x0d00, 0x0d04, 0x0d08, 0x0d0c, 0x0d10, 0x0d14, 0x0d18,
0x0d1c, 0x0d20, 0x0d24, 0x0d28, 0x0d2c, 0x0d30, 0x0d34, 0x0d38,
0x0d3c, 0x0d40, 0x0d44, 0x0d48, 0x0d4c, 0x0d50, 0x0d54, 0x0d58,
0x0d5c, 0x0d60, 0x0d64, 0x0d68, 0x0d6c, 0x0d70, 0x0d74, 0x0d78,
0x0d7c, 0x0d80, 0x0d84, 0x0d88, 0x0d8c, 0x0d90, 0x0d94, 0x0d98,
0x0d9c, 0x0da0, 0x0da4, 0x0da8, 0x0dac, 0x0db0, 0x0db4, 0x0db8,
0x0dbc, 0x0dc0, 0x0dc4, 0x0dc8, 0x0dcc, 0x0dd0, 0x0dd4, 0x0dd8,
0x0ddc, 0x0de0, 0x0de4, 0x0de8, 0x0dec, 0x0df0, 0x0df4, 0x0df8,
// Entry 340 - 37F
0x0dfc, 0x0e00, 0x0e04, 0x0e08, 0x0e0c, 0x0e10, 0x0e14, 0x0e18,
0x0e1d, 0x0e22, 0x0e27, 0x0e2c, 0x0e31, 0x0e36, 0x0e3a, 0x0e3e,
0x0e42, 0x0e46, 0x0e4a, 0x0e4e, 0x0e52, 0x0e56, 0x0e5a, 0x0e5e,
0x0e62, 0x0e66, 0x0e6a, 0x0e6e, 0x0e72, 0x0e76, 0x0e7a, 0x0e7e,
0x0e82, 0x0e86, 0x0e8a, 0x0e8e, 0x0e92, 0x0e96, 0x0e9a, 0x0e9e,
0x0ea2, 0x0ea6, 0x0eaa, 0x0eae, 0x0eb2, 0x0eb6, 0x0ebc, 0x0ec2,
0x0ec8, 0x0ecc, 0x0ed0, 0x0ed4, 0x0ed8, 0x0edc, 0x0ee0, 0x0ee4,
0x0ee8, 0x0eec, 0x0ef0, 0x0ef4, 0x0ef8, 0x0efc, 0x0f00, 0x0f04,
// Entry 380 - 3BF
0x0f08, 0x0f0c, 0x0f10, 0x0f14, 0x0f18, 0x0f1c, 0x0f20, 0x0f24,
0x0f28, 0x0f2c, 0x0f30, 0x0f34, 0x0f38, 0x0f3e, 0x0f44, 0x0f4a,
0x0f50, 0x0f56, 0x0f5c, 0x0f62, 0x0f68, 0x0f6e, 0x0f74, 0x0f7a,
0x0f80, 0x0f86, 0x0f8c, 0x0f92, 0x0f98, 0x0f9e, 0x0fa4, 0x0faa,
0x0fb0, 0x0fb6, 0x0fbc, 0x0fc2, 0x0fc8, 0x0fce, 0x0fd4, 0x0fda,
0x0fe0, 0x0fe6, 0x0fec, 0x0ff2, 0x0ff8, 0x0ffe, 0x1004, 0x100a,
0x1010, 0x1016, 0x101c, 0x1022, 0x1028, 0x102e, 0x1034, 0x103a,
0x1040, 0x1046, 0x104c, 0x1052, 0x1058, 0x105e, 0x1064, 0x106a,
// Entry 3C0 - 3FF
0x1070, 0x1076, 0x107c, 0x1082, 0x1088, 0x108e, 0x1094, 0x109a,
0x10a0, 0x10a6, 0x10ac, 0x10b2, 0x10b8, 0x10be, 0x10c4, 0x10ca,
0x10d0, 0x10d6, 0x10dc, 0x10e2, 0x10e8, 0x10ee, 0x10f4, 0x10fa,
0x1100, 0x1106, 0x110c, 0x1112, 0x1118, 0x111e, 0x1124, 0x112a,
0x1130, 0x1136, 0x113c, 0x1142, 0x1148, 0x114e, 0x1154, 0x115a,
0x1160, 0x1166, 0x116c, 0x1172, 0x1178, 0x1180, 0x1188, 0x1190,
0x1198, 0x11a0, 0x11a8, 0x11b0, 0x11b6, 0x11d7, 0x11e6, 0x11ee,
0x11ef, 0x11f0, 0x11f1, 0x11f2, 0x11f3, 0x11f4, 0x11f5, 0x11f6,
// Entry 400 - 43F
0x11f7, 0x11f8, 0x11f9, 0x11fa, 0x11fb, 0x11fc, 0x11fd, 0x11fe,
0x11ff, 0x1200, 0x1201, 0x1205, 0x1209, 0x120d, 0x1211, 0x1215,
0x1219, 0x121b, 0x121d, 0x121f, 0x1221, 0x1223, 0x1225, 0x1227,
0x1229, 0x122b, 0x122d, 0x122f, 0x1231, 0x1233, 0x1235, 0x1237,
0x1239, 0x123b, 0x123d, 0x123f, 0x1241, 0x1243, 0x1245, 0x1247,
0x1249, 0x124b, 0x124d, 0x124f, 0x1251, 0x1253, 0x1255, 0x1257,
0x1259, 0x125b, 0x125d, 0x125f, 0x1263, 0x1267, 0x126b, 0x126f,
0x1270, 0x1271, 0x1272, 0x1273, 0x1274, 0x1275, 0x1277, 0x1279,
// Entry 440 - 47F
0x127b, 0x127d, 0x127f, 0x1281, 0x1283, 0x1285, 0x1287, 0x1289,
0x128c, 0x128e, 0x1290, 0x1292, 0x1294, 0x1297, 0x1299, 0x129b,
0x129d, 0x129f, 0x12a1, 0x12a3, 0x12a5, 0x12a7, 0x12a9, 0x12ab,
0x12ad, 0x12af, 0x12b2, 0x12b4, 0x12b6, 0x12b8, 0x12ba, 0x12bc,
0x12be, 0x12c0, 0x12c2, 0x12c4, 0x12c6, 0x12c9, 0x12cb, 0x12cd,
0x12d0, 0x12d2, 0x12d4, 0x12d6, 0x12d8, 0x12da, 0x12dc, 0x12de,
0x12e6, 0x12ee, 0x12fa, 0x1306, 0x1312, 0x131e, 0x132a, 0x1332,
0x133a, 0x1346, 0x1352, 0x135e, 0x136a, 0x136c, 0x136e, 0x1370,
// Entry 480 - 4BF
0x1372, 0x1374, 0x1376, 0x1378, 0x137a, 0x137c, 0x137e, 0x1380,
0x1382, 0x1384, 0x1386, 0x1388, 0x138a, 0x138d, 0x1390, 0x1392,
0x1394, 0x1396, 0x1398, 0x139a, 0x139c, 0x139e, 0x13a0, 0x13a2,
0x13a4, 0x13a6, 0x13a8, 0x13aa, 0x13ac, 0x13ae, 0x13b0, 0x13b2,
0x13b4, 0x13b6, 0x13b8, 0x13ba, 0x13bc, 0x13bf, 0x13c1, 0x13c3,
0x13c5, 0x13c7, 0x13c9, 0x13cb, 0x13cd, 0x13cf, 0x13d1, 0x13d3,
0x13d6, 0x13d8, 0x13da, 0x13dc, 0x13de, 0x13e0, 0x13e2, 0x13e4,
0x13e6, 0x13e8, 0x13ea, 0x13ec, 0x13ee, 0x13f0, 0x13f2, 0x13f5,
// Entry 4C0 - 4FF
0x13f8, 0x13fb, 0x13fe, 0x1401, 0x1404, 0x1407, 0x140a, 0x140d,
0x1410, 0x1413, 0x1416, 0x1419, 0x141c, 0x141f, 0x1422, 0x1425,
0x1428, 0x142b, 0x142e, 0x1431, 0x1434, 0x1437, 0x143a, 0x143d,
0x1440, 0x1447, 0x1449, 0x144b, 0x144d, 0x1450, 0x1452, 0x1454,
0x1456, 0x1458, 0x145a, 0x1460, 0x1466, 0x1469, 0x146c, 0x146f,
0x1472, 0x1475, 0x1478, 0x147b, 0x147e, 0x1481, 0x1484, 0x1487,
0x148a, 0x148d, 0x1490, 0x1493, 0x1496, 0x1499, 0x149c, 0x149f,
0x14a2, 0x14a5, 0x14a8, 0x14ab, 0x14ae, 0x14b1, 0x14b4, 0x14b7,
// Entry 500 - 53F
0x14ba, 0x14bd, 0x14c0, 0x14c3, 0x14c6, 0x14c9, 0x14cc, 0x14cf,
0x14d2, 0x14d5, 0x14d8, 0x14db, 0x14de, 0x14e1, 0x14e4, 0x14e7,
0x14ea, 0x14ed, 0x14f6, 0x14ff, 0x1508, 0x1511, 0x151a, 0x1523,
0x152c, 0x1535, 0x153e, 0x1541, 0x1544, 0x1547, 0x154a, 0x154d,
0x1550, 0x1553, 0x1556, 0x1559, 0x155c, 0x155f, 0x1562, 0x1565,
0x1568, 0x156b, 0x156e, 0x1571, 0x1574, 0x1577, 0x157a, 0x157d,
0x1580, 0x1583, 0x1586, 0x1589, 0x158c, 0x158f, 0x1592, 0x1595,
0x1598, 0x159b, 0x159e, 0x15a1, 0x15a4, 0x15a7, 0x15aa, 0x15ad,
// Entry 540 - 57F
0x15b0, 0x15b3, 0x15b6, 0x15b9, 0x15bc, 0x15bf, 0x15c2, 0x15c5,
0x15c8, 0x15cb, 0x15ce, 0x15d1, 0x15d4, 0x15d7, 0x15da, 0x15dd,
0x15e0, 0x15e3, 0x15e6, 0x15e9, 0x15ec, 0x15ef, 0x15f2, 0x15f5,
0x15f8, 0x15fb, 0x15fe, 0x1601, 0x1604, 0x1607, 0x160a, 0x160d,
0x1610, 0x1613, 0x1616, 0x1619, 0x161c, 0x161f, 0x1622, 0x1625,
0x1628, 0x162b, 0x162e, 0x1631, 0x1634, 0x1637, 0x163a, 0x163d,
0x1640, 0x1643, 0x1646, 0x1649, 0x164c, 0x164f, 0x1652, 0x1655,
0x1658, 0x165b, 0x165e, 0x1661, 0x1664, 0x1667, 0x166a, 0x166d,
// Entry 580 - 5BF
0x1670, 0x1673, 0x1676, 0x1679, 0x167c, 0x167f, 0x1682, 0x1685,
0x1688, 0x168b, 0x168e, 0x1691, 0x1694, 0x1697, 0x169a, 0x169d,
0x16a0, 0x16a3, 0x16a6, 0x16a9, 0x16ac, 0x16af, 0x16b2, 0x16b5,
0x16b8, 0x16bb, 0x16be, 0x16c1, 0x16c4, 0x16c7, 0x16ca, 0x16cd,
0x16d0, 0x16d3, 0x16d6, 0x16d9, 0x16dc, 0x16df, 0x16e2, 0x16e5,
0x16e8, 0x16eb, 0x16ee, 0x16f1, 0x16f4, 0x16f7, 0x16fa, 0x16fd,
0x1700, 0x1703, 0x1706, 0x1709, 0x170c, 0x170f, 0x1712, 0x1715,
0x1718, 0x171b, 0x171e, 0x1721, 0x1724, 0x1727, 0x172a, 0x172d,
// Entry 5C0 - 5FF
0x1730, 0x1733, 0x1736, 0x1739, 0x173c, 0x173f, 0x1742, 0x1745,
0x1748, 0x174b, 0x174e, 0x1751, 0x1754, 0x1757, 0x175a, 0x175d,
0x1760, 0x1763, 0x1766, 0x1769, 0x176c, 0x176f, 0x1772, 0x1775,
0x1778, 0x177b, 0x177e, 0x1781, 0x1784, 0x1787, 0x178a, 0x178d,
0x1790, 0x1793, 0x1796, 0x1799, 0x179c, 0x179f, 0x17a2, 0x17a5,
0x17a8, 0x17ab, 0x17ae, 0x17b1, 0x17b4, 0x17b7, 0x17ba, 0x17bd,
0x17c0, 0x17c3, 0x17c6, 0x17c9, 0x17cc, 0x17cf, 0x17d2, 0x17d5,
0x17d8, 0x17db, 0x17de, 0x17e1, 0x17e4, 0x17e7, 0x17ea, 0x17ed,
// Entry 600 - 63F
0x17f0, 0x17f3, 0x17f6, 0x17f9, 0x17fc, 0x17ff, 0x1802, 0x1805,
0x1808, 0x180b, 0x180e, 0x1811, 0x1814, 0x1817, 0x181a, 0x181d,
0x1820, 0x1823, 0x1826, 0x1829, 0x182c, 0x182f, 0x1832, 0x1835,
0x1838, 0x183b, 0x183e, 0x1841, 0x1844, 0x1847, 0x184a, 0x184d,
0x1850, 0x1853, 0x1856, 0x1859, 0x185c, 0x185f, 0x1862, 0x1865,
0x1868, 0x186b, 0x186e, 0x1871, 0x1874, 0x1877, 0x187a, 0x187d,
0x1880, 0x1883, 0x1886, 0x1889, 0x188c, 0x188f, 0x1892, 0x1895,
0x1898, 0x189b, 0x189e, 0x18a1, 0x18a4, 0x18a7, 0x18aa, 0x18ad,
// Entry 640 - 67F
0x18b0, 0x18b3, 0x18b6, 0x18b9, 0x18bc, 0x18bf, 0x18c2, 0x18c5,
0x18c8, 0x18cb, 0x18ce, 0x18d1, 0x18d4, 0x18d7, 0x18da, 0x18dd,
0x18e0, 0x18e3, 0x18e6, 0x18e9, 0x18ec, 0x18ef, 0x18f2, 0x18f5,
0x18f8, 0x18fb, 0x18fe, 0x1901, 0x1904, 0x1907, 0x190a, 0x190d,
0x1910, 0x1913, 0x1916, 0x1919, 0x191c, 0x191f, 0x1922, 0x1925,
0x1928, 0x192b, 0x192e, 0x1931, 0x1934, 0x1937, 0x193a, 0x193d,
0x1940, 0x1943, 0x1946, 0x1949, 0x194c, 0x194f, 0x1952, 0x1955,
0x1958, 0x195b, 0x195e, 0x1961, 0x1964, 0x1967, 0x196a, 0x196d,
// Entry 680 - 6BF
0x1970, 0x1973, 0x1976, 0x1979, 0x197c, 0x197f, 0x1982, 0x1985,
0x1988, 0x198b, 0x198e, 0x1991, 0x1994, 0x1997, 0x199a, 0x199d,
0x19a0, 0x19a3, 0x19a6, 0x19a9, 0x19ac, 0x19af, 0x19b2, 0x19b5,
0x19b8, 0x19bb, 0x19be, 0x19c1, 0x19c4, 0x19c7, 0x19ca, 0x19cd,
0x19d0, 0x19d3, 0x19d6, 0x19d9, 0x19dc, 0x19df, 0x19e2, 0x19e5,
0x19e8, 0x19eb, 0x19ee, 0x19f1, 0x19f4, 0x19f7, 0x19fa, 0x19fd,
0x1a00, 0x1a03, 0x1a06, 0x1a09, 0x1a0c, 0x1a0f, 0x1a12, 0x1a15,
0x1a18, 0x1a1b, 0x1a1e, 0x1a21, 0x1a24, 0x1a27, 0x1a2a, 0x1a2d,
// Entry 6C0 - 6FF
0x1a30,
} // Size: 3482 bytes
var xorData string = "" + // Size: 4907 bytes
"\x02\x0c\x09\x02\xb0\xec\x02\xad\xd8\x02\xad\xd9\x02\x06\x07\x02\x0f\x12" +
"\x02\x0f\x1f\x02\x0f\x1d\x02\x01\x13\x02\x0f\x16\x02\x0f\x0b\x02\x0f3" +
"\x02\x0f7\x02\x0f?\x02\x0f/\x02\x0f*\x02\x0c&\x02\x0c*\x02\x0c;\x02\x0c9" +
"\x02\x0c%\x02\xab\xed\x02\xab\xe2\x02\xab\xe3\x02\xa9\xe0\x02\xa9\xe1" +
"\x02\xa9\xe6\x02\xa3\xcb\x02\xa3\xc8\x02\xa3\xc9\x02\x01#\x02\x01\x08" +
"\x02\x0e>\x02\x0e'\x02\x0f\x03\x02\x03\x0d\x02\x03\x09\x02\x03\x17\x02" +
"\x03\x0e\x02\x02\x03\x02\x011\x02\x01\x00\x02\x01\x10\x02\x03<\x02\x07" +
"\x0d\x02\x02\x0c\x02\x0c0\x02\x01\x03\x02\x01\x01\x02\x01 \x02\x01\x22" +
"\x02\x01)\x02\x01\x0a\x02\x01\x0c\x02\x02\x06\x02\x02\x02\x02\x03\x10" +
"\x03\x037 \x03\x0b+\x03\x021\x00\x02\x01\x04\x02\x01\x02\x02\x019\x02" +
"\x03\x1c\x02\x02$\x03\x80p$\x02\x03:\x02\x03\x0a\x03\xc1r.\x03\xc1r,\x03" +
"\xc1r\x02\x02\x02:\x02\x02>\x02\x02,\x02\x02\x10\x02\x02\x00\x03\xc1s<" +
"\x03\xc1s*\x03\xc2L$\x03\xc2L;\x02\x09)\x02\x0a\x19\x03\x83\xab\xe3\x03" +
"\x83\xab\xf2\x03 4\xe0\x03\x81\xab\xea\x03\x81\xab\xf3\x03 4\xef\x03\x96" +
"\xe1\xcd\x03\x84\xe5\xc3\x02\x0d\x11\x03\x8b\xec\xcb\x03\x94\xec\xcf\x03" +
"\x9a\xec\xc2\x03\x8b\xec\xdb\x03\x94\xec\xdf\x03\x9a\xec\xd2\x03\x01\x0c" +
"!\x03\x01\x0c#\x03\x9d\x03\x9c\x03\x9f\x03\x9e\x03\x91\x03\x90\x03" +
"\x93\x03\x92\x03\x95\x03\xca\xf3\xb5\x03\xca\xf0\xb4\x03\xca\xf1\xb7" +
"\x03\xca\xf6\xb6\x03\xca\xf7\x89\x03\xca\xf4\x88\x03\xca\xf5\x8b\x03\xca" +
"\xfa\x8a\x03\xca\xfb\x8d\x03\xca\xf8\x8c\x03\xca\xf9\x8f\x03\xca\xfe\x8e" +
"\x03\xca\xff\x81\x03\xca\xfc\x80\x03\xca\xfd\x83\x03\xca\xe2\x82\x03\xca" +
"\xe3\x85\x03\xca\xe0\x84\x03\xca\xe1\x87\x03\xca\xe6\x86\x03\xca\xe7\x99" +
"\x03\xca\xe4\x98\x03\xca\xe5\x9b\x03\xca\xea\x9a\x03\xca\xeb\x9d\x03\xca" +
"\xe8\x9c\x03\x89\x03\x8b\x02\x010\x03\x03\x04\x1e\x03\x04\x15\x12\x03" +
"\x0b\x05,\x03\x06\x04\x00\x03\x06\x04)\x03\x06\x044\x03\x06\x04<\x03\x06" +
"\x05\x1d\x03\x06\x06\x00\x03\x06\x06\x0a\x03\x06\x06'\x03\x06\x062\x03" +
"\x0786\x03\x079/\x03\x079 \x03\x07:\x0e\x03\x07:\x1b\x03\x07:%\x03\x07;/" +
"\x03\x07;%\x03\x074\x11\x03\x076\x09\x03\x077*\x03\x070\x01\x03\x070\x0f" +
"\x03\x070.\x03\x071\x16\x03\x071\x04\x03\x0710\x03\x072\x18\x03\x072-" +
"\x03\x073\x14\x03\x073>\x03\x07'\x09\x03\x07 \x00\x03\x07\x1f\x0b\x03" +
"\x07\x18#\x03\x07\x18(\x03\x07\x186\x03\x07\x18\x03\x03\x07\x19\x16\x03" +
"\x07\x116\x03\x07\x12'\x03\x07\x13\x10\x03\x07\x0c&\x03\x07\x0c\x08\x03" +
"\x07\x0c\x13\x03\x07\x0d\x02\x03\x07\x0d\x1c\x03\x07\x0b5\x03\x07\x0b" +
"\x0a\x03\x07\x0b\x01\x03\x07\x0b\x0f\x03\x07\x05\x00\x03\x07\x05\x09\x03" +
"\x07\x05\x0b\x03\x07\x07\x01\x03\x07\x07\x08\x03\x07\x00<\x03\x07\x00+" +
"\x03\x07\x01)\x03\x07\x01\x1b\x03\x07\x01\x08\x03\x07\x03?\x03\x0445\x03" +
"\x044\x08\x03\x0454\x03\x04)/\x03\x04)5\x03\x04+\x05\x03\x04+\x14\x03" +
"\x04+ \x03\x04+<\x03\x04*&\x03\x04*\x22\x03\x04&8\x03\x04!\x01\x03\x04!" +
"\x22\x03\x04\x11+\x03\x04\x10.\x03\x04\x104\x03\x04\x13=\x03\x04\x12\x04" +
"\x03\x04\x12\x0a\x03\x04\x0d\x1d\x03\x04\x0d\x07\x03\x04\x0d \x03\x05<>" +
"\x03\x055<\x03\x055!\x03\x055#\x03\x055&\x03\x054\x1d\x03\x054\x02\x03" +
"\x054\x07\x03\x0571\x03\x053\x1a\x03\x053\x16\x03\x05.<\x03\x05.\x07\x03" +
"\x05):\x03\x05)<\x03\x05)\x0c\x03\x05)\x15\x03\x05+-\x03\x05+5\x03\x05$" +
"\x1e\x03\x05$\x14\x03\x05'\x04\x03\x05'\x14\x03\x05&\x02\x03\x05\x226" +
"\x03\x05\x22\x0c\x03\x05\x22\x1c\x03\x05\x19\x0a\x03\x05\x1b\x09\x03\x05" +
"\x1b\x0c\x03\x05\x14\x07\x03\x05\x16?\x03\x05\x16\x0c\x03\x05\x0c\x05" +
"\x03\x05\x0e\x0f\x03\x05\x01\x0e\x03\x05\x00(\x03\x05\x030\x03\x05\x03" +
"\x06\x03\x0a==\x03\x0a=1\x03\x0a=,\x03\x0a=\x0c\x03\x0a??\x03\x0a<\x08" +
"\x03\x0a9!\x03\x0a9)\x03\x0a97\x03\x0a99\x03\x0a6\x0a\x03\x0a6\x1c\x03" +
"\x0a6\x17\x03\x0a7'\x03\x0a78\x03\x0a73\x03\x0a'\x01\x03\x0a'&\x03\x0a" +
"\x1f\x0e\x03\x0a\x1f\x03\x03\x0a\x1f3\x03\x0a\x1b/\x03\x0a\x18\x19\x03" +
"\x0a\x19\x01\x03\x0a\x16\x14\x03\x0a\x0e\x22\x03\x0a\x0f\x10\x03\x0a\x0f" +
"\x02\x03\x0a\x0f \x03\x0a\x0c\x04\x03\x0a\x0b>\x03\x0a\x0b+\x03\x0a\x08/" +
"\x03\x0a\x046\x03\x0a\x05\x14\x03\x0a\x00\x04\x03\x0a\x00\x10\x03\x0a" +
"\x00\x14\x03\x0b<3\x03\x0b;*\x03\x0b9\x22\x03\x0b9)\x03\x0b97\x03\x0b+" +
"\x10\x03\x0b((\x03\x0b&5\x03\x0b$\x1c\x03\x0b$\x12\x03\x0b%\x04\x03\x0b#" +
"<\x03\x0b#0\x03\x0b#\x0d\x03\x0b#\x19\x03\x0b!:\x03\x0b!\x1f\x03\x0b!" +
"\x00\x03\x0b\x1e5\x03\x0b\x1c\x1d\x03\x0b\x1d-\x03\x0b\x1d(\x03\x0b\x18." +
"\x03\x0b\x18 \x03\x0b\x18\x16\x03\x0b\x14\x13\x03\x0b\x15$\x03\x0b\x15" +
"\x22\x03\x0b\x12\x1b\x03\x0b\x12\x10\x03\x0b\x132\x03\x0b\x13=\x03\x0b" +
"\x12\x18\x03\x0b\x0c&\x03\x0b\x061\x03\x0b\x06:\x03\x0b\x05#\x03\x0b\x05" +
"<\x03\x0b\x04\x0b\x03\x0b\x04\x04\x03\x0b\x04\x1b\x03\x0b\x042\x03\x0b" +
"\x041\x03\x0b\x03\x03\x03\x0b\x03\x1d\x03\x0b\x03/\x03\x0b\x03+\x03\x0b" +
"\x02\x1b\x03\x0b\x02\x00\x03\x0b\x01\x1e\x03\x0b\x01\x08\x03\x0b\x015" +
"\x03\x06\x0d9\x03\x06\x0d=\x03\x06\x0d?\x03\x02\x001\x03\x02\x003\x03" +
"\x02\x02\x19\x03\x02\x006\x03\x02\x02\x1b\x03\x02\x004\x03\x02\x00<\x03" +
"\x02\x02\x0a\x03\x02\x02\x0e\x03\x02\x01\x1a\x03\x02\x01\x07\x03\x02\x01" +
"\x05\x03\x02\x01\x0b\x03\x02\x01%\x03\x02\x01\x0c\x03\x02\x01\x04\x03" +
"\x02\x01\x1c\x03\x02\x00.\x03\x02\x002\x03\x02\x00>\x03\x02\x00\x12\x03" +
"\x02\x00\x16\x03\x02\x011\x03\x02\x013\x03\x02\x02 \x03\x02\x02%\x03\x02" +
"\x02$\x03\x02\x028\x03\x02\x02;\x03\x02\x024\x03\x02\x012\x03\x02\x022" +
"\x03\x02\x02/\x03\x02\x01,\x03\x02\x01\x13\x03\x02\x01\x16\x03\x02\x01" +
"\x11\x03\x02\x01\x1e\x03\x02\x01\x15\x03\x02\x01\x17\x03\x02\x01\x0f\x03" +
"\x02\x01\x08\x03\x02\x00?\x03\x02\x03\x07\x03\x02\x03\x0d\x03\x02\x03" +
"\x13\x03\x02\x03\x1d\x03\x02\x03\x1f\x03\x02\x00\x03\x03\x02\x00\x0d\x03" +
"\x02\x00\x01\x03\x02\x00\x1b\x03\x02\x00\x19\x03\x02\x00\x18\x03\x02\x00" +
"\x13\x03\x02\x00/\x03\x07>\x12\x03\x07<\x1f\x03\x07>\x1d\x03\x06\x1d\x0e" +
"\x03\x07>\x1c\x03\x07>:\x03\x07>\x13\x03\x04\x12+\x03\x07?\x03\x03\x07>" +
"\x02\x03\x06\x224\x03\x06\x1a.\x03\x07<%\x03\x06\x1c\x0b\x03\x0609\x03" +
"\x05\x1f\x01\x03\x04'\x08\x03\x93\xfd\xf5\x03\x02\x0d \x03\x02\x0d#\x03" +
"\x02\x0d!\x03\x02\x0d&\x03\x02\x0d\x22\x03\x02\x0d/\x03\x02\x0d,\x03\x02" +
"\x0d$\x03\x02\x0d'\x03\x02\x0d%\x03\x02\x0d;\x03\x02\x0d=\x03\x02\x0d?" +
"\x03\x099.\x03\x08\x0b7\x03\x08\x02\x14\x03\x08\x14\x0d\x03\x08.:\x03" +
"\x089'\x03\x0f\x0b\x18\x03\x0f\x1c1\x03\x0f\x17&\x03\x0f9\x1f\x03\x0f0" +
"\x0c\x03\x0e\x0a9\x03\x0e\x056\x03\x0e\x1c#\x03\x0f\x13\x0e\x03\x072\x00" +
"\x03\x070\x0d\x03\x072\x0b\x03\x06\x11\x18\x03\x070\x10\x03\x06\x0f(\x03" +
"\x072\x05\x03\x06\x0f,\x03\x073\x15\x03\x06\x07\x08\x03\x05\x16\x02\x03" +
"\x04\x0b \x03\x05:8\x03\x05\x16%\x03\x0a\x0d\x1f\x03\x06\x16\x10\x03\x05" +
"\x1d5\x03\x05*;\x03\x05\x16\x1b\x03\x04.-\x03\x06\x1a\x19\x03\x04\x03," +
"\x03\x0b87\x03\x04/\x0a\x03\x06\x00,\x03\x04-\x01\x03\x04\x1e-\x03\x06/(" +
"\x03\x0a\x0b5\x03\x06\x0e7\x03\x06\x07.\x03\x0597\x03\x0a*%\x03\x0760" +
"\x03\x06\x0c;\x03\x05'\x00\x03\x072.\x03\x072\x08\x03\x06=\x01\x03\x06" +
"\x05\x1b\x03\x06\x06\x12\x03\x06$=\x03\x06'\x0d\x03\x04\x11\x0f\x03\x076" +
",\x03\x06\x07;\x03\x06.,\x03\x86\xf9\xea\x03\x8f\xff\xeb\x02\x092\x02" +
"\x095\x02\x094\x02\x09;\x02\x09>\x02\x098\x02\x09*\x02\x09/\x02\x09,\x02" +
"\x09%\x02\x09&\x02\x09#\x02\x09 \x02\x08!\x02\x08%\x02\x08$\x02\x08+\x02" +
"\x08.\x02\x08*\x02\x08&\x02\x088\x02\x08>\x02\x084\x02\x086\x02\x080\x02" +
"\x08\x10\x02\x08\x17\x02\x08\x12\x02\x08\x1d\x02\x08\x1f\x02\x08\x13\x02" +
"\x08\x15\x02\x08\x14\x02\x08\x0c\x03\x8b\xfd\xd0\x03\x81\xec\xc6\x03\x87" +
"\xe0\x8a\x03-2\xe3\x03\x80\xef\xe4\x03-2\xea\x03\x88\xe6\xeb\x03\x8e\xe6" +
"\xe8\x03\x84\xe6\xe9\x03\x97\xe6\xee\x03-2\xf9\x03-2\xf6\x03\x8e\xe3\xad" +
"\x03\x80\xe3\x92\x03\x88\xe3\x90\x03\x8e\xe3\x90\x03\x80\xe3\x97\x03\x88" +
"\xe3\x95\x03\x88\xfe\xcb\x03\x8e\xfe\xca\x03\x84\xfe\xcd\x03\x91\xef\xc9" +
"\x03-2\xc1\x03-2\xc0\x03-2\xcb\x03\x88@\x09\x03\x8e@\x08\x03\x8f\xe0\xf5" +
"\x03\x8e\xe6\xf9\x03\x8e\xe0\xfa\x03\x93\xff\xf4\x03\x84\xee\xd3\x03\x0b" +
"(\x04\x023 \x03\x0b)\x08\x021;\x02\x01*\x03\x0b#\x10\x03\x0b 0\x03\x0b!" +
"\x10\x03\x0b!0\x03\x07\x15\x08\x03\x09?5\x03\x07\x1f\x08\x03\x07\x17\x0b" +
"\x03\x09\x1f\x15\x03\x0b\x1c7\x03\x0a+#\x03\x06\x1a\x1b\x03\x06\x1a\x14" +
"\x03\x0a\x01\x18\x03\x06#\x1b\x03\x0a2\x0c\x03\x0a\x01\x04\x03\x09#;\x03" +
"\x08='\x03\x08\x1a\x0a\x03\x07</\x03\x07:+\x03\x07\x07*\x03\x06&\x1c\x03" +
"\x09\x0c\x16\x03\x09\x10\x0e\x03\x08'\x0f\x03\x08+\x09\x03\x074%\x03\x06" +
"!3\x03\x06\x03+\x03\x0b\x1e\x19\x03\x0a))\x03\x09\x08\x19\x03\x08,\x05" +
"\x03\x07<2\x03\x06\x1c>\x03\x0a\x111\x03\x09\x1b\x09\x03\x073.\x03\x07" +
"\x01\x00\x03\x09/,\x03\x07#>\x03\x07\x048\x03\x0a\x1f\x22\x03\x098>\x03" +
"\x09\x11\x00\x03\x08/\x17\x03\x06'\x22\x03\x0b\x1a+\x03\x0a\x22\x19\x03" +
"\x0a/1\x03\x0974\x03\x09\x0f\x22\x03\x08,\x22\x03\x08?\x14\x03\x07$5\x03" +
"\x07<3\x03\x07=*\x03\x07\x13\x18\x03\x068\x0a\x03\x06\x09\x16\x03\x06" +
"\x13\x00\x03\x08\x067\x03\x08\x01\x03\x03\x08\x12\x1d\x03\x07+7\x03\x06(" +
";\x03\x06\x1c?\x03\x07\x0e\x17\x03\x0a\x06\x1d\x03\x0a\x19\x07\x03\x08" +
"\x14$\x03\x07$;\x03\x08,$\x03\x08\x06\x0d\x03\x07\x16\x0a\x03\x06>>\x03" +
"\x0a\x06\x12\x03\x0a\x14)\x03\x09\x0d\x1f\x03\x09\x12\x17\x03\x09\x19" +
"\x01\x03\x08\x11 \x03\x08\x1d'\x03\x06<\x1a\x03\x0a.\x00\x03\x07'\x18" +
"\x03\x0a\x22\x08\x03\x08\x0d\x0a\x03\x08\x13)\x03\x07*)\x03\x06<,\x03" +
"\x07\x0b\x1a\x03\x09.\x14\x03\x09\x0d\x1e\x03\x07\x0e#\x03\x0b\x1d'\x03" +
"\x0a\x0a8\x03\x09%2\x03\x08+&\x03\x080\x12\x03\x0a)4\x03\x08\x06\x1f\x03" +
"\x0b\x1b\x1a\x03\x0a\x1b\x0f\x03\x0b\x1d*\x03\x09\x16$\x03\x090\x11\x03" +
"\x08\x11\x08\x03\x0a*(\x03\x0a\x042\x03\x089,\x03\x074'\x03\x07\x0f\x05" +
"\x03\x09\x0b\x0a\x03\x07\x1b\x01\x03\x09\x17:\x03\x09.\x0d\x03\x07.\x11" +
"\x03\x09+\x15\x03\x080\x13\x03\x0b\x1f\x19\x03\x0a \x11\x03\x0a\x220\x03" +
"\x09\x07;\x03\x08\x16\x1c\x03\x07,\x13\x03\x07\x0e/\x03\x06\x221\x03\x0a" +
".\x0a\x03\x0a7\x02\x03\x0a\x032\x03\x0a\x1d.\x03\x091\x06\x03\x09\x19:" +
"\x03\x08\x02/\x03\x060+\x03\x06\x0f-\x03\x06\x1c\x1f\x03\x06\x1d\x07\x03" +
"\x0a,\x11\x03\x09=\x0d\x03\x09\x0b;\x03\x07\x1b/\x03\x0a\x1f:\x03\x09 " +
"\x1f\x03\x09.\x10\x03\x094\x0b\x03\x09\x1a1\x03\x08#\x1a\x03\x084\x1d" +
"\x03\x08\x01\x1f\x03\x08\x11\x22\x03\x07'8\x03\x07\x1a>\x03\x0757\x03" +
"\x06&9\x03\x06+\x11\x03\x0a.\x0b\x03\x0a,>\x03\x0a4#\x03\x08%\x17\x03" +
"\x07\x05\x22\x03\x07\x0c\x0b\x03\x0a\x1d+\x03\x0a\x19\x16\x03\x09+\x1f" +
"\x03\x09\x08\x0b\x03\x08\x16\x18\x03\x08+\x12\x03\x0b\x1d\x0c\x03\x0a=" +
"\x10\x03\x0a\x09\x0d\x03\x0a\x10\x11\x03\x09&0\x03\x08(\x1f\x03\x087\x07" +
"\x03\x08\x185\x03\x07'6\x03\x06.\x05\x03\x06=\x04\x03\x06;;\x03\x06\x06," +
"\x03\x0b\x18>\x03\x08\x00\x18\x03\x06 \x03\x03\x06<\x00\x03\x09%\x18\x03" +
"\x0b\x1c<\x03\x0a%!\x03\x0a\x09\x12\x03\x0a\x16\x02\x03\x090'\x03\x09" +
"\x0e=\x03\x08 \x0e\x03\x08>\x03\x03\x074>\x03\x06&?\x03\x06\x19\x09\x03" +
"\x06?(\x03\x0a-\x0e\x03\x09:3\x03\x098:\x03\x09\x12\x0b\x03\x09\x1d\x17" +
"\x03\x087\x05\x03\x082\x14\x03\x08\x06%\x03\x08\x13\x1f\x03\x06\x06\x0e" +
"\x03\x0a\x22<\x03\x09/<\x03\x06>+\x03\x0a'?\x03\x0a\x13\x0c\x03\x09\x10<" +
"\x03\x07\x1b=\x03\x0a\x19\x13\x03\x09\x22\x1d\x03\x09\x07\x0d\x03\x08)" +
"\x1c\x03\x06=\x1a\x03\x0a/4\x03\x0a7\x11\x03\x0a\x16:\x03\x09?3\x03\x09:" +
"/\x03\x09\x05\x0a\x03\x09\x14\x06\x03\x087\x22\x03\x080\x07\x03\x08\x1a" +
"\x1f\x03\x07\x04(\x03\x07\x04\x09\x03\x06 %\x03\x06<\x08\x03\x0a+\x14" +
"\x03\x09\x1d\x16\x03\x0a70\x03\x08 >\x03\x0857\x03\x070\x0a\x03\x06=\x12" +
"\x03\x06\x16%\x03\x06\x1d,\x03\x099#\x03\x09\x10>\x03\x07 \x1e\x03\x08" +
"\x0c<\x03\x08\x0b\x18\x03\x08\x15+\x03\x08,:\x03\x08%\x22\x03\x07\x0a$" +
"\x03\x0b\x1c=\x03\x07+\x08\x03\x0a/\x05\x03\x0a \x07\x03\x0a\x12'\x03" +
"\x09#\x11\x03\x08\x1b\x15\x03\x0a\x06\x01\x03\x09\x1c\x1b\x03\x0922\x03" +
"\x07\x14<\x03\x07\x09\x04\x03\x061\x04\x03\x07\x0e\x01\x03\x0a\x13\x18" +
"\x03\x0a-\x0c\x03\x0a?\x0d\x03\x0a\x09\x0a\x03\x091&\x03\x0a/\x0b\x03" +
"\x08$<\x03\x083\x1d\x03\x08\x0c$\x03\x08\x0d\x07\x03\x08\x0d?\x03\x08" +
"\x0e\x14\x03\x065\x0a\x03\x08\x1a#\x03\x08\x16#\x03\x0702\x03\x07\x03" +
"\x1a\x03\x06(\x1d\x03\x06+\x1b\x03\x06\x0b\x05\x03\x06\x0b\x17\x03\x06" +
"\x0c\x04\x03\x06\x1e\x19\x03\x06+0\x03\x062\x18\x03\x0b\x16\x1e\x03\x0a+" +
"\x16\x03\x0a-?\x03\x0a#:\x03\x0a#\x10\x03\x0a%$\x03\x0a>+\x03\x0a01\x03" +
"\x0a1\x10\x03\x0a\x099\x03\x0a\x0a\x12\x03\x0a\x19\x1f\x03\x0a\x19\x12" +
"\x03\x09*)\x03\x09-\x16\x03\x09.1\x03\x09.2\x03\x09<\x0e\x03\x09> \x03" +
"\x093\x12\x03\x09\x0b\x01\x03\x09\x1c2\x03\x09\x11\x1c\x03\x09\x15%\x03" +
"\x08,&\x03\x08!\x22\x03\x089(\x03\x08\x0b\x1a\x03\x08\x0d2\x03\x08\x0c" +
"\x04\x03\x08\x0c\x06\x03\x08\x0c\x1f\x03\x08\x0c\x0c\x03\x08\x0f\x1f\x03" +
"\x08\x0f\x1d\x03\x08\x00\x14\x03\x08\x03\x14\x03\x08\x06\x16\x03\x08\x1e" +
"#\x03\x08\x11\x11\x03\x08\x10\x18\x03\x08\x14(\x03\x07)\x1e\x03\x07.1" +
"\x03\x07 $\x03\x07 '\x03\x078\x08\x03\x07\x0d0\x03\x07\x0f7\x03\x07\x05#" +
"\x03\x07\x05\x1a\x03\x07\x1a7\x03\x07\x1d-\x03\x07\x17\x10\x03\x06)\x1f" +
"\x03\x062\x0b\x03\x066\x16\x03\x06\x09\x11\x03\x09(\x1e\x03\x07!5\x03" +
"\x0b\x11\x16\x03\x0a/\x04\x03\x0a,\x1a\x03\x0b\x173\x03\x0a,1\x03\x0a/5" +
"\x03\x0a\x221\x03\x0a\x22\x0d\x03\x0a?%\x03\x0a<,\x03\x0a?#\x03\x0a>\x19" +
"\x03\x0a\x08&\x03\x0a\x0b\x0e\x03\x0a\x0c:\x03\x0a\x0c+\x03\x0a\x03\x22" +
"\x03\x0a\x06)\x03\x0a\x11\x10\x03\x0a\x11\x1a\x03\x0a\x17-\x03\x0a\x14(" +
"\x03\x09)\x1e\x03\x09/\x09\x03\x09.\x00\x03\x09,\x07\x03\x09/*\x03\x09-9" +
"\x03\x09\x228\x03\x09%\x09\x03\x09:\x12\x03\x09;\x1d\x03\x09?\x06\x03" +
"\x093%\x03\x096\x05\x03\x096\x08\x03\x097\x02\x03\x09\x07,\x03\x09\x04," +
"\x03\x09\x1f\x16\x03\x09\x11\x03\x03\x09\x11\x12\x03\x09\x168\x03\x08*" +
"\x05\x03\x08/2\x03\x084:\x03\x08\x22+\x03\x08 0\x03\x08&\x0a\x03\x08;" +
"\x10\x03\x08>$\x03\x08>\x18\x03\x0829\x03\x082:\x03\x081,\x03\x081<\x03" +
"\x081\x1c\x03\x087#\x03\x087*\x03\x08\x09'\x03\x08\x00\x1d\x03\x08\x05-" +
"\x03\x08\x1f4\x03\x08\x1d\x04\x03\x08\x16\x0f\x03\x07*7\x03\x07'!\x03" +
"\x07%\x1b\x03\x077\x0c\x03\x07\x0c1\x03\x07\x0c.\x03\x07\x00\x06\x03\x07" +
"\x01\x02\x03\x07\x010\x03\x07\x06=\x03\x07\x01\x03\x03\x07\x01\x13\x03" +
"\x07\x06\x06\x03\x07\x05\x0a\x03\x07\x1f\x09\x03\x07\x17:\x03\x06*1\x03" +
"\x06-\x1d\x03\x06\x223\x03\x062:\x03\x060$\x03\x066\x1e\x03\x064\x12\x03" +
"\x0645\x03\x06\x0b\x00\x03\x06\x0b7\x03\x06\x07\x1f\x03\x06\x15\x12\x03" +
"\x0c\x05\x0f\x03\x0b+\x0b\x03\x0b+-\x03\x06\x16\x1b\x03\x06\x15\x17\x03" +
"\x89\xca\xea\x03\x89\xca\xe8\x03\x0c8\x10\x03\x0c8\x01\x03\x0c8\x0f\x03" +
"\x0d8%\x03\x0d8!\x03\x0c8-\x03\x0c8/\x03\x0c8+\x03\x0c87\x03\x0c85\x03" +
"\x0c9\x09\x03\x0c9\x0d\x03\x0c9\x0f\x03\x0c9\x0b\x03\xcfu\x0c\x03\xcfu" +
"\x0f\x03\xcfu\x0e\x03\xcfu\x09\x03\x0c9\x10\x03\x0d9\x0c\x03\xcf`;\x03" +
"\xcf`>\x03\xcf`9\x03\xcf`8\x03\xcf`7\x03\xcf`*\x03\xcf`-\x03\xcf`,\x03" +
"\x0d\x1b\x1a\x03\x0d\x1b&\x03\x0c=.\x03\x0c=%\x03\x0c>\x1e\x03\x0c>\x14" +
"\x03\x0c?\x06\x03\x0c?\x0b\x03\x0c?\x0c\x03\x0c?\x0d\x03\x0c?\x02\x03" +
"\x0c>\x0f\x03\x0c>\x08\x03\x0c>\x09\x03\x0c>,\x03\x0c>\x0c\x03\x0c?\x13" +
"\x03\x0c?\x16\x03\x0c?\x15\x03\x0c?\x1c\x03\x0c?\x1f\x03\x0c?\x1d\x03" +
"\x0c?\x1a\x03\x0c?\x17\x03\x0c?\x08\x03\x0c?\x09\x03\x0c?\x0e\x03\x0c?" +
"\x04\x03\x0c?\x05\x03\x0c<?\x03\x0c=\x00\x03\x0c=\x06\x03\x0c=\x05\x03" +
"\x0c=\x0c\x03\x0c=\x0f\x03\x0c=\x0d\x03\x0c=\x0b\x03\x0c=\x07\x03\x0c=" +
"\x19\x03\x0c=\x15\x03\x0c=\x11\x03\x0c=1\x03\x0c=3\x03\x0c=0\x03\x0c=>" +
"\x03\x0c=2\x03\x0c=6\x03\x0c<\x07\x03\x0c<\x05\x03\x0e:!\x03\x0e:#\x03" +
"\x0e8\x09\x03\x0e:&\x03\x0e8\x0b\x03\x0e:$\x03\x0e:,\x03\x0e8\x1a\x03" +
"\x0e8\x1e\x03\x0e:*\x03\x0e:7\x03\x0e:5\x03\x0e:;\x03\x0e:\x15\x03\x0e:<" +
"\x03\x0e:4\x03\x0e:'\x03\x0e:-\x03\x0e:%\x03\x0e:?\x03\x0e:=\x03\x0e:)" +
"\x03\x0e:/\x03\xcfs'\x03\x0d=\x0f\x03\x0d+*\x03\x0d99\x03\x0d9;\x03\x0d9" +
"?\x03\x0d)\x0d\x03\x0d(%\x02\x01\x18\x02\x01(\x02\x03'\x02\x03)\x02\x03+" +
"\x02\x03/\x02\x03\x19\x02\x03\x1b\x02\x03\x1f\x03\x0d\x22\x18\x03\x0d" +
"\x22\x1a\x03\x0d\x22'\x03\x0d\x22/\x03\x0d\x223\x03\x0d\x22$\x02\x01\x1e" +
"\x03\x0f$!\x03\x0f87\x03\x0f4\x0e\x03\x0f5\x1d\x03\x06'\x03\x03\x0f\x08" +
"\x18\x03\x0f\x0d\x1b\x03\x0e2=\x03\x0e;\x08\x03\x0e:\x0b\x03\x0e\x06$" +
"\x03\x0e\x0d)\x03\x0e\x16\x1f\x03\x0e\x16\x1b\x03\x0d$\x0a\x03\x05,\x1d" +
"\x03\x0d. \x03\x0d.#\x03\x0c(/\x03\x09%\x02\x03\x0d90\x03\x0d\x0e4\x03" +
"\x0d\x0d\x0f\x03\x0c#\x00\x03\x0c,\x1e\x03\x0c2\x0e\x03\x0c\x01\x17\x03" +
"\x0c\x09:\x03\x0e\x173\x03\x0c\x08\x03\x03\x0c\x11\x07\x03\x0c\x10\x18" +
"\x03\x0c\x1f\x1c\x03\x0c\x19\x0e\x03\x0c\x1a\x1f\x03\x0f0>\x03\x0b->\x03" +
"\x0b<+\x03\x0b8\x13\x03\x0b\x043\x03\x0b\x14\x03\x03\x0b\x16%\x03\x0d" +
"\x22&\x03\x0b\x1a\x1a\x03\x0b\x1a\x04\x03\x0a%9\x03\x0a&2\x03\x0a&0\x03" +
"\x0a!\x1a\x03\x0a!7\x03\x0a5\x10\x03\x0a=4\x03\x0a?\x0e\x03\x0a>\x10\x03" +
"\x0a\x00 \x03\x0a\x0f:\x03\x0a\x0f9\x03\x0a\x0b\x0a\x03\x0a\x17%\x03\x0a" +
"\x1b-\x03\x09-\x1a\x03\x09,4\x03\x09.,\x03\x09)\x09\x03\x096!\x03\x091" +
"\x1f\x03\x093\x16\x03\x0c+\x1f\x03\x098 \x03\x098=\x03\x0c(\x1a\x03\x0c(" +
"\x16\x03\x09\x0a+\x03\x09\x16\x12\x03\x09\x13\x0e\x03\x09\x153\x03\x08)!" +
"\x03\x09\x1a\x01\x03\x09\x18\x01\x03\x08%#\x03\x08>\x22\x03\x08\x05%\x03" +
"\x08\x02*\x03\x08\x15;\x03\x08\x1b7\x03\x0f\x07\x1d\x03\x0f\x04\x03\x03" +
"\x070\x0c\x03\x07;\x0b\x03\x07\x08\x17\x03\x07\x12\x06\x03\x06/-\x03\x06" +
"71\x03\x065+\x03\x06>7\x03\x06\x049\x03\x05+\x1e\x03\x05,\x17\x03\x05 " +
"\x1d\x03\x05\x22\x05\x03\x050\x1d"
// lookup returns the trie value for the first UTF-8 encoding in s and
// the width in bytes of this encoding. The size will be 0 if s does not
// hold enough bytes to complete the encoding. len(s) must be greater than 0.
func (t *idnaTrie) lookup(s []byte) (v uint16, sz int) {
c0 := s[0]
switch {
case c0 < 0x80: // is ASCII
return idnaValues[c0], 1
case c0 < 0xC2:
return 0, 1 // Illegal UTF-8: not a starter, not ASCII.
case c0 < 0xE0: // 2-byte UTF-8
if len(s) < 2 {
return 0, 0
}
i := idnaIndex[c0]
c1 := s[1]
if c1 < 0x80 || 0xC0 <= c1 {
return 0, 1 // Illegal UTF-8: not a continuation byte.
}
return t.lookupValue(uint32(i), c1), 2
case c0 < 0xF0: // 3-byte UTF-8
if len(s) < 3 {
return 0, 0
}
i := idnaIndex[c0]
c1 := s[1]
if c1 < 0x80 || 0xC0 <= c1 {
return 0, 1 // Illegal UTF-8: not a continuation byte.
}
o := uint32(i)<<6 + uint32(c1)
i = idnaIndex[o]
c2 := s[2]
if c2 < 0x80 || 0xC0 <= c2 {
return 0, 2 // Illegal UTF-8: not a continuation byte.
}
return t.lookupValue(uint32(i), c2), 3
case c0 < 0xF8: // 4-byte UTF-8
if len(s) < 4 {
return 0, 0
}
i := idnaIndex[c0]
c1 := s[1]
if c1 < 0x80 || 0xC0 <= c1 {
return 0, 1 // Illegal UTF-8: not a continuation byte.
}
o := uint32(i)<<6 + uint32(c1)
i = idnaIndex[o]
c2 := s[2]
if c2 < 0x80 || 0xC0 <= c2 {
return 0, 2 // Illegal UTF-8: not a continuation byte.
}
o = uint32(i)<<6 + uint32(c2)
i = idnaIndex[o]
c3 := s[3]
if c3 < 0x80 || 0xC0 <= c3 {
return 0, 3 // Illegal UTF-8: not a continuation byte.
}
return t.lookupValue(uint32(i), c3), 4
}
// Illegal rune
return 0, 1
}
// lookupUnsafe returns the trie value for the first UTF-8 encoding in s.
// s must start with a full and valid UTF-8 encoded rune.
func (t *idnaTrie) lookupUnsafe(s []byte) uint16 {
c0 := s[0]
if c0 < 0x80 { // is ASCII
return idnaValues[c0]
}
i := idnaIndex[c0]
if c0 < 0xE0 { // 2-byte UTF-8
return t.lookupValue(uint32(i), s[1])
}
i = idnaIndex[uint32(i)<<6+uint32(s[1])]
if c0 < 0xF0 { // 3-byte UTF-8
return t.lookupValue(uint32(i), s[2])
}
i = idnaIndex[uint32(i)<<6+uint32(s[2])]
if c0 < 0xF8 { // 4-byte UTF-8
return t.lookupValue(uint32(i), s[3])
}
return 0
}
// lookupString returns the trie value for the first UTF-8 encoding in s and
// the width in bytes of this encoding. The size will be 0 if s does not
// hold enough bytes to complete the encoding. len(s) must be greater than 0.
func (t *idnaTrie) lookupString(s string) (v uint16, sz int) {
c0 := s[0]
switch {
case c0 < 0x80: // is ASCII
return idnaValues[c0], 1
case c0 < 0xC2:
return 0, 1 // Illegal UTF-8: not a starter, not ASCII.
case c0 < 0xE0: // 2-byte UTF-8
if len(s) < 2 {
return 0, 0
}
i := idnaIndex[c0]
c1 := s[1]
if c1 < 0x80 || 0xC0 <= c1 {
return 0, 1 // Illegal UTF-8: not a continuation byte.
}
return t.lookupValue(uint32(i), c1), 2
case c0 < 0xF0: // 3-byte UTF-8
if len(s) < 3 {
return 0, 0
}
i := idnaIndex[c0]
c1 := s[1]
if c1 < 0x80 || 0xC0 <= c1 {
return 0, 1 // Illegal UTF-8: not a continuation byte.
}
o := uint32(i)<<6 + uint32(c1)
i = idnaIndex[o]
c2 := s[2]
if c2 < 0x80 || 0xC0 <= c2 {
return 0, 2 // Illegal UTF-8: not a continuation byte.
}
return t.lookupValue(uint32(i), c2), 3
case c0 < 0xF8: // 4-byte UTF-8
if len(s) < 4 {
return 0, 0
}
i := idnaIndex[c0]
c1 := s[1]
if c1 < 0x80 || 0xC0 <= c1 {
return 0, 1 // Illegal UTF-8: not a continuation byte.
}
o := uint32(i)<<6 + uint32(c1)
i = idnaIndex[o]
c2 := s[2]
if c2 < 0x80 || 0xC0 <= c2 {
return 0, 2 // Illegal UTF-8: not a continuation byte.
}
o = uint32(i)<<6 + uint32(c2)
i = idnaIndex[o]
c3 := s[3]
if c3 < 0x80 || 0xC0 <= c3 {
return 0, 3 // Illegal UTF-8: not a continuation byte.
}
return t.lookupValue(uint32(i), c3), 4
}
// Illegal rune
return 0, 1
}
// lookupStringUnsafe returns the trie value for the first UTF-8 encoding in s.
// s must start with a full and valid UTF-8 encoded rune.
func (t *idnaTrie) lookupStringUnsafe(s string) uint16 {
c0 := s[0]
if c0 < 0x80 { // is ASCII
return idnaValues[c0]
}
i := idnaIndex[c0]
if c0 < 0xE0 { // 2-byte UTF-8
return t.lookupValue(uint32(i), s[1])
}
i = idnaIndex[uint32(i)<<6+uint32(s[1])]
if c0 < 0xF0 { // 3-byte UTF-8
return t.lookupValue(uint32(i), s[2])
}
i = idnaIndex[uint32(i)<<6+uint32(s[2])]
if c0 < 0xF8 { // 4-byte UTF-8
return t.lookupValue(uint32(i), s[3])
}
return 0
}
// idnaTrie. Total size: 31598 bytes (30.86 KiB). Checksum: d3118eda0d6b5360.
type idnaTrie struct{}
func newIdnaTrie(i int) *idnaTrie {
return &idnaTrie{}
}
// lookupValue determines the type of block n and looks up the value for b.
func (t *idnaTrie) lookupValue(n uint32, b byte) uint16 {
switch {
case n < 133:
return uint16(idnaValues[n<<6+uint32(b)])
default:
n -= 133
return uint16(idnaSparse.lookup(n, b))
}
}
// idnaValues: 135 blocks, 8640 entries, 17280 bytes
// The third block is the zero block.
var idnaValues = [8640]uint16{
// Block 0x0, offset 0x0
0x00: 0x0080, 0x01: 0x0080, 0x02: 0x0080, 0x03: 0x0080, 0x04: 0x0080, 0x05: 0x0080,
0x06: 0x0080, 0x07: 0x0080, 0x08: 0x0080, 0x09: 0x0080, 0x0a: 0x0080, 0x0b: 0x0080,
0x0c: 0x0080, 0x0d: 0x0080, 0x0e: 0x0080, 0x0f: 0x0080, 0x10: 0x0080, 0x11: 0x0080,
0x12: 0x0080, 0x13: 0x0080, 0x14: 0x0080, 0x15: 0x0080, 0x16: 0x0080, 0x17: 0x0080,
0x18: 0x0080, 0x19: 0x0080, 0x1a: 0x0080, 0x1b: 0x0080, 0x1c: 0x0080, 0x1d: 0x0080,
0x1e: 0x0080, 0x1f: 0x0080, 0x20: 0x0080, 0x21: 0x0080, 0x22: 0x0080, 0x23: 0x0080,
0x24: 0x0080, 0x25: 0x0080, 0x26: 0x0080, 0x27: 0x0080, 0x28: 0x0080, 0x29: 0x0080,
0x2a: 0x0080, 0x2b: 0x0080, 0x2c: 0x0080, 0x2d: 0x0008, 0x2e: 0x0008, 0x2f: 0x0080,
0x30: 0x0008, 0x31: 0x0008, 0x32: 0x0008, 0x33: 0x0008, 0x34: 0x0008, 0x35: 0x0008,
0x36: 0x0008, 0x37: 0x0008, 0x38: 0x0008, 0x39: 0x0008, 0x3a: 0x0080, 0x3b: 0x0080,
0x3c: 0x0080, 0x3d: 0x0080, 0x3e: 0x0080, 0x3f: 0x0080,
// Block 0x1, offset 0x40
0x40: 0x0080, 0x41: 0xe105, 0x42: 0xe105, 0x43: 0xe105, 0x44: 0xe105, 0x45: 0xe105,
0x46: 0xe105, 0x47: 0xe105, 0x48: 0xe105, 0x49: 0xe105, 0x4a: 0xe105, 0x4b: 0xe105,
0x4c: 0xe105, 0x4d: 0xe105, 0x4e: 0xe105, 0x4f: 0xe105, 0x50: 0xe105, 0x51: 0xe105,
0x52: 0xe105, 0x53: 0xe105, 0x54: 0xe105, 0x55: 0xe105, 0x56: 0xe105, 0x57: 0xe105,
0x58: 0xe105, 0x59: 0xe105, 0x5a: 0xe105, 0x5b: 0x0080, 0x5c: 0x0080, 0x5d: 0x0080,
0x5e: 0x0080, 0x5f: 0x0080, 0x60: 0x0080, 0x61: 0x0008, 0x62: 0x0008, 0x63: 0x0008,
0x64: 0x0008, 0x65: 0x0008, 0x66: 0x0008, 0x67: 0x0008, 0x68: 0x0008, 0x69: 0x0008,
0x6a: 0x0008, 0x6b: 0x0008, 0x6c: 0x0008, 0x6d: 0x0008, 0x6e: 0x0008, 0x6f: 0x0008,
0x70: 0x0008, 0x71: 0x0008, 0x72: 0x0008, 0x73: 0x0008, 0x74: 0x0008, 0x75: 0x0008,
0x76: 0x0008, 0x77: 0x0008, 0x78: 0x0008, 0x79: 0x0008, 0x7a: 0x0008, 0x7b: 0x0080,
0x7c: 0x0080, 0x7d: 0x0080, 0x7e: 0x0080, 0x7f: 0x0080,
// Block 0x2, offset 0x80
// Block 0x3, offset 0xc0
0xc0: 0x0040, 0xc1: 0x0040, 0xc2: 0x0040, 0xc3: 0x0040, 0xc4: 0x0040, 0xc5: 0x0040,
0xc6: 0x0040, 0xc7: 0x0040, 0xc8: 0x0040, 0xc9: 0x0040, 0xca: 0x0040, 0xcb: 0x0040,
0xcc: 0x0040, 0xcd: 0x0040, 0xce: 0x0040, 0xcf: 0x0040, 0xd0: 0x0040, 0xd1: 0x0040,
0xd2: 0x0040, 0xd3: 0x0040, 0xd4: 0x0040, 0xd5: 0x0040, 0xd6: 0x0040, 0xd7: 0x0040,
0xd8: 0x0040, 0xd9: 0x0040, 0xda: 0x0040, 0xdb: 0x0040, 0xdc: 0x0040, 0xdd: 0x0040,
0xde: 0x0040, 0xdf: 0x0040, 0xe0: 0x000a, 0xe1: 0x0018, 0xe2: 0x0018, 0xe3: 0x0018,
0xe4: 0x0018, 0xe5: 0x0018, 0xe6: 0x0018, 0xe7: 0x0018, 0xe8: 0x0012, 0xe9: 0x0018,
0xea: 0x0019, 0xeb: 0x0018, 0xec: 0x0018, 0xed: 0x03c0, 0xee: 0x0018, 0xef: 0x0022,
0xf0: 0x0018, 0xf1: 0x0018, 0xf2: 0x0029, 0xf3: 0x0031, 0xf4: 0x003a, 0xf5: 0x0005,
0xf6: 0x0018, 0xf7: 0x0008, 0xf8: 0x0042, 0xf9: 0x0049, 0xfa: 0x0051, 0xfb: 0x0018,
0xfc: 0x0059, 0xfd: 0x0061, 0xfe: 0x0069, 0xff: 0x0018,
// Block 0x4, offset 0x100
0x100: 0xe00d, 0x101: 0x0008, 0x102: 0xe00d, 0x103: 0x0008, 0x104: 0xe00d, 0x105: 0x0008,
0x106: 0xe00d, 0x107: 0x0008, 0x108: 0xe00d, 0x109: 0x0008, 0x10a: 0xe00d, 0x10b: 0x0008,
0x10c: 0xe00d, 0x10d: 0x0008, 0x10e: 0xe00d, 0x10f: 0x0008, 0x110: 0xe00d, 0x111: 0x0008,
0x112: 0xe00d, 0x113: 0x0008, 0x114: 0xe00d, 0x115: 0x0008, 0x116: 0xe00d, 0x117: 0x0008,
0x118: 0xe00d, 0x119: 0x0008, 0x11a: 0xe00d, 0x11b: 0x0008, 0x11c: 0xe00d, 0x11d: 0x0008,
0x11e: 0xe00d, 0x11f: 0x0008, 0x120: 0xe00d, 0x121: 0x0008, 0x122: 0xe00d, 0x123: 0x0008,
0x124: 0xe00d, 0x125: 0x0008, 0x126: 0xe00d, 0x127: 0x0008, 0x128: 0xe00d, 0x129: 0x0008,
0x12a: 0xe00d, 0x12b: 0x0008, 0x12c: 0xe00d, 0x12d: 0x0008, 0x12e: 0xe00d, 0x12f: 0x0008,
0x130: 0x0071, 0x131: 0x0008, 0x132: 0x0035, 0x133: 0x004d, 0x134: 0xe00d, 0x135: 0x0008,
0x136: 0xe00d, 0x137: 0x0008, 0x138: 0x0008, 0x139: 0xe01d, 0x13a: 0x0008, 0x13b: 0xe03d,
0x13c: 0x0008, 0x13d: 0xe01d, 0x13e: 0x0008, 0x13f: 0x0079,
// Block 0x5, offset 0x140
0x140: 0x0079, 0x141: 0xe01d, 0x142: 0x0008, 0x143: 0xe03d, 0x144: 0x0008, 0x145: 0xe01d,
0x146: 0x0008, 0x147: 0xe07d, 0x148: 0x0008, 0x149: 0x0081, 0x14a: 0xe00d, 0x14b: 0x0008,
0x14c: 0xe00d, 0x14d: 0x0008, 0x14e: 0xe00d, 0x14f: 0x0008, 0x150: 0xe00d, 0x151: 0x0008,
0x152: 0xe00d, 0x153: 0x0008, 0x154: 0xe00d, 0x155: 0x0008, 0x156: 0xe00d, 0x157: 0x0008,
0x158: 0xe00d, 0x159: 0x0008, 0x15a: 0xe00d, 0x15b: 0x0008, 0x15c: 0xe00d, 0x15d: 0x0008,
0x15e: 0xe00d, 0x15f: 0x0008, 0x160: 0xe00d, 0x161: 0x0008, 0x162: 0xe00d, 0x163: 0x0008,
0x164: 0xe00d, 0x165: 0x0008, 0x166: 0xe00d, 0x167: 0x0008, 0x168: 0xe00d, 0x169: 0x0008,
0x16a: 0xe00d, 0x16b: 0x0008, 0x16c: 0xe00d, 0x16d: 0x0008, 0x16e: 0xe00d, 0x16f: 0x0008,
0x170: 0xe00d, 0x171: 0x0008, 0x172: 0xe00d, 0x173: 0x0008, 0x174: 0xe00d, 0x175: 0x0008,
0x176: 0xe00d, 0x177: 0x0008, 0x178: 0x0065, 0x179: 0xe01d, 0x17a: 0x0008, 0x17b: 0xe03d,
0x17c: 0x0008, 0x17d: 0xe01d, 0x17e: 0x0008, 0x17f: 0x0089,
// Block 0x6, offset 0x180
0x180: 0x0008, 0x181: 0x007d, 0x182: 0xe00d, 0x183: 0x0008, 0x184: 0xe00d, 0x185: 0x0008,
0x186: 0x007d, 0x187: 0xe07d, 0x188: 0x0008, 0x189: 0x0095, 0x18a: 0x00ad, 0x18b: 0xe03d,
0x18c: 0x0008, 0x18d: 0x0008, 0x18e: 0x00c5, 0x18f: 0x00dd, 0x190: 0x00f5, 0x191: 0xe01d,
0x192: 0x0008, 0x193: 0x010d, 0x194: 0x0125, 0x195: 0x0008, 0x196: 0x013d, 0x197: 0x013d,
0x198: 0xe00d, 0x199: 0x0008, 0x19a: 0x0008, 0x19b: 0x0008, 0x19c: 0x010d, 0x19d: 0x0155,
0x19e: 0x0008, 0x19f: 0x016d, 0x1a0: 0xe00d, 0x1a1: 0x0008, 0x1a2: 0xe00d, 0x1a3: 0x0008,
0x1a4: 0xe00d, 0x1a5: 0x0008, 0x1a6: 0x0185, 0x1a7: 0xe07d, 0x1a8: 0x0008, 0x1a9: 0x019d,
0x1aa: 0x0008, 0x1ab: 0x0008, 0x1ac: 0xe00d, 0x1ad: 0x0008, 0x1ae: 0x0185, 0x1af: 0xe0fd,
0x1b0: 0x0008, 0x1b1: 0x01b5, 0x1b2: 0x01cd, 0x1b3: 0xe03d, 0x1b4: 0x0008, 0x1b5: 0xe01d,
0x1b6: 0x0008, 0x1b7: 0x01e5, 0x1b8: 0xe00d, 0x1b9: 0x0008, 0x1ba: 0x0008, 0x1bb: 0x0008,
0x1bc: 0xe00d, 0x1bd: 0x0008, 0x1be: 0x0008, 0x1bf: 0x0008,
// Block 0x7, offset 0x1c0
0x1c0: 0x0008, 0x1c1: 0x0008, 0x1c2: 0x0008, 0x1c3: 0x0008, 0x1c4: 0x0091, 0x1c5: 0x0091,
0x1c6: 0x0091, 0x1c7: 0x01fd, 0x1c8: 0x0215, 0x1c9: 0x022d, 0x1ca: 0x0245, 0x1cb: 0x025d,
0x1cc: 0x0275, 0x1cd: 0xe01d, 0x1ce: 0x0008, 0x1cf: 0xe0fd, 0x1d0: 0x0008, 0x1d1: 0xe01d,
0x1d2: 0x0008, 0x1d3: 0xe03d, 0x1d4: 0x0008, 0x1d5: 0xe01d, 0x1d6: 0x0008, 0x1d7: 0xe07d,
0x1d8: 0x0008, 0x1d9: 0xe01d, 0x1da: 0x0008, 0x1db: 0xe03d, 0x1dc: 0x0008, 0x1dd: 0x0008,
0x1de: 0xe00d, 0x1df: 0x0008, 0x1e0: 0xe00d, 0x1e1: 0x0008, 0x1e2: 0xe00d, 0x1e3: 0x0008,
0x1e4: 0xe00d, 0x1e5: 0x0008, 0x1e6: 0xe00d, 0x1e7: 0x0008, 0x1e8: 0xe00d, 0x1e9: 0x0008,
0x1ea: 0xe00d, 0x1eb: 0x0008, 0x1ec: 0xe00d, 0x1ed: 0x0008, 0x1ee: 0xe00d, 0x1ef: 0x0008,
0x1f0: 0x0008, 0x1f1: 0x028d, 0x1f2: 0x02a5, 0x1f3: 0x02bd, 0x1f4: 0xe00d, 0x1f5: 0x0008,
0x1f6: 0x02d5, 0x1f7: 0x02ed, 0x1f8: 0xe00d, 0x1f9: 0x0008, 0x1fa: 0xe00d, 0x1fb: 0x0008,
0x1fc: 0xe00d, 0x1fd: 0x0008, 0x1fe: 0xe00d, 0x1ff: 0x0008,
// Block 0x8, offset 0x200
0x200: 0xe00d, 0x201: 0x0008, 0x202: 0xe00d, 0x203: 0x0008, 0x204: 0xe00d, 0x205: 0x0008,
0x206: 0xe00d, 0x207: 0x0008, 0x208: 0xe00d, 0x209: 0x0008, 0x20a: 0xe00d, 0x20b: 0x0008,
0x20c: 0xe00d, 0x20d: 0x0008, 0x20e: 0xe00d, 0x20f: 0x0008, 0x210: 0xe00d, 0x211: 0x0008,
0x212: 0xe00d, 0x213: 0x0008, 0x214: 0xe00d, 0x215: 0x0008, 0x216: 0xe00d, 0x217: 0x0008,
0x218: 0xe00d, 0x219: 0x0008, 0x21a: 0xe00d, 0x21b: 0x0008, 0x21c: 0xe00d, 0x21d: 0x0008,
0x21e: 0xe00d, 0x21f: 0x0008, 0x220: 0x0305, 0x221: 0x0008, 0x222: 0xe00d, 0x223: 0x0008,
0x224: 0xe00d, 0x225: 0x0008, 0x226: 0xe00d, 0x227: 0x0008, 0x228: 0xe00d, 0x229: 0x0008,
0x22a: 0xe00d, 0x22b: 0x0008, 0x22c: 0xe00d, 0x22d: 0x0008, 0x22e: 0xe00d, 0x22f: 0x0008,
0x230: 0xe00d, 0x231: 0x0008, 0x232: 0xe00d, 0x233: 0x0008, 0x234: 0x0008, 0x235: 0x0008,
0x236: 0x0008, 0x237: 0x0008, 0x238: 0x0008, 0x239: 0x0008, 0x23a: 0x0099, 0x23b: 0xe03d,
0x23c: 0x0008, 0x23d: 0x031d, 0x23e: 0x00a1, 0x23f: 0x0008,
// Block 0x9, offset 0x240
0x240: 0x0008, 0x241: 0x0008, 0x242: 0x0018, 0x243: 0x0018, 0x244: 0x0018, 0x245: 0x0018,
0x246: 0x0008, 0x247: 0x0008, 0x248: 0x0008, 0x249: 0x0008, 0x24a: 0x0008, 0x24b: 0x0008,
0x24c: 0x0008, 0x24d: 0x0008, 0x24e: 0x0008, 0x24f: 0x0008, 0x250: 0x0008, 0x251: 0x0008,
0x252: 0x0018, 0x253: 0x0018, 0x254: 0x0018, 0x255: 0x0018, 0x256: 0x0018, 0x257: 0x0018,
0x258: 0x00d2, 0x259: 0x00da, 0x25a: 0x00e2, 0x25b: 0x00ea, 0x25c: 0x00f2, 0x25d: 0x00fa,
0x25e: 0x0018, 0x25f: 0x0018, 0x260: 0x03ad, 0x261: 0x0101, 0x262: 0x0089, 0x263: 0x0109,
0x264: 0x03c5, 0x265: 0x0018, 0x266: 0x0018, 0x267: 0x0018, 0x268: 0x0018, 0x269: 0x0018,
0x26a: 0x0018, 0x26b: 0x0018, 0x26c: 0x0008, 0x26d: 0x0018, 0x26e: 0x0008, 0x26f: 0x0018,
0x270: 0x0018, 0x271: 0x0018, 0x272: 0x0018, 0x273: 0x0018, 0x274: 0x0018, 0x275: 0x0018,
0x276: 0x0018, 0x277: 0x0018, 0x278: 0x0018, 0x279: 0x0018, 0x27a: 0x0018, 0x27b: 0x0018,
0x27c: 0x0018, 0x27d: 0x0018, 0x27e: 0x0018, 0x27f: 0x0018,
// Block 0xa, offset 0x280
0x280: 0x03dd, 0x281: 0x03dd, 0x282: 0x3308, 0x283: 0x03f5, 0x284: 0x0111, 0x285: 0x040d,
0x286: 0x3308, 0x287: 0x3308, 0x288: 0x3308, 0x289: 0x3308, 0x28a: 0x3308, 0x28b: 0x3308,
0x28c: 0x3308, 0x28d: 0x3308, 0x28e: 0x3308, 0x28f: 0x33c0, 0x290: 0x3308, 0x291: 0x3308,
0x292: 0x3308, 0x293: 0x3308, 0x294: 0x3308, 0x295: 0x3308, 0x296: 0x3308, 0x297: 0x3308,
0x298: 0x3308, 0x299: 0x3308, 0x29a: 0x3308, 0x29b: 0x3308, 0x29c: 0x3308, 0x29d: 0x3308,
0x29e: 0x3308, 0x29f: 0x3308, 0x2a0: 0x3308, 0x2a1: 0x3308, 0x2a2: 0x3308, 0x2a3: 0x3308,
0x2a4: 0x3308, 0x2a5: 0x3308, 0x2a6: 0x3308, 0x2a7: 0x3308, 0x2a8: 0x3308, 0x2a9: 0x3308,
0x2aa: 0x3308, 0x2ab: 0x3308, 0x2ac: 0x3308, 0x2ad: 0x3308, 0x2ae: 0x3308, 0x2af: 0x3308,
0x2b0: 0xe00d, 0x2b1: 0x0008, 0x2b2: 0xe00d, 0x2b3: 0x0008, 0x2b4: 0x0425, 0x2b5: 0x0008,
0x2b6: 0xe00d, 0x2b7: 0x0008, 0x2b8: 0x0040, 0x2b9: 0x0040, 0x2ba: 0x011a, 0x2bb: 0x0008,
0x2bc: 0x0008, 0x2bd: 0x0008, 0x2be: 0x0122, 0x2bf: 0x043d,
// Block 0xb, offset 0x2c0
0x2c0: 0x0040, 0x2c1: 0x0040, 0x2c2: 0x0040, 0x2c3: 0x0040, 0x2c4: 0x003a, 0x2c5: 0x012a,
0x2c6: 0xe155, 0x2c7: 0x0455, 0x2c8: 0xe12d, 0x2c9: 0xe13d, 0x2ca: 0xe12d, 0x2cb: 0x0040,
0x2cc: 0x03dd, 0x2cd: 0x0040, 0x2ce: 0x046d, 0x2cf: 0x0485, 0x2d0: 0x0008, 0x2d1: 0xe105,
0x2d2: 0xe105, 0x2d3: 0xe105, 0x2d4: 0xe105, 0x2d5: 0xe105, 0x2d6: 0xe105, 0x2d7: 0xe105,
0x2d8: 0xe105, 0x2d9: 0xe105, 0x2da: 0xe105, 0x2db: 0xe105, 0x2dc: 0xe105, 0x2dd: 0xe105,
0x2de: 0xe105, 0x2df: 0xe105, 0x2e0: 0x049d, 0x2e1: 0x049d, 0x2e2: 0x0040, 0x2e3: 0x049d,
0x2e4: 0x049d, 0x2e5: 0x049d, 0x2e6: 0x049d, 0x2e7: 0x049d, 0x2e8: 0x049d, 0x2e9: 0x049d,
0x2ea: 0x049d, 0x2eb: 0x049d, 0x2ec: 0x0008, 0x2ed: 0x0008, 0x2ee: 0x0008, 0x2ef: 0x0008,
0x2f0: 0x0008, 0x2f1: 0x0008, 0x2f2: 0x0008, 0x2f3: 0x0008, 0x2f4: 0x0008, 0x2f5: 0x0008,
0x2f6: 0x0008, 0x2f7: 0x0008, 0x2f8: 0x0008, 0x2f9: 0x0008, 0x2fa: 0x0008, 0x2fb: 0x0008,
0x2fc: 0x0008, 0x2fd: 0x0008, 0x2fe: 0x0008, 0x2ff: 0x0008,
// Block 0xc, offset 0x300
0x300: 0x0008, 0x301: 0x0008, 0x302: 0xe00f, 0x303: 0x0008, 0x304: 0x0008, 0x305: 0x0008,
0x306: 0x0008, 0x307: 0x0008, 0x308: 0x0008, 0x309: 0x0008, 0x30a: 0x0008, 0x30b: 0x0008,
0x30c: 0x0008, 0x30d: 0x0008, 0x30e: 0x0008, 0x30f: 0xe0c5, 0x310: 0x04b5, 0x311: 0x04cd,
0x312: 0xe0bd, 0x313: 0xe0f5, 0x314: 0xe0fd, 0x315: 0xe09d, 0x316: 0xe0b5, 0x317: 0x0008,
0x318: 0xe00d, 0x319: 0x0008, 0x31a: 0xe00d, 0x31b: 0x0008, 0x31c: 0xe00d, 0x31d: 0x0008,
0x31e: 0xe00d, 0x31f: 0x0008, 0x320: 0xe00d, 0x321: 0x0008, 0x322: 0xe00d, 0x323: 0x0008,
0x324: 0xe00d, 0x325: 0x0008, 0x326: 0xe00d, 0x327: 0x0008, 0x328: 0xe00d, 0x329: 0x0008,
0x32a: 0xe00d, 0x32b: 0x0008, 0x32c: 0xe00d, 0x32d: 0x0008, 0x32e: 0xe00d, 0x32f: 0x0008,
0x330: 0x04e5, 0x331: 0xe185, 0x332: 0xe18d, 0x333: 0x0008, 0x334: 0x04fd, 0x335: 0x03dd,
0x336: 0x0018, 0x337: 0xe07d, 0x338: 0x0008, 0x339: 0xe1d5, 0x33a: 0xe00d, 0x33b: 0x0008,
0x33c: 0x0008, 0x33d: 0x0515, 0x33e: 0x052d, 0x33f: 0x052d,
// Block 0xd, offset 0x340
0x340: 0x0008, 0x341: 0x0008, 0x342: 0x0008, 0x343: 0x0008, 0x344: 0x0008, 0x345: 0x0008,
0x346: 0x0008, 0x347: 0x0008, 0x348: 0x0008, 0x349: 0x0008, 0x34a: 0x0008, 0x34b: 0x0008,
0x34c: 0x0008, 0x34d: 0x0008, 0x34e: 0x0008, 0x34f: 0x0008, 0x350: 0x0008, 0x351: 0x0008,
0x352: 0x0008, 0x353: 0x0008, 0x354: 0x0008, 0x355: 0x0008, 0x356: 0x0008, 0x357: 0x0008,
0x358: 0x0008, 0x359: 0x0008, 0x35a: 0x0008, 0x35b: 0x0008, 0x35c: 0x0008, 0x35d: 0x0008,
0x35e: 0x0008, 0x35f: 0x0008, 0x360: 0xe00d, 0x361: 0x0008, 0x362: 0xe00d, 0x363: 0x0008,
0x364: 0xe00d, 0x365: 0x0008, 0x366: 0xe00d, 0x367: 0x0008, 0x368: 0xe00d, 0x369: 0x0008,
0x36a: 0xe00d, 0x36b: 0x0008, 0x36c: 0xe00d, 0x36d: 0x0008, 0x36e: 0xe00d, 0x36f: 0x0008,
0x370: 0xe00d, 0x371: 0x0008, 0x372: 0xe00d, 0x373: 0x0008, 0x374: 0xe00d, 0x375: 0x0008,
0x376: 0xe00d, 0x377: 0x0008, 0x378: 0xe00d, 0x379: 0x0008, 0x37a: 0xe00d, 0x37b: 0x0008,
0x37c: 0xe00d, 0x37d: 0x0008, 0x37e: 0xe00d, 0x37f: 0x0008,
// Block 0xe, offset 0x380
0x380: 0xe00d, 0x381: 0x0008, 0x382: 0x0018, 0x383: 0x3308, 0x384: 0x3308, 0x385: 0x3308,
0x386: 0x3308, 0x387: 0x3308, 0x388: 0x3318, 0x389: 0x3318, 0x38a: 0xe00d, 0x38b: 0x0008,
0x38c: 0xe00d, 0x38d: 0x0008, 0x38e: 0xe00d, 0x38f: 0x0008, 0x390: 0xe00d, 0x391: 0x0008,
0x392: 0xe00d, 0x393: 0x0008, 0x394: 0xe00d, 0x395: 0x0008, 0x396: 0xe00d, 0x397: 0x0008,
0x398: 0xe00d, 0x399: 0x0008, 0x39a: 0xe00d, 0x39b: 0x0008, 0x39c: 0xe00d, 0x39d: 0x0008,
0x39e: 0xe00d, 0x39f: 0x0008, 0x3a0: 0xe00d, 0x3a1: 0x0008, 0x3a2: 0xe00d, 0x3a3: 0x0008,
0x3a4: 0xe00d, 0x3a5: 0x0008, 0x3a6: 0xe00d, 0x3a7: 0x0008, 0x3a8: 0xe00d, 0x3a9: 0x0008,
0x3aa: 0xe00d, 0x3ab: 0x0008, 0x3ac: 0xe00d, 0x3ad: 0x0008, 0x3ae: 0xe00d, 0x3af: 0x0008,
0x3b0: 0xe00d, 0x3b1: 0x0008, 0x3b2: 0xe00d, 0x3b3: 0x0008, 0x3b4: 0xe00d, 0x3b5: 0x0008,
0x3b6: 0xe00d, 0x3b7: 0x0008, 0x3b8: 0xe00d, 0x3b9: 0x0008, 0x3ba: 0xe00d, 0x3bb: 0x0008,
0x3bc: 0xe00d, 0x3bd: 0x0008, 0x3be: 0xe00d, 0x3bf: 0x0008,
// Block 0xf, offset 0x3c0
0x3c0: 0x0040, 0x3c1: 0xe01d, 0x3c2: 0x0008, 0x3c3: 0xe03d, 0x3c4: 0x0008, 0x3c5: 0xe01d,
0x3c6: 0x0008, 0x3c7: 0xe07d, 0x3c8: 0x0008, 0x3c9: 0xe01d, 0x3ca: 0x0008, 0x3cb: 0xe03d,
0x3cc: 0x0008, 0x3cd: 0xe01d, 0x3ce: 0x0008, 0x3cf: 0x0008, 0x3d0: 0xe00d, 0x3d1: 0x0008,
0x3d2: 0xe00d, 0x3d3: 0x0008, 0x3d4: 0xe00d, 0x3d5: 0x0008, 0x3d6: 0xe00d, 0x3d7: 0x0008,
0x3d8: 0xe00d, 0x3d9: 0x0008, 0x3da: 0xe00d, 0x3db: 0x0008, 0x3dc: 0xe00d, 0x3dd: 0x0008,
0x3de: 0xe00d, 0x3df: 0x0008, 0x3e0: 0xe00d, 0x3e1: 0x0008, 0x3e2: 0xe00d, 0x3e3: 0x0008,
0x3e4: 0xe00d, 0x3e5: 0x0008, 0x3e6: 0xe00d, 0x3e7: 0x0008, 0x3e8: 0xe00d, 0x3e9: 0x0008,
0x3ea: 0xe00d, 0x3eb: 0x0008, 0x3ec: 0xe00d, 0x3ed: 0x0008, 0x3ee: 0xe00d, 0x3ef: 0x0008,
0x3f0: 0xe00d, 0x3f1: 0x0008, 0x3f2: 0xe00d, 0x3f3: 0x0008, 0x3f4: 0xe00d, 0x3f5: 0x0008,
0x3f6: 0xe00d, 0x3f7: 0x0008, 0x3f8: 0xe00d, 0x3f9: 0x0008, 0x3fa: 0xe00d, 0x3fb: 0x0008,
0x3fc: 0xe00d, 0x3fd: 0x0008, 0x3fe: 0xe00d, 0x3ff: 0x0008,
// Block 0x10, offset 0x400
0x400: 0xe00d, 0x401: 0x0008, 0x402: 0xe00d, 0x403: 0x0008, 0x404: 0xe00d, 0x405: 0x0008,
0x406: 0xe00d, 0x407: 0x0008, 0x408: 0xe00d, 0x409: 0x0008, 0x40a: 0xe00d, 0x40b: 0x0008,
0x40c: 0xe00d, 0x40d: 0x0008, 0x40e: 0xe00d, 0x40f: 0x0008, 0x410: 0xe00d, 0x411: 0x0008,
0x412: 0xe00d, 0x413: 0x0008, 0x414: 0xe00d, 0x415: 0x0008, 0x416: 0xe00d, 0x417: 0x0008,
0x418: 0xe00d, 0x419: 0x0008, 0x41a: 0xe00d, 0x41b: 0x0008, 0x41c: 0xe00d, 0x41d: 0x0008,
0x41e: 0xe00d, 0x41f: 0x0008, 0x420: 0xe00d, 0x421: 0x0008, 0x422: 0xe00d, 0x423: 0x0008,
0x424: 0xe00d, 0x425: 0x0008, 0x426: 0xe00d, 0x427: 0x0008, 0x428: 0xe00d, 0x429: 0x0008,
0x42a: 0xe00d, 0x42b: 0x0008, 0x42c: 0xe00d, 0x42d: 0x0008, 0x42e: 0xe00d, 0x42f: 0x0008,
0x430: 0x0040, 0x431: 0x03f5, 0x432: 0x03f5, 0x433: 0x03f5, 0x434: 0x03f5, 0x435: 0x03f5,
0x436: 0x03f5, 0x437: 0x03f5, 0x438: 0x03f5, 0x439: 0x03f5, 0x43a: 0x03f5, 0x43b: 0x03f5,
0x43c: 0x03f5, 0x43d: 0x03f5, 0x43e: 0x03f5, 0x43f: 0x03f5,
// Block 0x11, offset 0x440
0x440: 0x0840, 0x441: 0x0840, 0x442: 0x0840, 0x443: 0x0840, 0x444: 0x0840, 0x445: 0x0840,
0x446: 0x0018, 0x447: 0x0018, 0x448: 0x0818, 0x449: 0x0018, 0x44a: 0x0018, 0x44b: 0x0818,
0x44c: 0x0018, 0x44d: 0x0818, 0x44e: 0x0018, 0x44f: 0x0018, 0x450: 0x3308, 0x451: 0x3308,
0x452: 0x3308, 0x453: 0x3308, 0x454: 0x3308, 0x455: 0x3308, 0x456: 0x3308, 0x457: 0x3308,
0x458: 0x3308, 0x459: 0x3308, 0x45a: 0x3308, 0x45b: 0x0818, 0x45c: 0x0b40, 0x45d: 0x0818,
0x45e: 0x0818, 0x45f: 0x0818, 0x460: 0x0a08, 0x461: 0x0808, 0x462: 0x0c08, 0x463: 0x0c08,
0x464: 0x0c08, 0x465: 0x0c08, 0x466: 0x0a08, 0x467: 0x0c08, 0x468: 0x0a08, 0x469: 0x0c08,
0x46a: 0x0a08, 0x46b: 0x0a08, 0x46c: 0x0a08, 0x46d: 0x0a08, 0x46e: 0x0a08, 0x46f: 0x0c08,
0x470: 0x0c08, 0x471: 0x0c08, 0x472: 0x0c08, 0x473: 0x0a08, 0x474: 0x0a08, 0x475: 0x0a08,
0x476: 0x0a08, 0x477: 0x0a08, 0x478: 0x0a08, 0x479: 0x0a08, 0x47a: 0x0a08, 0x47b: 0x0a08,
0x47c: 0x0a08, 0x47d: 0x0a08, 0x47e: 0x0a08, 0x47f: 0x0a08,
// Block 0x12, offset 0x480
0x480: 0x0818, 0x481: 0x0a08, 0x482: 0x0a08, 0x483: 0x0a08, 0x484: 0x0a08, 0x485: 0x0a08,
0x486: 0x0a08, 0x487: 0x0a08, 0x488: 0x0c08, 0x489: 0x0a08, 0x48a: 0x0a08, 0x48b: 0x3308,
0x48c: 0x3308, 0x48d: 0x3308, 0x48e: 0x3308, 0x48f: 0x3308, 0x490: 0x3308, 0x491: 0x3308,
0x492: 0x3308, 0x493: 0x3308, 0x494: 0x3308, 0x495: 0x3308, 0x496: 0x3308, 0x497: 0x3308,
0x498: 0x3308, 0x499: 0x3308, 0x49a: 0x3308, 0x49b: 0x3308, 0x49c: 0x3308, 0x49d: 0x3308,
0x49e: 0x3308, 0x49f: 0x3308, 0x4a0: 0x0808, 0x4a1: 0x0808, 0x4a2: 0x0808, 0x4a3: 0x0808,
0x4a4: 0x0808, 0x4a5: 0x0808, 0x4a6: 0x0808, 0x4a7: 0x0808, 0x4a8: 0x0808, 0x4a9: 0x0808,
0x4aa: 0x0018, 0x4ab: 0x0818, 0x4ac: 0x0818, 0x4ad: 0x0818, 0x4ae: 0x0a08, 0x4af: 0x0a08,
0x4b0: 0x3308, 0x4b1: 0x0c08, 0x4b2: 0x0c08, 0x4b3: 0x0c08, 0x4b4: 0x0808, 0x4b5: 0x0139,
0x4b6: 0x0141, 0x4b7: 0x0149, 0x4b8: 0x0151, 0x4b9: 0x0a08, 0x4ba: 0x0a08, 0x4bb: 0x0a08,
0x4bc: 0x0a08, 0x4bd: 0x0a08, 0x4be: 0x0a08, 0x4bf: 0x0a08,
// Block 0x13, offset 0x4c0
0x4c0: 0x0c08, 0x4c1: 0x0a08, 0x4c2: 0x0a08, 0x4c3: 0x0c08, 0x4c4: 0x0c08, 0x4c5: 0x0c08,
0x4c6: 0x0c08, 0x4c7: 0x0c08, 0x4c8: 0x0c08, 0x4c9: 0x0c08, 0x4ca: 0x0c08, 0x4cb: 0x0c08,
0x4cc: 0x0a08, 0x4cd: 0x0c08, 0x4ce: 0x0a08, 0x4cf: 0x0c08, 0x4d0: 0x0a08, 0x4d1: 0x0a08,
0x4d2: 0x0c08, 0x4d3: 0x0c08, 0x4d4: 0x0818, 0x4d5: 0x0c08, 0x4d6: 0x3308, 0x4d7: 0x3308,
0x4d8: 0x3308, 0x4d9: 0x3308, 0x4da: 0x3308, 0x4db: 0x3308, 0x4dc: 0x3308, 0x4dd: 0x0840,
0x4de: 0x0018, 0x4df: 0x3308, 0x4e0: 0x3308, 0x4e1: 0x3308, 0x4e2: 0x3308, 0x4e3: 0x3308,
0x4e4: 0x3308, 0x4e5: 0x0808, 0x4e6: 0x0808, 0x4e7: 0x3308, 0x4e8: 0x3308, 0x4e9: 0x0018,
0x4ea: 0x3308, 0x4eb: 0x3308, 0x4ec: 0x3308, 0x4ed: 0x3308, 0x4ee: 0x0c08, 0x4ef: 0x0c08,
0x4f0: 0x0008, 0x4f1: 0x0008, 0x4f2: 0x0008, 0x4f3: 0x0008, 0x4f4: 0x0008, 0x4f5: 0x0008,
0x4f6: 0x0008, 0x4f7: 0x0008, 0x4f8: 0x0008, 0x4f9: 0x0008, 0x4fa: 0x0a08, 0x4fb: 0x0a08,
0x4fc: 0x0a08, 0x4fd: 0x0808, 0x4fe: 0x0808, 0x4ff: 0x0a08,
// Block 0x14, offset 0x500
0x500: 0x0818, 0x501: 0x0818, 0x502: 0x0818, 0x503: 0x0818, 0x504: 0x0818, 0x505: 0x0818,
0x506: 0x0818, 0x507: 0x0818, 0x508: 0x0818, 0x509: 0x0818, 0x50a: 0x0818, 0x50b: 0x0818,
0x50c: 0x0818, 0x50d: 0x0818, 0x50e: 0x0040, 0x50f: 0x0b40, 0x510: 0x0c08, 0x511: 0x3308,
0x512: 0x0a08, 0x513: 0x0a08, 0x514: 0x0a08, 0x515: 0x0c08, 0x516: 0x0c08, 0x517: 0x0c08,
0x518: 0x0c08, 0x519: 0x0c08, 0x51a: 0x0a08, 0x51b: 0x0a08, 0x51c: 0x0a08, 0x51d: 0x0a08,
0x51e: 0x0c08, 0x51f: 0x0a08, 0x520: 0x0a08, 0x521: 0x0a08, 0x522: 0x0a08, 0x523: 0x0a08,
0x524: 0x0a08, 0x525: 0x0a08, 0x526: 0x0a08, 0x527: 0x0a08, 0x528: 0x0c08, 0x529: 0x0a08,
0x52a: 0x0c08, 0x52b: 0x0a08, 0x52c: 0x0c08, 0x52d: 0x0a08, 0x52e: 0x0a08, 0x52f: 0x0c08,
0x530: 0x3308, 0x531: 0x3308, 0x532: 0x3308, 0x533: 0x3308, 0x534: 0x3308, 0x535: 0x3308,
0x536: 0x3308, 0x537: 0x3308, 0x538: 0x3308, 0x539: 0x3308, 0x53a: 0x3308, 0x53b: 0x3308,
0x53c: 0x3308, 0x53d: 0x3308, 0x53e: 0x3308, 0x53f: 0x3308,
// Block 0x15, offset 0x540
0x540: 0x0c08, 0x541: 0x0a08, 0x542: 0x0a08, 0x543: 0x0a08, 0x544: 0x0a08, 0x545: 0x0a08,
0x546: 0x0c08, 0x547: 0x0c08, 0x548: 0x0a08, 0x549: 0x0c08, 0x54a: 0x0a08, 0x54b: 0x0a08,
0x54c: 0x0a08, 0x54d: 0x0a08, 0x54e: 0x0a08, 0x54f: 0x0a08, 0x550: 0x0a08, 0x551: 0x0a08,
0x552: 0x0a08, 0x553: 0x0a08, 0x554: 0x0c08, 0x555: 0x0a08, 0x556: 0x0c08, 0x557: 0x0c08,
0x558: 0x0c08, 0x559: 0x3308, 0x55a: 0x3308, 0x55b: 0x3308, 0x55c: 0x0040, 0x55d: 0x0040,
0x55e: 0x0818, 0x55f: 0x0040, 0x560: 0x0a08, 0x561: 0x0808, 0x562: 0x0a08, 0x563: 0x0a08,
0x564: 0x0a08, 0x565: 0x0a08, 0x566: 0x0808, 0x567: 0x0c08, 0x568: 0x0a08, 0x569: 0x0c08,
0x56a: 0x0c08, 0x56b: 0x0040, 0x56c: 0x0040, 0x56d: 0x0040, 0x56e: 0x0040, 0x56f: 0x0040,
0x570: 0x0c08, 0x571: 0x0c08, 0x572: 0x0c08, 0x573: 0x0c08, 0x574: 0x0c08, 0x575: 0x0c08,
0x576: 0x0c08, 0x577: 0x0c08, 0x578: 0x0c08, 0x579: 0x0c08, 0x57a: 0x0c08, 0x57b: 0x0c08,
0x57c: 0x0c08, 0x57d: 0x0c08, 0x57e: 0x0c08, 0x57f: 0x0c08,
// Block 0x16, offset 0x580
0x580: 0x0c08, 0x581: 0x0c08, 0x582: 0x0c08, 0x583: 0x0808, 0x584: 0x0808, 0x585: 0x0808,
0x586: 0x0a08, 0x587: 0x0808, 0x588: 0x0818, 0x589: 0x0a08, 0x58a: 0x0a08, 0x58b: 0x0a08,
0x58c: 0x0a08, 0x58d: 0x0a08, 0x58e: 0x0c08, 0x58f: 0x0040, 0x590: 0x0840, 0x591: 0x0840,
0x592: 0x0040, 0x593: 0x0040, 0x594: 0x0040, 0x595: 0x0040, 0x596: 0x0040, 0x597: 0x0040,
0x598: 0x3308, 0x599: 0x3308, 0x59a: 0x3308, 0x59b: 0x3308, 0x59c: 0x3308, 0x59d: 0x3308,
0x59e: 0x3308, 0x59f: 0x3308, 0x5a0: 0x0a08, 0x5a1: 0x0a08, 0x5a2: 0x0a08, 0x5a3: 0x0a08,
0x5a4: 0x0a08, 0x5a5: 0x0a08, 0x5a6: 0x0a08, 0x5a7: 0x0a08, 0x5a8: 0x0a08, 0x5a9: 0x0a08,
0x5aa: 0x0c08, 0x5ab: 0x0c08, 0x5ac: 0x0c08, 0x5ad: 0x0808, 0x5ae: 0x0c08, 0x5af: 0x0a08,
0x5b0: 0x0a08, 0x5b1: 0x0c08, 0x5b2: 0x0c08, 0x5b3: 0x0a08, 0x5b4: 0x0a08, 0x5b5: 0x0a08,
0x5b6: 0x0a08, 0x5b7: 0x0a08, 0x5b8: 0x0a08, 0x5b9: 0x0c08, 0x5ba: 0x0a08, 0x5bb: 0x0a08,
0x5bc: 0x0a08, 0x5bd: 0x0a08, 0x5be: 0x0a08, 0x5bf: 0x0a08,
// Block 0x17, offset 0x5c0
0x5c0: 0x3008, 0x5c1: 0x3308, 0x5c2: 0x3308, 0x5c3: 0x3308, 0x5c4: 0x3308, 0x5c5: 0x3308,
0x5c6: 0x3308, 0x5c7: 0x3308, 0x5c8: 0x3308, 0x5c9: 0x3008, 0x5ca: 0x3008, 0x5cb: 0x3008,
0x5cc: 0x3008, 0x5cd: 0x3b08, 0x5ce: 0x3008, 0x5cf: 0x3008, 0x5d0: 0x0008, 0x5d1: 0x3308,
0x5d2: 0x3308, 0x5d3: 0x3308, 0x5d4: 0x3308, 0x5d5: 0x3308, 0x5d6: 0x3308, 0x5d7: 0x3308,
0x5d8: 0x0159, 0x5d9: 0x0161, 0x5da: 0x0169, 0x5db: 0x0171, 0x5dc: 0x0179, 0x5dd: 0x0181,
0x5de: 0x0189, 0x5df: 0x0191, 0x5e0: 0x0008, 0x5e1: 0x0008, 0x5e2: 0x3308, 0x5e3: 0x3308,
0x5e4: 0x0018, 0x5e5: 0x0018, 0x5e6: 0x0008, 0x5e7: 0x0008, 0x5e8: 0x0008, 0x5e9: 0x0008,
0x5ea: 0x0008, 0x5eb: 0x0008, 0x5ec: 0x0008, 0x5ed: 0x0008, 0x5ee: 0x0008, 0x5ef: 0x0008,
0x5f0: 0x0018, 0x5f1: 0x0008, 0x5f2: 0x0008, 0x5f3: 0x0008, 0x5f4: 0x0008, 0x5f5: 0x0008,
0x5f6: 0x0008, 0x5f7: 0x0008, 0x5f8: 0x0008, 0x5f9: 0x0008, 0x5fa: 0x0008, 0x5fb: 0x0008,
0x5fc: 0x0008, 0x5fd: 0x0008, 0x5fe: 0x0008, 0x5ff: 0x0008,
// Block 0x18, offset 0x600
0x600: 0x0008, 0x601: 0x3308, 0x602: 0x3008, 0x603: 0x3008, 0x604: 0x0040, 0x605: 0x0008,
0x606: 0x0008, 0x607: 0x0008, 0x608: 0x0008, 0x609: 0x0008, 0x60a: 0x0008, 0x60b: 0x0008,
0x60c: 0x0008, 0x60d: 0x0040, 0x60e: 0x0040, 0x60f: 0x0008, 0x610: 0x0008, 0x611: 0x0040,
0x612: 0x0040, 0x613: 0x0008, 0x614: 0x0008, 0x615: 0x0008, 0x616: 0x0008, 0x617: 0x0008,
0x618: 0x0008, 0x619: 0x0008, 0x61a: 0x0008, 0x61b: 0x0008, 0x61c: 0x0008, 0x61d: 0x0008,
0x61e: 0x0008, 0x61f: 0x0008, 0x620: 0x0008, 0x621: 0x0008, 0x622: 0x0008, 0x623: 0x0008,
0x624: 0x0008, 0x625: 0x0008, 0x626: 0x0008, 0x627: 0x0008, 0x628: 0x0008, 0x629: 0x0040,
0x62a: 0x0008, 0x62b: 0x0008, 0x62c: 0x0008, 0x62d: 0x0008, 0x62e: 0x0008, 0x62f: 0x0008,
0x630: 0x0008, 0x631: 0x0040, 0x632: 0x0008, 0x633: 0x0040, 0x634: 0x0040, 0x635: 0x0040,
0x636: 0x0008, 0x637: 0x0008, 0x638: 0x0008, 0x639: 0x0008, 0x63a: 0x0040, 0x63b: 0x0040,
0x63c: 0x3308, 0x63d: 0x0008, 0x63e: 0x3008, 0x63f: 0x3008,
// Block 0x19, offset 0x640
0x640: 0x3008, 0x641: 0x3308, 0x642: 0x3308, 0x643: 0x3308, 0x644: 0x3308, 0x645: 0x0040,
0x646: 0x0040, 0x647: 0x3008, 0x648: 0x3008, 0x649: 0x0040, 0x64a: 0x0040, 0x64b: 0x3008,
0x64c: 0x3008, 0x64d: 0x3b08, 0x64e: 0x0008, 0x64f: 0x0040, 0x650: 0x0040, 0x651: 0x0040,
0x652: 0x0040, 0x653: 0x0040, 0x654: 0x0040, 0x655: 0x0040, 0x656: 0x0040, 0x657: 0x3008,
0x658: 0x0040, 0x659: 0x0040, 0x65a: 0x0040, 0x65b: 0x0040, 0x65c: 0x0199, 0x65d: 0x01a1,
0x65e: 0x0040, 0x65f: 0x01a9, 0x660: 0x0008, 0x661: 0x0008, 0x662: 0x3308, 0x663: 0x3308,
0x664: 0x0040, 0x665: 0x0040, 0x666: 0x0008, 0x667: 0x0008, 0x668: 0x0008, 0x669: 0x0008,
0x66a: 0x0008, 0x66b: 0x0008, 0x66c: 0x0008, 0x66d: 0x0008, 0x66e: 0x0008, 0x66f: 0x0008,
0x670: 0x0008, 0x671: 0x0008, 0x672: 0x0018, 0x673: 0x0018, 0x674: 0x0018, 0x675: 0x0018,
0x676: 0x0018, 0x677: 0x0018, 0x678: 0x0018, 0x679: 0x0018, 0x67a: 0x0018, 0x67b: 0x0018,
0x67c: 0x0008, 0x67d: 0x0018, 0x67e: 0x3308, 0x67f: 0x0040,
// Block 0x1a, offset 0x680
0x680: 0x0040, 0x681: 0x3308, 0x682: 0x3308, 0x683: 0x3008, 0x684: 0x0040, 0x685: 0x0008,
0x686: 0x0008, 0x687: 0x0008, 0x688: 0x0008, 0x689: 0x0008, 0x68a: 0x0008, 0x68b: 0x0040,
0x68c: 0x0040, 0x68d: 0x0040, 0x68e: 0x0040, 0x68f: 0x0008, 0x690: 0x0008, 0x691: 0x0040,
0x692: 0x0040, 0x693: 0x0008, 0x694: 0x0008, 0x695: 0x0008, 0x696: 0x0008, 0x697: 0x0008,
0x698: 0x0008, 0x699: 0x0008, 0x69a: 0x0008, 0x69b: 0x0008, 0x69c: 0x0008, 0x69d: 0x0008,
0x69e: 0x0008, 0x69f: 0x0008, 0x6a0: 0x0008, 0x6a1: 0x0008, 0x6a2: 0x0008, 0x6a3: 0x0008,
0x6a4: 0x0008, 0x6a5: 0x0008, 0x6a6: 0x0008, 0x6a7: 0x0008, 0x6a8: 0x0008, 0x6a9: 0x0040,
0x6aa: 0x0008, 0x6ab: 0x0008, 0x6ac: 0x0008, 0x6ad: 0x0008, 0x6ae: 0x0008, 0x6af: 0x0008,
0x6b0: 0x0008, 0x6b1: 0x0040, 0x6b2: 0x0008, 0x6b3: 0x01b1, 0x6b4: 0x0040, 0x6b5: 0x0008,
0x6b6: 0x01b9, 0x6b7: 0x0040, 0x6b8: 0x0008, 0x6b9: 0x0008, 0x6ba: 0x0040, 0x6bb: 0x0040,
0x6bc: 0x3308, 0x6bd: 0x0040, 0x6be: 0x3008, 0x6bf: 0x3008,
// Block 0x1b, offset 0x6c0
0x6c0: 0x3008, 0x6c1: 0x3308, 0x6c2: 0x3308, 0x6c3: 0x0040, 0x6c4: 0x0040, 0x6c5: 0x0040,
0x6c6: 0x0040, 0x6c7: 0x3308, 0x6c8: 0x3308, 0x6c9: 0x0040, 0x6ca: 0x0040, 0x6cb: 0x3308,
0x6cc: 0x3308, 0x6cd: 0x3b08, 0x6ce: 0x0040, 0x6cf: 0x0040, 0x6d0: 0x0040, 0x6d1: 0x3308,
0x6d2: 0x0040, 0x6d3: 0x0040, 0x6d4: 0x0040, 0x6d5: 0x0040, 0x6d6: 0x0040, 0x6d7: 0x0040,
0x6d8: 0x0040, 0x6d9: 0x01c1, 0x6da: 0x01c9, 0x6db: 0x01d1, 0x6dc: 0x0008, 0x6dd: 0x0040,
0x6de: 0x01d9, 0x6df: 0x0040, 0x6e0: 0x0040, 0x6e1: 0x0040, 0x6e2: 0x0040, 0x6e3: 0x0040,
0x6e4: 0x0040, 0x6e5: 0x0040, 0x6e6: 0x0008, 0x6e7: 0x0008, 0x6e8: 0x0008, 0x6e9: 0x0008,
0x6ea: 0x0008, 0x6eb: 0x0008, 0x6ec: 0x0008, 0x6ed: 0x0008, 0x6ee: 0x0008, 0x6ef: 0x0008,
0x6f0: 0x3308, 0x6f1: 0x3308, 0x6f2: 0x0008, 0x6f3: 0x0008, 0x6f4: 0x0008, 0x6f5: 0x3308,
0x6f6: 0x0018, 0x6f7: 0x0040, 0x6f8: 0x0040, 0x6f9: 0x0040, 0x6fa: 0x0040, 0x6fb: 0x0040,
0x6fc: 0x0040, 0x6fd: 0x0040, 0x6fe: 0x0040, 0x6ff: 0x0040,
// Block 0x1c, offset 0x700
0x700: 0x0040, 0x701: 0x3308, 0x702: 0x3308, 0x703: 0x3008, 0x704: 0x0040, 0x705: 0x0008,
0x706: 0x0008, 0x707: 0x0008, 0x708: 0x0008, 0x709: 0x0008, 0x70a: 0x0008, 0x70b: 0x0008,
0x70c: 0x0008, 0x70d: 0x0008, 0x70e: 0x0040, 0x70f: 0x0008, 0x710: 0x0008, 0x711: 0x0008,
0x712: 0x0040, 0x713: 0x0008, 0x714: 0x0008, 0x715: 0x0008, 0x716: 0x0008, 0x717: 0x0008,
0x718: 0x0008, 0x719: 0x0008, 0x71a: 0x0008, 0x71b: 0x0008, 0x71c: 0x0008, 0x71d: 0x0008,
0x71e: 0x0008, 0x71f: 0x0008, 0x720: 0x0008, 0x721: 0x0008, 0x722: 0x0008, 0x723: 0x0008,
0x724: 0x0008, 0x725: 0x0008, 0x726: 0x0008, 0x727: 0x0008, 0x728: 0x0008, 0x729: 0x0040,
0x72a: 0x0008, 0x72b: 0x0008, 0x72c: 0x0008, 0x72d: 0x0008, 0x72e: 0x0008, 0x72f: 0x0008,
0x730: 0x0008, 0x731: 0x0040, 0x732: 0x0008, 0x733: 0x0008, 0x734: 0x0040, 0x735: 0x0008,
0x736: 0x0008, 0x737: 0x0008, 0x738: 0x0008, 0x739: 0x0008, 0x73a: 0x0040, 0x73b: 0x0040,
0x73c: 0x3308, 0x73d: 0x0008, 0x73e: 0x3008, 0x73f: 0x3008,
// Block 0x1d, offset 0x740
0x740: 0x3008, 0x741: 0x3308, 0x742: 0x3308, 0x743: 0x3308, 0x744: 0x3308, 0x745: 0x3308,
0x746: 0x0040, 0x747: 0x3308, 0x748: 0x3308, 0x749: 0x3008, 0x74a: 0x0040, 0x74b: 0x3008,
0x74c: 0x3008, 0x74d: 0x3b08, 0x74e: 0x0040, 0x74f: 0x0040, 0x750: 0x0008, 0x751: 0x0040,
0x752: 0x0040, 0x753: 0x0040, 0x754: 0x0040, 0x755: 0x0040, 0x756: 0x0040, 0x757: 0x0040,
0x758: 0x0040, 0x759: 0x0040, 0x75a: 0x0040, 0x75b: 0x0040, 0x75c: 0x0040, 0x75d: 0x0040,
0x75e: 0x0040, 0x75f: 0x0040, 0x760: 0x0008, 0x761: 0x0008, 0x762: 0x3308, 0x763: 0x3308,
0x764: 0x0040, 0x765: 0x0040, 0x766: 0x0008, 0x767: 0x0008, 0x768: 0x0008, 0x769: 0x0008,
0x76a: 0x0008, 0x76b: 0x0008, 0x76c: 0x0008, 0x76d: 0x0008, 0x76e: 0x0008, 0x76f: 0x0008,
0x770: 0x0018, 0x771: 0x0018, 0x772: 0x0040, 0x773: 0x0040, 0x774: 0x0040, 0x775: 0x0040,
0x776: 0x0040, 0x777: 0x0040, 0x778: 0x0040, 0x779: 0x0008, 0x77a: 0x3308, 0x77b: 0x3308,
0x77c: 0x3308, 0x77d: 0x3308, 0x77e: 0x3308, 0x77f: 0x3308,
// Block 0x1e, offset 0x780
0x780: 0x0040, 0x781: 0x3308, 0x782: 0x3008, 0x783: 0x3008, 0x784: 0x0040, 0x785: 0x0008,
0x786: 0x0008, 0x787: 0x0008, 0x788: 0x0008, 0x789: 0x0008, 0x78a: 0x0008, 0x78b: 0x0008,
0x78c: 0x0008, 0x78d: 0x0040, 0x78e: 0x0040, 0x78f: 0x0008, 0x790: 0x0008, 0x791: 0x0040,
0x792: 0x0040, 0x793: 0x0008, 0x794: 0x0008, 0x795: 0x0008, 0x796: 0x0008, 0x797: 0x0008,
0x798: 0x0008, 0x799: 0x0008, 0x79a: 0x0008, 0x79b: 0x0008, 0x79c: 0x0008, 0x79d: 0x0008,
0x79e: 0x0008, 0x79f: 0x0008, 0x7a0: 0x0008, 0x7a1: 0x0008, 0x7a2: 0x0008, 0x7a3: 0x0008,
0x7a4: 0x0008, 0x7a5: 0x0008, 0x7a6: 0x0008, 0x7a7: 0x0008, 0x7a8: 0x0008, 0x7a9: 0x0040,
0x7aa: 0x0008, 0x7ab: 0x0008, 0x7ac: 0x0008, 0x7ad: 0x0008, 0x7ae: 0x0008, 0x7af: 0x0008,
0x7b0: 0x0008, 0x7b1: 0x0040, 0x7b2: 0x0008, 0x7b3: 0x0008, 0x7b4: 0x0040, 0x7b5: 0x0008,
0x7b6: 0x0008, 0x7b7: 0x0008, 0x7b8: 0x0008, 0x7b9: 0x0008, 0x7ba: 0x0040, 0x7bb: 0x0040,
0x7bc: 0x3308, 0x7bd: 0x0008, 0x7be: 0x3008, 0x7bf: 0x3308,
// Block 0x1f, offset 0x7c0
0x7c0: 0x3008, 0x7c1: 0x3308, 0x7c2: 0x3308, 0x7c3: 0x3308, 0x7c4: 0x3308, 0x7c5: 0x0040,
0x7c6: 0x0040, 0x7c7: 0x3008, 0x7c8: 0x3008, 0x7c9: 0x0040, 0x7ca: 0x0040, 0x7cb: 0x3008,
0x7cc: 0x3008, 0x7cd: 0x3b08, 0x7ce: 0x0040, 0x7cf: 0x0040, 0x7d0: 0x0040, 0x7d1: 0x0040,
0x7d2: 0x0040, 0x7d3: 0x0040, 0x7d4: 0x0040, 0x7d5: 0x3308, 0x7d6: 0x3308, 0x7d7: 0x3008,
0x7d8: 0x0040, 0x7d9: 0x0040, 0x7da: 0x0040, 0x7db: 0x0040, 0x7dc: 0x01e1, 0x7dd: 0x01e9,
0x7de: 0x0040, 0x7df: 0x0008, 0x7e0: 0x0008, 0x7e1: 0x0008, 0x7e2: 0x3308, 0x7e3: 0x3308,
0x7e4: 0x0040, 0x7e5: 0x0040, 0x7e6: 0x0008, 0x7e7: 0x0008, 0x7e8: 0x0008, 0x7e9: 0x0008,
0x7ea: 0x0008, 0x7eb: 0x0008, 0x7ec: 0x0008, 0x7ed: 0x0008, 0x7ee: 0x0008, 0x7ef: 0x0008,
0x7f0: 0x0018, 0x7f1: 0x0008, 0x7f2: 0x0018, 0x7f3: 0x0018, 0x7f4: 0x0018, 0x7f5: 0x0018,
0x7f6: 0x0018, 0x7f7: 0x0018, 0x7f8: 0x0040, 0x7f9: 0x0040, 0x7fa: 0x0040, 0x7fb: 0x0040,
0x7fc: 0x0040, 0x7fd: 0x0040, 0x7fe: 0x0040, 0x7ff: 0x0040,
// Block 0x20, offset 0x800
0x800: 0x0040, 0x801: 0x0040, 0x802: 0x3308, 0x803: 0x0008, 0x804: 0x0040, 0x805: 0x0008,
0x806: 0x0008, 0x807: 0x0008, 0x808: 0x0008, 0x809: 0x0008, 0x80a: 0x0008, 0x80b: 0x0040,
0x80c: 0x0040, 0x80d: 0x0040, 0x80e: 0x0008, 0x80f: 0x0008, 0x810: 0x0008, 0x811: 0x0040,
0x812: 0x0008, 0x813: 0x0008, 0x814: 0x0008, 0x815: 0x0008, 0x816: 0x0040, 0x817: 0x0040,
0x818: 0x0040, 0x819: 0x0008, 0x81a: 0x0008, 0x81b: 0x0040, 0x81c: 0x0008, 0x81d: 0x0040,
0x81e: 0x0008, 0x81f: 0x0008, 0x820: 0x0040, 0x821: 0x0040, 0x822: 0x0040, 0x823: 0x0008,
0x824: 0x0008, 0x825: 0x0040, 0x826: 0x0040, 0x827: 0x0040, 0x828: 0x0008, 0x829: 0x0008,
0x82a: 0x0008, 0x82b: 0x0040, 0x82c: 0x0040, 0x82d: 0x0040, 0x82e: 0x0008, 0x82f: 0x0008,
0x830: 0x0008, 0x831: 0x0008, 0x832: 0x0008, 0x833: 0x0008, 0x834: 0x0008, 0x835: 0x0008,
0x836: 0x0008, 0x837: 0x0008, 0x838: 0x0008, 0x839: 0x0008, 0x83a: 0x0040, 0x83b: 0x0040,
0x83c: 0x0040, 0x83d: 0x0040, 0x83e: 0x3008, 0x83f: 0x3008,
// Block 0x21, offset 0x840
0x840: 0x3308, 0x841: 0x3008, 0x842: 0x3008, 0x843: 0x3008, 0x844: 0x3008, 0x845: 0x0040,
0x846: 0x3308, 0x847: 0x3308, 0x848: 0x3308, 0x849: 0x0040, 0x84a: 0x3308, 0x84b: 0x3308,
0x84c: 0x3308, 0x84d: 0x3b08, 0x84e: 0x0040, 0x84f: 0x0040, 0x850: 0x0040, 0x851: 0x0040,
0x852: 0x0040, 0x853: 0x0040, 0x854: 0x0040, 0x855: 0x3308, 0x856: 0x3308, 0x857: 0x0040,
0x858: 0x0008, 0x859: 0x0008, 0x85a: 0x0008, 0x85b: 0x0040, 0x85c: 0x0040, 0x85d: 0x0008,
0x85e: 0x0040, 0x85f: 0x0040, 0x860: 0x0008, 0x861: 0x0008, 0x862: 0x3308, 0x863: 0x3308,
0x864: 0x0040, 0x865: 0x0040, 0x866: 0x0008, 0x867: 0x0008, 0x868: 0x0008, 0x869: 0x0008,
0x86a: 0x0008, 0x86b: 0x0008, 0x86c: 0x0008, 0x86d: 0x0008, 0x86e: 0x0008, 0x86f: 0x0008,
0x870: 0x0040, 0x871: 0x0040, 0x872: 0x0040, 0x873: 0x0040, 0x874: 0x0040, 0x875: 0x0040,
0x876: 0x0040, 0x877: 0x0018, 0x878: 0x0018, 0x879: 0x0018, 0x87a: 0x0018, 0x87b: 0x0018,
0x87c: 0x0018, 0x87d: 0x0018, 0x87e: 0x0018, 0x87f: 0x0018,
// Block 0x22, offset 0x880
0x880: 0x0008, 0x881: 0x3308, 0x882: 0x3008, 0x883: 0x3008, 0x884: 0x0018, 0x885: 0x0008,
0x886: 0x0008, 0x887: 0x0008, 0x888: 0x0008, 0x889: 0x0008, 0x88a: 0x0008, 0x88b: 0x0008,
0x88c: 0x0008, 0x88d: 0x0040, 0x88e: 0x0008, 0x88f: 0x0008, 0x890: 0x0008, 0x891: 0x0040,
0x892: 0x0008, 0x893: 0x0008, 0x894: 0x0008, 0x895: 0x0008, 0x896: 0x0008, 0x897: 0x0008,
0x898: 0x0008, 0x899: 0x0008, 0x89a: 0x0008, 0x89b: 0x0008, 0x89c: 0x0008, 0x89d: 0x0008,
0x89e: 0x0008, 0x89f: 0x0008, 0x8a0: 0x0008, 0x8a1: 0x0008, 0x8a2: 0x0008, 0x8a3: 0x0008,
0x8a4: 0x0008, 0x8a5: 0x0008, 0x8a6: 0x0008, 0x8a7: 0x0008, 0x8a8: 0x0008, 0x8a9: 0x0040,
0x8aa: 0x0008, 0x8ab: 0x0008, 0x8ac: 0x0008, 0x8ad: 0x0008, 0x8ae: 0x0008, 0x8af: 0x0008,
0x8b0: 0x0008, 0x8b1: 0x0008, 0x8b2: 0x0008, 0x8b3: 0x0008, 0x8b4: 0x0040, 0x8b5: 0x0008,
0x8b6: 0x0008, 0x8b7: 0x0008, 0x8b8: 0x0008, 0x8b9: 0x0008, 0x8ba: 0x0040, 0x8bb: 0x0040,
0x8bc: 0x3308, 0x8bd: 0x0008, 0x8be: 0x3008, 0x8bf: 0x3308,
// Block 0x23, offset 0x8c0
0x8c0: 0x3008, 0x8c1: 0x3008, 0x8c2: 0x3008, 0x8c3: 0x3008, 0x8c4: 0x3008, 0x8c5: 0x0040,
0x8c6: 0x3308, 0x8c7: 0x3008, 0x8c8: 0x3008, 0x8c9: 0x0040, 0x8ca: 0x3008, 0x8cb: 0x3008,
0x8cc: 0x3308, 0x8cd: 0x3b08, 0x8ce: 0x0040, 0x8cf: 0x0040, 0x8d0: 0x0040, 0x8d1: 0x0040,
0x8d2: 0x0040, 0x8d3: 0x0040, 0x8d4: 0x0040, 0x8d5: 0x3008, 0x8d6: 0x3008, 0x8d7: 0x0040,
0x8d8: 0x0040, 0x8d9: 0x0040, 0x8da: 0x0040, 0x8db: 0x0040, 0x8dc: 0x0040, 0x8dd: 0x0008,
0x8de: 0x0008, 0x8df: 0x0040, 0x8e0: 0x0008, 0x8e1: 0x0008, 0x8e2: 0x3308, 0x8e3: 0x3308,
0x8e4: 0x0040, 0x8e5: 0x0040, 0x8e6: 0x0008, 0x8e7: 0x0008, 0x8e8: 0x0008, 0x8e9: 0x0008,
0x8ea: 0x0008, 0x8eb: 0x0008, 0x8ec: 0x0008, 0x8ed: 0x0008, 0x8ee: 0x0008, 0x8ef: 0x0008,
0x8f0: 0x0040, 0x8f1: 0x0008, 0x8f2: 0x0008, 0x8f3: 0x3008, 0x8f4: 0x0040, 0x8f5: 0x0040,
0x8f6: 0x0040, 0x8f7: 0x0040, 0x8f8: 0x0040, 0x8f9: 0x0040, 0x8fa: 0x0040, 0x8fb: 0x0040,
0x8fc: 0x0040, 0x8fd: 0x0040, 0x8fe: 0x0040, 0x8ff: 0x0040,
// Block 0x24, offset 0x900
0x900: 0x3008, 0x901: 0x3308, 0x902: 0x3308, 0x903: 0x3308, 0x904: 0x3308, 0x905: 0x0040,
0x906: 0x3008, 0x907: 0x3008, 0x908: 0x3008, 0x909: 0x0040, 0x90a: 0x3008, 0x90b: 0x3008,
0x90c: 0x3008, 0x90d: 0x3b08, 0x90e: 0x0008, 0x90f: 0x0018, 0x910: 0x0040, 0x911: 0x0040,
0x912: 0x0040, 0x913: 0x0040, 0x914: 0x0008, 0x915: 0x0008, 0x916: 0x0008, 0x917: 0x3008,
0x918: 0x0018, 0x919: 0x0018, 0x91a: 0x0018, 0x91b: 0x0018, 0x91c: 0x0018, 0x91d: 0x0018,
0x91e: 0x0018, 0x91f: 0x0008, 0x920: 0x0008, 0x921: 0x0008, 0x922: 0x3308, 0x923: 0x3308,
0x924: 0x0040, 0x925: 0x0040, 0x926: 0x0008, 0x927: 0x0008, 0x928: 0x0008, 0x929: 0x0008,
0x92a: 0x0008, 0x92b: 0x0008, 0x92c: 0x0008, 0x92d: 0x0008, 0x92e: 0x0008, 0x92f: 0x0008,
0x930: 0x0018, 0x931: 0x0018, 0x932: 0x0018, 0x933: 0x0018, 0x934: 0x0018, 0x935: 0x0018,
0x936: 0x0018, 0x937: 0x0018, 0x938: 0x0018, 0x939: 0x0018, 0x93a: 0x0008, 0x93b: 0x0008,
0x93c: 0x0008, 0x93d: 0x0008, 0x93e: 0x0008, 0x93f: 0x0008,
// Block 0x25, offset 0x940
0x940: 0x0040, 0x941: 0x0008, 0x942: 0x0008, 0x943: 0x0040, 0x944: 0x0008, 0x945: 0x0040,
0x946: 0x0008, 0x947: 0x0008, 0x948: 0x0008, 0x949: 0x0008, 0x94a: 0x0008, 0x94b: 0x0040,
0x94c: 0x0008, 0x94d: 0x0008, 0x94e: 0x0008, 0x94f: 0x0008, 0x950: 0x0008, 0x951: 0x0008,
0x952: 0x0008, 0x953: 0x0008, 0x954: 0x0008, 0x955: 0x0008, 0x956: 0x0008, 0x957: 0x0008,
0x958: 0x0008, 0x959: 0x0008, 0x95a: 0x0008, 0x95b: 0x0008, 0x95c: 0x0008, 0x95d: 0x0008,
0x95e: 0x0008, 0x95f: 0x0008, 0x960: 0x0008, 0x961: 0x0008, 0x962: 0x0008, 0x963: 0x0008,
0x964: 0x0040, 0x965: 0x0008, 0x966: 0x0040, 0x967: 0x0008, 0x968: 0x0008, 0x969: 0x0008,
0x96a: 0x0008, 0x96b: 0x0008, 0x96c: 0x0008, 0x96d: 0x0008, 0x96e: 0x0008, 0x96f: 0x0008,
0x970: 0x0008, 0x971: 0x3308, 0x972: 0x0008, 0x973: 0x01f9, 0x974: 0x3308, 0x975: 0x3308,
0x976: 0x3308, 0x977: 0x3308, 0x978: 0x3308, 0x979: 0x3308, 0x97a: 0x3b08, 0x97b: 0x3308,
0x97c: 0x3308, 0x97d: 0x0008, 0x97e: 0x0040, 0x97f: 0x0040,
// Block 0x26, offset 0x980
0x980: 0x0008, 0x981: 0x0008, 0x982: 0x0008, 0x983: 0x0211, 0x984: 0x0008, 0x985: 0x0008,
0x986: 0x0008, 0x987: 0x0008, 0x988: 0x0040, 0x989: 0x0008, 0x98a: 0x0008, 0x98b: 0x0008,
0x98c: 0x0008, 0x98d: 0x0219, 0x98e: 0x0008, 0x98f: 0x0008, 0x990: 0x0008, 0x991: 0x0008,
0x992: 0x0221, 0x993: 0x0008, 0x994: 0x0008, 0x995: 0x0008, 0x996: 0x0008, 0x997: 0x0229,
0x998: 0x0008, 0x999: 0x0008, 0x99a: 0x0008, 0x99b: 0x0008, 0x99c: 0x0231, 0x99d: 0x0008,
0x99e: 0x0008, 0x99f: 0x0008, 0x9a0: 0x0008, 0x9a1: 0x0008, 0x9a2: 0x0008, 0x9a3: 0x0008,
0x9a4: 0x0008, 0x9a5: 0x0008, 0x9a6: 0x0008, 0x9a7: 0x0008, 0x9a8: 0x0008, 0x9a9: 0x0239,
0x9aa: 0x0008, 0x9ab: 0x0008, 0x9ac: 0x0008, 0x9ad: 0x0040, 0x9ae: 0x0040, 0x9af: 0x0040,
0x9b0: 0x0040, 0x9b1: 0x3308, 0x9b2: 0x3308, 0x9b3: 0x0241, 0x9b4: 0x3308, 0x9b5: 0x0249,
0x9b6: 0x0251, 0x9b7: 0x0259, 0x9b8: 0x0261, 0x9b9: 0x0269, 0x9ba: 0x3308, 0x9bb: 0x3308,
0x9bc: 0x3308, 0x9bd: 0x3308, 0x9be: 0x3308, 0x9bf: 0x3008,
// Block 0x27, offset 0x9c0
0x9c0: 0x3308, 0x9c1: 0x0271, 0x9c2: 0x3308, 0x9c3: 0x3308, 0x9c4: 0x3b08, 0x9c5: 0x0018,
0x9c6: 0x3308, 0x9c7: 0x3308, 0x9c8: 0x0008, 0x9c9: 0x0008, 0x9ca: 0x0008, 0x9cb: 0x0008,
0x9cc: 0x0008, 0x9cd: 0x3308, 0x9ce: 0x3308, 0x9cf: 0x3308, 0x9d0: 0x3308, 0x9d1: 0x3308,
0x9d2: 0x3308, 0x9d3: 0x0279, 0x9d4: 0x3308, 0x9d5: 0x3308, 0x9d6: 0x3308, 0x9d7: 0x3308,
0x9d8: 0x0040, 0x9d9: 0x3308, 0x9da: 0x3308, 0x9db: 0x3308, 0x9dc: 0x3308, 0x9dd: 0x0281,
0x9de: 0x3308, 0x9df: 0x3308, 0x9e0: 0x3308, 0x9e1: 0x3308, 0x9e2: 0x0289, 0x9e3: 0x3308,
0x9e4: 0x3308, 0x9e5: 0x3308, 0x9e6: 0x3308, 0x9e7: 0x0291, 0x9e8: 0x3308, 0x9e9: 0x3308,
0x9ea: 0x3308, 0x9eb: 0x3308, 0x9ec: 0x0299, 0x9ed: 0x3308, 0x9ee: 0x3308, 0x9ef: 0x3308,
0x9f0: 0x3308, 0x9f1: 0x3308, 0x9f2: 0x3308, 0x9f3: 0x3308, 0x9f4: 0x3308, 0x9f5: 0x3308,
0x9f6: 0x3308, 0x9f7: 0x3308, 0x9f8: 0x3308, 0x9f9: 0x02a1, 0x9fa: 0x3308, 0x9fb: 0x3308,
0x9fc: 0x3308, 0x9fd: 0x0040, 0x9fe: 0x0018, 0x9ff: 0x0018,
// Block 0x28, offset 0xa00
0xa00: 0x0008, 0xa01: 0x0008, 0xa02: 0x0008, 0xa03: 0x0008, 0xa04: 0x0008, 0xa05: 0x0008,
0xa06: 0x0008, 0xa07: 0x0008, 0xa08: 0x0008, 0xa09: 0x0008, 0xa0a: 0x0008, 0xa0b: 0x0008,
0xa0c: 0x0008, 0xa0d: 0x0008, 0xa0e: 0x0008, 0xa0f: 0x0008, 0xa10: 0x0008, 0xa11: 0x0008,
0xa12: 0x0008, 0xa13: 0x0008, 0xa14: 0x0008, 0xa15: 0x0008, 0xa16: 0x0008, 0xa17: 0x0008,
0xa18: 0x0008, 0xa19: 0x0008, 0xa1a: 0x0008, 0xa1b: 0x0008, 0xa1c: 0x0008, 0xa1d: 0x0008,
0xa1e: 0x0008, 0xa1f: 0x0008, 0xa20: 0x0008, 0xa21: 0x0008, 0xa22: 0x0008, 0xa23: 0x0008,
0xa24: 0x0008, 0xa25: 0x0008, 0xa26: 0x0008, 0xa27: 0x0008, 0xa28: 0x0008, 0xa29: 0x0008,
0xa2a: 0x0008, 0xa2b: 0x0008, 0xa2c: 0x0019, 0xa2d: 0x02e1, 0xa2e: 0x02e9, 0xa2f: 0x0008,
0xa30: 0x02f1, 0xa31: 0x02f9, 0xa32: 0x0301, 0xa33: 0x0309, 0xa34: 0x00a9, 0xa35: 0x0311,
0xa36: 0x00b1, 0xa37: 0x0319, 0xa38: 0x0101, 0xa39: 0x0321, 0xa3a: 0x0329, 0xa3b: 0x0008,
0xa3c: 0x0051, 0xa3d: 0x0331, 0xa3e: 0x0339, 0xa3f: 0x00b9,
// Block 0x29, offset 0xa40
0xa40: 0x0341, 0xa41: 0x0349, 0xa42: 0x00c1, 0xa43: 0x0019, 0xa44: 0x0351, 0xa45: 0x0359,
0xa46: 0x05b5, 0xa47: 0x02e9, 0xa48: 0x02f1, 0xa49: 0x02f9, 0xa4a: 0x0361, 0xa4b: 0x0369,
0xa4c: 0x0371, 0xa4d: 0x0309, 0xa4e: 0x0008, 0xa4f: 0x0319, 0xa50: 0x0321, 0xa51: 0x0379,
0xa52: 0x0051, 0xa53: 0x0381, 0xa54: 0x05cd, 0xa55: 0x05cd, 0xa56: 0x0339, 0xa57: 0x0341,
0xa58: 0x0349, 0xa59: 0x05b5, 0xa5a: 0x0389, 0xa5b: 0x0391, 0xa5c: 0x05e5, 0xa5d: 0x0399,
0xa5e: 0x03a1, 0xa5f: 0x03a9, 0xa60: 0x03b1, 0xa61: 0x03b9, 0xa62: 0x0311, 0xa63: 0x00b9,
0xa64: 0x0349, 0xa65: 0x0391, 0xa66: 0x0399, 0xa67: 0x03a1, 0xa68: 0x03c1, 0xa69: 0x03b1,
0xa6a: 0x03b9, 0xa6b: 0x0008, 0xa6c: 0x0008, 0xa6d: 0x0008, 0xa6e: 0x0008, 0xa6f: 0x0008,
0xa70: 0x0008, 0xa71: 0x0008, 0xa72: 0x0008, 0xa73: 0x0008, 0xa74: 0x0008, 0xa75: 0x0008,
0xa76: 0x0008, 0xa77: 0x0008, 0xa78: 0x03c9, 0xa79: 0x0008, 0xa7a: 0x0008, 0xa7b: 0x0008,
0xa7c: 0x0008, 0xa7d: 0x0008, 0xa7e: 0x0008, 0xa7f: 0x0008,
// Block 0x2a, offset 0xa80
0xa80: 0x0008, 0xa81: 0x0008, 0xa82: 0x0008, 0xa83: 0x0008, 0xa84: 0x0008, 0xa85: 0x0008,
0xa86: 0x0008, 0xa87: 0x0008, 0xa88: 0x0008, 0xa89: 0x0008, 0xa8a: 0x0008, 0xa8b: 0x0008,
0xa8c: 0x0008, 0xa8d: 0x0008, 0xa8e: 0x0008, 0xa8f: 0x0008, 0xa90: 0x0008, 0xa91: 0x0008,
0xa92: 0x0008, 0xa93: 0x0008, 0xa94: 0x0008, 0xa95: 0x0008, 0xa96: 0x0008, 0xa97: 0x0008,
0xa98: 0x0008, 0xa99: 0x0008, 0xa9a: 0x0008, 0xa9b: 0x03d1, 0xa9c: 0x03d9, 0xa9d: 0x03e1,
0xa9e: 0x03e9, 0xa9f: 0x0371, 0xaa0: 0x03f1, 0xaa1: 0x03f9, 0xaa2: 0x0401, 0xaa3: 0x0409,
0xaa4: 0x0411, 0xaa5: 0x0419, 0xaa6: 0x0421, 0xaa7: 0x05fd, 0xaa8: 0x0429, 0xaa9: 0x0431,
0xaaa: 0xe17d, 0xaab: 0x0439, 0xaac: 0x0441, 0xaad: 0x0449, 0xaae: 0x0451, 0xaaf: 0x0459,
0xab0: 0x0461, 0xab1: 0x0469, 0xab2: 0x0471, 0xab3: 0x0479, 0xab4: 0x0481, 0xab5: 0x0489,
0xab6: 0x0491, 0xab7: 0x0499, 0xab8: 0x0615, 0xab9: 0x04a1, 0xaba: 0x04a9, 0xabb: 0x04b1,
0xabc: 0x04b9, 0xabd: 0x04c1, 0xabe: 0x04c9, 0xabf: 0x04d1,
// Block 0x2b, offset 0xac0
0xac0: 0xe00d, 0xac1: 0x0008, 0xac2: 0xe00d, 0xac3: 0x0008, 0xac4: 0xe00d, 0xac5: 0x0008,
0xac6: 0xe00d, 0xac7: 0x0008, 0xac8: 0xe00d, 0xac9: 0x0008, 0xaca: 0xe00d, 0xacb: 0x0008,
0xacc: 0xe00d, 0xacd: 0x0008, 0xace: 0xe00d, 0xacf: 0x0008, 0xad0: 0xe00d, 0xad1: 0x0008,
0xad2: 0xe00d, 0xad3: 0x0008, 0xad4: 0xe00d, 0xad5: 0x0008, 0xad6: 0xe00d, 0xad7: 0x0008,
0xad8: 0xe00d, 0xad9: 0x0008, 0xada: 0xe00d, 0xadb: 0x0008, 0xadc: 0xe00d, 0xadd: 0x0008,
0xade: 0xe00d, 0xadf: 0x0008, 0xae0: 0xe00d, 0xae1: 0x0008, 0xae2: 0xe00d, 0xae3: 0x0008,
0xae4: 0xe00d, 0xae5: 0x0008, 0xae6: 0xe00d, 0xae7: 0x0008, 0xae8: 0xe00d, 0xae9: 0x0008,
0xaea: 0xe00d, 0xaeb: 0x0008, 0xaec: 0xe00d, 0xaed: 0x0008, 0xaee: 0xe00d, 0xaef: 0x0008,
0xaf0: 0xe00d, 0xaf1: 0x0008, 0xaf2: 0xe00d, 0xaf3: 0x0008, 0xaf4: 0xe00d, 0xaf5: 0x0008,
0xaf6: 0xe00d, 0xaf7: 0x0008, 0xaf8: 0xe00d, 0xaf9: 0x0008, 0xafa: 0xe00d, 0xafb: 0x0008,
0xafc: 0xe00d, 0xafd: 0x0008, 0xafe: 0xe00d, 0xaff: 0x0008,
// Block 0x2c, offset 0xb00
0xb00: 0xe00d, 0xb01: 0x0008, 0xb02: 0xe00d, 0xb03: 0x0008, 0xb04: 0xe00d, 0xb05: 0x0008,
0xb06: 0xe00d, 0xb07: 0x0008, 0xb08: 0xe00d, 0xb09: 0x0008, 0xb0a: 0xe00d, 0xb0b: 0x0008,
0xb0c: 0xe00d, 0xb0d: 0x0008, 0xb0e: 0xe00d, 0xb0f: 0x0008, 0xb10: 0xe00d, 0xb11: 0x0008,
0xb12: 0xe00d, 0xb13: 0x0008, 0xb14: 0xe00d, 0xb15: 0x0008, 0xb16: 0x0008, 0xb17: 0x0008,
0xb18: 0x0008, 0xb19: 0x0008, 0xb1a: 0x062d, 0xb1b: 0x064d, 0xb1c: 0x0008, 0xb1d: 0x0008,
0xb1e: 0x04d9, 0xb1f: 0x0008, 0xb20: 0xe00d, 0xb21: 0x0008, 0xb22: 0xe00d, 0xb23: 0x0008,
0xb24: 0xe00d, 0xb25: 0x0008, 0xb26: 0xe00d, 0xb27: 0x0008, 0xb28: 0xe00d, 0xb29: 0x0008,
0xb2a: 0xe00d, 0xb2b: 0x0008, 0xb2c: 0xe00d, 0xb2d: 0x0008, 0xb2e: 0xe00d, 0xb2f: 0x0008,
0xb30: 0xe00d, 0xb31: 0x0008, 0xb32: 0xe00d, 0xb33: 0x0008, 0xb34: 0xe00d, 0xb35: 0x0008,
0xb36: 0xe00d, 0xb37: 0x0008, 0xb38: 0xe00d, 0xb39: 0x0008, 0xb3a: 0xe00d, 0xb3b: 0x0008,
0xb3c: 0xe00d, 0xb3d: 0x0008, 0xb3e: 0xe00d, 0xb3f: 0x0008,
// Block 0x2d, offset 0xb40
0xb40: 0x0008, 0xb41: 0x0008, 0xb42: 0x0008, 0xb43: 0x0008, 0xb44: 0x0008, 0xb45: 0x0008,
0xb46: 0x0040, 0xb47: 0x0040, 0xb48: 0xe045, 0xb49: 0xe045, 0xb4a: 0xe045, 0xb4b: 0xe045,
0xb4c: 0xe045, 0xb4d: 0xe045, 0xb4e: 0x0040, 0xb4f: 0x0040, 0xb50: 0x0008, 0xb51: 0x0008,
0xb52: 0x0008, 0xb53: 0x0008, 0xb54: 0x0008, 0xb55: 0x0008, 0xb56: 0x0008, 0xb57: 0x0008,
0xb58: 0x0040, 0xb59: 0xe045, 0xb5a: 0x0040, 0xb5b: 0xe045, 0xb5c: 0x0040, 0xb5d: 0xe045,
0xb5e: 0x0040, 0xb5f: 0xe045, 0xb60: 0x0008, 0xb61: 0x0008, 0xb62: 0x0008, 0xb63: 0x0008,
0xb64: 0x0008, 0xb65: 0x0008, 0xb66: 0x0008, 0xb67: 0x0008, 0xb68: 0xe045, 0xb69: 0xe045,
0xb6a: 0xe045, 0xb6b: 0xe045, 0xb6c: 0xe045, 0xb6d: 0xe045, 0xb6e: 0xe045, 0xb6f: 0xe045,
0xb70: 0x0008, 0xb71: 0x04e1, 0xb72: 0x0008, 0xb73: 0x04e9, 0xb74: 0x0008, 0xb75: 0x04f1,
0xb76: 0x0008, 0xb77: 0x04f9, 0xb78: 0x0008, 0xb79: 0x0501, 0xb7a: 0x0008, 0xb7b: 0x0509,
0xb7c: 0x0008, 0xb7d: 0x0511, 0xb7e: 0x0040, 0xb7f: 0x0040,
// Block 0x2e, offset 0xb80
0xb80: 0x0519, 0xb81: 0x0521, 0xb82: 0x0529, 0xb83: 0x0531, 0xb84: 0x0539, 0xb85: 0x0541,
0xb86: 0x0549, 0xb87: 0x0551, 0xb88: 0x0519, 0xb89: 0x0521, 0xb8a: 0x0529, 0xb8b: 0x0531,
0xb8c: 0x0539, 0xb8d: 0x0541, 0xb8e: 0x0549, 0xb8f: 0x0551, 0xb90: 0x0559, 0xb91: 0x0561,
0xb92: 0x0569, 0xb93: 0x0571, 0xb94: 0x0579, 0xb95: 0x0581, 0xb96: 0x0589, 0xb97: 0x0591,
0xb98: 0x0559, 0xb99: 0x0561, 0xb9a: 0x0569, 0xb9b: 0x0571, 0xb9c: 0x0579, 0xb9d: 0x0581,
0xb9e: 0x0589, 0xb9f: 0x0591, 0xba0: 0x0599, 0xba1: 0x05a1, 0xba2: 0x05a9, 0xba3: 0x05b1,
0xba4: 0x05b9, 0xba5: 0x05c1, 0xba6: 0x05c9, 0xba7: 0x05d1, 0xba8: 0x0599, 0xba9: 0x05a1,
0xbaa: 0x05a9, 0xbab: 0x05b1, 0xbac: 0x05b9, 0xbad: 0x05c1, 0xbae: 0x05c9, 0xbaf: 0x05d1,
0xbb0: 0x0008, 0xbb1: 0x0008, 0xbb2: 0x05d9, 0xbb3: 0x05e1, 0xbb4: 0x05e9, 0xbb5: 0x0040,
0xbb6: 0x0008, 0xbb7: 0x05f1, 0xbb8: 0xe045, 0xbb9: 0xe045, 0xbba: 0x0665, 0xbbb: 0x04e1,
0xbbc: 0x05e1, 0xbbd: 0x067e, 0xbbe: 0x05f9, 0xbbf: 0x069e,
// Block 0x2f, offset 0xbc0
0xbc0: 0x06be, 0xbc1: 0x0602, 0xbc2: 0x0609, 0xbc3: 0x0611, 0xbc4: 0x0619, 0xbc5: 0x0040,
0xbc6: 0x0008, 0xbc7: 0x0621, 0xbc8: 0x06dd, 0xbc9: 0x04e9, 0xbca: 0x06f5, 0xbcb: 0x04f1,
0xbcc: 0x0611, 0xbcd: 0x062a, 0xbce: 0x0632, 0xbcf: 0x063a, 0xbd0: 0x0008, 0xbd1: 0x0008,
0xbd2: 0x0008, 0xbd3: 0x0641, 0xbd4: 0x0040, 0xbd5: 0x0040, 0xbd6: 0x0008, 0xbd7: 0x0008,
0xbd8: 0xe045, 0xbd9: 0xe045, 0xbda: 0x070d, 0xbdb: 0x04f9, 0xbdc: 0x0040, 0xbdd: 0x064a,
0xbde: 0x0652, 0xbdf: 0x065a, 0xbe0: 0x0008, 0xbe1: 0x0008, 0xbe2: 0x0008, 0xbe3: 0x0661,
0xbe4: 0x0008, 0xbe5: 0x0008, 0xbe6: 0x0008, 0xbe7: 0x0008, 0xbe8: 0xe045, 0xbe9: 0xe045,
0xbea: 0x0725, 0xbeb: 0x0509, 0xbec: 0xe04d, 0xbed: 0x066a, 0xbee: 0x012a, 0xbef: 0x0672,
0xbf0: 0x0040, 0xbf1: 0x0040, 0xbf2: 0x0679, 0xbf3: 0x0681, 0xbf4: 0x0689, 0xbf5: 0x0040,
0xbf6: 0x0008, 0xbf7: 0x0691, 0xbf8: 0x073d, 0xbf9: 0x0501, 0xbfa: 0x0515, 0xbfb: 0x0511,
0xbfc: 0x0681, 0xbfd: 0x0756, 0xbfe: 0x0776, 0xbff: 0x0040,
// Block 0x30, offset 0xc00
0xc00: 0x000a, 0xc01: 0x000a, 0xc02: 0x000a, 0xc03: 0x000a, 0xc04: 0x000a, 0xc05: 0x000a,
0xc06: 0x000a, 0xc07: 0x000a, 0xc08: 0x000a, 0xc09: 0x000a, 0xc0a: 0x000a, 0xc0b: 0x03c0,
0xc0c: 0x0003, 0xc0d: 0x0003, 0xc0e: 0x0340, 0xc0f: 0x0b40, 0xc10: 0x0018, 0xc11: 0xe00d,
0xc12: 0x0018, 0xc13: 0x0018, 0xc14: 0x0018, 0xc15: 0x0018, 0xc16: 0x0018, 0xc17: 0x0796,
0xc18: 0x0018, 0xc19: 0x0018, 0xc1a: 0x0018, 0xc1b: 0x0018, 0xc1c: 0x0018, 0xc1d: 0x0018,
0xc1e: 0x0018, 0xc1f: 0x0018, 0xc20: 0x0018, 0xc21: 0x0018, 0xc22: 0x0018, 0xc23: 0x0018,
0xc24: 0x0040, 0xc25: 0x0040, 0xc26: 0x0040, 0xc27: 0x0018, 0xc28: 0x0040, 0xc29: 0x0040,
0xc2a: 0x0340, 0xc2b: 0x0340, 0xc2c: 0x0340, 0xc2d: 0x0340, 0xc2e: 0x0340, 0xc2f: 0x000a,
0xc30: 0x0018, 0xc31: 0x0018, 0xc32: 0x0018, 0xc33: 0x0699, 0xc34: 0x06a1, 0xc35: 0x0018,
0xc36: 0x06a9, 0xc37: 0x06b1, 0xc38: 0x0018, 0xc39: 0x0018, 0xc3a: 0x0018, 0xc3b: 0x0018,
0xc3c: 0x06ba, 0xc3d: 0x0018, 0xc3e: 0x07b6, 0xc3f: 0x0018,
// Block 0x31, offset 0xc40
0xc40: 0x0018, 0xc41: 0x0018, 0xc42: 0x0018, 0xc43: 0x0018, 0xc44: 0x0018, 0xc45: 0x0018,
0xc46: 0x0018, 0xc47: 0x06c2, 0xc48: 0x06ca, 0xc49: 0x06d2, 0xc4a: 0x0018, 0xc4b: 0x0018,
0xc4c: 0x0018, 0xc4d: 0x0018, 0xc4e: 0x0018, 0xc4f: 0x0018, 0xc50: 0x0018, 0xc51: 0x0018,
0xc52: 0x0018, 0xc53: 0x0018, 0xc54: 0x0018, 0xc55: 0x0018, 0xc56: 0x0018, 0xc57: 0x06d9,
0xc58: 0x0018, 0xc59: 0x0018, 0xc5a: 0x0018, 0xc5b: 0x0018, 0xc5c: 0x0018, 0xc5d: 0x0018,
0xc5e: 0x0018, 0xc5f: 0x000a, 0xc60: 0x03c0, 0xc61: 0x0340, 0xc62: 0x0340, 0xc63: 0x0340,
0xc64: 0x03c0, 0xc65: 0x0040, 0xc66: 0x0040, 0xc67: 0x0040, 0xc68: 0x0040, 0xc69: 0x0040,
0xc6a: 0x0340, 0xc6b: 0x0340, 0xc6c: 0x0340, 0xc6d: 0x0340, 0xc6e: 0x0340, 0xc6f: 0x0340,
0xc70: 0x06e1, 0xc71: 0x0311, 0xc72: 0x0040, 0xc73: 0x0040, 0xc74: 0x06e9, 0xc75: 0x06f1,
0xc76: 0x06f9, 0xc77: 0x0701, 0xc78: 0x0709, 0xc79: 0x0711, 0xc7a: 0x071a, 0xc7b: 0x07d5,
0xc7c: 0x0722, 0xc7d: 0x072a, 0xc7e: 0x0732, 0xc7f: 0x0329,
// Block 0x32, offset 0xc80
0xc80: 0x06e1, 0xc81: 0x0049, 0xc82: 0x0029, 0xc83: 0x0031, 0xc84: 0x06e9, 0xc85: 0x06f1,
0xc86: 0x06f9, 0xc87: 0x0701, 0xc88: 0x0709, 0xc89: 0x0711, 0xc8a: 0x071a, 0xc8b: 0x07ed,
0xc8c: 0x0722, 0xc8d: 0x072a, 0xc8e: 0x0732, 0xc8f: 0x0040, 0xc90: 0x0019, 0xc91: 0x02f9,
0xc92: 0x0051, 0xc93: 0x0109, 0xc94: 0x0361, 0xc95: 0x00a9, 0xc96: 0x0319, 0xc97: 0x0101,
0xc98: 0x0321, 0xc99: 0x0329, 0xc9a: 0x0339, 0xc9b: 0x0089, 0xc9c: 0x0341, 0xc9d: 0x0040,
0xc9e: 0x0040, 0xc9f: 0x0040, 0xca0: 0x0018, 0xca1: 0x0018, 0xca2: 0x0018, 0xca3: 0x0018,
0xca4: 0x0018, 0xca5: 0x0018, 0xca6: 0x0018, 0xca7: 0x0018, 0xca8: 0x0739, 0xca9: 0x0018,
0xcaa: 0x0018, 0xcab: 0x0018, 0xcac: 0x0018, 0xcad: 0x0018, 0xcae: 0x0018, 0xcaf: 0x0018,
0xcb0: 0x0018, 0xcb1: 0x0018, 0xcb2: 0x0018, 0xcb3: 0x0018, 0xcb4: 0x0018, 0xcb5: 0x0018,
0xcb6: 0x0018, 0xcb7: 0x0018, 0xcb8: 0x0018, 0xcb9: 0x0018, 0xcba: 0x0018, 0xcbb: 0x0018,
0xcbc: 0x0018, 0xcbd: 0x0018, 0xcbe: 0x0018, 0xcbf: 0x0018,
// Block 0x33, offset 0xcc0
0xcc0: 0x0806, 0xcc1: 0x0826, 0xcc2: 0x03d9, 0xcc3: 0x0845, 0xcc4: 0x0018, 0xcc5: 0x0866,
0xcc6: 0x0886, 0xcc7: 0x0369, 0xcc8: 0x0018, 0xcc9: 0x08a5, 0xcca: 0x0309, 0xccb: 0x00a9,
0xccc: 0x00a9, 0xccd: 0x00a9, 0xcce: 0x00a9, 0xccf: 0x0741, 0xcd0: 0x0311, 0xcd1: 0x0311,
0xcd2: 0x0101, 0xcd3: 0x0101, 0xcd4: 0x0018, 0xcd5: 0x0329, 0xcd6: 0x0749, 0xcd7: 0x0018,
0xcd8: 0x0018, 0xcd9: 0x0339, 0xcda: 0x0751, 0xcdb: 0x00b9, 0xcdc: 0x00b9, 0xcdd: 0x00b9,
0xcde: 0x0018, 0xcdf: 0x0018, 0xce0: 0x0759, 0xce1: 0x08c5, 0xce2: 0x0761, 0xce3: 0x0018,
0xce4: 0x04b1, 0xce5: 0x0018, 0xce6: 0x0769, 0xce7: 0x0018, 0xce8: 0x04b1, 0xce9: 0x0018,
0xcea: 0x0319, 0xceb: 0x0771, 0xcec: 0x02e9, 0xced: 0x03d9, 0xcee: 0x0018, 0xcef: 0x02f9,
0xcf0: 0x02f9, 0xcf1: 0x03f1, 0xcf2: 0x0040, 0xcf3: 0x0321, 0xcf4: 0x0051, 0xcf5: 0x0779,
0xcf6: 0x0781, 0xcf7: 0x0789, 0xcf8: 0x0791, 0xcf9: 0x0311, 0xcfa: 0x0018, 0xcfb: 0x08e5,
0xcfc: 0x0799, 0xcfd: 0x03a1, 0xcfe: 0x03a1, 0xcff: 0x0799,
// Block 0x34, offset 0xd00
0xd00: 0x0905, 0xd01: 0x0018, 0xd02: 0x0018, 0xd03: 0x0018, 0xd04: 0x0018, 0xd05: 0x02f1,
0xd06: 0x02f1, 0xd07: 0x02f9, 0xd08: 0x0311, 0xd09: 0x00b1, 0xd0a: 0x0018, 0xd0b: 0x0018,
0xd0c: 0x0018, 0xd0d: 0x0018, 0xd0e: 0x0008, 0xd0f: 0x0018, 0xd10: 0x07a1, 0xd11: 0x07a9,
0xd12: 0x07b1, 0xd13: 0x07b9, 0xd14: 0x07c1, 0xd15: 0x07c9, 0xd16: 0x07d1, 0xd17: 0x07d9,
0xd18: 0x07e1, 0xd19: 0x07e9, 0xd1a: 0x07f1, 0xd1b: 0x07f9, 0xd1c: 0x0801, 0xd1d: 0x0809,
0xd1e: 0x0811, 0xd1f: 0x0819, 0xd20: 0x0311, 0xd21: 0x0821, 0xd22: 0x091d, 0xd23: 0x0829,
0xd24: 0x0391, 0xd25: 0x0831, 0xd26: 0x093d, 0xd27: 0x0839, 0xd28: 0x0841, 0xd29: 0x0109,
0xd2a: 0x0849, 0xd2b: 0x095d, 0xd2c: 0x0101, 0xd2d: 0x03d9, 0xd2e: 0x02f1, 0xd2f: 0x0321,
0xd30: 0x0311, 0xd31: 0x0821, 0xd32: 0x097d, 0xd33: 0x0829, 0xd34: 0x0391, 0xd35: 0x0831,
0xd36: 0x099d, 0xd37: 0x0839, 0xd38: 0x0841, 0xd39: 0x0109, 0xd3a: 0x0849, 0xd3b: 0x09bd,
0xd3c: 0x0101, 0xd3d: 0x03d9, 0xd3e: 0x02f1, 0xd3f: 0x0321,
// Block 0x35, offset 0xd40
0xd40: 0x0018, 0xd41: 0x0018, 0xd42: 0x0018, 0xd43: 0x0018, 0xd44: 0x0018, 0xd45: 0x0018,
0xd46: 0x0018, 0xd47: 0x0018, 0xd48: 0x0018, 0xd49: 0x0018, 0xd4a: 0x0018, 0xd4b: 0x0040,
0xd4c: 0x0040, 0xd4d: 0x0040, 0xd4e: 0x0040, 0xd4f: 0x0040, 0xd50: 0x0040, 0xd51: 0x0040,
0xd52: 0x0040, 0xd53: 0x0040, 0xd54: 0x0040, 0xd55: 0x0040, 0xd56: 0x0040, 0xd57: 0x0040,
0xd58: 0x0040, 0xd59: 0x0040, 0xd5a: 0x0040, 0xd5b: 0x0040, 0xd5c: 0x0040, 0xd5d: 0x0040,
0xd5e: 0x0040, 0xd5f: 0x0040, 0xd60: 0x0049, 0xd61: 0x0029, 0xd62: 0x0031, 0xd63: 0x06e9,
0xd64: 0x06f1, 0xd65: 0x06f9, 0xd66: 0x0701, 0xd67: 0x0709, 0xd68: 0x0711, 0xd69: 0x0879,
0xd6a: 0x0881, 0xd6b: 0x0889, 0xd6c: 0x0891, 0xd6d: 0x0899, 0xd6e: 0x08a1, 0xd6f: 0x08a9,
0xd70: 0x08b1, 0xd71: 0x08b9, 0xd72: 0x08c1, 0xd73: 0x08c9, 0xd74: 0x0a1e, 0xd75: 0x0a3e,
0xd76: 0x0a5e, 0xd77: 0x0a7e, 0xd78: 0x0a9e, 0xd79: 0x0abe, 0xd7a: 0x0ade, 0xd7b: 0x0afe,
0xd7c: 0x0b1e, 0xd7d: 0x08d2, 0xd7e: 0x08da, 0xd7f: 0x08e2,
// Block 0x36, offset 0xd80
0xd80: 0x08ea, 0xd81: 0x08f2, 0xd82: 0x08fa, 0xd83: 0x0902, 0xd84: 0x090a, 0xd85: 0x0912,
0xd86: 0x091a, 0xd87: 0x0922, 0xd88: 0x0040, 0xd89: 0x0040, 0xd8a: 0x0040, 0xd8b: 0x0040,
0xd8c: 0x0040, 0xd8d: 0x0040, 0xd8e: 0x0040, 0xd8f: 0x0040, 0xd90: 0x0040, 0xd91: 0x0040,
0xd92: 0x0040, 0xd93: 0x0040, 0xd94: 0x0040, 0xd95: 0x0040, 0xd96: 0x0040, 0xd97: 0x0040,
0xd98: 0x0040, 0xd99: 0x0040, 0xd9a: 0x0040, 0xd9b: 0x0040, 0xd9c: 0x0b3e, 0xd9d: 0x0b5e,
0xd9e: 0x0b7e, 0xd9f: 0x0b9e, 0xda0: 0x0bbe, 0xda1: 0x0bde, 0xda2: 0x0bfe, 0xda3: 0x0c1e,
0xda4: 0x0c3e, 0xda5: 0x0c5e, 0xda6: 0x0c7e, 0xda7: 0x0c9e, 0xda8: 0x0cbe, 0xda9: 0x0cde,
0xdaa: 0x0cfe, 0xdab: 0x0d1e, 0xdac: 0x0d3e, 0xdad: 0x0d5e, 0xdae: 0x0d7e, 0xdaf: 0x0d9e,
0xdb0: 0x0dbe, 0xdb1: 0x0dde, 0xdb2: 0x0dfe, 0xdb3: 0x0e1e, 0xdb4: 0x0e3e, 0xdb5: 0x0e5e,
0xdb6: 0x0019, 0xdb7: 0x02e9, 0xdb8: 0x03d9, 0xdb9: 0x02f1, 0xdba: 0x02f9, 0xdbb: 0x03f1,
0xdbc: 0x0309, 0xdbd: 0x00a9, 0xdbe: 0x0311, 0xdbf: 0x00b1,
// Block 0x37, offset 0xdc0
0xdc0: 0x0319, 0xdc1: 0x0101, 0xdc2: 0x0321, 0xdc3: 0x0329, 0xdc4: 0x0051, 0xdc5: 0x0339,
0xdc6: 0x0751, 0xdc7: 0x00b9, 0xdc8: 0x0089, 0xdc9: 0x0341, 0xdca: 0x0349, 0xdcb: 0x0391,
0xdcc: 0x00c1, 0xdcd: 0x0109, 0xdce: 0x00c9, 0xdcf: 0x04b1, 0xdd0: 0x0019, 0xdd1: 0x02e9,
0xdd2: 0x03d9, 0xdd3: 0x02f1, 0xdd4: 0x02f9, 0xdd5: 0x03f1, 0xdd6: 0x0309, 0xdd7: 0x00a9,
0xdd8: 0x0311, 0xdd9: 0x00b1, 0xdda: 0x0319, 0xddb: 0x0101, 0xddc: 0x0321, 0xddd: 0x0329,
0xdde: 0x0051, 0xddf: 0x0339, 0xde0: 0x0751, 0xde1: 0x00b9, 0xde2: 0x0089, 0xde3: 0x0341,
0xde4: 0x0349, 0xde5: 0x0391, 0xde6: 0x00c1, 0xde7: 0x0109, 0xde8: 0x00c9, 0xde9: 0x04b1,
0xdea: 0x06e1, 0xdeb: 0x0018, 0xdec: 0x0018, 0xded: 0x0018, 0xdee: 0x0018, 0xdef: 0x0018,
0xdf0: 0x0018, 0xdf1: 0x0018, 0xdf2: 0x0018, 0xdf3: 0x0018, 0xdf4: 0x0018, 0xdf5: 0x0018,
0xdf6: 0x0018, 0xdf7: 0x0018, 0xdf8: 0x0018, 0xdf9: 0x0018, 0xdfa: 0x0018, 0xdfb: 0x0018,
0xdfc: 0x0018, 0xdfd: 0x0018, 0xdfe: 0x0018, 0xdff: 0x0018,
// Block 0x38, offset 0xe00
0xe00: 0x0008, 0xe01: 0x0008, 0xe02: 0x0008, 0xe03: 0x0008, 0xe04: 0x0008, 0xe05: 0x0008,
0xe06: 0x0008, 0xe07: 0x0008, 0xe08: 0x0008, 0xe09: 0x0008, 0xe0a: 0x0008, 0xe0b: 0x0008,
0xe0c: 0x0008, 0xe0d: 0x0008, 0xe0e: 0x0008, 0xe0f: 0x0008, 0xe10: 0x0008, 0xe11: 0x0008,
0xe12: 0x0008, 0xe13: 0x0008, 0xe14: 0x0008, 0xe15: 0x0008, 0xe16: 0x0008, 0xe17: 0x0008,
0xe18: 0x0008, 0xe19: 0x0008, 0xe1a: 0x0008, 0xe1b: 0x0008, 0xe1c: 0x0008, 0xe1d: 0x0008,
0xe1e: 0x0008, 0xe1f: 0x0008, 0xe20: 0xe00d, 0xe21: 0x0008, 0xe22: 0x0941, 0xe23: 0x0ed5,
0xe24: 0x0949, 0xe25: 0x0008, 0xe26: 0x0008, 0xe27: 0xe07d, 0xe28: 0x0008, 0xe29: 0xe01d,
0xe2a: 0x0008, 0xe2b: 0xe03d, 0xe2c: 0x0008, 0xe2d: 0x0359, 0xe2e: 0x0441, 0xe2f: 0x0351,
0xe30: 0x03d1, 0xe31: 0x0008, 0xe32: 0xe00d, 0xe33: 0x0008, 0xe34: 0x0008, 0xe35: 0xe01d,
0xe36: 0x0008, 0xe37: 0x0008, 0xe38: 0x0008, 0xe39: 0x0008, 0xe3a: 0x0008, 0xe3b: 0x0008,
0xe3c: 0x00b1, 0xe3d: 0x0391, 0xe3e: 0x0951, 0xe3f: 0x0959,
// Block 0x39, offset 0xe40
0xe40: 0xe00d, 0xe41: 0x0008, 0xe42: 0xe00d, 0xe43: 0x0008, 0xe44: 0xe00d, 0xe45: 0x0008,
0xe46: 0xe00d, 0xe47: 0x0008, 0xe48: 0xe00d, 0xe49: 0x0008, 0xe4a: 0xe00d, 0xe4b: 0x0008,
0xe4c: 0xe00d, 0xe4d: 0x0008, 0xe4e: 0xe00d, 0xe4f: 0x0008, 0xe50: 0xe00d, 0xe51: 0x0008,
0xe52: 0xe00d, 0xe53: 0x0008, 0xe54: 0xe00d, 0xe55: 0x0008, 0xe56: 0xe00d, 0xe57: 0x0008,
0xe58: 0xe00d, 0xe59: 0x0008, 0xe5a: 0xe00d, 0xe5b: 0x0008, 0xe5c: 0xe00d, 0xe5d: 0x0008,
0xe5e: 0xe00d, 0xe5f: 0x0008, 0xe60: 0xe00d, 0xe61: 0x0008, 0xe62: 0xe00d, 0xe63: 0x0008,
0xe64: 0x0008, 0xe65: 0x0018, 0xe66: 0x0018, 0xe67: 0x0018, 0xe68: 0x0018, 0xe69: 0x0018,
0xe6a: 0x0018, 0xe6b: 0xe03d, 0xe6c: 0x0008, 0xe6d: 0xe01d, 0xe6e: 0x0008, 0xe6f: 0x3308,
0xe70: 0x3308, 0xe71: 0x3308, 0xe72: 0xe00d, 0xe73: 0x0008, 0xe74: 0x0040, 0xe75: 0x0040,
0xe76: 0x0040, 0xe77: 0x0040, 0xe78: 0x0040, 0xe79: 0x0018, 0xe7a: 0x0018, 0xe7b: 0x0018,
0xe7c: 0x0018, 0xe7d: 0x0018, 0xe7e: 0x0018, 0xe7f: 0x0018,
// Block 0x3a, offset 0xe80
0xe80: 0x2715, 0xe81: 0x2735, 0xe82: 0x2755, 0xe83: 0x2775, 0xe84: 0x2795, 0xe85: 0x27b5,
0xe86: 0x27d5, 0xe87: 0x27f5, 0xe88: 0x2815, 0xe89: 0x2835, 0xe8a: 0x2855, 0xe8b: 0x2875,
0xe8c: 0x2895, 0xe8d: 0x28b5, 0xe8e: 0x28d5, 0xe8f: 0x28f5, 0xe90: 0x2915, 0xe91: 0x2935,
0xe92: 0x2955, 0xe93: 0x2975, 0xe94: 0x2995, 0xe95: 0x29b5, 0xe96: 0x0040, 0xe97: 0x0040,
0xe98: 0x0040, 0xe99: 0x0040, 0xe9a: 0x0040, 0xe9b: 0x0040, 0xe9c: 0x0040, 0xe9d: 0x0040,
0xe9e: 0x0040, 0xe9f: 0x0040, 0xea0: 0x0040, 0xea1: 0x0040, 0xea2: 0x0040, 0xea3: 0x0040,
0xea4: 0x0040, 0xea5: 0x0040, 0xea6: 0x0040, 0xea7: 0x0040, 0xea8: 0x0040, 0xea9: 0x0040,
0xeaa: 0x0040, 0xeab: 0x0040, 0xeac: 0x0040, 0xead: 0x0040, 0xeae: 0x0040, 0xeaf: 0x0040,
0xeb0: 0x0040, 0xeb1: 0x0040, 0xeb2: 0x0040, 0xeb3: 0x0040, 0xeb4: 0x0040, 0xeb5: 0x0040,
0xeb6: 0x0040, 0xeb7: 0x0040, 0xeb8: 0x0040, 0xeb9: 0x0040, 0xeba: 0x0040, 0xebb: 0x0040,
0xebc: 0x0040, 0xebd: 0x0040, 0xebe: 0x0040, 0xebf: 0x0040,
// Block 0x3b, offset 0xec0
0xec0: 0x000a, 0xec1: 0x0018, 0xec2: 0x0961, 0xec3: 0x0018, 0xec4: 0x0018, 0xec5: 0x0008,
0xec6: 0x0008, 0xec7: 0x0008, 0xec8: 0x0018, 0xec9: 0x0018, 0xeca: 0x0018, 0xecb: 0x0018,
0xecc: 0x0018, 0xecd: 0x0018, 0xece: 0x0018, 0xecf: 0x0018, 0xed0: 0x0018, 0xed1: 0x0018,
0xed2: 0x0018, 0xed3: 0x0018, 0xed4: 0x0018, 0xed5: 0x0018, 0xed6: 0x0018, 0xed7: 0x0018,
0xed8: 0x0018, 0xed9: 0x0018, 0xeda: 0x0018, 0xedb: 0x0018, 0xedc: 0x0018, 0xedd: 0x0018,
0xede: 0x0018, 0xedf: 0x0018, 0xee0: 0x0018, 0xee1: 0x0018, 0xee2: 0x0018, 0xee3: 0x0018,
0xee4: 0x0018, 0xee5: 0x0018, 0xee6: 0x0018, 0xee7: 0x0018, 0xee8: 0x0018, 0xee9: 0x0018,
0xeea: 0x3308, 0xeeb: 0x3308, 0xeec: 0x3308, 0xeed: 0x3308, 0xeee: 0x3018, 0xeef: 0x3018,
0xef0: 0x0018, 0xef1: 0x0018, 0xef2: 0x0018, 0xef3: 0x0018, 0xef4: 0x0018, 0xef5: 0x0018,
0xef6: 0xe125, 0xef7: 0x0018, 0xef8: 0x29d5, 0xef9: 0x29f5, 0xefa: 0x2a15, 0xefb: 0x0018,
0xefc: 0x0008, 0xefd: 0x0018, 0xefe: 0x0018, 0xeff: 0x0018,
// Block 0x3c, offset 0xf00
0xf00: 0x2b55, 0xf01: 0x2b75, 0xf02: 0x2b95, 0xf03: 0x2bb5, 0xf04: 0x2bd5, 0xf05: 0x2bf5,
0xf06: 0x2bf5, 0xf07: 0x2bf5, 0xf08: 0x2c15, 0xf09: 0x2c15, 0xf0a: 0x2c15, 0xf0b: 0x2c15,
0xf0c: 0x2c35, 0xf0d: 0x2c35, 0xf0e: 0x2c35, 0xf0f: 0x2c55, 0xf10: 0x2c75, 0xf11: 0x2c75,
0xf12: 0x2a95, 0xf13: 0x2a95, 0xf14: 0x2c75, 0xf15: 0x2c75, 0xf16: 0x2c95, 0xf17: 0x2c95,
0xf18: 0x2c75, 0xf19: 0x2c75, 0xf1a: 0x2a95, 0xf1b: 0x2a95, 0xf1c: 0x2c75, 0xf1d: 0x2c75,
0xf1e: 0x2c55, 0xf1f: 0x2c55, 0xf20: 0x2cb5, 0xf21: 0x2cb5, 0xf22: 0x2cd5, 0xf23: 0x2cd5,
0xf24: 0x0040, 0xf25: 0x2cf5, 0xf26: 0x2d15, 0xf27: 0x2d35, 0xf28: 0x2d35, 0xf29: 0x2d55,
0xf2a: 0x2d75, 0xf2b: 0x2d95, 0xf2c: 0x2db5, 0xf2d: 0x2dd5, 0xf2e: 0x2df5, 0xf2f: 0x2e15,
0xf30: 0x2e35, 0xf31: 0x2e55, 0xf32: 0x2e55, 0xf33: 0x2e75, 0xf34: 0x2e95, 0xf35: 0x2e95,
0xf36: 0x2eb5, 0xf37: 0x2ed5, 0xf38: 0x2e75, 0xf39: 0x2ef5, 0xf3a: 0x2f15, 0xf3b: 0x2ef5,
0xf3c: 0x2e75, 0xf3d: 0x2f35, 0xf3e: 0x2f55, 0xf3f: 0x2f75,
// Block 0x3d, offset 0xf40
0xf40: 0x2f95, 0xf41: 0x2fb5, 0xf42: 0x2d15, 0xf43: 0x2cf5, 0xf44: 0x2fd5, 0xf45: 0x2ff5,
0xf46: 0x3015, 0xf47: 0x3035, 0xf48: 0x3055, 0xf49: 0x3075, 0xf4a: 0x3095, 0xf4b: 0x30b5,
0xf4c: 0x30d5, 0xf4d: 0x30f5, 0xf4e: 0x3115, 0xf4f: 0x0040, 0xf50: 0x0018, 0xf51: 0x0018,
0xf52: 0x3135, 0xf53: 0x3155, 0xf54: 0x3175, 0xf55: 0x3195, 0xf56: 0x31b5, 0xf57: 0x31d5,
0xf58: 0x31f5, 0xf59: 0x3215, 0xf5a: 0x3235, 0xf5b: 0x3255, 0xf5c: 0x3175, 0xf5d: 0x3275,
0xf5e: 0x3295, 0xf5f: 0x32b5, 0xf60: 0x0008, 0xf61: 0x0008, 0xf62: 0x0008, 0xf63: 0x0008,
0xf64: 0x0008, 0xf65: 0x0008, 0xf66: 0x0008, 0xf67: 0x0008, 0xf68: 0x0008, 0xf69: 0x0008,
0xf6a: 0x0008, 0xf6b: 0x0008, 0xf6c: 0x0008, 0xf6d: 0x0008, 0xf6e: 0x0008, 0xf6f: 0x0008,
0xf70: 0x0008, 0xf71: 0x0008, 0xf72: 0x0008, 0xf73: 0x0008, 0xf74: 0x0008, 0xf75: 0x0008,
0xf76: 0x0008, 0xf77: 0x0008, 0xf78: 0x0008, 0xf79: 0x0008, 0xf7a: 0x0008, 0xf7b: 0x0008,
0xf7c: 0x0008, 0xf7d: 0x0008, 0xf7e: 0x0008, 0xf7f: 0x0008,
// Block 0x3e, offset 0xf80
0xf80: 0x0b82, 0xf81: 0x0b8a, 0xf82: 0x0b92, 0xf83: 0x0b9a, 0xf84: 0x32d5, 0xf85: 0x32f5,
0xf86: 0x3315, 0xf87: 0x3335, 0xf88: 0x0018, 0xf89: 0x0018, 0xf8a: 0x0018, 0xf8b: 0x0018,
0xf8c: 0x0018, 0xf8d: 0x0018, 0xf8e: 0x0018, 0xf8f: 0x0018, 0xf90: 0x3355, 0xf91: 0x0ba1,
0xf92: 0x0ba9, 0xf93: 0x0bb1, 0xf94: 0x0bb9, 0xf95: 0x0bc1, 0xf96: 0x0bc9, 0xf97: 0x0bd1,
0xf98: 0x0bd9, 0xf99: 0x0be1, 0xf9a: 0x0be9, 0xf9b: 0x0bf1, 0xf9c: 0x0bf9, 0xf9d: 0x0c01,
0xf9e: 0x0c09, 0xf9f: 0x0c11, 0xfa0: 0x3375, 0xfa1: 0x3395, 0xfa2: 0x33b5, 0xfa3: 0x33d5,
0xfa4: 0x33f5, 0xfa5: 0x33f5, 0xfa6: 0x3415, 0xfa7: 0x3435, 0xfa8: 0x3455, 0xfa9: 0x3475,
0xfaa: 0x3495, 0xfab: 0x34b5, 0xfac: 0x34d5, 0xfad: 0x34f5, 0xfae: 0x3515, 0xfaf: 0x3535,
0xfb0: 0x3555, 0xfb1: 0x3575, 0xfb2: 0x3595, 0xfb3: 0x35b5, 0xfb4: 0x35d5, 0xfb5: 0x35f5,
0xfb6: 0x3615, 0xfb7: 0x3635, 0xfb8: 0x3655, 0xfb9: 0x3675, 0xfba: 0x3695, 0xfbb: 0x36b5,
0xfbc: 0x0c19, 0xfbd: 0x0c21, 0xfbe: 0x36d5, 0xfbf: 0x0018,
// Block 0x3f, offset 0xfc0
0xfc0: 0x36f5, 0xfc1: 0x3715, 0xfc2: 0x3735, 0xfc3: 0x3755, 0xfc4: 0x3775, 0xfc5: 0x3795,
0xfc6: 0x37b5, 0xfc7: 0x37d5, 0xfc8: 0x37f5, 0xfc9: 0x3815, 0xfca: 0x3835, 0xfcb: 0x3855,
0xfcc: 0x3875, 0xfcd: 0x3895, 0xfce: 0x38b5, 0xfcf: 0x38d5, 0xfd0: 0x38f5, 0xfd1: 0x3915,
0xfd2: 0x3935, 0xfd3: 0x3955, 0xfd4: 0x3975, 0xfd5: 0x3995, 0xfd6: 0x39b5, 0xfd7: 0x39d5,
0xfd8: 0x39f5, 0xfd9: 0x3a15, 0xfda: 0x3a35, 0xfdb: 0x3a55, 0xfdc: 0x3a75, 0xfdd: 0x3a95,
0xfde: 0x3ab5, 0xfdf: 0x3ad5, 0xfe0: 0x3af5, 0xfe1: 0x3b15, 0xfe2: 0x3b35, 0xfe3: 0x3b55,
0xfe4: 0x3b75, 0xfe5: 0x3b95, 0xfe6: 0x1295, 0xfe7: 0x3bb5, 0xfe8: 0x3bd5, 0xfe9: 0x3bf5,
0xfea: 0x3c15, 0xfeb: 0x3c35, 0xfec: 0x3c55, 0xfed: 0x3c75, 0xfee: 0x23b5, 0xfef: 0x3c95,
0xff0: 0x3cb5, 0xff1: 0x0c29, 0xff2: 0x0c31, 0xff3: 0x0c39, 0xff4: 0x0c41, 0xff5: 0x0c49,
0xff6: 0x0c51, 0xff7: 0x0c59, 0xff8: 0x0c61, 0xff9: 0x0c69, 0xffa: 0x0c71, 0xffb: 0x0c79,
0xffc: 0x0c81, 0xffd: 0x0c89, 0xffe: 0x0c91, 0xfff: 0x0c99,
// Block 0x40, offset 0x1000
0x1000: 0x0ca1, 0x1001: 0x0ca9, 0x1002: 0x0cb1, 0x1003: 0x0cb9, 0x1004: 0x0cc1, 0x1005: 0x0cc9,
0x1006: 0x0cd1, 0x1007: 0x0cd9, 0x1008: 0x0ce1, 0x1009: 0x0ce9, 0x100a: 0x0cf1, 0x100b: 0x0cf9,
0x100c: 0x0d01, 0x100d: 0x3cd5, 0x100e: 0x0d09, 0x100f: 0x3cf5, 0x1010: 0x3d15, 0x1011: 0x3d2d,
0x1012: 0x3d45, 0x1013: 0x3d5d, 0x1014: 0x3d75, 0x1015: 0x3d75, 0x1016: 0x3d5d, 0x1017: 0x3d8d,
0x1018: 0x07d5, 0x1019: 0x3da5, 0x101a: 0x3dbd, 0x101b: 0x3dd5, 0x101c: 0x3ded, 0x101d: 0x3e05,
0x101e: 0x3e1d, 0x101f: 0x3e35, 0x1020: 0x3e4d, 0x1021: 0x3e65, 0x1022: 0x3e7d, 0x1023: 0x3e95,
0x1024: 0x3ead, 0x1025: 0x3ead, 0x1026: 0x3ec5, 0x1027: 0x3ec5, 0x1028: 0x3edd, 0x1029: 0x3edd,
0x102a: 0x3ef5, 0x102b: 0x3f0d, 0x102c: 0x3f25, 0x102d: 0x3f3d, 0x102e: 0x3f55, 0x102f: 0x3f55,
0x1030: 0x3f6d, 0x1031: 0x3f6d, 0x1032: 0x3f6d, 0x1033: 0x3f85, 0x1034: 0x3f9d, 0x1035: 0x3fb5,
0x1036: 0x3fcd, 0x1037: 0x3fb5, 0x1038: 0x3fe5, 0x1039: 0x3ffd, 0x103a: 0x3f85, 0x103b: 0x4015,
0x103c: 0x402d, 0x103d: 0x402d, 0x103e: 0x402d, 0x103f: 0x0d11,
// Block 0x41, offset 0x1040
0x1040: 0x10f9, 0x1041: 0x1101, 0x1042: 0x40a5, 0x1043: 0x1109, 0x1044: 0x1111, 0x1045: 0x1119,
0x1046: 0x1121, 0x1047: 0x1129, 0x1048: 0x40c5, 0x1049: 0x1131, 0x104a: 0x1139, 0x104b: 0x1141,
0x104c: 0x40e5, 0x104d: 0x40e5, 0x104e: 0x1149, 0x104f: 0x1151, 0x1050: 0x1159, 0x1051: 0x4105,
0x1052: 0x4125, 0x1053: 0x4145, 0x1054: 0x4165, 0x1055: 0x4185, 0x1056: 0x1161, 0x1057: 0x1169,
0x1058: 0x1171, 0x1059: 0x1179, 0x105a: 0x1181, 0x105b: 0x41a5, 0x105c: 0x1189, 0x105d: 0x1191,
0x105e: 0x1199, 0x105f: 0x41c5, 0x1060: 0x41e5, 0x1061: 0x11a1, 0x1062: 0x4205, 0x1063: 0x4225,
0x1064: 0x4245, 0x1065: 0x11a9, 0x1066: 0x4265, 0x1067: 0x11b1, 0x1068: 0x11b9, 0x1069: 0x10f9,
0x106a: 0x4285, 0x106b: 0x42a5, 0x106c: 0x42c5, 0x106d: 0x42e5, 0x106e: 0x11c1, 0x106f: 0x11c9,
0x1070: 0x11d1, 0x1071: 0x11d9, 0x1072: 0x4305, 0x1073: 0x11e1, 0x1074: 0x11e9, 0x1075: 0x11f1,
0x1076: 0x4325, 0x1077: 0x11f9, 0x1078: 0x1201, 0x1079: 0x11f9, 0x107a: 0x1209, 0x107b: 0x1211,
0x107c: 0x4345, 0x107d: 0x1219, 0x107e: 0x1221, 0x107f: 0x1219,
// Block 0x42, offset 0x1080
0x1080: 0x4365, 0x1081: 0x4385, 0x1082: 0x0040, 0x1083: 0x1229, 0x1084: 0x1231, 0x1085: 0x1239,
0x1086: 0x1241, 0x1087: 0x0040, 0x1088: 0x1249, 0x1089: 0x1251, 0x108a: 0x1259, 0x108b: 0x1261,
0x108c: 0x1269, 0x108d: 0x1271, 0x108e: 0x1199, 0x108f: 0x1279, 0x1090: 0x1281, 0x1091: 0x1289,
0x1092: 0x43a5, 0x1093: 0x1291, 0x1094: 0x1121, 0x1095: 0x43c5, 0x1096: 0x43e5, 0x1097: 0x1299,
0x1098: 0x0040, 0x1099: 0x4405, 0x109a: 0x12a1, 0x109b: 0x12a9, 0x109c: 0x12b1, 0x109d: 0x12b9,
0x109e: 0x12c1, 0x109f: 0x12c9, 0x10a0: 0x12d1, 0x10a1: 0x12d9, 0x10a2: 0x12e1, 0x10a3: 0x12e9,
0x10a4: 0x12f1, 0x10a5: 0x12f9, 0x10a6: 0x1301, 0x10a7: 0x1309, 0x10a8: 0x1311, 0x10a9: 0x1319,
0x10aa: 0x1321, 0x10ab: 0x1329, 0x10ac: 0x1331, 0x10ad: 0x1339, 0x10ae: 0x1341, 0x10af: 0x1349,
0x10b0: 0x1351, 0x10b1: 0x1359, 0x10b2: 0x1361, 0x10b3: 0x1369, 0x10b4: 0x1371, 0x10b5: 0x1379,
0x10b6: 0x1381, 0x10b7: 0x1389, 0x10b8: 0x1391, 0x10b9: 0x1399, 0x10ba: 0x13a1, 0x10bb: 0x13a9,
0x10bc: 0x13b1, 0x10bd: 0x13b9, 0x10be: 0x13c1, 0x10bf: 0x4425,
// Block 0x43, offset 0x10c0
0x10c0: 0xe00d, 0x10c1: 0x0008, 0x10c2: 0xe00d, 0x10c3: 0x0008, 0x10c4: 0xe00d, 0x10c5: 0x0008,
0x10c6: 0xe00d, 0x10c7: 0x0008, 0x10c8: 0xe00d, 0x10c9: 0x0008, 0x10ca: 0xe00d, 0x10cb: 0x0008,
0x10cc: 0xe00d, 0x10cd: 0x0008, 0x10ce: 0xe00d, 0x10cf: 0x0008, 0x10d0: 0xe00d, 0x10d1: 0x0008,
0x10d2: 0xe00d, 0x10d3: 0x0008, 0x10d4: 0xe00d, 0x10d5: 0x0008, 0x10d6: 0xe00d, 0x10d7: 0x0008,
0x10d8: 0xe00d, 0x10d9: 0x0008, 0x10da: 0xe00d, 0x10db: 0x0008, 0x10dc: 0xe00d, 0x10dd: 0x0008,
0x10de: 0xe00d, 0x10df: 0x0008, 0x10e0: 0xe00d, 0x10e1: 0x0008, 0x10e2: 0xe00d, 0x10e3: 0x0008,
0x10e4: 0xe00d, 0x10e5: 0x0008, 0x10e6: 0xe00d, 0x10e7: 0x0008, 0x10e8: 0xe00d, 0x10e9: 0x0008,
0x10ea: 0xe00d, 0x10eb: 0x0008, 0x10ec: 0xe00d, 0x10ed: 0x0008, 0x10ee: 0x0008, 0x10ef: 0x3308,
0x10f0: 0x3318, 0x10f1: 0x3318, 0x10f2: 0x3318, 0x10f3: 0x0018, 0x10f4: 0x3308, 0x10f5: 0x3308,
0x10f6: 0x3308, 0x10f7: 0x3308, 0x10f8: 0x3308, 0x10f9: 0x3308, 0x10fa: 0x3308, 0x10fb: 0x3308,
0x10fc: 0x3308, 0x10fd: 0x3308, 0x10fe: 0x0018, 0x10ff: 0x0008,
// Block 0x44, offset 0x1100
0x1100: 0xe00d, 0x1101: 0x0008, 0x1102: 0xe00d, 0x1103: 0x0008, 0x1104: 0xe00d, 0x1105: 0x0008,
0x1106: 0xe00d, 0x1107: 0x0008, 0x1108: 0xe00d, 0x1109: 0x0008, 0x110a: 0xe00d, 0x110b: 0x0008,
0x110c: 0xe00d, 0x110d: 0x0008, 0x110e: 0xe00d, 0x110f: 0x0008, 0x1110: 0xe00d, 0x1111: 0x0008,
0x1112: 0xe00d, 0x1113: 0x0008, 0x1114: 0xe00d, 0x1115: 0x0008, 0x1116: 0xe00d, 0x1117: 0x0008,
0x1118: 0xe00d, 0x1119: 0x0008, 0x111a: 0xe00d, 0x111b: 0x0008, 0x111c: 0x02d1, 0x111d: 0x13c9,
0x111e: 0x3308, 0x111f: 0x3308, 0x1120: 0x0008, 0x1121: 0x0008, 0x1122: 0x0008, 0x1123: 0x0008,
0x1124: 0x0008, 0x1125: 0x0008, 0x1126: 0x0008, 0x1127: 0x0008, 0x1128: 0x0008, 0x1129: 0x0008,
0x112a: 0x0008, 0x112b: 0x0008, 0x112c: 0x0008, 0x112d: 0x0008, 0x112e: 0x0008, 0x112f: 0x0008,
0x1130: 0x0008, 0x1131: 0x0008, 0x1132: 0x0008, 0x1133: 0x0008, 0x1134: 0x0008, 0x1135: 0x0008,
0x1136: 0x0008, 0x1137: 0x0008, 0x1138: 0x0008, 0x1139: 0x0008, 0x113a: 0x0008, 0x113b: 0x0008,
0x113c: 0x0008, 0x113d: 0x0008, 0x113e: 0x0008, 0x113f: 0x0008,
// Block 0x45, offset 0x1140
0x1140: 0x0018, 0x1141: 0x0018, 0x1142: 0x0018, 0x1143: 0x0018, 0x1144: 0x0018, 0x1145: 0x0018,
0x1146: 0x0018, 0x1147: 0x0018, 0x1148: 0x0018, 0x1149: 0x0018, 0x114a: 0x0018, 0x114b: 0x0018,
0x114c: 0x0018, 0x114d: 0x0018, 0x114e: 0x0018, 0x114f: 0x0018, 0x1150: 0x0018, 0x1151: 0x0018,
0x1152: 0x0018, 0x1153: 0x0018, 0x1154: 0x0018, 0x1155: 0x0018, 0x1156: 0x0018, 0x1157: 0x0008,
0x1158: 0x0008, 0x1159: 0x0008, 0x115a: 0x0008, 0x115b: 0x0008, 0x115c: 0x0008, 0x115d: 0x0008,
0x115e: 0x0008, 0x115f: 0x0008, 0x1160: 0x0018, 0x1161: 0x0018, 0x1162: 0xe00d, 0x1163: 0x0008,
0x1164: 0xe00d, 0x1165: 0x0008, 0x1166: 0xe00d, 0x1167: 0x0008, 0x1168: 0xe00d, 0x1169: 0x0008,
0x116a: 0xe00d, 0x116b: 0x0008, 0x116c: 0xe00d, 0x116d: 0x0008, 0x116e: 0xe00d, 0x116f: 0x0008,
0x1170: 0x0008, 0x1171: 0x0008, 0x1172: 0xe00d, 0x1173: 0x0008, 0x1174: 0xe00d, 0x1175: 0x0008,
0x1176: 0xe00d, 0x1177: 0x0008, 0x1178: 0xe00d, 0x1179: 0x0008, 0x117a: 0xe00d, 0x117b: 0x0008,
0x117c: 0xe00d, 0x117d: 0x0008, 0x117e: 0xe00d, 0x117f: 0x0008,
// Block 0x46, offset 0x1180
0x1180: 0xe00d, 0x1181: 0x0008, 0x1182: 0xe00d, 0x1183: 0x0008, 0x1184: 0xe00d, 0x1185: 0x0008,
0x1186: 0xe00d, 0x1187: 0x0008, 0x1188: 0xe00d, 0x1189: 0x0008, 0x118a: 0xe00d, 0x118b: 0x0008,
0x118c: 0xe00d, 0x118d: 0x0008, 0x118e: 0xe00d, 0x118f: 0x0008, 0x1190: 0xe00d, 0x1191: 0x0008,
0x1192: 0xe00d, 0x1193: 0x0008, 0x1194: 0xe00d, 0x1195: 0x0008, 0x1196: 0xe00d, 0x1197: 0x0008,
0x1198: 0xe00d, 0x1199: 0x0008, 0x119a: 0xe00d, 0x119b: 0x0008, 0x119c: 0xe00d, 0x119d: 0x0008,
0x119e: 0xe00d, 0x119f: 0x0008, 0x11a0: 0xe00d, 0x11a1: 0x0008, 0x11a2: 0xe00d, 0x11a3: 0x0008,
0x11a4: 0xe00d, 0x11a5: 0x0008, 0x11a6: 0xe00d, 0x11a7: 0x0008, 0x11a8: 0xe00d, 0x11a9: 0x0008,
0x11aa: 0xe00d, 0x11ab: 0x0008, 0x11ac: 0xe00d, 0x11ad: 0x0008, 0x11ae: 0xe00d, 0x11af: 0x0008,
0x11b0: 0xe0fd, 0x11b1: 0x0008, 0x11b2: 0x0008, 0x11b3: 0x0008, 0x11b4: 0x0008, 0x11b5: 0x0008,
0x11b6: 0x0008, 0x11b7: 0x0008, 0x11b8: 0x0008, 0x11b9: 0xe01d, 0x11ba: 0x0008, 0x11bb: 0xe03d,
0x11bc: 0x0008, 0x11bd: 0x4445, 0x11be: 0xe00d, 0x11bf: 0x0008,
// Block 0x47, offset 0x11c0
0x11c0: 0xe00d, 0x11c1: 0x0008, 0x11c2: 0xe00d, 0x11c3: 0x0008, 0x11c4: 0xe00d, 0x11c5: 0x0008,
0x11c6: 0xe00d, 0x11c7: 0x0008, 0x11c8: 0x0008, 0x11c9: 0x0018, 0x11ca: 0x0018, 0x11cb: 0xe03d,
0x11cc: 0x0008, 0x11cd: 0x0409, 0x11ce: 0x0008, 0x11cf: 0x0008, 0x11d0: 0xe00d, 0x11d1: 0x0008,
0x11d2: 0xe00d, 0x11d3: 0x0008, 0x11d4: 0x0008, 0x11d5: 0x0008, 0x11d6: 0xe00d, 0x11d7: 0x0008,
0x11d8: 0xe00d, 0x11d9: 0x0008, 0x11da: 0xe00d, 0x11db: 0x0008, 0x11dc: 0xe00d, 0x11dd: 0x0008,
0x11de: 0xe00d, 0x11df: 0x0008, 0x11e0: 0xe00d, 0x11e1: 0x0008, 0x11e2: 0xe00d, 0x11e3: 0x0008,
0x11e4: 0xe00d, 0x11e5: 0x0008, 0x11e6: 0xe00d, 0x11e7: 0x0008, 0x11e8: 0xe00d, 0x11e9: 0x0008,
0x11ea: 0x13d1, 0x11eb: 0x0371, 0x11ec: 0x0401, 0x11ed: 0x13d9, 0x11ee: 0x0421, 0x11ef: 0x0008,
0x11f0: 0x13e1, 0x11f1: 0x13e9, 0x11f2: 0x0429, 0x11f3: 0x4465, 0x11f4: 0xe00d, 0x11f5: 0x0008,
0x11f6: 0xe00d, 0x11f7: 0x0008, 0x11f8: 0xe00d, 0x11f9: 0x0008, 0x11fa: 0xe00d, 0x11fb: 0x0008,
0x11fc: 0xe00d, 0x11fd: 0x0008, 0x11fe: 0xe00d, 0x11ff: 0x0008,
// Block 0x48, offset 0x1200
0x1200: 0xe00d, 0x1201: 0x0008, 0x1202: 0xe00d, 0x1203: 0x0008, 0x1204: 0x03f5, 0x1205: 0x0479,
0x1206: 0x447d, 0x1207: 0xe07d, 0x1208: 0x0008, 0x1209: 0xe01d, 0x120a: 0x0008, 0x120b: 0x0040,
0x120c: 0x0040, 0x120d: 0x0040, 0x120e: 0x0040, 0x120f: 0x0040, 0x1210: 0xe00d, 0x1211: 0x0008,
0x1212: 0x0040, 0x1213: 0x0008, 0x1214: 0x0040, 0x1215: 0x0008, 0x1216: 0xe00d, 0x1217: 0x0008,
0x1218: 0xe00d, 0x1219: 0x0008, 0x121a: 0x0040, 0x121b: 0x0040, 0x121c: 0x0040, 0x121d: 0x0040,
0x121e: 0x0040, 0x121f: 0x0040, 0x1220: 0x0040, 0x1221: 0x0040, 0x1222: 0x0040, 0x1223: 0x0040,
0x1224: 0x0040, 0x1225: 0x0040, 0x1226: 0x0040, 0x1227: 0x0040, 0x1228: 0x0040, 0x1229: 0x0040,
0x122a: 0x0040, 0x122b: 0x0040, 0x122c: 0x0040, 0x122d: 0x0040, 0x122e: 0x0040, 0x122f: 0x0040,
0x1230: 0x0040, 0x1231: 0x0040, 0x1232: 0x03d9, 0x1233: 0x03f1, 0x1234: 0x0751, 0x1235: 0xe01d,
0x1236: 0x0008, 0x1237: 0x0008, 0x1238: 0x0741, 0x1239: 0x13f1, 0x123a: 0x0008, 0x123b: 0x0008,
0x123c: 0x0008, 0x123d: 0x0008, 0x123e: 0x0008, 0x123f: 0x0008,
// Block 0x49, offset 0x1240
0x1240: 0x650d, 0x1241: 0x652d, 0x1242: 0x654d, 0x1243: 0x656d, 0x1244: 0x658d, 0x1245: 0x65ad,
0x1246: 0x65cd, 0x1247: 0x65ed, 0x1248: 0x660d, 0x1249: 0x662d, 0x124a: 0x664d, 0x124b: 0x666d,
0x124c: 0x668d, 0x124d: 0x66ad, 0x124e: 0x0008, 0x124f: 0x0008, 0x1250: 0x66cd, 0x1251: 0x0008,
0x1252: 0x66ed, 0x1253: 0x0008, 0x1254: 0x0008, 0x1255: 0x670d, 0x1256: 0x672d, 0x1257: 0x674d,
0x1258: 0x676d, 0x1259: 0x678d, 0x125a: 0x67ad, 0x125b: 0x67cd, 0x125c: 0x67ed, 0x125d: 0x680d,
0x125e: 0x682d, 0x125f: 0x0008, 0x1260: 0x684d, 0x1261: 0x0008, 0x1262: 0x686d, 0x1263: 0x0008,
0x1264: 0x0008, 0x1265: 0x688d, 0x1266: 0x68ad, 0x1267: 0x0008, 0x1268: 0x0008, 0x1269: 0x0008,
0x126a: 0x68cd, 0x126b: 0x68ed, 0x126c: 0x690d, 0x126d: 0x692d, 0x126e: 0x694d, 0x126f: 0x696d,
0x1270: 0x698d, 0x1271: 0x69ad, 0x1272: 0x69cd, 0x1273: 0x69ed, 0x1274: 0x6a0d, 0x1275: 0x6a2d,
0x1276: 0x6a4d, 0x1277: 0x6a6d, 0x1278: 0x6a8d, 0x1279: 0x6aad, 0x127a: 0x6acd, 0x127b: 0x6aed,
0x127c: 0x6b0d, 0x127d: 0x6b2d, 0x127e: 0x6b4d, 0x127f: 0x6b6d,
// Block 0x4a, offset 0x1280
0x1280: 0x7acd, 0x1281: 0x7aed, 0x1282: 0x7b0d, 0x1283: 0x7b2d, 0x1284: 0x7b4d, 0x1285: 0x7b6d,
0x1286: 0x7b8d, 0x1287: 0x7bad, 0x1288: 0x7bcd, 0x1289: 0x7bed, 0x128a: 0x7c0d, 0x128b: 0x7c2d,
0x128c: 0x7c4d, 0x128d: 0x7c6d, 0x128e: 0x7c8d, 0x128f: 0x1409, 0x1290: 0x1411, 0x1291: 0x1419,
0x1292: 0x7cad, 0x1293: 0x7ccd, 0x1294: 0x7ced, 0x1295: 0x1421, 0x1296: 0x1429, 0x1297: 0x1431,
0x1298: 0x7d0d, 0x1299: 0x7d2d, 0x129a: 0x0040, 0x129b: 0x0040, 0x129c: 0x0040, 0x129d: 0x0040,
0x129e: 0x0040, 0x129f: 0x0040, 0x12a0: 0x0040, 0x12a1: 0x0040, 0x12a2: 0x0040, 0x12a3: 0x0040,
0x12a4: 0x0040, 0x12a5: 0x0040, 0x12a6: 0x0040, 0x12a7: 0x0040, 0x12a8: 0x0040, 0x12a9: 0x0040,
0x12aa: 0x0040, 0x12ab: 0x0040, 0x12ac: 0x0040, 0x12ad: 0x0040, 0x12ae: 0x0040, 0x12af: 0x0040,
0x12b0: 0x0040, 0x12b1: 0x0040, 0x12b2: 0x0040, 0x12b3: 0x0040, 0x12b4: 0x0040, 0x12b5: 0x0040,
0x12b6: 0x0040, 0x12b7: 0x0040, 0x12b8: 0x0040, 0x12b9: 0x0040, 0x12ba: 0x0040, 0x12bb: 0x0040,
0x12bc: 0x0040, 0x12bd: 0x0040, 0x12be: 0x0040, 0x12bf: 0x0040,
// Block 0x4b, offset 0x12c0
0x12c0: 0x1439, 0x12c1: 0x1441, 0x12c2: 0x1449, 0x12c3: 0x7d4d, 0x12c4: 0x7d6d, 0x12c5: 0x1451,
0x12c6: 0x1451, 0x12c7: 0x0040, 0x12c8: 0x0040, 0x12c9: 0x0040, 0x12ca: 0x0040, 0x12cb: 0x0040,
0x12cc: 0x0040, 0x12cd: 0x0040, 0x12ce: 0x0040, 0x12cf: 0x0040, 0x12d0: 0x0040, 0x12d1: 0x0040,
0x12d2: 0x0040, 0x12d3: 0x1459, 0x12d4: 0x1461, 0x12d5: 0x1469, 0x12d6: 0x1471, 0x12d7: 0x1479,
0x12d8: 0x0040, 0x12d9: 0x0040, 0x12da: 0x0040, 0x12db: 0x0040, 0x12dc: 0x0040, 0x12dd: 0x1481,
0x12de: 0x3308, 0x12df: 0x1489, 0x12e0: 0x1491, 0x12e1: 0x0779, 0x12e2: 0x0791, 0x12e3: 0x1499,
0x12e4: 0x14a1, 0x12e5: 0x14a9, 0x12e6: 0x14b1, 0x12e7: 0x14b9, 0x12e8: 0x14c1, 0x12e9: 0x071a,
0x12ea: 0x14c9, 0x12eb: 0x14d1, 0x12ec: 0x14d9, 0x12ed: 0x14e1, 0x12ee: 0x14e9, 0x12ef: 0x14f1,
0x12f0: 0x14f9, 0x12f1: 0x1501, 0x12f2: 0x1509, 0x12f3: 0x1511, 0x12f4: 0x1519, 0x12f5: 0x1521,
0x12f6: 0x1529, 0x12f7: 0x0040, 0x12f8: 0x1531, 0x12f9: 0x1539, 0x12fa: 0x1541, 0x12fb: 0x1549,
0x12fc: 0x1551, 0x12fd: 0x0040, 0x12fe: 0x1559, 0x12ff: 0x0040,
// Block 0x4c, offset 0x1300
0x1300: 0x1561, 0x1301: 0x1569, 0x1302: 0x0040, 0x1303: 0x1571, 0x1304: 0x1579, 0x1305: 0x0040,
0x1306: 0x1581, 0x1307: 0x1589, 0x1308: 0x1591, 0x1309: 0x1599, 0x130a: 0x15a1, 0x130b: 0x15a9,
0x130c: 0x15b1, 0x130d: 0x15b9, 0x130e: 0x15c1, 0x130f: 0x15c9, 0x1310: 0x15d1, 0x1311: 0x15d1,
0x1312: 0x15d9, 0x1313: 0x15d9, 0x1314: 0x15d9, 0x1315: 0x15d9, 0x1316: 0x15e1, 0x1317: 0x15e1,
0x1318: 0x15e1, 0x1319: 0x15e1, 0x131a: 0x15e9, 0x131b: 0x15e9, 0x131c: 0x15e9, 0x131d: 0x15e9,
0x131e: 0x15f1, 0x131f: 0x15f1, 0x1320: 0x15f1, 0x1321: 0x15f1, 0x1322: 0x15f9, 0x1323: 0x15f9,
0x1324: 0x15f9, 0x1325: 0x15f9, 0x1326: 0x1601, 0x1327: 0x1601, 0x1328: 0x1601, 0x1329: 0x1601,
0x132a: 0x1609, 0x132b: 0x1609, 0x132c: 0x1609, 0x132d: 0x1609, 0x132e: 0x1611, 0x132f: 0x1611,
0x1330: 0x1611, 0x1331: 0x1611, 0x1332: 0x1619, 0x1333: 0x1619, 0x1334: 0x1619, 0x1335: 0x1619,
0x1336: 0x1621, 0x1337: 0x1621, 0x1338: 0x1621, 0x1339: 0x1621, 0x133a: 0x1629, 0x133b: 0x1629,
0x133c: 0x1629, 0x133d: 0x1629, 0x133e: 0x1631, 0x133f: 0x1631,
// Block 0x4d, offset 0x1340
0x1340: 0x1631, 0x1341: 0x1631, 0x1342: 0x1639, 0x1343: 0x1639, 0x1344: 0x1641, 0x1345: 0x1641,
0x1346: 0x1649, 0x1347: 0x1649, 0x1348: 0x1651, 0x1349: 0x1651, 0x134a: 0x1659, 0x134b: 0x1659,
0x134c: 0x1661, 0x134d: 0x1661, 0x134e: 0x1669, 0x134f: 0x1669, 0x1350: 0x1669, 0x1351: 0x1669,
0x1352: 0x1671, 0x1353: 0x1671, 0x1354: 0x1671, 0x1355: 0x1671, 0x1356: 0x1679, 0x1357: 0x1679,
0x1358: 0x1679, 0x1359: 0x1679, 0x135a: 0x1681, 0x135b: 0x1681, 0x135c: 0x1681, 0x135d: 0x1681,
0x135e: 0x1689, 0x135f: 0x1689, 0x1360: 0x1691, 0x1361: 0x1691, 0x1362: 0x1691, 0x1363: 0x1691,
0x1364: 0x1699, 0x1365: 0x1699, 0x1366: 0x16a1, 0x1367: 0x16a1, 0x1368: 0x16a1, 0x1369: 0x16a1,
0x136a: 0x16a9, 0x136b: 0x16a9, 0x136c: 0x16a9, 0x136d: 0x16a9, 0x136e: 0x16b1, 0x136f: 0x16b1,
0x1370: 0x16b9, 0x1371: 0x16b9, 0x1372: 0x0818, 0x1373: 0x0818, 0x1374: 0x0818, 0x1375: 0x0818,
0x1376: 0x0818, 0x1377: 0x0818, 0x1378: 0x0818, 0x1379: 0x0818, 0x137a: 0x0818, 0x137b: 0x0818,
0x137c: 0x0818, 0x137d: 0x0818, 0x137e: 0x0818, 0x137f: 0x0818,
// Block 0x4e, offset 0x1380
0x1380: 0x0818, 0x1381: 0x0818, 0x1382: 0x0818, 0x1383: 0x0040, 0x1384: 0x0040, 0x1385: 0x0040,
0x1386: 0x0040, 0x1387: 0x0040, 0x1388: 0x0040, 0x1389: 0x0040, 0x138a: 0x0040, 0x138b: 0x0040,
0x138c: 0x0040, 0x138d: 0x0040, 0x138e: 0x0040, 0x138f: 0x0040, 0x1390: 0x0040, 0x1391: 0x0040,
0x1392: 0x0040, 0x1393: 0x16c1, 0x1394: 0x16c1, 0x1395: 0x16c1, 0x1396: 0x16c1, 0x1397: 0x16c9,
0x1398: 0x16c9, 0x1399: 0x16d1, 0x139a: 0x16d1, 0x139b: 0x16d9, 0x139c: 0x16d9, 0x139d: 0x0149,
0x139e: 0x16e1, 0x139f: 0x16e1, 0x13a0: 0x16e9, 0x13a1: 0x16e9, 0x13a2: 0x16f1, 0x13a3: 0x16f1,
0x13a4: 0x16f9, 0x13a5: 0x16f9, 0x13a6: 0x16f9, 0x13a7: 0x16f9, 0x13a8: 0x1701, 0x13a9: 0x1701,
0x13aa: 0x1709, 0x13ab: 0x1709, 0x13ac: 0x1711, 0x13ad: 0x1711, 0x13ae: 0x1719, 0x13af: 0x1719,
0x13b0: 0x1721, 0x13b1: 0x1721, 0x13b2: 0x1729, 0x13b3: 0x1729, 0x13b4: 0x1731, 0x13b5: 0x1731,
0x13b6: 0x1739, 0x13b7: 0x1739, 0x13b8: 0x1739, 0x13b9: 0x1741, 0x13ba: 0x1741, 0x13bb: 0x1741,
0x13bc: 0x1749, 0x13bd: 0x1749, 0x13be: 0x1749, 0x13bf: 0x1749,
// Block 0x4f, offset 0x13c0
0x13c0: 0x1949, 0x13c1: 0x1951, 0x13c2: 0x1959, 0x13c3: 0x1961, 0x13c4: 0x1969, 0x13c5: 0x1971,
0x13c6: 0x1979, 0x13c7: 0x1981, 0x13c8: 0x1989, 0x13c9: 0x1991, 0x13ca: 0x1999, 0x13cb: 0x19a1,
0x13cc: 0x19a9, 0x13cd: 0x19b1, 0x13ce: 0x19b9, 0x13cf: 0x19c1, 0x13d0: 0x19c9, 0x13d1: 0x19d1,
0x13d2: 0x19d9, 0x13d3: 0x19e1, 0x13d4: 0x19e9, 0x13d5: 0x19f1, 0x13d6: 0x19f9, 0x13d7: 0x1a01,
0x13d8: 0x1a09, 0x13d9: 0x1a11, 0x13da: 0x1a19, 0x13db: 0x1a21, 0x13dc: 0x1a29, 0x13dd: 0x1a31,
0x13de: 0x1a3a, 0x13df: 0x1a42, 0x13e0: 0x1a4a, 0x13e1: 0x1a52, 0x13e2: 0x1a5a, 0x13e3: 0x1a62,
0x13e4: 0x1a69, 0x13e5: 0x1a71, 0x13e6: 0x1761, 0x13e7: 0x1a79, 0x13e8: 0x1741, 0x13e9: 0x1769,
0x13ea: 0x1a81, 0x13eb: 0x1a89, 0x13ec: 0x1789, 0x13ed: 0x1a91, 0x13ee: 0x1791, 0x13ef: 0x1799,
0x13f0: 0x1a99, 0x13f1: 0x1aa1, 0x13f2: 0x17b9, 0x13f3: 0x1aa9, 0x13f4: 0x17c1, 0x13f5: 0x17c9,
0x13f6: 0x1ab1, 0x13f7: 0x1ab9, 0x13f8: 0x17d9, 0x13f9: 0x1ac1, 0x13fa: 0x17e1, 0x13fb: 0x17e9,
0x13fc: 0x18d1, 0x13fd: 0x18d9, 0x13fe: 0x18f1, 0x13ff: 0x18f9,
// Block 0x50, offset 0x1400
0x1400: 0x1901, 0x1401: 0x1921, 0x1402: 0x1929, 0x1403: 0x1931, 0x1404: 0x1939, 0x1405: 0x1959,
0x1406: 0x1961, 0x1407: 0x1969, 0x1408: 0x1ac9, 0x1409: 0x1989, 0x140a: 0x1ad1, 0x140b: 0x1ad9,
0x140c: 0x19b9, 0x140d: 0x1ae1, 0x140e: 0x19c1, 0x140f: 0x19c9, 0x1410: 0x1a31, 0x1411: 0x1ae9,
0x1412: 0x1af1, 0x1413: 0x1a09, 0x1414: 0x1af9, 0x1415: 0x1a11, 0x1416: 0x1a19, 0x1417: 0x1751,
0x1418: 0x1759, 0x1419: 0x1b01, 0x141a: 0x1761, 0x141b: 0x1b09, 0x141c: 0x1771, 0x141d: 0x1779,
0x141e: 0x1781, 0x141f: 0x1789, 0x1420: 0x1b11, 0x1421: 0x17a1, 0x1422: 0x17a9, 0x1423: 0x17b1,
0x1424: 0x17b9, 0x1425: 0x1b19, 0x1426: 0x17d9, 0x1427: 0x17f1, 0x1428: 0x17f9, 0x1429: 0x1801,
0x142a: 0x1809, 0x142b: 0x1811, 0x142c: 0x1821, 0x142d: 0x1829, 0x142e: 0x1831, 0x142f: 0x1839,
0x1430: 0x1841, 0x1431: 0x1849, 0x1432: 0x1b21, 0x1433: 0x1851, 0x1434: 0x1859, 0x1435: 0x1861,
0x1436: 0x1869, 0x1437: 0x1871, 0x1438: 0x1879, 0x1439: 0x1889, 0x143a: 0x1891, 0x143b: 0x1899,
0x143c: 0x18a1, 0x143d: 0x18a9, 0x143e: 0x18b1, 0x143f: 0x18b9,
// Block 0x51, offset 0x1440
0x1440: 0x18c1, 0x1441: 0x18c9, 0x1442: 0x18e1, 0x1443: 0x18e9, 0x1444: 0x1909, 0x1445: 0x1911,
0x1446: 0x1919, 0x1447: 0x1921, 0x1448: 0x1929, 0x1449: 0x1941, 0x144a: 0x1949, 0x144b: 0x1951,
0x144c: 0x1959, 0x144d: 0x1b29, 0x144e: 0x1971, 0x144f: 0x1979, 0x1450: 0x1981, 0x1451: 0x1989,
0x1452: 0x19a1, 0x1453: 0x19a9, 0x1454: 0x19b1, 0x1455: 0x19b9, 0x1456: 0x1b31, 0x1457: 0x19d1,
0x1458: 0x19d9, 0x1459: 0x1b39, 0x145a: 0x19f1, 0x145b: 0x19f9, 0x145c: 0x1a01, 0x145d: 0x1a09,
0x145e: 0x1b41, 0x145f: 0x1761, 0x1460: 0x1b09, 0x1461: 0x1789, 0x1462: 0x1b11, 0x1463: 0x17b9,
0x1464: 0x1b19, 0x1465: 0x17d9, 0x1466: 0x1b49, 0x1467: 0x1841, 0x1468: 0x1b51, 0x1469: 0x1b59,
0x146a: 0x1b61, 0x146b: 0x1921, 0x146c: 0x1929, 0x146d: 0x1959, 0x146e: 0x19b9, 0x146f: 0x1b31,
0x1470: 0x1a09, 0x1471: 0x1b41, 0x1472: 0x1b69, 0x1473: 0x1b71, 0x1474: 0x1b79, 0x1475: 0x1b81,
0x1476: 0x1b89, 0x1477: 0x1b91, 0x1478: 0x1b99, 0x1479: 0x1ba1, 0x147a: 0x1ba9, 0x147b: 0x1bb1,
0x147c: 0x1bb9, 0x147d: 0x1bc1, 0x147e: 0x1bc9, 0x147f: 0x1bd1,
// Block 0x52, offset 0x1480
0x1480: 0x1bd9, 0x1481: 0x1be1, 0x1482: 0x1be9, 0x1483: 0x1bf1, 0x1484: 0x1bf9, 0x1485: 0x1c01,
0x1486: 0x1c09, 0x1487: 0x1c11, 0x1488: 0x1c19, 0x1489: 0x1c21, 0x148a: 0x1c29, 0x148b: 0x1c31,
0x148c: 0x1b59, 0x148d: 0x1c39, 0x148e: 0x1c41, 0x148f: 0x1c49, 0x1490: 0x1c51, 0x1491: 0x1b81,
0x1492: 0x1b89, 0x1493: 0x1b91, 0x1494: 0x1b99, 0x1495: 0x1ba1, 0x1496: 0x1ba9, 0x1497: 0x1bb1,
0x1498: 0x1bb9, 0x1499: 0x1bc1, 0x149a: 0x1bc9, 0x149b: 0x1bd1, 0x149c: 0x1bd9, 0x149d: 0x1be1,
0x149e: 0x1be9, 0x149f: 0x1bf1, 0x14a0: 0x1bf9, 0x14a1: 0x1c01, 0x14a2: 0x1c09, 0x14a3: 0x1c11,
0x14a4: 0x1c19, 0x14a5: 0x1c21, 0x14a6: 0x1c29, 0x14a7: 0x1c31, 0x14a8: 0x1b59, 0x14a9: 0x1c39,
0x14aa: 0x1c41, 0x14ab: 0x1c49, 0x14ac: 0x1c51, 0x14ad: 0x1c21, 0x14ae: 0x1c29, 0x14af: 0x1c31,
0x14b0: 0x1b59, 0x14b1: 0x1b51, 0x14b2: 0x1b61, 0x14b3: 0x1881, 0x14b4: 0x1829, 0x14b5: 0x1831,
0x14b6: 0x1839, 0x14b7: 0x1c21, 0x14b8: 0x1c29, 0x14b9: 0x1c31, 0x14ba: 0x1881, 0x14bb: 0x1889,
0x14bc: 0x1c59, 0x14bd: 0x1c59, 0x14be: 0x0018, 0x14bf: 0x0018,
// Block 0x53, offset 0x14c0
0x14c0: 0x0018, 0x14c1: 0x0018, 0x14c2: 0x0018, 0x14c3: 0x0018, 0x14c4: 0x0018, 0x14c5: 0x0018,
0x14c6: 0x0018, 0x14c7: 0x0018, 0x14c8: 0x0018, 0x14c9: 0x0018, 0x14ca: 0x0018, 0x14cb: 0x0018,
0x14cc: 0x0018, 0x14cd: 0x0018, 0x14ce: 0x0018, 0x14cf: 0x0018, 0x14d0: 0x1c61, 0x14d1: 0x1c69,
0x14d2: 0x1c69, 0x14d3: 0x1c71, 0x14d4: 0x1c79, 0x14d5: 0x1c81, 0x14d6: 0x1c89, 0x14d7: 0x1c91,
0x14d8: 0x1c99, 0x14d9: 0x1c99, 0x14da: 0x1ca1, 0x14db: 0x1ca9, 0x14dc: 0x1cb1, 0x14dd: 0x1cb9,
0x14de: 0x1cc1, 0x14df: 0x1cc9, 0x14e0: 0x1cc9, 0x14e1: 0x1cd1, 0x14e2: 0x1cd9, 0x14e3: 0x1cd9,
0x14e4: 0x1ce1, 0x14e5: 0x1ce1, 0x14e6: 0x1ce9, 0x14e7: 0x1cf1, 0x14e8: 0x1cf1, 0x14e9: 0x1cf9,
0x14ea: 0x1d01, 0x14eb: 0x1d01, 0x14ec: 0x1d09, 0x14ed: 0x1d09, 0x14ee: 0x1d11, 0x14ef: 0x1d19,
0x14f0: 0x1d19, 0x14f1: 0x1d21, 0x14f2: 0x1d21, 0x14f3: 0x1d29, 0x14f4: 0x1d31, 0x14f5: 0x1d39,
0x14f6: 0x1d41, 0x14f7: 0x1d41, 0x14f8: 0x1d49, 0x14f9: 0x1d51, 0x14fa: 0x1d59, 0x14fb: 0x1d61,
0x14fc: 0x1d69, 0x14fd: 0x1d69, 0x14fe: 0x1d71, 0x14ff: 0x1d79,
// Block 0x54, offset 0x1500
0x1500: 0x1f29, 0x1501: 0x1f31, 0x1502: 0x1f39, 0x1503: 0x1f11, 0x1504: 0x1d39, 0x1505: 0x1ce9,
0x1506: 0x1f41, 0x1507: 0x1f49, 0x1508: 0x0040, 0x1509: 0x0040, 0x150a: 0x0040, 0x150b: 0x0040,
0x150c: 0x0040, 0x150d: 0x0040, 0x150e: 0x0040, 0x150f: 0x0018, 0x1510: 0x0040, 0x1511: 0x0040,
0x1512: 0x0040, 0x1513: 0x0040, 0x1514: 0x0040, 0x1515: 0x0040, 0x1516: 0x0040, 0x1517: 0x0040,
0x1518: 0x0040, 0x1519: 0x0040, 0x151a: 0x0040, 0x151b: 0x0040, 0x151c: 0x0040, 0x151d: 0x0040,
0x151e: 0x0040, 0x151f: 0x0040, 0x1520: 0x0040, 0x1521: 0x0040, 0x1522: 0x0040, 0x1523: 0x0040,
0x1524: 0x0040, 0x1525: 0x0040, 0x1526: 0x0040, 0x1527: 0x0040, 0x1528: 0x0040, 0x1529: 0x0040,
0x152a: 0x0040, 0x152b: 0x0040, 0x152c: 0x0040, 0x152d: 0x0040, 0x152e: 0x0040, 0x152f: 0x0040,
0x1530: 0x1f51, 0x1531: 0x1f59, 0x1532: 0x1f61, 0x1533: 0x1f69, 0x1534: 0x1f71, 0x1535: 0x1f79,
0x1536: 0x1f81, 0x1537: 0x1f89, 0x1538: 0x1f91, 0x1539: 0x1f99, 0x153a: 0x1fa2, 0x153b: 0x1faa,
0x153c: 0x1fb1, 0x153d: 0x0018, 0x153e: 0x0018, 0x153f: 0x0018,
// Block 0x55, offset 0x1540
0x1540: 0x33c0, 0x1541: 0x33c0, 0x1542: 0x33c0, 0x1543: 0x33c0, 0x1544: 0x33c0, 0x1545: 0x33c0,
0x1546: 0x33c0, 0x1547: 0x33c0, 0x1548: 0x33c0, 0x1549: 0x33c0, 0x154a: 0x33c0, 0x154b: 0x33c0,
0x154c: 0x33c0, 0x154d: 0x33c0, 0x154e: 0x33c0, 0x154f: 0x33c0, 0x1550: 0x1fba, 0x1551: 0x7d8d,
0x1552: 0x0040, 0x1553: 0x1fc2, 0x1554: 0x0122, 0x1555: 0x1fca, 0x1556: 0x1fd2, 0x1557: 0x7dad,
0x1558: 0x7dcd, 0x1559: 0x0040, 0x155a: 0x0040, 0x155b: 0x0040, 0x155c: 0x0040, 0x155d: 0x0040,
0x155e: 0x0040, 0x155f: 0x0040, 0x1560: 0x3308, 0x1561: 0x3308, 0x1562: 0x3308, 0x1563: 0x3308,
0x1564: 0x3308, 0x1565: 0x3308, 0x1566: 0x3308, 0x1567: 0x3308, 0x1568: 0x3308, 0x1569: 0x3308,
0x156a: 0x3308, 0x156b: 0x3308, 0x156c: 0x3308, 0x156d: 0x3308, 0x156e: 0x3308, 0x156f: 0x3308,
0x1570: 0x0040, 0x1571: 0x7ded, 0x1572: 0x7e0d, 0x1573: 0x1fda, 0x1574: 0x1fda, 0x1575: 0x072a,
0x1576: 0x0732, 0x1577: 0x1fe2, 0x1578: 0x1fea, 0x1579: 0x7e2d, 0x157a: 0x7e4d, 0x157b: 0x7e6d,
0x157c: 0x7e2d, 0x157d: 0x7e8d, 0x157e: 0x7ead, 0x157f: 0x7e8d,
// Block 0x56, offset 0x1580
0x1580: 0x7ecd, 0x1581: 0x7eed, 0x1582: 0x7f0d, 0x1583: 0x7eed, 0x1584: 0x7f2d, 0x1585: 0x0018,
0x1586: 0x0018, 0x1587: 0x1ff2, 0x1588: 0x1ffa, 0x1589: 0x7f4e, 0x158a: 0x7f6e, 0x158b: 0x7f8e,
0x158c: 0x7fae, 0x158d: 0x1fda, 0x158e: 0x1fda, 0x158f: 0x1fda, 0x1590: 0x1fba, 0x1591: 0x7fcd,
0x1592: 0x0040, 0x1593: 0x0040, 0x1594: 0x0122, 0x1595: 0x1fc2, 0x1596: 0x1fd2, 0x1597: 0x1fca,
0x1598: 0x7fed, 0x1599: 0x072a, 0x159a: 0x0732, 0x159b: 0x1fe2, 0x159c: 0x1fea, 0x159d: 0x7ecd,
0x159e: 0x7f2d, 0x159f: 0x2002, 0x15a0: 0x200a, 0x15a1: 0x2012, 0x15a2: 0x071a, 0x15a3: 0x2019,
0x15a4: 0x2022, 0x15a5: 0x202a, 0x15a6: 0x0722, 0x15a7: 0x0040, 0x15a8: 0x2032, 0x15a9: 0x203a,
0x15aa: 0x2042, 0x15ab: 0x204a, 0x15ac: 0x0040, 0x15ad: 0x0040, 0x15ae: 0x0040, 0x15af: 0x0040,
0x15b0: 0x800e, 0x15b1: 0x2051, 0x15b2: 0x802e, 0x15b3: 0x0808, 0x15b4: 0x804e, 0x15b5: 0x0040,
0x15b6: 0x806e, 0x15b7: 0x2059, 0x15b8: 0x808e, 0x15b9: 0x2061, 0x15ba: 0x80ae, 0x15bb: 0x2069,
0x15bc: 0x80ce, 0x15bd: 0x2071, 0x15be: 0x80ee, 0x15bf: 0x2079,
// Block 0x57, offset 0x15c0
0x15c0: 0x2081, 0x15c1: 0x2089, 0x15c2: 0x2089, 0x15c3: 0x2091, 0x15c4: 0x2091, 0x15c5: 0x2099,
0x15c6: 0x2099, 0x15c7: 0x20a1, 0x15c8: 0x20a1, 0x15c9: 0x20a9, 0x15ca: 0x20a9, 0x15cb: 0x20a9,
0x15cc: 0x20a9, 0x15cd: 0x20b1, 0x15ce: 0x20b1, 0x15cf: 0x20b9, 0x15d0: 0x20b9, 0x15d1: 0x20b9,
0x15d2: 0x20b9, 0x15d3: 0x20c1, 0x15d4: 0x20c1, 0x15d5: 0x20c9, 0x15d6: 0x20c9, 0x15d7: 0x20c9,
0x15d8: 0x20c9, 0x15d9: 0x20d1, 0x15da: 0x20d1, 0x15db: 0x20d1, 0x15dc: 0x20d1, 0x15dd: 0x20d9,
0x15de: 0x20d9, 0x15df: 0x20d9, 0x15e0: 0x20d9, 0x15e1: 0x20e1, 0x15e2: 0x20e1, 0x15e3: 0x20e1,
0x15e4: 0x20e1, 0x15e5: 0x20e9, 0x15e6: 0x20e9, 0x15e7: 0x20e9, 0x15e8: 0x20e9, 0x15e9: 0x20f1,
0x15ea: 0x20f1, 0x15eb: 0x20f9, 0x15ec: 0x20f9, 0x15ed: 0x2101, 0x15ee: 0x2101, 0x15ef: 0x2109,
0x15f0: 0x2109, 0x15f1: 0x2111, 0x15f2: 0x2111, 0x15f3: 0x2111, 0x15f4: 0x2111, 0x15f5: 0x2119,
0x15f6: 0x2119, 0x15f7: 0x2119, 0x15f8: 0x2119, 0x15f9: 0x2121, 0x15fa: 0x2121, 0x15fb: 0x2121,
0x15fc: 0x2121, 0x15fd: 0x2129, 0x15fe: 0x2129, 0x15ff: 0x2129,
// Block 0x58, offset 0x1600
0x1600: 0x2129, 0x1601: 0x2131, 0x1602: 0x2131, 0x1603: 0x2131, 0x1604: 0x2131, 0x1605: 0x2139,
0x1606: 0x2139, 0x1607: 0x2139, 0x1608: 0x2139, 0x1609: 0x2141, 0x160a: 0x2141, 0x160b: 0x2141,
0x160c: 0x2141, 0x160d: 0x2149, 0x160e: 0x2149, 0x160f: 0x2149, 0x1610: 0x2149, 0x1611: 0x2151,
0x1612: 0x2151, 0x1613: 0x2151, 0x1614: 0x2151, 0x1615: 0x2159, 0x1616: 0x2159, 0x1617: 0x2159,
0x1618: 0x2159, 0x1619: 0x2161, 0x161a: 0x2161, 0x161b: 0x2161, 0x161c: 0x2161, 0x161d: 0x2169,
0x161e: 0x2169, 0x161f: 0x2169, 0x1620: 0x2169, 0x1621: 0x2171, 0x1622: 0x2171, 0x1623: 0x2171,
0x1624: 0x2171, 0x1625: 0x2179, 0x1626: 0x2179, 0x1627: 0x2179, 0x1628: 0x2179, 0x1629: 0x2181,
0x162a: 0x2181, 0x162b: 0x2181, 0x162c: 0x2181, 0x162d: 0x2189, 0x162e: 0x2189, 0x162f: 0x1701,
0x1630: 0x1701, 0x1631: 0x2191, 0x1632: 0x2191, 0x1633: 0x2191, 0x1634: 0x2191, 0x1635: 0x2199,
0x1636: 0x2199, 0x1637: 0x21a1, 0x1638: 0x21a1, 0x1639: 0x21a9, 0x163a: 0x21a9, 0x163b: 0x21b1,
0x163c: 0x21b1, 0x163d: 0x0040, 0x163e: 0x0040, 0x163f: 0x03c0,
// Block 0x59, offset 0x1640
0x1640: 0x0040, 0x1641: 0x1fca, 0x1642: 0x21ba, 0x1643: 0x2002, 0x1644: 0x203a, 0x1645: 0x2042,
0x1646: 0x200a, 0x1647: 0x21c2, 0x1648: 0x072a, 0x1649: 0x0732, 0x164a: 0x2012, 0x164b: 0x071a,
0x164c: 0x1fba, 0x164d: 0x2019, 0x164e: 0x0961, 0x164f: 0x21ca, 0x1650: 0x06e1, 0x1651: 0x0049,
0x1652: 0x0029, 0x1653: 0x0031, 0x1654: 0x06e9, 0x1655: 0x06f1, 0x1656: 0x06f9, 0x1657: 0x0701,
0x1658: 0x0709, 0x1659: 0x0711, 0x165a: 0x1fc2, 0x165b: 0x0122, 0x165c: 0x2022, 0x165d: 0x0722,
0x165e: 0x202a, 0x165f: 0x1fd2, 0x1660: 0x204a, 0x1661: 0x0019, 0x1662: 0x02e9, 0x1663: 0x03d9,
0x1664: 0x02f1, 0x1665: 0x02f9, 0x1666: 0x03f1, 0x1667: 0x0309, 0x1668: 0x00a9, 0x1669: 0x0311,
0x166a: 0x00b1, 0x166b: 0x0319, 0x166c: 0x0101, 0x166d: 0x0321, 0x166e: 0x0329, 0x166f: 0x0051,
0x1670: 0x0339, 0x1671: 0x0751, 0x1672: 0x00b9, 0x1673: 0x0089, 0x1674: 0x0341, 0x1675: 0x0349,
0x1676: 0x0391, 0x1677: 0x00c1, 0x1678: 0x0109, 0x1679: 0x00c9, 0x167a: 0x04b1, 0x167b: 0x1ff2,
0x167c: 0x2032, 0x167d: 0x1ffa, 0x167e: 0x21d2, 0x167f: 0x1fda,
// Block 0x5a, offset 0x1680
0x1680: 0x0672, 0x1681: 0x0019, 0x1682: 0x02e9, 0x1683: 0x03d9, 0x1684: 0x02f1, 0x1685: 0x02f9,
0x1686: 0x03f1, 0x1687: 0x0309, 0x1688: 0x00a9, 0x1689: 0x0311, 0x168a: 0x00b1, 0x168b: 0x0319,
0x168c: 0x0101, 0x168d: 0x0321, 0x168e: 0x0329, 0x168f: 0x0051, 0x1690: 0x0339, 0x1691: 0x0751,
0x1692: 0x00b9, 0x1693: 0x0089, 0x1694: 0x0341, 0x1695: 0x0349, 0x1696: 0x0391, 0x1697: 0x00c1,
0x1698: 0x0109, 0x1699: 0x00c9, 0x169a: 0x04b1, 0x169b: 0x1fe2, 0x169c: 0x21da, 0x169d: 0x1fea,
0x169e: 0x21e2, 0x169f: 0x810d, 0x16a0: 0x812d, 0x16a1: 0x0961, 0x16a2: 0x814d, 0x16a3: 0x814d,
0x16a4: 0x816d, 0x16a5: 0x818d, 0x16a6: 0x81ad, 0x16a7: 0x81cd, 0x16a8: 0x81ed, 0x16a9: 0x820d,
0x16aa: 0x822d, 0x16ab: 0x824d, 0x16ac: 0x826d, 0x16ad: 0x828d, 0x16ae: 0x82ad, 0x16af: 0x82cd,
0x16b0: 0x82ed, 0x16b1: 0x830d, 0x16b2: 0x832d, 0x16b3: 0x834d, 0x16b4: 0x836d, 0x16b5: 0x838d,
0x16b6: 0x83ad, 0x16b7: 0x83cd, 0x16b8: 0x83ed, 0x16b9: 0x840d, 0x16ba: 0x842d, 0x16bb: 0x844d,
0x16bc: 0x81ed, 0x16bd: 0x846d, 0x16be: 0x848d, 0x16bf: 0x824d,
// Block 0x5b, offset 0x16c0
0x16c0: 0x84ad, 0x16c1: 0x84cd, 0x16c2: 0x84ed, 0x16c3: 0x850d, 0x16c4: 0x852d, 0x16c5: 0x854d,
0x16c6: 0x856d, 0x16c7: 0x858d, 0x16c8: 0x850d, 0x16c9: 0x85ad, 0x16ca: 0x850d, 0x16cb: 0x85cd,
0x16cc: 0x85cd, 0x16cd: 0x85ed, 0x16ce: 0x85ed, 0x16cf: 0x860d, 0x16d0: 0x854d, 0x16d1: 0x862d,
0x16d2: 0x864d, 0x16d3: 0x862d, 0x16d4: 0x866d, 0x16d5: 0x864d, 0x16d6: 0x868d, 0x16d7: 0x868d,
0x16d8: 0x86ad, 0x16d9: 0x86ad, 0x16da: 0x86cd, 0x16db: 0x86cd, 0x16dc: 0x864d, 0x16dd: 0x814d,
0x16de: 0x86ed, 0x16df: 0x870d, 0x16e0: 0x0040, 0x16e1: 0x872d, 0x16e2: 0x874d, 0x16e3: 0x876d,
0x16e4: 0x878d, 0x16e5: 0x876d, 0x16e6: 0x87ad, 0x16e7: 0x87cd, 0x16e8: 0x87ed, 0x16e9: 0x87ed,
0x16ea: 0x880d, 0x16eb: 0x880d, 0x16ec: 0x882d, 0x16ed: 0x882d, 0x16ee: 0x880d, 0x16ef: 0x880d,
0x16f0: 0x884d, 0x16f1: 0x886d, 0x16f2: 0x888d, 0x16f3: 0x88ad, 0x16f4: 0x88cd, 0x16f5: 0x88ed,
0x16f6: 0x88ed, 0x16f7: 0x88ed, 0x16f8: 0x890d, 0x16f9: 0x890d, 0x16fa: 0x890d, 0x16fb: 0x890d,
0x16fc: 0x87ed, 0x16fd: 0x87ed, 0x16fe: 0x87ed, 0x16ff: 0x0040,
// Block 0x5c, offset 0x1700
0x1700: 0x0040, 0x1701: 0x0040, 0x1702: 0x874d, 0x1703: 0x872d, 0x1704: 0x892d, 0x1705: 0x872d,
0x1706: 0x874d, 0x1707: 0x872d, 0x1708: 0x0040, 0x1709: 0x0040, 0x170a: 0x894d, 0x170b: 0x874d,
0x170c: 0x896d, 0x170d: 0x892d, 0x170e: 0x896d, 0x170f: 0x874d, 0x1710: 0x0040, 0x1711: 0x0040,
0x1712: 0x898d, 0x1713: 0x89ad, 0x1714: 0x88ad, 0x1715: 0x896d, 0x1716: 0x892d, 0x1717: 0x896d,
0x1718: 0x0040, 0x1719: 0x0040, 0x171a: 0x89cd, 0x171b: 0x89ed, 0x171c: 0x89cd, 0x171d: 0x0040,
0x171e: 0x0040, 0x171f: 0x0040, 0x1720: 0x21e9, 0x1721: 0x21f1, 0x1722: 0x21f9, 0x1723: 0x8a0e,
0x1724: 0x2201, 0x1725: 0x2209, 0x1726: 0x8a2d, 0x1727: 0x0040, 0x1728: 0x8a4d, 0x1729: 0x8a6d,
0x172a: 0x8a8d, 0x172b: 0x8a6d, 0x172c: 0x8aad, 0x172d: 0x8acd, 0x172e: 0x8aed, 0x172f: 0x0040,
0x1730: 0x0040, 0x1731: 0x0040, 0x1732: 0x0040, 0x1733: 0x0040, 0x1734: 0x0040, 0x1735: 0x0040,
0x1736: 0x0040, 0x1737: 0x0040, 0x1738: 0x0040, 0x1739: 0x0340, 0x173a: 0x0340, 0x173b: 0x0340,
0x173c: 0x0040, 0x173d: 0x0040, 0x173e: 0x0040, 0x173f: 0x0040,
// Block 0x5d, offset 0x1740
0x1740: 0x0008, 0x1741: 0x0008, 0x1742: 0x0008, 0x1743: 0x0008, 0x1744: 0x0008, 0x1745: 0x0008,
0x1746: 0x0008, 0x1747: 0x0008, 0x1748: 0x0008, 0x1749: 0x0008, 0x174a: 0x0008, 0x174b: 0x0008,
0x174c: 0x0008, 0x174d: 0x0008, 0x174e: 0x0008, 0x174f: 0x0008, 0x1750: 0x0008, 0x1751: 0x0008,
0x1752: 0x0008, 0x1753: 0x0008, 0x1754: 0x0008, 0x1755: 0x0008, 0x1756: 0x0008, 0x1757: 0x0008,
0x1758: 0x0008, 0x1759: 0x0008, 0x175a: 0x0008, 0x175b: 0x0008, 0x175c: 0x0008, 0x175d: 0x0008,
0x175e: 0x0008, 0x175f: 0x0008, 0x1760: 0x0008, 0x1761: 0x0008, 0x1762: 0x0008, 0x1763: 0x0008,
0x1764: 0x0040, 0x1765: 0x0040, 0x1766: 0x0040, 0x1767: 0x0040, 0x1768: 0x0040, 0x1769: 0x0040,
0x176a: 0x0040, 0x176b: 0x0040, 0x176c: 0x0040, 0x176d: 0x0040, 0x176e: 0x0040, 0x176f: 0x0018,
0x1770: 0x8b3d, 0x1771: 0x8b55, 0x1772: 0x8b6d, 0x1773: 0x8b55, 0x1774: 0x8b85, 0x1775: 0x8b55,
0x1776: 0x8b6d, 0x1777: 0x8b55, 0x1778: 0x8b3d, 0x1779: 0x8b9d, 0x177a: 0x8bb5, 0x177b: 0x0040,
0x177c: 0x8bcd, 0x177d: 0x8b9d, 0x177e: 0x8bb5, 0x177f: 0x8b9d,
// Block 0x5e, offset 0x1780
0x1780: 0xe13d, 0x1781: 0xe14d, 0x1782: 0xe15d, 0x1783: 0xe14d, 0x1784: 0xe17d, 0x1785: 0xe14d,
0x1786: 0xe15d, 0x1787: 0xe14d, 0x1788: 0xe13d, 0x1789: 0xe1cd, 0x178a: 0xe1dd, 0x178b: 0x0040,
0x178c: 0xe1fd, 0x178d: 0xe1cd, 0x178e: 0xe1dd, 0x178f: 0xe1cd, 0x1790: 0xe13d, 0x1791: 0xe14d,
0x1792: 0xe15d, 0x1793: 0x0040, 0x1794: 0xe17d, 0x1795: 0xe14d, 0x1796: 0x0040, 0x1797: 0x0008,
0x1798: 0x0008, 0x1799: 0x0008, 0x179a: 0x0008, 0x179b: 0x0008, 0x179c: 0x0008, 0x179d: 0x0008,
0x179e: 0x0008, 0x179f: 0x0008, 0x17a0: 0x0008, 0x17a1: 0x0008, 0x17a2: 0x0040, 0x17a3: 0x0008,
0x17a4: 0x0008, 0x17a5: 0x0008, 0x17a6: 0x0008, 0x17a7: 0x0008, 0x17a8: 0x0008, 0x17a9: 0x0008,
0x17aa: 0x0008, 0x17ab: 0x0008, 0x17ac: 0x0008, 0x17ad: 0x0008, 0x17ae: 0x0008, 0x17af: 0x0008,
0x17b0: 0x0008, 0x17b1: 0x0008, 0x17b2: 0x0040, 0x17b3: 0x0008, 0x17b4: 0x0008, 0x17b5: 0x0008,
0x17b6: 0x0008, 0x17b7: 0x0008, 0x17b8: 0x0008, 0x17b9: 0x0008, 0x17ba: 0x0040, 0x17bb: 0x0008,
0x17bc: 0x0008, 0x17bd: 0x0040, 0x17be: 0x0040, 0x17bf: 0x0040,
// Block 0x5f, offset 0x17c0
0x17c0: 0x0008, 0x17c1: 0x2211, 0x17c2: 0x2219, 0x17c3: 0x02e1, 0x17c4: 0x2221, 0x17c5: 0x2229,
0x17c6: 0x0040, 0x17c7: 0x2231, 0x17c8: 0x2239, 0x17c9: 0x2241, 0x17ca: 0x2249, 0x17cb: 0x2251,
0x17cc: 0x2259, 0x17cd: 0x2261, 0x17ce: 0x2269, 0x17cf: 0x2271, 0x17d0: 0x2279, 0x17d1: 0x2281,
0x17d2: 0x2289, 0x17d3: 0x2291, 0x17d4: 0x2299, 0x17d5: 0x0741, 0x17d6: 0x22a1, 0x17d7: 0x22a9,
0x17d8: 0x22b1, 0x17d9: 0x22b9, 0x17da: 0x22c1, 0x17db: 0x13d9, 0x17dc: 0x8be5, 0x17dd: 0x22c9,
0x17de: 0x22d1, 0x17df: 0x8c05, 0x17e0: 0x22d9, 0x17e1: 0x8c25, 0x17e2: 0x22e1, 0x17e3: 0x22e9,
0x17e4: 0x22f1, 0x17e5: 0x0751, 0x17e6: 0x22f9, 0x17e7: 0x8c45, 0x17e8: 0x0949, 0x17e9: 0x2301,
0x17ea: 0x2309, 0x17eb: 0x2311, 0x17ec: 0x2319, 0x17ed: 0x2321, 0x17ee: 0x2329, 0x17ef: 0x2331,
0x17f0: 0x2339, 0x17f1: 0x0040, 0x17f2: 0x2341, 0x17f3: 0x2349, 0x17f4: 0x2351, 0x17f5: 0x2359,
0x17f6: 0x2361, 0x17f7: 0x2369, 0x17f8: 0x2371, 0x17f9: 0x8c65, 0x17fa: 0x8c85, 0x17fb: 0x0040,
0x17fc: 0x0040, 0x17fd: 0x0040, 0x17fe: 0x0040, 0x17ff: 0x0040,
// Block 0x60, offset 0x1800
0x1800: 0x0a08, 0x1801: 0x0a08, 0x1802: 0x0a08, 0x1803: 0x0a08, 0x1804: 0x0a08, 0x1805: 0x0c08,
0x1806: 0x0808, 0x1807: 0x0c08, 0x1808: 0x0818, 0x1809: 0x0c08, 0x180a: 0x0c08, 0x180b: 0x0808,
0x180c: 0x0808, 0x180d: 0x0908, 0x180e: 0x0c08, 0x180f: 0x0c08, 0x1810: 0x0c08, 0x1811: 0x0c08,
0x1812: 0x0c08, 0x1813: 0x0a08, 0x1814: 0x0a08, 0x1815: 0x0a08, 0x1816: 0x0a08, 0x1817: 0x0908,
0x1818: 0x0a08, 0x1819: 0x0a08, 0x181a: 0x0a08, 0x181b: 0x0a08, 0x181c: 0x0a08, 0x181d: 0x0c08,
0x181e: 0x0a08, 0x181f: 0x0a08, 0x1820: 0x0a08, 0x1821: 0x0c08, 0x1822: 0x0808, 0x1823: 0x0808,
0x1824: 0x0c08, 0x1825: 0x3308, 0x1826: 0x3308, 0x1827: 0x0040, 0x1828: 0x0040, 0x1829: 0x0040,
0x182a: 0x0040, 0x182b: 0x0a18, 0x182c: 0x0a18, 0x182d: 0x0a18, 0x182e: 0x0a18, 0x182f: 0x0c18,
0x1830: 0x0818, 0x1831: 0x0818, 0x1832: 0x0818, 0x1833: 0x0818, 0x1834: 0x0818, 0x1835: 0x0818,
0x1836: 0x0818, 0x1837: 0x0040, 0x1838: 0x0040, 0x1839: 0x0040, 0x183a: 0x0040, 0x183b: 0x0040,
0x183c: 0x0040, 0x183d: 0x0040, 0x183e: 0x0040, 0x183f: 0x0040,
// Block 0x61, offset 0x1840
0x1840: 0x0a08, 0x1841: 0x0c08, 0x1842: 0x0a08, 0x1843: 0x0c08, 0x1844: 0x0c08, 0x1845: 0x0c08,
0x1846: 0x0a08, 0x1847: 0x0a08, 0x1848: 0x0a08, 0x1849: 0x0c08, 0x184a: 0x0a08, 0x184b: 0x0a08,
0x184c: 0x0c08, 0x184d: 0x0a08, 0x184e: 0x0c08, 0x184f: 0x0c08, 0x1850: 0x0a08, 0x1851: 0x0c08,
0x1852: 0x0040, 0x1853: 0x0040, 0x1854: 0x0040, 0x1855: 0x0040, 0x1856: 0x0040, 0x1857: 0x0040,
0x1858: 0x0040, 0x1859: 0x0818, 0x185a: 0x0818, 0x185b: 0x0818, 0x185c: 0x0818, 0x185d: 0x0040,
0x185e: 0x0040, 0x185f: 0x0040, 0x1860: 0x0040, 0x1861: 0x0040, 0x1862: 0x0040, 0x1863: 0x0040,
0x1864: 0x0040, 0x1865: 0x0040, 0x1866: 0x0040, 0x1867: 0x0040, 0x1868: 0x0040, 0x1869: 0x0c18,
0x186a: 0x0c18, 0x186b: 0x0c18, 0x186c: 0x0c18, 0x186d: 0x0a18, 0x186e: 0x0a18, 0x186f: 0x0818,
0x1870: 0x0040, 0x1871: 0x0040, 0x1872: 0x0040, 0x1873: 0x0040, 0x1874: 0x0040, 0x1875: 0x0040,
0x1876: 0x0040, 0x1877: 0x0040, 0x1878: 0x0040, 0x1879: 0x0040, 0x187a: 0x0040, 0x187b: 0x0040,
0x187c: 0x0040, 0x187d: 0x0040, 0x187e: 0x0040, 0x187f: 0x0040,
// Block 0x62, offset 0x1880
0x1880: 0x3308, 0x1881: 0x3308, 0x1882: 0x3008, 0x1883: 0x3008, 0x1884: 0x0040, 0x1885: 0x0008,
0x1886: 0x0008, 0x1887: 0x0008, 0x1888: 0x0008, 0x1889: 0x0008, 0x188a: 0x0008, 0x188b: 0x0008,
0x188c: 0x0008, 0x188d: 0x0040, 0x188e: 0x0040, 0x188f: 0x0008, 0x1890: 0x0008, 0x1891: 0x0040,
0x1892: 0x0040, 0x1893: 0x0008, 0x1894: 0x0008, 0x1895: 0x0008, 0x1896: 0x0008, 0x1897: 0x0008,
0x1898: 0x0008, 0x1899: 0x0008, 0x189a: 0x0008, 0x189b: 0x0008, 0x189c: 0x0008, 0x189d: 0x0008,
0x189e: 0x0008, 0x189f: 0x0008, 0x18a0: 0x0008, 0x18a1: 0x0008, 0x18a2: 0x0008, 0x18a3: 0x0008,
0x18a4: 0x0008, 0x18a5: 0x0008, 0x18a6: 0x0008, 0x18a7: 0x0008, 0x18a8: 0x0008, 0x18a9: 0x0040,
0x18aa: 0x0008, 0x18ab: 0x0008, 0x18ac: 0x0008, 0x18ad: 0x0008, 0x18ae: 0x0008, 0x18af: 0x0008,
0x18b0: 0x0008, 0x18b1: 0x0040, 0x18b2: 0x0008, 0x18b3: 0x0008, 0x18b4: 0x0040, 0x18b5: 0x0008,
0x18b6: 0x0008, 0x18b7: 0x0008, 0x18b8: 0x0008, 0x18b9: 0x0008, 0x18ba: 0x0040, 0x18bb: 0x3308,
0x18bc: 0x3308, 0x18bd: 0x0008, 0x18be: 0x3008, 0x18bf: 0x3008,
// Block 0x63, offset 0x18c0
0x18c0: 0x3308, 0x18c1: 0x3008, 0x18c2: 0x3008, 0x18c3: 0x3008, 0x18c4: 0x3008, 0x18c5: 0x0040,
0x18c6: 0x0040, 0x18c7: 0x3008, 0x18c8: 0x3008, 0x18c9: 0x0040, 0x18ca: 0x0040, 0x18cb: 0x3008,
0x18cc: 0x3008, 0x18cd: 0x3808, 0x18ce: 0x0040, 0x18cf: 0x0040, 0x18d0: 0x0008, 0x18d1: 0x0040,
0x18d2: 0x0040, 0x18d3: 0x0040, 0x18d4: 0x0040, 0x18d5: 0x0040, 0x18d6: 0x0040, 0x18d7: 0x3008,
0x18d8: 0x0040, 0x18d9: 0x0040, 0x18da: 0x0040, 0x18db: 0x0040, 0x18dc: 0x0040, 0x18dd: 0x0008,
0x18de: 0x0008, 0x18df: 0x0008, 0x18e0: 0x0008, 0x18e1: 0x0008, 0x18e2: 0x3008, 0x18e3: 0x3008,
0x18e4: 0x0040, 0x18e5: 0x0040, 0x18e6: 0x3308, 0x18e7: 0x3308, 0x18e8: 0x3308, 0x18e9: 0x3308,
0x18ea: 0x3308, 0x18eb: 0x3308, 0x18ec: 0x3308, 0x18ed: 0x0040, 0x18ee: 0x0040, 0x18ef: 0x0040,
0x18f0: 0x3308, 0x18f1: 0x3308, 0x18f2: 0x3308, 0x18f3: 0x3308, 0x18f4: 0x3308, 0x18f5: 0x0040,
0x18f6: 0x0040, 0x18f7: 0x0040, 0x18f8: 0x0040, 0x18f9: 0x0040, 0x18fa: 0x0040, 0x18fb: 0x0040,
0x18fc: 0x0040, 0x18fd: 0x0040, 0x18fe: 0x0040, 0x18ff: 0x0040,
// Block 0x64, offset 0x1900
0x1900: 0x0008, 0x1901: 0x0008, 0x1902: 0x0008, 0x1903: 0x0008, 0x1904: 0x0008, 0x1905: 0x0008,
0x1906: 0x0008, 0x1907: 0x0040, 0x1908: 0x0040, 0x1909: 0x0008, 0x190a: 0x0040, 0x190b: 0x0040,
0x190c: 0x0008, 0x190d: 0x0008, 0x190e: 0x0008, 0x190f: 0x0008, 0x1910: 0x0008, 0x1911: 0x0008,
0x1912: 0x0008, 0x1913: 0x0008, 0x1914: 0x0040, 0x1915: 0x0008, 0x1916: 0x0008, 0x1917: 0x0040,
0x1918: 0x0008, 0x1919: 0x0008, 0x191a: 0x0008, 0x191b: 0x0008, 0x191c: 0x0008, 0x191d: 0x0008,
0x191e: 0x0008, 0x191f: 0x0008, 0x1920: 0x0008, 0x1921: 0x0008, 0x1922: 0x0008, 0x1923: 0x0008,
0x1924: 0x0008, 0x1925: 0x0008, 0x1926: 0x0008, 0x1927: 0x0008, 0x1928: 0x0008, 0x1929: 0x0008,
0x192a: 0x0008, 0x192b: 0x0008, 0x192c: 0x0008, 0x192d: 0x0008, 0x192e: 0x0008, 0x192f: 0x0008,
0x1930: 0x3008, 0x1931: 0x3008, 0x1932: 0x3008, 0x1933: 0x3008, 0x1934: 0x3008, 0x1935: 0x3008,
0x1936: 0x0040, 0x1937: 0x3008, 0x1938: 0x3008, 0x1939: 0x0040, 0x193a: 0x0040, 0x193b: 0x3308,
0x193c: 0x3308, 0x193d: 0x3808, 0x193e: 0x3b08, 0x193f: 0x0008,
// Block 0x65, offset 0x1940
0x1940: 0x0019, 0x1941: 0x02e9, 0x1942: 0x03d9, 0x1943: 0x02f1, 0x1944: 0x02f9, 0x1945: 0x03f1,
0x1946: 0x0309, 0x1947: 0x00a9, 0x1948: 0x0311, 0x1949: 0x00b1, 0x194a: 0x0319, 0x194b: 0x0101,
0x194c: 0x0321, 0x194d: 0x0329, 0x194e: 0x0051, 0x194f: 0x0339, 0x1950: 0x0751, 0x1951: 0x00b9,
0x1952: 0x0089, 0x1953: 0x0341, 0x1954: 0x0349, 0x1955: 0x0391, 0x1956: 0x00c1, 0x1957: 0x0109,
0x1958: 0x00c9, 0x1959: 0x04b1, 0x195a: 0x0019, 0x195b: 0x02e9, 0x195c: 0x03d9, 0x195d: 0x02f1,
0x195e: 0x02f9, 0x195f: 0x03f1, 0x1960: 0x0309, 0x1961: 0x00a9, 0x1962: 0x0311, 0x1963: 0x00b1,
0x1964: 0x0319, 0x1965: 0x0101, 0x1966: 0x0321, 0x1967: 0x0329, 0x1968: 0x0051, 0x1969: 0x0339,
0x196a: 0x0751, 0x196b: 0x00b9, 0x196c: 0x0089, 0x196d: 0x0341, 0x196e: 0x0349, 0x196f: 0x0391,
0x1970: 0x00c1, 0x1971: 0x0109, 0x1972: 0x00c9, 0x1973: 0x04b1, 0x1974: 0x0019, 0x1975: 0x02e9,
0x1976: 0x03d9, 0x1977: 0x02f1, 0x1978: 0x02f9, 0x1979: 0x03f1, 0x197a: 0x0309, 0x197b: 0x00a9,
0x197c: 0x0311, 0x197d: 0x00b1, 0x197e: 0x0319, 0x197f: 0x0101,
// Block 0x66, offset 0x1980
0x1980: 0x0321, 0x1981: 0x0329, 0x1982: 0x0051, 0x1983: 0x0339, 0x1984: 0x0751, 0x1985: 0x00b9,
0x1986: 0x0089, 0x1987: 0x0341, 0x1988: 0x0349, 0x1989: 0x0391, 0x198a: 0x00c1, 0x198b: 0x0109,
0x198c: 0x00c9, 0x198d: 0x04b1, 0x198e: 0x0019, 0x198f: 0x02e9, 0x1990: 0x03d9, 0x1991: 0x02f1,
0x1992: 0x02f9, 0x1993: 0x03f1, 0x1994: 0x0309, 0x1995: 0x0040, 0x1996: 0x0311, 0x1997: 0x00b1,
0x1998: 0x0319, 0x1999: 0x0101, 0x199a: 0x0321, 0x199b: 0x0329, 0x199c: 0x0051, 0x199d: 0x0339,
0x199e: 0x0751, 0x199f: 0x00b9, 0x19a0: 0x0089, 0x19a1: 0x0341, 0x19a2: 0x0349, 0x19a3: 0x0391,
0x19a4: 0x00c1, 0x19a5: 0x0109, 0x19a6: 0x00c9, 0x19a7: 0x04b1, 0x19a8: 0x0019, 0x19a9: 0x02e9,
0x19aa: 0x03d9, 0x19ab: 0x02f1, 0x19ac: 0x02f9, 0x19ad: 0x03f1, 0x19ae: 0x0309, 0x19af: 0x00a9,
0x19b0: 0x0311, 0x19b1: 0x00b1, 0x19b2: 0x0319, 0x19b3: 0x0101, 0x19b4: 0x0321, 0x19b5: 0x0329,
0x19b6: 0x0051, 0x19b7: 0x0339, 0x19b8: 0x0751, 0x19b9: 0x00b9, 0x19ba: 0x0089, 0x19bb: 0x0341,
0x19bc: 0x0349, 0x19bd: 0x0391, 0x19be: 0x00c1, 0x19bf: 0x0109,
// Block 0x67, offset 0x19c0
0x19c0: 0x00c9, 0x19c1: 0x04b1, 0x19c2: 0x0019, 0x19c3: 0x02e9, 0x19c4: 0x03d9, 0x19c5: 0x02f1,
0x19c6: 0x02f9, 0x19c7: 0x03f1, 0x19c8: 0x0309, 0x19c9: 0x00a9, 0x19ca: 0x0311, 0x19cb: 0x00b1,
0x19cc: 0x0319, 0x19cd: 0x0101, 0x19ce: 0x0321, 0x19cf: 0x0329, 0x19d0: 0x0051, 0x19d1: 0x0339,
0x19d2: 0x0751, 0x19d3: 0x00b9, 0x19d4: 0x0089, 0x19d5: 0x0341, 0x19d6: 0x0349, 0x19d7: 0x0391,
0x19d8: 0x00c1, 0x19d9: 0x0109, 0x19da: 0x00c9, 0x19db: 0x04b1, 0x19dc: 0x0019, 0x19dd: 0x0040,
0x19de: 0x03d9, 0x19df: 0x02f1, 0x19e0: 0x0040, 0x19e1: 0x0040, 0x19e2: 0x0309, 0x19e3: 0x0040,
0x19e4: 0x0040, 0x19e5: 0x00b1, 0x19e6: 0x0319, 0x19e7: 0x0040, 0x19e8: 0x0040, 0x19e9: 0x0329,
0x19ea: 0x0051, 0x19eb: 0x0339, 0x19ec: 0x0751, 0x19ed: 0x0040, 0x19ee: 0x0089, 0x19ef: 0x0341,
0x19f0: 0x0349, 0x19f1: 0x0391, 0x19f2: 0x00c1, 0x19f3: 0x0109, 0x19f4: 0x00c9, 0x19f5: 0x04b1,
0x19f6: 0x0019, 0x19f7: 0x02e9, 0x19f8: 0x03d9, 0x19f9: 0x02f1, 0x19fa: 0x0040, 0x19fb: 0x03f1,
0x19fc: 0x0040, 0x19fd: 0x00a9, 0x19fe: 0x0311, 0x19ff: 0x00b1,
// Block 0x68, offset 0x1a00
0x1a00: 0x0319, 0x1a01: 0x0101, 0x1a02: 0x0321, 0x1a03: 0x0329, 0x1a04: 0x0040, 0x1a05: 0x0339,
0x1a06: 0x0751, 0x1a07: 0x00b9, 0x1a08: 0x0089, 0x1a09: 0x0341, 0x1a0a: 0x0349, 0x1a0b: 0x0391,
0x1a0c: 0x00c1, 0x1a0d: 0x0109, 0x1a0e: 0x00c9, 0x1a0f: 0x04b1, 0x1a10: 0x0019, 0x1a11: 0x02e9,
0x1a12: 0x03d9, 0x1a13: 0x02f1, 0x1a14: 0x02f9, 0x1a15: 0x03f1, 0x1a16: 0x0309, 0x1a17: 0x00a9,
0x1a18: 0x0311, 0x1a19: 0x00b1, 0x1a1a: 0x0319, 0x1a1b: 0x0101, 0x1a1c: 0x0321, 0x1a1d: 0x0329,
0x1a1e: 0x0051, 0x1a1f: 0x0339, 0x1a20: 0x0751, 0x1a21: 0x00b9, 0x1a22: 0x0089, 0x1a23: 0x0341,
0x1a24: 0x0349, 0x1a25: 0x0391, 0x1a26: 0x00c1, 0x1a27: 0x0109, 0x1a28: 0x00c9, 0x1a29: 0x04b1,
0x1a2a: 0x0019, 0x1a2b: 0x02e9, 0x1a2c: 0x03d9, 0x1a2d: 0x02f1, 0x1a2e: 0x02f9, 0x1a2f: 0x03f1,
0x1a30: 0x0309, 0x1a31: 0x00a9, 0x1a32: 0x0311, 0x1a33: 0x00b1, 0x1a34: 0x0319, 0x1a35: 0x0101,
0x1a36: 0x0321, 0x1a37: 0x0329, 0x1a38: 0x0051, 0x1a39: 0x0339, 0x1a3a: 0x0751, 0x1a3b: 0x00b9,
0x1a3c: 0x0089, 0x1a3d: 0x0341, 0x1a3e: 0x0349, 0x1a3f: 0x0391,
// Block 0x69, offset 0x1a40
0x1a40: 0x00c1, 0x1a41: 0x0109, 0x1a42: 0x00c9, 0x1a43: 0x04b1, 0x1a44: 0x0019, 0x1a45: 0x02e9,
0x1a46: 0x0040, 0x1a47: 0x02f1, 0x1a48: 0x02f9, 0x1a49: 0x03f1, 0x1a4a: 0x0309, 0x1a4b: 0x0040,
0x1a4c: 0x0040, 0x1a4d: 0x00b1, 0x1a4e: 0x0319, 0x1a4f: 0x0101, 0x1a50: 0x0321, 0x1a51: 0x0329,
0x1a52: 0x0051, 0x1a53: 0x0339, 0x1a54: 0x0751, 0x1a55: 0x0040, 0x1a56: 0x0089, 0x1a57: 0x0341,
0x1a58: 0x0349, 0x1a59: 0x0391, 0x1a5a: 0x00c1, 0x1a5b: 0x0109, 0x1a5c: 0x00c9, 0x1a5d: 0x0040,
0x1a5e: 0x0019, 0x1a5f: 0x02e9, 0x1a60: 0x03d9, 0x1a61: 0x02f1, 0x1a62: 0x02f9, 0x1a63: 0x03f1,
0x1a64: 0x0309, 0x1a65: 0x00a9, 0x1a66: 0x0311, 0x1a67: 0x00b1, 0x1a68: 0x0319, 0x1a69: 0x0101,
0x1a6a: 0x0321, 0x1a6b: 0x0329, 0x1a6c: 0x0051, 0x1a6d: 0x0339, 0x1a6e: 0x0751, 0x1a6f: 0x00b9,
0x1a70: 0x0089, 0x1a71: 0x0341, 0x1a72: 0x0349, 0x1a73: 0x0391, 0x1a74: 0x00c1, 0x1a75: 0x0109,
0x1a76: 0x00c9, 0x1a77: 0x04b1, 0x1a78: 0x0019, 0x1a79: 0x02e9, 0x1a7a: 0x0040, 0x1a7b: 0x02f1,
0x1a7c: 0x02f9, 0x1a7d: 0x03f1, 0x1a7e: 0x0309, 0x1a7f: 0x0040,
// Block 0x6a, offset 0x1a80
0x1a80: 0x0311, 0x1a81: 0x00b1, 0x1a82: 0x0319, 0x1a83: 0x0101, 0x1a84: 0x0321, 0x1a85: 0x0040,
0x1a86: 0x0051, 0x1a87: 0x0040, 0x1a88: 0x0040, 0x1a89: 0x0040, 0x1a8a: 0x0089, 0x1a8b: 0x0341,
0x1a8c: 0x0349, 0x1a8d: 0x0391, 0x1a8e: 0x00c1, 0x1a8f: 0x0109, 0x1a90: 0x00c9, 0x1a91: 0x0040,
0x1a92: 0x0019, 0x1a93: 0x02e9, 0x1a94: 0x03d9, 0x1a95: 0x02f1, 0x1a96: 0x02f9, 0x1a97: 0x03f1,
0x1a98: 0x0309, 0x1a99: 0x00a9, 0x1a9a: 0x0311, 0x1a9b: 0x00b1, 0x1a9c: 0x0319, 0x1a9d: 0x0101,
0x1a9e: 0x0321, 0x1a9f: 0x0329, 0x1aa0: 0x0051, 0x1aa1: 0x0339, 0x1aa2: 0x0751, 0x1aa3: 0x00b9,
0x1aa4: 0x0089, 0x1aa5: 0x0341, 0x1aa6: 0x0349, 0x1aa7: 0x0391, 0x1aa8: 0x00c1, 0x1aa9: 0x0109,
0x1aaa: 0x00c9, 0x1aab: 0x04b1, 0x1aac: 0x0019, 0x1aad: 0x02e9, 0x1aae: 0x03d9, 0x1aaf: 0x02f1,
0x1ab0: 0x02f9, 0x1ab1: 0x03f1, 0x1ab2: 0x0309, 0x1ab3: 0x00a9, 0x1ab4: 0x0311, 0x1ab5: 0x00b1,
0x1ab6: 0x0319, 0x1ab7: 0x0101, 0x1ab8: 0x0321, 0x1ab9: 0x0329, 0x1aba: 0x0051, 0x1abb: 0x0339,
0x1abc: 0x0751, 0x1abd: 0x00b9, 0x1abe: 0x0089, 0x1abf: 0x0341,
// Block 0x6b, offset 0x1ac0
0x1ac0: 0x0349, 0x1ac1: 0x0391, 0x1ac2: 0x00c1, 0x1ac3: 0x0109, 0x1ac4: 0x00c9, 0x1ac5: 0x04b1,
0x1ac6: 0x0019, 0x1ac7: 0x02e9, 0x1ac8: 0x03d9, 0x1ac9: 0x02f1, 0x1aca: 0x02f9, 0x1acb: 0x03f1,
0x1acc: 0x0309, 0x1acd: 0x00a9, 0x1ace: 0x0311, 0x1acf: 0x00b1, 0x1ad0: 0x0319, 0x1ad1: 0x0101,
0x1ad2: 0x0321, 0x1ad3: 0x0329, 0x1ad4: 0x0051, 0x1ad5: 0x0339, 0x1ad6: 0x0751, 0x1ad7: 0x00b9,
0x1ad8: 0x0089, 0x1ad9: 0x0341, 0x1ada: 0x0349, 0x1adb: 0x0391, 0x1adc: 0x00c1, 0x1add: 0x0109,
0x1ade: 0x00c9, 0x1adf: 0x04b1, 0x1ae0: 0x0019, 0x1ae1: 0x02e9, 0x1ae2: 0x03d9, 0x1ae3: 0x02f1,
0x1ae4: 0x02f9, 0x1ae5: 0x03f1, 0x1ae6: 0x0309, 0x1ae7: 0x00a9, 0x1ae8: 0x0311, 0x1ae9: 0x00b1,
0x1aea: 0x0319, 0x1aeb: 0x0101, 0x1aec: 0x0321, 0x1aed: 0x0329, 0x1aee: 0x0051, 0x1aef: 0x0339,
0x1af0: 0x0751, 0x1af1: 0x00b9, 0x1af2: 0x0089, 0x1af3: 0x0341, 0x1af4: 0x0349, 0x1af5: 0x0391,
0x1af6: 0x00c1, 0x1af7: 0x0109, 0x1af8: 0x00c9, 0x1af9: 0x04b1, 0x1afa: 0x0019, 0x1afb: 0x02e9,
0x1afc: 0x03d9, 0x1afd: 0x02f1, 0x1afe: 0x02f9, 0x1aff: 0x03f1,
// Block 0x6c, offset 0x1b00
0x1b00: 0x0309, 0x1b01: 0x00a9, 0x1b02: 0x0311, 0x1b03: 0x00b1, 0x1b04: 0x0319, 0x1b05: 0x0101,
0x1b06: 0x0321, 0x1b07: 0x0329, 0x1b08: 0x0051, 0x1b09: 0x0339, 0x1b0a: 0x0751, 0x1b0b: 0x00b9,
0x1b0c: 0x0089, 0x1b0d: 0x0341, 0x1b0e: 0x0349, 0x1b0f: 0x0391, 0x1b10: 0x00c1, 0x1b11: 0x0109,
0x1b12: 0x00c9, 0x1b13: 0x04b1, 0x1b14: 0x0019, 0x1b15: 0x02e9, 0x1b16: 0x03d9, 0x1b17: 0x02f1,
0x1b18: 0x02f9, 0x1b19: 0x03f1, 0x1b1a: 0x0309, 0x1b1b: 0x00a9, 0x1b1c: 0x0311, 0x1b1d: 0x00b1,
0x1b1e: 0x0319, 0x1b1f: 0x0101, 0x1b20: 0x0321, 0x1b21: 0x0329, 0x1b22: 0x0051, 0x1b23: 0x0339,
0x1b24: 0x0751, 0x1b25: 0x00b9, 0x1b26: 0x0089, 0x1b27: 0x0341, 0x1b28: 0x0349, 0x1b29: 0x0391,
0x1b2a: 0x00c1, 0x1b2b: 0x0109, 0x1b2c: 0x00c9, 0x1b2d: 0x04b1, 0x1b2e: 0x0019, 0x1b2f: 0x02e9,
0x1b30: 0x03d9, 0x1b31: 0x02f1, 0x1b32: 0x02f9, 0x1b33: 0x03f1, 0x1b34: 0x0309, 0x1b35: 0x00a9,
0x1b36: 0x0311, 0x1b37: 0x00b1, 0x1b38: 0x0319, 0x1b39: 0x0101, 0x1b3a: 0x0321, 0x1b3b: 0x0329,
0x1b3c: 0x0051, 0x1b3d: 0x0339, 0x1b3e: 0x0751, 0x1b3f: 0x00b9,
// Block 0x6d, offset 0x1b40
0x1b40: 0x0089, 0x1b41: 0x0341, 0x1b42: 0x0349, 0x1b43: 0x0391, 0x1b44: 0x00c1, 0x1b45: 0x0109,
0x1b46: 0x00c9, 0x1b47: 0x04b1, 0x1b48: 0x0019, 0x1b49: 0x02e9, 0x1b4a: 0x03d9, 0x1b4b: 0x02f1,
0x1b4c: 0x02f9, 0x1b4d: 0x03f1, 0x1b4e: 0x0309, 0x1b4f: 0x00a9, 0x1b50: 0x0311, 0x1b51: 0x00b1,
0x1b52: 0x0319, 0x1b53: 0x0101, 0x1b54: 0x0321, 0x1b55: 0x0329, 0x1b56: 0x0051, 0x1b57: 0x0339,
0x1b58: 0x0751, 0x1b59: 0x00b9, 0x1b5a: 0x0089, 0x1b5b: 0x0341, 0x1b5c: 0x0349, 0x1b5d: 0x0391,
0x1b5e: 0x00c1, 0x1b5f: 0x0109, 0x1b60: 0x00c9, 0x1b61: 0x04b1, 0x1b62: 0x0019, 0x1b63: 0x02e9,
0x1b64: 0x03d9, 0x1b65: 0x02f1, 0x1b66: 0x02f9, 0x1b67: 0x03f1, 0x1b68: 0x0309, 0x1b69: 0x00a9,
0x1b6a: 0x0311, 0x1b6b: 0x00b1, 0x1b6c: 0x0319, 0x1b6d: 0x0101, 0x1b6e: 0x0321, 0x1b6f: 0x0329,
0x1b70: 0x0051, 0x1b71: 0x0339, 0x1b72: 0x0751, 0x1b73: 0x00b9, 0x1b74: 0x0089, 0x1b75: 0x0341,
0x1b76: 0x0349, 0x1b77: 0x0391, 0x1b78: 0x00c1, 0x1b79: 0x0109, 0x1b7a: 0x00c9, 0x1b7b: 0x04b1,
0x1b7c: 0x0019, 0x1b7d: 0x02e9, 0x1b7e: 0x03d9, 0x1b7f: 0x02f1,
// Block 0x6e, offset 0x1b80
0x1b80: 0x02f9, 0x1b81: 0x03f1, 0x1b82: 0x0309, 0x1b83: 0x00a9, 0x1b84: 0x0311, 0x1b85: 0x00b1,
0x1b86: 0x0319, 0x1b87: 0x0101, 0x1b88: 0x0321, 0x1b89: 0x0329, 0x1b8a: 0x0051, 0x1b8b: 0x0339,
0x1b8c: 0x0751, 0x1b8d: 0x00b9, 0x1b8e: 0x0089, 0x1b8f: 0x0341, 0x1b90: 0x0349, 0x1b91: 0x0391,
0x1b92: 0x00c1, 0x1b93: 0x0109, 0x1b94: 0x00c9, 0x1b95: 0x04b1, 0x1b96: 0x0019, 0x1b97: 0x02e9,
0x1b98: 0x03d9, 0x1b99: 0x02f1, 0x1b9a: 0x02f9, 0x1b9b: 0x03f1, 0x1b9c: 0x0309, 0x1b9d: 0x00a9,
0x1b9e: 0x0311, 0x1b9f: 0x00b1, 0x1ba0: 0x0319, 0x1ba1: 0x0101, 0x1ba2: 0x0321, 0x1ba3: 0x0329,
0x1ba4: 0x0051, 0x1ba5: 0x0339, 0x1ba6: 0x0751, 0x1ba7: 0x00b9, 0x1ba8: 0x0089, 0x1ba9: 0x0341,
0x1baa: 0x0349, 0x1bab: 0x0391, 0x1bac: 0x00c1, 0x1bad: 0x0109, 0x1bae: 0x00c9, 0x1baf: 0x04b1,
0x1bb0: 0x0019, 0x1bb1: 0x02e9, 0x1bb2: 0x03d9, 0x1bb3: 0x02f1, 0x1bb4: 0x02f9, 0x1bb5: 0x03f1,
0x1bb6: 0x0309, 0x1bb7: 0x00a9, 0x1bb8: 0x0311, 0x1bb9: 0x00b1, 0x1bba: 0x0319, 0x1bbb: 0x0101,
0x1bbc: 0x0321, 0x1bbd: 0x0329, 0x1bbe: 0x0051, 0x1bbf: 0x0339,
// Block 0x6f, offset 0x1bc0
0x1bc0: 0x0751, 0x1bc1: 0x00b9, 0x1bc2: 0x0089, 0x1bc3: 0x0341, 0x1bc4: 0x0349, 0x1bc5: 0x0391,
0x1bc6: 0x00c1, 0x1bc7: 0x0109, 0x1bc8: 0x00c9, 0x1bc9: 0x04b1, 0x1bca: 0x0019, 0x1bcb: 0x02e9,
0x1bcc: 0x03d9, 0x1bcd: 0x02f1, 0x1bce: 0x02f9, 0x1bcf: 0x03f1, 0x1bd0: 0x0309, 0x1bd1: 0x00a9,
0x1bd2: 0x0311, 0x1bd3: 0x00b1, 0x1bd4: 0x0319, 0x1bd5: 0x0101, 0x1bd6: 0x0321, 0x1bd7: 0x0329,
0x1bd8: 0x0051, 0x1bd9: 0x0339, 0x1bda: 0x0751, 0x1bdb: 0x00b9, 0x1bdc: 0x0089, 0x1bdd: 0x0341,
0x1bde: 0x0349, 0x1bdf: 0x0391, 0x1be0: 0x00c1, 0x1be1: 0x0109, 0x1be2: 0x00c9, 0x1be3: 0x04b1,
0x1be4: 0x23e1, 0x1be5: 0x23e9, 0x1be6: 0x0040, 0x1be7: 0x0040, 0x1be8: 0x23f1, 0x1be9: 0x0399,
0x1bea: 0x03a1, 0x1beb: 0x03a9, 0x1bec: 0x23f9, 0x1bed: 0x2401, 0x1bee: 0x2409, 0x1bef: 0x04d1,
0x1bf0: 0x05f9, 0x1bf1: 0x2411, 0x1bf2: 0x2419, 0x1bf3: 0x2421, 0x1bf4: 0x2429, 0x1bf5: 0x2431,
0x1bf6: 0x2439, 0x1bf7: 0x0799, 0x1bf8: 0x03c1, 0x1bf9: 0x04d1, 0x1bfa: 0x2441, 0x1bfb: 0x2449,
0x1bfc: 0x2451, 0x1bfd: 0x03b1, 0x1bfe: 0x03b9, 0x1bff: 0x2459,
// Block 0x70, offset 0x1c00
0x1c00: 0x0769, 0x1c01: 0x2461, 0x1c02: 0x23f1, 0x1c03: 0x0399, 0x1c04: 0x03a1, 0x1c05: 0x03a9,
0x1c06: 0x23f9, 0x1c07: 0x2401, 0x1c08: 0x2409, 0x1c09: 0x04d1, 0x1c0a: 0x05f9, 0x1c0b: 0x2411,
0x1c0c: 0x2419, 0x1c0d: 0x2421, 0x1c0e: 0x2429, 0x1c0f: 0x2431, 0x1c10: 0x2439, 0x1c11: 0x0799,
0x1c12: 0x03c1, 0x1c13: 0x2441, 0x1c14: 0x2441, 0x1c15: 0x2449, 0x1c16: 0x2451, 0x1c17: 0x03b1,
0x1c18: 0x03b9, 0x1c19: 0x2459, 0x1c1a: 0x0769, 0x1c1b: 0x2469, 0x1c1c: 0x23f9, 0x1c1d: 0x04d1,
0x1c1e: 0x2411, 0x1c1f: 0x03b1, 0x1c20: 0x03c1, 0x1c21: 0x0799, 0x1c22: 0x23f1, 0x1c23: 0x0399,
0x1c24: 0x03a1, 0x1c25: 0x03a9, 0x1c26: 0x23f9, 0x1c27: 0x2401, 0x1c28: 0x2409, 0x1c29: 0x04d1,
0x1c2a: 0x05f9, 0x1c2b: 0x2411, 0x1c2c: 0x2419, 0x1c2d: 0x2421, 0x1c2e: 0x2429, 0x1c2f: 0x2431,
0x1c30: 0x2439, 0x1c31: 0x0799, 0x1c32: 0x03c1, 0x1c33: 0x04d1, 0x1c34: 0x2441, 0x1c35: 0x2449,
0x1c36: 0x2451, 0x1c37: 0x03b1, 0x1c38: 0x03b9, 0x1c39: 0x2459, 0x1c3a: 0x0769, 0x1c3b: 0x2461,
0x1c3c: 0x23f1, 0x1c3d: 0x0399, 0x1c3e: 0x03a1, 0x1c3f: 0x03a9,
// Block 0x71, offset 0x1c40
0x1c40: 0x23f9, 0x1c41: 0x2401, 0x1c42: 0x2409, 0x1c43: 0x04d1, 0x1c44: 0x05f9, 0x1c45: 0x2411,
0x1c46: 0x2419, 0x1c47: 0x2421, 0x1c48: 0x2429, 0x1c49: 0x2431, 0x1c4a: 0x2439, 0x1c4b: 0x0799,
0x1c4c: 0x03c1, 0x1c4d: 0x2441, 0x1c4e: 0x2441, 0x1c4f: 0x2449, 0x1c50: 0x2451, 0x1c51: 0x03b1,
0x1c52: 0x03b9, 0x1c53: 0x2459, 0x1c54: 0x0769, 0x1c55: 0x2469, 0x1c56: 0x23f9, 0x1c57: 0x04d1,
0x1c58: 0x2411, 0x1c59: 0x03b1, 0x1c5a: 0x03c1, 0x1c5b: 0x0799, 0x1c5c: 0x23f1, 0x1c5d: 0x0399,
0x1c5e: 0x03a1, 0x1c5f: 0x03a9, 0x1c60: 0x23f9, 0x1c61: 0x2401, 0x1c62: 0x2409, 0x1c63: 0x04d1,
0x1c64: 0x05f9, 0x1c65: 0x2411, 0x1c66: 0x2419, 0x1c67: 0x2421, 0x1c68: 0x2429, 0x1c69: 0x2431,
0x1c6a: 0x2439, 0x1c6b: 0x0799, 0x1c6c: 0x03c1, 0x1c6d: 0x04d1, 0x1c6e: 0x2441, 0x1c6f: 0x2449,
0x1c70: 0x2451, 0x1c71: 0x03b1, 0x1c72: 0x03b9, 0x1c73: 0x2459, 0x1c74: 0x0769, 0x1c75: 0x2461,
0x1c76: 0x23f1, 0x1c77: 0x0399, 0x1c78: 0x03a1, 0x1c79: 0x03a9, 0x1c7a: 0x23f9, 0x1c7b: 0x2401,
0x1c7c: 0x2409, 0x1c7d: 0x04d1, 0x1c7e: 0x05f9, 0x1c7f: 0x2411,
// Block 0x72, offset 0x1c80
0x1c80: 0x2419, 0x1c81: 0x2421, 0x1c82: 0x2429, 0x1c83: 0x2431, 0x1c84: 0x2439, 0x1c85: 0x0799,
0x1c86: 0x03c1, 0x1c87: 0x2441, 0x1c88: 0x2441, 0x1c89: 0x2449, 0x1c8a: 0x2451, 0x1c8b: 0x03b1,
0x1c8c: 0x03b9, 0x1c8d: 0x2459, 0x1c8e: 0x0769, 0x1c8f: 0x2469, 0x1c90: 0x23f9, 0x1c91: 0x04d1,
0x1c92: 0x2411, 0x1c93: 0x03b1, 0x1c94: 0x03c1, 0x1c95: 0x0799, 0x1c96: 0x23f1, 0x1c97: 0x0399,
0x1c98: 0x03a1, 0x1c99: 0x03a9, 0x1c9a: 0x23f9, 0x1c9b: 0x2401, 0x1c9c: 0x2409, 0x1c9d: 0x04d1,
0x1c9e: 0x05f9, 0x1c9f: 0x2411, 0x1ca0: 0x2419, 0x1ca1: 0x2421, 0x1ca2: 0x2429, 0x1ca3: 0x2431,
0x1ca4: 0x2439, 0x1ca5: 0x0799, 0x1ca6: 0x03c1, 0x1ca7: 0x04d1, 0x1ca8: 0x2441, 0x1ca9: 0x2449,
0x1caa: 0x2451, 0x1cab: 0x03b1, 0x1cac: 0x03b9, 0x1cad: 0x2459, 0x1cae: 0x0769, 0x1caf: 0x2461,
0x1cb0: 0x23f1, 0x1cb1: 0x0399, 0x1cb2: 0x03a1, 0x1cb3: 0x03a9, 0x1cb4: 0x23f9, 0x1cb5: 0x2401,
0x1cb6: 0x2409, 0x1cb7: 0x04d1, 0x1cb8: 0x05f9, 0x1cb9: 0x2411, 0x1cba: 0x2419, 0x1cbb: 0x2421,
0x1cbc: 0x2429, 0x1cbd: 0x2431, 0x1cbe: 0x2439, 0x1cbf: 0x0799,
// Block 0x73, offset 0x1cc0
0x1cc0: 0x03c1, 0x1cc1: 0x2441, 0x1cc2: 0x2441, 0x1cc3: 0x2449, 0x1cc4: 0x2451, 0x1cc5: 0x03b1,
0x1cc6: 0x03b9, 0x1cc7: 0x2459, 0x1cc8: 0x0769, 0x1cc9: 0x2469, 0x1cca: 0x23f9, 0x1ccb: 0x04d1,
0x1ccc: 0x2411, 0x1ccd: 0x03b1, 0x1cce: 0x03c1, 0x1ccf: 0x0799, 0x1cd0: 0x23f1, 0x1cd1: 0x0399,
0x1cd2: 0x03a1, 0x1cd3: 0x03a9, 0x1cd4: 0x23f9, 0x1cd5: 0x2401, 0x1cd6: 0x2409, 0x1cd7: 0x04d1,
0x1cd8: 0x05f9, 0x1cd9: 0x2411, 0x1cda: 0x2419, 0x1cdb: 0x2421, 0x1cdc: 0x2429, 0x1cdd: 0x2431,
0x1cde: 0x2439, 0x1cdf: 0x0799, 0x1ce0: 0x03c1, 0x1ce1: 0x04d1, 0x1ce2: 0x2441, 0x1ce3: 0x2449,
0x1ce4: 0x2451, 0x1ce5: 0x03b1, 0x1ce6: 0x03b9, 0x1ce7: 0x2459, 0x1ce8: 0x0769, 0x1ce9: 0x2461,
0x1cea: 0x23f1, 0x1ceb: 0x0399, 0x1cec: 0x03a1, 0x1ced: 0x03a9, 0x1cee: 0x23f9, 0x1cef: 0x2401,
0x1cf0: 0x2409, 0x1cf1: 0x04d1, 0x1cf2: 0x05f9, 0x1cf3: 0x2411, 0x1cf4: 0x2419, 0x1cf5: 0x2421,
0x1cf6: 0x2429, 0x1cf7: 0x2431, 0x1cf8: 0x2439, 0x1cf9: 0x0799, 0x1cfa: 0x03c1, 0x1cfb: 0x2441,
0x1cfc: 0x2441, 0x1cfd: 0x2449, 0x1cfe: 0x2451, 0x1cff: 0x03b1,
// Block 0x74, offset 0x1d00
0x1d00: 0x03b9, 0x1d01: 0x2459, 0x1d02: 0x0769, 0x1d03: 0x2469, 0x1d04: 0x23f9, 0x1d05: 0x04d1,
0x1d06: 0x2411, 0x1d07: 0x03b1, 0x1d08: 0x03c1, 0x1d09: 0x0799, 0x1d0a: 0x2471, 0x1d0b: 0x2471,
0x1d0c: 0x0040, 0x1d0d: 0x0040, 0x1d0e: 0x06e1, 0x1d0f: 0x0049, 0x1d10: 0x0029, 0x1d11: 0x0031,
0x1d12: 0x06e9, 0x1d13: 0x06f1, 0x1d14: 0x06f9, 0x1d15: 0x0701, 0x1d16: 0x0709, 0x1d17: 0x0711,
0x1d18: 0x06e1, 0x1d19: 0x0049, 0x1d1a: 0x0029, 0x1d1b: 0x0031, 0x1d1c: 0x06e9, 0x1d1d: 0x06f1,
0x1d1e: 0x06f9, 0x1d1f: 0x0701, 0x1d20: 0x0709, 0x1d21: 0x0711, 0x1d22: 0x06e1, 0x1d23: 0x0049,
0x1d24: 0x0029, 0x1d25: 0x0031, 0x1d26: 0x06e9, 0x1d27: 0x06f1, 0x1d28: 0x06f9, 0x1d29: 0x0701,
0x1d2a: 0x0709, 0x1d2b: 0x0711, 0x1d2c: 0x06e1, 0x1d2d: 0x0049, 0x1d2e: 0x0029, 0x1d2f: 0x0031,
0x1d30: 0x06e9, 0x1d31: 0x06f1, 0x1d32: 0x06f9, 0x1d33: 0x0701, 0x1d34: 0x0709, 0x1d35: 0x0711,
0x1d36: 0x06e1, 0x1d37: 0x0049, 0x1d38: 0x0029, 0x1d39: 0x0031, 0x1d3a: 0x06e9, 0x1d3b: 0x06f1,
0x1d3c: 0x06f9, 0x1d3d: 0x0701, 0x1d3e: 0x0709, 0x1d3f: 0x0711,
// Block 0x75, offset 0x1d40
0x1d40: 0x3308, 0x1d41: 0x3308, 0x1d42: 0x3308, 0x1d43: 0x3308, 0x1d44: 0x3308, 0x1d45: 0x3308,
0x1d46: 0x3308, 0x1d47: 0x0040, 0x1d48: 0x3308, 0x1d49: 0x3308, 0x1d4a: 0x3308, 0x1d4b: 0x3308,
0x1d4c: 0x3308, 0x1d4d: 0x3308, 0x1d4e: 0x3308, 0x1d4f: 0x3308, 0x1d50: 0x3308, 0x1d51: 0x3308,
0x1d52: 0x3308, 0x1d53: 0x3308, 0x1d54: 0x3308, 0x1d55: 0x3308, 0x1d56: 0x3308, 0x1d57: 0x3308,
0x1d58: 0x3308, 0x1d59: 0x0040, 0x1d5a: 0x0040, 0x1d5b: 0x3308, 0x1d5c: 0x3308, 0x1d5d: 0x3308,
0x1d5e: 0x3308, 0x1d5f: 0x3308, 0x1d60: 0x3308, 0x1d61: 0x3308, 0x1d62: 0x0040, 0x1d63: 0x3308,
0x1d64: 0x3308, 0x1d65: 0x0040, 0x1d66: 0x3308, 0x1d67: 0x3308, 0x1d68: 0x3308, 0x1d69: 0x3308,
0x1d6a: 0x3308, 0x1d6b: 0x0040, 0x1d6c: 0x0040, 0x1d6d: 0x0040, 0x1d6e: 0x0040, 0x1d6f: 0x0040,
0x1d70: 0x2479, 0x1d71: 0x2481, 0x1d72: 0x02a9, 0x1d73: 0x2489, 0x1d74: 0x02b1, 0x1d75: 0x2491,
0x1d76: 0x2499, 0x1d77: 0x24a1, 0x1d78: 0x24a9, 0x1d79: 0x24b1, 0x1d7a: 0x24b9, 0x1d7b: 0x24c1,
0x1d7c: 0x02b9, 0x1d7d: 0x24c9, 0x1d7e: 0x24d1, 0x1d7f: 0x02c1,
// Block 0x76, offset 0x1d80
0x1d80: 0x02c9, 0x1d81: 0x24d9, 0x1d82: 0x24e1, 0x1d83: 0x24e9, 0x1d84: 0x24f1, 0x1d85: 0x24f9,
0x1d86: 0x2501, 0x1d87: 0x2509, 0x1d88: 0x2511, 0x1d89: 0x2519, 0x1d8a: 0x2521, 0x1d8b: 0x2529,
0x1d8c: 0x2531, 0x1d8d: 0x2539, 0x1d8e: 0x2541, 0x1d8f: 0x2549, 0x1d90: 0x2551, 0x1d91: 0x2479,
0x1d92: 0x2481, 0x1d93: 0x02a9, 0x1d94: 0x2489, 0x1d95: 0x02b1, 0x1d96: 0x2491, 0x1d97: 0x2499,
0x1d98: 0x24a1, 0x1d99: 0x24a9, 0x1d9a: 0x24b1, 0x1d9b: 0x24b9, 0x1d9c: 0x02b9, 0x1d9d: 0x24c9,
0x1d9e: 0x02c1, 0x1d9f: 0x24d9, 0x1da0: 0x24e1, 0x1da1: 0x24e9, 0x1da2: 0x24f1, 0x1da3: 0x24f9,
0x1da4: 0x2501, 0x1da5: 0x02d1, 0x1da6: 0x2509, 0x1da7: 0x2559, 0x1da8: 0x2531, 0x1da9: 0x2561,
0x1daa: 0x2569, 0x1dab: 0x2571, 0x1dac: 0x2579, 0x1dad: 0x2581, 0x1dae: 0x0040, 0x1daf: 0x0040,
0x1db0: 0x0040, 0x1db1: 0x0040, 0x1db2: 0x0040, 0x1db3: 0x0040, 0x1db4: 0x0040, 0x1db5: 0x0040,
0x1db6: 0x0040, 0x1db7: 0x0040, 0x1db8: 0x0040, 0x1db9: 0x0040, 0x1dba: 0x0040, 0x1dbb: 0x0040,
0x1dbc: 0x0040, 0x1dbd: 0x0040, 0x1dbe: 0x0040, 0x1dbf: 0x0040,
// Block 0x77, offset 0x1dc0
0x1dc0: 0xe115, 0x1dc1: 0xe115, 0x1dc2: 0xe135, 0x1dc3: 0xe135, 0x1dc4: 0xe115, 0x1dc5: 0xe115,
0x1dc6: 0xe175, 0x1dc7: 0xe175, 0x1dc8: 0xe115, 0x1dc9: 0xe115, 0x1dca: 0xe135, 0x1dcb: 0xe135,
0x1dcc: 0xe115, 0x1dcd: 0xe115, 0x1dce: 0xe1f5, 0x1dcf: 0xe1f5, 0x1dd0: 0xe115, 0x1dd1: 0xe115,
0x1dd2: 0xe135, 0x1dd3: 0xe135, 0x1dd4: 0xe115, 0x1dd5: 0xe115, 0x1dd6: 0xe175, 0x1dd7: 0xe175,
0x1dd8: 0xe115, 0x1dd9: 0xe115, 0x1dda: 0xe135, 0x1ddb: 0xe135, 0x1ddc: 0xe115, 0x1ddd: 0xe115,
0x1dde: 0x8ca5, 0x1ddf: 0x8ca5, 0x1de0: 0x04b5, 0x1de1: 0x04b5, 0x1de2: 0x0a08, 0x1de3: 0x0a08,
0x1de4: 0x0a08, 0x1de5: 0x0a08, 0x1de6: 0x0a08, 0x1de7: 0x0a08, 0x1de8: 0x0a08, 0x1de9: 0x0a08,
0x1dea: 0x0a08, 0x1deb: 0x0a08, 0x1dec: 0x0a08, 0x1ded: 0x0a08, 0x1dee: 0x0a08, 0x1def: 0x0a08,
0x1df0: 0x0a08, 0x1df1: 0x0a08, 0x1df2: 0x0a08, 0x1df3: 0x0a08, 0x1df4: 0x0a08, 0x1df5: 0x0a08,
0x1df6: 0x0a08, 0x1df7: 0x0a08, 0x1df8: 0x0a08, 0x1df9: 0x0a08, 0x1dfa: 0x0a08, 0x1dfb: 0x0a08,
0x1dfc: 0x0a08, 0x1dfd: 0x0a08, 0x1dfe: 0x0a08, 0x1dff: 0x0a08,
// Block 0x78, offset 0x1e00
0x1e00: 0x20b1, 0x1e01: 0x20b9, 0x1e02: 0x20d9, 0x1e03: 0x20f1, 0x1e04: 0x0040, 0x1e05: 0x2189,
0x1e06: 0x2109, 0x1e07: 0x20e1, 0x1e08: 0x2131, 0x1e09: 0x2191, 0x1e0a: 0x2161, 0x1e0b: 0x2169,
0x1e0c: 0x2171, 0x1e0d: 0x2179, 0x1e0e: 0x2111, 0x1e0f: 0x2141, 0x1e10: 0x2151, 0x1e11: 0x2121,
0x1e12: 0x2159, 0x1e13: 0x2101, 0x1e14: 0x2119, 0x1e15: 0x20c9, 0x1e16: 0x20d1, 0x1e17: 0x20e9,
0x1e18: 0x20f9, 0x1e19: 0x2129, 0x1e1a: 0x2139, 0x1e1b: 0x2149, 0x1e1c: 0x2589, 0x1e1d: 0x1689,
0x1e1e: 0x2591, 0x1e1f: 0x2599, 0x1e20: 0x0040, 0x1e21: 0x20b9, 0x1e22: 0x20d9, 0x1e23: 0x0040,
0x1e24: 0x2181, 0x1e25: 0x0040, 0x1e26: 0x0040, 0x1e27: 0x20e1, 0x1e28: 0x0040, 0x1e29: 0x2191,
0x1e2a: 0x2161, 0x1e2b: 0x2169, 0x1e2c: 0x2171, 0x1e2d: 0x2179, 0x1e2e: 0x2111, 0x1e2f: 0x2141,
0x1e30: 0x2151, 0x1e31: 0x2121, 0x1e32: 0x2159, 0x1e33: 0x0040, 0x1e34: 0x2119, 0x1e35: 0x20c9,
0x1e36: 0x20d1, 0x1e37: 0x20e9, 0x1e38: 0x0040, 0x1e39: 0x2129, 0x1e3a: 0x0040, 0x1e3b: 0x2149,
0x1e3c: 0x0040, 0x1e3d: 0x0040, 0x1e3e: 0x0040, 0x1e3f: 0x0040,
// Block 0x79, offset 0x1e40
0x1e40: 0x0040, 0x1e41: 0x0040, 0x1e42: 0x20d9, 0x1e43: 0x0040, 0x1e44: 0x0040, 0x1e45: 0x0040,
0x1e46: 0x0040, 0x1e47: 0x20e1, 0x1e48: 0x0040, 0x1e49: 0x2191, 0x1e4a: 0x0040, 0x1e4b: 0x2169,
0x1e4c: 0x0040, 0x1e4d: 0x2179, 0x1e4e: 0x2111, 0x1e4f: 0x2141, 0x1e50: 0x0040, 0x1e51: 0x2121,
0x1e52: 0x2159, 0x1e53: 0x0040, 0x1e54: 0x2119, 0x1e55: 0x0040, 0x1e56: 0x0040, 0x1e57: 0x20e9,
0x1e58: 0x0040, 0x1e59: 0x2129, 0x1e5a: 0x0040, 0x1e5b: 0x2149, 0x1e5c: 0x0040, 0x1e5d: 0x1689,
0x1e5e: 0x0040, 0x1e5f: 0x2599, 0x1e60: 0x0040, 0x1e61: 0x20b9, 0x1e62: 0x20d9, 0x1e63: 0x0040,
0x1e64: 0x2181, 0x1e65: 0x0040, 0x1e66: 0x0040, 0x1e67: 0x20e1, 0x1e68: 0x2131, 0x1e69: 0x2191,
0x1e6a: 0x2161, 0x1e6b: 0x0040, 0x1e6c: 0x2171, 0x1e6d: 0x2179, 0x1e6e: 0x2111, 0x1e6f: 0x2141,
0x1e70: 0x2151, 0x1e71: 0x2121, 0x1e72: 0x2159, 0x1e73: 0x0040, 0x1e74: 0x2119, 0x1e75: 0x20c9,
0x1e76: 0x20d1, 0x1e77: 0x20e9, 0x1e78: 0x0040, 0x1e79: 0x2129, 0x1e7a: 0x2139, 0x1e7b: 0x2149,
0x1e7c: 0x2589, 0x1e7d: 0x0040, 0x1e7e: 0x2591, 0x1e7f: 0x0040,
// Block 0x7a, offset 0x1e80
0x1e80: 0x20b1, 0x1e81: 0x20b9, 0x1e82: 0x20d9, 0x1e83: 0x20f1, 0x1e84: 0x2181, 0x1e85: 0x2189,
0x1e86: 0x2109, 0x1e87: 0x20e1, 0x1e88: 0x2131, 0x1e89: 0x2191, 0x1e8a: 0x0040, 0x1e8b: 0x2169,
0x1e8c: 0x2171, 0x1e8d: 0x2179, 0x1e8e: 0x2111, 0x1e8f: 0x2141, 0x1e90: 0x2151, 0x1e91: 0x2121,
0x1e92: 0x2159, 0x1e93: 0x2101, 0x1e94: 0x2119, 0x1e95: 0x20c9, 0x1e96: 0x20d1, 0x1e97: 0x20e9,
0x1e98: 0x20f9, 0x1e99: 0x2129, 0x1e9a: 0x2139, 0x1e9b: 0x2149, 0x1e9c: 0x0040, 0x1e9d: 0x0040,
0x1e9e: 0x0040, 0x1e9f: 0x0040, 0x1ea0: 0x0040, 0x1ea1: 0x20b9, 0x1ea2: 0x20d9, 0x1ea3: 0x20f1,
0x1ea4: 0x0040, 0x1ea5: 0x2189, 0x1ea6: 0x2109, 0x1ea7: 0x20e1, 0x1ea8: 0x2131, 0x1ea9: 0x2191,
0x1eaa: 0x0040, 0x1eab: 0x2169, 0x1eac: 0x2171, 0x1ead: 0x2179, 0x1eae: 0x2111, 0x1eaf: 0x2141,
0x1eb0: 0x2151, 0x1eb1: 0x2121, 0x1eb2: 0x2159, 0x1eb3: 0x2101, 0x1eb4: 0x2119, 0x1eb5: 0x20c9,
0x1eb6: 0x20d1, 0x1eb7: 0x20e9, 0x1eb8: 0x20f9, 0x1eb9: 0x2129, 0x1eba: 0x2139, 0x1ebb: 0x2149,
0x1ebc: 0x0040, 0x1ebd: 0x0040, 0x1ebe: 0x0040, 0x1ebf: 0x0040,
// Block 0x7b, offset 0x1ec0
0x1ec0: 0x0040, 0x1ec1: 0x25a2, 0x1ec2: 0x25aa, 0x1ec3: 0x25b2, 0x1ec4: 0x25ba, 0x1ec5: 0x25c2,
0x1ec6: 0x25ca, 0x1ec7: 0x25d2, 0x1ec8: 0x25da, 0x1ec9: 0x25e2, 0x1eca: 0x25ea, 0x1ecb: 0x0018,
0x1ecc: 0x0018, 0x1ecd: 0x0018, 0x1ece: 0x0018, 0x1ecf: 0x0018, 0x1ed0: 0x25f2, 0x1ed1: 0x25fa,
0x1ed2: 0x2602, 0x1ed3: 0x260a, 0x1ed4: 0x2612, 0x1ed5: 0x261a, 0x1ed6: 0x2622, 0x1ed7: 0x262a,
0x1ed8: 0x2632, 0x1ed9: 0x263a, 0x1eda: 0x2642, 0x1edb: 0x264a, 0x1edc: 0x2652, 0x1edd: 0x265a,
0x1ede: 0x2662, 0x1edf: 0x266a, 0x1ee0: 0x2672, 0x1ee1: 0x267a, 0x1ee2: 0x2682, 0x1ee3: 0x268a,
0x1ee4: 0x2692, 0x1ee5: 0x269a, 0x1ee6: 0x26a2, 0x1ee7: 0x26aa, 0x1ee8: 0x26b2, 0x1ee9: 0x26ba,
0x1eea: 0x26c1, 0x1eeb: 0x03d9, 0x1eec: 0x00b9, 0x1eed: 0x1239, 0x1eee: 0x26c9, 0x1eef: 0x0018,
0x1ef0: 0x0019, 0x1ef1: 0x02e9, 0x1ef2: 0x03d9, 0x1ef3: 0x02f1, 0x1ef4: 0x02f9, 0x1ef5: 0x03f1,
0x1ef6: 0x0309, 0x1ef7: 0x00a9, 0x1ef8: 0x0311, 0x1ef9: 0x00b1, 0x1efa: 0x0319, 0x1efb: 0x0101,
0x1efc: 0x0321, 0x1efd: 0x0329, 0x1efe: 0x0051, 0x1eff: 0x0339,
// Block 0x7c, offset 0x1f00
0x1f00: 0x0751, 0x1f01: 0x00b9, 0x1f02: 0x0089, 0x1f03: 0x0341, 0x1f04: 0x0349, 0x1f05: 0x0391,
0x1f06: 0x00c1, 0x1f07: 0x0109, 0x1f08: 0x00c9, 0x1f09: 0x04b1, 0x1f0a: 0x26d1, 0x1f0b: 0x11f9,
0x1f0c: 0x26d9, 0x1f0d: 0x04d9, 0x1f0e: 0x26e1, 0x1f0f: 0x26e9, 0x1f10: 0x0018, 0x1f11: 0x0018,
0x1f12: 0x0018, 0x1f13: 0x0018, 0x1f14: 0x0018, 0x1f15: 0x0018, 0x1f16: 0x0018, 0x1f17: 0x0018,
0x1f18: 0x0018, 0x1f19: 0x0018, 0x1f1a: 0x0018, 0x1f1b: 0x0018, 0x1f1c: 0x0018, 0x1f1d: 0x0018,
0x1f1e: 0x0018, 0x1f1f: 0x0018, 0x1f20: 0x0018, 0x1f21: 0x0018, 0x1f22: 0x0018, 0x1f23: 0x0018,
0x1f24: 0x0018, 0x1f25: 0x0018, 0x1f26: 0x0018, 0x1f27: 0x0018, 0x1f28: 0x0018, 0x1f29: 0x0018,
0x1f2a: 0x26f1, 0x1f2b: 0x26f9, 0x1f2c: 0x2701, 0x1f2d: 0x0018, 0x1f2e: 0x0018, 0x1f2f: 0x0018,
0x1f30: 0x0018, 0x1f31: 0x0018, 0x1f32: 0x0018, 0x1f33: 0x0018, 0x1f34: 0x0018, 0x1f35: 0x0018,
0x1f36: 0x0018, 0x1f37: 0x0018, 0x1f38: 0x0018, 0x1f39: 0x0018, 0x1f3a: 0x0018, 0x1f3b: 0x0018,
0x1f3c: 0x0018, 0x1f3d: 0x0018, 0x1f3e: 0x0018, 0x1f3f: 0x0018,
// Block 0x7d, offset 0x1f40
0x1f40: 0x2711, 0x1f41: 0x2719, 0x1f42: 0x2721, 0x1f43: 0x0040, 0x1f44: 0x0040, 0x1f45: 0x0040,
0x1f46: 0x0040, 0x1f47: 0x0040, 0x1f48: 0x0040, 0x1f49: 0x0040, 0x1f4a: 0x0040, 0x1f4b: 0x0040,
0x1f4c: 0x0040, 0x1f4d: 0x0040, 0x1f4e: 0x0040, 0x1f4f: 0x0040, 0x1f50: 0x2729, 0x1f51: 0x2731,
0x1f52: 0x2739, 0x1f53: 0x2741, 0x1f54: 0x2749, 0x1f55: 0x2751, 0x1f56: 0x2759, 0x1f57: 0x2761,
0x1f58: 0x2769, 0x1f59: 0x2771, 0x1f5a: 0x2779, 0x1f5b: 0x2781, 0x1f5c: 0x2789, 0x1f5d: 0x2791,
0x1f5e: 0x2799, 0x1f5f: 0x27a1, 0x1f60: 0x27a9, 0x1f61: 0x27b1, 0x1f62: 0x27b9, 0x1f63: 0x27c1,
0x1f64: 0x27c9, 0x1f65: 0x27d1, 0x1f66: 0x27d9, 0x1f67: 0x27e1, 0x1f68: 0x27e9, 0x1f69: 0x27f1,
0x1f6a: 0x27f9, 0x1f6b: 0x2801, 0x1f6c: 0x2809, 0x1f6d: 0x2811, 0x1f6e: 0x2819, 0x1f6f: 0x2821,
0x1f70: 0x2829, 0x1f71: 0x2831, 0x1f72: 0x2839, 0x1f73: 0x2841, 0x1f74: 0x2849, 0x1f75: 0x2851,
0x1f76: 0x2859, 0x1f77: 0x2861, 0x1f78: 0x2869, 0x1f79: 0x2871, 0x1f7a: 0x2879, 0x1f7b: 0x2881,
0x1f7c: 0x0040, 0x1f7d: 0x0040, 0x1f7e: 0x0040, 0x1f7f: 0x0040,
// Block 0x7e, offset 0x1f80
0x1f80: 0x28e1, 0x1f81: 0x28e9, 0x1f82: 0x28f1, 0x1f83: 0x8cbd, 0x1f84: 0x28f9, 0x1f85: 0x2901,
0x1f86: 0x2909, 0x1f87: 0x2911, 0x1f88: 0x2919, 0x1f89: 0x2921, 0x1f8a: 0x2929, 0x1f8b: 0x2931,
0x1f8c: 0x2939, 0x1f8d: 0x8cdd, 0x1f8e: 0x2941, 0x1f8f: 0x2949, 0x1f90: 0x2951, 0x1f91: 0x2959,
0x1f92: 0x8cfd, 0x1f93: 0x2961, 0x1f94: 0x2969, 0x1f95: 0x2799, 0x1f96: 0x8d1d, 0x1f97: 0x2971,
0x1f98: 0x2979, 0x1f99: 0x2981, 0x1f9a: 0x2989, 0x1f9b: 0x2991, 0x1f9c: 0x8d3d, 0x1f9d: 0x2999,
0x1f9e: 0x29a1, 0x1f9f: 0x29a9, 0x1fa0: 0x29b1, 0x1fa1: 0x29b9, 0x1fa2: 0x2871, 0x1fa3: 0x29c1,
0x1fa4: 0x29c9, 0x1fa5: 0x29d1, 0x1fa6: 0x29d9, 0x1fa7: 0x29e1, 0x1fa8: 0x29e9, 0x1fa9: 0x29f1,
0x1faa: 0x29f9, 0x1fab: 0x2a01, 0x1fac: 0x2a09, 0x1fad: 0x2a11, 0x1fae: 0x2a19, 0x1faf: 0x2a21,
0x1fb0: 0x2a29, 0x1fb1: 0x2a31, 0x1fb2: 0x2a31, 0x1fb3: 0x2a31, 0x1fb4: 0x8d5d, 0x1fb5: 0x2a39,
0x1fb6: 0x2a41, 0x1fb7: 0x2a49, 0x1fb8: 0x8d7d, 0x1fb9: 0x2a51, 0x1fba: 0x2a59, 0x1fbb: 0x2a61,
0x1fbc: 0x2a69, 0x1fbd: 0x2a71, 0x1fbe: 0x2a79, 0x1fbf: 0x2a81,
// Block 0x7f, offset 0x1fc0
0x1fc0: 0x2a89, 0x1fc1: 0x2a91, 0x1fc2: 0x2a99, 0x1fc3: 0x2aa1, 0x1fc4: 0x2aa9, 0x1fc5: 0x2ab1,
0x1fc6: 0x2ab1, 0x1fc7: 0x2ab9, 0x1fc8: 0x2ac1, 0x1fc9: 0x2ac9, 0x1fca: 0x2ad1, 0x1fcb: 0x2ad9,
0x1fcc: 0x2ae1, 0x1fcd: 0x2ae9, 0x1fce: 0x2af1, 0x1fcf: 0x2af9, 0x1fd0: 0x2b01, 0x1fd1: 0x2b09,
0x1fd2: 0x2b11, 0x1fd3: 0x2b19, 0x1fd4: 0x2b21, 0x1fd5: 0x2b29, 0x1fd6: 0x2b31, 0x1fd7: 0x2b39,
0x1fd8: 0x2b41, 0x1fd9: 0x8d9d, 0x1fda: 0x2b49, 0x1fdb: 0x2b51, 0x1fdc: 0x2b59, 0x1fdd: 0x2751,
0x1fde: 0x2b61, 0x1fdf: 0x2b69, 0x1fe0: 0x8dbd, 0x1fe1: 0x8ddd, 0x1fe2: 0x2b71, 0x1fe3: 0x2b79,
0x1fe4: 0x2b81, 0x1fe5: 0x2b89, 0x1fe6: 0x2b91, 0x1fe7: 0x2b99, 0x1fe8: 0x2040, 0x1fe9: 0x2ba1,
0x1fea: 0x2ba9, 0x1feb: 0x2ba9, 0x1fec: 0x8dfd, 0x1fed: 0x2bb1, 0x1fee: 0x2bb9, 0x1fef: 0x2bc1,
0x1ff0: 0x2bc9, 0x1ff1: 0x8e1d, 0x1ff2: 0x2bd1, 0x1ff3: 0x2bd9, 0x1ff4: 0x2040, 0x1ff5: 0x2be1,
0x1ff6: 0x2be9, 0x1ff7: 0x2bf1, 0x1ff8: 0x2bf9, 0x1ff9: 0x2c01, 0x1ffa: 0x2c09, 0x1ffb: 0x8e3d,
0x1ffc: 0x2c11, 0x1ffd: 0x8e5d, 0x1ffe: 0x2c19, 0x1fff: 0x2c21,
// Block 0x80, offset 0x2000
0x2000: 0x2c29, 0x2001: 0x2c31, 0x2002: 0x2c39, 0x2003: 0x2c41, 0x2004: 0x2c49, 0x2005: 0x2c51,
0x2006: 0x2c59, 0x2007: 0x2c61, 0x2008: 0x2c69, 0x2009: 0x8e7d, 0x200a: 0x2c71, 0x200b: 0x2c79,
0x200c: 0x2c81, 0x200d: 0x2c89, 0x200e: 0x2c91, 0x200f: 0x8e9d, 0x2010: 0x2c99, 0x2011: 0x8ebd,
0x2012: 0x8edd, 0x2013: 0x2ca1, 0x2014: 0x2ca9, 0x2015: 0x2ca9, 0x2016: 0x2cb1, 0x2017: 0x8efd,
0x2018: 0x8f1d, 0x2019: 0x2cb9, 0x201a: 0x2cc1, 0x201b: 0x2cc9, 0x201c: 0x2cd1, 0x201d: 0x2cd9,
0x201e: 0x2ce1, 0x201f: 0x2ce9, 0x2020: 0x2cf1, 0x2021: 0x2cf9, 0x2022: 0x2d01, 0x2023: 0x2d09,
0x2024: 0x8f3d, 0x2025: 0x2d11, 0x2026: 0x2d19, 0x2027: 0x2d21, 0x2028: 0x2d29, 0x2029: 0x2d21,
0x202a: 0x2d31, 0x202b: 0x2d39, 0x202c: 0x2d41, 0x202d: 0x2d49, 0x202e: 0x2d51, 0x202f: 0x2d59,
0x2030: 0x2d61, 0x2031: 0x2d69, 0x2032: 0x2d71, 0x2033: 0x2d79, 0x2034: 0x2d81, 0x2035: 0x2d89,
0x2036: 0x2d91, 0x2037: 0x2d99, 0x2038: 0x8f5d, 0x2039: 0x2da1, 0x203a: 0x2da9, 0x203b: 0x2db1,
0x203c: 0x2db9, 0x203d: 0x2dc1, 0x203e: 0x8f7d, 0x203f: 0x2dc9,
// Block 0x81, offset 0x2040
0x2040: 0x2dd1, 0x2041: 0x2dd9, 0x2042: 0x2de1, 0x2043: 0x2de9, 0x2044: 0x2df1, 0x2045: 0x2df9,
0x2046: 0x2e01, 0x2047: 0x2e09, 0x2048: 0x2e11, 0x2049: 0x2e19, 0x204a: 0x8f9d, 0x204b: 0x2e21,
0x204c: 0x2e29, 0x204d: 0x2e31, 0x204e: 0x2e39, 0x204f: 0x2e41, 0x2050: 0x2e49, 0x2051: 0x2e51,
0x2052: 0x2e59, 0x2053: 0x2e61, 0x2054: 0x2e69, 0x2055: 0x2e71, 0x2056: 0x2e79, 0x2057: 0x2e81,
0x2058: 0x2e89, 0x2059: 0x2e91, 0x205a: 0x2e99, 0x205b: 0x2ea1, 0x205c: 0x2ea9, 0x205d: 0x8fbd,
0x205e: 0x2eb1, 0x205f: 0x2eb9, 0x2060: 0x2ec1, 0x2061: 0x2ec9, 0x2062: 0x2ed1, 0x2063: 0x8fdd,
0x2064: 0x2ed9, 0x2065: 0x2ee1, 0x2066: 0x2ee9, 0x2067: 0x2ef1, 0x2068: 0x2ef9, 0x2069: 0x2f01,
0x206a: 0x2f09, 0x206b: 0x2f11, 0x206c: 0x7f0d, 0x206d: 0x2f19, 0x206e: 0x2f21, 0x206f: 0x2f29,
0x2070: 0x8ffd, 0x2071: 0x2f31, 0x2072: 0x2f39, 0x2073: 0x2f41, 0x2074: 0x2f49, 0x2075: 0x2f51,
0x2076: 0x2f59, 0x2077: 0x901d, 0x2078: 0x903d, 0x2079: 0x905d, 0x207a: 0x2f61, 0x207b: 0x907d,
0x207c: 0x2f69, 0x207d: 0x2f71, 0x207e: 0x2f79, 0x207f: 0x2f81,
// Block 0x82, offset 0x2080
0x2080: 0x2f89, 0x2081: 0x2f91, 0x2082: 0x2f99, 0x2083: 0x2fa1, 0x2084: 0x2fa9, 0x2085: 0x2fb1,
0x2086: 0x909d, 0x2087: 0x2fb9, 0x2088: 0x2fc1, 0x2089: 0x2fc9, 0x208a: 0x2fd1, 0x208b: 0x2fd9,
0x208c: 0x2fe1, 0x208d: 0x90bd, 0x208e: 0x2fe9, 0x208f: 0x2ff1, 0x2090: 0x90dd, 0x2091: 0x90fd,
0x2092: 0x2ff9, 0x2093: 0x3001, 0x2094: 0x3009, 0x2095: 0x3011, 0x2096: 0x3019, 0x2097: 0x3021,
0x2098: 0x3029, 0x2099: 0x3031, 0x209a: 0x3039, 0x209b: 0x911d, 0x209c: 0x3041, 0x209d: 0x913d,
0x209e: 0x3049, 0x209f: 0x2040, 0x20a0: 0x3051, 0x20a1: 0x3059, 0x20a2: 0x3061, 0x20a3: 0x915d,
0x20a4: 0x3069, 0x20a5: 0x3071, 0x20a6: 0x917d, 0x20a7: 0x919d, 0x20a8: 0x3079, 0x20a9: 0x3081,
0x20aa: 0x3089, 0x20ab: 0x3091, 0x20ac: 0x3099, 0x20ad: 0x3099, 0x20ae: 0x30a1, 0x20af: 0x30a9,
0x20b0: 0x30b1, 0x20b1: 0x30b9, 0x20b2: 0x30c1, 0x20b3: 0x30c9, 0x20b4: 0x30d1, 0x20b5: 0x91bd,
0x20b6: 0x30d9, 0x20b7: 0x91dd, 0x20b8: 0x30e1, 0x20b9: 0x91fd, 0x20ba: 0x30e9, 0x20bb: 0x921d,
0x20bc: 0x923d, 0x20bd: 0x925d, 0x20be: 0x30f1, 0x20bf: 0x30f9,
// Block 0x83, offset 0x20c0
0x20c0: 0x3101, 0x20c1: 0x927d, 0x20c2: 0x929d, 0x20c3: 0x92bd, 0x20c4: 0x92dd, 0x20c5: 0x3109,
0x20c6: 0x3111, 0x20c7: 0x3111, 0x20c8: 0x3119, 0x20c9: 0x3121, 0x20ca: 0x3129, 0x20cb: 0x3131,
0x20cc: 0x3139, 0x20cd: 0x92fd, 0x20ce: 0x3141, 0x20cf: 0x3149, 0x20d0: 0x3151, 0x20d1: 0x3159,
0x20d2: 0x931d, 0x20d3: 0x3161, 0x20d4: 0x933d, 0x20d5: 0x935d, 0x20d6: 0x3169, 0x20d7: 0x3171,
0x20d8: 0x3179, 0x20d9: 0x3181, 0x20da: 0x3189, 0x20db: 0x3191, 0x20dc: 0x937d, 0x20dd: 0x939d,
0x20de: 0x93bd, 0x20df: 0x2040, 0x20e0: 0x3199, 0x20e1: 0x93dd, 0x20e2: 0x31a1, 0x20e3: 0x31a9,
0x20e4: 0x31b1, 0x20e5: 0x93fd, 0x20e6: 0x31b9, 0x20e7: 0x31c1, 0x20e8: 0x31c9, 0x20e9: 0x31d1,
0x20ea: 0x31d9, 0x20eb: 0x941d, 0x20ec: 0x31e1, 0x20ed: 0x31e9, 0x20ee: 0x31f1, 0x20ef: 0x31f9,
0x20f0: 0x3201, 0x20f1: 0x3209, 0x20f2: 0x943d, 0x20f3: 0x945d, 0x20f4: 0x3211, 0x20f5: 0x947d,
0x20f6: 0x3219, 0x20f7: 0x949d, 0x20f8: 0x3221, 0x20f9: 0x3229, 0x20fa: 0x3231, 0x20fb: 0x94bd,
0x20fc: 0x94dd, 0x20fd: 0x3239, 0x20fe: 0x94fd, 0x20ff: 0x3241,
// Block 0x84, offset 0x2100
0x2100: 0x951d, 0x2101: 0x3249, 0x2102: 0x3251, 0x2103: 0x3259, 0x2104: 0x3261, 0x2105: 0x3269,
0x2106: 0x3271, 0x2107: 0x953d, 0x2108: 0x955d, 0x2109: 0x957d, 0x210a: 0x959d, 0x210b: 0x2ca1,
0x210c: 0x3279, 0x210d: 0x3281, 0x210e: 0x3289, 0x210f: 0x3291, 0x2110: 0x3299, 0x2111: 0x32a1,
0x2112: 0x32a9, 0x2113: 0x32b1, 0x2114: 0x32b9, 0x2115: 0x32c1, 0x2116: 0x32c9, 0x2117: 0x95bd,
0x2118: 0x32d1, 0x2119: 0x32d9, 0x211a: 0x32e1, 0x211b: 0x32e9, 0x211c: 0x32f1, 0x211d: 0x32f9,
0x211e: 0x3301, 0x211f: 0x3309, 0x2120: 0x3311, 0x2121: 0x3319, 0x2122: 0x3321, 0x2123: 0x3329,
0x2124: 0x95dd, 0x2125: 0x95fd, 0x2126: 0x961d, 0x2127: 0x3331, 0x2128: 0x3339, 0x2129: 0x3341,
0x212a: 0x3349, 0x212b: 0x963d, 0x212c: 0x3351, 0x212d: 0x965d, 0x212e: 0x3359, 0x212f: 0x3361,
0x2130: 0x967d, 0x2131: 0x969d, 0x2132: 0x3369, 0x2133: 0x3371, 0x2134: 0x3379, 0x2135: 0x3381,
0x2136: 0x3389, 0x2137: 0x3391, 0x2138: 0x3399, 0x2139: 0x33a1, 0x213a: 0x33a9, 0x213b: 0x33b1,
0x213c: 0x33b9, 0x213d: 0x33c1, 0x213e: 0x33c9, 0x213f: 0x2040,
// Block 0x85, offset 0x2140
0x2140: 0x33d1, 0x2141: 0x33d9, 0x2142: 0x33e1, 0x2143: 0x33e9, 0x2144: 0x33f1, 0x2145: 0x96bd,
0x2146: 0x33f9, 0x2147: 0x3401, 0x2148: 0x3409, 0x2149: 0x3411, 0x214a: 0x3419, 0x214b: 0x96dd,
0x214c: 0x96fd, 0x214d: 0x3421, 0x214e: 0x3429, 0x214f: 0x3431, 0x2150: 0x3439, 0x2151: 0x3441,
0x2152: 0x3449, 0x2153: 0x971d, 0x2154: 0x3451, 0x2155: 0x3459, 0x2156: 0x3461, 0x2157: 0x3469,
0x2158: 0x973d, 0x2159: 0x975d, 0x215a: 0x3471, 0x215b: 0x3479, 0x215c: 0x3481, 0x215d: 0x977d,
0x215e: 0x3489, 0x215f: 0x3491, 0x2160: 0x684d, 0x2161: 0x979d, 0x2162: 0x3499, 0x2163: 0x34a1,
0x2164: 0x34a9, 0x2165: 0x97bd, 0x2166: 0x34b1, 0x2167: 0x34b9, 0x2168: 0x34c1, 0x2169: 0x34c9,
0x216a: 0x34d1, 0x216b: 0x34d9, 0x216c: 0x34e1, 0x216d: 0x97dd, 0x216e: 0x34e9, 0x216f: 0x34f1,
0x2170: 0x34f9, 0x2171: 0x97fd, 0x2172: 0x3501, 0x2173: 0x3509, 0x2174: 0x3511, 0x2175: 0x3519,
0x2176: 0x7b6d, 0x2177: 0x981d, 0x2178: 0x3521, 0x2179: 0x3529, 0x217a: 0x3531, 0x217b: 0x983d,
0x217c: 0x3539, 0x217d: 0x985d, 0x217e: 0x3541, 0x217f: 0x3541,
// Block 0x86, offset 0x2180
0x2180: 0x3549, 0x2181: 0x987d, 0x2182: 0x3551, 0x2183: 0x3559, 0x2184: 0x3561, 0x2185: 0x3569,
0x2186: 0x3571, 0x2187: 0x3579, 0x2188: 0x3581, 0x2189: 0x989d, 0x218a: 0x3589, 0x218b: 0x3591,
0x218c: 0x3599, 0x218d: 0x35a1, 0x218e: 0x35a9, 0x218f: 0x35b1, 0x2190: 0x98bd, 0x2191: 0x35b9,
0x2192: 0x98dd, 0x2193: 0x98fd, 0x2194: 0x991d, 0x2195: 0x35c1, 0x2196: 0x35c9, 0x2197: 0x35d1,
0x2198: 0x35d9, 0x2199: 0x35e1, 0x219a: 0x35e9, 0x219b: 0x35f1, 0x219c: 0x35f9, 0x219d: 0x993d,
0x219e: 0x0040, 0x219f: 0x0040, 0x21a0: 0x0040, 0x21a1: 0x0040, 0x21a2: 0x0040, 0x21a3: 0x0040,
0x21a4: 0x0040, 0x21a5: 0x0040, 0x21a6: 0x0040, 0x21a7: 0x0040, 0x21a8: 0x0040, 0x21a9: 0x0040,
0x21aa: 0x0040, 0x21ab: 0x0040, 0x21ac: 0x0040, 0x21ad: 0x0040, 0x21ae: 0x0040, 0x21af: 0x0040,
0x21b0: 0x0040, 0x21b1: 0x0040, 0x21b2: 0x0040, 0x21b3: 0x0040, 0x21b4: 0x0040, 0x21b5: 0x0040,
0x21b6: 0x0040, 0x21b7: 0x0040, 0x21b8: 0x0040, 0x21b9: 0x0040, 0x21ba: 0x0040, 0x21bb: 0x0040,
0x21bc: 0x0040, 0x21bd: 0x0040, 0x21be: 0x0040, 0x21bf: 0x0040,
}
// idnaIndex: 39 blocks, 2496 entries, 4992 bytes
// Block 0 is the zero block.
var idnaIndex = [2496]uint16{
// Block 0x0, offset 0x0
// Block 0x1, offset 0x40
// Block 0x2, offset 0x80
// Block 0x3, offset 0xc0
0xc2: 0x01, 0xc3: 0x85, 0xc4: 0x02, 0xc5: 0x03, 0xc6: 0x04, 0xc7: 0x05,
0xc8: 0x06, 0xc9: 0x86, 0xca: 0x87, 0xcb: 0x07, 0xcc: 0x88, 0xcd: 0x08, 0xce: 0x09, 0xcf: 0x0a,
0xd0: 0x89, 0xd1: 0x0b, 0xd2: 0x0c, 0xd3: 0x0d, 0xd4: 0x0e, 0xd5: 0x8a, 0xd6: 0x8b, 0xd7: 0x8c,
0xd8: 0x0f, 0xd9: 0x10, 0xda: 0x8d, 0xdb: 0x11, 0xdc: 0x12, 0xdd: 0x8e, 0xde: 0x8f, 0xdf: 0x90,
0xe0: 0x02, 0xe1: 0x03, 0xe2: 0x04, 0xe3: 0x05, 0xe4: 0x06, 0xe5: 0x07, 0xe6: 0x07, 0xe7: 0x07,
0xe8: 0x07, 0xe9: 0x07, 0xea: 0x08, 0xeb: 0x07, 0xec: 0x07, 0xed: 0x09, 0xee: 0x0a, 0xef: 0x0b,
0xf0: 0x20, 0xf1: 0x21, 0xf2: 0x21, 0xf3: 0x23, 0xf4: 0x24,
// Block 0x4, offset 0x100
0x120: 0x91, 0x121: 0x13, 0x122: 0x14, 0x123: 0x92, 0x124: 0x93, 0x125: 0x15, 0x126: 0x16, 0x127: 0x17,
0x128: 0x18, 0x129: 0x19, 0x12a: 0x1a, 0x12b: 0x1b, 0x12c: 0x1c, 0x12d: 0x1d, 0x12e: 0x1e, 0x12f: 0x94,
0x130: 0x95, 0x131: 0x1f, 0x132: 0x20, 0x133: 0x21, 0x134: 0x96, 0x135: 0x22, 0x136: 0x97, 0x137: 0x98,
0x138: 0x99, 0x139: 0x9a, 0x13a: 0x23, 0x13b: 0x9b, 0x13c: 0x9c, 0x13d: 0x24, 0x13e: 0x25, 0x13f: 0x9d,
// Block 0x5, offset 0x140
0x140: 0x9e, 0x141: 0x9f, 0x142: 0xa0, 0x143: 0xa1, 0x144: 0xa2, 0x145: 0xa3, 0x146: 0xa4, 0x147: 0xa5,
0x148: 0xa6, 0x149: 0xa7, 0x14a: 0xa8, 0x14b: 0xa9, 0x14c: 0xaa, 0x14d: 0xab, 0x14e: 0xac, 0x14f: 0xad,
0x150: 0xae, 0x151: 0xa6, 0x152: 0xa6, 0x153: 0xa6, 0x154: 0xa6, 0x155: 0xa6, 0x156: 0xa6, 0x157: 0xa6,
0x158: 0xa6, 0x159: 0xaf, 0x15a: 0xb0, 0x15b: 0xb1, 0x15c: 0xb2, 0x15d: 0xb3, 0x15e: 0xb4, 0x15f: 0xb5,
0x160: 0xb6, 0x161: 0xb7, 0x162: 0xb8, 0x163: 0xb9, 0x164: 0xba, 0x165: 0xbb, 0x166: 0xbc, 0x167: 0xbd,
0x168: 0xbe, 0x169: 0xbf, 0x16a: 0xc0, 0x16b: 0xc1, 0x16c: 0xc2, 0x16d: 0xc3, 0x16e: 0xc4, 0x16f: 0xc5,
0x170: 0xc6, 0x171: 0xc7, 0x172: 0xc8, 0x173: 0xc9, 0x174: 0x26, 0x175: 0x27, 0x176: 0x28, 0x177: 0x88,
0x178: 0x29, 0x179: 0x29, 0x17a: 0x2a, 0x17b: 0x29, 0x17c: 0xca, 0x17d: 0x2b, 0x17e: 0x2c, 0x17f: 0x2d,
// Block 0x6, offset 0x180
0x180: 0x2e, 0x181: 0x2f, 0x182: 0x30, 0x183: 0xcb, 0x184: 0x31, 0x185: 0x32, 0x186: 0xcc, 0x187: 0xa2,
0x188: 0xcd, 0x189: 0xce, 0x18a: 0xa2, 0x18b: 0xa2, 0x18c: 0xcf, 0x18d: 0xa2, 0x18e: 0xa2, 0x18f: 0xa2,
0x190: 0xd0, 0x191: 0x33, 0x192: 0x34, 0x193: 0x35, 0x194: 0xa2, 0x195: 0xa2, 0x196: 0xa2, 0x197: 0xa2,
0x198: 0xa2, 0x199: 0xa2, 0x19a: 0xa2, 0x19b: 0xa2, 0x19c: 0xa2, 0x19d: 0xa2, 0x19e: 0xa2, 0x19f: 0xa2,
0x1a0: 0xa2, 0x1a1: 0xa2, 0x1a2: 0xa2, 0x1a3: 0xa2, 0x1a4: 0xa2, 0x1a5: 0xa2, 0x1a6: 0xa2, 0x1a7: 0xa2,
0x1a8: 0xd1, 0x1a9: 0xd2, 0x1aa: 0xa2, 0x1ab: 0xd3, 0x1ac: 0xa2, 0x1ad: 0xd4, 0x1ae: 0xd5, 0x1af: 0xa2,
0x1b0: 0xd6, 0x1b1: 0x36, 0x1b2: 0x29, 0x1b3: 0x37, 0x1b4: 0xd7, 0x1b5: 0xd8, 0x1b6: 0xd9, 0x1b7: 0xda,
0x1b8: 0xdb, 0x1b9: 0xdc, 0x1ba: 0xdd, 0x1bb: 0xde, 0x1bc: 0xdf, 0x1bd: 0xe0, 0x1be: 0xe1, 0x1bf: 0x38,
// Block 0x7, offset 0x1c0
0x1c0: 0x39, 0x1c1: 0xe2, 0x1c2: 0xe3, 0x1c3: 0xe4, 0x1c4: 0xe5, 0x1c5: 0x3a, 0x1c6: 0x3b, 0x1c7: 0xe6,
0x1c8: 0xe7, 0x1c9: 0x3c, 0x1ca: 0x3d, 0x1cb: 0x3e, 0x1cc: 0xe8, 0x1cd: 0xe9, 0x1ce: 0x3f, 0x1cf: 0x40,
0x1d0: 0xa6, 0x1d1: 0xa6, 0x1d2: 0xa6, 0x1d3: 0xa6, 0x1d4: 0xa6, 0x1d5: 0xa6, 0x1d6: 0xa6, 0x1d7: 0xa6,
0x1d8: 0xa6, 0x1d9: 0xa6, 0x1da: 0xa6, 0x1db: 0xa6, 0x1dc: 0xa6, 0x1dd: 0xa6, 0x1de: 0xa6, 0x1df: 0xa6,
0x1e0: 0xa6, 0x1e1: 0xa6, 0x1e2: 0xa6, 0x1e3: 0xa6, 0x1e4: 0xa6, 0x1e5: 0xa6, 0x1e6: 0xa6, 0x1e7: 0xa6,
0x1e8: 0xa6, 0x1e9: 0xa6, 0x1ea: 0xa6, 0x1eb: 0xa6, 0x1ec: 0xa6, 0x1ed: 0xa6, 0x1ee: 0xa6, 0x1ef: 0xa6,
0x1f0: 0xa6, 0x1f1: 0xa6, 0x1f2: 0xa6, 0x1f3: 0xa6, 0x1f4: 0xa6, 0x1f5: 0xa6, 0x1f6: 0xa6, 0x1f7: 0xa6,
0x1f8: 0xa6, 0x1f9: 0xa6, 0x1fa: 0xa6, 0x1fb: 0xa6, 0x1fc: 0xa6, 0x1fd: 0xa6, 0x1fe: 0xa6, 0x1ff: 0xa6,
// Block 0x8, offset 0x200
0x200: 0xa6, 0x201: 0xa6, 0x202: 0xa6, 0x203: 0xa6, 0x204: 0xa6, 0x205: 0xa6, 0x206: 0xa6, 0x207: 0xa6,
0x208: 0xa6, 0x209: 0xa6, 0x20a: 0xa6, 0x20b: 0xa6, 0x20c: 0xa6, 0x20d: 0xa6, 0x20e: 0xa6, 0x20f: 0xa6,
0x210: 0xa6, 0x211: 0xa6, 0x212: 0xa6, 0x213: 0xa6, 0x214: 0xa6, 0x215: 0xa6, 0x216: 0xa6, 0x217: 0xa6,
0x218: 0xa6, 0x219: 0xa6, 0x21a: 0xa6, 0x21b: 0xa6, 0x21c: 0xa6, 0x21d: 0xa6, 0x21e: 0xa6, 0x21f: 0xa6,
0x220: 0xa6, 0x221: 0xa6, 0x222: 0xa6, 0x223: 0xa6, 0x224: 0xa6, 0x225: 0xa6, 0x226: 0xa6, 0x227: 0xa6,
0x228: 0xa6, 0x229: 0xa6, 0x22a: 0xa6, 0x22b: 0xa6, 0x22c: 0xa6, 0x22d: 0xa6, 0x22e: 0xa6, 0x22f: 0xa6,
0x230: 0xa6, 0x231: 0xa6, 0x232: 0xa6, 0x233: 0xa6, 0x234: 0xa6, 0x235: 0xa6, 0x236: 0xa6, 0x237: 0xa2,
0x238: 0xa6, 0x239: 0xa6, 0x23a: 0xa6, 0x23b: 0xa6, 0x23c: 0xa6, 0x23d: 0xa6, 0x23e: 0xa6, 0x23f: 0xa6,
// Block 0x9, offset 0x240
0x240: 0xa6, 0x241: 0xa6, 0x242: 0xa6, 0x243: 0xa6, 0x244: 0xa6, 0x245: 0xa6, 0x246: 0xa6, 0x247: 0xa6,
0x248: 0xa6, 0x249: 0xa6, 0x24a: 0xa6, 0x24b: 0xa6, 0x24c: 0xa6, 0x24d: 0xa6, 0x24e: 0xa6, 0x24f: 0xa6,
0x250: 0xa6, 0x251: 0xa6, 0x252: 0xa6, 0x253: 0xa6, 0x254: 0xa6, 0x255: 0xa6, 0x256: 0xa6, 0x257: 0xa6,
0x258: 0xa6, 0x259: 0xa6, 0x25a: 0xa6, 0x25b: 0xa6, 0x25c: 0xa6, 0x25d: 0xa6, 0x25e: 0xa6, 0x25f: 0xa6,
0x260: 0xa6, 0x261: 0xa6, 0x262: 0xa6, 0x263: 0xa6, 0x264: 0xa6, 0x265: 0xa6, 0x266: 0xa6, 0x267: 0xa6,
0x268: 0xa6, 0x269: 0xa6, 0x26a: 0xa6, 0x26b: 0xa6, 0x26c: 0xa6, 0x26d: 0xa6, 0x26e: 0xa6, 0x26f: 0xa6,
0x270: 0xa6, 0x271: 0xa6, 0x272: 0xa6, 0x273: 0xa6, 0x274: 0xa6, 0x275: 0xa6, 0x276: 0xa6, 0x277: 0xa6,
0x278: 0xa6, 0x279: 0xa6, 0x27a: 0xa6, 0x27b: 0xa6, 0x27c: 0xa6, 0x27d: 0xa6, 0x27e: 0xa6, 0x27f: 0xa6,
// Block 0xa, offset 0x280
0x280: 0xa6, 0x281: 0xa6, 0x282: 0xa6, 0x283: 0xa6, 0x284: 0xa6, 0x285: 0xa6, 0x286: 0xa6, 0x287: 0xa6,
0x288: 0xa6, 0x289: 0xa6, 0x28a: 0xa6, 0x28b: 0xa6, 0x28c: 0xa6, 0x28d: 0xa6, 0x28e: 0xa6, 0x28f: 0xa6,
0x290: 0xa6, 0x291: 0xa6, 0x292: 0xea, 0x293: 0xeb, 0x294: 0xa6, 0x295: 0xa6, 0x296: 0xa6, 0x297: 0xa6,
0x298: 0xec, 0x299: 0x41, 0x29a: 0x42, 0x29b: 0xed, 0x29c: 0x43, 0x29d: 0x44, 0x29e: 0x45, 0x29f: 0x46,
0x2a0: 0xee, 0x2a1: 0xef, 0x2a2: 0xf0, 0x2a3: 0xf1, 0x2a4: 0xf2, 0x2a5: 0xf3, 0x2a6: 0xf4, 0x2a7: 0xf5,
0x2a8: 0xf6, 0x2a9: 0xf7, 0x2aa: 0xf8, 0x2ab: 0xf9, 0x2ac: 0xfa, 0x2ad: 0xfb, 0x2ae: 0xfc, 0x2af: 0xfd,
0x2b0: 0xa6, 0x2b1: 0xa6, 0x2b2: 0xa6, 0x2b3: 0xa6, 0x2b4: 0xa6, 0x2b5: 0xa6, 0x2b6: 0xa6, 0x2b7: 0xa6,
0x2b8: 0xa6, 0x2b9: 0xa6, 0x2ba: 0xa6, 0x2bb: 0xa6, 0x2bc: 0xa6, 0x2bd: 0xa6, 0x2be: 0xa6, 0x2bf: 0xa6,
// Block 0xb, offset 0x2c0
0x2c0: 0xa6, 0x2c1: 0xa6, 0x2c2: 0xa6, 0x2c3: 0xa6, 0x2c4: 0xa6, 0x2c5: 0xa6, 0x2c6: 0xa6, 0x2c7: 0xa6,
0x2c8: 0xa6, 0x2c9: 0xa6, 0x2ca: 0xa6, 0x2cb: 0xa6, 0x2cc: 0xa6, 0x2cd: 0xa6, 0x2ce: 0xa6, 0x2cf: 0xa6,
0x2d0: 0xa6, 0x2d1: 0xa6, 0x2d2: 0xa6, 0x2d3: 0xa6, 0x2d4: 0xa6, 0x2d5: 0xa6, 0x2d6: 0xa6, 0x2d7: 0xa6,
0x2d8: 0xa6, 0x2d9: 0xa6, 0x2da: 0xa6, 0x2db: 0xa6, 0x2dc: 0xa6, 0x2dd: 0xa6, 0x2de: 0xfe, 0x2df: 0xff,
// Block 0xc, offset 0x300
0x300: 0x100, 0x301: 0x100, 0x302: 0x100, 0x303: 0x100, 0x304: 0x100, 0x305: 0x100, 0x306: 0x100, 0x307: 0x100,
0x308: 0x100, 0x309: 0x100, 0x30a: 0x100, 0x30b: 0x100, 0x30c: 0x100, 0x30d: 0x100, 0x30e: 0x100, 0x30f: 0x100,
0x310: 0x100, 0x311: 0x100, 0x312: 0x100, 0x313: 0x100, 0x314: 0x100, 0x315: 0x100, 0x316: 0x100, 0x317: 0x100,
0x318: 0x100, 0x319: 0x100, 0x31a: 0x100, 0x31b: 0x100, 0x31c: 0x100, 0x31d: 0x100, 0x31e: 0x100, 0x31f: 0x100,
0x320: 0x100, 0x321: 0x100, 0x322: 0x100, 0x323: 0x100, 0x324: 0x100, 0x325: 0x100, 0x326: 0x100, 0x327: 0x100,
0x328: 0x100, 0x329: 0x100, 0x32a: 0x100, 0x32b: 0x100, 0x32c: 0x100, 0x32d: 0x100, 0x32e: 0x100, 0x32f: 0x100,
0x330: 0x100, 0x331: 0x100, 0x332: 0x100, 0x333: 0x100, 0x334: 0x100, 0x335: 0x100, 0x336: 0x100, 0x337: 0x100,
0x338: 0x100, 0x339: 0x100, 0x33a: 0x100, 0x33b: 0x100, 0x33c: 0x100, 0x33d: 0x100, 0x33e: 0x100, 0x33f: 0x100,
// Block 0xd, offset 0x340
0x340: 0x100, 0x341: 0x100, 0x342: 0x100, 0x343: 0x100, 0x344: 0x100, 0x345: 0x100, 0x346: 0x100, 0x347: 0x100,
0x348: 0x100, 0x349: 0x100, 0x34a: 0x100, 0x34b: 0x100, 0x34c: 0x100, 0x34d: 0x100, 0x34e: 0x100, 0x34f: 0x100,
0x350: 0x100, 0x351: 0x100, 0x352: 0x100, 0x353: 0x100, 0x354: 0x100, 0x355: 0x100, 0x356: 0x100, 0x357: 0x100,
0x358: 0x100, 0x359: 0x100, 0x35a: 0x100, 0x35b: 0x100, 0x35c: 0x100, 0x35d: 0x100, 0x35e: 0x100, 0x35f: 0x100,
0x360: 0x100, 0x361: 0x100, 0x362: 0x100, 0x363: 0x100, 0x364: 0x101, 0x365: 0x102, 0x366: 0x103, 0x367: 0x104,
0x368: 0x47, 0x369: 0x105, 0x36a: 0x106, 0x36b: 0x48, 0x36c: 0x49, 0x36d: 0x4a, 0x36e: 0x4b, 0x36f: 0x4c,
0x370: 0x107, 0x371: 0x4d, 0x372: 0x4e, 0x373: 0x4f, 0x374: 0x50, 0x375: 0x51, 0x376: 0x108, 0x377: 0x52,
0x378: 0x53, 0x379: 0x54, 0x37a: 0x55, 0x37b: 0x56, 0x37c: 0x57, 0x37d: 0x58, 0x37e: 0x59, 0x37f: 0x5a,
// Block 0xe, offset 0x380
0x380: 0x109, 0x381: 0x10a, 0x382: 0xa6, 0x383: 0x10b, 0x384: 0x10c, 0x385: 0xa2, 0x386: 0x10d, 0x387: 0x10e,
0x388: 0x100, 0x389: 0x100, 0x38a: 0x10f, 0x38b: 0x110, 0x38c: 0x111, 0x38d: 0x112, 0x38e: 0x113, 0x38f: 0x114,
0x390: 0x115, 0x391: 0xa6, 0x392: 0x116, 0x393: 0x117, 0x394: 0x118, 0x395: 0x5b, 0x396: 0x5c, 0x397: 0x100,
0x398: 0xa6, 0x399: 0xa6, 0x39a: 0xa6, 0x39b: 0xa6, 0x39c: 0x119, 0x39d: 0x11a, 0x39e: 0x5d, 0x39f: 0x100,
0x3a0: 0x11b, 0x3a1: 0x11c, 0x3a2: 0x11d, 0x3a3: 0x11e, 0x3a4: 0x11f, 0x3a5: 0x100, 0x3a6: 0x120, 0x3a7: 0x121,
0x3a8: 0x122, 0x3a9: 0x123, 0x3aa: 0x124, 0x3ab: 0x5e, 0x3ac: 0x125, 0x3ad: 0x126, 0x3ae: 0x5f, 0x3af: 0x100,
0x3b0: 0x127, 0x3b1: 0x128, 0x3b2: 0x129, 0x3b3: 0x12a, 0x3b4: 0x12b, 0x3b5: 0x100, 0x3b6: 0x100, 0x3b7: 0x100,
0x3b8: 0x100, 0x3b9: 0x12c, 0x3ba: 0x12d, 0x3bb: 0x12e, 0x3bc: 0x12f, 0x3bd: 0x130, 0x3be: 0x131, 0x3bf: 0x132,
// Block 0xf, offset 0x3c0
0x3c0: 0x133, 0x3c1: 0x134, 0x3c2: 0x135, 0x3c3: 0x136, 0x3c4: 0x137, 0x3c5: 0x138, 0x3c6: 0x139, 0x3c7: 0x13a,
0x3c8: 0x13b, 0x3c9: 0x13c, 0x3ca: 0x13d, 0x3cb: 0x13e, 0x3cc: 0x60, 0x3cd: 0x61, 0x3ce: 0x100, 0x3cf: 0x100,
0x3d0: 0x13f, 0x3d1: 0x140, 0x3d2: 0x141, 0x3d3: 0x142, 0x3d4: 0x100, 0x3d5: 0x100, 0x3d6: 0x143, 0x3d7: 0x144,
0x3d8: 0x145, 0x3d9: 0x146, 0x3da: 0x147, 0x3db: 0x148, 0x3dc: 0x149, 0x3dd: 0x14a, 0x3de: 0x100, 0x3df: 0x100,
0x3e0: 0x14b, 0x3e1: 0x100, 0x3e2: 0x14c, 0x3e3: 0x14d, 0x3e4: 0x62, 0x3e5: 0x14e, 0x3e6: 0x14f, 0x3e7: 0x150,
0x3e8: 0x151, 0x3e9: 0x152, 0x3ea: 0x153, 0x3eb: 0x154, 0x3ec: 0x155, 0x3ed: 0x100, 0x3ee: 0x100, 0x3ef: 0x100,
0x3f0: 0x156, 0x3f1: 0x157, 0x3f2: 0x158, 0x3f3: 0x100, 0x3f4: 0x159, 0x3f5: 0x15a, 0x3f6: 0x15b, 0x3f7: 0x100,
0x3f8: 0x100, 0x3f9: 0x100, 0x3fa: 0x100, 0x3fb: 0x15c, 0x3fc: 0x15d, 0x3fd: 0x15e, 0x3fe: 0x15f, 0x3ff: 0x160,
// Block 0x10, offset 0x400
0x400: 0xa6, 0x401: 0xa6, 0x402: 0xa6, 0x403: 0xa6, 0x404: 0xa6, 0x405: 0xa6, 0x406: 0xa6, 0x407: 0xa6,
0x408: 0xa6, 0x409: 0xa6, 0x40a: 0xa6, 0x40b: 0xa6, 0x40c: 0xa6, 0x40d: 0xa6, 0x40e: 0x161, 0x40f: 0x100,
0x410: 0xa2, 0x411: 0x162, 0x412: 0xa6, 0x413: 0xa6, 0x414: 0xa6, 0x415: 0x163, 0x416: 0x100, 0x417: 0x100,
0x418: 0x100, 0x419: 0x100, 0x41a: 0x100, 0x41b: 0x100, 0x41c: 0x100, 0x41d: 0x100, 0x41e: 0x100, 0x41f: 0x100,
0x420: 0x100, 0x421: 0x100, 0x422: 0x100, 0x423: 0x100, 0x424: 0x100, 0x425: 0x100, 0x426: 0x100, 0x427: 0x100,
0x428: 0x100, 0x429: 0x100, 0x42a: 0x100, 0x42b: 0x100, 0x42c: 0x100, 0x42d: 0x100, 0x42e: 0x100, 0x42f: 0x100,
0x430: 0x100, 0x431: 0x100, 0x432: 0x100, 0x433: 0x100, 0x434: 0x100, 0x435: 0x100, 0x436: 0x100, 0x437: 0x100,
0x438: 0x100, 0x439: 0x100, 0x43a: 0x100, 0x43b: 0x100, 0x43c: 0x100, 0x43d: 0x100, 0x43e: 0x164, 0x43f: 0x165,
// Block 0x11, offset 0x440
0x440: 0xa6, 0x441: 0xa6, 0x442: 0xa6, 0x443: 0xa6, 0x444: 0xa6, 0x445: 0xa6, 0x446: 0xa6, 0x447: 0xa6,
0x448: 0xa6, 0x449: 0xa6, 0x44a: 0xa6, 0x44b: 0xa6, 0x44c: 0xa6, 0x44d: 0xa6, 0x44e: 0xa6, 0x44f: 0xa6,
0x450: 0x166, 0x451: 0x167, 0x452: 0x100, 0x453: 0x100, 0x454: 0x100, 0x455: 0x100, 0x456: 0x100, 0x457: 0x100,
0x458: 0x100, 0x459: 0x100, 0x45a: 0x100, 0x45b: 0x100, 0x45c: 0x100, 0x45d: 0x100, 0x45e: 0x100, 0x45f: 0x100,
0x460: 0x100, 0x461: 0x100, 0x462: 0x100, 0x463: 0x100, 0x464: 0x100, 0x465: 0x100, 0x466: 0x100, 0x467: 0x100,
0x468: 0x100, 0x469: 0x100, 0x46a: 0x100, 0x46b: 0x100, 0x46c: 0x100, 0x46d: 0x100, 0x46e: 0x100, 0x46f: 0x100,
0x470: 0x100, 0x471: 0x100, 0x472: 0x100, 0x473: 0x100, 0x474: 0x100, 0x475: 0x100, 0x476: 0x100, 0x477: 0x100,
0x478: 0x100, 0x479: 0x100, 0x47a: 0x100, 0x47b: 0x100, 0x47c: 0x100, 0x47d: 0x100, 0x47e: 0x100, 0x47f: 0x100,
// Block 0x12, offset 0x480
0x480: 0x100, 0x481: 0x100, 0x482: 0x100, 0x483: 0x100, 0x484: 0x100, 0x485: 0x100, 0x486: 0x100, 0x487: 0x100,
0x488: 0x100, 0x489: 0x100, 0x48a: 0x100, 0x48b: 0x100, 0x48c: 0x100, 0x48d: 0x100, 0x48e: 0x100, 0x48f: 0x100,
0x490: 0xa6, 0x491: 0xa6, 0x492: 0xa6, 0x493: 0xa6, 0x494: 0xa6, 0x495: 0xa6, 0x496: 0xa6, 0x497: 0xa6,
0x498: 0xa6, 0x499: 0x14a, 0x49a: 0x100, 0x49b: 0x100, 0x49c: 0x100, 0x49d: 0x100, 0x49e: 0x100, 0x49f: 0x100,
0x4a0: 0x100, 0x4a1: 0x100, 0x4a2: 0x100, 0x4a3: 0x100, 0x4a4: 0x100, 0x4a5: 0x100, 0x4a6: 0x100, 0x4a7: 0x100,
0x4a8: 0x100, 0x4a9: 0x100, 0x4aa: 0x100, 0x4ab: 0x100, 0x4ac: 0x100, 0x4ad: 0x100, 0x4ae: 0x100, 0x4af: 0x100,
0x4b0: 0x100, 0x4b1: 0x100, 0x4b2: 0x100, 0x4b3: 0x100, 0x4b4: 0x100, 0x4b5: 0x100, 0x4b6: 0x100, 0x4b7: 0x100,
0x4b8: 0x100, 0x4b9: 0x100, 0x4ba: 0x100, 0x4bb: 0x100, 0x4bc: 0x100, 0x4bd: 0x100, 0x4be: 0x100, 0x4bf: 0x100,
// Block 0x13, offset 0x4c0
0x4c0: 0x100, 0x4c1: 0x100, 0x4c2: 0x100, 0x4c3: 0x100, 0x4c4: 0x100, 0x4c5: 0x100, 0x4c6: 0x100, 0x4c7: 0x100,
0x4c8: 0x100, 0x4c9: 0x100, 0x4ca: 0x100, 0x4cb: 0x100, 0x4cc: 0x100, 0x4cd: 0x100, 0x4ce: 0x100, 0x4cf: 0x100,
0x4d0: 0x100, 0x4d1: 0x100, 0x4d2: 0x100, 0x4d3: 0x100, 0x4d4: 0x100, 0x4d5: 0x100, 0x4d6: 0x100, 0x4d7: 0x100,
0x4d8: 0x100, 0x4d9: 0x100, 0x4da: 0x100, 0x4db: 0x100, 0x4dc: 0x100, 0x4dd: 0x100, 0x4de: 0x100, 0x4df: 0x100,
0x4e0: 0xa6, 0x4e1: 0xa6, 0x4e2: 0xa6, 0x4e3: 0xa6, 0x4e4: 0xa6, 0x4e5: 0xa6, 0x4e6: 0xa6, 0x4e7: 0xa6,
0x4e8: 0x154, 0x4e9: 0x168, 0x4ea: 0x169, 0x4eb: 0x16a, 0x4ec: 0x16b, 0x4ed: 0x16c, 0x4ee: 0x16d, 0x4ef: 0x100,
0x4f0: 0x100, 0x4f1: 0x100, 0x4f2: 0x100, 0x4f3: 0x100, 0x4f4: 0x100, 0x4f5: 0x100, 0x4f6: 0x100, 0x4f7: 0x100,
0x4f8: 0x100, 0x4f9: 0x16e, 0x4fa: 0x16f, 0x4fb: 0x100, 0x4fc: 0xa6, 0x4fd: 0x170, 0x4fe: 0x171, 0x4ff: 0x172,
// Block 0x14, offset 0x500
0x500: 0xa6, 0x501: 0xa6, 0x502: 0xa6, 0x503: 0xa6, 0x504: 0xa6, 0x505: 0xa6, 0x506: 0xa6, 0x507: 0xa6,
0x508: 0xa6, 0x509: 0xa6, 0x50a: 0xa6, 0x50b: 0xa6, 0x50c: 0xa6, 0x50d: 0xa6, 0x50e: 0xa6, 0x50f: 0xa6,
0x510: 0xa6, 0x511: 0xa6, 0x512: 0xa6, 0x513: 0xa6, 0x514: 0xa6, 0x515: 0xa6, 0x516: 0xa6, 0x517: 0xa6,
0x518: 0xa6, 0x519: 0xa6, 0x51a: 0xa6, 0x51b: 0xa6, 0x51c: 0xa6, 0x51d: 0xa6, 0x51e: 0xa6, 0x51f: 0x173,
0x520: 0xa6, 0x521: 0xa6, 0x522: 0xa6, 0x523: 0xa6, 0x524: 0xa6, 0x525: 0xa6, 0x526: 0xa6, 0x527: 0xa6,
0x528: 0xa6, 0x529: 0xa6, 0x52a: 0xa6, 0x52b: 0xa6, 0x52c: 0xa6, 0x52d: 0xa6, 0x52e: 0xa6, 0x52f: 0xa6,
0x530: 0xa6, 0x531: 0xa6, 0x532: 0xa6, 0x533: 0x174, 0x534: 0x175, 0x535: 0x100, 0x536: 0x100, 0x537: 0x100,
0x538: 0x100, 0x539: 0x100, 0x53a: 0x100, 0x53b: 0x100, 0x53c: 0x100, 0x53d: 0x100, 0x53e: 0x100, 0x53f: 0x100,
// Block 0x15, offset 0x540
0x540: 0x100, 0x541: 0x100, 0x542: 0x100, 0x543: 0x100, 0x544: 0x100, 0x545: 0x100, 0x546: 0x100, 0x547: 0x100,
0x548: 0x100, 0x549: 0x100, 0x54a: 0x100, 0x54b: 0x100, 0x54c: 0x100, 0x54d: 0x100, 0x54e: 0x100, 0x54f: 0x100,
0x550: 0x100, 0x551: 0x100, 0x552: 0x100, 0x553: 0x100, 0x554: 0x100, 0x555: 0x100, 0x556: 0x100, 0x557: 0x100,
0x558: 0x100, 0x559: 0x100, 0x55a: 0x100, 0x55b: 0x100, 0x55c: 0x100, 0x55d: 0x100, 0x55e: 0x100, 0x55f: 0x100,
0x560: 0x100, 0x561: 0x100, 0x562: 0x100, 0x563: 0x100, 0x564: 0x100, 0x565: 0x100, 0x566: 0x100, 0x567: 0x100,
0x568: 0x100, 0x569: 0x100, 0x56a: 0x100, 0x56b: 0x100, 0x56c: 0x100, 0x56d: 0x100, 0x56e: 0x100, 0x56f: 0x100,
0x570: 0x100, 0x571: 0x100, 0x572: 0x100, 0x573: 0x100, 0x574: 0x100, 0x575: 0x100, 0x576: 0x100, 0x577: 0x100,
0x578: 0x100, 0x579: 0x100, 0x57a: 0x100, 0x57b: 0x100, 0x57c: 0x100, 0x57d: 0x100, 0x57e: 0x100, 0x57f: 0x176,
// Block 0x16, offset 0x580
0x580: 0xa6, 0x581: 0xa6, 0x582: 0xa6, 0x583: 0xa6, 0x584: 0x177, 0x585: 0x178, 0x586: 0xa6, 0x587: 0xa6,
0x588: 0xa6, 0x589: 0xa6, 0x58a: 0xa6, 0x58b: 0x179, 0x58c: 0x100, 0x58d: 0x100, 0x58e: 0x100, 0x58f: 0x100,
0x590: 0x100, 0x591: 0x100, 0x592: 0x100, 0x593: 0x100, 0x594: 0x100, 0x595: 0x100, 0x596: 0x100, 0x597: 0x100,
0x598: 0x100, 0x599: 0x100, 0x59a: 0x100, 0x59b: 0x100, 0x59c: 0x100, 0x59d: 0x100, 0x59e: 0x100, 0x59f: 0x100,
0x5a0: 0x100, 0x5a1: 0x100, 0x5a2: 0x100, 0x5a3: 0x100, 0x5a4: 0x100, 0x5a5: 0x100, 0x5a6: 0x100, 0x5a7: 0x100,
0x5a8: 0x100, 0x5a9: 0x100, 0x5aa: 0x100, 0x5ab: 0x100, 0x5ac: 0x100, 0x5ad: 0x100, 0x5ae: 0x100, 0x5af: 0x100,
0x5b0: 0xa6, 0x5b1: 0x17a, 0x5b2: 0x17b, 0x5b3: 0x100, 0x5b4: 0x100, 0x5b5: 0x100, 0x5b6: 0x100, 0x5b7: 0x100,
0x5b8: 0x100, 0x5b9: 0x100, 0x5ba: 0x100, 0x5bb: 0x100, 0x5bc: 0x100, 0x5bd: 0x100, 0x5be: 0x100, 0x5bf: 0x100,
// Block 0x17, offset 0x5c0
0x5c0: 0x100, 0x5c1: 0x100, 0x5c2: 0x100, 0x5c3: 0x100, 0x5c4: 0x100, 0x5c5: 0x100, 0x5c6: 0x100, 0x5c7: 0x100,
0x5c8: 0x100, 0x5c9: 0x100, 0x5ca: 0x100, 0x5cb: 0x100, 0x5cc: 0x100, 0x5cd: 0x100, 0x5ce: 0x100, 0x5cf: 0x100,
0x5d0: 0x100, 0x5d1: 0x100, 0x5d2: 0x100, 0x5d3: 0x100, 0x5d4: 0x100, 0x5d5: 0x100, 0x5d6: 0x100, 0x5d7: 0x100,
0x5d8: 0x100, 0x5d9: 0x100, 0x5da: 0x100, 0x5db: 0x100, 0x5dc: 0x100, 0x5dd: 0x100, 0x5de: 0x100, 0x5df: 0x100,
0x5e0: 0x100, 0x5e1: 0x100, 0x5e2: 0x100, 0x5e3: 0x100, 0x5e4: 0x100, 0x5e5: 0x100, 0x5e6: 0x100, 0x5e7: 0x100,
0x5e8: 0x100, 0x5e9: 0x100, 0x5ea: 0x100, 0x5eb: 0x100, 0x5ec: 0x100, 0x5ed: 0x100, 0x5ee: 0x100, 0x5ef: 0x100,
0x5f0: 0x100, 0x5f1: 0x100, 0x5f2: 0x100, 0x5f3: 0x100, 0x5f4: 0x100, 0x5f5: 0x100, 0x5f6: 0x100, 0x5f7: 0x100,
0x5f8: 0x100, 0x5f9: 0x100, 0x5fa: 0x100, 0x5fb: 0x100, 0x5fc: 0x17c, 0x5fd: 0x17d, 0x5fe: 0xa2, 0x5ff: 0x17e,
// Block 0x18, offset 0x600
0x600: 0xa2, 0x601: 0xa2, 0x602: 0xa2, 0x603: 0x17f, 0x604: 0x180, 0x605: 0x181, 0x606: 0x182, 0x607: 0x183,
0x608: 0xa2, 0x609: 0x184, 0x60a: 0x100, 0x60b: 0x185, 0x60c: 0xa2, 0x60d: 0x186, 0x60e: 0x100, 0x60f: 0x100,
0x610: 0x63, 0x611: 0x64, 0x612: 0x65, 0x613: 0x66, 0x614: 0x67, 0x615: 0x68, 0x616: 0x69, 0x617: 0x6a,
0x618: 0x6b, 0x619: 0x6c, 0x61a: 0x6d, 0x61b: 0x6e, 0x61c: 0x6f, 0x61d: 0x70, 0x61e: 0x71, 0x61f: 0x72,
0x620: 0xa2, 0x621: 0xa2, 0x622: 0xa2, 0x623: 0xa2, 0x624: 0xa2, 0x625: 0xa2, 0x626: 0xa2, 0x627: 0xa2,
0x628: 0x187, 0x629: 0x188, 0x62a: 0x189, 0x62b: 0x100, 0x62c: 0x100, 0x62d: 0x100, 0x62e: 0x100, 0x62f: 0x100,
0x630: 0x100, 0x631: 0x100, 0x632: 0x100, 0x633: 0x100, 0x634: 0x100, 0x635: 0x100, 0x636: 0x100, 0x637: 0x100,
0x638: 0x100, 0x639: 0x100, 0x63a: 0x100, 0x63b: 0x100, 0x63c: 0x18a, 0x63d: 0x100, 0x63e: 0x100, 0x63f: 0x100,
// Block 0x19, offset 0x640
0x640: 0x73, 0x641: 0x74, 0x642: 0x18b, 0x643: 0x100, 0x644: 0x18c, 0x645: 0x18d, 0x646: 0x100, 0x647: 0x100,
0x648: 0x100, 0x649: 0x100, 0x64a: 0x18e, 0x64b: 0x18f, 0x64c: 0x100, 0x64d: 0x100, 0x64e: 0x100, 0x64f: 0x100,
0x650: 0x100, 0x651: 0x100, 0x652: 0x100, 0x653: 0x190, 0x654: 0x100, 0x655: 0x100, 0x656: 0x100, 0x657: 0x100,
0x658: 0x100, 0x659: 0x100, 0x65a: 0x100, 0x65b: 0x100, 0x65c: 0x100, 0x65d: 0x100, 0x65e: 0x100, 0x65f: 0x191,
0x660: 0x127, 0x661: 0x127, 0x662: 0x127, 0x663: 0x192, 0x664: 0x75, 0x665: 0x193, 0x666: 0x100, 0x667: 0x100,
0x668: 0x100, 0x669: 0x100, 0x66a: 0x100, 0x66b: 0x100, 0x66c: 0x100, 0x66d: 0x100, 0x66e: 0x100, 0x66f: 0x100,
0x670: 0x100, 0x671: 0x194, 0x672: 0x195, 0x673: 0x100, 0x674: 0x196, 0x675: 0x100, 0x676: 0x100, 0x677: 0x100,
0x678: 0x76, 0x679: 0x77, 0x67a: 0x78, 0x67b: 0x197, 0x67c: 0x100, 0x67d: 0x100, 0x67e: 0x100, 0x67f: 0x100,
// Block 0x1a, offset 0x680
0x680: 0x198, 0x681: 0xa2, 0x682: 0x199, 0x683: 0x19a, 0x684: 0x79, 0x685: 0x7a, 0x686: 0x19b, 0x687: 0x19c,
0x688: 0x7b, 0x689: 0x19d, 0x68a: 0x100, 0x68b: 0x100, 0x68c: 0xa2, 0x68d: 0xa2, 0x68e: 0xa2, 0x68f: 0xa2,
0x690: 0xa2, 0x691: 0xa2, 0x692: 0xa2, 0x693: 0xa2, 0x694: 0xa2, 0x695: 0xa2, 0x696: 0xa2, 0x697: 0xa2,
0x698: 0xa2, 0x699: 0xa2, 0x69a: 0xa2, 0x69b: 0x19e, 0x69c: 0xa2, 0x69d: 0x19f, 0x69e: 0xa2, 0x69f: 0x1a0,
0x6a0: 0x1a1, 0x6a1: 0x1a2, 0x6a2: 0x1a3, 0x6a3: 0x100, 0x6a4: 0xa2, 0x6a5: 0xa2, 0x6a6: 0xa2, 0x6a7: 0xa2,
0x6a8: 0xa2, 0x6a9: 0x1a4, 0x6aa: 0x1a5, 0x6ab: 0x1a6, 0x6ac: 0xa2, 0x6ad: 0xa2, 0x6ae: 0x1a7, 0x6af: 0x1a8,
0x6b0: 0x100, 0x6b1: 0x100, 0x6b2: 0x100, 0x6b3: 0x100, 0x6b4: 0x100, 0x6b5: 0x100, 0x6b6: 0x100, 0x6b7: 0x100,
0x6b8: 0x100, 0x6b9: 0x100, 0x6ba: 0x100, 0x6bb: 0x100, 0x6bc: 0x100, 0x6bd: 0x100, 0x6be: 0x100, 0x6bf: 0x100,
// Block 0x1b, offset 0x6c0
0x6c0: 0xa6, 0x6c1: 0xa6, 0x6c2: 0xa6, 0x6c3: 0xa6, 0x6c4: 0xa6, 0x6c5: 0xa6, 0x6c6: 0xa6, 0x6c7: 0xa6,
0x6c8: 0xa6, 0x6c9: 0xa6, 0x6ca: 0xa6, 0x6cb: 0xa6, 0x6cc: 0xa6, 0x6cd: 0xa6, 0x6ce: 0xa6, 0x6cf: 0xa6,
0x6d0: 0xa6, 0x6d1: 0xa6, 0x6d2: 0xa6, 0x6d3: 0xa6, 0x6d4: 0xa6, 0x6d5: 0xa6, 0x6d6: 0xa6, 0x6d7: 0xa6,
0x6d8: 0xa6, 0x6d9: 0xa6, 0x6da: 0xa6, 0x6db: 0x1a9, 0x6dc: 0xa6, 0x6dd: 0xa6, 0x6de: 0xa6, 0x6df: 0xa6,
0x6e0: 0xa6, 0x6e1: 0xa6, 0x6e2: 0xa6, 0x6e3: 0xa6, 0x6e4: 0xa6, 0x6e5: 0xa6, 0x6e6: 0xa6, 0x6e7: 0xa6,
0x6e8: 0xa6, 0x6e9: 0xa6, 0x6ea: 0xa6, 0x6eb: 0xa6, 0x6ec: 0xa6, 0x6ed: 0xa6, 0x6ee: 0xa6, 0x6ef: 0xa6,
0x6f0: 0xa6, 0x6f1: 0xa6, 0x6f2: 0xa6, 0x6f3: 0xa6, 0x6f4: 0xa6, 0x6f5: 0xa6, 0x6f6: 0xa6, 0x6f7: 0xa6,
0x6f8: 0xa6, 0x6f9: 0xa6, 0x6fa: 0xa6, 0x6fb: 0xa6, 0x6fc: 0xa6, 0x6fd: 0xa6, 0x6fe: 0xa6, 0x6ff: 0xa6,
// Block 0x1c, offset 0x700
0x700: 0xa6, 0x701: 0xa6, 0x702: 0xa6, 0x703: 0xa6, 0x704: 0xa6, 0x705: 0xa6, 0x706: 0xa6, 0x707: 0xa6,
0x708: 0xa6, 0x709: 0xa6, 0x70a: 0xa6, 0x70b: 0xa6, 0x70c: 0xa6, 0x70d: 0xa6, 0x70e: 0xa6, 0x70f: 0xa6,
0x710: 0xa6, 0x711: 0xa6, 0x712: 0xa6, 0x713: 0xa6, 0x714: 0xa6, 0x715: 0xa6, 0x716: 0xa6, 0x717: 0xa6,
0x718: 0xa6, 0x719: 0xa6, 0x71a: 0xa6, 0x71b: 0xa6, 0x71c: 0x1aa, 0x71d: 0xa6, 0x71e: 0xa6, 0x71f: 0xa6,
0x720: 0x1ab, 0x721: 0xa6, 0x722: 0xa6, 0x723: 0xa6, 0x724: 0xa6, 0x725: 0xa6, 0x726: 0xa6, 0x727: 0xa6,
0x728: 0xa6, 0x729: 0xa6, 0x72a: 0xa6, 0x72b: 0xa6, 0x72c: 0xa6, 0x72d: 0xa6, 0x72e: 0xa6, 0x72f: 0xa6,
0x730: 0xa6, 0x731: 0xa6, 0x732: 0xa6, 0x733: 0xa6, 0x734: 0xa6, 0x735: 0xa6, 0x736: 0xa6, 0x737: 0xa6,
0x738: 0xa6, 0x739: 0xa6, 0x73a: 0xa6, 0x73b: 0xa6, 0x73c: 0xa6, 0x73d: 0xa6, 0x73e: 0xa6, 0x73f: 0xa6,
// Block 0x1d, offset 0x740
0x740: 0xa6, 0x741: 0xa6, 0x742: 0xa6, 0x743: 0xa6, 0x744: 0xa6, 0x745: 0xa6, 0x746: 0xa6, 0x747: 0xa6,
0x748: 0xa6, 0x749: 0xa6, 0x74a: 0xa6, 0x74b: 0xa6, 0x74c: 0xa6, 0x74d: 0xa6, 0x74e: 0xa6, 0x74f: 0xa6,
0x750: 0xa6, 0x751: 0xa6, 0x752: 0xa6, 0x753: 0xa6, 0x754: 0xa6, 0x755: 0xa6, 0x756: 0xa6, 0x757: 0xa6,
0x758: 0xa6, 0x759: 0xa6, 0x75a: 0xa6, 0x75b: 0xa6, 0x75c: 0xa6, 0x75d: 0xa6, 0x75e: 0xa6, 0x75f: 0xa6,
0x760: 0xa6, 0x761: 0xa6, 0x762: 0xa6, 0x763: 0xa6, 0x764: 0xa6, 0x765: 0xa6, 0x766: 0xa6, 0x767: 0xa6,
0x768: 0xa6, 0x769: 0xa6, 0x76a: 0xa6, 0x76b: 0xa6, 0x76c: 0xa6, 0x76d: 0xa6, 0x76e: 0xa6, 0x76f: 0xa6,
0x770: 0xa6, 0x771: 0xa6, 0x772: 0xa6, 0x773: 0xa6, 0x774: 0xa6, 0x775: 0xa6, 0x776: 0xa6, 0x777: 0xa6,
0x778: 0xa6, 0x779: 0xa6, 0x77a: 0x1ac, 0x77b: 0xa6, 0x77c: 0xa6, 0x77d: 0xa6, 0x77e: 0xa6, 0x77f: 0xa6,
// Block 0x1e, offset 0x780
0x780: 0xa6, 0x781: 0xa6, 0x782: 0xa6, 0x783: 0xa6, 0x784: 0xa6, 0x785: 0xa6, 0x786: 0xa6, 0x787: 0xa6,
0x788: 0xa6, 0x789: 0xa6, 0x78a: 0xa6, 0x78b: 0xa6, 0x78c: 0xa6, 0x78d: 0xa6, 0x78e: 0xa6, 0x78f: 0xa6,
0x790: 0xa6, 0x791: 0xa6, 0x792: 0xa6, 0x793: 0xa6, 0x794: 0xa6, 0x795: 0xa6, 0x796: 0xa6, 0x797: 0xa6,
0x798: 0xa6, 0x799: 0xa6, 0x79a: 0xa6, 0x79b: 0xa6, 0x79c: 0xa6, 0x79d: 0xa6, 0x79e: 0xa6, 0x79f: 0xa6,
0x7a0: 0xa6, 0x7a1: 0xa6, 0x7a2: 0xa6, 0x7a3: 0xa6, 0x7a4: 0xa6, 0x7a5: 0xa6, 0x7a6: 0xa6, 0x7a7: 0xa6,
0x7a8: 0xa6, 0x7a9: 0xa6, 0x7aa: 0xa6, 0x7ab: 0xa6, 0x7ac: 0xa6, 0x7ad: 0xa6, 0x7ae: 0xa6, 0x7af: 0x1ad,
0x7b0: 0x100, 0x7b1: 0x100, 0x7b2: 0x100, 0x7b3: 0x100, 0x7b4: 0x100, 0x7b5: 0x100, 0x7b6: 0x100, 0x7b7: 0x100,
0x7b8: 0x100, 0x7b9: 0x100, 0x7ba: 0x100, 0x7bb: 0x100, 0x7bc: 0x100, 0x7bd: 0x100, 0x7be: 0x100, 0x7bf: 0x100,
// Block 0x1f, offset 0x7c0
0x7c0: 0x100, 0x7c1: 0x100, 0x7c2: 0x100, 0x7c3: 0x100, 0x7c4: 0x100, 0x7c5: 0x100, 0x7c6: 0x100, 0x7c7: 0x100,
0x7c8: 0x100, 0x7c9: 0x100, 0x7ca: 0x100, 0x7cb: 0x100, 0x7cc: 0x100, 0x7cd: 0x100, 0x7ce: 0x100, 0x7cf: 0x100,
0x7d0: 0x100, 0x7d1: 0x100, 0x7d2: 0x100, 0x7d3: 0x100, 0x7d4: 0x100, 0x7d5: 0x100, 0x7d6: 0x100, 0x7d7: 0x100,
0x7d8: 0x100, 0x7d9: 0x100, 0x7da: 0x100, 0x7db: 0x100, 0x7dc: 0x100, 0x7dd: 0x100, 0x7de: 0x100, 0x7df: 0x100,
0x7e0: 0x7c, 0x7e1: 0x7d, 0x7e2: 0x7e, 0x7e3: 0x7f, 0x7e4: 0x80, 0x7e5: 0x81, 0x7e6: 0x82, 0x7e7: 0x83,
0x7e8: 0x84, 0x7e9: 0x100, 0x7ea: 0x100, 0x7eb: 0x100, 0x7ec: 0x100, 0x7ed: 0x100, 0x7ee: 0x100, 0x7ef: 0x100,
0x7f0: 0x100, 0x7f1: 0x100, 0x7f2: 0x100, 0x7f3: 0x100, 0x7f4: 0x100, 0x7f5: 0x100, 0x7f6: 0x100, 0x7f7: 0x100,
0x7f8: 0x100, 0x7f9: 0x100, 0x7fa: 0x100, 0x7fb: 0x100, 0x7fc: 0x100, 0x7fd: 0x100, 0x7fe: 0x100, 0x7ff: 0x100,
// Block 0x20, offset 0x800
0x800: 0xa6, 0x801: 0xa6, 0x802: 0xa6, 0x803: 0xa6, 0x804: 0xa6, 0x805: 0xa6, 0x806: 0xa6, 0x807: 0xa6,
0x808: 0xa6, 0x809: 0xa6, 0x80a: 0xa6, 0x80b: 0xa6, 0x80c: 0xa6, 0x80d: 0x1ae, 0x80e: 0xa6, 0x80f: 0xa6,
0x810: 0xa6, 0x811: 0xa6, 0x812: 0xa6, 0x813: 0xa6, 0x814: 0xa6, 0x815: 0xa6, 0x816: 0xa6, 0x817: 0xa6,
0x818: 0xa6, 0x819: 0xa6, 0x81a: 0xa6, 0x81b: 0xa6, 0x81c: 0xa6, 0x81d: 0xa6, 0x81e: 0xa6, 0x81f: 0xa6,
0x820: 0xa6, 0x821: 0xa6, 0x822: 0xa6, 0x823: 0xa6, 0x824: 0xa6, 0x825: 0xa6, 0x826: 0xa6, 0x827: 0xa6,
0x828: 0xa6, 0x829: 0xa6, 0x82a: 0xa6, 0x82b: 0xa6, 0x82c: 0xa6, 0x82d: 0xa6, 0x82e: 0xa6, 0x82f: 0xa6,
0x830: 0xa6, 0x831: 0xa6, 0x832: 0xa6, 0x833: 0xa6, 0x834: 0xa6, 0x835: 0xa6, 0x836: 0xa6, 0x837: 0xa6,
0x838: 0xa6, 0x839: 0xa6, 0x83a: 0xa6, 0x83b: 0xa6, 0x83c: 0xa6, 0x83d: 0xa6, 0x83e: 0xa6, 0x83f: 0xa6,
// Block 0x21, offset 0x840
0x840: 0xa6, 0x841: 0xa6, 0x842: 0xa6, 0x843: 0xa6, 0x844: 0xa6, 0x845: 0xa6, 0x846: 0xa6, 0x847: 0xa6,
0x848: 0xa6, 0x849: 0xa6, 0x84a: 0xa6, 0x84b: 0xa6, 0x84c: 0xa6, 0x84d: 0xa6, 0x84e: 0x1af, 0x84f: 0x100,
0x850: 0x100, 0x851: 0x100, 0x852: 0x100, 0x853: 0x100, 0x854: 0x100, 0x855: 0x100, 0x856: 0x100, 0x857: 0x100,
0x858: 0x100, 0x859: 0x100, 0x85a: 0x100, 0x85b: 0x100, 0x85c: 0x100, 0x85d: 0x100, 0x85e: 0x100, 0x85f: 0x100,
0x860: 0x100, 0x861: 0x100, 0x862: 0x100, 0x863: 0x100, 0x864: 0x100, 0x865: 0x100, 0x866: 0x100, 0x867: 0x100,
0x868: 0x100, 0x869: 0x100, 0x86a: 0x100, 0x86b: 0x100, 0x86c: 0x100, 0x86d: 0x100, 0x86e: 0x100, 0x86f: 0x100,
0x870: 0x100, 0x871: 0x100, 0x872: 0x100, 0x873: 0x100, 0x874: 0x100, 0x875: 0x100, 0x876: 0x100, 0x877: 0x100,
0x878: 0x100, 0x879: 0x100, 0x87a: 0x100, 0x87b: 0x100, 0x87c: 0x100, 0x87d: 0x100, 0x87e: 0x100, 0x87f: 0x100,
// Block 0x22, offset 0x880
0x890: 0x0c, 0x891: 0x0d, 0x892: 0x0e, 0x893: 0x0f, 0x894: 0x10, 0x895: 0x0a, 0x896: 0x11, 0x897: 0x07,
0x898: 0x12, 0x899: 0x0a, 0x89a: 0x13, 0x89b: 0x14, 0x89c: 0x15, 0x89d: 0x16, 0x89e: 0x17, 0x89f: 0x18,
0x8a0: 0x07, 0x8a1: 0x07, 0x8a2: 0x07, 0x8a3: 0x07, 0x8a4: 0x07, 0x8a5: 0x07, 0x8a6: 0x07, 0x8a7: 0x07,
0x8a8: 0x07, 0x8a9: 0x07, 0x8aa: 0x19, 0x8ab: 0x1a, 0x8ac: 0x1b, 0x8ad: 0x07, 0x8ae: 0x1c, 0x8af: 0x1d,
0x8b0: 0x07, 0x8b1: 0x1e, 0x8b2: 0x1f, 0x8b3: 0x0a, 0x8b4: 0x0a, 0x8b5: 0x0a, 0x8b6: 0x0a, 0x8b7: 0x0a,
0x8b8: 0x0a, 0x8b9: 0x0a, 0x8ba: 0x0a, 0x8bb: 0x0a, 0x8bc: 0x0a, 0x8bd: 0x0a, 0x8be: 0x0a, 0x8bf: 0x0a,
// Block 0x23, offset 0x8c0
0x8c0: 0x0a, 0x8c1: 0x0a, 0x8c2: 0x0a, 0x8c3: 0x0a, 0x8c4: 0x0a, 0x8c5: 0x0a, 0x8c6: 0x0a, 0x8c7: 0x0a,
0x8c8: 0x0a, 0x8c9: 0x0a, 0x8ca: 0x0a, 0x8cb: 0x0a, 0x8cc: 0x0a, 0x8cd: 0x0a, 0x8ce: 0x0a, 0x8cf: 0x0a,
0x8d0: 0x0a, 0x8d1: 0x0a, 0x8d2: 0x0a, 0x8d3: 0x0a, 0x8d4: 0x0a, 0x8d5: 0x0a, 0x8d6: 0x0a, 0x8d7: 0x0a,
0x8d8: 0x0a, 0x8d9: 0x0a, 0x8da: 0x0a, 0x8db: 0x0a, 0x8dc: 0x0a, 0x8dd: 0x0a, 0x8de: 0x0a, 0x8df: 0x0a,
0x8e0: 0x0a, 0x8e1: 0x0a, 0x8e2: 0x0a, 0x8e3: 0x0a, 0x8e4: 0x0a, 0x8e5: 0x0a, 0x8e6: 0x0a, 0x8e7: 0x0a,
0x8e8: 0x0a, 0x8e9: 0x0a, 0x8ea: 0x0a, 0x8eb: 0x0a, 0x8ec: 0x0a, 0x8ed: 0x0a, 0x8ee: 0x0a, 0x8ef: 0x0a,
0x8f0: 0x0a, 0x8f1: 0x0a, 0x8f2: 0x0a, 0x8f3: 0x0a, 0x8f4: 0x0a, 0x8f5: 0x0a, 0x8f6: 0x0a, 0x8f7: 0x0a,
0x8f8: 0x0a, 0x8f9: 0x0a, 0x8fa: 0x0a, 0x8fb: 0x0a, 0x8fc: 0x0a, 0x8fd: 0x0a, 0x8fe: 0x0a, 0x8ff: 0x0a,
// Block 0x24, offset 0x900
0x900: 0x1b0, 0x901: 0x1b1, 0x902: 0x100, 0x903: 0x100, 0x904: 0x1b2, 0x905: 0x1b2, 0x906: 0x1b2, 0x907: 0x1b3,
0x908: 0x100, 0x909: 0x100, 0x90a: 0x100, 0x90b: 0x100, 0x90c: 0x100, 0x90d: 0x100, 0x90e: 0x100, 0x90f: 0x100,
0x910: 0x100, 0x911: 0x100, 0x912: 0x100, 0x913: 0x100, 0x914: 0x100, 0x915: 0x100, 0x916: 0x100, 0x917: 0x100,
0x918: 0x100, 0x919: 0x100, 0x91a: 0x100, 0x91b: 0x100, 0x91c: 0x100, 0x91d: 0x100, 0x91e: 0x100, 0x91f: 0x100,
0x920: 0x100, 0x921: 0x100, 0x922: 0x100, 0x923: 0x100, 0x924: 0x100, 0x925: 0x100, 0x926: 0x100, 0x927: 0x100,
0x928: 0x100, 0x929: 0x100, 0x92a: 0x100, 0x92b: 0x100, 0x92c: 0x100, 0x92d: 0x100, 0x92e: 0x100, 0x92f: 0x100,
0x930: 0x100, 0x931: 0x100, 0x932: 0x100, 0x933: 0x100, 0x934: 0x100, 0x935: 0x100, 0x936: 0x100, 0x937: 0x100,
0x938: 0x100, 0x939: 0x100, 0x93a: 0x100, 0x93b: 0x100, 0x93c: 0x100, 0x93d: 0x100, 0x93e: 0x100, 0x93f: 0x100,
// Block 0x25, offset 0x940
0x940: 0x0a, 0x941: 0x0a, 0x942: 0x0a, 0x943: 0x0a, 0x944: 0x0a, 0x945: 0x0a, 0x946: 0x0a, 0x947: 0x0a,
0x948: 0x0a, 0x949: 0x0a, 0x94a: 0x0a, 0x94b: 0x0a, 0x94c: 0x0a, 0x94d: 0x0a, 0x94e: 0x0a, 0x94f: 0x0a,
0x950: 0x0a, 0x951: 0x0a, 0x952: 0x0a, 0x953: 0x0a, 0x954: 0x0a, 0x955: 0x0a, 0x956: 0x0a, 0x957: 0x0a,
0x958: 0x0a, 0x959: 0x0a, 0x95a: 0x0a, 0x95b: 0x0a, 0x95c: 0x0a, 0x95d: 0x0a, 0x95e: 0x0a, 0x95f: 0x0a,
0x960: 0x22, 0x961: 0x0a, 0x962: 0x0a, 0x963: 0x0a, 0x964: 0x0a, 0x965: 0x0a, 0x966: 0x0a, 0x967: 0x0a,
0x968: 0x0a, 0x969: 0x0a, 0x96a: 0x0a, 0x96b: 0x0a, 0x96c: 0x0a, 0x96d: 0x0a, 0x96e: 0x0a, 0x96f: 0x0a,
0x970: 0x0a, 0x971: 0x0a, 0x972: 0x0a, 0x973: 0x0a, 0x974: 0x0a, 0x975: 0x0a, 0x976: 0x0a, 0x977: 0x0a,
0x978: 0x0a, 0x979: 0x0a, 0x97a: 0x0a, 0x97b: 0x0a, 0x97c: 0x0a, 0x97d: 0x0a, 0x97e: 0x0a, 0x97f: 0x0a,
// Block 0x26, offset 0x980
0x980: 0x0a, 0x981: 0x0a, 0x982: 0x0a, 0x983: 0x0a, 0x984: 0x0a, 0x985: 0x0a, 0x986: 0x0a, 0x987: 0x0a,
0x988: 0x0a, 0x989: 0x0a, 0x98a: 0x0a, 0x98b: 0x0a, 0x98c: 0x0a, 0x98d: 0x0a, 0x98e: 0x0a, 0x98f: 0x0a,
}
// idnaSparseOffset: 303 entries, 606 bytes
var idnaSparseOffset = []uint16{0x0, 0x8, 0x19, 0x25, 0x27, 0x2c, 0x33, 0x3e, 0x4a, 0x4e, 0x5d, 0x62, 0x6c, 0x78, 0x7e, 0x87, 0x97, 0xa6, 0xb1, 0xbe, 0xcf, 0xd9, 0xe0, 0xed, 0xfe, 0x105, 0x110, 0x11f, 0x12d, 0x137, 0x139, 0x13e, 0x141, 0x144, 0x146, 0x152, 0x15d, 0x165, 0x16b, 0x171, 0x176, 0x17b, 0x17e, 0x182, 0x188, 0x18d, 0x198, 0x1a2, 0x1a8, 0x1b9, 0x1c4, 0x1c7, 0x1cf, 0x1d2, 0x1df, 0x1e7, 0x1eb, 0x1f2, 0x1fa, 0x20a, 0x216, 0x219, 0x223, 0x22f, 0x23b, 0x247, 0x24f, 0x254, 0x261, 0x272, 0x27d, 0x282, 0x28b, 0x293, 0x299, 0x29e, 0x2a1, 0x2a5, 0x2ab, 0x2af, 0x2b3, 0x2b7, 0x2bc, 0x2c4, 0x2cb, 0x2d6, 0x2e0, 0x2e4, 0x2e7, 0x2ed, 0x2f1, 0x2f3, 0x2f6, 0x2f8, 0x2fb, 0x305, 0x308, 0x317, 0x31b, 0x31f, 0x321, 0x32a, 0x32e, 0x333, 0x338, 0x33e, 0x34e, 0x354, 0x358, 0x367, 0x36c, 0x374, 0x37e, 0x389, 0x391, 0x3a2, 0x3ab, 0x3bb, 0x3c8, 0x3d4, 0x3d9, 0x3e6, 0x3ea, 0x3ef, 0x3f1, 0x3f3, 0x3f7, 0x3f9, 0x3fd, 0x406, 0x40c, 0x410, 0x420, 0x42a, 0x42f, 0x432, 0x438, 0x43f, 0x444, 0x448, 0x44e, 0x453, 0x45c, 0x461, 0x467, 0x46e, 0x475, 0x47c, 0x480, 0x483, 0x488, 0x494, 0x49a, 0x49f, 0x4a6, 0x4ae, 0x4b3, 0x4b7, 0x4c7, 0x4ce, 0x4d2, 0x4d6, 0x4dd, 0x4df, 0x4e2, 0x4e5, 0x4e9, 0x4f2, 0x4f6, 0x4fe, 0x501, 0x509, 0x514, 0x523, 0x52f, 0x535, 0x542, 0x54e, 0x556, 0x55f, 0x56a, 0x571, 0x580, 0x58d, 0x591, 0x59e, 0x5a7, 0x5ab, 0x5ba, 0x5c2, 0x5cd, 0x5d6, 0x5dc, 0x5e4, 0x5ed, 0x5f9, 0x5fc, 0x608, 0x60b, 0x614, 0x617, 0x61c, 0x625, 0x62a, 0x637, 0x642, 0x64b, 0x656, 0x659, 0x65c, 0x666, 0x66f, 0x67b, 0x688, 0x695, 0x6a3, 0x6aa, 0x6b5, 0x6bc, 0x6c0, 0x6c4, 0x6c7, 0x6cc, 0x6cf, 0x6d2, 0x6d6, 0x6d9, 0x6de, 0x6e5, 0x6e8, 0x6f0, 0x6f4, 0x6ff, 0x702, 0x705, 0x708, 0x70e, 0x714, 0x71d, 0x720, 0x723, 0x726, 0x72e, 0x733, 0x73c, 0x73f, 0x744, 0x74e, 0x752, 0x756, 0x759, 0x75c, 0x760, 0x76f, 0x77b, 0x77f, 0x784, 0x789, 0x78e, 0x792, 0x797, 0x7a0, 0x7a5, 0x7a9, 0x7af, 0x7b5, 0x7ba, 0x7c0, 0x7c6, 0x7d0, 0x7d6, 0x7df, 0x7e2, 0x7e5, 0x7e9, 0x7ed, 0x7f1, 0x7f7, 0x7fd, 0x802, 0x805, 0x815, 0x81c, 0x820, 0x827, 0x82b, 0x831, 0x838, 0x83f, 0x845, 0x84e, 0x852, 0x860, 0x863, 0x866, 0x86a, 0x86e, 0x871, 0x875, 0x878, 0x87d, 0x87f, 0x881}
// idnaSparseValues: 2180 entries, 8720 bytes
var idnaSparseValues = [2180]valueRange{
// Block 0x0, offset 0x0
{value: 0x0000, lo: 0x07},
{value: 0xe105, lo: 0x80, hi: 0x96},
{value: 0x0018, lo: 0x97, hi: 0x97},
{value: 0xe105, lo: 0x98, hi: 0x9e},
{value: 0x001f, lo: 0x9f, hi: 0x9f},
{value: 0x0008, lo: 0xa0, hi: 0xb6},
{value: 0x0018, lo: 0xb7, hi: 0xb7},
{value: 0x0008, lo: 0xb8, hi: 0xbf},
// Block 0x1, offset 0x8
{value: 0x0000, lo: 0x10},
{value: 0x0008, lo: 0x80, hi: 0x80},
{value: 0xe01d, lo: 0x81, hi: 0x81},
{value: 0x0008, lo: 0x82, hi: 0x82},
{value: 0x0335, lo: 0x83, hi: 0x83},
{value: 0x034d, lo: 0x84, hi: 0x84},
{value: 0x0365, lo: 0x85, hi: 0x85},
{value: 0xe00d, lo: 0x86, hi: 0x86},
{value: 0x0008, lo: 0x87, hi: 0x87},
{value: 0xe00d, lo: 0x88, hi: 0x88},
{value: 0x0008, lo: 0x89, hi: 0x89},
{value: 0xe00d, lo: 0x8a, hi: 0x8a},
{value: 0x0008, lo: 0x8b, hi: 0x8b},
{value: 0xe00d, lo: 0x8c, hi: 0x8c},
{value: 0x0008, lo: 0x8d, hi: 0x8d},
{value: 0xe00d, lo: 0x8e, hi: 0x8e},
{value: 0x0008, lo: 0x8f, hi: 0xbf},
// Block 0x2, offset 0x19
{value: 0x0000, lo: 0x0b},
{value: 0x0008, lo: 0x80, hi: 0xaf},
{value: 0x00a9, lo: 0xb0, hi: 0xb0},
{value: 0x037d, lo: 0xb1, hi: 0xb1},
{value: 0x00b1, lo: 0xb2, hi: 0xb2},
{value: 0x00b9, lo: 0xb3, hi: 0xb3},
{value: 0x034d, lo: 0xb4, hi: 0xb4},
{value: 0x0395, lo: 0xb5, hi: 0xb5},
{value: 0xe1bd, lo: 0xb6, hi: 0xb6},
{value: 0x00c1, lo: 0xb7, hi: 0xb7},
{value: 0x00c9, lo: 0xb8, hi: 0xb8},
{value: 0x0008, lo: 0xb9, hi: 0xbf},
// Block 0x3, offset 0x25
{value: 0x0000, lo: 0x01},
{value: 0x3308, lo: 0x80, hi: 0xbf},
// Block 0x4, offset 0x27
{value: 0x0000, lo: 0x04},
{value: 0x03f5, lo: 0x80, hi: 0x8f},
{value: 0xe105, lo: 0x90, hi: 0x9f},
{value: 0x049d, lo: 0xa0, hi: 0xaf},
{value: 0x0008, lo: 0xb0, hi: 0xbf},
// Block 0x5, offset 0x2c
{value: 0x0000, lo: 0x06},
{value: 0xe185, lo: 0x80, hi: 0x8f},
{value: 0x0545, lo: 0x90, hi: 0x96},
{value: 0x0040, lo: 0x97, hi: 0x98},
{value: 0x0008, lo: 0x99, hi: 0x99},
{value: 0x0018, lo: 0x9a, hi: 0x9f},
{value: 0x0008, lo: 0xa0, hi: 0xbf},
// Block 0x6, offset 0x33
{value: 0x0000, lo: 0x0a},
{value: 0x0008, lo: 0x80, hi: 0x86},
{value: 0x0131, lo: 0x87, hi: 0x87},
{value: 0x0008, lo: 0x88, hi: 0x88},
{value: 0x0018, lo: 0x89, hi: 0x8a},
{value: 0x0040, lo: 0x8b, hi: 0x8c},
{value: 0x0018, lo: 0x8d, hi: 0x8f},
{value: 0x0040, lo: 0x90, hi: 0x90},
{value: 0x3308, lo: 0x91, hi: 0xbd},
{value: 0x0818, lo: 0xbe, hi: 0xbe},
{value: 0x3308, lo: 0xbf, hi: 0xbf},
// Block 0x7, offset 0x3e
{value: 0x0000, lo: 0x0b},
{value: 0x0818, lo: 0x80, hi: 0x80},
{value: 0x3308, lo: 0x81, hi: 0x82},
{value: 0x0818, lo: 0x83, hi: 0x83},
{value: 0x3308, lo: 0x84, hi: 0x85},
{value: 0x0818, lo: 0x86, hi: 0x86},
{value: 0x3308, lo: 0x87, hi: 0x87},
{value: 0x0040, lo: 0x88, hi: 0x8f},
{value: 0x0808, lo: 0x90, hi: 0xaa},
{value: 0x0040, lo: 0xab, hi: 0xae},
{value: 0x0808, lo: 0xaf, hi: 0xb4},
{value: 0x0040, lo: 0xb5, hi: 0xbf},
// Block 0x8, offset 0x4a
{value: 0x0000, lo: 0x03},
{value: 0x0a08, lo: 0x80, hi: 0x87},
{value: 0x0c08, lo: 0x88, hi: 0x99},
{value: 0x0a08, lo: 0x9a, hi: 0xbf},
// Block 0x9, offset 0x4e
{value: 0x0000, lo: 0x0e},
{value: 0x3308, lo: 0x80, hi: 0x8a},
{value: 0x0040, lo: 0x8b, hi: 0x8c},
{value: 0x0c08, lo: 0x8d, hi: 0x8d},
{value: 0x0a08, lo: 0x8e, hi: 0x98},
{value: 0x0c08, lo: 0x99, hi: 0x9b},
{value: 0x0a08, lo: 0x9c, hi: 0xaa},
{value: 0x0c08, lo: 0xab, hi: 0xac},
{value: 0x0a08, lo: 0xad, hi: 0xb0},
{value: 0x0c08, lo: 0xb1, hi: 0xb1},
{value: 0x0a08, lo: 0xb2, hi: 0xb2},
{value: 0x0c08, lo: 0xb3, hi: 0xb4},
{value: 0x0a08, lo: 0xb5, hi: 0xb7},
{value: 0x0c08, lo: 0xb8, hi: 0xb9},
{value: 0x0a08, lo: 0xba, hi: 0xbf},
// Block 0xa, offset 0x5d
{value: 0x0000, lo: 0x04},
{value: 0x0808, lo: 0x80, hi: 0xa5},
{value: 0x3308, lo: 0xa6, hi: 0xb0},
{value: 0x0808, lo: 0xb1, hi: 0xb1},
{value: 0x0040, lo: 0xb2, hi: 0xbf},
// Block 0xb, offset 0x62
{value: 0x0000, lo: 0x09},
{value: 0x0808, lo: 0x80, hi: 0x89},
{value: 0x0a08, lo: 0x8a, hi: 0xaa},
{value: 0x3308, lo: 0xab, hi: 0xb3},
{value: 0x0808, lo: 0xb4, hi: 0xb5},
{value: 0x0018, lo: 0xb6, hi: 0xb9},
{value: 0x0818, lo: 0xba, hi: 0xba},
{value: 0x0040, lo: 0xbb, hi: 0xbc},
{value: 0x3308, lo: 0xbd, hi: 0xbd},
{value: 0x0818, lo: 0xbe, hi: 0xbf},
// Block 0xc, offset 0x6c
{value: 0x0000, lo: 0x0b},
{value: 0x0808, lo: 0x80, hi: 0x95},
{value: 0x3308, lo: 0x96, hi: 0x99},
{value: 0x0808, lo: 0x9a, hi: 0x9a},
{value: 0x3308, lo: 0x9b, hi: 0xa3},
{value: 0x0808, lo: 0xa4, hi: 0xa4},
{value: 0x3308, lo: 0xa5, hi: 0xa7},
{value: 0x0808, lo: 0xa8, hi: 0xa8},
{value: 0x3308, lo: 0xa9, hi: 0xad},
{value: 0x0040, lo: 0xae, hi: 0xaf},
{value: 0x0818, lo: 0xb0, hi: 0xbe},
{value: 0x0040, lo: 0xbf, hi: 0xbf},
// Block 0xd, offset 0x78
{value: 0x0000, lo: 0x05},
{value: 0x0a08, lo: 0x80, hi: 0x88},
{value: 0x0808, lo: 0x89, hi: 0x89},
{value: 0x3308, lo: 0x8a, hi: 0xa1},
{value: 0x0840, lo: 0xa2, hi: 0xa2},
{value: 0x3308, lo: 0xa3, hi: 0xbf},
// Block 0xe, offset 0x7e
{value: 0x0000, lo: 0x08},
{value: 0x3308, lo: 0x80, hi: 0x82},
{value: 0x3008, lo: 0x83, hi: 0x83},
{value: 0x0008, lo: 0x84, hi: 0xb9},
{value: 0x3308, lo: 0xba, hi: 0xba},
{value: 0x3008, lo: 0xbb, hi: 0xbb},
{value: 0x3308, lo: 0xbc, hi: 0xbc},
{value: 0x0008, lo: 0xbd, hi: 0xbd},
{value: 0x3008, lo: 0xbe, hi: 0xbf},
// Block 0xf, offset 0x87
{value: 0x0000, lo: 0x0f},
{value: 0x3308, lo: 0x80, hi: 0x80},
{value: 0x3008, lo: 0x81, hi: 0x82},
{value: 0x0040, lo: 0x83, hi: 0x85},
{value: 0x3008, lo: 0x86, hi: 0x88},
{value: 0x0040, lo: 0x89, hi: 0x89},
{value: 0x3008, lo: 0x8a, hi: 0x8c},
{value: 0x3b08, lo: 0x8d, hi: 0x8d},
{value: 0x0040, lo: 0x8e, hi: 0x8f},
{value: 0x0008, lo: 0x90, hi: 0x90},
{value: 0x0040, lo: 0x91, hi: 0x96},
{value: 0x3008, lo: 0x97, hi: 0x97},
{value: 0x0040, lo: 0x98, hi: 0xa5},
{value: 0x0008, lo: 0xa6, hi: 0xaf},
{value: 0x0018, lo: 0xb0, hi: 0xba},
{value: 0x0040, lo: 0xbb, hi: 0xbf},
// Block 0x10, offset 0x97
{value: 0x0000, lo: 0x0e},
{value: 0x3308, lo: 0x80, hi: 0x80},
{value: 0x3008, lo: 0x81, hi: 0x83},
{value: 0x3308, lo: 0x84, hi: 0x84},
{value: 0x0008, lo: 0x85, hi: 0x8c},
{value: 0x0040, lo: 0x8d, hi: 0x8d},
{value: 0x0008, lo: 0x8e, hi: 0x90},
{value: 0x0040, lo: 0x91, hi: 0x91},
{value: 0x0008, lo: 0x92, hi: 0xa8},
{value: 0x0040, lo: 0xa9, hi: 0xa9},
{value: 0x0008, lo: 0xaa, hi: 0xb9},
{value: 0x0040, lo: 0xba, hi: 0xbb},
{value: 0x3308, lo: 0xbc, hi: 0xbc},
{value: 0x0008, lo: 0xbd, hi: 0xbd},
{value: 0x3308, lo: 0xbe, hi: 0xbf},
// Block 0x11, offset 0xa6
{value: 0x0000, lo: 0x0a},
{value: 0x3308, lo: 0x80, hi: 0x81},
{value: 0x3008, lo: 0x82, hi: 0x83},
{value: 0x0008, lo: 0x84, hi: 0x8c},
{value: 0x0040, lo: 0x8d, hi: 0x8d},
{value: 0x0008, lo: 0x8e, hi: 0x90},
{value: 0x0040, lo: 0x91, hi: 0x91},
{value: 0x0008, lo: 0x92, hi: 0xba},
{value: 0x3b08, lo: 0xbb, hi: 0xbc},
{value: 0x0008, lo: 0xbd, hi: 0xbd},
{value: 0x3008, lo: 0xbe, hi: 0xbf},
// Block 0x12, offset 0xb1
{value: 0x0000, lo: 0x0c},
{value: 0x0040, lo: 0x80, hi: 0x80},
{value: 0x3308, lo: 0x81, hi: 0x81},
{value: 0x3008, lo: 0x82, hi: 0x83},
{value: 0x0040, lo: 0x84, hi: 0x84},
{value: 0x0008, lo: 0x85, hi: 0x96},
{value: 0x0040, lo: 0x97, hi: 0x99},
{value: 0x0008, lo: 0x9a, hi: 0xb1},
{value: 0x0040, lo: 0xb2, hi: 0xb2},
{value: 0x0008, lo: 0xb3, hi: 0xbb},
{value: 0x0040, lo: 0xbc, hi: 0xbc},
{value: 0x0008, lo: 0xbd, hi: 0xbd},
{value: 0x0040, lo: 0xbe, hi: 0xbf},
// Block 0x13, offset 0xbe
{value: 0x0000, lo: 0x10},
{value: 0x0008, lo: 0x80, hi: 0x86},
{value: 0x0040, lo: 0x87, hi: 0x89},
{value: 0x3b08, lo: 0x8a, hi: 0x8a},
{value: 0x0040, lo: 0x8b, hi: 0x8e},
{value: 0x3008, lo: 0x8f, hi: 0x91},
{value: 0x3308, lo: 0x92, hi: 0x94},
{value: 0x0040, lo: 0x95, hi: 0x95},
{value: 0x3308, lo: 0x96, hi: 0x96},
{value: 0x0040, lo: 0x97, hi: 0x97},
{value: 0x3008, lo: 0x98, hi: 0x9f},
{value: 0x0040, lo: 0xa0, hi: 0xa5},
{value: 0x0008, lo: 0xa6, hi: 0xaf},
{value: 0x0040, lo: 0xb0, hi: 0xb1},
{value: 0x3008, lo: 0xb2, hi: 0xb3},
{value: 0x0018, lo: 0xb4, hi: 0xb4},
{value: 0x0040, lo: 0xb5, hi: 0xbf},
// Block 0x14, offset 0xcf
{value: 0x0000, lo: 0x09},
{value: 0x0040, lo: 0x80, hi: 0x80},
{value: 0x0008, lo: 0x81, hi: 0xb0},
{value: 0x3308, lo: 0xb1, hi: 0xb1},
{value: 0x0008, lo: 0xb2, hi: 0xb2},
{value: 0x01f1, lo: 0xb3, hi: 0xb3},
{value: 0x3308, lo: 0xb4, hi: 0xb9},
{value: 0x3b08, lo: 0xba, hi: 0xba},
{value: 0x0040, lo: 0xbb, hi: 0xbe},
{value: 0x0018, lo: 0xbf, hi: 0xbf},
// Block 0x15, offset 0xd9
{value: 0x0000, lo: 0x06},
{value: 0x0008, lo: 0x80, hi: 0x86},
{value: 0x3308, lo: 0x87, hi: 0x8e},
{value: 0x0018, lo: 0x8f, hi: 0x8f},
{value: 0x0008, lo: 0x90, hi: 0x99},
{value: 0x0018, lo: 0x9a, hi: 0x9b},
{value: 0x0040, lo: 0x9c, hi: 0xbf},
// Block 0x16, offset 0xe0
{value: 0x0000, lo: 0x0c},
{value: 0x0008, lo: 0x80, hi: 0x84},
{value: 0x0040, lo: 0x85, hi: 0x85},
{value: 0x0008, lo: 0x86, hi: 0x86},
{value: 0x0040, lo: 0x87, hi: 0x87},
{value: 0x3308, lo: 0x88, hi: 0x8e},
{value: 0x0040, lo: 0x8f, hi: 0x8f},
{value: 0x0008, lo: 0x90, hi: 0x99},
{value: 0x0040, lo: 0x9a, hi: 0x9b},
{value: 0x0201, lo: 0x9c, hi: 0x9c},
{value: 0x0209, lo: 0x9d, hi: 0x9d},
{value: 0x0008, lo: 0x9e, hi: 0x9f},
{value: 0x0040, lo: 0xa0, hi: 0xbf},
// Block 0x17, offset 0xed
{value: 0x0000, lo: 0x10},
{value: 0x0008, lo: 0x80, hi: 0x80},
{value: 0x0018, lo: 0x81, hi: 0x8a},
{value: 0x0008, lo: 0x8b, hi: 0x8b},
{value: 0xe03d, lo: 0x8c, hi: 0x8c},
{value: 0x0018, lo: 0x8d, hi: 0x97},
{value: 0x3308, lo: 0x98, hi: 0x99},
{value: 0x0018, lo: 0x9a, hi: 0x9f},
{value: 0x0008, lo: 0xa0, hi: 0xa9},
{value: 0x0018, lo: 0xaa, hi: 0xb4},
{value: 0x3308, lo: 0xb5, hi: 0xb5},
{value: 0x0018, lo: 0xb6, hi: 0xb6},
{value: 0x3308, lo: 0xb7, hi: 0xb7},
{value: 0x0018, lo: 0xb8, hi: 0xb8},
{value: 0x3308, lo: 0xb9, hi: 0xb9},
{value: 0x0018, lo: 0xba, hi: 0xbd},
{value: 0x3008, lo: 0xbe, hi: 0xbf},
// Block 0x18, offset 0xfe
{value: 0x0000, lo: 0x06},
{value: 0x0018, lo: 0x80, hi: 0x85},
{value: 0x3308, lo: 0x86, hi: 0x86},
{value: 0x0018, lo: 0x87, hi: 0x8c},
{value: 0x0040, lo: 0x8d, hi: 0x8d},
{value: 0x0018, lo: 0x8e, hi: 0x9a},
{value: 0x0040, lo: 0x9b, hi: 0xbf},
// Block 0x19, offset 0x105
{value: 0x0000, lo: 0x0a},
{value: 0x0008, lo: 0x80, hi: 0xaa},
{value: 0x3008, lo: 0xab, hi: 0xac},
{value: 0x3308, lo: 0xad, hi: 0xb0},
{value: 0x3008, lo: 0xb1, hi: 0xb1},
{value: 0x3308, lo: 0xb2, hi: 0xb7},
{value: 0x3008, lo: 0xb8, hi: 0xb8},
{value: 0x3b08, lo: 0xb9, hi: 0xba},
{value: 0x3008, lo: 0xbb, hi: 0xbc},
{value: 0x3308, lo: 0xbd, hi: 0xbe},
{value: 0x0008, lo: 0xbf, hi: 0xbf},
// Block 0x1a, offset 0x110
{value: 0x0000, lo: 0x0e},
{value: 0x0008, lo: 0x80, hi: 0x89},
{value: 0x0018, lo: 0x8a, hi: 0x8f},
{value: 0x0008, lo: 0x90, hi: 0x95},
{value: 0x3008, lo: 0x96, hi: 0x97},
{value: 0x3308, lo: 0x98, hi: 0x99},
{value: 0x0008, lo: 0x9a, hi: 0x9d},
{value: 0x3308, lo: 0x9e, hi: 0xa0},
{value: 0x0008, lo: 0xa1, hi: 0xa1},
{value: 0x3008, lo: 0xa2, hi: 0xa4},
{value: 0x0008, lo: 0xa5, hi: 0xa6},
{value: 0x3008, lo: 0xa7, hi: 0xad},
{value: 0x0008, lo: 0xae, hi: 0xb0},
{value: 0x3308, lo: 0xb1, hi: 0xb4},
{value: 0x0008, lo: 0xb5, hi: 0xbf},
// Block 0x1b, offset 0x11f
{value: 0x0000, lo: 0x0d},
{value: 0x0008, lo: 0x80, hi: 0x81},
{value: 0x3308, lo: 0x82, hi: 0x82},
{value: 0x3008, lo: 0x83, hi: 0x84},
{value: 0x3308, lo: 0x85, hi: 0x86},
{value: 0x3008, lo: 0x87, hi: 0x8c},
{value: 0x3308, lo: 0x8d, hi: 0x8d},
{value: 0x0008, lo: 0x8e, hi: 0x8e},
{value: 0x3008, lo: 0x8f, hi: 0x8f},
{value: 0x0008, lo: 0x90, hi: 0x99},
{value: 0x3008, lo: 0x9a, hi: 0x9c},
{value: 0x3308, lo: 0x9d, hi: 0x9d},
{value: 0x0018, lo: 0x9e, hi: 0x9f},
{value: 0x0040, lo: 0xa0, hi: 0xbf},
// Block 0x1c, offset 0x12d
{value: 0x0000, lo: 0x09},
{value: 0x0040, lo: 0x80, hi: 0x86},
{value: 0x055d, lo: 0x87, hi: 0x87},
{value: 0x0040, lo: 0x88, hi: 0x8c},
{value: 0x055d, lo: 0x8d, hi: 0x8d},
{value: 0x0040, lo: 0x8e, hi: 0x8f},
{value: 0x0008, lo: 0x90, hi: 0xba},
{value: 0x0018, lo: 0xbb, hi: 0xbb},
{value: 0xe105, lo: 0xbc, hi: 0xbc},
{value: 0x0008, lo: 0xbd, hi: 0xbf},
// Block 0x1d, offset 0x137
{value: 0x0000, lo: 0x01},
{value: 0x0018, lo: 0x80, hi: 0xbf},
// Block 0x1e, offset 0x139
{value: 0x0000, lo: 0x04},
{value: 0x0018, lo: 0x80, hi: 0x9e},
{value: 0x0040, lo: 0x9f, hi: 0xa0},
{value: 0x2018, lo: 0xa1, hi: 0xb5},
{value: 0x0018, lo: 0xb6, hi: 0xbf},
// Block 0x1f, offset 0x13e
{value: 0x0000, lo: 0x02},
{value: 0x0018, lo: 0x80, hi: 0xa7},
{value: 0x2018, lo: 0xa8, hi: 0xbf},
// Block 0x20, offset 0x141
{value: 0x0000, lo: 0x02},
{value: 0x2018, lo: 0x80, hi: 0x82},
{value: 0x0018, lo: 0x83, hi: 0xbf},
// Block 0x21, offset 0x144
{value: 0x0000, lo: 0x01},
{value: 0x0008, lo: 0x80, hi: 0xbf},
// Block 0x22, offset 0x146
{value: 0x0000, lo: 0x0b},
{value: 0x0008, lo: 0x80, hi: 0x88},
{value: 0x0040, lo: 0x89, hi: 0x89},
{value: 0x0008, lo: 0x8a, hi: 0x8d},
{value: 0x0040, lo: 0x8e, hi: 0x8f},
{value: 0x0008, lo: 0x90, hi: 0x96},
{value: 0x0040, lo: 0x97, hi: 0x97},
{value: 0x0008, lo: 0x98, hi: 0x98},
{value: 0x0040, lo: 0x99, hi: 0x99},
{value: 0x0008, lo: 0x9a, hi: 0x9d},
{value: 0x0040, lo: 0x9e, hi: 0x9f},
{value: 0x0008, lo: 0xa0, hi: 0xbf},
// Block 0x23, offset 0x152
{value: 0x0000, lo: 0x0a},
{value: 0x0008, lo: 0x80, hi: 0x88},
{value: 0x0040, lo: 0x89, hi: 0x89},
{value: 0x0008, lo: 0x8a, hi: 0x8d},
{value: 0x0040, lo: 0x8e, hi: 0x8f},
{value: 0x0008, lo: 0x90, hi: 0xb0},
{value: 0x0040, lo: 0xb1, hi: 0xb1},
{value: 0x0008, lo: 0xb2, hi: 0xb5},
{value: 0x0040, lo: 0xb6, hi: 0xb7},
{value: 0x0008, lo: 0xb8, hi: 0xbe},
{value: 0x0040, lo: 0xbf, hi: 0xbf},
// Block 0x24, offset 0x15d
{value: 0x0000, lo: 0x07},
{value: 0x0008, lo: 0x80, hi: 0x80},
{value: 0x0040, lo: 0x81, hi: 0x81},
{value: 0x0008, lo: 0x82, hi: 0x85},
{value: 0x0040, lo: 0x86, hi: 0x87},
{value: 0x0008, lo: 0x88, hi: 0x96},
{value: 0x0040, lo: 0x97, hi: 0x97},
{value: 0x0008, lo: 0x98, hi: 0xbf},
// Block 0x25, offset 0x165
{value: 0x0000, lo: 0x05},
{value: 0x0008, lo: 0x80, hi: 0x90},
{value: 0x0040, lo: 0x91, hi: 0x91},
{value: 0x0008, lo: 0x92, hi: 0x95},
{value: 0x0040, lo: 0x96, hi: 0x97},
{value: 0x0008, lo: 0x98, hi: 0xbf},
// Block 0x26, offset 0x16b
{value: 0x0000, lo: 0x05},
{value: 0x0008, lo: 0x80, hi: 0x9a},
{value: 0x0040, lo: 0x9b, hi: 0x9c},
{value: 0x3308, lo: 0x9d, hi: 0x9f},
{value: 0x0018, lo: 0xa0, hi: 0xbc},
{value: 0x0040, lo: 0xbd, hi: 0xbf},
// Block 0x27, offset 0x171
{value: 0x0000, lo: 0x04},
{value: 0x0008, lo: 0x80, hi: 0x8f},
{value: 0x0018, lo: 0x90, hi: 0x99},
{value: 0x0040, lo: 0x9a, hi: 0x9f},
{value: 0x0008, lo: 0xa0, hi: 0xbf},
// Block 0x28, offset 0x176
{value: 0x0000, lo: 0x04},
{value: 0x0008, lo: 0x80, hi: 0xb5},
{value: 0x0040, lo: 0xb6, hi: 0xb7},
{value: 0xe045, lo: 0xb8, hi: 0xbd},
{value: 0x0040, lo: 0xbe, hi: 0xbf},
// Block 0x29, offset 0x17b
{value: 0x0000, lo: 0x02},
{value: 0x0018, lo: 0x80, hi: 0x80},
{value: 0x0008, lo: 0x81, hi: 0xbf},
// Block 0x2a, offset 0x17e
{value: 0x0000, lo: 0x03},
{value: 0x0008, lo: 0x80, hi: 0xac},
{value: 0x0018, lo: 0xad, hi: 0xae},
{value: 0x0008, lo: 0xaf, hi: 0xbf},
// Block 0x2b, offset 0x182
{value: 0x0000, lo: 0x05},
{value: 0x0040, lo: 0x80, hi: 0x80},
{value: 0x0008, lo: 0x81, hi: 0x9a},
{value: 0x0018, lo: 0x9b, hi: 0x9c},
{value: 0x0040, lo: 0x9d, hi: 0x9f},
{value: 0x0008, lo: 0xa0, hi: 0xbf},
// Block 0x2c, offset 0x188
{value: 0x0000, lo: 0x04},
{value: 0x0008, lo: 0x80, hi: 0xaa},
{value: 0x0018, lo: 0xab, hi: 0xb0},
{value: 0x0008, lo: 0xb1, hi: 0xb8},
{value: 0x0040, lo: 0xb9, hi: 0xbf},
// Block 0x2d, offset 0x18d
{value: 0x0000, lo: 0x0a},
{value: 0x0008, lo: 0x80, hi: 0x91},
{value: 0x3308, lo: 0x92, hi: 0x93},
{value: 0x3b08, lo: 0x94, hi: 0x94},
{value: 0x3808, lo: 0x95, hi: 0x95},
{value: 0x0040, lo: 0x96, hi: 0x9e},
{value: 0x0008, lo: 0x9f, hi: 0xb1},
{value: 0x3308, lo: 0xb2, hi: 0xb3},
{value: 0x3808, lo: 0xb4, hi: 0xb4},
{value: 0x0018, lo: 0xb5, hi: 0xb6},
{value: 0x0040, lo: 0xb7, hi: 0xbf},
// Block 0x2e, offset 0x198
{value: 0x0000, lo: 0x09},
{value: 0x0008, lo: 0x80, hi: 0x91},
{value: 0x3308, lo: 0x92, hi: 0x93},
{value: 0x0040, lo: 0x94, hi: 0x9f},
{value: 0x0008, lo: 0xa0, hi: 0xac},
{value: 0x0040, lo: 0xad, hi: 0xad},
{value: 0x0008, lo: 0xae, hi: 0xb0},
{value: 0x0040, lo: 0xb1, hi: 0xb1},
{value: 0x3308, lo: 0xb2, hi: 0xb3},
{value: 0x0040, lo: 0xb4, hi: 0xbf},
// Block 0x2f, offset 0x1a2
{value: 0x0000, lo: 0x05},
{value: 0x0008, lo: 0x80, hi: 0xb3},
{value: 0x3340, lo: 0xb4, hi: 0xb5},
{value: 0x3008, lo: 0xb6, hi: 0xb6},
{value: 0x3308, lo: 0xb7, hi: 0xbd},
{value: 0x3008, lo: 0xbe, hi: 0xbf},
// Block 0x30, offset 0x1a8
{value: 0x0000, lo: 0x10},
{value: 0x3008, lo: 0x80, hi: 0x85},
{value: 0x3308, lo: 0x86, hi: 0x86},
{value: 0x3008, lo: 0x87, hi: 0x88},
{value: 0x3308, lo: 0x89, hi: 0x91},
{value: 0x3b08, lo: 0x92, hi: 0x92},
{value: 0x3308, lo: 0x93, hi: 0x93},
{value: 0x0018, lo: 0x94, hi: 0x96},
{value: 0x0008, lo: 0x97, hi: 0x97},
{value: 0x0018, lo: 0x98, hi: 0x9b},
{value: 0x0008, lo: 0x9c, hi: 0x9c},
{value: 0x3308, lo: 0x9d, hi: 0x9d},
{value: 0x0040, lo: 0x9e, hi: 0x9f},
{value: 0x0008, lo: 0xa0, hi: 0xa9},
{value: 0x0040, lo: 0xaa, hi: 0xaf},
{value: 0x0018, lo: 0xb0, hi: 0xb9},
{value: 0x0040, lo: 0xba, hi: 0xbf},
// Block 0x31, offset 0x1b9
{value: 0x0000, lo: 0x0a},
{value: 0x0018, lo: 0x80, hi: 0x85},
{value: 0x0040, lo: 0x86, hi: 0x86},
{value: 0x0218, lo: 0x87, hi: 0x87},
{value: 0x0018, lo: 0x88, hi: 0x8a},
{value: 0x33c0, lo: 0x8b, hi: 0x8d},
{value: 0x0040, lo: 0x8e, hi: 0x8e},
{value: 0x33c0, lo: 0x8f, hi: 0x8f},
{value: 0x0008, lo: 0x90, hi: 0x99},
{value: 0x0040, lo: 0x9a, hi: 0x9f},
{value: 0x0208, lo: 0xa0, hi: 0xbf},
// Block 0x32, offset 0x1c4
{value: 0x0000, lo: 0x02},
{value: 0x0208, lo: 0x80, hi: 0xb8},
{value: 0x0040, lo: 0xb9, hi: 0xbf},
// Block 0x33, offset 0x1c7
{value: 0x0000, lo: 0x07},
{value: 0x0008, lo: 0x80, hi: 0x84},
{value: 0x3308, lo: 0x85, hi: 0x86},
{value: 0x0208, lo: 0x87, hi: 0xa8},
{value: 0x3308, lo: 0xa9, hi: 0xa9},
{value: 0x0208, lo: 0xaa, hi: 0xaa},
{value: 0x0040, lo: 0xab, hi: 0xaf},
{value: 0x0008, lo: 0xb0, hi: 0xbf},
// Block 0x34, offset 0x1cf
{value: 0x0000, lo: 0x02},
{value: 0x0008, lo: 0x80, hi: 0xb5},
{value: 0x0040, lo: 0xb6, hi: 0xbf},
// Block 0x35, offset 0x1d2
{value: 0x0000, lo: 0x0c},
{value: 0x0008, lo: 0x80, hi: 0x9e},
{value: 0x0040, lo: 0x9f, hi: 0x9f},
{value: 0x3308, lo: 0xa0, hi: 0xa2},
{value: 0x3008, lo: 0xa3, hi: 0xa6},
{value: 0x3308, lo: 0xa7, hi: 0xa8},
{value: 0x3008, lo: 0xa9, hi: 0xab},
{value: 0x0040, lo: 0xac, hi: 0xaf},
{value: 0x3008, lo: 0xb0, hi: 0xb1},
{value: 0x3308, lo: 0xb2, hi: 0xb2},
{value: 0x3008, lo: 0xb3, hi: 0xb8},
{value: 0x3308, lo: 0xb9, hi: 0xbb},
{value: 0x0040, lo: 0xbc, hi: 0xbf},
// Block 0x36, offset 0x1df
{value: 0x0000, lo: 0x07},
{value: 0x0018, lo: 0x80, hi: 0x80},
{value: 0x0040, lo: 0x81, hi: 0x83},
{value: 0x0018, lo: 0x84, hi: 0x85},
{value: 0x0008, lo: 0x86, hi: 0xad},
{value: 0x0040, lo: 0xae, hi: 0xaf},
{value: 0x0008, lo: 0xb0, hi: 0xb4},
{value: 0x0040, lo: 0xb5, hi: 0xbf},
// Block 0x37, offset 0x1e7
{value: 0x0000, lo: 0x03},
{value: 0x0008, lo: 0x80, hi: 0xab},
{value: 0x0040, lo: 0xac, hi: 0xaf},
{value: 0x0008, lo: 0xb0, hi: 0xbf},
// Block 0x38, offset 0x1eb
{value: 0x0000, lo: 0x06},
{value: 0x0008, lo: 0x80, hi: 0x89},
{value: 0x0040, lo: 0x8a, hi: 0x8f},
{value: 0x0008, lo: 0x90, hi: 0x99},
{value: 0x0028, lo: 0x9a, hi: 0x9a},
{value: 0x0040, lo: 0x9b, hi: 0x9d},
{value: 0x0018, lo: 0x9e, hi: 0xbf},
// Block 0x39, offset 0x1f2
{value: 0x0000, lo: 0x07},
{value: 0x0008, lo: 0x80, hi: 0x96},
{value: 0x3308, lo: 0x97, hi: 0x98},
{value: 0x3008, lo: 0x99, hi: 0x9a},
{value: 0x3308, lo: 0x9b, hi: 0x9b},
{value: 0x0040, lo: 0x9c, hi: 0x9d},
{value: 0x0018, lo: 0x9e, hi: 0x9f},
{value: 0x0008, lo: 0xa0, hi: 0xbf},
// Block 0x3a, offset 0x1fa
{value: 0x0000, lo: 0x0f},
{value: 0x0008, lo: 0x80, hi: 0x94},
{value: 0x3008, lo: 0x95, hi: 0x95},
{value: 0x3308, lo: 0x96, hi: 0x96},
{value: 0x3008, lo: 0x97, hi: 0x97},
{value: 0x3308, lo: 0x98, hi: 0x9e},
{value: 0x0040, lo: 0x9f, hi: 0x9f},
{value: 0x3b08, lo: 0xa0, hi: 0xa0},
{value: 0x3008, lo: 0xa1, hi: 0xa1},
{value: 0x3308, lo: 0xa2, hi: 0xa2},
{value: 0x3008, lo: 0xa3, hi: 0xa4},
{value: 0x3308, lo: 0xa5, hi: 0xac},
{value: 0x3008, lo: 0xad, hi: 0xb2},
{value: 0x3308, lo: 0xb3, hi: 0xbc},
{value: 0x0040, lo: 0xbd, hi: 0xbe},
{value: 0x3308, lo: 0xbf, hi: 0xbf},
// Block 0x3b, offset 0x20a
{value: 0x0000, lo: 0x0b},
{value: 0x0008, lo: 0x80, hi: 0x89},
{value: 0x0040, lo: 0x8a, hi: 0x8f},
{value: 0x0008, lo: 0x90, hi: 0x99},
{value: 0x0040, lo: 0x9a, hi: 0x9f},
{value: 0x0018, lo: 0xa0, hi: 0xa6},
{value: 0x0008, lo: 0xa7, hi: 0xa7},
{value: 0x0018, lo: 0xa8, hi: 0xad},
{value: 0x0040, lo: 0xae, hi: 0xaf},
{value: 0x3308, lo: 0xb0, hi: 0xbd},
{value: 0x3318, lo: 0xbe, hi: 0xbe},
{value: 0x3308, lo: 0xbf, hi: 0xbf},
// Block 0x3c, offset 0x216
{value: 0x0000, lo: 0x02},
{value: 0x3308, lo: 0x80, hi: 0x8e},
{value: 0x0040, lo: 0x8f, hi: 0xbf},
// Block 0x3d, offset 0x219
{value: 0x0000, lo: 0x09},
{value: 0x3308, lo: 0x80, hi: 0x83},
{value: 0x3008, lo: 0x84, hi: 0x84},
{value: 0x0008, lo: 0x85, hi: 0xb3},
{value: 0x3308, lo: 0xb4, hi: 0xb4},
{value: 0x3008, lo: 0xb5, hi: 0xb5},
{value: 0x3308, lo: 0xb6, hi: 0xba},
{value: 0x3008, lo: 0xbb, hi: 0xbb},
{value: 0x3308, lo: 0xbc, hi: 0xbc},
{value: 0x3008, lo: 0xbd, hi: 0xbf},
// Block 0x3e, offset 0x223
{value: 0x0000, lo: 0x0b},
{value: 0x3008, lo: 0x80, hi: 0x81},
{value: 0x3308, lo: 0x82, hi: 0x82},
{value: 0x3008, lo: 0x83, hi: 0x83},
{value: 0x3808, lo: 0x84, hi: 0x84},
{value: 0x0008, lo: 0x85, hi: 0x8c},
{value: 0x0040, lo: 0x8d, hi: 0x8f},
{value: 0x0008, lo: 0x90, hi: 0x99},
{value: 0x0018, lo: 0x9a, hi: 0xaa},
{value: 0x3308, lo: 0xab, hi: 0xb3},
{value: 0x0018, lo: 0xb4, hi: 0xbe},
{value: 0x0040, lo: 0xbf, hi: 0xbf},
// Block 0x3f, offset 0x22f
{value: 0x0000, lo: 0x0b},
{value: 0x3308, lo: 0x80, hi: 0x81},
{value: 0x3008, lo: 0x82, hi: 0x82},
{value: 0x0008, lo: 0x83, hi: 0xa0},
{value: 0x3008, lo: 0xa1, hi: 0xa1},
{value: 0x3308, lo: 0xa2, hi: 0xa5},
{value: 0x3008, lo: 0xa6, hi: 0xa7},
{value: 0x3308, lo: 0xa8, hi: 0xa9},
{value: 0x3808, lo: 0xaa, hi: 0xaa},
{value: 0x3b08, lo: 0xab, hi: 0xab},
{value: 0x3308, lo: 0xac, hi: 0xad},
{value: 0x0008, lo: 0xae, hi: 0xbf},
// Block 0x40, offset 0x23b
{value: 0x0000, lo: 0x0b},
{value: 0x0008, lo: 0x80, hi: 0xa5},
{value: 0x3308, lo: 0xa6, hi: 0xa6},
{value: 0x3008, lo: 0xa7, hi: 0xa7},
{value: 0x3308, lo: 0xa8, hi: 0xa9},
{value: 0x3008, lo: 0xaa, hi: 0xac},
{value: 0x3308, lo: 0xad, hi: 0xad},
{value: 0x3008, lo: 0xae, hi: 0xae},
{value: 0x3308, lo: 0xaf, hi: 0xb1},
{value: 0x3808, lo: 0xb2, hi: 0xb3},
{value: 0x0040, lo: 0xb4, hi: 0xbb},
{value: 0x0018, lo: 0xbc, hi: 0xbf},
// Block 0x41, offset 0x247
{value: 0x0000, lo: 0x07},
{value: 0x0008, lo: 0x80, hi: 0xa3},
{value: 0x3008, lo: 0xa4, hi: 0xab},
{value: 0x3308, lo: 0xac, hi: 0xb3},
{value: 0x3008, lo: 0xb4, hi: 0xb5},
{value: 0x3308, lo: 0xb6, hi: 0xb7},
{value: 0x0040, lo: 0xb8, hi: 0xba},
{value: 0x0018, lo: 0xbb, hi: 0xbf},
// Block 0x42, offset 0x24f
{value: 0x0000, lo: 0x04},
{value: 0x0008, lo: 0x80, hi: 0x89},
{value: 0x0040, lo: 0x8a, hi: 0x8c},
{value: 0x0008, lo: 0x8d, hi: 0xbd},
{value: 0x0018, lo: 0xbe, hi: 0xbf},
// Block 0x43, offset 0x254
{value: 0x0000, lo: 0x0c},
{value: 0x02a9, lo: 0x80, hi: 0x80},
{value: 0x02b1, lo: 0x81, hi: 0x81},
{value: 0x02b9, lo: 0x82, hi: 0x82},
{value: 0x02c1, lo: 0x83, hi: 0x83},
{value: 0x02c9, lo: 0x84, hi: 0x85},
{value: 0x02d1, lo: 0x86, hi: 0x86},
{value: 0x02d9, lo: 0x87, hi: 0x87},
{value: 0x057d, lo: 0x88, hi: 0x88},
{value: 0x0040, lo: 0x89, hi: 0x8f},
{value: 0x059d, lo: 0x90, hi: 0xba},
{value: 0x0040, lo: 0xbb, hi: 0xbc},
{value: 0x059d, lo: 0xbd, hi: 0xbf},
// Block 0x44, offset 0x261
{value: 0x0000, lo: 0x10},
{value: 0x0018, lo: 0x80, hi: 0x87},
{value: 0x0040, lo: 0x88, hi: 0x8f},
{value: 0x3308, lo: 0x90, hi: 0x92},
{value: 0x0018, lo: 0x93, hi: 0x93},
{value: 0x3308, lo: 0x94, hi: 0xa0},
{value: 0x3008, lo: 0xa1, hi: 0xa1},
{value: 0x3308, lo: 0xa2, hi: 0xa8},
{value: 0x0008, lo: 0xa9, hi: 0xac},
{value: 0x3308, lo: 0xad, hi: 0xad},
{value: 0x0008, lo: 0xae, hi: 0xb3},
{value: 0x3308, lo: 0xb4, hi: 0xb4},
{value: 0x0008, lo: 0xb5, hi: 0xb6},
{value: 0x3008, lo: 0xb7, hi: 0xb7},
{value: 0x3308, lo: 0xb8, hi: 0xb9},
{value: 0x0008, lo: 0xba, hi: 0xba},
{value: 0x0040, lo: 0xbb, hi: 0xbf},
// Block 0x45, offset 0x272
{value: 0x0000, lo: 0x0a},
{value: 0x0008, lo: 0x80, hi: 0x87},
{value: 0xe045, lo: 0x88, hi: 0x8f},
{value: 0x0008, lo: 0x90, hi: 0x95},
{value: 0x0040, lo: 0x96, hi: 0x97},
{value: 0xe045, lo: 0x98, hi: 0x9d},
{value: 0x0040, lo: 0x9e, hi: 0x9f},
{value: 0x0008, lo: 0xa0, hi: 0xa7},
{value: 0xe045, lo: 0xa8, hi: 0xaf},
{value: 0x0008, lo: 0xb0, hi: 0xb7},
{value: 0xe045, lo: 0xb8, hi: 0xbf},
// Block 0x46, offset 0x27d
{value: 0x0000, lo: 0x04},
{value: 0x0018, lo: 0x80, hi: 0x80},
{value: 0x0040, lo: 0x81, hi: 0x8f},
{value: 0x3318, lo: 0x90, hi: 0xb0},
{value: 0x0040, lo: 0xb1, hi: 0xbf},
// Block 0x47, offset 0x282
{value: 0x0000, lo: 0x08},
{value: 0x0018, lo: 0x80, hi: 0x82},
{value: 0x0040, lo: 0x83, hi: 0x83},
{value: 0x0008, lo: 0x84, hi: 0x84},
{value: 0x0018, lo: 0x85, hi: 0x88},
{value: 0x0851, lo: 0x89, hi: 0x89},
{value: 0x0018, lo: 0x8a, hi: 0x8b},
{value: 0x0040, lo: 0x8c, hi: 0x8f},
{value: 0x0018, lo: 0x90, hi: 0xbf},
// Block 0x48, offset 0x28b
{value: 0x0000, lo: 0x07},
{value: 0x0018, lo: 0x80, hi: 0xab},
{value: 0x0859, lo: 0xac, hi: 0xac},
{value: 0x0861, lo: 0xad, hi: 0xad},
{value: 0x0018, lo: 0xae, hi: 0xae},
{value: 0x0869, lo: 0xaf, hi: 0xaf},
{value: 0x0871, lo: 0xb0, hi: 0xb0},
{value: 0x0018, lo: 0xb1, hi: 0xbf},
// Block 0x49, offset 0x293
{value: 0x0000, lo: 0x05},
{value: 0x0018, lo: 0x80, hi: 0x9f},
{value: 0x0080, lo: 0xa0, hi: 0xa0},
{value: 0x0018, lo: 0xa1, hi: 0xad},
{value: 0x0080, lo: 0xae, hi: 0xaf},
{value: 0x0018, lo: 0xb0, hi: 0xbf},
// Block 0x4a, offset 0x299
{value: 0x0000, lo: 0x04},
{value: 0x0018, lo: 0x80, hi: 0xa8},
{value: 0x09dd, lo: 0xa9, hi: 0xa9},
{value: 0x09fd, lo: 0xaa, hi: 0xaa},
{value: 0x0018, lo: 0xab, hi: 0xbf},
// Block 0x4b, offset 0x29e
{value: 0x0000, lo: 0x02},
{value: 0x0018, lo: 0x80, hi: 0xa6},
{value: 0x0040, lo: 0xa7, hi: 0xbf},
// Block 0x4c, offset 0x2a1
{value: 0x0000, lo: 0x03},
{value: 0x0018, lo: 0x80, hi: 0x8b},
{value: 0x0929, lo: 0x8c, hi: 0x8c},
{value: 0x0018, lo: 0x8d, hi: 0xbf},
// Block 0x4d, offset 0x2a5
{value: 0x0000, lo: 0x05},
{value: 0x0018, lo: 0x80, hi: 0xb3},
{value: 0x0e7e, lo: 0xb4, hi: 0xb4},
{value: 0x0932, lo: 0xb5, hi: 0xb5},
{value: 0x0e9e, lo: 0xb6, hi: 0xb6},
{value: 0x0018, lo: 0xb7, hi: 0xbf},
// Block 0x4e, offset 0x2ab
{value: 0x0000, lo: 0x03},
{value: 0x0018, lo: 0x80, hi: 0x9b},
{value: 0x0939, lo: 0x9c, hi: 0x9c},
{value: 0x0018, lo: 0x9d, hi: 0xbf},
// Block 0x4f, offset 0x2af
{value: 0x0000, lo: 0x03},
{value: 0x0018, lo: 0x80, hi: 0xb3},
{value: 0x0040, lo: 0xb4, hi: 0xb5},
{value: 0x0018, lo: 0xb6, hi: 0xbf},
// Block 0x50, offset 0x2b3
{value: 0x0000, lo: 0x03},
{value: 0x0018, lo: 0x80, hi: 0x95},
{value: 0x0040, lo: 0x96, hi: 0x96},
{value: 0x0018, lo: 0x97, hi: 0xbf},
// Block 0x51, offset 0x2b7
{value: 0x0000, lo: 0x04},
{value: 0xe185, lo: 0x80, hi: 0x8f},
{value: 0x03f5, lo: 0x90, hi: 0x9f},
{value: 0x0ebd, lo: 0xa0, hi: 0xaf},
{value: 0x0008, lo: 0xb0, hi: 0xbf},
// Block 0x52, offset 0x2bc
{value: 0x0000, lo: 0x07},
{value: 0x0008, lo: 0x80, hi: 0xa5},
{value: 0x0040, lo: 0xa6, hi: 0xa6},
{value: 0x0008, lo: 0xa7, hi: 0xa7},
{value: 0x0040, lo: 0xa8, hi: 0xac},
{value: 0x0008, lo: 0xad, hi: 0xad},
{value: 0x0040, lo: 0xae, hi: 0xaf},
{value: 0x0008, lo: 0xb0, hi: 0xbf},
// Block 0x53, offset 0x2c4
{value: 0x0000, lo: 0x06},
{value: 0x0008, lo: 0x80, hi: 0xa7},
{value: 0x0040, lo: 0xa8, hi: 0xae},
{value: 0xe075, lo: 0xaf, hi: 0xaf},
{value: 0x0018, lo: 0xb0, hi: 0xb0},
{value: 0x0040, lo: 0xb1, hi: 0xbe},
{value: 0x3b08, lo: 0xbf, hi: 0xbf},
// Block 0x54, offset 0x2cb
{value: 0x0000, lo: 0x0a},
{value: 0x0008, lo: 0x80, hi: 0x96},
{value: 0x0040, lo: 0x97, hi: 0x9f},
{value: 0x0008, lo: 0xa0, hi: 0xa6},
{value: 0x0040, lo: 0xa7, hi: 0xa7},
{value: 0x0008, lo: 0xa8, hi: 0xae},
{value: 0x0040, lo: 0xaf, hi: 0xaf},
{value: 0x0008, lo: 0xb0, hi: 0xb6},
{value: 0x0040, lo: 0xb7, hi: 0xb7},
{value: 0x0008, lo: 0xb8, hi: 0xbe},
{value: 0x0040, lo: 0xbf, hi: 0xbf},
// Block 0x55, offset 0x2d6
{value: 0x0000, lo: 0x09},
{value: 0x0008, lo: 0x80, hi: 0x86},
{value: 0x0040, lo: 0x87, hi: 0x87},
{value: 0x0008, lo: 0x88, hi: 0x8e},
{value: 0x0040, lo: 0x8f, hi: 0x8f},
{value: 0x0008, lo: 0x90, hi: 0x96},
{value: 0x0040, lo: 0x97, hi: 0x97},
{value: 0x0008, lo: 0x98, hi: 0x9e},
{value: 0x0040, lo: 0x9f, hi: 0x9f},
{value: 0x3308, lo: 0xa0, hi: 0xbf},
// Block 0x56, offset 0x2e0
{value: 0x0000, lo: 0x03},
{value: 0x0018, lo: 0x80, hi: 0xae},
{value: 0x0008, lo: 0xaf, hi: 0xaf},
{value: 0x0018, lo: 0xb0, hi: 0xbf},
// Block 0x57, offset 0x2e4
{value: 0x0000, lo: 0x02},
{value: 0x0018, lo: 0x80, hi: 0x9d},
{value: 0x0040, lo: 0x9e, hi: 0xbf},
// Block 0x58, offset 0x2e7
{value: 0x0000, lo: 0x05},
{value: 0x0018, lo: 0x80, hi: 0x99},
{value: 0x0040, lo: 0x9a, hi: 0x9a},
{value: 0x0018, lo: 0x9b, hi: 0x9e},
{value: 0x0ef5, lo: 0x9f, hi: 0x9f},
{value: 0x0018, lo: 0xa0, hi: 0xbf},
// Block 0x59, offset 0x2ed
{value: 0x0000, lo: 0x03},
{value: 0x0018, lo: 0x80, hi: 0xb2},
{value: 0x0f15, lo: 0xb3, hi: 0xb3},
{value: 0x0040, lo: 0xb4, hi: 0xbf},
// Block 0x5a, offset 0x2f1
{value: 0x0020, lo: 0x01},
{value: 0x0f35, lo: 0x80, hi: 0xbf},
// Block 0x5b, offset 0x2f3
{value: 0x0020, lo: 0x02},
{value: 0x1735, lo: 0x80, hi: 0x8f},
{value: 0x1915, lo: 0x90, hi: 0xbf},
// Block 0x5c, offset 0x2f6
{value: 0x0020, lo: 0x01},
{value: 0x1f15, lo: 0x80, hi: 0xbf},
// Block 0x5d, offset 0x2f8
{value: 0x0000, lo: 0x02},
{value: 0x0040, lo: 0x80, hi: 0x80},
{value: 0x0008, lo: 0x81, hi: 0xbf},
// Block 0x5e, offset 0x2fb
{value: 0x0000, lo: 0x09},
{value: 0x0008, lo: 0x80, hi: 0x96},
{value: 0x0040, lo: 0x97, hi: 0x98},
{value: 0x3308, lo: 0x99, hi: 0x9a},
{value: 0x096a, lo: 0x9b, hi: 0x9b},
{value: 0x0972, lo: 0x9c, hi: 0x9c},
{value: 0x0008, lo: 0x9d, hi: 0x9e},
{value: 0x0979, lo: 0x9f, hi: 0x9f},
{value: 0x0018, lo: 0xa0, hi: 0xa0},
{value: 0x0008, lo: 0xa1, hi: 0xbf},
// Block 0x5f, offset 0x305
{value: 0x0000, lo: 0x02},
{value: 0x0008, lo: 0x80, hi: 0xbe},
{value: 0x0981, lo: 0xbf, hi: 0xbf},
// Block 0x60, offset 0x308
{value: 0x0000, lo: 0x0e},
{value: 0x0040, lo: 0x80, hi: 0x84},
{value: 0x0008, lo: 0x85, hi: 0xaf},
{value: 0x0040, lo: 0xb0, hi: 0xb0},
{value: 0x2a35, lo: 0xb1, hi: 0xb1},
{value: 0x2a55, lo: 0xb2, hi: 0xb2},
{value: 0x2a75, lo: 0xb3, hi: 0xb3},
{value: 0x2a95, lo: 0xb4, hi: 0xb4},
{value: 0x2a75, lo: 0xb5, hi: 0xb5},
{value: 0x2ab5, lo: 0xb6, hi: 0xb6},
{value: 0x2ad5, lo: 0xb7, hi: 0xb7},
{value: 0x2af5, lo: 0xb8, hi: 0xb9},
{value: 0x2b15, lo: 0xba, hi: 0xbb},
{value: 0x2b35, lo: 0xbc, hi: 0xbd},
{value: 0x2b15, lo: 0xbe, hi: 0xbf},
// Block 0x61, offset 0x317
{value: 0x0000, lo: 0x03},
{value: 0x0018, lo: 0x80, hi: 0xa3},
{value: 0x0040, lo: 0xa4, hi: 0xaf},
{value: 0x0008, lo: 0xb0, hi: 0xbf},
// Block 0x62, offset 0x31b
{value: 0x0008, lo: 0x03},
{value: 0x098a, lo: 0x80, hi: 0x9e},
{value: 0x0040, lo: 0x9f, hi: 0x9f},
{value: 0x0a82, lo: 0xa0, hi: 0xbf},
// Block 0x63, offset 0x31f
{value: 0x0008, lo: 0x01},
{value: 0x0d19, lo: 0x80, hi: 0xbf},
// Block 0x64, offset 0x321
{value: 0x0008, lo: 0x08},
{value: 0x0f19, lo: 0x80, hi: 0xb0},
{value: 0x4045, lo: 0xb1, hi: 0xb1},
{value: 0x10a1, lo: 0xb2, hi: 0xb3},
{value: 0x4065, lo: 0xb4, hi: 0xb4},
{value: 0x10b1, lo: 0xb5, hi: 0xb7},
{value: 0x4085, lo: 0xb8, hi: 0xb8},
{value: 0x4085, lo: 0xb9, hi: 0xb9},
{value: 0x10c9, lo: 0xba, hi: 0xbf},
// Block 0x65, offset 0x32a
{value: 0x0000, lo: 0x03},
{value: 0x0008, lo: 0x80, hi: 0x8c},
{value: 0x0040, lo: 0x8d, hi: 0x8f},
{value: 0x0018, lo: 0x90, hi: 0xbf},
// Block 0x66, offset 0x32e
{value: 0x0000, lo: 0x04},
{value: 0x0018, lo: 0x80, hi: 0x86},
{value: 0x0040, lo: 0x87, hi: 0x8f},
{value: 0x0008, lo: 0x90, hi: 0xbd},
{value: 0x0018, lo: 0xbe, hi: 0xbf},
// Block 0x67, offset 0x333
{value: 0x0000, lo: 0x04},
{value: 0x0008, lo: 0x80, hi: 0x8c},
{value: 0x0018, lo: 0x8d, hi: 0x8f},
{value: 0x0008, lo: 0x90, hi: 0xab},
{value: 0x0040, lo: 0xac, hi: 0xbf},
// Block 0x68, offset 0x338
{value: 0x0000, lo: 0x05},
{value: 0x0008, lo: 0x80, hi: 0xa5},
{value: 0x0018, lo: 0xa6, hi: 0xaf},
{value: 0x3308, lo: 0xb0, hi: 0xb1},
{value: 0x0018, lo: 0xb2, hi: 0xb7},
{value: 0x0040, lo: 0xb8, hi: 0xbf},
// Block 0x69, offset 0x33e
{value: 0x0000, lo: 0x0f},
{value: 0x0008, lo: 0x80, hi: 0x81},
{value: 0x3308, lo: 0x82, hi: 0x82},
{value: 0x0008, lo: 0x83, hi: 0x85},
{value: 0x3b08, lo: 0x86, hi: 0x86},
{value: 0x0008, lo: 0x87, hi: 0x8a},
{value: 0x3308, lo: 0x8b, hi: 0x8b},
{value: 0x0008, lo: 0x8c, hi: 0xa2},
{value: 0x3008, lo: 0xa3, hi: 0xa4},
{value: 0x3308, lo: 0xa5, hi: 0xa6},
{value: 0x3008, lo: 0xa7, hi: 0xa7},
{value: 0x0018, lo: 0xa8, hi: 0xab},
{value: 0x3b08, lo: 0xac, hi: 0xac},
{value: 0x0040, lo: 0xad, hi: 0xaf},
{value: 0x0018, lo: 0xb0, hi: 0xb9},
{value: 0x0040, lo: 0xba, hi: 0xbf},
// Block 0x6a, offset 0x34e
{value: 0x0000, lo: 0x05},
{value: 0x0208, lo: 0x80, hi: 0xb1},
{value: 0x0108, lo: 0xb2, hi: 0xb2},
{value: 0x0008, lo: 0xb3, hi: 0xb3},
{value: 0x0018, lo: 0xb4, hi: 0xb7},
{value: 0x0040, lo: 0xb8, hi: 0xbf},
// Block 0x6b, offset 0x354
{value: 0x0000, lo: 0x03},
{value: 0x3008, lo: 0x80, hi: 0x81},
{value: 0x0008, lo: 0x82, hi: 0xb3},
{value: 0x3008, lo: 0xb4, hi: 0xbf},
// Block 0x6c, offset 0x358
{value: 0x0000, lo: 0x0e},
{value: 0x3008, lo: 0x80, hi: 0x83},
{value: 0x3b08, lo: 0x84, hi: 0x84},
{value: 0x3308, lo: 0x85, hi: 0x85},
{value: 0x0040, lo: 0x86, hi: 0x8d},
{value: 0x0018, lo: 0x8e, hi: 0x8f},
{value: 0x0008, lo: 0x90, hi: 0x99},
{value: 0x0040, lo: 0x9a, hi: 0x9f},
{value: 0x3308, lo: 0xa0, hi: 0xb1},
{value: 0x0008, lo: 0xb2, hi: 0xb7},
{value: 0x0018, lo: 0xb8, hi: 0xba},
{value: 0x0008, lo: 0xbb, hi: 0xbb},
{value: 0x0018, lo: 0xbc, hi: 0xbc},
{value: 0x0008, lo: 0xbd, hi: 0xbe},
{value: 0x3308, lo: 0xbf, hi: 0xbf},
// Block 0x6d, offset 0x367
{value: 0x0000, lo: 0x04},
{value: 0x0008, lo: 0x80, hi: 0xa5},
{value: 0x3308, lo: 0xa6, hi: 0xad},
{value: 0x0018, lo: 0xae, hi: 0xaf},
{value: 0x0008, lo: 0xb0, hi: 0xbf},
// Block 0x6e, offset 0x36c
{value: 0x0000, lo: 0x07},
{value: 0x0008, lo: 0x80, hi: 0x86},
{value: 0x3308, lo: 0x87, hi: 0x91},
{value: 0x3008, lo: 0x92, hi: 0x92},
{value: 0x3808, lo: 0x93, hi: 0x93},
{value: 0x0040, lo: 0x94, hi: 0x9e},
{value: 0x0018, lo: 0x9f, hi: 0xbc},
{value: 0x0040, lo: 0xbd, hi: 0xbf},
// Block 0x6f, offset 0x374
{value: 0x0000, lo: 0x09},
{value: 0x3308, lo: 0x80, hi: 0x82},
{value: 0x3008, lo: 0x83, hi: 0x83},
{value: 0x0008, lo: 0x84, hi: 0xb2},
{value: 0x3308, lo: 0xb3, hi: 0xb3},
{value: 0x3008, lo: 0xb4, hi: 0xb5},
{value: 0x3308, lo: 0xb6, hi: 0xb9},
{value: 0x3008, lo: 0xba, hi: 0xbb},
{value: 0x3308, lo: 0xbc, hi: 0xbd},
{value: 0x3008, lo: 0xbe, hi: 0xbf},
// Block 0x70, offset 0x37e
{value: 0x0000, lo: 0x0a},
{value: 0x3808, lo: 0x80, hi: 0x80},
{value: 0x0018, lo: 0x81, hi: 0x8d},
{value: 0x0040, lo: 0x8e, hi: 0x8e},
{value: 0x0008, lo: 0x8f, hi: 0x99},
{value: 0x0040, lo: 0x9a, hi: 0x9d},
{value: 0x0018, lo: 0x9e, hi: 0x9f},
{value: 0x0008, lo: 0xa0, hi: 0xa4},
{value: 0x3308, lo: 0xa5, hi: 0xa5},
{value: 0x0008, lo: 0xa6, hi: 0xbe},
{value: 0x0040, lo: 0xbf, hi: 0xbf},
// Block 0x71, offset 0x389
{value: 0x0000, lo: 0x07},
{value: 0x0008, lo: 0x80, hi: 0xa8},
{value: 0x3308, lo: 0xa9, hi: 0xae},
{value: 0x3008, lo: 0xaf, hi: 0xb0},
{value: 0x3308, lo: 0xb1, hi: 0xb2},
{value: 0x3008, lo: 0xb3, hi: 0xb4},
{value: 0x3308, lo: 0xb5, hi: 0xb6},
{value: 0x0040, lo: 0xb7, hi: 0xbf},
// Block 0x72, offset 0x391
{value: 0x0000, lo: 0x10},
{value: 0x0008, lo: 0x80, hi: 0x82},
{value: 0x3308, lo: 0x83, hi: 0x83},
{value: 0x0008, lo: 0x84, hi: 0x8b},
{value: 0x3308, lo: 0x8c, hi: 0x8c},
{value: 0x3008, lo: 0x8d, hi: 0x8d},
{value: 0x0040, lo: 0x8e, hi: 0x8f},
{value: 0x0008, lo: 0x90, hi: 0x99},
{value: 0x0040, lo: 0x9a, hi: 0x9b},
{value: 0x0018, lo: 0x9c, hi: 0x9f},
{value: 0x0008, lo: 0xa0, hi: 0xb6},
{value: 0x0018, lo: 0xb7, hi: 0xb9},
{value: 0x0008, lo: 0xba, hi: 0xba},
{value: 0x3008, lo: 0xbb, hi: 0xbb},
{value: 0x3308, lo: 0xbc, hi: 0xbc},
{value: 0x3008, lo: 0xbd, hi: 0xbd},
{value: 0x0008, lo: 0xbe, hi: 0xbf},
// Block 0x73, offset 0x3a2
{value: 0x0000, lo: 0x08},
{value: 0x0008, lo: 0x80, hi: 0xaf},
{value: 0x3308, lo: 0xb0, hi: 0xb0},
{value: 0x0008, lo: 0xb1, hi: 0xb1},
{value: 0x3308, lo: 0xb2, hi: 0xb4},
{value: 0x0008, lo: 0xb5, hi: 0xb6},
{value: 0x3308, lo: 0xb7, hi: 0xb8},
{value: 0x0008, lo: 0xb9, hi: 0xbd},
{value: 0x3308, lo: 0xbe, hi: 0xbf},
// Block 0x74, offset 0x3ab
{value: 0x0000, lo: 0x0f},
{value: 0x0008, lo: 0x80, hi: 0x80},
{value: 0x3308, lo: 0x81, hi: 0x81},
{value: 0x0008, lo: 0x82, hi: 0x82},
{value: 0x0040, lo: 0x83, hi: 0x9a},
{value: 0x0008, lo: 0x9b, hi: 0x9d},
{value: 0x0018, lo: 0x9e, hi: 0x9f},
{value: 0x0008, lo: 0xa0, hi: 0xaa},
{value: 0x3008, lo: 0xab, hi: 0xab},
{value: 0x3308, lo: 0xac, hi: 0xad},
{value: 0x3008, lo: 0xae, hi: 0xaf},
{value: 0x0018, lo: 0xb0, hi: 0xb1},
{value: 0x0008, lo: 0xb2, hi: 0xb4},
{value: 0x3008, lo: 0xb5, hi: 0xb5},
{value: 0x3b08, lo: 0xb6, hi: 0xb6},
{value: 0x0040, lo: 0xb7, hi: 0xbf},
// Block 0x75, offset 0x3bb
{value: 0x0000, lo: 0x0c},
{value: 0x0040, lo: 0x80, hi: 0x80},
{value: 0x0008, lo: 0x81, hi: 0x86},
{value: 0x0040, lo: 0x87, hi: 0x88},
{value: 0x0008, lo: 0x89, hi: 0x8e},
{value: 0x0040, lo: 0x8f, hi: 0x90},
{value: 0x0008, lo: 0x91, hi: 0x96},
{value: 0x0040, lo: 0x97, hi: 0x9f},
{value: 0x0008, lo: 0xa0, hi: 0xa6},
{value: 0x0040, lo: 0xa7, hi: 0xa7},
{value: 0x0008, lo: 0xa8, hi: 0xae},
{value: 0x0040, lo: 0xaf, hi: 0xaf},
{value: 0x0008, lo: 0xb0, hi: 0xbf},
// Block 0x76, offset 0x3c8
{value: 0x0000, lo: 0x0b},
{value: 0x0008, lo: 0x80, hi: 0x9a},
{value: 0x0018, lo: 0x9b, hi: 0x9b},
{value: 0x449d, lo: 0x9c, hi: 0x9c},
{value: 0x44b5, lo: 0x9d, hi: 0x9d},
{value: 0x0941, lo: 0x9e, hi: 0x9e},
{value: 0xe06d, lo: 0x9f, hi: 0x9f},
{value: 0x0008, lo: 0xa0, hi: 0xa8},
{value: 0x13f9, lo: 0xa9, hi: 0xa9},
{value: 0x0018, lo: 0xaa, hi: 0xab},
{value: 0x0040, lo: 0xac, hi: 0xaf},
{value: 0x44cd, lo: 0xb0, hi: 0xbf},
// Block 0x77, offset 0x3d4
{value: 0x0000, lo: 0x04},
{value: 0x44ed, lo: 0x80, hi: 0x8f},
{value: 0x450d, lo: 0x90, hi: 0x9f},
{value: 0x452d, lo: 0xa0, hi: 0xaf},
{value: 0x450d, lo: 0xb0, hi: 0xbf},
// Block 0x78, offset 0x3d9
{value: 0x0000, lo: 0x0c},
{value: 0x0008, lo: 0x80, hi: 0xa2},
{value: 0x3008, lo: 0xa3, hi: 0xa4},
{value: 0x3308, lo: 0xa5, hi: 0xa5},
{value: 0x3008, lo: 0xa6, hi: 0xa7},
{value: 0x3308, lo: 0xa8, hi: 0xa8},
{value: 0x3008, lo: 0xa9, hi: 0xaa},
{value: 0x0018, lo: 0xab, hi: 0xab},
{value: 0x3008, lo: 0xac, hi: 0xac},
{value: 0x3b08, lo: 0xad, hi: 0xad},
{value: 0x0040, lo: 0xae, hi: 0xaf},
{value: 0x0008, lo: 0xb0, hi: 0xb9},
{value: 0x0040, lo: 0xba, hi: 0xbf},
// Block 0x79, offset 0x3e6
{value: 0x0000, lo: 0x03},
{value: 0x0008, lo: 0x80, hi: 0xa3},
{value: 0x0040, lo: 0xa4, hi: 0xaf},
{value: 0x0018, lo: 0xb0, hi: 0xbf},
// Block 0x7a, offset 0x3ea
{value: 0x0000, lo: 0x04},
{value: 0x0018, lo: 0x80, hi: 0x86},
{value: 0x0040, lo: 0x87, hi: 0x8a},
{value: 0x0018, lo: 0x8b, hi: 0xbb},
{value: 0x0040, lo: 0xbc, hi: 0xbf},
// Block 0x7b, offset 0x3ef
{value: 0x0000, lo: 0x01},
{value: 0x0040, lo: 0x80, hi: 0xbf},
// Block 0x7c, offset 0x3f1
{value: 0x0020, lo: 0x01},
{value: 0x454d, lo: 0x80, hi: 0xbf},
// Block 0x7d, offset 0x3f3
{value: 0x0020, lo: 0x03},
{value: 0x4d4d, lo: 0x80, hi: 0x94},
{value: 0x4b0d, lo: 0x95, hi: 0x95},
{value: 0x4fed, lo: 0x96, hi: 0xbf},
// Block 0x7e, offset 0x3f7
{value: 0x0020, lo: 0x01},
{value: 0x552d, lo: 0x80, hi: 0xbf},
// Block 0x7f, offset 0x3f9
{value: 0x0020, lo: 0x03},
{value: 0x5d2d, lo: 0x80, hi: 0x84},
{value: 0x568d, lo: 0x85, hi: 0x85},
{value: 0x5dcd, lo: 0x86, hi: 0xbf},
// Block 0x80, offset 0x3fd
{value: 0x0020, lo: 0x08},
{value: 0x6b8d, lo: 0x80, hi: 0x8f},
{value: 0x6d4d, lo: 0x90, hi: 0x90},
{value: 0x6d8d, lo: 0x91, hi: 0xab},
{value: 0x1401, lo: 0xac, hi: 0xac},
{value: 0x70ed, lo: 0xad, hi: 0xad},
{value: 0x0040, lo: 0xae, hi: 0xae},
{value: 0x0040, lo: 0xaf, hi: 0xaf},
{value: 0x710d, lo: 0xb0, hi: 0xbf},
// Block 0x81, offset 0x406
{value: 0x0020, lo: 0x05},
{value: 0x730d, lo: 0x80, hi: 0xad},
{value: 0x656d, lo: 0xae, hi: 0xae},
{value: 0x78cd, lo: 0xaf, hi: 0xb5},
{value: 0x6f8d, lo: 0xb6, hi: 0xb6},
{value: 0x79ad, lo: 0xb7, hi: 0xbf},
// Block 0x82, offset 0x40c
{value: 0x0008, lo: 0x03},
{value: 0x1751, lo: 0x80, hi: 0x82},
{value: 0x1741, lo: 0x83, hi: 0x83},
{value: 0x1769, lo: 0x84, hi: 0xbf},
// Block 0x83, offset 0x410
{value: 0x0008, lo: 0x0f},
{value: 0x1d81, lo: 0x80, hi: 0x83},
{value: 0x1d99, lo: 0x84, hi: 0x85},
{value: 0x1da1, lo: 0x86, hi: 0x87},
{value: 0x1da9, lo: 0x88, hi: 0x8f},
{value: 0x0040, lo: 0x90, hi: 0x90},
{value: 0x0040, lo: 0x91, hi: 0x91},
{value: 0x1de9, lo: 0x92, hi: 0x97},
{value: 0x1e11, lo: 0x98, hi: 0x9c},
{value: 0x1e31, lo: 0x9d, hi: 0xb3},
{value: 0x1d71, lo: 0xb4, hi: 0xb4},
{value: 0x1d81, lo: 0xb5, hi: 0xb5},
{value: 0x1ee9, lo: 0xb6, hi: 0xbb},
{value: 0x1f09, lo: 0xbc, hi: 0xbc},
{value: 0x1ef9, lo: 0xbd, hi: 0xbd},
{value: 0x1f19, lo: 0xbe, hi: 0xbf},
// Block 0x84, offset 0x420
{value: 0x0000, lo: 0x09},
{value: 0x0008, lo: 0x80, hi: 0x8b},
{value: 0x0040, lo: 0x8c, hi: 0x8c},
{value: 0x0008, lo: 0x8d, hi: 0xa6},
{value: 0x0040, lo: 0xa7, hi: 0xa7},
{value: 0x0008, lo: 0xa8, hi: 0xba},
{value: 0x0040, lo: 0xbb, hi: 0xbb},
{value: 0x0008, lo: 0xbc, hi: 0xbd},
{value: 0x0040, lo: 0xbe, hi: 0xbe},
{value: 0x0008, lo: 0xbf, hi: 0xbf},
// Block 0x85, offset 0x42a
{value: 0x0000, lo: 0x04},
{value: 0x0008, lo: 0x80, hi: 0x8d},
{value: 0x0040, lo: 0x8e, hi: 0x8f},
{value: 0x0008, lo: 0x90, hi: 0x9d},
{value: 0x0040, lo: 0x9e, hi: 0xbf},
// Block 0x86, offset 0x42f
{value: 0x0000, lo: 0x02},
{value: 0x0008, lo: 0x80, hi: 0xba},
{value: 0x0040, lo: 0xbb, hi: 0xbf},
// Block 0x87, offset 0x432
{value: 0x0000, lo: 0x05},
{value: 0x0018, lo: 0x80, hi: 0x82},
{value: 0x0040, lo: 0x83, hi: 0x86},
{value: 0x0018, lo: 0x87, hi: 0xb3},
{value: 0x0040, lo: 0xb4, hi: 0xb6},
{value: 0x0018, lo: 0xb7, hi: 0xbf},
// Block 0x88, offset 0x438
{value: 0x0000, lo: 0x06},
{value: 0x0018, lo: 0x80, hi: 0x8e},
{value: 0x0040, lo: 0x8f, hi: 0x8f},
{value: 0x0018, lo: 0x90, hi: 0x9c},
{value: 0x0040, lo: 0x9d, hi: 0x9f},
{value: 0x0018, lo: 0xa0, hi: 0xa0},
{value: 0x0040, lo: 0xa1, hi: 0xbf},
// Block 0x89, offset 0x43f
{value: 0x0000, lo: 0x04},
{value: 0x0040, lo: 0x80, hi: 0x8f},
{value: 0x0018, lo: 0x90, hi: 0xbc},
{value: 0x3308, lo: 0xbd, hi: 0xbd},
{value: 0x0040, lo: 0xbe, hi: 0xbf},
// Block 0x8a, offset 0x444
{value: 0x0000, lo: 0x03},
{value: 0x0008, lo: 0x80, hi: 0x9c},
{value: 0x0040, lo: 0x9d, hi: 0x9f},
{value: 0x0008, lo: 0xa0, hi: 0xbf},
// Block 0x8b, offset 0x448
{value: 0x0000, lo: 0x05},
{value: 0x0008, lo: 0x80, hi: 0x90},
{value: 0x0040, lo: 0x91, hi: 0x9f},
{value: 0x3308, lo: 0xa0, hi: 0xa0},
{value: 0x0018, lo: 0xa1, hi: 0xbb},
{value: 0x0040, lo: 0xbc, hi: 0xbf},
// Block 0x8c, offset 0x44e
{value: 0x0000, lo: 0x04},
{value: 0x0008, lo: 0x80, hi: 0x9f},
{value: 0x0018, lo: 0xa0, hi: 0xa3},
{value: 0x0040, lo: 0xa4, hi: 0xac},
{value: 0x0008, lo: 0xad, hi: 0xbf},
// Block 0x8d, offset 0x453
{value: 0x0000, lo: 0x08},
{value: 0x0008, lo: 0x80, hi: 0x80},
{value: 0x0018, lo: 0x81, hi: 0x81},
{value: 0x0008, lo: 0x82, hi: 0x89},
{value: 0x0018, lo: 0x8a, hi: 0x8a},
{value: 0x0040, lo: 0x8b, hi: 0x8f},
{value: 0x0008, lo: 0x90, hi: 0xb5},
{value: 0x3308, lo: 0xb6, hi: 0xba},
{value: 0x0040, lo: 0xbb, hi: 0xbf},
// Block 0x8e, offset 0x45c
{value: 0x0000, lo: 0x04},
{value: 0x0008, lo: 0x80, hi: 0x9d},
{value: 0x0040, lo: 0x9e, hi: 0x9e},
{value: 0x0018, lo: 0x9f, hi: 0x9f},
{value: 0x0008, lo: 0xa0, hi: 0xbf},
// Block 0x8f, offset 0x461
{value: 0x0000, lo: 0x05},
{value: 0x0008, lo: 0x80, hi: 0x83},
{value: 0x0040, lo: 0x84, hi: 0x87},
{value: 0x0008, lo: 0x88, hi: 0x8f},
{value: 0x0018, lo: 0x90, hi: 0x95},
{value: 0x0040, lo: 0x96, hi: 0xbf},
// Block 0x90, offset 0x467
{value: 0x0000, lo: 0x06},
{value: 0xe145, lo: 0x80, hi: 0x87},
{value: 0xe1c5, lo: 0x88, hi: 0x8f},
{value: 0xe145, lo: 0x90, hi: 0x97},
{value: 0x8b0d, lo: 0x98, hi: 0x9f},
{value: 0x8b25, lo: 0xa0, hi: 0xa7},
{value: 0x0008, lo: 0xa8, hi: 0xbf},
// Block 0x91, offset 0x46e
{value: 0x0000, lo: 0x06},
{value: 0x0008, lo: 0x80, hi: 0x9d},
{value: 0x0040, lo: 0x9e, hi: 0x9f},
{value: 0x0008, lo: 0xa0, hi: 0xa9},
{value: 0x0040, lo: 0xaa, hi: 0xaf},
{value: 0x8b25, lo: 0xb0, hi: 0xb7},
{value: 0x8b0d, lo: 0xb8, hi: 0xbf},
// Block 0x92, offset 0x475
{value: 0x0000, lo: 0x06},
{value: 0xe145, lo: 0x80, hi: 0x87},
{value: 0xe1c5, lo: 0x88, hi: 0x8f},
{value: 0xe145, lo: 0x90, hi: 0x93},
{value: 0x0040, lo: 0x94, hi: 0x97},
{value: 0x0008, lo: 0x98, hi: 0xbb},
{value: 0x0040, lo: 0xbc, hi: 0xbf},
// Block 0x93, offset 0x47c
{value: 0x0000, lo: 0x03},
{value: 0x0008, lo: 0x80, hi: 0xa7},
{value: 0x0040, lo: 0xa8, hi: 0xaf},
{value: 0x0008, lo: 0xb0, hi: 0xbf},
// Block 0x94, offset 0x480
{value: 0x0000, lo: 0x02},
{value: 0x0008, lo: 0x80, hi: 0xb6},
{value: 0x0040, lo: 0xb7, hi: 0xbf},
// Block 0x95, offset 0x483
{value: 0x0000, lo: 0x04},
{value: 0x0008, lo: 0x80, hi: 0x95},
{value: 0x0040, lo: 0x96, hi: 0x9f},
{value: 0x0008, lo: 0xa0, hi: 0xa7},
{value: 0x0040, lo: 0xa8, hi: 0xbf},
// Block 0x96, offset 0x488
{value: 0x0000, lo: 0x0b},
{value: 0x0808, lo: 0x80, hi: 0x85},
{value: 0x0040, lo: 0x86, hi: 0x87},
{value: 0x0808, lo: 0x88, hi: 0x88},
{value: 0x0040, lo: 0x89, hi: 0x89},
{value: 0x0808, lo: 0x8a, hi: 0xb5},
{value: 0x0040, lo: 0xb6, hi: 0xb6},
{value: 0x0808, lo: 0xb7, hi: 0xb8},
{value: 0x0040, lo: 0xb9, hi: 0xbb},
{value: 0x0808, lo: 0xbc, hi: 0xbc},
{value: 0x0040, lo: 0xbd, hi: 0xbe},
{value: 0x0808, lo: 0xbf, hi: 0xbf},
// Block 0x97, offset 0x494
{value: 0x0000, lo: 0x05},
{value: 0x0808, lo: 0x80, hi: 0x95},
{value: 0x0040, lo: 0x96, hi: 0x96},
{value: 0x0818, lo: 0x97, hi: 0x9f},
{value: 0x0808, lo: 0xa0, hi: 0xb6},
{value: 0x0818, lo: 0xb7, hi: 0xbf},
// Block 0x98, offset 0x49a
{value: 0x0000, lo: 0x04},
{value: 0x0808, lo: 0x80, hi: 0x9e},
{value: 0x0040, lo: 0x9f, hi: 0xa6},
{value: 0x0818, lo: 0xa7, hi: 0xaf},
{value: 0x0040, lo: 0xb0, hi: 0xbf},
// Block 0x99, offset 0x49f
{value: 0x0000, lo: 0x06},
{value: 0x0040, lo: 0x80, hi: 0x9f},
{value: 0x0808, lo: 0xa0, hi: 0xb2},
{value: 0x0040, lo: 0xb3, hi: 0xb3},
{value: 0x0808, lo: 0xb4, hi: 0xb5},
{value: 0x0040, lo: 0xb6, hi: 0xba},
{value: 0x0818, lo: 0xbb, hi: 0xbf},
// Block 0x9a, offset 0x4a6
{value: 0x0000, lo: 0x07},
{value: 0x0808, lo: 0x80, hi: 0x95},
{value: 0x0818, lo: 0x96, hi: 0x9b},
{value: 0x0040, lo: 0x9c, hi: 0x9e},
{value: 0x0018, lo: 0x9f, hi: 0x9f},
{value: 0x0808, lo: 0xa0, hi: 0xb9},
{value: 0x0040, lo: 0xba, hi: 0xbe},
{value: 0x0818, lo: 0xbf, hi: 0xbf},
// Block 0x9b, offset 0x4ae
{value: 0x0000, lo: 0x04},
{value: 0x0808, lo: 0x80, hi: 0xb7},
{value: 0x0040, lo: 0xb8, hi: 0xbb},
{value: 0x0818, lo: 0xbc, hi: 0xbd},
{value: 0x0808, lo: 0xbe, hi: 0xbf},
// Block 0x9c, offset 0x4b3
{value: 0x0000, lo: 0x03},
{value: 0x0818, lo: 0x80, hi: 0x8f},
{value: 0x0040, lo: 0x90, hi: 0x91},
{value: 0x0818, lo: 0x92, hi: 0xbf},
// Block 0x9d, offset 0x4b7
{value: 0x0000, lo: 0x0f},
{value: 0x0808, lo: 0x80, hi: 0x80},
{value: 0x3308, lo: 0x81, hi: 0x83},
{value: 0x0040, lo: 0x84, hi: 0x84},
{value: 0x3308, lo: 0x85, hi: 0x86},
{value: 0x0040, lo: 0x87, hi: 0x8b},
{value: 0x3308, lo: 0x8c, hi: 0x8f},
{value: 0x0808, lo: 0x90, hi: 0x93},
{value: 0x0040, lo: 0x94, hi: 0x94},
{value: 0x0808, lo: 0x95, hi: 0x97},
{value: 0x0040, lo: 0x98, hi: 0x98},
{value: 0x0808, lo: 0x99, hi: 0xb5},
{value: 0x0040, lo: 0xb6, hi: 0xb7},
{value: 0x3308, lo: 0xb8, hi: 0xba},
{value: 0x0040, lo: 0xbb, hi: 0xbe},
{value: 0x3b08, lo: 0xbf, hi: 0xbf},
// Block 0x9e, offset 0x4c7
{value: 0x0000, lo: 0x06},
{value: 0x0818, lo: 0x80, hi: 0x88},
{value: 0x0040, lo: 0x89, hi: 0x8f},
{value: 0x0818, lo: 0x90, hi: 0x98},
{value: 0x0040, lo: 0x99, hi: 0x9f},
{value: 0x0808, lo: 0xa0, hi: 0xbc},
{value: 0x0818, lo: 0xbd, hi: 0xbf},
// Block 0x9f, offset 0x4ce
{value: 0x0000, lo: 0x03},
{value: 0x0808, lo: 0x80, hi: 0x9c},
{value: 0x0818, lo: 0x9d, hi: 0x9f},
{value: 0x0040, lo: 0xa0, hi: 0xbf},
// Block 0xa0, offset 0x4d2
{value: 0x0000, lo: 0x03},
{value: 0x0808, lo: 0x80, hi: 0xb5},
{value: 0x0040, lo: 0xb6, hi: 0xb8},
{value: 0x0018, lo: 0xb9, hi: 0xbf},
// Block 0xa1, offset 0x4d6
{value: 0x0000, lo: 0x06},
{value: 0x0808, lo: 0x80, hi: 0x95},
{value: 0x0040, lo: 0x96, hi: 0x97},
{value: 0x0818, lo: 0x98, hi: 0x9f},
{value: 0x0808, lo: 0xa0, hi: 0xb2},
{value: 0x0040, lo: 0xb3, hi: 0xb7},
{value: 0x0818, lo: 0xb8, hi: 0xbf},
// Block 0xa2, offset 0x4dd
{value: 0x0000, lo: 0x01},
{value: 0x0808, lo: 0x80, hi: 0xbf},
// Block 0xa3, offset 0x4df
{value: 0x0000, lo: 0x02},
{value: 0x0808, lo: 0x80, hi: 0x88},
{value: 0x0040, lo: 0x89, hi: 0xbf},
// Block 0xa4, offset 0x4e2
{value: 0x0000, lo: 0x02},
{value: 0x03dd, lo: 0x80, hi: 0xb2},
{value: 0x0040, lo: 0xb3, hi: 0xbf},
// Block 0xa5, offset 0x4e5
{value: 0x0000, lo: 0x03},
{value: 0x0808, lo: 0x80, hi: 0xb2},
{value: 0x0040, lo: 0xb3, hi: 0xb9},
{value: 0x0818, lo: 0xba, hi: 0xbf},
// Block 0xa6, offset 0x4e9
{value: 0x0000, lo: 0x08},
{value: 0x0908, lo: 0x80, hi: 0x80},
{value: 0x0a08, lo: 0x81, hi: 0xa1},
{value: 0x0c08, lo: 0xa2, hi: 0xa2},
{value: 0x0a08, lo: 0xa3, hi: 0xa3},
{value: 0x3308, lo: 0xa4, hi: 0xa7},
{value: 0x0040, lo: 0xa8, hi: 0xaf},
{value: 0x0808, lo: 0xb0, hi: 0xb9},
{value: 0x0040, lo: 0xba, hi: 0xbf},
// Block 0xa7, offset 0x4f2
{value: 0x0000, lo: 0x03},
{value: 0x0040, lo: 0x80, hi: 0x9f},
{value: 0x0818, lo: 0xa0, hi: 0xbe},
{value: 0x0040, lo: 0xbf, hi: 0xbf},
// Block 0xa8, offset 0x4f6
{value: 0x0000, lo: 0x07},
{value: 0x0808, lo: 0x80, hi: 0xa9},
{value: 0x0040, lo: 0xaa, hi: 0xaa},
{value: 0x3308, lo: 0xab, hi: 0xac},
{value: 0x0818, lo: 0xad, hi: 0xad},
{value: 0x0040, lo: 0xae, hi: 0xaf},
{value: 0x0808, lo: 0xb0, hi: 0xb1},
{value: 0x0040, lo: 0xb2, hi: 0xbf},
// Block 0xa9, offset 0x4fe
{value: 0x0000, lo: 0x02},
{value: 0x0040, lo: 0x80, hi: 0xbc},
{value: 0x3308, lo: 0xbd, hi: 0xbf},
// Block 0xaa, offset 0x501
{value: 0x0000, lo: 0x07},
{value: 0x0808, lo: 0x80, hi: 0x9c},
{value: 0x0818, lo: 0x9d, hi: 0xa6},
{value: 0x0808, lo: 0xa7, hi: 0xa7},
{value: 0x0040, lo: 0xa8, hi: 0xaf},
{value: 0x0a08, lo: 0xb0, hi: 0xb2},
{value: 0x0c08, lo: 0xb3, hi: 0xb3},
{value: 0x0a08, lo: 0xb4, hi: 0xbf},
// Block 0xab, offset 0x509
{value: 0x0000, lo: 0x0a},
{value: 0x0a08, lo: 0x80, hi: 0x84},
{value: 0x0808, lo: 0x85, hi: 0x85},
{value: 0x3308, lo: 0x86, hi: 0x90},
{value: 0x0a18, lo: 0x91, hi: 0x93},
{value: 0x0c18, lo: 0x94, hi: 0x94},
{value: 0x0818, lo: 0x95, hi: 0x99},
{value: 0x0040, lo: 0x9a, hi: 0xaf},
{value: 0x0a08, lo: 0xb0, hi: 0xb3},
{value: 0x0c08, lo: 0xb4, hi: 0xb5},
{value: 0x0a08, lo: 0xb6, hi: 0xbf},
// Block 0xac, offset 0x514
{value: 0x0000, lo: 0x0e},
{value: 0x0a08, lo: 0x80, hi: 0x81},
{value: 0x3308, lo: 0x82, hi: 0x85},
{value: 0x0818, lo: 0x86, hi: 0x89},
{value: 0x0040, lo: 0x8a, hi: 0xaf},
{value: 0x0a08, lo: 0xb0, hi: 0xb0},
{value: 0x0808, lo: 0xb1, hi: 0xb1},
{value: 0x0a08, lo: 0xb2, hi: 0xb3},
{value: 0x0c08, lo: 0xb4, hi: 0xb6},
{value: 0x0808, lo: 0xb7, hi: 0xb7},
{value: 0x0a08, lo: 0xb8, hi: 0xb8},
{value: 0x0c08, lo: 0xb9, hi: 0xba},
{value: 0x0a08, lo: 0xbb, hi: 0xbc},
{value: 0x0c08, lo: 0xbd, hi: 0xbd},
{value: 0x0a08, lo: 0xbe, hi: 0xbf},
// Block 0xad, offset 0x523
{value: 0x0000, lo: 0x0b},
{value: 0x0808, lo: 0x80, hi: 0x80},
{value: 0x0a08, lo: 0x81, hi: 0x81},
{value: 0x0c08, lo: 0x82, hi: 0x83},
{value: 0x0a08, lo: 0x84, hi: 0x84},
{value: 0x0818, lo: 0x85, hi: 0x88},
{value: 0x0c18, lo: 0x89, hi: 0x89},
{value: 0x0a18, lo: 0x8a, hi: 0x8a},
{value: 0x0918, lo: 0x8b, hi: 0x8b},
{value: 0x0040, lo: 0x8c, hi: 0x9f},
{value: 0x0808, lo: 0xa0, hi: 0xb6},
{value: 0x0040, lo: 0xb7, hi: 0xbf},
// Block 0xae, offset 0x52f
{value: 0x0000, lo: 0x05},
{value: 0x3008, lo: 0x80, hi: 0x80},
{value: 0x3308, lo: 0x81, hi: 0x81},
{value: 0x3008, lo: 0x82, hi: 0x82},
{value: 0x0008, lo: 0x83, hi: 0xb7},
{value: 0x3308, lo: 0xb8, hi: 0xbf},
// Block 0xaf, offset 0x535
{value: 0x0000, lo: 0x0c},
{value: 0x3308, lo: 0x80, hi: 0x85},
{value: 0x3b08, lo: 0x86, hi: 0x86},
{value: 0x0018, lo: 0x87, hi: 0x8d},
{value: 0x0040, lo: 0x8e, hi: 0x91},
{value: 0x0018, lo: 0x92, hi: 0xa5},
{value: 0x0008, lo: 0xa6, hi: 0xaf},
{value: 0x3b08, lo: 0xb0, hi: 0xb0},
{value: 0x0008, lo: 0xb1, hi: 0xb2},
{value: 0x3308, lo: 0xb3, hi: 0xb4},
{value: 0x0008, lo: 0xb5, hi: 0xb5},
{value: 0x0040, lo: 0xb6, hi: 0xbe},
{value: 0x3b08, lo: 0xbf, hi: 0xbf},
// Block 0xb0, offset 0x542
{value: 0x0000, lo: 0x0b},
{value: 0x3308, lo: 0x80, hi: 0x81},
{value: 0x3008, lo: 0x82, hi: 0x82},
{value: 0x0008, lo: 0x83, hi: 0xaf},
{value: 0x3008, lo: 0xb0, hi: 0xb2},
{value: 0x3308, lo: 0xb3, hi: 0xb6},
{value: 0x3008, lo: 0xb7, hi: 0xb8},
{value: 0x3b08, lo: 0xb9, hi: 0xb9},
{value: 0x3308, lo: 0xba, hi: 0xba},
{value: 0x0018, lo: 0xbb, hi: 0xbc},
{value: 0x0040, lo: 0xbd, hi: 0xbd},
{value: 0x0018, lo: 0xbe, hi: 0xbf},
// Block 0xb1, offset 0x54e
{value: 0x0000, lo: 0x07},
{value: 0x0018, lo: 0x80, hi: 0x81},
{value: 0x3308, lo: 0x82, hi: 0x82},
{value: 0x0040, lo: 0x83, hi: 0x8f},
{value: 0x0008, lo: 0x90, hi: 0xa8},
{value: 0x0040, lo: 0xa9, hi: 0xaf},
{value: 0x0008, lo: 0xb0, hi: 0xb9},
{value: 0x0040, lo: 0xba, hi: 0xbf},
// Block 0xb2, offset 0x556
{value: 0x0000, lo: 0x08},
{value: 0x3308, lo: 0x80, hi: 0x82},
{value: 0x0008, lo: 0x83, hi: 0xa6},
{value: 0x3308, lo: 0xa7, hi: 0xab},
{value: 0x3008, lo: 0xac, hi: 0xac},
{value: 0x3308, lo: 0xad, hi: 0xb2},
{value: 0x3b08, lo: 0xb3, hi: 0xb4},
{value: 0x0040, lo: 0xb5, hi: 0xb5},
{value: 0x0008, lo: 0xb6, hi: 0xbf},
// Block 0xb3, offset 0x55f
{value: 0x0000, lo: 0x0a},
{value: 0x0018, lo: 0x80, hi: 0x83},
{value: 0x0008, lo: 0x84, hi: 0x84},
{value: 0x3008, lo: 0x85, hi: 0x86},
{value: 0x0008, lo: 0x87, hi: 0x87},
{value: 0x0040, lo: 0x88, hi: 0x8f},
{value: 0x0008, lo: 0x90, hi: 0xb2},
{value: 0x3308, lo: 0xb3, hi: 0xb3},
{value: 0x0018, lo: 0xb4, hi: 0xb5},
{value: 0x0008, lo: 0xb6, hi: 0xb6},
{value: 0x0040, lo: 0xb7, hi: 0xbf},
// Block 0xb4, offset 0x56a
{value: 0x0000, lo: 0x06},
{value: 0x3308, lo: 0x80, hi: 0x81},
{value: 0x3008, lo: 0x82, hi: 0x82},
{value: 0x0008, lo: 0x83, hi: 0xb2},
{value: 0x3008, lo: 0xb3, hi: 0xb5},
{value: 0x3308, lo: 0xb6, hi: 0xbe},
{value: 0x3008, lo: 0xbf, hi: 0xbf},
// Block 0xb5, offset 0x571
{value: 0x0000, lo: 0x0e},
{value: 0x3808, lo: 0x80, hi: 0x80},
{value: 0x0008, lo: 0x81, hi: 0x84},
{value: 0x0018, lo: 0x85, hi: 0x88},
{value: 0x3308, lo: 0x89, hi: 0x8c},
{value: 0x0018, lo: 0x8d, hi: 0x8d},
{value: 0x3008, lo: 0x8e, hi: 0x8e},
{value: 0x3308, lo: 0x8f, hi: 0x8f},
{value: 0x0008, lo: 0x90, hi: 0x9a},
{value: 0x0018, lo: 0x9b, hi: 0x9b},
{value: 0x0008, lo: 0x9c, hi: 0x9c},
{value: 0x0018, lo: 0x9d, hi: 0x9f},
{value: 0x0040, lo: 0xa0, hi: 0xa0},
{value: 0x0018, lo: 0xa1, hi: 0xb4},
{value: 0x0040, lo: 0xb5, hi: 0xbf},
// Block 0xb6, offset 0x580
{value: 0x0000, lo: 0x0c},
{value: 0x0008, lo: 0x80, hi: 0x91},
{value: 0x0040, lo: 0x92, hi: 0x92},
{value: 0x0008, lo: 0x93, hi: 0xab},
{value: 0x3008, lo: 0xac, hi: 0xae},
{value: 0x3308, lo: 0xaf, hi: 0xb1},
{value: 0x3008, lo: 0xb2, hi: 0xb3},
{value: 0x3308, lo: 0xb4, hi: 0xb4},
{value: 0x3808, lo: 0xb5, hi: 0xb5},
{value: 0x3308, lo: 0xb6, hi: 0xb7},
{value: 0x0018, lo: 0xb8, hi: 0xbd},
{value: 0x3308, lo: 0xbe, hi: 0xbe},
{value: 0x0008, lo: 0xbf, hi: 0xbf},
// Block 0xb7, offset 0x58d
{value: 0x0000, lo: 0x03},
{value: 0x0008, lo: 0x80, hi: 0x80},
{value: 0x3308, lo: 0x81, hi: 0x81},
{value: 0x0040, lo: 0x82, hi: 0xbf},
// Block 0xb8, offset 0x591
{value: 0x0000, lo: 0x0c},
{value: 0x0008, lo: 0x80, hi: 0x86},
{value: 0x0040, lo: 0x87, hi: 0x87},
{value: 0x0008, lo: 0x88, hi: 0x88},
{value: 0x0040, lo: 0x89, hi: 0x89},
{value: 0x0008, lo: 0x8a, hi: 0x8d},
{value: 0x0040, lo: 0x8e, hi: 0x8e},
{value: 0x0008, lo: 0x8f, hi: 0x9d},
{value: 0x0040, lo: 0x9e, hi: 0x9e},
{value: 0x0008, lo: 0x9f, hi: 0xa8},
{value: 0x0018, lo: 0xa9, hi: 0xa9},
{value: 0x0040, lo: 0xaa, hi: 0xaf},
{value: 0x0008, lo: 0xb0, hi: 0xbf},
// Block 0xb9, offset 0x59e
{value: 0x0000, lo: 0x08},
{value: 0x0008, lo: 0x80, hi: 0x9e},
{value: 0x3308, lo: 0x9f, hi: 0x9f},
{value: 0x3008, lo: 0xa0, hi: 0xa2},
{value: 0x3308, lo: 0xa3, hi: 0xa9},
{value: 0x3b08, lo: 0xaa, hi: 0xaa},
{value: 0x0040, lo: 0xab, hi: 0xaf},
{value: 0x0008, lo: 0xb0, hi: 0xb9},
{value: 0x0040, lo: 0xba, hi: 0xbf},
// Block 0xba, offset 0x5a7
{value: 0x0000, lo: 0x03},
{value: 0x0008, lo: 0x80, hi: 0xb4},
{value: 0x3008, lo: 0xb5, hi: 0xb7},
{value: 0x3308, lo: 0xb8, hi: 0xbf},
// Block 0xbb, offset 0x5ab
{value: 0x0000, lo: 0x0e},
{value: 0x3008, lo: 0x80, hi: 0x81},
{value: 0x3b08, lo: 0x82, hi: 0x82},
{value: 0x3308, lo: 0x83, hi: 0x84},
{value: 0x3008, lo: 0x85, hi: 0x85},
{value: 0x3308, lo: 0x86, hi: 0x86},
{value: 0x0008, lo: 0x87, hi: 0x8a},
{value: 0x0018, lo: 0x8b, hi: 0x8f},
{value: 0x0008, lo: 0x90, hi: 0x99},
{value: 0x0018, lo: 0x9a, hi: 0x9b},
{value: 0x0040, lo: 0x9c, hi: 0x9c},
{value: 0x0018, lo: 0x9d, hi: 0x9d},
{value: 0x3308, lo: 0x9e, hi: 0x9e},
{value: 0x0008, lo: 0x9f, hi: 0xa1},
{value: 0x0040, lo: 0xa2, hi: 0xbf},
// Block 0xbc, offset 0x5ba
{value: 0x0000, lo: 0x07},
{value: 0x0008, lo: 0x80, hi: 0xaf},
{value: 0x3008, lo: 0xb0, hi: 0xb2},
{value: 0x3308, lo: 0xb3, hi: 0xb8},
{value: 0x3008, lo: 0xb9, hi: 0xb9},
{value: 0x3308, lo: 0xba, hi: 0xba},
{value: 0x3008, lo: 0xbb, hi: 0xbe},
{value: 0x3308, lo: 0xbf, hi: 0xbf},
// Block 0xbd, offset 0x5c2
{value: 0x0000, lo: 0x0a},
{value: 0x3308, lo: 0x80, hi: 0x80},
{value: 0x3008, lo: 0x81, hi: 0x81},
{value: 0x3b08, lo: 0x82, hi: 0x82},
{value: 0x3308, lo: 0x83, hi: 0x83},
{value: 0x0008, lo: 0x84, hi: 0x85},
{value: 0x0018, lo: 0x86, hi: 0x86},
{value: 0x0008, lo: 0x87, hi: 0x87},
{value: 0x0040, lo: 0x88, hi: 0x8f},
{value: 0x0008, lo: 0x90, hi: 0x99},
{value: 0x0040, lo: 0x9a, hi: 0xbf},
// Block 0xbe, offset 0x5cd
{value: 0x0000, lo: 0x08},
{value: 0x0008, lo: 0x80, hi: 0xae},
{value: 0x3008, lo: 0xaf, hi: 0xb1},
{value: 0x3308, lo: 0xb2, hi: 0xb5},
{value: 0x0040, lo: 0xb6, hi: 0xb7},
{value: 0x3008, lo: 0xb8, hi: 0xbb},
{value: 0x3308, lo: 0xbc, hi: 0xbd},
{value: 0x3008, lo: 0xbe, hi: 0xbe},
{value: 0x3b08, lo: 0xbf, hi: 0xbf},
// Block 0xbf, offset 0x5d6
{value: 0x0000, lo: 0x05},
{value: 0x3308, lo: 0x80, hi: 0x80},
{value: 0x0018, lo: 0x81, hi: 0x97},
{value: 0x0008, lo: 0x98, hi: 0x9b},
{value: 0x3308, lo: 0x9c, hi: 0x9d},
{value: 0x0040, lo: 0x9e, hi: 0xbf},
// Block 0xc0, offset 0x5dc
{value: 0x0000, lo: 0x07},
{value: 0x0008, lo: 0x80, hi: 0xaf},
{value: 0x3008, lo: 0xb0, hi: 0xb2},
{value: 0x3308, lo: 0xb3, hi: 0xba},
{value: 0x3008, lo: 0xbb, hi: 0xbc},
{value: 0x3308, lo: 0xbd, hi: 0xbd},
{value: 0x3008, lo: 0xbe, hi: 0xbe},
{value: 0x3b08, lo: 0xbf, hi: 0xbf},
// Block 0xc1, offset 0x5e4
{value: 0x0000, lo: 0x08},
{value: 0x3308, lo: 0x80, hi: 0x80},
{value: 0x0018, lo: 0x81, hi: 0x83},
{value: 0x0008, lo: 0x84, hi: 0x84},
{value: 0x0040, lo: 0x85, hi: 0x8f},
{value: 0x0008, lo: 0x90, hi: 0x99},
{value: 0x0040, lo: 0x9a, hi: 0x9f},
{value: 0x0018, lo: 0xa0, hi: 0xac},
{value: 0x0040, lo: 0xad, hi: 0xbf},
// Block 0xc2, offset 0x5ed
{value: 0x0000, lo: 0x0b},
{value: 0x0008, lo: 0x80, hi: 0xaa},
{value: 0x3308, lo: 0xab, hi: 0xab},
{value: 0x3008, lo: 0xac, hi: 0xac},
{value: 0x3308, lo: 0xad, hi: 0xad},
{value: 0x3008, lo: 0xae, hi: 0xaf},
{value: 0x3308, lo: 0xb0, hi: 0xb5},
{value: 0x3808, lo: 0xb6, hi: 0xb6},
{value: 0x3308, lo: 0xb7, hi: 0xb7},
{value: 0x0008, lo: 0xb8, hi: 0xb8},
{value: 0x0018, lo: 0xb9, hi: 0xb9},
{value: 0x0040, lo: 0xba, hi: 0xbf},
// Block 0xc3, offset 0x5f9
{value: 0x0000, lo: 0x02},
{value: 0x0008, lo: 0x80, hi: 0x89},
{value: 0x0040, lo: 0x8a, hi: 0xbf},
// Block 0xc4, offset 0x5fc
{value: 0x0000, lo: 0x0b},
{value: 0x0008, lo: 0x80, hi: 0x9a},
{value: 0x0040, lo: 0x9b, hi: 0x9c},
{value: 0x3308, lo: 0x9d, hi: 0x9f},
{value: 0x3008, lo: 0xa0, hi: 0xa1},
{value: 0x3308, lo: 0xa2, hi: 0xa5},
{value: 0x3008, lo: 0xa6, hi: 0xa6},
{value: 0x3308, lo: 0xa7, hi: 0xaa},
{value: 0x3b08, lo: 0xab, hi: 0xab},
{value: 0x0040, lo: 0xac, hi: 0xaf},
{value: 0x0008, lo: 0xb0, hi: 0xb9},
{value: 0x0018, lo: 0xba, hi: 0xbf},
// Block 0xc5, offset 0x608
{value: 0x0000, lo: 0x02},
{value: 0x0008, lo: 0x80, hi: 0x86},
{value: 0x0040, lo: 0x87, hi: 0xbf},
// Block 0xc6, offset 0x60b
{value: 0x0000, lo: 0x08},
{value: 0x0008, lo: 0x80, hi: 0xab},
{value: 0x3008, lo: 0xac, hi: 0xae},
{value: 0x3308, lo: 0xaf, hi: 0xb7},
{value: 0x3008, lo: 0xb8, hi: 0xb8},
{value: 0x3b08, lo: 0xb9, hi: 0xb9},
{value: 0x3308, lo: 0xba, hi: 0xba},
{value: 0x0018, lo: 0xbb, hi: 0xbb},
{value: 0x0040, lo: 0xbc, hi: 0xbf},
// Block 0xc7, offset 0x614
{value: 0x0000, lo: 0x02},
{value: 0x0040, lo: 0x80, hi: 0x9f},
{value: 0x049d, lo: 0xa0, hi: 0xbf},
// Block 0xc8, offset 0x617
{value: 0x0000, lo: 0x04},
{value: 0x0008, lo: 0x80, hi: 0xa9},
{value: 0x0018, lo: 0xaa, hi: 0xb2},
{value: 0x0040, lo: 0xb3, hi: 0xbe},
{value: 0x0008, lo: 0xbf, hi: 0xbf},
// Block 0xc9, offset 0x61c
{value: 0x0000, lo: 0x08},
{value: 0x3008, lo: 0x80, hi: 0x80},
{value: 0x0008, lo: 0x81, hi: 0x81},
{value: 0x3008, lo: 0x82, hi: 0x82},
{value: 0x3308, lo: 0x83, hi: 0x83},
{value: 0x0018, lo: 0x84, hi: 0x86},
{value: 0x0040, lo: 0x87, hi: 0x8f},
{value: 0x0008, lo: 0x90, hi: 0x99},
{value: 0x0040, lo: 0x9a, hi: 0xbf},
// Block 0xca, offset 0x625
{value: 0x0000, lo: 0x04},
{value: 0x0040, lo: 0x80, hi: 0x9f},
{value: 0x0008, lo: 0xa0, hi: 0xa7},
{value: 0x0040, lo: 0xa8, hi: 0xa9},
{value: 0x0008, lo: 0xaa, hi: 0xbf},
// Block 0xcb, offset 0x62a
{value: 0x0000, lo: 0x0c},
{value: 0x0008, lo: 0x80, hi: 0x90},
{value: 0x3008, lo: 0x91, hi: 0x93},
{value: 0x3308, lo: 0x94, hi: 0x97},
{value: 0x0040, lo: 0x98, hi: 0x99},
{value: 0x3308, lo: 0x9a, hi: 0x9b},
{value: 0x3008, lo: 0x9c, hi: 0x9f},
{value: 0x3b08, lo: 0xa0, hi: 0xa0},
{value: 0x0008, lo: 0xa1, hi: 0xa1},
{value: 0x0018, lo: 0xa2, hi: 0xa2},
{value: 0x0008, lo: 0xa3, hi: 0xa3},
{value: 0x3008, lo: 0xa4, hi: 0xa4},
{value: 0x0040, lo: 0xa5, hi: 0xbf},
// Block 0xcc, offset 0x637
{value: 0x0000, lo: 0x0a},
{value: 0x0008, lo: 0x80, hi: 0x80},
{value: 0x3308, lo: 0x81, hi: 0x8a},
{value: 0x0008, lo: 0x8b, hi: 0xb2},
{value: 0x3308, lo: 0xb3, hi: 0xb3},
{value: 0x3b08, lo: 0xb4, hi: 0xb4},
{value: 0x3308, lo: 0xb5, hi: 0xb8},
{value: 0x3008, lo: 0xb9, hi: 0xb9},
{value: 0x0008, lo: 0xba, hi: 0xba},
{value: 0x3308, lo: 0xbb, hi: 0xbe},
{value: 0x0018, lo: 0xbf, hi: 0xbf},
// Block 0xcd, offset 0x642
{value: 0x0000, lo: 0x08},
{value: 0x0018, lo: 0x80, hi: 0x86},
{value: 0x3b08, lo: 0x87, hi: 0x87},
{value: 0x0040, lo: 0x88, hi: 0x8f},
{value: 0x0008, lo: 0x90, hi: 0x90},
{value: 0x3308, lo: 0x91, hi: 0x96},
{value: 0x3008, lo: 0x97, hi: 0x98},
{value: 0x3308, lo: 0x99, hi: 0x9b},
{value: 0x0008, lo: 0x9c, hi: 0xbf},
// Block 0xce, offset 0x64b
{value: 0x0000, lo: 0x0a},
{value: 0x0008, lo: 0x80, hi: 0x89},
{value: 0x3308, lo: 0x8a, hi: 0x96},
{value: 0x3008, lo: 0x97, hi: 0x97},
{value: 0x3308, lo: 0x98, hi: 0x98},
{value: 0x3b08, lo: 0x99, hi: 0x99},
{value: 0x0018, lo: 0x9a, hi: 0x9c},
{value: 0x0008, lo: 0x9d, hi: 0x9d},
{value: 0x0018, lo: 0x9e, hi: 0xa2},
{value: 0x0040, lo: 0xa3, hi: 0xaf},
{value: 0x0008, lo: 0xb0, hi: 0xbf},
// Block 0xcf, offset 0x656
{value: 0x0000, lo: 0x02},
{value: 0x0008, lo: 0x80, hi: 0xb8},
{value: 0x0040, lo: 0xb9, hi: 0xbf},
// Block 0xd0, offset 0x659
{value: 0x0000, lo: 0x02},
{value: 0x0018, lo: 0x80, hi: 0x89},
{value: 0x0040, lo: 0x8a, hi: 0xbf},
// Block 0xd1, offset 0x65c
{value: 0x0000, lo: 0x09},
{value: 0x0008, lo: 0x80, hi: 0x88},
{value: 0x0040, lo: 0x89, hi: 0x89},
{value: 0x0008, lo: 0x8a, hi: 0xae},
{value: 0x3008, lo: 0xaf, hi: 0xaf},
{value: 0x3308, lo: 0xb0, hi: 0xb6},
{value: 0x0040, lo: 0xb7, hi: 0xb7},
{value: 0x3308, lo: 0xb8, hi: 0xbd},
{value: 0x3008, lo: 0xbe, hi: 0xbe},
{value: 0x3b08, lo: 0xbf, hi: 0xbf},
// Block 0xd2, offset 0x666
{value: 0x0000, lo: 0x08},
{value: 0x0008, lo: 0x80, hi: 0x80},
{value: 0x0018, lo: 0x81, hi: 0x85},
{value: 0x0040, lo: 0x86, hi: 0x8f},
{value: 0x0008, lo: 0x90, hi: 0x99},
{value: 0x0018, lo: 0x9a, hi: 0xac},
{value: 0x0040, lo: 0xad, hi: 0xaf},
{value: 0x0018, lo: 0xb0, hi: 0xb1},
{value: 0x0008, lo: 0xb2, hi: 0xbf},
// Block 0xd3, offset 0x66f
{value: 0x0000, lo: 0x0b},
{value: 0x0008, lo: 0x80, hi: 0x8f},
{value: 0x0040, lo: 0x90, hi: 0x91},
{value: 0x3308, lo: 0x92, hi: 0xa7},
{value: 0x0040, lo: 0xa8, hi: 0xa8},
{value: 0x3008, lo: 0xa9, hi: 0xa9},
{value: 0x3308, lo: 0xaa, hi: 0xb0},
{value: 0x3008, lo: 0xb1, hi: 0xb1},
{value: 0x3308, lo: 0xb2, hi: 0xb3},
{value: 0x3008, lo: 0xb4, hi: 0xb4},
{value: 0x3308, lo: 0xb5, hi: 0xb6},
{value: 0x0040, lo: 0xb7, hi: 0xbf},
// Block 0xd4, offset 0x67b
{value: 0x0000, lo: 0x0c},
{value: 0x0008, lo: 0x80, hi: 0x86},
{value: 0x0040, lo: 0x87, hi: 0x87},
{value: 0x0008, lo: 0x88, hi: 0x89},
{value: 0x0040, lo: 0x8a, hi: 0x8a},
{value: 0x0008, lo: 0x8b, hi: 0xb0},
{value: 0x3308, lo: 0xb1, hi: 0xb6},
{value: 0x0040, lo: 0xb7, hi: 0xb9},
{value: 0x3308, lo: 0xba, hi: 0xba},
{value: 0x0040, lo: 0xbb, hi: 0xbb},
{value: 0x3308, lo: 0xbc, hi: 0xbd},
{value: 0x0040, lo: 0xbe, hi: 0xbe},
{value: 0x3308, lo: 0xbf, hi: 0xbf},
// Block 0xd5, offset 0x688
{value: 0x0000, lo: 0x0c},
{value: 0x3308, lo: 0x80, hi: 0x83},
{value: 0x3b08, lo: 0x84, hi: 0x85},
{value: 0x0008, lo: 0x86, hi: 0x86},
{value: 0x3308, lo: 0x87, hi: 0x87},
{value: 0x0040, lo: 0x88, hi: 0x8f},
{value: 0x0008, lo: 0x90, hi: 0x99},
{value: 0x0040, lo: 0x9a, hi: 0x9f},
{value: 0x0008, lo: 0xa0, hi: 0xa5},
{value: 0x0040, lo: 0xa6, hi: 0xa6},
{value: 0x0008, lo: 0xa7, hi: 0xa8},
{value: 0x0040, lo: 0xa9, hi: 0xa9},
{value: 0x0008, lo: 0xaa, hi: 0xbf},
// Block 0xd6, offset 0x695
{value: 0x0000, lo: 0x0d},
{value: 0x0008, lo: 0x80, hi: 0x89},
{value: 0x3008, lo: 0x8a, hi: 0x8e},
{value: 0x0040, lo: 0x8f, hi: 0x8f},
{value: 0x3308, lo: 0x90, hi: 0x91},
{value: 0x0040, lo: 0x92, hi: 0x92},
{value: 0x3008, lo: 0x93, hi: 0x94},
{value: 0x3308, lo: 0x95, hi: 0x95},
{value: 0x3008, lo: 0x96, hi: 0x96},
{value: 0x3b08, lo: 0x97, hi: 0x97},
{value: 0x0008, lo: 0x98, hi: 0x98},
{value: 0x0040, lo: 0x99, hi: 0x9f},
{value: 0x0008, lo: 0xa0, hi: 0xa9},
{value: 0x0040, lo: 0xaa, hi: 0xbf},
// Block 0xd7, offset 0x6a3
{value: 0x0000, lo: 0x06},
{value: 0x0040, lo: 0x80, hi: 0x9f},
{value: 0x0008, lo: 0xa0, hi: 0xb2},
{value: 0x3308, lo: 0xb3, hi: 0xb4},
{value: 0x3008, lo: 0xb5, hi: 0xb6},
{value: 0x0018, lo: 0xb7, hi: 0xb8},
{value: 0x0040, lo: 0xb9, hi: 0xbf},
// Block 0xd8, offset 0x6aa
{value: 0x0000, lo: 0x0a},
{value: 0x3308, lo: 0x80, hi: 0x81},
{value: 0x0008, lo: 0x82, hi: 0x82},
{value: 0x3008, lo: 0x83, hi: 0x83},
{value: 0x0008, lo: 0x84, hi: 0x90},
{value: 0x0040, lo: 0x91, hi: 0x91},
{value: 0x0008, lo: 0x92, hi: 0xb3},
{value: 0x3008, lo: 0xb4, hi: 0xb5},
{value: 0x3308, lo: 0xb6, hi: 0xba},
{value: 0x0040, lo: 0xbb, hi: 0xbd},
{value: 0x3008, lo: 0xbe, hi: 0xbf},
// Block 0xd9, offset 0x6b5
{value: 0x0000, lo: 0x06},
{value: 0x3308, lo: 0x80, hi: 0x80},
{value: 0x3808, lo: 0x81, hi: 0x81},
{value: 0x3b08, lo: 0x82, hi: 0x82},
{value: 0x0018, lo: 0x83, hi: 0x8f},
{value: 0x0008, lo: 0x90, hi: 0x99},
{value: 0x0040, lo: 0x9a, hi: 0xbf},
// Block 0xda, offset 0x6bc
{value: 0x0000, lo: 0x03},
{value: 0x0040, lo: 0x80, hi: 0xaf},
{value: 0x0008, lo: 0xb0, hi: 0xb0},
{value: 0x0040, lo: 0xb1, hi: 0xbf},
// Block 0xdb, offset 0x6c0
{value: 0x0000, lo: 0x03},
{value: 0x0018, lo: 0x80, hi: 0xb1},
{value: 0x0040, lo: 0xb2, hi: 0xbe},
{value: 0x0018, lo: 0xbf, hi: 0xbf},
// Block 0xdc, offset 0x6c4
{value: 0x0000, lo: 0x02},
{value: 0x0008, lo: 0x80, hi: 0x99},
{value: 0x0040, lo: 0x9a, hi: 0xbf},
// Block 0xdd, offset 0x6c7
{value: 0x0000, lo: 0x04},
{value: 0x0018, lo: 0x80, hi: 0xae},
{value: 0x0040, lo: 0xaf, hi: 0xaf},
{value: 0x0018, lo: 0xb0, hi: 0xb4},
{value: 0x0040, lo: 0xb5, hi: 0xbf},
// Block 0xde, offset 0x6cc
{value: 0x0000, lo: 0x02},
{value: 0x0008, lo: 0x80, hi: 0x83},
{value: 0x0040, lo: 0x84, hi: 0xbf},
// Block 0xdf, offset 0x6cf
{value: 0x0000, lo: 0x02},
{value: 0x0040, lo: 0x80, hi: 0x8f},
{value: 0x0008, lo: 0x90, hi: 0xbf},
// Block 0xe0, offset 0x6d2
{value: 0x0000, lo: 0x03},
{value: 0x0008, lo: 0x80, hi: 0xb0},
{value: 0x0018, lo: 0xb1, hi: 0xb2},
{value: 0x0040, lo: 0xb3, hi: 0xbf},
// Block 0xe1, offset 0x6d6
{value: 0x0000, lo: 0x02},
{value: 0x0008, lo: 0x80, hi: 0xaf},
{value: 0x0340, lo: 0xb0, hi: 0xbf},
// Block 0xe2, offset 0x6d9
{value: 0x0000, lo: 0x04},
{value: 0x3308, lo: 0x80, hi: 0x80},
{value: 0x0008, lo: 0x81, hi: 0x86},
{value: 0x3308, lo: 0x87, hi: 0x95},
{value: 0x0040, lo: 0x96, hi: 0xbf},
// Block 0xe3, offset 0x6de
{value: 0x0000, lo: 0x06},
{value: 0x0008, lo: 0x80, hi: 0x9e},
{value: 0x0040, lo: 0x9f, hi: 0x9f},
{value: 0x0008, lo: 0xa0, hi: 0xa9},
{value: 0x0040, lo: 0xaa, hi: 0xad},
{value: 0x0018, lo: 0xae, hi: 0xaf},
{value: 0x0008, lo: 0xb0, hi: 0xbf},
// Block 0xe4, offset 0x6e5
{value: 0x0000, lo: 0x02},
{value: 0x0008, lo: 0x80, hi: 0xbe},
{value: 0x0040, lo: 0xbf, hi: 0xbf},
// Block 0xe5, offset 0x6e8
{value: 0x0000, lo: 0x07},
{value: 0x0008, lo: 0x80, hi: 0x89},
{value: 0x0040, lo: 0x8a, hi: 0x8f},
{value: 0x0008, lo: 0x90, hi: 0xad},
{value: 0x0040, lo: 0xae, hi: 0xaf},
{value: 0x3308, lo: 0xb0, hi: 0xb4},
{value: 0x0018, lo: 0xb5, hi: 0xb5},
{value: 0x0040, lo: 0xb6, hi: 0xbf},
// Block 0xe6, offset 0x6f0
{value: 0x0000, lo: 0x03},
{value: 0x0008, lo: 0x80, hi: 0xaf},
{value: 0x3308, lo: 0xb0, hi: 0xb6},
{value: 0x0018, lo: 0xb7, hi: 0xbf},
// Block 0xe7, offset 0x6f4
{value: 0x0000, lo: 0x0a},
{value: 0x0008, lo: 0x80, hi: 0x83},
{value: 0x0018, lo: 0x84, hi: 0x85},
{value: 0x0040, lo: 0x86, hi: 0x8f},
{value: 0x0008, lo: 0x90, hi: 0x99},
{value: 0x0040, lo: 0x9a, hi: 0x9a},
{value: 0x0018, lo: 0x9b, hi: 0xa1},
{value: 0x0040, lo: 0xa2, hi: 0xa2},
{value: 0x0008, lo: 0xa3, hi: 0xb7},
{value: 0x0040, lo: 0xb8, hi: 0xbc},
{value: 0x0008, lo: 0xbd, hi: 0xbf},
// Block 0xe8, offset 0x6ff
{value: 0x0000, lo: 0x02},
{value: 0x0008, lo: 0x80, hi: 0x8f},
{value: 0x0040, lo: 0x90, hi: 0xbf},
// Block 0xe9, offset 0x702
{value: 0x0000, lo: 0x02},
{value: 0xe105, lo: 0x80, hi: 0x9f},
{value: 0x0008, lo: 0xa0, hi: 0xbf},
// Block 0xea, offset 0x705
{value: 0x0000, lo: 0x02},
{value: 0x0018, lo: 0x80, hi: 0x9a},
{value: 0x0040, lo: 0x9b, hi: 0xbf},
// Block 0xeb, offset 0x708
{value: 0x0000, lo: 0x05},
{value: 0x0008, lo: 0x80, hi: 0x8a},
{value: 0x0040, lo: 0x8b, hi: 0x8e},
{value: 0x3308, lo: 0x8f, hi: 0x8f},
{value: 0x0008, lo: 0x90, hi: 0x90},
{value: 0x3008, lo: 0x91, hi: 0xbf},
// Block 0xec, offset 0x70e
{value: 0x0000, lo: 0x05},
{value: 0x3008, lo: 0x80, hi: 0x87},
{value: 0x0040, lo: 0x88, hi: 0x8e},
{value: 0x3308, lo: 0x8f, hi: 0x92},
{value: 0x0008, lo: 0x93, hi: 0x9f},
{value: 0x0040, lo: 0xa0, hi: 0xbf},
// Block 0xed, offset 0x714
{value: 0x0000, lo: 0x08},
{value: 0x0040, lo: 0x80, hi: 0x9f},
{value: 0x0008, lo: 0xa0, hi: 0xa1},
{value: 0x0018, lo: 0xa2, hi: 0xa2},
{value: 0x0008, lo: 0xa3, hi: 0xa3},
{value: 0x3308, lo: 0xa4, hi: 0xa4},
{value: 0x0040, lo: 0xa5, hi: 0xaf},
{value: 0x3008, lo: 0xb0, hi: 0xb1},
{value: 0x0040, lo: 0xb2, hi: 0xbf},
// Block 0xee, offset 0x71d
{value: 0x0000, lo: 0x02},
{value: 0x0008, lo: 0x80, hi: 0xb7},
{value: 0x0040, lo: 0xb8, hi: 0xbf},
// Block 0xef, offset 0x720
{value: 0x0000, lo: 0x02},
{value: 0x0008, lo: 0x80, hi: 0x95},
{value: 0x0040, lo: 0x96, hi: 0xbf},
// Block 0xf0, offset 0x723
{value: 0x0000, lo: 0x02},
{value: 0x0008, lo: 0x80, hi: 0x88},
{value: 0x0040, lo: 0x89, hi: 0xbf},
// Block 0xf1, offset 0x726
{value: 0x0000, lo: 0x07},
{value: 0x0040, lo: 0x80, hi: 0xaf},
{value: 0x0008, lo: 0xb0, hi: 0xb3},
{value: 0x0040, lo: 0xb4, hi: 0xb4},
{value: 0x0008, lo: 0xb5, hi: 0xbb},
{value: 0x0040, lo: 0xbc, hi: 0xbc},
{value: 0x0008, lo: 0xbd, hi: 0xbe},
{value: 0x0040, lo: 0xbf, hi: 0xbf},
// Block 0xf2, offset 0x72e
{value: 0x0000, lo: 0x04},
{value: 0x0008, lo: 0x80, hi: 0xa2},
{value: 0x0040, lo: 0xa3, hi: 0xb1},
{value: 0x0008, lo: 0xb2, hi: 0xb2},
{value: 0x0040, lo: 0xb3, hi: 0xbf},
// Block 0xf3, offset 0x733
{value: 0x0000, lo: 0x08},
{value: 0x0040, lo: 0x80, hi: 0x8f},
{value: 0x0008, lo: 0x90, hi: 0x92},
{value: 0x0040, lo: 0x93, hi: 0x94},
{value: 0x0008, lo: 0x95, hi: 0x95},
{value: 0x0040, lo: 0x96, hi: 0xa3},
{value: 0x0008, lo: 0xa4, hi: 0xa7},
{value: 0x0040, lo: 0xa8, hi: 0xaf},
{value: 0x0008, lo: 0xb0, hi: 0xbf},
// Block 0xf4, offset 0x73c
{value: 0x0000, lo: 0x02},
{value: 0x0008, lo: 0x80, hi: 0xbb},
{value: 0x0040, lo: 0xbc, hi: 0xbf},
// Block 0xf5, offset 0x73f
{value: 0x0000, lo: 0x04},
{value: 0x0008, lo: 0x80, hi: 0xaa},
{value: 0x0040, lo: 0xab, hi: 0xaf},
{value: 0x0008, lo: 0xb0, hi: 0xbc},
{value: 0x0040, lo: 0xbd, hi: 0xbf},
// Block 0xf6, offset 0x744
{value: 0x0000, lo: 0x09},
{value: 0x0008, lo: 0x80, hi: 0x88},
{value: 0x0040, lo: 0x89, hi: 0x8f},
{value: 0x0008, lo: 0x90, hi: 0x99},
{value: 0x0040, lo: 0x9a, hi: 0x9b},
{value: 0x0018, lo: 0x9c, hi: 0x9c},
{value: 0x3308, lo: 0x9d, hi: 0x9e},
{value: 0x0018, lo: 0x9f, hi: 0x9f},
{value: 0x03c0, lo: 0xa0, hi: 0xa3},
{value: 0x0040, lo: 0xa4, hi: 0xbf},
// Block 0xf7, offset 0x74e
{value: 0x0000, lo: 0x03},
{value: 0x3308, lo: 0x80, hi: 0xad},
{value: 0x0040, lo: 0xae, hi: 0xaf},
{value: 0x3308, lo: 0xb0, hi: 0xbf},
// Block 0xf8, offset 0x752
{value: 0x0000, lo: 0x03},
{value: 0x3308, lo: 0x80, hi: 0x86},
{value: 0x0040, lo: 0x87, hi: 0x8f},
{value: 0x0018, lo: 0x90, hi: 0xbf},
// Block 0xf9, offset 0x756
{value: 0x0000, lo: 0x02},
{value: 0x0018, lo: 0x80, hi: 0x83},
{value: 0x0040, lo: 0x84, hi: 0xbf},
// Block 0xfa, offset 0x759
{value: 0x0000, lo: 0x02},
{value: 0x0018, lo: 0x80, hi: 0xb5},
{value: 0x0040, lo: 0xb6, hi: 0xbf},
// Block 0xfb, offset 0x75c
{value: 0x0000, lo: 0x03},
{value: 0x0018, lo: 0x80, hi: 0xa6},
{value: 0x0040, lo: 0xa7, hi: 0xa8},
{value: 0x0018, lo: 0xa9, hi: 0xbf},
// Block 0xfc, offset 0x760
{value: 0x0000, lo: 0x0e},
{value: 0x0018, lo: 0x80, hi: 0x9d},
{value: 0x2379, lo: 0x9e, hi: 0x9e},
{value: 0x2381, lo: 0x9f, hi: 0x9f},
{value: 0x2389, lo: 0xa0, hi: 0xa0},
{value: 0x2391, lo: 0xa1, hi: 0xa1},
{value: 0x2399, lo: 0xa2, hi: 0xa2},
{value: 0x23a1, lo: 0xa3, hi: 0xa3},
{value: 0x23a9, lo: 0xa4, hi: 0xa4},
{value: 0x3018, lo: 0xa5, hi: 0xa6},
{value: 0x3318, lo: 0xa7, hi: 0xa9},
{value: 0x0018, lo: 0xaa, hi: 0xac},
{value: 0x3018, lo: 0xad, hi: 0xb2},
{value: 0x0340, lo: 0xb3, hi: 0xba},
{value: 0x3318, lo: 0xbb, hi: 0xbf},
// Block 0xfd, offset 0x76f
{value: 0x0000, lo: 0x0b},
{value: 0x3318, lo: 0x80, hi: 0x82},
{value: 0x0018, lo: 0x83, hi: 0x84},
{value: 0x3318, lo: 0x85, hi: 0x8b},
{value: 0x0018, lo: 0x8c, hi: 0xa9},
{value: 0x3318, lo: 0xaa, hi: 0xad},
{value: 0x0018, lo: 0xae, hi: 0xba},
{value: 0x23b1, lo: 0xbb, hi: 0xbb},
{value: 0x23b9, lo: 0xbc, hi: 0xbc},
{value: 0x23c1, lo: 0xbd, hi: 0xbd},
{value: 0x23c9, lo: 0xbe, hi: 0xbe},
{value: 0x23d1, lo: 0xbf, hi: 0xbf},
// Block 0xfe, offset 0x77b
{value: 0x0000, lo: 0x03},
{value: 0x23d9, lo: 0x80, hi: 0x80},
{value: 0x0018, lo: 0x81, hi: 0xaa},
{value: 0x0040, lo: 0xab, hi: 0xbf},
// Block 0xff, offset 0x77f
{value: 0x0000, lo: 0x04},
{value: 0x0018, lo: 0x80, hi: 0x81},
{value: 0x3318, lo: 0x82, hi: 0x84},
{value: 0x0018, lo: 0x85, hi: 0x85},
{value: 0x0040, lo: 0x86, hi: 0xbf},
// Block 0x100, offset 0x784
{value: 0x0000, lo: 0x04},
{value: 0x0018, lo: 0x80, hi: 0x93},
{value: 0x0040, lo: 0x94, hi: 0x9f},
{value: 0x0018, lo: 0xa0, hi: 0xb3},
{value: 0x0040, lo: 0xb4, hi: 0xbf},
// Block 0x101, offset 0x789
{value: 0x0000, lo: 0x04},
{value: 0x0018, lo: 0x80, hi: 0x96},
{value: 0x0040, lo: 0x97, hi: 0x9f},
{value: 0x0018, lo: 0xa0, hi: 0xb8},
{value: 0x0040, lo: 0xb9, hi: 0xbf},
// Block 0x102, offset 0x78e
{value: 0x0000, lo: 0x03},
{value: 0x3308, lo: 0x80, hi: 0xb6},
{value: 0x0018, lo: 0xb7, hi: 0xba},
{value: 0x3308, lo: 0xbb, hi: 0xbf},
// Block 0x103, offset 0x792
{value: 0x0000, lo: 0x04},
{value: 0x3308, lo: 0x80, hi: 0xac},
{value: 0x0018, lo: 0xad, hi: 0xb4},
{value: 0x3308, lo: 0xb5, hi: 0xb5},
{value: 0x0018, lo: 0xb6, hi: 0xbf},
// Block 0x104, offset 0x797
{value: 0x0000, lo: 0x08},
{value: 0x0018, lo: 0x80, hi: 0x83},
{value: 0x3308, lo: 0x84, hi: 0x84},
{value: 0x0018, lo: 0x85, hi: 0x8b},
{value: 0x0040, lo: 0x8c, hi: 0x9a},
{value: 0x3308, lo: 0x9b, hi: 0x9f},
{value: 0x0040, lo: 0xa0, hi: 0xa0},
{value: 0x3308, lo: 0xa1, hi: 0xaf},
{value: 0x0040, lo: 0xb0, hi: 0xbf},
// Block 0x105, offset 0x7a0
{value: 0x0000, lo: 0x04},
{value: 0x0008, lo: 0x80, hi: 0x9e},
{value: 0x0040, lo: 0x9f, hi: 0xa4},
{value: 0x0008, lo: 0xa5, hi: 0xaa},
{value: 0x0040, lo: 0xab, hi: 0xbf},
// Block 0x106, offset 0x7a5
{value: 0x0000, lo: 0x03},
{value: 0x0040, lo: 0x80, hi: 0x8e},
{value: 0x3308, lo: 0x8f, hi: 0x8f},
{value: 0x0040, lo: 0x90, hi: 0xbf},
// Block 0x107, offset 0x7a9
{value: 0x0000, lo: 0x05},
{value: 0x0008, lo: 0x80, hi: 0xac},
{value: 0x0040, lo: 0xad, hi: 0xaf},
{value: 0x3308, lo: 0xb0, hi: 0xb6},
{value: 0x0008, lo: 0xb7, hi: 0xbd},
{value: 0x0040, lo: 0xbe, hi: 0xbf},
// Block 0x108, offset 0x7af
{value: 0x0000, lo: 0x05},
{value: 0x0008, lo: 0x80, hi: 0x89},
{value: 0x0040, lo: 0x8a, hi: 0x8d},
{value: 0x0008, lo: 0x8e, hi: 0x8e},
{value: 0x0018, lo: 0x8f, hi: 0x8f},
{value: 0x0040, lo: 0x90, hi: 0xbf},
// Block 0x109, offset 0x7b5
{value: 0x0000, lo: 0x04},
{value: 0x0040, lo: 0x80, hi: 0x8f},
{value: 0x0008, lo: 0x90, hi: 0xad},
{value: 0x3308, lo: 0xae, hi: 0xae},
{value: 0x0040, lo: 0xaf, hi: 0xbf},
// Block 0x10a, offset 0x7ba
{value: 0x0000, lo: 0x05},
{value: 0x0008, lo: 0x80, hi: 0xab},
{value: 0x3308, lo: 0xac, hi: 0xaf},
{value: 0x0008, lo: 0xb0, hi: 0xb9},
{value: 0x0040, lo: 0xba, hi: 0xbe},
{value: 0x0018, lo: 0xbf, hi: 0xbf},
// Block 0x10b, offset 0x7c0
{value: 0x0000, lo: 0x05},
{value: 0x0040, lo: 0x80, hi: 0x8f},
{value: 0x0008, lo: 0x90, hi: 0xab},
{value: 0x3308, lo: 0xac, hi: 0xaf},
{value: 0x0008, lo: 0xb0, hi: 0xb9},
{value: 0x0040, lo: 0xba, hi: 0xbf},
// Block 0x10c, offset 0x7c6
{value: 0x0000, lo: 0x09},
{value: 0x0040, lo: 0x80, hi: 0x9f},
{value: 0x0008, lo: 0xa0, hi: 0xa6},
{value: 0x0040, lo: 0xa7, hi: 0xa7},
{value: 0x0008, lo: 0xa8, hi: 0xab},
{value: 0x0040, lo: 0xac, hi: 0xac},
{value: 0x0008, lo: 0xad, hi: 0xae},
{value: 0x0040, lo: 0xaf, hi: 0xaf},
{value: 0x0008, lo: 0xb0, hi: 0xbe},
{value: 0x0040, lo: 0xbf, hi: 0xbf},
// Block 0x10d, offset 0x7d0
{value: 0x0000, lo: 0x05},
{value: 0x0808, lo: 0x80, hi: 0x84},
{value: 0x0040, lo: 0x85, hi: 0x86},
{value: 0x0818, lo: 0x87, hi: 0x8f},
{value: 0x3308, lo: 0x90, hi: 0x96},
{value: 0x0040, lo: 0x97, hi: 0xbf},
// Block 0x10e, offset 0x7d6
{value: 0x0000, lo: 0x08},
{value: 0x0a08, lo: 0x80, hi: 0x83},
{value: 0x3308, lo: 0x84, hi: 0x8a},
{value: 0x0b08, lo: 0x8b, hi: 0x8b},
{value: 0x0040, lo: 0x8c, hi: 0x8f},
{value: 0x0808, lo: 0x90, hi: 0x99},
{value: 0x0040, lo: 0x9a, hi: 0x9d},
{value: 0x0818, lo: 0x9e, hi: 0x9f},
{value: 0x0040, lo: 0xa0, hi: 0xbf},
// Block 0x10f, offset 0x7df
{value: 0x0000, lo: 0x02},
{value: 0x0040, lo: 0x80, hi: 0xb0},
{value: 0x0818, lo: 0xb1, hi: 0xbf},
// Block 0x110, offset 0x7e2
{value: 0x0000, lo: 0x02},
{value: 0x0818, lo: 0x80, hi: 0xb4},
{value: 0x0040, lo: 0xb5, hi: 0xbf},
// Block 0x111, offset 0x7e5
{value: 0x0000, lo: 0x03},
{value: 0x0040, lo: 0x80, hi: 0x80},
{value: 0x0818, lo: 0x81, hi: 0xbd},
{value: 0x0040, lo: 0xbe, hi: 0xbf},
// Block 0x112, offset 0x7e9
{value: 0x0000, lo: 0x03},
{value: 0x0040, lo: 0x80, hi: 0xaf},
{value: 0x0018, lo: 0xb0, hi: 0xb1},
{value: 0x0040, lo: 0xb2, hi: 0xbf},
// Block 0x113, offset 0x7ed
{value: 0x0000, lo: 0x03},
{value: 0x0018, lo: 0x80, hi: 0xab},
{value: 0x0040, lo: 0xac, hi: 0xaf},
{value: 0x0018, lo: 0xb0, hi: 0xbf},
// Block 0x114, offset 0x7f1
{value: 0x0000, lo: 0x05},
{value: 0x0018, lo: 0x80, hi: 0x93},
{value: 0x0040, lo: 0x94, hi: 0x9f},
{value: 0x0018, lo: 0xa0, hi: 0xae},
{value: 0x0040, lo: 0xaf, hi: 0xb0},
{value: 0x0018, lo: 0xb1, hi: 0xbf},
// Block 0x115, offset 0x7f7
{value: 0x0000, lo: 0x05},
{value: 0x0040, lo: 0x80, hi: 0x80},
{value: 0x0018, lo: 0x81, hi: 0x8f},
{value: 0x0040, lo: 0x90, hi: 0x90},
{value: 0x0018, lo: 0x91, hi: 0xb5},
{value: 0x0040, lo: 0xb6, hi: 0xbf},
// Block 0x116, offset 0x7fd
{value: 0x0000, lo: 0x04},
{value: 0x0018, lo: 0x80, hi: 0x8f},
{value: 0x2709, lo: 0x90, hi: 0x90},
{value: 0x0018, lo: 0x91, hi: 0xad},
{value: 0x0040, lo: 0xae, hi: 0xbf},
// Block 0x117, offset 0x802
{value: 0x0000, lo: 0x02},
{value: 0x0040, lo: 0x80, hi: 0xa5},
{value: 0x0018, lo: 0xa6, hi: 0xbf},
// Block 0x118, offset 0x805
{value: 0x0000, lo: 0x0f},
{value: 0x2889, lo: 0x80, hi: 0x80},
{value: 0x2891, lo: 0x81, hi: 0x81},
{value: 0x2899, lo: 0x82, hi: 0x82},
{value: 0x28a1, lo: 0x83, hi: 0x83},
{value: 0x28a9, lo: 0x84, hi: 0x84},
{value: 0x28b1, lo: 0x85, hi: 0x85},
{value: 0x28b9, lo: 0x86, hi: 0x86},
{value: 0x28c1, lo: 0x87, hi: 0x87},
{value: 0x28c9, lo: 0x88, hi: 0x88},
{value: 0x0040, lo: 0x89, hi: 0x8f},
{value: 0x28d1, lo: 0x90, hi: 0x90},
{value: 0x28d9, lo: 0x91, hi: 0x91},
{value: 0x0040, lo: 0x92, hi: 0x9f},
{value: 0x0018, lo: 0xa0, hi: 0xa5},
{value: 0x0040, lo: 0xa6, hi: 0xbf},
// Block 0x119, offset 0x815
{value: 0x0000, lo: 0x06},
{value: 0x0018, lo: 0x80, hi: 0x97},
{value: 0x0040, lo: 0x98, hi: 0x9b},
{value: 0x0018, lo: 0x9c, hi: 0xac},
{value: 0x0040, lo: 0xad, hi: 0xaf},
{value: 0x0018, lo: 0xb0, hi: 0xbc},
{value: 0x0040, lo: 0xbd, hi: 0xbf},
// Block 0x11a, offset 0x81c
{value: 0x0000, lo: 0x03},
{value: 0x0018, lo: 0x80, hi: 0xb6},
{value: 0x0040, lo: 0xb7, hi: 0xba},
{value: 0x0018, lo: 0xbb, hi: 0xbf},
// Block 0x11b, offset 0x820
{value: 0x0000, lo: 0x06},
{value: 0x0018, lo: 0x80, hi: 0x99},
{value: 0x0040, lo: 0x9a, hi: 0x9f},
{value: 0x0018, lo: 0xa0, hi: 0xab},
{value: 0x0040, lo: 0xac, hi: 0xaf},
{value: 0x0018, lo: 0xb0, hi: 0xb0},
{value: 0x0040, lo: 0xb1, hi: 0xbf},
// Block 0x11c, offset 0x827
{value: 0x0000, lo: 0x03},
{value: 0x0018, lo: 0x80, hi: 0x8b},
{value: 0x0040, lo: 0x8c, hi: 0x8f},
{value: 0x0018, lo: 0x90, hi: 0xbf},
// Block 0x11d, offset 0x82b
{value: 0x0000, lo: 0x05},
{value: 0x0018, lo: 0x80, hi: 0x87},
{value: 0x0040, lo: 0x88, hi: 0x8f},
{value: 0x0018, lo: 0x90, hi: 0x99},
{value: 0x0040, lo: 0x9a, hi: 0x9f},
{value: 0x0018, lo: 0xa0, hi: 0xbf},
// Block 0x11e, offset 0x831
{value: 0x0000, lo: 0x06},
{value: 0x0018, lo: 0x80, hi: 0x87},
{value: 0x0040, lo: 0x88, hi: 0x8f},
{value: 0x0018, lo: 0x90, hi: 0xad},
{value: 0x0040, lo: 0xae, hi: 0xaf},
{value: 0x0018, lo: 0xb0, hi: 0xb1},
{value: 0x0040, lo: 0xb2, hi: 0xbf},
// Block 0x11f, offset 0x838
{value: 0x0000, lo: 0x06},
{value: 0x0018, lo: 0x80, hi: 0x93},
{value: 0x0040, lo: 0x94, hi: 0x9f},
{value: 0x0018, lo: 0xa0, hi: 0xad},
{value: 0x0040, lo: 0xae, hi: 0xaf},
{value: 0x0018, lo: 0xb0, hi: 0xbc},
{value: 0x0040, lo: 0xbd, hi: 0xbf},
// Block 0x120, offset 0x83f
{value: 0x0000, lo: 0x05},
{value: 0x0018, lo: 0x80, hi: 0x88},
{value: 0x0040, lo: 0x89, hi: 0x8f},
{value: 0x0018, lo: 0x90, hi: 0xbd},
{value: 0x0040, lo: 0xbe, hi: 0xbe},
{value: 0x0018, lo: 0xbf, hi: 0xbf},
// Block 0x121, offset 0x845
{value: 0x0000, lo: 0x08},
{value: 0x0018, lo: 0x80, hi: 0x85},
{value: 0x0040, lo: 0x86, hi: 0x8d},
{value: 0x0018, lo: 0x8e, hi: 0x9b},
{value: 0x0040, lo: 0x9c, hi: 0x9f},
{value: 0x0018, lo: 0xa0, hi: 0xa8},
{value: 0x0040, lo: 0xa9, hi: 0xaf},
{value: 0x0018, lo: 0xb0, hi: 0xb8},
{value: 0x0040, lo: 0xb9, hi: 0xbf},
// Block 0x122, offset 0x84e
{value: 0x0000, lo: 0x03},
{value: 0x0018, lo: 0x80, hi: 0x92},
{value: 0x0040, lo: 0x93, hi: 0x93},
{value: 0x0018, lo: 0x94, hi: 0xbf},
// Block 0x123, offset 0x852
{value: 0x0000, lo: 0x0d},
{value: 0x0018, lo: 0x80, hi: 0x8a},
{value: 0x0040, lo: 0x8b, hi: 0xaf},
{value: 0x06e1, lo: 0xb0, hi: 0xb0},
{value: 0x0049, lo: 0xb1, hi: 0xb1},
{value: 0x0029, lo: 0xb2, hi: 0xb2},
{value: 0x0031, lo: 0xb3, hi: 0xb3},
{value: 0x06e9, lo: 0xb4, hi: 0xb4},
{value: 0x06f1, lo: 0xb5, hi: 0xb5},
{value: 0x06f9, lo: 0xb6, hi: 0xb6},
{value: 0x0701, lo: 0xb7, hi: 0xb7},
{value: 0x0709, lo: 0xb8, hi: 0xb8},
{value: 0x0711, lo: 0xb9, hi: 0xb9},
{value: 0x0040, lo: 0xba, hi: 0xbf},
// Block 0x124, offset 0x860
{value: 0x0000, lo: 0x02},
{value: 0x0008, lo: 0x80, hi: 0x9f},
{value: 0x0040, lo: 0xa0, hi: 0xbf},
// Block 0x125, offset 0x863
{value: 0x0000, lo: 0x02},
{value: 0x0008, lo: 0x80, hi: 0xb9},
{value: 0x0040, lo: 0xba, hi: 0xbf},
// Block 0x126, offset 0x866
{value: 0x0000, lo: 0x03},
{value: 0x0008, lo: 0x80, hi: 0x9d},
{value: 0x0040, lo: 0x9e, hi: 0x9f},
{value: 0x0008, lo: 0xa0, hi: 0xbf},
// Block 0x127, offset 0x86a
{value: 0x0000, lo: 0x03},
{value: 0x0008, lo: 0x80, hi: 0xa1},
{value: 0x0040, lo: 0xa2, hi: 0xaf},
{value: 0x0008, lo: 0xb0, hi: 0xbf},
// Block 0x128, offset 0x86e
{value: 0x0000, lo: 0x02},
{value: 0x0008, lo: 0x80, hi: 0xa0},
{value: 0x0040, lo: 0xa1, hi: 0xbf},
// Block 0x129, offset 0x871
{value: 0x0000, lo: 0x03},
{value: 0x0008, lo: 0x80, hi: 0x8a},
{value: 0x0040, lo: 0x8b, hi: 0x8f},
{value: 0x0008, lo: 0x90, hi: 0xbf},
// Block 0x12a, offset 0x875
{value: 0x0000, lo: 0x02},
{value: 0x0008, lo: 0x80, hi: 0xaf},
{value: 0x0040, lo: 0xb0, hi: 0xbf},
// Block 0x12b, offset 0x878
{value: 0x0000, lo: 0x04},
{value: 0x0040, lo: 0x80, hi: 0x80},
{value: 0x0340, lo: 0x81, hi: 0x81},
{value: 0x0040, lo: 0x82, hi: 0x9f},
{value: 0x0340, lo: 0xa0, hi: 0xbf},
// Block 0x12c, offset 0x87d
{value: 0x0000, lo: 0x01},
{value: 0x0340, lo: 0x80, hi: 0xbf},
// Block 0x12d, offset 0x87f
{value: 0x0000, lo: 0x01},
{value: 0x33c0, lo: 0x80, hi: 0xbf},
// Block 0x12e, offset 0x881
{value: 0x0000, lo: 0x02},
{value: 0x33c0, lo: 0x80, hi: 0xaf},
{value: 0x0040, lo: 0xb0, hi: 0xbf},
}
// Total table size 46723 bytes (45KiB); checksum: 4CF3143A
```
|
```javascript
function function_declaration()
// this is a function
{
return 42
}
(function named()
// this is a function
{
return 42
})();
(function ()
// this is a function
{
return 42
})();
/* anonymous declaration */
export default function ()
// this is a function
{
return 42
}
a = {
foo()
// this is a function
{},
bar: function()
// this is a function
{},
}
```
|
```xml
<clickhouse>
<mqs>99999</mqs>
<users_1>
<user_1>
<password></password>
<profile>default</profile>
</user_1>
</users_1>
<users_2>
<user_2>
<password></password>
<profile>default</profile>
</user_2>
</users_2>
</clickhouse>
```
|
```python
#! /usr/bin/env python
# coding: utf-8
# Lefteris Karapetsas copied this from here:
# path_to_url
# so that I can include a python-only keccak implementation for the DAO tests
# without having users of the tests download external packages using pip
# The Keccak sponge function was designed by Guido Bertoni, Joan Daemen,
# Michal Peeters and Gilles Van Assche. For more information, feedback or
# questions, please refer to their website: path_to_url
#
# Based on the implementation by Renaud Bauvin,
# from path_to_url
#
# Modified by Moshe Kaplan to be hashlib-compliant
#
# To the extent possible under law, the implementer has waived all copyright
# and related or neighboring rights to the source code in this file.
# path_to_url
import math
def sha3_224(data=None):
return Keccak(c=448, r=1152, n=224, data=data)
def sha3_256(data=None):
return Keccak(c=512, r=1088, n=256, data=data)
def sha3_384(data=None):
return Keccak(c=768, r=832, n=384, data=data)
def sha3_512(data=None):
return Keccak(c=1024, r=576, n=512, data=data)
class KeccakError(Exception):
"""Custom error Class used in the Keccak implementation"""
def __init__(self, value):
self.value = value
def __str__(self):
return repr(self.value)
class Keccak:
def __init__(self, r, c, n, data=None):
# Initialize the constants used throughout Keccak
# bitrate
self.r = r
# capacity
self.c = c
# output size
self.n = n
self.b = r + c
# b = 25*w
self.w = self.b // 25
# 2**l = w
self.l = int(math.log(self.w, 2))
self.n_r = 12 + 2 * self.l
self.block_size = r
self.digest_size = n
# Initialize the state of the sponge
# The state is made up of 25 words, each word being w bits.
self.S = [[0, 0, 0, 0, 0],
[0, 0, 0, 0, 0],
[0, 0, 0, 0, 0],
[0, 0, 0, 0, 0],
[0, 0, 0, 0, 0]]
# A string of hexchars, where each char represents 4 bits.
self.buffered_data = ""
# Store the calculated digest.
# We'll only apply padding and recalculate the hash if it's modified.
self.last_digest = None
if data:
self.update(data)
# Constants
# Round constants
RC = [0x0000000000000001,
0x0000000000008082,
0x800000000000808A,
0x8000000080008000,
0x000000000000808B,
0x0000000080000001,
0x8000000080008081,
0x8000000000008009,
0x000000000000008A,
0x0000000000000088,
0x0000000080008009,
0x000000008000000A,
0x000000008000808B,
0x800000000000008B,
0x8000000000008089,
0x8000000000008003,
0x8000000000008002,
0x8000000000000080,
0x000000000000800A,
0x800000008000000A,
0x8000000080008081,
0x8000000000008080,
0x0000000080000001,
0x8000000080008008]
# Rotation offsets
r = [[0, 36, 3, 41, 18],
[1, 44, 10, 45, 2],
[62, 6, 43, 15, 61],
[28, 55, 25, 21, 56],
[27, 20, 39, 8, 14]]
@staticmethod
def Round(A, RCfixed, w):
"""Perform one round of computation as defined in the Keccak-f permutation
A: current state (5x5 matrix)
RCfixed: value of round constant to use (integer)
"""
# Initialization of temporary variables
B = [[0, 0, 0, 0, 0],
[0, 0, 0, 0, 0],
[0, 0, 0, 0, 0],
[0, 0, 0, 0, 0],
[0, 0, 0, 0, 0]]
C = [0, 0, 0, 0, 0]
D = [0, 0, 0, 0, 0]
# Theta step
for x in range(5):
C[x] = A[x][0] ^ A[x][1] ^ A[x][2] ^ A[x][3] ^ A[x][4]
for x in range(5):
D[x] = C[(x - 1) % 5] ^ _rot(C[(x + 1) % 5], 1, w)
for x in range(5):
for y in range(5):
A[x][y] = A[x][y] ^ D[x]
# Rho and Pi steps
for x in range(5):
for y in range(5):
B[y][(2 * x + 3 * y) % 5] = _rot(A[x][y], Keccak.r[x][y], w)
# Chi step
for x in range(5):
for y in range(5):
A[x][y] = B[x][y] ^ ((~B[(x + 1) % 5][y]) & B[(x + 2) % 5][y])
# Iota step
A[0][0] = A[0][0] ^ RCfixed
return A
@staticmethod
def KeccakF(A, n_r, w):
"""Perform Keccak-f function on the state A
A: 5x5 matrix containing the state, where each entry is a string of
hexchars that is 'w' bits long
n_r: number of rounds
w: word size
"""
for i in xrange(n_r):
A = Keccak.Round(A, Keccak.RC[i] % (1 << w), w)
return A
# Padding rule
# This is a disgusting piece of code. Clean it.
@staticmethod
def pad10star1(M, n):
"""Pad M with the pad10*1 padding rule to reach a length multiple of r bits
M: message pair (length in bits, string of hex characters ('9AFC...')
n: length in bits (must be a multiple of 8)
Example: pad10star1([60, 'BA594E0FB9EBBD30'],8) returns 'BA594E0FB9EBBD93'
"""
[my_string_length, my_string] = M
# Check the parameter n
if n % 8 != 0:
raise KeccakError.KeccakError("n must be a multiple of 8")
# Check the length of the provided string
if len(my_string) % 2 != 0:
# Pad with one '0' to reach correct length (don't know test
# vectors coding)
my_string += '0'
if my_string_length > (len(my_string) // 2 * 8):
raise KeccakError.KeccakError(
"the string is too short to contain "
"the number of bits announced"
)
nr_bytes_filled = my_string_length // 8
nbr_bits_filled = my_string_length % 8
l = my_string_length % n
if ((n - 8) <= l <= (n - 2)):
if (nbr_bits_filled == 0):
my_byte = 0
else:
my_byte = int(my_string[nr_bytes_filled * 2:nr_bytes_filled * 2 + 2], 16)
my_byte = (my_byte >> (8 - nbr_bits_filled))
my_byte = my_byte + 2 ** (nbr_bits_filled) + 2 ** 7
my_byte = "%02X" % my_byte
my_string = my_string[0:nr_bytes_filled * 2] + my_byte
else:
if (nbr_bits_filled == 0):
my_byte = 0
else:
my_byte = int(my_string[nr_bytes_filled * 2:nr_bytes_filled * 2 + 2], 16)
my_byte = (my_byte >> (8 - nbr_bits_filled))
my_byte = my_byte + 2 ** (nbr_bits_filled)
my_byte = "%02X" % my_byte
my_string = my_string[0:nr_bytes_filled * 2] + my_byte
while((8 * len(my_string) // 2) % n < (n - 8)):
my_string = my_string + '00'
my_string = my_string + '80'
return my_string
def update(self, arg):
# Update the hash object with the string arg. Repeated calls are #
# equivalent to a single call with the concatenation of all the
# arguments: m.update(a); m.update(b) is equivalent to m.update(a+b).
# arg is a normal bytestring.
self.last_digest = None
# Convert the data into a workable format, and add it to the buffer
self.buffered_data += arg.encode('hex')
# Absorb any blocks we can:
if len(self.buffered_data) * 4 >= self.r:
extra_bits = len(self.buffered_data) * 4 % self.r
# An exact fit!
if extra_bits == 0:
P = self.buffered_data
self.buffered_data = ""
else:
# Slice it up into the first r*a bits, for some constant a>=1,
# and the remaining total-r*a bits.
P = self.buffered_data[:-extra_bits // 4]
self.buffered_data = self.buffered_data[-extra_bits // 4:]
# Absorbing phase
for i in xrange((len(P) * 8 // 2) // self.r):
to_convert = P[i * (2 * self.r // 8):(i + 1) * (2 * self.r // 8)] + '00' * (self.c // 8)
P_i = _convertStrToTable(to_convert, self.w, self.b)
# First apply the XOR to the state + block
for y in xrange(5):
for x in xrange(5):
self.S[x][y] = self.S[x][y] ^ P_i[x][y]
# Then apply the block permutation, Keccak-F
self.S = Keccak.KeccakF(self.S, self.n_r, self.w)
def digest(self):
"""Return the digest of the strings passed to the update() method so far.
This is a string of digest_size bytes which may contain non-ASCII
characters, including null bytes."""
if self.last_digest:
return self.last_digest
# UGLY WARNING
# Handle bytestring/hexstring conversions
M = _build_message_pair(self.buffered_data.decode('hex'))
# First finish the padding and force the final update:
self.buffered_data = Keccak.pad10star1(M, self.r)
self.update('')
# UGLY WARNING over
assert len(self.buffered_data) == 0, "Why is there data left in the buffer? %s with length %d" % (self.buffered_data, len(self.buffered_data) * 4)
# Squeezing time!
Z = ''
outputLength = self.n
while outputLength > 0:
string = _convertTableToStr(self.S, self.w)
# Read the first 'r' bits of the state
Z = Z + string[:self.r * 2 // 8]
outputLength -= self.r
if outputLength > 0:
S = KeccakF(S, verbose)
self.last_digest = Z[:2 * self.n // 8].decode('hex')
return self.last_digest
def hexdigest(self):
"""Like digest() except the digest is returned as a string of hex digits
This may be used to exchange the value safely in email or other
non-binary environments."""
return self.digest().encode('hex')
def copy(self):
# First initialize whatever can be done normally
duplicate = Keccak(c=self.c, r=self.r, n=self.n)
# Then copy over the state.
for i in xrange(5):
for j in xrange(5):
duplicate.S[i][j] = self.S[i][j]
# and any other stored data
duplicate.buffered_data = self.buffered_data
duplicate.last_digest = self.last_digest
return duplicate
# Generic utility functions
def _build_message_pair(data):
hex_data = data.encode('hex')
size = len(hex_data) * 4
return (size, hex_data)
def _rot(x, shift_amount, length):
"""Rotate x shift_amount bits to the left, considering the \
string of bits is length bits long"""
shift_amount = shift_amount % length
return ((x >> (length - shift_amount)) +
(x << shift_amount)) % (1 << length)
# Conversion functions String <-> Table (and vice-versa)
def _fromHexStringToLane(string):
"""Convert a string of bytes written in hexadecimal to a lane value"""
# Check that the string has an even number of characters
# i.e. whole number of bytes
if len(string) % 2 != 0:
raise KeccakError.KeccakError(
"The provided string does not end with a full byte"
)
# Perform the conversion
temp = ''
nrBytes = len(string) // 2
for i in xrange(nrBytes):
offset = (nrBytes - i - 1) * 2
temp += string[offset:offset + 2]
return int(temp, 16)
def _fromLaneToHexString(lane, w):
"""Convert a lane value to a string of bytes written in hexadecimal"""
laneHexBE = (("%%0%dX" % (w // 4)) % lane)
# Perform the conversion
temp = ''
nrBytes = len(laneHexBE) // 2
for i in xrange(nrBytes):
offset = (nrBytes - i - 1) * 2
temp += laneHexBE[offset:offset + 2]
return temp.upper()
def _convertStrToTable(string, w, b):
"""Convert a string of hex-chars to its 5x5 matrix representation
string: string of bytes of hex-coded bytes (e.g. '9A2C...')"""
# Check that the input paramaters are expected
if w % 8 != 0:
raise KeccakError("w is not a multiple of 8")
# Each character in the string represents 4 bits.
# The string should have exactly 'b' bits.
if len(string) * 4 != b:
raise KeccakError.KeccakError(
"string can't be divided in 25 blocks of w bits"
"i.e. string must have exactly b bits"
)
# Convert
output = [[0, 0, 0, 0, 0],
[0, 0, 0, 0, 0],
[0, 0, 0, 0, 0],
[0, 0, 0, 0, 0],
[0, 0, 0, 0, 0]]
bits_per_char = 2 * w // 8
for x in xrange(5):
for y in xrange(5):
# Each entry will have b/25=w bits.
offset = (5 * y + x) * bits_per_char
# Store the data into the associated word.
hexstring = string[offset:offset + bits_per_char]
output[x][y] = _fromHexStringToLane(hexstring)
return output
def _convertTableToStr(table, w):
"""Convert a 5x5 matrix representation to its string representation"""
# Check input format
if w % 8 != 0:
raise KeccakError.KeccakError("w is not a multiple of 8")
if (len(table) != 5) or any(len(row) != 5 for row in table):
raise KeccakError.KeccakError("table must be 5x5")
# Convert
output = [''] * 25
for x in xrange(5):
for y in xrange(5):
output[5 * y + x] = _fromLaneToHexString(table[x][y], w)
output = ''.join(output).upper()
return output
```
|
```markdown
# Faster R-CNN Object Detector```
```markdown
<h1>Table of Contents<span class="tocSkip"></span></h1>
<div class="toc"><ul class="toc-item"><li><span><a href="#Faster-R-CNN-Object-Detector" data-toc-modified-id="Faster-R-CNN-Object-Detector-1"><span class="toc-item-num">1 </span>Faster R-CNN Object Detector</a></span><ul class="toc-item"><li><span><a href="#Introduction" data-toc-modified-id="Introduction-1.1"><span class="toc-item-num">1.1 </span>Introduction</a></span></li><li><span><a href="#Earlier-works" data-toc-modified-id="Earlier-works-1.2"><span class="toc-item-num">1.2 </span>Earlier works</a></span><ul class="toc-item"><li><span><a href="#R-CNN" data-toc-modified-id="R-CNN-1.2.1"><span class="toc-item-num">1.2.1 </span>R-CNN</a></span></li><li><span><a href="#Fast-R-CNN" data-toc-modified-id="Fast-R-CNN-1.2.2"><span class="toc-item-num">1.2.2 </span>Fast R-CNN</a></span></li></ul></li><li><span><a href="#Faster-R-CNN" data-toc-modified-id="Faster-R-CNN-1.3"><span class="toc-item-num">1.3 </span>Faster R-CNN</a></span><ul class="toc-item"><li><span><a href="#Region-Proposal-Network-(RPN)" data-toc-modified-id="Region-Proposal-Network-(RPN)-1.3.1"><span class="toc-item-num">1.3.1 </span>Region Proposal Network (RPN)</a></span></li></ul></li><li><span><a href="#Implementation-in-arcgis.learn" data-toc-modified-id="Implementation-in-arcgis.learn-1.4"><span class="toc-item-num">1.4 </span>Implementation in <code>arcgis.learn</code></a></span></li><li><span><a href="#References" data-toc-modified-id="References-1.5"><span class="toc-item-num">1.5 </span>References</a></span></li></ul></li></ul></div>```
```markdown
## Introduction```
```markdown
We have seen how the one-shot object detection models such as [SSD](path_to_url [RetinaNet](path_to_url and YOLOv3 work. However, before the single-stage detectors were the norm, the most popular object detectors were from the multi-stage R-CNN family. First, there was R-CNN, then Fast R-CNN came along with some improvements, and then eventually, Faster R-CNN became the state-of-the-art multi-stage object detector. As is obvious from the names, these models evolved from one to the next, providing better performance at faster speeds. Although Faster R-CNN is not as fast as some of the later single-stage models, it remains one of the most accurate object detection models.```
```markdown
<center><img src="../../static/img/fasterrcnn-detections.jpg" /></center>
<center>Figure 1. Object Detection using Faster R-CNN [1]</center>```
```markdown
## Earlier works```
```markdown
### R-CNN```
```markdown
R-CNN (Regions with Convolutional Neural Networks) architecture is a combination of multiple algorithms put together. It first uses a selection search algorithm to select 2000 region proposals that might contain objects. Each of these region proposals or Regions of Interest (RoIs) is processed through a convolutional net to obtain feature maps. The feature maps are then passed to an SVM model to classify the object class and to a regression model to obtain tight bounding boxes [2]. This method, although novel at the time, is extremely slow. You can read more about R-CNN [here](path_to_url```
```markdown
<center><img src="../../static/img/rcnn.jpg" /></center>
<center>Figure 2. R-CNN Architecture [2]</center>```
```markdown
### Fast R-CNN```
```markdown
Fast R-CNN came in as an improvement over R-CNN. In this model, instead of feeding each of the 2000 regions to separate CNNs, the whole image is fed to a single CNN. This results in a combined feature map for all the regions of interest. Region proposals are selected using an algorithm similar to the one used in R-CNN. An RoI pooling layer is used to extract and resize the feature maps of all the region proposals to the same size. This is then passed on to fully connected layers having two branches - a softmax classifier to give probabilities for each class and a bounding box regressor for precise bounding box coordinates [3]. This design speeds up the object detection task in comparison to R-CNN but still isn't good enough to work with large datasets. You can read more about Fast R-CNN [here](path_to_url```
```markdown
<center><img src="../../static/img/fastrcnn.jpg" /></center>
<center>Figure 3. Fast R-CNN Architecture [3]</center>```
```markdown
## Faster R-CNN```
```markdown
Until Faster R-CNN came out, its contemporaries were using various algorithms for region proposal that were being computed on the CPU and creating a bottleneck. Faster R-CNN improved the object detection architecture by replacing the selection search algorithm in Fast R-CNN with a convolutional network called the Region Proposal Network (RPN). The rest of the model architecture remains the same as Fast R-CNN - the image is fed to a CNN to produce a feature map from which features for regions proposed by the RPN are selected and resized by a pooling layer and fed to an FC layer with two heads, a softmax classifier, and a bounding box regressor. This design increased the speed of detection and brought it closer to realtime [1].```
```markdown
<center><img src="../../static/img/fasterrcnn.jpg" /></center>
<center>Figure 4. Faster R-CNN Architecture [1]</center>```
```markdown
### Region Proposal Network (RPN)```
```markdown
Region Proposal Network like other region proposal algorithms inputs an image and returns regions of interest that contain objects. An RPN also returns an objectness score that measures how likely the region is to have an object vs. a background [1]. In Faster R-CNN, the RPN and the detect network share the same backbone. The last shared layer of the backbone provides a feature map of the image that is used by the RPN to propose regions.```
```markdown
<center><img src="../../static/img/rpn.jpg" /></center>
<center>Figure 5. Region Proposal Network [1]</center>```
```markdown
Using a sliding window approach, a small network is overlaid onto the feature map. At each spatial window, there are multiple anchor boxes that are of predetermined scales and aspect ratios. This enables the model to detect objects of a wide range of scales and aspect ratios in the same image. Usually, three different scales and three different aspect ratios are used resulting in nine anchor boxes at each spatial location that denotes the maximum region proposals at that spatial location. The small network then feeds into fully connected layers with two heads - one for the objectness score and the other for the bounding box coordinates of the region proposals. Figure 5, demonstrates the sliding window at a spatial location, the corresponding anchor boxes and how it feeds into the subsequent layers [1]. Note that these layers though similar to the last few layers of the Fast R-CNN object detector are not the same nor do they share the weights. The RPN classifies the regions in a class agnostic manner as it is tasked with only finding the regions which contain the objects.
In this guide, we have tried to present an intuition to understand the Faster R-CNN model. To dive into more details about the model and it's architecture, please read the original papers mentioned in references below. You can reference this [blog](path_to_url```
```markdown
## Implementation in `arcgis.learn````
```markdown
You can create a Faster R-CNN model in `arcgis.learn` using a single line of code.
```
model = FasterRCNN(data)
```
Where ``data`` is the databunch that you would have prepared using `prepare_data` function.
Optionally, a ``backbone`` model from the ResNet family can be provided. The default is set to `resnet50`.
For more information about the API, please go to the [API reference](path_to_url#fasterrcnn).```
```markdown
## References```
```markdown
[1] Shaoqing Ren, Kaiming He, Ross Girshick, Jian Sun: “Faster R-CNN: Towards Real-Time Object Detection with Region Proposal Networks”, 2015; [path_to_url arXiv:1506.01497].
[2] Ross Girshick, Jeff Donahue, Trevor Darrell, Jitendra Malik: “Rich feature hierarchies for accurate object detection and semantic segmentation”, 2013; [path_to_url arXiv:1311.2524].
[3] Ross Girshick: “Fast R-CNN”, 2015; [path_to_url arXiv:1504.08083].```
|
```java
/**
* <p>
* <p>
* path_to_url
* <p>
* Unless required by applicable law or agreed to in writing, software
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*/
package com.justwayward.reader.wifitransfer;
import android.util.Log;
import com.justwayward.reader.api.BookApi;
import com.justwayward.reader.bean.BookMixAToc;
import com.justwayward.reader.bean.ChapterRead;
import com.justwayward.reader.manager.CacheManager;
import com.justwayward.reader.utils.FileUtils;
import java.io.BufferedReader;
import java.io.ByteArrayInputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.io.RandomAccessFile;
import java.io.UnsupportedEncodingException;
import java.net.InetSocketAddress;
import java.net.ServerSocket;
import java.net.Socket;
import java.nio.ByteBuffer;
import java.nio.channels.FileChannel;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Locale;
import java.util.Map;
import java.util.StringTokenizer;
import java.util.TimeZone;
import nl.siegmann.epublib.domain.Book;
import rx.Observer;
public abstract class NanoHTTPD {
/*
* Pseudo-Parameter to use to store the actual query string in the
* parameters map for later re-processing.
*/
public static final String QUERY_STRING_PARAMETER = "NanoHttpd.QUERY_STRING";
/**
* Common mime types for dynamic content
*/
public static final String MIME_PLAINTEXT = "text/plain";
public static final String MIME_HTML = "text/html";
public static final String MIME_DEFAULT_BINARY = "application/octet-stream";
private final String hostname;
private final int myPort;
private ServerSocket myServerSocket;
private Thread myThread;
private TempFileManagerFactory tempFileManagerFactory;
private AsyncRunner asyncRunner;
/**
* Constructs an HTTP server on given port.
*/
public NanoHTTPD(int port) {
this(null, port);
}
public NanoHTTPD(String hostname, int port) {
this.hostname = hostname;
this.myPort = port;
this.tempFileManagerFactory = new DefaultTempFileManagerFactory();
this.asyncRunner = new DefaultAsyncRunner();
}
/**
* Starts the server
* <p/>
* Throws an IOException if the socket is already in use
*/
public void start() throws IOException {
Log.i("NanoHTTPD", "server start");
myServerSocket = new ServerSocket();
myServerSocket.bind((hostname != null) ? new InetSocketAddress(
hostname, myPort) : new InetSocketAddress(myPort));
myThread = new Thread(new Runnable() {
@Override
public void run() {
do {
try {
final Socket finalAccept = myServerSocket.accept();
Log.i("NanoHTTPD",
"accept request from "
+ finalAccept.getInetAddress());
InputStream inputStream = finalAccept.getInputStream();
OutputStream outputStream = finalAccept
.getOutputStream();
TempFileManager tempFileManager = tempFileManagerFactory
.create();
final HTTPSession session = new HTTPSession(
tempFileManager, inputStream, outputStream);
asyncRunner.exec(new Runnable() {
@Override
public void run() {
session.run();
if (finalAccept != null) {
try {
finalAccept.close();
} catch (IOException ignored) {
}
}
}
});
} catch (IOException e) {
}
} while (!myServerSocket.isClosed());
}
});
myThread.setDaemon(true);
myThread.setName("NanoHttpd Main Listener");
myThread.start();
}
/**
* Stops the server.
*/
public void stop() {
Log.i("NanoHTTPD", "server stop");
try {
myServerSocket.close();
myThread.join();
} catch (IOException ioe) {
ioe.printStackTrace();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
public void setTempFileManagerFactory(
TempFileManagerFactory tempFileManagerFactory) {
this.tempFileManagerFactory = tempFileManagerFactory;
}
public void setAsyncRunner(AsyncRunner asyncRunner) {
this.asyncRunner = asyncRunner;
}
/**
* Override this to customize the server.
* <p/>
* <p/>
* (By default, this delegates to serveFile() and allows directory listing.)
*
* @param uri Percent-decoded URI without parameters, for example
* "/index.cgi"
* @param method "GET", "POST" etc.
* @param parms Parsed, percent decoded parameters from URI and, in case of
* POST, data.
* @param header Header entries, percent decoded
* @return HTTP response, see class Response for details
*/
public abstract Response serve(String uri, Method method,
Map<String, String> header, Map<String, String> parms,
Map<String, String> files);
/**
* Decodes the percent encoding scheme. <br/>
* For example: "an+example%20string" -> "an example string"
*/
protected String decodePercent(String str) throws InterruptedException {
try {
StringBuilder sb = new StringBuilder();
for (int i = 0; i < str.length(); i++) {
char c = str.charAt(i);
switch (c) {
case '+':
sb.append(' ');
break;
case '%':
sb.append((char) Integer.parseInt(
str.substring(i + 1, i + 3), 16));
i += 2;
break;
default:
sb.append(c);
break;
}
}
return sb.toString();
} catch (Exception e) {
throw new InterruptedException();
}
}
protected Map<String, List<String>> decodeParameters(
Map<String, String> parms) {
return this.decodeParameters(parms.get(QUERY_STRING_PARAMETER));
}
protected Map<String, List<String>> decodeParameters(String queryString) {
Map<String, List<String>> parms = new HashMap<String, List<String>>();
if (queryString != null) {
StringTokenizer st = new StringTokenizer(queryString, "&");
while (st.hasMoreTokens()) {
String e = st.nextToken();
int sep = e.indexOf('=');
try {
String propertyName = (sep >= 0) ? decodePercent(
e.substring(0, sep)).trim() : decodePercent(e)
.trim();
if (!parms.containsKey(propertyName)) {
parms.put(propertyName, new ArrayList<String>());
}
String propertyValue = (sep >= 0) ? decodePercent(e
.substring(sep + 1)) : null;
if (propertyValue != null) {
parms.get(propertyName).add(propertyValue);
}
} catch (InterruptedException e1) {
e1.printStackTrace();
}
}
}
return parms;
}
public enum Method {
GET, PUT, POST, DELETE;
static Method lookup(String method) {
for (Method m : Method.values()) {
if (m.toString().equalsIgnoreCase(method)) {
return m;
}
}
return null;
}
}
public interface AsyncRunner {
void exec(Runnable code);
}
public interface TempFileManagerFactory {
TempFileManager create();
}
public interface TempFileManager {
TempFile createTempFile() throws Exception;
void clear();
}
public interface TempFile {
OutputStream open() throws Exception;
void delete() throws Exception;
String getName();
}
/**
* HTTP response. Return one of these from serve().
*/
public static class Response {
private String bookId;
private BookMixAToc.mixToc bookMix;
private BookApi bookApi;
/**
* HTTP status code after processing, e.g. "200 OK", HTTP_OK
*/
public Status status;
/**
* MIME type of content, e.g. "text/html"
*/
public String mimeType;
/**
* Data of the response, may be null.
*/
public InputStream data;
/**
* Headers for the HTTP response. Use addHeader() to add lines.
*/
public Map<String, String> header = new HashMap<String, String>();
/**
* Default constructor: response = HTTP_OK, mime = MIME_HTML and your
* supplied message
*/
public Response(String msg) {
this(Status.OK, MIME_HTML, msg);
}
/**
* start Chapters index
*/
public int start;
/**
* Basic constructor.
*/
public Response(Status status, String mimeType, InputStream data) {
this.status = status;
this.mimeType = mimeType;
this.data = data;
}
/**
* Convenience method that makes an InputStream out of given text.
*/
public Response(Status status, String mimeType, String txt) {
this.status = status;
this.mimeType = mimeType;
try {
this.data = new ByteArrayInputStream(txt.getBytes("UTF-8"));
} catch (UnsupportedEncodingException uee) {
uee.printStackTrace();
}
}
public Response(Status status, String mimeType, String bookId, BookMixAToc.mixToc bookMix, BookApi bookApi, int start) {
this.status = status;
this.mimeType = mimeType;
this.bookId = bookId;
this.bookMix = bookMix;
this.bookApi = bookApi;
this.start = start;
}
public static void error(OutputStream outputStream, Status error,
String message) {
new Response(error, MIME_PLAINTEXT, message).send(outputStream);
}
/**
* Adds given line to the header.
*/
public void addHeader(String name, String value) {
header.put(name, value);
}
/**
* Sends given response to the socket.
*/
private void send(OutputStream outputStream) {
String mime = mimeType;
SimpleDateFormat gmtFrmt = new SimpleDateFormat(
"E, d MMM yyyy HH:mm:ss 'GMT'", Locale.US);
gmtFrmt.setTimeZone(TimeZone.getTimeZone("GMT"));
try {
if (status == null) {
throw new Error("sendResponse(): Status can't be null.");
}
PrintWriter pw = new PrintWriter(outputStream);
pw.print("HTTP/1.0 " + status.getDescription() + " \r\n");
if (mime != null) {
pw.print("Content-Type: " + mime + "\r\n");
}
if (header == null || header.get("Date") == null) {
pw.print("Date: " + gmtFrmt.format(new Date()) + "\r\n");
}
if (header != null) {
for (String key : header.keySet()) {
String value = header.get(key);
pw.print(key + ": " + value + "\r\n");
}
}
pw.print("\r\n");
pw.flush();
sendInputData(outputStream, data);
//
witBook(pw, outputStream);
outputStream.flush();
outputStream.close();
if (data != null)
data.close();
} catch (IOException ioe) {
// Couldn't write? No can do.
ioe.printStackTrace();
}
}
public void witBook(final PrintWriter pw, OutputStream outputStream) {
if (this.bookMix == null) {
return;
}
final List<BookMixAToc.mixToc.Chapters> list = this.bookMix.chapters;
for (int i = start; i < list.size(); i++) {
final BookMixAToc.mixToc.Chapters character = list.get(i);
final String title = character.title;
File fileIndex = CacheManager.getInstance().getChapterFile(this.bookId, i + 1);
if (fileIndex != null) {
FileInputStream fis = null;
try {
fis = new FileInputStream(fileIndex);
pw.print("\r\n");
pw.print(title);
pw.print("\r\n");
pw.flush();
sendInputData(outputStream, fis);
outputStream.flush();
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} finally {
if (fis != null) {
try {
fis.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
} else {
// 350ms
try {
Thread.sleep(350);
} catch (InterruptedException e) {
e.printStackTrace();
}
Log.i("tag_", "onload: " + character.link);
//
final int finalI = i;
bookApi.getChapterRead(character.link).subscribe(new Observer<ChapterRead>() {
@Override
public void onCompleted() {
// call(integer, observer);
}
@Override
public void onError(Throwable e) {
}
@Override
public void onNext(ChapterRead chapterRead) {
Log.i("tag_", "onload end: chapterRead -> " + title);
pw.print("\r\n");
pw.print(title);
pw.print("\r\n");
pw.print(chapterRead.chapter.body);
pw.flush();
//
CacheManager.getInstance().saveChapterFile(Response.this.bookId, finalI, chapterRead.chapter);
}
});
}
}
}
// public String getTitle(File file ,int i ,BookMixAToc.mixToc mixToc){
// if(mixToc != null && mixToc.chapters != null && i < mixToc.chapters.size() ){
// return mixToc.chapters.get(i).title;
// }else{
// return "" + FileUtils.getFileNameNotType(file) + "";
// }
//
// }
private void sendInputData(OutputStream outputStream, InputStream data) throws IOException {
if (data != null) {
int pending = data.available(); // This is to support
// partial sends, see
// serveFile()
int BUFFER_SIZE = 16 * 1024;
byte[] buff = new byte[BUFFER_SIZE];
while (pending > 0) {
int read = data.read(buff, 0,
((pending > BUFFER_SIZE) ? BUFFER_SIZE
: pending));
if (read <= 0) {
break;
}
outputStream.write(buff, 0, read);
pending -= read;
}
}
}
/**
* Some HTTP response status codes
*/
public enum Status {
OK(200, "OK"), CREATED(201, "Created"), NO_CONTENT(204,
"No Content"), PARTIAL_CONTENT(206, "Partial Content"), REDIRECT(
301, "Moved Permanently"), NOT_MODIFIED(304, "Not Modified"), BAD_REQUEST(
400, "Bad Request"), UNAUTHORIZED(401, "Unauthorized"), FORBIDDEN(
403, "Forbidden"), NOT_FOUND(404, "Not Found"), RANGE_NOT_SATISFIABLE(
416, "Requested Range Not Satisfiable"), INTERNAL_ERROR(
500, "Internal Server Error");
private int requestStatus;
private String descr;
Status(int requestStatus, String descr) {
this.requestStatus = requestStatus;
this.descr = descr;
}
public int getRequestStatus() {
return this.requestStatus;
}
public String getDescription() {
return "" + this.requestStatus + " " + descr;
}
}
}
public static class DefaultTempFile implements TempFile {
private File file;
private OutputStream fstream;
public DefaultTempFile(String tempdir) throws IOException {
file = File.createTempFile("NanoHTTPD-", "", new File(tempdir));
fstream = new FileOutputStream(file);
}
@Override
public OutputStream open() throws Exception {
return fstream;
}
@Override
public void delete() throws Exception {
file.delete();
}
@Override
public String getName() {
return file.getAbsolutePath();
}
}
/**
* Handles one session, i.e. parses the HTTP request and returns the
* response.
*/
protected class HTTPSession implements Runnable {
public static final int BUFSIZE = 8192;
private final TempFileManager tempFileManager;
private InputStream inputStream;
private OutputStream outputStream;
public HTTPSession(TempFileManager tempFileManager,
InputStream inputStream, OutputStream outputStream) {
this.tempFileManager = tempFileManager;
this.inputStream = inputStream;
this.outputStream = outputStream;
}
@Override
public void run() {
try {
if (inputStream == null) {
return;
}
// Read the first 8192 bytes.
// The full header should fit in here.
// Apache's default header limit is 8KB.
// Do NOT assume that a single read will get the entire header
// at once!
byte[] buf = new byte[BUFSIZE];
int splitbyte = 0;
int rlen = 0;
{
int read = inputStream.read(buf, 0, BUFSIZE);
while (read > 0) {
rlen += read;
splitbyte = findHeaderEnd(buf, rlen);
if (splitbyte > 0)
break;
read = inputStream.read(buf, rlen, BUFSIZE - rlen);
}
}
// Create a BufferedReader for parsing the header.
BufferedReader hin = new BufferedReader(new InputStreamReader(
new ByteArrayInputStream(buf, 0, rlen)));
Map<String, String> pre = new HashMap<String, String>();
Map<String, String> parms = new HashMap<String, String>();
Map<String, String> header = new HashMap<String, String>();
Map<String, String> files = new HashMap<String, String>();
// Decode the header into parms and header java properties
decodeHeader(hin, pre, parms, header);
Method method = Method.lookup(pre.get("method"));
if (method == null) {
Response.error(outputStream, Response.Status.BAD_REQUEST,
"BAD REQUEST: Syntax error.");
throw new InterruptedException();
}
String uri = pre.get("uri");
long size = extractContentLength(header);
// Write the part of body already read to ByteArrayOutputStream
// f
RandomAccessFile f = getTmpBucket();
if (splitbyte < rlen) {
f.write(buf, splitbyte, rlen - splitbyte);
}
// While Firefox sends on the first read all the data fitting
// our buffer, Chrome and Opera send only the headers even if
// there is data for the body. We do some magic here to find
// out whether we have already consumed part of body, if we
// have reached the end of the data to be sent or we should
// expect the first byte of the body at the next read.
if (splitbyte < rlen) {
size -= rlen - splitbyte + 1;
} else if (splitbyte == 0 || size == 0x7FFFFFFFFFFFFFFFl) {
size = 0;
}
// Now read all the body and write it to f
buf = new byte[512];
while (rlen >= 0 && size > 0) {
rlen = inputStream.read(buf, 0, 512);
size -= rlen;
if (rlen > 0) {
f.write(buf, 0, rlen);
}
}
// Get the raw body as a byte []
ByteBuffer fbuf = f.getChannel().map(
FileChannel.MapMode.READ_ONLY, 0, f.length());
f.seek(0);
// Create a BufferedReader for easily reading it as string.
InputStream bin = new FileInputStream(f.getFD());
BufferedReader in = new BufferedReader(new InputStreamReader(
bin));
// If the method is POST, there may be parameters
// in data section, too, read it:
if (Method.POST.equals(method)) {
String contentType = "";
String contentTypeHeader = header.get("content-type");
StringTokenizer st = null;
if (contentTypeHeader != null) {
st = new StringTokenizer(contentTypeHeader, ",; ");
if (st.hasMoreTokens()) {
contentType = st.nextToken();
}
}
if ("multipart/form-data".equalsIgnoreCase(contentType)) {
// Handle multipart/form-data
if (!st.hasMoreTokens()) {
Response.error(
outputStream,
Response.Status.BAD_REQUEST,
"BAD REQUEST: Content type is multipart/form-data but boundary missing. Usage: GET /example/file.html");
throw new InterruptedException();
}
String boundaryStartString = "boundary=";
int boundaryContentStart = contentTypeHeader
.indexOf(boundaryStartString)
+ boundaryStartString.length();
String boundary = contentTypeHeader.substring(
boundaryContentStart,
contentTypeHeader.length());
if (boundary.startsWith("\"")
&& boundary.startsWith("\"")) {
boundary = boundary.substring(1,
boundary.length() - 1);
}
decodeMultipartData(boundary, fbuf, in, parms, files);
} else {
// Handle application/x-www-form-urlencoded
String postLine = "";
char pbuf[] = new char[512];
int read = in.read(pbuf);
while (read >= 0 && !postLine.endsWith("\r\n")) {
postLine += String.valueOf(pbuf, 0, read);
read = in.read(pbuf);
}
postLine = postLine.trim();
decodeParms(postLine, parms);
}
}
if (Method.PUT.equals(method))
files.put("content", saveTmpFile(fbuf, 0, fbuf.limit()));
// Ok, now do the serve()
Response r = serve(uri, method, header, parms, files);
if (r == null) {
Response.error(outputStream,
Response.Status.INTERNAL_ERROR,
"SERVER INTERNAL ERROR: Serve() returned a null response.");
throw new InterruptedException();
} else {
r.send(outputStream);
}
in.close();
inputStream.close();
} catch (IOException ioe) {
try {
Response.error(
outputStream,
Response.Status.INTERNAL_ERROR,
"SERVER INTERNAL ERROR: IOException: "
+ ioe.getMessage());
throw new InterruptedException();
} catch (Throwable ignored) {
ignored.printStackTrace();
}
} catch (InterruptedException ie) {
// Thrown by sendError, ignore and exit the thread.
ie.printStackTrace();
} finally {
tempFileManager.clear();
}
}
private long extractContentLength(Map<String, String> header) {
long size = 0x7FFFFFFFFFFFFFFFl;
String contentLength = header.get("content-length");
if (contentLength != null) {
try {
size = Integer.parseInt(contentLength);
} catch (NumberFormatException ex) {
ex.printStackTrace();
}
}
return size;
}
/**
* Decodes the sent headers and loads the data into Key/value pairs
*/
private void decodeHeader(BufferedReader in, Map<String, String> pre,
Map<String, String> parms, Map<String, String> header)
throws InterruptedException {
try {
// Read the request line
String inLine = in.readLine();
if (inLine == null) {
return;
}
StringTokenizer st = new StringTokenizer(inLine);
if (!st.hasMoreTokens()) {
Response.error(outputStream, Response.Status.BAD_REQUEST,
"BAD REQUEST: Syntax error. Usage: GET /example/file.html");
throw new InterruptedException();
}
pre.put("method", st.nextToken());
if (!st.hasMoreTokens()) {
Response.error(outputStream, Response.Status.BAD_REQUEST,
"BAD REQUEST: Missing URI. Usage: GET /example/file.html");
throw new InterruptedException();
}
String uri = st.nextToken();
// Decode parameters from the URI
int qmi = uri.indexOf('?');
if (qmi >= 0) {
decodeParms(uri.substring(qmi + 1), parms);
uri = decodePercent(uri.substring(0, qmi));
} else {
uri = decodePercent(uri);
}
// If there's another token, it's protocol version,
// followed by HTTP headers. Ignore version but parse headers.
// NOTE: this now forces header names lowercase since they are
// case insensitive and vary by client.
if (st.hasMoreTokens()) {
String line = in.readLine();
while (line != null && line.trim().length() > 0) {
int p = line.indexOf(':');
if (p >= 0)
header.put(line.substring(0, p).trim()
.toLowerCase(), line.substring(p + 1)
.trim());
line = in.readLine();
}
}
pre.put("uri", uri);
} catch (IOException ioe) {
Response.error(
outputStream,
Response.Status.INTERNAL_ERROR,
"SERVER INTERNAL ERROR: IOException: "
+ ioe.getMessage());
throw new InterruptedException();
}
}
/**
* Decodes the Multipart Body data and put it into Key/Value pairs.
*/
private void decodeMultipartData(String boundary, ByteBuffer fbuf,
BufferedReader in, Map<String, String> parms,
Map<String, String> files) throws InterruptedException {
try {
int[] bpositions = getBoundaryPositions(fbuf,
boundary.getBytes());
int boundarycount = 1;
String mpline = in.readLine();
while (mpline != null) {
if (!mpline.contains(boundary)) {
Response.error(
outputStream,
Response.Status.BAD_REQUEST,
"BAD REQUEST: Content type is multipart/form-data but next chunk does not start with boundary. Usage: GET /example/file.html");
throw new InterruptedException();
}
boundarycount++;
Map<String, String> item = new HashMap<String, String>();
mpline = in.readLine();
while (mpline != null && mpline.trim().length() > 0) {
int p = mpline.indexOf(':');
if (p != -1) {
item.put(mpline.substring(0, p).trim()
.toLowerCase(), mpline.substring(p + 1)
.trim());
}
mpline = in.readLine();
}
if (mpline != null) {
String contentDisposition = item
.get("content-disposition");
if (contentDisposition == null) {
Response.error(
outputStream,
Response.Status.BAD_REQUEST,
"BAD REQUEST: Content type is multipart/form-data but no content-disposition info found. Usage: GET /example/file.html");
throw new InterruptedException();
}
StringTokenizer st = new StringTokenizer(contentDisposition, "; ");
Map<String, String> disposition = new HashMap<>();
while (st.hasMoreTokens()) {
String token = st.nextToken();
int p = token.indexOf('=');
if (p != -1) {
disposition.put(token.substring(0, p).trim()
.toLowerCase(), token.substring(p + 1)
.trim());
}
}
String pname = disposition.get("name");
pname = pname.substring(1, pname.length() - 1);
String value = "";
if (item.get("content-type") == null) {
while (mpline != null && !mpline.contains(boundary)) {
mpline = in.readLine();
if (mpline != null) {
int d = mpline.indexOf(boundary);
if (d == -1) {
value += mpline;
} else {
value += mpline.substring(0, d - 2);
}
}
}
} else {
if (boundarycount > bpositions.length) {
Response.error(outputStream,
Response.Status.INTERNAL_ERROR,
"Error processing request");
throw new InterruptedException();
}
int offset = stripMultipartHeaders(fbuf,
bpositions[boundarycount - 2]);
String path = saveTmpFile(fbuf, offset,
bpositions[boundarycount - 1] - offset - 4);
files.put(pname, path);
value = disposition.get("filename");
value = value.substring(1, value.length() - 1);
do {
mpline = in.readLine();
} while (mpline != null
&& !mpline.contains(boundary));
}
parms.put(pname, value);
}
}
} catch (IOException ioe) {
Response.error(
outputStream,
Response.Status.INTERNAL_ERROR,
"SERVER INTERNAL ERROR: IOException: "
+ ioe.getMessage());
throw new InterruptedException();
}
}
/**
* Find byte index separating header from body. It must be the last byte
* of the first two sequential new lines.
*/
private int findHeaderEnd(final byte[] buf, int rlen) {
int splitbyte = 0;
while (splitbyte + 3 < rlen) {
if (buf[splitbyte] == '\r' && buf[splitbyte + 1] == '\n'
&& buf[splitbyte + 2] == '\r'
&& buf[splitbyte + 3] == '\n') {
return splitbyte + 4;
}
splitbyte++;
}
return 0;
}
/**
* Find the byte positions where multipart boundaries start.
*/
public int[] getBoundaryPositions(ByteBuffer b, byte[] boundary) {
int matchcount = 0;
int matchbyte = -1;
List<Integer> matchbytes = new ArrayList<Integer>();
for (int i = 0; i < b.limit(); i++) {
if (b.get(i) == boundary[matchcount]) {
if (matchcount == 0)
matchbyte = i;
matchcount++;
if (matchcount == boundary.length) {
matchbytes.add(matchbyte);
matchcount = 0;
matchbyte = -1;
}
} else {
i -= matchcount;
matchcount = 0;
matchbyte = -1;
}
}
int[] ret = new int[matchbytes.size()];
for (int i = 0; i < ret.length; i++) {
ret[i] = matchbytes.get(i);
}
return ret;
}
/**
* Retrieves the content of a sent file and saves it to a temporary
* file. The full path to the saved file is returned.
*/
private String saveTmpFile(ByteBuffer b, int offset, int len) {
String path = "";
if (len > 0) {
try {
TempFile tempFile = tempFileManager.createTempFile();
ByteBuffer src = b.duplicate();
FileChannel dest = new FileOutputStream(tempFile.getName())
.getChannel();
src.position(offset).limit(offset + len);
dest.write(src.slice());
path = tempFile.getName();
} catch (Exception e) { // Catch exception if any
System.err.println("Error: " + e.getMessage());
}
}
return path;
}
private RandomAccessFile getTmpBucket() throws IOException {
try {
TempFile tempFile = tempFileManager.createTempFile();
return new RandomAccessFile(tempFile.getName(), "rw");
} catch (Exception e) {
System.err.println("Error: " + e.getMessage());
}
return null;
}
/**
* It returns the offset separating multipart file headers from the
* file's data.
*/
private int stripMultipartHeaders(ByteBuffer b, int offset) {
int i;
for (i = offset; i < b.limit(); i++) {
if (b.get(i) == '\r' && b.get(++i) == '\n'
&& b.get(++i) == '\r' && b.get(++i) == '\n') {
break;
}
}
return i + 1;
}
/**
* Decodes parameters in percent-encoded URI-format ( e.g.
* "name=Jack%20Daniels&pass=Single%20Malt" ) and adds them to given
* Map. NOTE: this doesn't support multiple identical keys due to the
* simplicity of Map.
*/
private void decodeParms(String parms, Map<String, String> p)
throws InterruptedException {
if (parms == null) {
p.put(QUERY_STRING_PARAMETER, "");
return;
}
p.put(QUERY_STRING_PARAMETER, parms);
StringTokenizer st = new StringTokenizer(parms, "&");
try {
while (st.hasMoreTokens()) {
String e = st.nextToken();
int sep = e.indexOf('=');
if (sep >= 0) {
p.put(decodePercent(e.substring(0, sep)).trim(),
decodePercent(e.substring(sep + 1)));
} else {
p.put(decodePercent(e).trim(), "");
}
}
} catch (InterruptedException e) {
Response.error(outputStream, Response.Status.BAD_REQUEST,
"BAD REQUEST: Bad percent-encoding.");
}
}
}
private class DefaultTempFileManagerFactory implements
TempFileManagerFactory {
@Override
public TempFileManager create() {
return new DefaultTempFileManager();
}
}
public static class DefaultTempFileManager implements TempFileManager {
private final String tmpdir;
private final List<TempFile> tempFiles;
public DefaultTempFileManager() {
tmpdir = System.getProperty("java.io.tmpdir");
tempFiles = new ArrayList<TempFile>();
}
@Override
public TempFile createTempFile() throws Exception {
DefaultTempFile tempFile = new DefaultTempFile(tmpdir);
tempFiles.add(tempFile);
return tempFile;
}
@Override
public void clear() {
for (TempFile file : tempFiles) {
try {
file.delete();
} catch (Exception ignored) {
}
}
tempFiles.clear();
}
}
private class DefaultAsyncRunner implements AsyncRunner {
private long requestCount;
@Override
public void exec(Runnable code) {
++requestCount;
Thread t = new Thread(code);
t.setDaemon(true);
t.setName("NanoHttpd Request Processor (#" + requestCount + ")");
t.start();
}
}
}
```
|
```java
/**
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
*
* path_to_url
*
* Unless required by applicable law or agreed to in writing, software
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*
*
* Original file: path_to_url
*/
package org.locationtech.jts.io.twkb;
import java.io.DataInput;
import java.io.DataOutput;
import java.io.IOException;
/**
* <p>
* Encodes signed and unsigned values using a common variable-length scheme, found for example in
* <a href="path_to_url"> Google's Protocol
* Buffers</a>. It uses fewer bytes to encode smaller values, but will use slightly more bytes to
* encode large values.
* </p>
*
* <p>
* Signed values are further encoded using so-called zig-zag encoding in order to make them
* "compatible" with variable-length encoding.
* </p>
*/
final class Varint {
private Varint() {
}
public static int zigZagEncode(int value) {
return (value << 1) ^ (value >> 31);
}
public static int zigzagDecode(int input) {
// This undoes the trick in zigZagEncode()
int temp = (((input << 31) >> 31) ^ input) >> 1;
// This extra step lets us deal with the largest signed values by treating
// negative results from read unsigned methods as like unsigned values.
// Must re-flip the top bit if the original read value had it set.
return temp ^ (input & (1 << 31));
}
public static long zigZagEncode(long value) {
return (value << 1) ^ (value >> 63);
}
/**
* Encodes a value using the variable-length encoding from
* <a href="path_to_url"> Google Protocol
* Buffers</a>. It uses zig-zag encoding to efficiently encode signed values. If values are
* known to be nonnegative, {@link #writeUnsignedVarLong(long, DataOutput)} should be used.
*
* @param value value to encode
* @param out to write bytes to
* @throws IOException if {@link DataOutput} throws {@link IOException}
*/
public static void writeSignedVarLong(long value, DataOutput out) throws IOException {
// Great trick from path_to_url#types
writeUnsignedVarLong(zigZagEncode(value), out);
}
/**
* Encodes a value using the variable-length encoding from
* <a href="path_to_url"> Google Protocol
* Buffers</a>. Zig-zag is not used, so input must not be negative. If values can be negative,
* use {@link #writeSignedVarLong(long, DataOutput)} instead. This method treats negative input
* as like a large unsigned value.
*
* @param value value to encode
* @param out to write bytes to
* @throws IOException if {@link DataOutput} throws {@link IOException}
*/
public static void writeUnsignedVarLong(long value, DataOutput out) throws IOException {
while ((value & 0xFFFFFFFFFFFFFF80L) != 0L) {
out.writeByte(((int) value & 0x7F) | 0x80);
value >>>= 7;
}
out.writeByte((int) value & 0x7F);
}
/**
* @see #writeSignedVarLong(long, DataOutput)
*/
public static void writeSignedVarInt(int value, DataOutput out) throws IOException {
// Great trick from path_to_url#types
writeUnsignedVarInt(zigZagEncode(value), out);
}
/**
* @return how many bytes have been written
* @see #writeUnsignedVarLong(long, DataOutput)
*/
public static void writeUnsignedVarInt(int value, DataOutput out) throws IOException {
while ((value & 0xFFFFFF80) != 0L) {
out.writeByte((value & 0x7F) | 0x80);
value >>>= 7;
}
out.writeByte(value & 0x7F);
}
/**
* @param in to read bytes from
* @return decode value
* @throws IOException if {@link DataInput} throws {@link IOException}
* @throws IllegalArgumentException if variable-length value does not terminate after 9 bytes
* have been read
* @see #writeSignedVarLong(long, DataOutput)
*/
public static long readSignedVarLong(DataInput in) throws IOException {
long raw = readUnsignedVarLong(in);
// This undoes the trick in writeSignedVarLong()
long temp = (((raw << 63) >> 63) ^ raw) >> 1;
// This extra step lets us deal with the largest signed values by treating
// negative results from read unsigned methods as like unsigned values
// Must re-flip the top bit if the original read value had it set.
return temp ^ (raw & (1L << 63));
}
/**
* @param in to read bytes from
* @return decode value
* @throws IOException if {@link DataInput} throws {@link IOException}
* @throws IllegalArgumentException if variable-length value does not terminate after 9 bytes
* have been read
* @see #writeUnsignedVarLong(long, DataOutput)
*/
public static long readUnsignedVarLong(DataInput in) throws IOException {
long value = 0L;
int i = 0;
long b;
while (((b = in.readByte()) & 0x80L) != 0) {
value |= (b & 0x7F) << i;
i += 7;
if (i > 63) {
throw new IllegalArgumentException(
"Variable length quantity is too long (must be <= 63)");
}
}
return value | (b << i);
}
/**
* @throws IllegalArgumentException if variable-length value does not terminate after 5 bytes
* have been read
* @throws IOException if {@link DataInput} throws {@link IOException}
* @see #readSignedVarLong(DataInput)
*/
public static int readSignedVarInt(DataInput in) throws IOException {
int raw = readUnsignedVarInt(in);
// This undoes the trick in writeSignedVarInt()
int temp = (((raw << 31) >> 31) ^ raw) >> 1;
// This extra step lets us deal with the largest signed values by treating
// negative results from read unsigned methods as like unsigned values.
// Must re-flip the top bit if the original read value had it set.
return temp ^ (raw & (1 << 31));
}
/**
* @throws IllegalArgumentException if variable-length value does not terminate after 5 bytes
* have been read
* @throws IOException if {@link DataInput} throws {@link IOException}
* @see #readUnsignedVarLong(DataInput)
*/
public static int readUnsignedVarInt(DataInput in) throws IOException {
int value = 0;
int i = 0;
int b;
while (((b = in.readByte()) & 0x80) != 0) {
value |= (b & 0x7F) << i;
i += 7;
if (i > 35) {
throw new IllegalArgumentException(
"Variable length quantity is too long (must be <= 35)");
}
}
return value | (b << i);
}
public static int readUnsignedVarInt(byte[] from) throws IOException {
if (from.length < 5) {
throw new IllegalArgumentException(
"buff should have at least 5 free slots to fit the biggest possible value representation");
}
int value = 0;
int i = 0;
int b;
int cnt = 0;
while (((b = from[cnt]) & 0x80) != 0) {
value |= (b & 0x7F) << i;
i += 7;
if (i > 35) {
throw new IllegalArgumentException(
"Variable length quantity is too long (must be <= 35)");
}
cnt++;
}
return value | (b << i);
}
}
```
|
The 1944 Howard Bulldogs football team was an American football team that represented Howard College (now known as the Samford University) as an independent during the 1944 college football season. In their first year under head coach Bub Walker, the team compiled an 0–5 record.
Schedule
References
Howard
Samford Bulldogs football seasons
College football winless seasons
Howard Bulldogs football
|
```scss
//
// Wells
// --------------------------------------------------
// Base class
.well {
min-height: 20px;
padding: 19px;
margin-bottom: 20px;
background-color: $well-bg;
border: 1px solid $well-border;
border-radius: $border-radius-base;
@include box-shadow(inset 0 1px 1px rgba(0, 0, 0, .05));
blockquote {
border-color: #ddd;
border-color: rgba(0, 0, 0, .15);
}
}
// Sizes
.well-lg {
padding: 24px;
border-radius: $border-radius-large;
}
.well-sm {
padding: 9px;
border-radius: $border-radius-small;
}
```
|
Marko Gušić (, born 6 August 2002) is a Serbian professional basketball player for Crvena zvezda. Standing at and weighing , he plays both small forward and shooting guard positions.
Early career
Gušić grew up playing basketball for youth systems of Mladost Zemun, Mega Basket, and Vizura before joining to the Crvena zvezda youth system in May 2019.
Professional career
On 25 August 2020, Gušić officially signed his first professional contract with Crvena zvezda. On 24 September 2021, Gušić signed new four-year contract with the Zvezda. On the same day, he made his ABA League debut in their season opening 97–61 win over Split, making 2 points, 2 rebounds, an assist, and 2 steals in under 16 minutes of playing time. On 7 October, he made his EuroLeague debut in a 75–63 win over Maccabi Tel Aviv, recording only seven seconds of playing time. He was loaned to FMP on 28 December 2021.
Career statistics
Euroleague
|-
| style="text-align:left;"| 2021–22
| style="text-align:left;"| Crvena zvezda mts
| 1 || 0 || 0:07 || .000 || .000 || .000 || 0.0 || 0.0 || 0.0 || 0.0 || 0.0 || 0.0
|-
|- class="sortbottom"
| style="text-align:center;" colspan="2"| Career
| 1 || 0 || 0:07 || .000 || .000 || .000 || 0.0 || 0.0 || 0.0 || 0.0 || 0.0 || 0.0
Personal life
His grand-father was Novica Gušić, a colonel in the Army of Republika Srpska.
References
External links
Profile at eurobasket.com
Profile at euroleague.net
Profile at realgm.com
Profile at ABA League
2002 births
Living people
ABA League players
Basketball players from Belgrade
KK Crvena zvezda players
KK FMP players
Serbian men's basketball players
Serbian people of Bosnia and Herzegovina descent
Shooting guards
Small forwards
|
```perl6
package Validator::ListMemberCheckTest;
use strict;
use warnings;
use Test::More;
use eventMacro::Data;
use eventMacro::Validator::ListMemberCheck;
sub start {
subtest 'single member' => sub {
my $v = eventMacro::Validator::ListMemberCheck->new( 'Poring' );
ok $v->parsed;
is_deeply($v->{list}, ['Poring']);
ok $v->validate( 'Poring' );
ok !$v->validate( 'Drops' );
ok !$v->validate( 'poring' );
$v = eventMacro::Validator::ListMemberCheck->new( 'drops' );
ok $v->parsed;
is_deeply($v->{list}, ['drops']);
ok $v->validate( 'drops' );
ok !$v->validate( 'marin' );
ok !$v->validate( 'Drops' );
$v = eventMacro::Validator::ListMemberCheck->new( 'prt_fild10' );
ok $v->parsed;
is_deeply($v->{list}, ['prt_fild10']);
ok !$v->validate( 'geffen' );
ok $v->validate( 'prt_fild10' );
ok !$v->validate( '' );
};
subtest 'multiple members' => sub {
my $v = eventMacro::Validator::ListMemberCheck->new( 'Poring, Drops, Poporing' );
ok $v->parsed;
is_deeply($v->{list}, ['Poring', 'Drops', 'Poporing']);
ok $v->validate( 'Poring' );
ok $v->validate( 'Drops' );
ok $v->validate( 'Poporing' );
ok !$v->validate( 'Marin' );
ok !$v->validate( '' );
$v = eventMacro::Validator::ListMemberCheck->new( 'prt_fild10, prt_fild11, gef_fild10' );
ok $v->parsed;
is_deeply($v->{list}, ['prt_fild10', 'prt_fild11', 'gef_fild10']);
ok $v->validate( 'prt_fild10' );
ok $v->validate( 'prt_fild11' );
ok !$v->validate( 'prt_fild12' );
ok $v->validate( 'gef_fild10' );
ok !$v->validate( 'gef_fild12' );
};
subtest 'single variable member' => sub {
my $v = eventMacro::Validator::ListMemberCheck->new( '$foo' );
ok $v->parsed;
is_deeply($v->{list}, [undef]);
is_deeply($v->{var_to_member_index}, {'$foo' => [0]});
ok !$v->validate( 'Poring' );
ok !$v->validate( 'Drops' );
ok !$v->validate( 'poring' );
$v->update_vars( '$foo', 'Poring' );
is_deeply($v->{list}, ['Poring']);
ok $v->validate( 'Poring' );
ok !$v->validate( 'Drops' );
ok !$v->validate( 'poring' );
$v = eventMacro::Validator::ListMemberCheck->new( '$foo{map}' );
ok $v->parsed;
is_deeply($v->{list}, [undef]);
is_deeply($v->{var_to_member_index}, {'$foo{map}' => [0]});
ok !$v->validate( 'geffen' );
ok !$v->validate( 'prt_fild10' );
$v->update_vars( '$foo{map}', 'prt_fild10' );
is_deeply($v->{list}, ['prt_fild10']);
ok !$v->validate( 'geffen' );
ok $v->validate( 'prt_fild10' );
};
subtest 'multiple variable members' => sub {
my $v = eventMacro::Validator::ListMemberCheck->new( '$foo, $bar[5], $foobar{mob}' );
ok $v->parsed;
is_deeply($v->{list}, [undef, undef, undef]);
is_deeply($v->{var_to_member_index}, {'$foo' => [0], '$bar[5]' => [1],'$foobar{mob}' => [2]});
ok !$v->validate( 'Poring' );
ok !$v->validate( 'Drops' );
ok !$v->validate( 'poring' );
ok !$v->validate( 'Marin' );
$v->update_vars( '$foo', 'Poring' );
is_deeply($v->{list}, ['Poring', undef, undef]);
ok $v->validate( 'Poring' );
ok !$v->validate( 'Drops' );
ok !$v->validate( 'poring' );
ok !$v->validate( 'Marin' );
$v->update_vars( '$foobar{mob}', 'poring' );
is_deeply($v->{list}, ['Poring', undef, 'poring']);
ok $v->validate( 'Poring' );
ok !$v->validate( 'Drops' );
ok $v->validate( 'poring' );
ok !$v->validate( 'Marin' );
$v->update_vars( '$bar[5]', 'Drops' );
is_deeply($v->{list}, ['Poring', 'Drops', 'poring']);
ok $v->validate( 'Poring' );
ok $v->validate( 'Drops' );
ok $v->validate( 'poring' );
ok !$v->validate( 'Marin' );
};
subtest 'multiple nested variable members' => sub {
my $v = eventMacro::Validator::ListMemberCheck->new( '$foo{$buz}, $bar[$hash{mob}], $baz{$bar[$foo]}' );
ok $v->parsed;
is_deeply($v->{list}, [undef, undef, undef]);
is_deeply($v->{var_to_member_index}, {'$foo{$buz}' => [0], '$bar[$hash{mob}]' => [1],'$baz{$bar[$foo]}' => [2]});
ok !$v->validate( 'Poring' );
ok !$v->validate( 'Drops' );
ok !$v->validate( 'poring' );
ok !$v->validate( 'Marin' );
$v->update_vars( '$foo{$buz}', 'Poring' );
is_deeply($v->{list}, ['Poring', undef, undef]);
ok $v->validate( 'Poring' );
ok !$v->validate( 'Drops' );
ok !$v->validate( 'poring' );
ok !$v->validate( 'Marin' );
$v->update_vars( '$baz{$bar[$foo]}', 'poring' );
is_deeply($v->{list}, ['Poring', undef, 'poring']);
ok $v->validate( 'Poring' );
ok !$v->validate( 'Drops' );
ok $v->validate( 'poring' );
ok !$v->validate( 'Marin' );
$v->update_vars( '$bar[$hash{mob}]', 'Drops' );
is_deeply($v->{list}, ['Poring', 'Drops', 'poring']);
ok $v->validate( 'Poring' );
ok $v->validate( 'Drops' );
ok $v->validate( 'poring' );
ok !$v->validate( 'Marin' );
};
}
1;
```
|
Mount Hope, California may refer to:
Mount Hope, California, former name of Hayden Hill, California
Mount Hope, San Diego, California
|
```go
package otto
import (
"testing"
)
func TestFunction(t *testing.T) {
tt(t, func() {
test, _ := test()
test(`
var abc = Object.getOwnPropertyDescriptor(Function, "prototype");
[ [ typeof Function.prototype, typeof Function.prototype.length, Function.prototype.length ],
[ abc.writable, abc.enumerable, abc.configurable ] ];
`, "function,number,0,false,false,false")
})
}
func Test_argumentList2parameterList(t *testing.T) {
tt(t, func() {
is(argumentList2parameterList([]Value{toValue("abc, def"), toValue("ghi")}), []string{"abc", "def", "ghi"})
})
}
func TestFunction_new(t *testing.T) {
tt(t, func() {
test, _ := test()
test(`raise:
new Function({});
`, "SyntaxError: Unexpected identifier")
test(`
var abc = Function("def, ghi", "jkl", "return def+ghi+jkl");
[ typeof abc, abc instanceof Function, abc("ab", "ba", 1) ];
`, "function,true,abba1")
test(`raise:
var abc = {
toString: function() { throw 1; }
};
var def = {
toString: function() { throw 2; }
};
var ghi = new Function(abc, def);
ghi;
`, "1")
// S15.3.2.1_A3_T10
test(`raise:
var abc = {
toString: function() { return "z;x"; }
};
var def = "return this";
var ghi = new Function(abc, def);
ghi;
`, "SyntaxError: Unexpected token ;")
test(`raise:
var abc;
var def = "return true";
var ghi = new Function(null, def);
ghi;
`, "SyntaxError: Unexpected token null")
})
}
func TestFunction_apply(t *testing.T) {
tt(t, func() {
test, _ := test()
test(`Function.prototype.apply.length`, 2)
test(`String.prototype.substring.apply("abc", [1, 11])`, "bc")
})
}
func TestFunction_call(t *testing.T) {
tt(t, func() {
test, _ := test()
test(`Function.prototype.call.length`, 1)
test(`String.prototype.substring.call("abc", 1, 11)`, "bc")
})
}
func TestFunctionArguments(t *testing.T) {
tt(t, func() {
test, _ := test()
// Should not be able to delete arguments
test(`
function abc(def, arguments){
delete def;
return def;
}
abc(1);
`, 1)
// Again, should not be able to delete arguments
test(`
function abc(def){
delete def;
return def;
}
abc(1);
`, 1)
// Test typeof of a function argument
test(`
function abc(def, ghi, jkl){
return typeof jkl
}
abc("1st", "2nd", "3rd", "4th", "5th");
`, "string")
test(`
function abc(def, ghi, jkl){
arguments[0] = 3.14;
arguments[1] = 'Nothing happens';
arguments[2] = 42;
if (3.14 === def && 'Nothing happens' === ghi && 42 === jkl)
return true;
}
abc(-1, 4.2, 314);
`, true)
})
}
func TestFunctionDeclarationInFunction(t *testing.T) {
tt(t, func() {
test, _ := test()
// Function declarations happen AFTER parameter/argument declarations
// That is, a function declared within a function will shadow/overwrite
// declared parameters
test(`
function abc(def){
return def;
function def(){
return 1;
}
}
typeof abc();
`, "function")
})
}
func TestArguments_defineOwnProperty(t *testing.T) {
tt(t, func() {
test, _ := test()
test(`
var abc;
var def = true;
var ghi = {};
(function (a, b, c) {
Object.defineProperty(arguments, "0", {
value: 42,
writable: false,
enumerable: false,
configurable: false
});
Object.defineProperty(arguments, "1", {
value: 3.14,
configurable: true,
enumerable: true
});
abc = Object.getOwnPropertyDescriptor(arguments, "0");
for (var name in arguments) {
ghi[name] = (ghi[name] || 0) + 1;
if (name === "0") {
def = false;
}
}
}(0, 1, 2));
[ abc.value, abc.writable, abc.enumerable, abc.configurable, def, ghi["1"] ];
`, "42,false,false,false,true,1")
})
}
func TestFunction_bind(t *testing.T) {
tt(t, func() {
test, _ := test()
defer mockUTC()()
test(`
abc = function(){
return "abc";
};
def = abc.bind();
[ typeof def.prototype, typeof def.hasOwnProperty, def.hasOwnProperty("caller"), def.hasOwnProperty("arguments"), def() ];
`, "object,function,true,true,abc")
test(`
abc = function(){
return arguments[1];
};
def = abc.bind(undefined, "abc");
ghi = abc.bind(undefined, "abc", "ghi");
[ def(), def("def"), ghi("def") ];
`, ",def,ghi")
test(`
var abc = function () {};
var ghi;
try {
Object.defineProperty(Function.prototype, "xyzzy", {
value: 1001,
writable: true,
enumerable: true,
configurable: true
});
var def = abc.bind({});
ghi = !def.hasOwnProperty("xyzzy") && ghi.xyzzy === 1001;
} finally {
delete Function.prototype.xyzzy;
}
[ ghi ];
`, "true")
test(`
var abc = function (def, ghi) {};
var jkl = abc.bind({});
var mno = abc.bind({}, 1, 2);
[ jkl.length, mno.length ];
`, "2,0")
test(`raise:
Math.bind();
`, "TypeError: 'bind' is not a function")
test(`
function construct(fn, arguments) {
var bound = Function.prototype.bind.apply(fn, [null].concat(arguments));
return new bound();
}
var abc = construct(Date, [1957, 4, 27]);
Object.prototype.toString.call(abc);
`, "[object Date]")
test(`
var fn = function (x, y, z) {
var result = {};
result.abc = x + y + z;
result.def = arguments[0] === "a" && arguments.length === 3;
return result;
};
var newFn = Function.prototype.bind.call(fn, {}, "a", "b", "c");
var result = new newFn();
[ result.hasOwnProperty("abc"), result.hasOwnProperty("def"), result.abc, result.def ];
`, "true,true,abc,true")
test(`
abc = function(){
return "abc";
};
def = abc.bind();
def.toString();
`, "function () { [native code] }")
})
}
func TestFunction_toString(t *testing.T) {
tt(t, func() {
test, _ := test()
test(`raise:
Function.prototype.toString.call(undefined);
`, "TypeError")
test(`
abc = function() { return -1 ;
}
1;
abc.toString();
`, "function() { return -1 ;\n}")
})
}
```
|
```php
<?php
declare(strict_types=1);
/*
* This file is part of the Kimai time-tracking app.
*
* For the full copyright and license information, please view the LICENSE
* file that was distributed with this source code.
*/
namespace DoctrineMigrations;
use App\Doctrine\AbstractMigration;
use Doctrine\DBAL\Schema\Schema;
/**
* Increase the configuration table column length
*
* @version 1.14
*/
final class Version20210405105611 extends AbstractMigration
{
public function getDescription(): string
{
return 'Increase the configuration table column length';
}
public function up(Schema $schema): void
{
$invoices = $schema->getTable('kimai2_configuration');
$invoices->getColumn('value')->setLength(1024);
}
public function down(Schema $schema): void
{
$invoices = $schema->getTable('kimai2_configuration');
$invoices->getColumn('value')->setLength(255);
}
}
```
|
ADAC Formula 4 () was a racing series regulated according to FIA Formula 4 regulations. The inaugural season was the 2015 ADAC Formula 4. It replaced the ADAC Formel Masters, held from 2008 to 2014.
History
Gerhard Berger and the FIA Single Seater Commission launched the FIA Formula 4 in March 2013. The goal of Formula 4 is to make the ladder to Formula 1 more transparent. Besides sporting and technical regulations, costs are regulated too. A car to compete in this category may not exceed a price of €30,000. A single season in Formula 4 may not exceed €100,000 in costs. ADAC F4 will be one of the second phase Formula 4 championships to be launched. The first phase championships were the Italian F4 Championship and Formula 4 Sudamericana which started in 2014. The ADAC championship was launched by the ADAC on 16 July 2014. Italian race car constructor Tatuus was contracted to design and build all the cars.
After the end of the 2022 season, which was understaffed by drivers, there was a long wait for the publication of a racing calendar for 2023. This, together with the rumors about the takeover of the DTM by the ADAC, which was also carried out on 2 December 2022, gave rise to speculation that the championship would not be continued. On 3 December, ADAC announced that ADAC Formula 4 would no longer be advertised for the 2023 season. The high costs compared to other national Formula 4 championships and the low number of drivers are given as reasons for the end of the championship. Only eleven drivers were registered for the last race at the Nürburgring in mid-October, while a week later a total of 41 drivers started at the last race of the Italian F4 race in Scarperia e San Piero.
Car
The championship features Tatuus designed and built cars. The cars are constructed out of carbon fibre and feature a monocoque chassis. The engine is a 1.4L turbo Abarth. This is the same engine as in the Italian F4 Championship.
Champions
Drivers
Teams
Rookies
The result of the championship was decided by different standings. Wins and points of the rookie standings are present in brackets.
Drivers graduated to F2
Bold denotes an active Formula 2 driver.
Gold background denotes ADAC Formula 4 champion.
Circuits
Notes
References
External links
Formula racing series
Formula 4 series
Auto racing series in Germany
Recurring sporting events established in 2015
Recurring sporting events disestablished in 2022
2015 establishments in Germany
2022 disestablishments in Germany
|
```objective-c
//
// MAOfflineCity.h
//
//
#import <Foundation/Foundation.h>
#import "MAOfflineItem.h"
typedef enum{
MAOfflineCityStatusNone __attribute__((deprecated("use MAOfflineItemStatusNone instead"))) = MAOfflineItemStatusNone, /* . */
MAOfflineCityStatusCached __attribute__((deprecated("use MAOfflineItemStatusCached instead"))) = MAOfflineItemStatusCached, /* . */
MAOfflineCityStatusInstalled __attribute__((deprecated("use MAOfflineItemStatusInstalled instead"))) = MAOfflineItemStatusInstalled, /* . */
MAOfflineCityStatusExpired __attribute__((deprecated("use MAOfflineItemStatusExpired instead"))) = MAOfflineItemStatusExpired /* . */
}MAOfflineCityStatus;
@interface MAOfflineCity : MAOfflineItem
/*!
@brief
*/
@property (nonatomic, copy, readonly) NSString *cityCode;
/*!
@brief
*/
@property (nonatomic, copy, readonly) NSString *cityName __attribute__ ((deprecated("use name instead")));
/*!
@brief
*/
@property (nonatomic, copy, readonly) NSString *urlString __attribute__ ((deprecated("Not supported in future version")));
/*!
@brief
*/
@property (nonatomic, assign, readonly) MAOfflineCityStatus status __attribute__ ((deprecated("use itemStatus instead")));
@end
```
|
```shell
Let's play the blame game
Locate a commit by its hash
Specify a range of commits using double dot syntax
Interactive staging
Interactively stage patches
```
|
N.Y. Ain't So Bad: Ali Plays the Blues is an album by drummer Rashied Ali that features blues singer Royal Blue. It was recorded during July and August, 1975, and was released on vinyl in 1976 by Ali's Survival Records. In 1999, it was reissued on CD by Survival in conjunction with the Knit Classics label. On the album, Ali and Blue are joined by saxophonists Marvin Blackman and James Vass, pianist Charles Eubanks, and bassist Benny Wilson.
N.Y. Ain't So Bad marks Royal Blue's only recorded appearance. According to Ali, shortly after the session, the vocalist was beaten to death with a pipe following a domestic quarrel, and his body was dumped on the street. Ali stated that Blue "was the only one of the younger cats who was singing from the heart," and reflected: "He was really articulate in his words, and if you listen to his songs, you can really hear where we was coming from. It was incredible; you don't have to know him, you can know him from his music."
Reception
In a review for AllMusic, Thom Jurek called the album an "all but lost gem, which, in a late modern context, reveals the true roots of jazz," and wrote: "In these seemingly 'straight' blues tunes, a jazz quintet is being itself, stretching the tunes, offering overtones as possibilities, and moving it on over into another space entirely, while firmly remaining a band that backs a blues singer."
The authors of The Penguin Guide to Jazz Recordings described the band as "strong," but stated that "the chemistry isn't compelling."
Michael J. West of JazzTimes called Blue "a joyful baritone in the Jimmy Rushing tradition," and commented: "In an earlier era of jazz, the 'New Thing' players were often accused of abandoning or indeed never properly learning the tradition; N.Y. Ain't So Bad is as deeply immersed in it as any mainstream jazz record."
Author Will Hermes singled out "Moontipping" for praise, calling it "the record's most magical moment," with "Ali's scatter-groove conjuring both swing and clave without pledging allegiance to either, Royal Blue floating above."
Steve Koenig of Perfect Sound Forever noted that Blue was "clearly from the Texas blue tradition," with a voice that "slurs like the horns do." He remarked: "He'll stretch out, yet soft, sweet, single notes are there too."
Track listing
"New York Ain't So Bad" (Royal Blue) – 3:00
"Boss Home Town Love" (Royal Blue) – 4:40
"Moontipping" (Royal Blue) – 5:00
"Everyday" (B.B. King) – 4:45
"Ladies and Gentleman Blues" (Royal Blue) – 6:42
"Real Blues" (Royal Blue) – 4:15
"Royal's Blues" (Royal Blue) – 3:40
"Stormy Monday" (T. Bone Walker) – 5:55
Tracks 1–4 and 6 were recorded on August 26, 1975. Tracks 5, 7, and 8 were recorded on July 12, 1975.
Personnel
Rashied Ali – drums
Royal Blue – vocals
Marvin Blackman – tenor saxophone, flute
James Vass – alto saxophone, flute
Charles Eubanks – piano
Benny Wilson – bass
References
1976 albums
Rashied Ali albums
Survival Records albums
Blues albums by American artists
|
```php
<?php
namespace PragmaRX\Health\Events;
use Illuminate\Broadcasting\InteractsWithSockets;
use Illuminate\Contracts\Broadcasting\ShouldBroadcast;
class HealthPing implements ShouldBroadcast
{
use InteractsWithSockets;
/**
* @var
*/
public $callbackUrl;
/**
* @var
*/
private $channel;
/**
* @var
*/
public $target;
/**
* Create a new event instance.
*/
public function __construct($channel, $callbackUrl, $target)
{
$this->callbackUrl = $callbackUrl;
$this->channel = $channel;
$this->target = $target;
}
/**
* Get the channels the event should broadcast on.
*
* @return array
*/
public function broadcastOn()
{
return [$this->channel];
}
}
```
|
```python
import asyncio
import io
import textwrap
from copy import copy
from typing import Union, Optional, Dict, List, Tuple, Any, Iterator, ItemsView, Literal, cast
import discord
import yaml
from schema import And, Or, Schema, SchemaError, Optional as UseOptional
from redbot.core import commands, config
from redbot.core.bot import Red
from redbot.core.i18n import Translator, cog_i18n
from redbot.core.utils import can_user_react_in
from redbot.core.utils.chat_formatting import box, error, success
from redbot.core.utils.menus import start_adding_reactions
from redbot.core.utils.predicates import ReactionPredicate, MessagePredicate
from .converters import (
CogOrCommand,
RuleType,
ClearableRuleType,
GuildUniqueObjectFinder,
GlobalUniqueObjectFinder,
)
_ = Translator("Permissions", __file__)
COG = "COG"
COMMAND = "COMMAND"
GLOBAL = 0
_OldConfigSchema = Dict[int, Dict[str, Dict[str, Dict[str, Dict[str, List[int]]]]]]
_NewConfigSchema = Dict[str, Dict[int, Dict[str, Dict[int, bool]]]]
# The strings in the schema are constants and should get extracted, but not translated until
# runtime.
translate = _
_ = lambda s: s
YAML_SCHEMA = Schema(
Or(
{
UseOptional(COMMAND): Or(
{
Or(str, int): Or(
{
Or(int, "default"): And(
bool, error=_("Rules must be either `true` or `false`.")
)
},
{},
error=_("Keys under command names must be IDs (numbers) or `default`."),
)
},
{},
error=_("Keys under `COMMAND` must be command names (strings)."),
),
UseOptional(COG): Or(
{
Or(str, int): Or(
{
Or(int, "default"): And(
bool, error=_("Rules must be either `true` or `false`.")
)
},
{},
error=_("Keys under cog names must be IDs or `default`."),
)
},
{},
error=_("Keys under `COG` must be cog names (strings)."),
),
},
{},
error=_("Top-level keys must be either `COG` or `COMMAND`."),
)
)
_ = translate
__version__ = "1.0.0"
@cog_i18n(_)
class Permissions(commands.Cog):
"""Customise permissions for commands and cogs."""
# The command groups in this cog should never directly take any configuration actions
# These should be delegated to specific commands so that it remains trivial
# to prevent the guild owner from ever locking themselves out
# see ``Permissions.__permissions_hook`` for more details
def __init__(self, bot: Red):
super().__init__()
self.bot = bot
# Config Schema:
# "COG"
# -> Cog names...
# -> Guild IDs...
# -> Model IDs...
# -> True|False
# -> "default"
# -> True|False
# "COMMAND"
# -> Command names...
# -> Guild IDs...
# -> Model IDs...
# -> True|False
# -> "default"
# -> True|False
# Note that GLOBAL rules are denoted by an ID of 0.
self.config = config.Config.get_conf(self, identifier=78631113035100160)
self.config.register_global(version="")
self.config.init_custom(COG, 1)
self.config.register_custom(COG)
self.config.init_custom(COMMAND, 1)
self.config.register_custom(COMMAND)
async def red_delete_data_for_user(
self,
*,
requester: Literal["discord_deleted_user", "owner", "user", "user_strict"],
user_id: int,
):
if requester != "discord_deleted_user":
return
count = 0
_uid = str(user_id)
# The dict as returned here as string keys. Above is for comparison,
# there's a below recast to int where needed for guild ids
for typename, getter in ((COG, self.bot.get_cog), (COMMAND, self.bot.get_command)):
obj_type_rules = await self.config.custom(typename).all()
count += 1
if not count % 100:
await asyncio.sleep(0)
for obj_name, rules_dict in obj_type_rules.items():
count += 1
if not count % 100:
await asyncio.sleep(0)
obj = getter(obj_name)
for guild_id, guild_rules in rules_dict.items():
count += 1
if not count % 100:
await asyncio.sleep(0)
if _uid in guild_rules:
if obj:
# delegate to remove rule here
await self._remove_rule(
CogOrCommand(typename, obj.qualified_name, obj),
user_id,
int(guild_id),
)
else:
grp = self.config.custom(typename, obj_name)
await grp.clear_raw(guild_id, user_id)
async def __permissions_hook(self, ctx: commands.Context) -> Optional[bool]:
"""
Purpose of this hook is to prevent guild owner lockouts of permissions specifically
without modifying rule behavior in any other case.
Guild owner is not special cased outside of these configuration commands
to allow guild owner to restrict the use of potentially damaging commands
such as, but not limited to, cleanup to specific channels.
Leaving the configuration commands special cased allows guild owners to fix
any misconfigurations.
"""
if ctx.guild:
if ctx.author == ctx.guild.owner:
# the below should contain all commands from this cog
# which configure or are useful to the
# configuration of guild permissions and should never
# have a potential impact on global configuration
# as well as the parent groups
if ctx.command in (
self.permissions, # main top level group
self.permissions_acl, # acl group
self.permissions_acl_getguild,
self.permissions_acl_setguild,
self.permissions_acl_updateguild,
self.permissions_addguildrule,
self.permissions_clearguildrules,
self.permissions_removeguildrule,
self.permissions_setdefaultguildrule,
self.permissions_canrun,
self.permissions_explain,
):
return True # permission rules will be ignored at this case
# this delegates to permissions rules, do not change to False which would deny
return None
@commands.group()
async def permissions(self, ctx: commands.Context):
"""Command permission management tools."""
pass
@permissions.command(name="explain")
async def permissions_explain(self, ctx: commands.Context):
"""Explain how permissions works."""
# Apologies in advance for the translators out there...
message = _(
"This cog extends the default permission model of the bot. By default, many commands "
"are restricted based on what the command can do.\n"
"This cog allows you to refine some of those restrictions. You can allow wider or "
"narrower access to most commands using it. You cannot, however, change the "
"restrictions on owner-only commands.\n\n"
"When additional rules are set using this cog, those rules will be checked prior to "
"checking for the default restrictions of the command.\n"
"Global rules (set by the owner) are checked first, then rules set for servers. If "
"multiple global or server rules apply to the case, the order they are checked in is:\n"
"1. Rules about a user.\n"
"2. Rules about the voice/stage channel a user is connected to.\n"
"3. Rules about the channel or a parent of the thread a command was issued in.\n"
"4. Rules about a role the user has (The highest role they have with a rule will be "
"used).\n"
"5. Rules about the server a user is in (Global rules only).\n\n"
"For more details, please read the [official documentation]"
"(path_to_url"
)
await ctx.maybe_send_embed(message)
@permissions.command(name="canrun")
async def permissions_canrun(
self, ctx: commands.Context, user: discord.Member, *, command: str
):
"""Check if a user can run a command.
This will take the current context into account, such as the
server and text channel.
"""
if not command:
return await ctx.send_help()
fake_message = copy(ctx.message)
fake_message.author = user
fake_message.content = "{}{}".format(ctx.prefix, command)
com = ctx.bot.get_command(command)
if com is None:
out = _("No such command")
else:
fake_context = await ctx.bot.get_context(fake_message)
try:
can = await com.can_run(
fake_context, check_all_parents=True, change_permission_state=False
)
except commands.CommandError:
can = False
out = (
success(_("That user can run the specified command."))
if can
else error(_("That user can not run the specified command."))
)
await ctx.send(out)
@commands.guildowner_or_permissions(administrator=True)
@permissions.group(name="acl", aliases=["yaml"])
async def permissions_acl(self, ctx: commands.Context):
"""Manage permissions with YAML files."""
@permissions_acl.command(name="yamlexample")
async def permissions_acl_yaml_example(self, ctx: commands.Context):
"""Sends an example of the yaml layout for permissions"""
await ctx.send(
_("Example YAML for setting rules:\n")
+ box(
textwrap.dedent(
"""\
COMMAND:
ping:
12345678901234567: true
56789012345671234: false
COG:
General:
56789012345671234: true
12345678901234567: false
default: false
"""
),
lang="yaml",
)
)
@commands.is_owner()
@permissions_acl.command(name="setglobal")
async def permissions_acl_setglobal(self, ctx: commands.Context):
"""Set global rules with a YAML file.
**WARNING**: This will override reset *all* global rules
to the rules specified in the uploaded file.
This does not validate the names of commands and cogs before
setting the new rules.
"""
await self._permissions_acl_set(ctx, guild_id=GLOBAL, update=False)
@commands.guild_only()
@commands.guildowner_or_permissions(administrator=True)
@permissions_acl.command(name="setserver", aliases=["setguild"])
async def permissions_acl_setguild(self, ctx: commands.Context):
"""Set rules for this server with a YAML file.
**WARNING**: This will override reset *all* rules in this
server to the rules specified in the uploaded file.
"""
await self._permissions_acl_set(ctx, guild_id=ctx.guild.id, update=False)
@commands.is_owner()
@permissions_acl.command(name="getglobal")
async def permissions_acl_getglobal(self, ctx: commands.Context):
"""Get a YAML file detailing all global rules."""
file = await self._yaml_get_acl(guild_id=GLOBAL)
try:
await ctx.author.send(file=file)
except discord.Forbidden:
await ctx.send(_("I'm not allowed to DM you."))
else:
if ctx.guild is not None:
await ctx.send(_("I've just sent the file to you via DM."))
finally:
file.close()
@commands.guild_only()
@commands.guildowner_or_permissions(administrator=True)
@permissions_acl.command(name="getserver", aliases=["getguild"])
async def permissions_acl_getguild(self, ctx: commands.Context):
"""Get a YAML file detailing all rules in this server."""
file = await self._yaml_get_acl(guild_id=ctx.guild.id)
try:
await ctx.author.send(file=file)
except discord.Forbidden:
await ctx.send(_("I'm not allowed to DM you."))
else:
await ctx.send(_("I've just sent the file to you via DM."))
finally:
file.close()
@commands.is_owner()
@permissions_acl.command(name="updateglobal")
async def permissions_acl_updateglobal(self, ctx: commands.Context):
"""Update global rules with a YAML file.
This won't touch any rules not specified in the YAML
file.
"""
await self._permissions_acl_set(ctx, guild_id=GLOBAL, update=True)
@commands.guild_only()
@commands.guildowner_or_permissions(administrator=True)
@permissions_acl.command(name="updateserver", aliases=["updateguild"])
async def permissions_acl_updateguild(self, ctx: commands.Context):
"""Update rules for this server with a YAML file.
This won't touch any rules not specified in the YAML
file.
"""
await self._permissions_acl_set(ctx, guild_id=ctx.guild.id, update=True)
@commands.is_owner()
@permissions.command(name="addglobalrule", require_var_positional=True)
async def permissions_addglobalrule(
self,
ctx: commands.Context,
allow_or_deny: RuleType,
cog_or_command: CogOrCommand,
*who_or_what: GlobalUniqueObjectFinder,
):
"""Add a global rule to a command.
`<allow_or_deny>` should be one of "allow" or "deny".
`<cog_or_command>` is the cog or command to add the rule to.
This is case sensitive.
`<who_or_what...>` is one or more users, channels or roles the rule is for.
"""
for w in who_or_what:
await self._add_rule(
rule=cast(bool, allow_or_deny),
cog_or_cmd=cog_or_command,
model_id=w.id,
guild_id=0,
)
await ctx.send(_("Rule added."))
@commands.guild_only()
@commands.guildowner_or_permissions(administrator=True)
@permissions.command(
name="addserverrule", aliases=["addguildrule"], require_var_positional=True
)
async def permissions_addguildrule(
self,
ctx: commands.Context,
allow_or_deny: RuleType,
cog_or_command: CogOrCommand,
*who_or_what: GuildUniqueObjectFinder,
):
"""Add a rule to a command in this server.
`<allow_or_deny>` should be one of "allow" or "deny".
`<cog_or_command>` is the cog or command to add the rule to.
This is case sensitive.
`<who_or_what...>` is one or more users, channels or roles the rule is for.
"""
for w in who_or_what:
await self._add_rule(
rule=cast(bool, allow_or_deny),
cog_or_cmd=cog_or_command,
model_id=w.id,
guild_id=ctx.guild.id,
)
await ctx.send(_("Rule added."))
@commands.is_owner()
@permissions.command(name="removeglobalrule", require_var_positional=True)
async def permissions_removeglobalrule(
self,
ctx: commands.Context,
cog_or_command: CogOrCommand,
*who_or_what: GlobalUniqueObjectFinder,
):
"""Remove a global rule from a command.
`<cog_or_command>` is the cog or command to remove the rule
from. This is case sensitive.
`<who_or_what...>` is one or more users, channels or roles the rule is for.
"""
for w in who_or_what:
await self._remove_rule(cog_or_cmd=cog_or_command, model_id=w.id, guild_id=GLOBAL)
await ctx.send(_("Rule removed."))
@commands.guild_only()
@commands.guildowner_or_permissions(administrator=True)
@permissions.command(
name="removeserverrule", aliases=["removeguildrule"], require_var_positional=True
)
async def permissions_removeguildrule(
self,
ctx: commands.Context,
cog_or_command: CogOrCommand,
*who_or_what: GlobalUniqueObjectFinder,
):
"""Remove a server rule from a command.
`<cog_or_command>` is the cog or command to remove the rule
from. This is case sensitive.
`<who_or_what...>` is one or more users, channels or roles the rule is for.
"""
for w in who_or_what:
await self._remove_rule(
cog_or_cmd=cog_or_command, model_id=w.id, guild_id=ctx.guild.id
)
await ctx.send(_("Rule removed."))
@commands.guild_only()
@commands.guildowner_or_permissions(administrator=True)
@permissions.command(name="setdefaultserverrule", aliases=["setdefaultguildrule"])
async def permissions_setdefaultguildrule(
self, ctx: commands.Context, allow_or_deny: ClearableRuleType, cog_or_command: CogOrCommand
):
"""Set the default rule for a command in this server.
This is the rule a command will default to when no other rule
is found.
`<allow_or_deny>` should be one of "allow", "deny" or "clear".
"clear" will reset the default rule.
`<cog_or_command>` is the cog or command to set the default
rule for. This is case sensitive.
"""
await self._set_default_rule(
rule=cast(Optional[bool], allow_or_deny),
cog_or_cmd=cog_or_command,
guild_id=ctx.guild.id,
)
await ctx.send(_("Default set."))
@commands.is_owner()
@permissions.command(name="setdefaultglobalrule")
async def permissions_setdefaultglobalrule(
self, ctx: commands.Context, allow_or_deny: ClearableRuleType, cog_or_command: CogOrCommand
):
"""Set the default global rule for a command.
This is the rule a command will default to when no other rule
is found.
`<allow_or_deny>` should be one of "allow", "deny" or "clear".
"clear" will reset the default rule.
`<cog_or_command>` is the cog or command to set the default
rule for. This is case sensitive.
"""
await self._set_default_rule(
rule=cast(Optional[bool], allow_or_deny), cog_or_cmd=cog_or_command, guild_id=GLOBAL
)
await ctx.send(_("Default set."))
@commands.is_owner()
@permissions.command(name="clearglobalrules")
async def permissions_clearglobalrules(self, ctx: commands.Context):
"""Reset all global rules."""
agreed = await self._confirm(ctx)
if agreed:
await self._clear_rules(guild_id=GLOBAL)
await ctx.tick()
@commands.guild_only()
@commands.guildowner_or_permissions(administrator=True)
@permissions.command(name="clearserverrules", aliases=["clearguildrules"])
async def permissions_clearguildrules(self, ctx: commands.Context):
"""Reset all rules in this server."""
agreed = await self._confirm(ctx)
if agreed:
await self._clear_rules(guild_id=ctx.guild.id)
await ctx.tick()
@commands.Cog.listener()
async def on_cog_add(self, cog: commands.Cog) -> None:
"""Event listener for `cog_add`.
This loads rules whenever a new cog is added.
"""
if cog is self:
# This cog has its rules loaded manually in setup()
return
await self._on_cog_add(cog)
@commands.Cog.listener()
async def on_command_add(self, command: commands.Command) -> None:
"""Event listener for `command_add`.
This loads rules whenever a new command is added.
"""
if command.cog is self:
# This cog's commands have their rules loaded manually in setup()
return
await self._on_command_add(command)
async def _on_cog_add(self, cog: commands.Cog) -> None:
self._load_rules_for(
cog_or_command=cog,
rule_dict=await self.config.custom(COG, cog.__class__.__name__).all(),
)
cog.requires.ready_event.set()
async def _on_command_add(self, command: commands.Command) -> None:
self._load_rules_for(
cog_or_command=command,
rule_dict=await self.config.custom(COMMAND, command.qualified_name).all(),
)
command.requires.ready_event.set()
async def _add_rule(
self, rule: bool, cog_or_cmd: CogOrCommand, model_id: int, guild_id: int
) -> None:
"""Add a rule.
Guild ID should be 0 for global rules.
Handles config.
"""
if rule is True:
cog_or_cmd.obj.allow_for(model_id, guild_id=guild_id)
else:
cog_or_cmd.obj.deny_to(model_id, guild_id=guild_id)
async with self.config.custom(cog_or_cmd.type, cog_or_cmd.name).all() as rules:
rules.setdefault(str(guild_id), {})[str(model_id)] = rule
async def _remove_rule(self, cog_or_cmd: CogOrCommand, model_id: int, guild_id: int) -> None:
"""Remove a rule.
Guild ID should be 0 for global rules.
Handles config.
"""
cog_or_cmd.obj.clear_rule_for(model_id, guild_id=guild_id)
guild_id, model_id = str(guild_id), str(model_id)
async with self.config.custom(cog_or_cmd.type, cog_or_cmd.name).all() as rules:
if (guild_rules := rules.get(guild_id)) is not None:
guild_rules.pop(model_id, None)
async def _set_default_rule(
self, rule: Optional[bool], cog_or_cmd: CogOrCommand, guild_id: int
) -> None:
"""Set the default rule.
Guild ID should be 0 for the global default.
Handles config.
"""
cog_or_cmd.obj.set_default_rule(rule, guild_id)
async with self.config.custom(cog_or_cmd.type, cog_or_cmd.name).all() as rules:
rules.setdefault(str(guild_id), {})["default"] = rule
async def _clear_rules(self, guild_id: int) -> None:
"""Clear all global rules or rules for a guild.
Guild ID should be 0 for global rules.
Handles config.
"""
self.bot.clear_permission_rules(guild_id, preserve_default_rule=False)
for category in (COG, COMMAND):
async with self.config.custom(category).all() as all_rules:
for name, rules in all_rules.items():
rules.pop(str(guild_id), None)
async def _permissions_acl_set(
self, ctx: commands.Context, guild_id: int, update: bool
) -> None:
"""Set rules from a YAML file and handle response to users too."""
if not ctx.message.attachments:
await ctx.send(_("Supply a file with next message or type anything to cancel."))
try:
message = await ctx.bot.wait_for(
"message", check=MessagePredicate.same_context(ctx), timeout=30
)
except asyncio.TimeoutError:
await ctx.send(_("You took too long to upload a file."))
return
if not message.attachments:
await ctx.send(_("You have cancelled the upload process."))
return
parsedfile = message.attachments[0]
else:
parsedfile = ctx.message.attachments[0]
try:
await self._yaml_set_acl(parsedfile, guild_id=guild_id, update=update)
except yaml.MarkedYAMLError as e:
await ctx.send(_("Invalid syntax: ") + str(e))
except SchemaError as e:
await ctx.send(
_("Your YAML file did not match the schema: ") + translate(e.errors[-1])
)
else:
await ctx.send(_("Rules set."))
async def _yaml_set_acl(self, source: discord.Attachment, guild_id: int, update: bool) -> None:
"""Set rules from a YAML file."""
with io.BytesIO() as fp:
await source.save(fp)
rules = yaml.safe_load(fp)
if rules is None:
rules = {}
YAML_SCHEMA.validate(rules)
if update is False:
await self._clear_rules(guild_id)
for category, getter in ((COG, self.bot.get_cog), (COMMAND, self.bot.get_command)):
rules_dict = rules.get(category)
if not rules_dict:
continue
conf = self.config.custom(category)
for cmd_name, cmd_rules in rules_dict.items():
cmd_rules = {str(model_id): rule for model_id, rule in cmd_rules.items()}
await conf.set_raw(cmd_name, str(guild_id), value=cmd_rules)
cmd_obj = getter(str(cmd_name))
if cmd_obj is not None:
self._load_rules_for(cmd_obj, {guild_id: cmd_rules})
async def _yaml_get_acl(self, guild_id: int) -> discord.File:
"""Get a YAML file for all rules set in a guild."""
guild_rules = {}
for category in (COG, COMMAND):
guild_rules.setdefault(category, {})
rules_dict = await self.config.custom(category).all()
for cmd_name, cmd_rules in rules_dict.items():
model_rules = cmd_rules.get(str(guild_id))
if model_rules is not None:
guild_rules[category][cmd_name] = dict(_int_key_map(model_rules.items()))
fp = io.BytesIO(yaml.dump(guild_rules, default_flow_style=False).encode("utf-8"))
return discord.File(fp, filename="acl.yaml")
@staticmethod
async def _confirm(ctx: commands.Context) -> bool:
"""Ask "Are you sure?" and get the response as a bool."""
if ctx.guild is None or can_user_react_in(ctx.guild.me, ctx.channel):
msg = await ctx.send(_("Are you sure?"))
# noinspection PyAsyncCall
task = start_adding_reactions(msg, ReactionPredicate.YES_OR_NO_EMOJIS)
pred = ReactionPredicate.yes_or_no(msg, ctx.author)
try:
await ctx.bot.wait_for("reaction_add", check=pred, timeout=30)
except asyncio.TimeoutError:
await ctx.send(_("Response timed out."))
return False
else:
task.cancel()
agreed = pred.result
finally:
await msg.delete()
else:
await ctx.send(_("Are you sure?") + " (yes/no)")
pred = MessagePredicate.yes_or_no(ctx)
try:
await ctx.bot.wait_for("message", check=pred, timeout=30)
except asyncio.TimeoutError:
await ctx.send(_("Response timed out."))
return False
else:
agreed = pred.result
if agreed is False:
await ctx.send(_("Action cancelled."))
return agreed
async def initialize(self) -> None:
"""Initialize this cog.
This will load all rules from config onto every currently
loaded command.
"""
await self._maybe_update_schema()
await self._load_all_rules()
async def _maybe_update_schema(self) -> None:
"""Maybe update rules set by config prior to permissions 1.0.0."""
if await self.config.version():
return
old_config = await self.config.all_guilds()
old_config[GLOBAL] = await self.config.all()
new_cog_rules, new_cmd_rules = self._get_updated_schema(old_config)
await self.config.custom(COG).set(new_cog_rules)
await self.config.custom(COMMAND).set(new_cmd_rules)
await self.config.version.set(__version__)
@staticmethod
def _get_updated_schema(
old_config: _OldConfigSchema,
) -> Tuple[_NewConfigSchema, _NewConfigSchema]:
# Prior to 1.0.0, the schema was in this form for both global
# and guild-based rules:
# "owner_models"
# -> "cogs"
# -> Cog names...
# -> "allow"
# -> [Model IDs...]
# -> "deny"
# -> [Model IDs...]
# -> "default"
# -> "allow"|"deny"
# -> "commands"
# -> Command names...
# -> "allow"
# -> [Model IDs...]
# -> "deny"
# -> [Model IDs...]
# -> "default"
# -> "allow"|"deny"
new_cog_rules = {}
new_cmd_rules = {}
for guild_id, old_rules in old_config.items():
if "owner_models" not in old_rules:
continue
old_rules = old_rules["owner_models"]
for category, new_rules in zip(("cogs", "commands"), (new_cog_rules, new_cmd_rules)):
if category in old_rules:
for name, rules in old_rules[category].items():
these_rules = new_rules.setdefault(name, {})
guild_rules = these_rules.setdefault(str(guild_id), {})
# Since allow rules would take precedence if the same model ID
# sat in both the allow and deny list, we add the deny entries
# first and let any conflicting allow entries overwrite.
for model_id in rules.get("deny", []):
guild_rules[str(model_id)] = False
for model_id in rules.get("allow", []):
guild_rules[str(model_id)] = True
if "default" in rules:
default = rules["default"]
if default == "allow":
guild_rules["default"] = True
elif default == "deny":
guild_rules["default"] = False
return new_cog_rules, new_cmd_rules
async def _load_all_rules(self):
"""Load all of this cog's rules into loaded commands and cogs."""
for category, getter in ((COG, self.bot.get_cog), (COMMAND, self.bot.get_command)):
all_rules = await self.config.custom(category).all()
for name, rules in all_rules.items():
obj = getter(name)
if obj is None:
continue
self._load_rules_for(obj, rules)
@staticmethod
def _load_rules_for(
cog_or_command: Union[commands.Command, commands.Cog],
rule_dict: Dict[Union[int, str], Dict[Union[int, str], bool]],
) -> None:
"""Load the rules into a command or cog object.
rule_dict should be a dict mapping Guild IDs to Model IDs to
rules.
"""
for guild_id, guild_dict in _int_key_map(rule_dict.items()):
for model_id, rule in _int_key_map(guild_dict.items()):
if model_id == "default":
cog_or_command.set_default_rule(rule, guild_id=guild_id)
elif rule is True:
cog_or_command.allow_for(model_id, guild_id=guild_id)
elif rule is False:
cog_or_command.deny_to(model_id, guild_id=guild_id)
async def cog_unload(self) -> None:
await self._unload_all_rules()
async def _unload_all_rules(self) -> None:
"""Unload all rules set by this cog.
This is done instead of just clearing all rules, which could
clear rules set by other cogs.
"""
for category, getter in ((COG, self.bot.get_cog), (COMMAND, self.bot.get_command)):
all_rules = await self.config.custom(category).all()
for name, rules in all_rules.items():
obj = getter(name)
if obj is None:
continue
self._unload_rules_for(obj, rules)
@staticmethod
def _unload_rules_for(
cog_or_command: Union[commands.Command, commands.Cog],
rule_dict: Dict[Union[int, str], Dict[Union[int, str], bool]],
) -> None:
"""Unload the rules from a command or cog object.
rule_dict should be a dict mapping Guild IDs to Model IDs to
rules.
"""
for guild_id, guild_dict in _int_key_map(rule_dict.items()):
for model_id in guild_dict.keys():
if model_id == "default":
cog_or_command.set_default_rule(None, guild_id=guild_id)
else:
cog_or_command.clear_rule_for(int(model_id), guild_id=guild_id)
def _int_key_map(items_view: ItemsView[str, Any]) -> Iterator[Tuple[Union[str, int], Any]]:
for k, v in items_view:
if k == "default":
yield k, v
else:
yield int(k), v
```
|
The 1911 Curtiss Model D (or frequently "Curtiss Pusher") was an early United States pusher aircraft with the engine and propeller behind the pilot's seat. It was among the first aircraft in the world to be built in any quantity, during an era of trial-and-error development and equally important parallel technical development in internal combustion engine technologies.
It was also the aircraft type which made the first takeoff from the deck of a ship (flown by Eugene B. Ely off the deck of on November 14, 1910, near Hampton Roads, Virginia) and made the first landing aboard a ship () on January 18, 1911, near San Francisco, California.
It was originally fitted with a foreplane for pitch control, but this was dispensed with when it was accidentally discovered to be unnecessary. The new version without the foreplane was known as the Headless Pusher.
Like all Curtiss designs, the aircraft used ailerons, which first existed on a Curtiss-designed airframe as quadruple "wing-tip" ailerons on the 1908 June Bug to control rolling in flight, thus avoiding use of the Wright brothers' patented wing warping technology.
Development
The Model D was a biplane fitted with a wheeled tricycle undercarriage. The construction was primarily of spruce, with ash used in parts of the engine bearers and undercarriage beams, with doped linen stretched over it. The outrigger beams were made of bamboo. Prevented by patents from using the Wright Brothers' wing warping technique to provide lateral control, and with neither the Wrights nor himself likely to have known about its prior patenting in 1868 England, Curtiss did not use the June Bug's "wing-tip" aileron configuration, but instead used between-the-wing-panels "inter-plane" ailerons, instead, as directly derived from his earlier Curtiss No. 1 and Curtiss No. 2 pushers. In the end, this proved to be a superior solution. Both the interplane and trailing-edge ailerons on these early aircraft did not use a hand or foot-operated mechanism to operate them, but very much like the earlier Santos-Dumont 14-bis had adopted in November 1906, required the pilot to "lean-into" the turn to operate the ailerons — on the Curtiss pushers, a transverse-rocking, metal framework "shoulder cradle", hinged longitudinally on either side of the pilot's seat - initially as straight metal tubes resting against the pilot's upper arms; and later achieved with "armrests" in a similar location; achieved the connection between the pilot and aileron control cabling. Almost all Model Ds were constructed with a pusher configuration, with the propeller behind the pilot. Because of this configuration, they were often referred to as the "Curtiss Pusher". Early examples were built in a canard configuration, with elevators mounted on struts at the front of the aircraft in addition to a horizontal stabilizer at the rear. Later, the elevators were incorporated into the tail unit, and the canard surface arrangement dispensed with, resulting in what became called the Curtiss "Headless" Pushers.
In addition to amateur aviators, a Model D was purchased in April 1911 by the Aeronautical Division of the U.S. Army Signal Corps as a trainer (S.C. No. 2), and by the Navy as an airborne observation platform. A number of them were exported to foreign militaries, as well, including the Russian Navy. On November 14, 1910, Eugene Ely took off from USS Birmingham in a Model D. This was the first time an aircraft had taken off from a ship. On January 18, 1911, Ely landed a Model D aboard USS Pennsylvania. This was the first aircraft to land on a ship.
Upon his election in November 1915, Congressman Orrin Dubbs Bleakley became the first government official to fly from his home state to Washington, D.C. The trip was made in a 75 hp (56 kW) Curtiss biplane from Philadelphia, piloted by Sergeant William C. Ocker, on leave from the United States Aviation Corps at the time. The trip took 3 hours, 15 minutes, including an unscheduled stop in a wheat field in Maryland.
Variants
Model D-4 with one 40 hp (30 kW) Curtiss four-cylinder inline engine
Model D-8 Signal Corps Number 2, one 40 hp (30 kW) Curtiss Vee engine, top speed of 60 mph (97 km/h) at sea level
Model D-8-75 with one 75 hp (56 kW) Curtiss eight-cylinder Vee engine
Burgess Model Dsingle prototype built under licence by Burgess Company of Marblehead, Massachusetts
Operators
United States Army
Aeronautical Division, U.S. Signal Corps
S.C. No.2 (1911–1914)
United States Navy
Surviving aircraft
A number of Curtiss Pusher original and reproduction aircraft exist, and reproductions of the design date as far back to the era when the original aircraft was in production, mostly built by private parties.
Original – Model D in storage with the Ohio History Connection in Columbus, Ohio. It was assembled by Paul and Josh Wilber in Norwalk, Ohio from 1911-1912 and first flew on October 7, 1912. The original Roberts four-cylinder, two-cycle, 50 horsepower engine was replaced by a Kirkham six-cylinder, four-cycle, 50 horsepower engine. The aircraft is currently in storage. Approximately ninety percent of the aircraft is original.
Replica – Model D airworthy at the Military Aviation Museum in Virginia Beach, Virginia.
Replica – Model D airworthy at the Old Rhinebeck Aerodrome in Red Hook, New York. It was built for the collection in 1976, and has been powered by first a Hall-Scott V8 engine, and more recently, with a vintage Curtiss V8 engine.
Replica – Model D airworthy at the Owls Head Maine Transportation Museum in Owls Head, Maine. It has a Continental O-300 engine installed.
Unknown – Model D airworthy at the Western Antique Aeroplane & Automobile Museum in Hood River, Oregon. It has a Curtiss OX-5 engine installed. It was rebuilt in 1934, but includes parts dating back to 1910.
Replica – Model D on display at the Western Antique Aeroplane & Automobile Museum in Hood River, Oregon. It has a Continental C-85 engine installed.
Replica – Model D on static display at the National Air and Space Museum in Washington, D.C. It was built in 1919 and includes parts from an original airframe. It initially had an OX-5 engine installed, but this was replaced by a Curtiss V8. It was donated to the Smithsonian in 1925.
Replica – Model D on static display at the Minneapolis-Saint Paul International Airport in Saint Paul, Minnesota. It was built in 1964 and was previously owned by Chuck Doyle.
Replica – Model D on static display at the National Museum of the United States Air Force in Dayton, Ohio. It was completed in 1987 and has a replica engine made of wood and plastic.
Replica – Model D on static display at the College Park Aviation Museum in College Park, Maryland. It was completed in 2010.
Replica – Model D on static display at the Durango Silverton Narrow Gauge Railroad Museum in Durango, Colorado. It was built by Dave Claussen and installed in April 2013.
Replica – Model D on static display at the Nebraska National Guard Museum in Seward, Nebraska. It was built by Dave Claussen and installed in July 2016.
Replica – Model D on static display at the Reynolds-Alberta Museum in Wetaskiwin, Alberta, Canada. It incorporates an original Curtiss Pusher engine.
Replica – Model D on static display at Hector International Airport in Fargo, North Dakota. It was built, restored, and flown by Charles Klessig of Galesburg, North Dakota.
Specifications (Model D Type IV)
See also
References
Notes
Bibliography
Casey, Louis S. Curtiss, The Hammondsport Era, 1907-1915, New York: Crown Publishers, 1981, pp. 12–15, .
Jarrett, Philip, editor. Pioneer Aircraft Early Aviation to 1914. London: Putnam Aeronautical Books, 2002. .
Taylor, Michael J. H. Jane's Encyclopedia of Aviation. London: Studio Editions, 1989. .
External links
Flight video of Old Rhinebeck's repro Curtiss Model D
Narrated walkaround video of Old Rhinebeck's repro Curtiss Model D
1910s United States civil utility aircraft
Model D
Single-engined pusher aircraft
Canard aircraft
Aircraft first flown in 1910
Biplanes
|
South East Nanango is a rural locality in the South Burnett Region, Queensland, Australia. In the , South East Nanango had a population of 294 people.
References
South Burnett Region
Localities in Queensland
|
```c++
// (See accompanying file LICENSE_1_0.txt or copy at
// path_to_url
// See path_to_url for the library home page.
//
/// @file
/// @brief string_cast unit test
// *****************************************************************************
// Boost.Test
#define BOOST_TEST_MODULE string_cast unit test
#include <boost/test/unit_test.hpp>
#include <boost/test/utils/string_cast.hpp>
namespace utu = boost::unit_test::utils;
//your_sha256_hash____________//
struct A {
A(int i_) : i(i_) {}
int i;
};
inline std::ostream&
operator<<(std::ostream& ostr, A const& a) { return ostr << "A{i=" << a.i << "}"; }
//your_sha256_hash____________//
BOOST_AUTO_TEST_CASE( test_string_cast )
{
BOOST_TEST( utu::string_cast( 1 ) == "1" );
BOOST_TEST( utu::string_cast( 1.1 ) == "1.1" );
BOOST_TEST( utu::string_cast( -1 ) == "-1" );
BOOST_TEST( utu::string_cast( 1U ) == "1" );
BOOST_TEST( utu::string_cast( 100000000000L ) == "100000000000" );
BOOST_TEST( utu::string_cast( 1LL << 55 ) == "36028797018963968" );
BOOST_TEST( utu::string_cast( 'a' ) == "a" );
BOOST_TEST( utu::string_cast( "abc" ) == "abc" );
BOOST_TEST( utu::string_cast( A(12) ) == "A{i=12}" );
}
//your_sha256_hash____________//
BOOST_AUTO_TEST_CASE( test_string_as )
{
int ival;
BOOST_TEST( utu::string_as<int>( "1", ival ) );
BOOST_TEST( ival == 1 );
BOOST_TEST( utu::string_as<int>( " 2", ival ) );
BOOST_TEST( ival == 2 );
BOOST_TEST( utu::string_as<int>( "+3", ival ) );
BOOST_TEST( ival == 3 );
BOOST_TEST( utu::string_as<int>( "-2", ival ) );
BOOST_TEST( ival == -2 );
double dval;
BOOST_TEST( utu::string_as<double>( "0.32", dval ) );
BOOST_TEST( dval == 0.32 );
BOOST_TEST( utu::string_as<double>( "-1e-3", dval ) );
BOOST_TEST( dval == -0.001 );
unsigned uval;
BOOST_TEST( utu::string_as<unsigned>( "123", uval ) );
BOOST_TEST( uval == 123U );
long lval;
BOOST_TEST( utu::string_as<long>( "909090", lval ) );
BOOST_TEST( lval == 909090 );
long long llval;
BOOST_TEST( utu::string_as<long long>( "1234123412341234", llval ) );
BOOST_TEST( llval == 1234123412341234LL );
std::string sval;
BOOST_TEST( utu::string_as<std::string>( "abc", sval ) );
BOOST_TEST( sval == "abc" );
}
//your_sha256_hash____________//
BOOST_AUTO_TEST_CASE( test_string_as_validations )
{
int ival;
BOOST_TEST( !utu::string_as<int>( "1a", ival ) );
BOOST_TEST( !utu::string_as<int>( "1 ", ival ) );
double dval;
BOOST_TEST( !utu::string_as<double>( "1e-0.1", dval ) );
BOOST_TEST( !utu::string_as<double>( "1.001.1 ", dval ) );
unsigned uval;
BOOST_TEST( !utu::string_as<unsigned>( "1.1", uval ) );
std::string sval;
BOOST_TEST( !utu::string_as<std::string>( "a b", sval ) );
}
// EOF
```
|
```css
Change the style of the decoration with `text-decoration-style`
A great font resource: Google Font API
Underline feature on HTML elements
`letter-spacing` property
Page breaks for printing
```
|
The Holcombe Legion of South Carolina fought in the American Civil War as part of the Confederate States Army. It was a true legion, being made up of different types of units, in this case cavalry (four companies) and infantry (initially eight companies, later expanded to ten).
Peter Fayssoux Stevens, former superintendent of the South Carolina Military Academy (and after the war a bishop of the Reformed Episcopal Church), was authorized by South Carolina Governor Francis Wilkinson Pickens to raise a legion consisting of an infantry regiment, a cavalry battalion and artillery. When asked to name it, Stevens chose to honor the governor's wife, Lucy Holcombe Pickens, in the couple's presence. The unit's motto was "It is for the brave to die, but not to surrender."
The artillery component never materialized, but the legion was organized in fall 1861 and assigned to Evans' Brigade. William Porcher DuBose, later an Episcopal priest and noted theologian, served as its adjutant until 1862. The legion helped defend Charleston, South Carolina, in the summer of 1862. On July 17, Evans was ordered to move his unit to Richmond, Virginia. After reaching the city, the legion's infantry and cavalry were separated, never to be reunited, a common fate for Civil War legions. The cavalry was assigned to bolster the city's defense and eventually became part of the 7th South Carolina Cavalry Regiment. The Holcombe Legion fought in the Second Battle of Bull Run (or Second Manassas), South Mountain and Antietam (or Sharpsburg), all in August and September 1862. The legion suffered 24 dead and 131 wounded at Second Manassas, and DuBose wrote, "The Holcombe Legion was practically destroyed as a regiment; when we gathered up the remains there were about a hundred men." The legion served as skirmishers for a delaying force at the Battle of South Mountain. In September 1863, it mustered 276 men. It participated in the 1864 Siege of Petersburg and the 1865 Appomattox Campaign which ended in Robert E. Lee's surrender to Ulysses S. Grant, effectively ending the war.
See also
List of South Carolina Confederate Civil War units
List of American Civil War legions
References
External links
Some Civil War accounts of John DeWitt McCollough, a chaplain in the Holcombe Legion, in the library of the University of South Carolina
Legions of the American Civil War
Units and formations of the Confederate States Army from South Carolina
1861 establishments in South Carolina
Military units and formations established in 1861
|
```java
/*
*
*
* path_to_url
*
* Unless required by applicable law or agreed to in writing, software
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*/
package com.google.copybara.git;
import static com.google.common.base.Preconditions.checkNotNull;
import static com.google.copybara.config.SkylarkUtil.convertFromNoneable;
import com.google.common.collect.ImmutableList;
import com.google.copybara.CheckoutPath;
import com.google.copybara.DestinationReader;
import com.google.copybara.exception.RepoException;
import com.google.copybara.git.GitRepository.TreeElement;
import com.google.copybara.util.Glob;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.PathMatcher;
import net.starlark.java.annot.StarlarkBuiltin;
import net.starlark.java.eval.EvalException;
/**
* A DestinationReader for reading files from a GitDestination.
*/
@StarlarkBuiltin(
name = "git_destination_reader",
doc = "Handle to read from a git destination",
documented = false)
public class GitDestinationReader extends DestinationReader {
private final GitRepository repository;
private final Path workDir;
private final GitRevision baseline;
public GitDestinationReader(GitRepository repository, GitRevision baseline, Path workDir) {
this.repository = checkNotNull(repository);
this.baseline = checkNotNull(baseline);
this.workDir = checkNotNull(workDir);
}
@Override
public String readFile(String path) throws RepoException {
return repository.readFile(baseline.getSha1(), path);
}
@Override
public void copyDestinationFiles(Object globObj, Object path) throws RepoException,
EvalException {
CheckoutPath checkoutPath = convertFromNoneable(path, null);
Glob glob = Glob.wrapGlob(globObj, null);
if (checkoutPath == null) {
copyDestinationFilesToDirectory(glob, workDir);
} else {
copyDestinationFilesToDirectory(
glob, checkoutPath.getCheckoutDir().resolve(checkoutPath.getPath()));
}
}
@Override
public void copyDestinationFilesToDirectory(Glob glob, Path directory) throws RepoException {
ImmutableList<TreeElement> treeElements = repository.lsTree(baseline, null, true, true);
PathMatcher pathMatcher = glob.relativeTo(directory);
for (TreeElement file : treeElements) {
Path path = directory.resolve(file.getPath());
if (pathMatcher.matches(path)) {
try {
Files.createDirectories(path.getParent());
} catch (IOException e) {
throw new RepoException(String.format("Cannot create parent directory for %s", path), e);
}
}
}
repository.checkout(glob, directory, baseline);
}
@Override
public boolean exists(String path) {
try {
return repository.readFile(baseline.getSha1(), path) != null;
} catch (RepoException e) {
return false;
}
}
}
```
|
```smalltalk
// ==========================================================================
// Squidex Headless CMS
// ==========================================================================
// ==========================================================================
using Squidex.Infrastructure.EventSourcing;
namespace Squidex.Domain.Apps.Events.Schemas;
[EventType(nameof(FieldDeleted))]
public sealed class FieldDeleted : FieldEvent
{
}
```
|
```javascript
module.exports = function(text, replacements) {
if (!this.opts.texts) return '';
var text = this.opts.texts[text];
if (replacements)
for (let key in replacements) {
// console.log(key)
text = text.replace('{' + key + '}',replacements[key]);
}
return text;
}
```
|
Lao, Togo is a village in the Doufelgou Prefecture in the Kara Region of north-eastern Togo.
References
Populated places in Kara Region
Doufelgou Prefecture
|
```java
/*
*
*
* path_to_url
*
* Unless required by applicable law or agreed to in writing, software
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*/
package com.haulmont.cuba.core.entity;
import com.haulmont.chile.core.annotations.MetaClass;
import com.haulmont.chile.core.annotations.MetaProperty;
import com.haulmont.cuba.core.entity.annotation.SystemLevel;
@MetaClass(name = "sys$CategoryAttributeEnumValue")
@SystemLevel
public class CategoryAttributeEnumValue extends BaseUuidEntity {
@MetaProperty
protected String value;
@MetaProperty
protected String localizedValues;
public String getValue() {
return value;
}
public void setValue(String value) {
this.value = value;
}
public String getLocalizedValues() {
return localizedValues;
}
public void setLocalizedValues(String localizedValues) {
this.localizedValues = localizedValues;
}
}
```
|
Bucculatrix canadensisella, the birch skeletonizer, is a moth of the family Bucculatricidae. The species was first described by Vactor Tousey Chambers in 1875. It is found in North America. In Canada, it has been recorded from New Brunswick to British Columbia, Nova Scotia and Prince Edward Island. In the United States, it has been recorded from New York, New Jersey, Michigan, Wisconsin, Minnesota, Pennsylvania, North Carolina, Tennessee, Kentucky and Colorado.
The wingspan is 7–8.5 mm. Adults have been recorded on wing from April to September. Adults are on wing between June and July depending on the location.
The larvae feed on Betula species, including Betula nigra, Betula lutea and Betula occidentalis. They mine the leaves of their host plant.
References
External links
Bug Guide
Larval stage info
Bucculatricidae
Moths described in 1875
Moths of North America
|
```javascript
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
function newArrayWithGetter() {
var arr = [1, 2, 3];
Object.defineProperty(arr, '1', {
get: function() { delete this[1]; return undefined; },
configurable: true
});
return arr;
}
var a = newArrayWithGetter();
var s = a.slice(1);
assertTrue('0' in s);
// Sparse case should hit the same code as above due to presence of the getter.
a = newArrayWithGetter();
a[0xffff] = 4;
s = a.slice(1);
assertTrue('0' in s);
a = newArrayWithGetter();
a.shift();
assertTrue('0' in a);
a = newArrayWithGetter();
a.unshift(0);
assertTrue('2' in a);
```
|
```go
// Unless explicitly stated otherwise all files in this repository are licensed
// This product includes software developed at Datadog (path_to_url
//go:build windows && npm
package http
import (
"fmt"
"sync"
"time"
"unsafe"
"github.com/DataDog/datadog-agent/comp/etw"
etwimpl "github.com/DataDog/datadog-agent/comp/etw/impl"
"github.com/DataDog/datadog-agent/pkg/network/config"
"github.com/DataDog/datadog-agent/pkg/util/log"
"golang.org/x/sys/windows"
)
//nolint:revive // TODO(WKIT) Fix revive linter
type EtwInterface struct {
maxEntriesBuffered int
DataChannel chan []WinHttpTransaction
eventLoopWG sync.WaitGroup
captureHTTP bool
captureHTTPS bool
requestSize int64
// ETW component
httpguid windows.GUID
session etw.Session
}
// NewEtwInterface returns a new EtwInterface instance
func NewEtwInterface(c *config.Config) (*EtwInterface, error) {
ei := &EtwInterface{
maxEntriesBuffered: c.MaxHTTPStatsBuffered,
DataChannel: make(chan []WinHttpTransaction),
captureHTTPS: c.EnableNativeTLSMonitoring,
captureHTTP: c.EnableHTTPMonitoring,
requestSize: c.HTTPMaxRequestFragment,
}
etwSessionName := "SystemProbeUSM_ETW"
etwcomp, err := etwimpl.NewEtw()
if err != nil {
return nil, err
}
ei.session, err = etwcomp.NewSession(etwSessionName, func(_ *etw.SessionConfiguration) {})
if err != nil {
return nil, err
}
// Microsoft-Windows-HttpService {dd5ef90a-6398-47a4-ad34-4dcecdef795f}
// path_to_url
ei.httpguid, err = windows.GUIDFromString("{dd5ef90a-6398-47a4-ad34-4dcecdef795f}")
if err != nil {
return nil, fmt.Errorf("Error creating GUID for HTTPService ETW provider: %v", err)
}
pidsList := []uint32{0}
ei.session.ConfigureProvider(ei.httpguid, func(cfg *etw.ProviderConfiguration) {
cfg.TraceLevel = etw.TRACE_LEVEL_INFORMATION
cfg.PIDs = pidsList
cfg.MatchAnyKeyword = 0x136
})
err = ei.session.EnableProvider(ei.httpguid)
if err != nil {
return nil, fmt.Errorf("Error enabling HTTPService ETW provider: %v", err)
}
return ei, nil
}
//nolint:revive // TODO(WKIT) Fix revive linter
func (hei *EtwInterface) SetCapturedProtocols(http, https bool) {
hei.captureHTTP = http
hei.captureHTTPS = https
SetEnabledProtocols(http, https)
}
//nolint:revive // TODO(WKIT) Fix revive linter
func (hei *EtwInterface) SetMaxFlows(maxFlows uint64) {
log.Debugf("Setting max flows in ETW http source to %v", maxFlows)
SetMaxFlows(maxFlows)
}
//nolint:revive // TODO(WKIT) Fix revive linter
func (hei *EtwInterface) SetMaxRequestBytes(maxRequestBytes uint64) {
log.Debugf("Setting max request bytes in ETW http source to to %v", maxRequestBytes)
SetMaxRequestBytes(maxRequestBytes)
}
//nolint:revive // TODO(WKIT) Fix revive linter
func (hei *EtwInterface) StartReadingHttpFlows() {
hei.OnStart()
hei.eventLoopWG.Add(2)
startingEtwChan := make(chan struct{})
// Currently ETW needs be started on a separate thread
// because it is blocked until subscription is stopped
go func() {
defer hei.eventLoopWG.Done()
startingEtwChan <- struct{}{}
err := hei.session.StartTracing(func(e *etw.DDEventRecord) {
// By default this function call never exits and its callbacks or rather events
// will be returned on the very the same thread until ETW is canceled via
// etw.StopEtw(). There is asynchronous flag which implicitly will create a real
// (Windows API) thread but it is not tested yet.
hei.OnEvent(e)
})
if err == nil {
log.Infof("ETW HttpService subscription completed")
} else {
log.Errorf("ETW HttpService subscription failed with error %v", err)
}
}()
log.Infof("BEFORE hei.eventLoopWG.Done")
// Start reading accumulated HTTP transactions
go func() {
defer hei.eventLoopWG.Done()
defer close(startingEtwChan)
// Block until we get go ahead signal
<-startingEtwChan
// We need to make sure that we are invoked when etw.StartEtw() is called but
// we cannot wait until it exits because it exits only when Agent exit. There
// shoulbe be more elegant ways to deal with that, perhaps adding dedicated
// callback from CGO but for now let's sleep for a second
time.Sleep(time.Second)
log.Infof("Starting etw.ReadHttpTx()")
for {
// etw.ReadHttpTx() should be executed after another thread above executes etw.StartEtw()
// Probably additional synchronization is required
httpTxs, err := ReadHttpTx()
if err != nil {
log.Infof("ETW HttpService subscriptions is stopped. Stopping http monitoring")
return
}
if len(httpTxs) > 0 {
hei.DataChannel <- httpTxs
}
// need a better signalling mechanism
time.Sleep(3 * time.Second)
}
}()
}
//nolint:revive // TODO(WKIT) Fix revive linter
func (hei *EtwInterface) Close() {
hei.OnStop()
if hei.session != nil {
_ = hei.session.StopTracing()
hei.eventLoopWG.Wait()
}
close(hei.DataChannel)
}
func getRelatedActivityID(e *etw.DDEventRecord) *etw.DDGUID {
if e.ExtendedDataCount == 0 || e.ExtendedData == nil {
return nil
}
exDatas := unsafe.Slice(e.ExtendedData, e.ExtendedDataCount)
for _, exData := range exDatas {
var g etw.DDGUID
if exData.ExtType == etw.EVENT_HEADER_EXT_TYPE_RELATED_ACTIVITYID && exData.DataSize == uint16(unsafe.Sizeof(g)) {
activityID := (*etw.DDGUID)(unsafe.Pointer(exData.DataPtr))
return activityID
}
}
return nil
}
// FormatGUID converts a guid structure to a go string
func FormatGUID(guid etw.DDGUID) string {
return fmt.Sprintf("{%08X-%04X-%04X-%02X%02X%02X%02X%02X%02X%02X%02X}",
guid.Data1, guid.Data2, guid.Data3,
guid.Data4[0], guid.Data4[1], guid.Data4[2], guid.Data4[3],
guid.Data4[4], guid.Data4[5], guid.Data4[6], guid.Data4[7])
}
```
|
```java
/*
*
*
* path_to_url
*
* Unless required by applicable law or agreed to in writing, software
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*/
package com.google.android.material.button;
import com.google.android.material.test.R;
import static android.view.View.GONE;
import static androidx.test.platform.app.InstrumentationRegistry.getInstrumentation;
import static com.google.common.truth.Truth.assertThat;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;
import android.content.Context;
import android.graphics.RectF;
import android.view.View;
import android.view.accessibility.AccessibilityNodeInfo;
import android.widget.Checkable;
import android.widget.LinearLayout;
import android.widget.RadioButton;
import android.widget.ToggleButton;
import androidx.test.core.app.ApplicationProvider;
import com.google.android.material.button.MaterialButtonToggleGroup.OnButtonCheckedListener;
import com.google.android.material.shape.AbsoluteCornerSize;
import com.google.android.material.shape.ShapeAppearanceModel;
import java.util.List;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.robolectric.RobolectricTestRunner;
import org.robolectric.annotation.Config;
import org.robolectric.annotation.LooperMode;
@LooperMode(LooperMode.Mode.LEGACY)
/** Tests for {@link com.google.android.material.button.MaterialButtonToggleGroup}. */
@RunWith(RobolectricTestRunner.class)
@Config(sdk = 21)
public class MaterialButtonToggleGroupTest {
private static final float CORNER_SIZE = 10f;
private final Context context = ApplicationProvider.getApplicationContext();
private MaterialButtonToggleGroup toggleGroup;
private int checkedChangeCallCount;
private void themeApplicationContext() {
context.setTheme(R.style.Theme_MaterialComponents_Light_NoActionBar_Bridge);
}
@Before
public void createToggleGroupWithButtons() {
themeApplicationContext();
toggleGroup = new MaterialButtonToggleGroup(context);
for (int i = 0; i < 3; ++i) {
MaterialButton child = new MaterialButton(context);
child.setShapeAppearanceModel(child.getShapeAppearanceModel().withCornerSize(CORNER_SIZE));
toggleGroup.addView(child, i);
getInstrumentation().waitForIdleSync();
}
}
@Test
public void correctShapeAppearances_inToggle_afterAdding() {
MaterialButton firstChild = (MaterialButton) toggleGroup.getChildAt(0);
MaterialButton middleChild = (MaterialButton) toggleGroup.getChildAt(1);
MaterialButton lastChild = (MaterialButton) toggleGroup.getChildAt(2);
toggleGroup.updateChildShapes();
assertShapeAppearance(firstChild.getShapeAppearanceModel(), CORNER_SIZE, CORNER_SIZE, 0, 0);
assertShapeAppearance(middleChild.getShapeAppearanceModel(), 0, 0, 0, 0);
assertShapeAppearance(lastChild.getShapeAppearanceModel(), 0, 0, CORNER_SIZE, CORNER_SIZE);
}
@Test
public void correctShapeAppearances_inToggle_afterAdding_withInnerCorner() {
MaterialButton firstChild = (MaterialButton) toggleGroup.getChildAt(0);
MaterialButton middleChild = (MaterialButton) toggleGroup.getChildAt(1);
MaterialButton lastChild = (MaterialButton) toggleGroup.getChildAt(2);
toggleGroup.setInnerCornerSize(new AbsoluteCornerSize(5));
assertShapeAppearance(firstChild.getShapeAppearanceModel(), CORNER_SIZE, CORNER_SIZE, 5, 5);
assertShapeAppearance(middleChild.getShapeAppearanceModel(), 5, 5, 5, 5);
assertShapeAppearance(lastChild.getShapeAppearanceModel(), 5, 5, CORNER_SIZE, CORNER_SIZE);
}
@Test
public void correctShapeAppearances_inToggle_afterAddingInVertical() {
toggleGroup.setOrientation(LinearLayout.VERTICAL);
MaterialButton firstChild = (MaterialButton) toggleGroup.getChildAt(0);
MaterialButton middleChild = (MaterialButton) toggleGroup.getChildAt(1);
MaterialButton lastChild = (MaterialButton) toggleGroup.getChildAt(2);
toggleGroup.updateChildShapes();
assertShapeAppearance(firstChild.getShapeAppearanceModel(), CORNER_SIZE, 0, CORNER_SIZE, 0);
assertShapeAppearance(middleChild.getShapeAppearanceModel(), 0, 0, 0, 0);
assertShapeAppearance(lastChild.getShapeAppearanceModel(), 0, CORNER_SIZE, 0, CORNER_SIZE);
}
@Test
public void your_sha256_hashCorner() {
toggleGroup.setOrientation(LinearLayout.VERTICAL);
MaterialButton firstChild = (MaterialButton) toggleGroup.getChildAt(0);
MaterialButton middleChild = (MaterialButton) toggleGroup.getChildAt(1);
MaterialButton lastChild = (MaterialButton) toggleGroup.getChildAt(2);
toggleGroup.setInnerCornerSize(new AbsoluteCornerSize(5));
assertShapeAppearance(firstChild.getShapeAppearanceModel(), CORNER_SIZE, 5, CORNER_SIZE, 5);
assertShapeAppearance(middleChild.getShapeAppearanceModel(), 5, 5, 5, 5);
assertShapeAppearance(lastChild.getShapeAppearanceModel(), 5, CORNER_SIZE, 5, CORNER_SIZE);
}
@Test
public void correctShapeAppearances_inToggle_afterSettingViewToGone() {
toggleGroup.setOrientation(LinearLayout.VERTICAL);
MaterialButton firstChild = (MaterialButton) toggleGroup.getChildAt(0);
MaterialButton middleChild = (MaterialButton) toggleGroup.getChildAt(1);
MaterialButton lastChild = (MaterialButton) toggleGroup.getChildAt(2);
firstChild.setVisibility(GONE);
toggleGroup.updateChildShapes();
// Now middle and end child has rounded corners.
assertShapeAppearance(middleChild.getShapeAppearanceModel(), CORNER_SIZE, 0, CORNER_SIZE, 0);
assertShapeAppearance(lastChild.getShapeAppearanceModel(), 0, CORNER_SIZE, 0, CORNER_SIZE);
}
@Test
public void your_sha256_hashrCorner() {
toggleGroup.setOrientation(LinearLayout.VERTICAL);
MaterialButton firstChild = (MaterialButton) toggleGroup.getChildAt(0);
MaterialButton middleChild = (MaterialButton) toggleGroup.getChildAt(1);
MaterialButton lastChild = (MaterialButton) toggleGroup.getChildAt(2);
firstChild.setVisibility(GONE);
toggleGroup.setInnerCornerSize(new AbsoluteCornerSize(5));
// Now middle and end child has rounded corners.
assertShapeAppearance(middleChild.getShapeAppearanceModel(), CORNER_SIZE, 5, CORNER_SIZE, 5);
assertShapeAppearance(lastChild.getShapeAppearanceModel(), 5, CORNER_SIZE, 5, CORNER_SIZE);
}
@Test
public void correctShapeAppearances_inToggle_whenOneVisibleButton() {
MaterialButton firstChild = (MaterialButton) toggleGroup.getChildAt(0);
MaterialButton middleChild = (MaterialButton) toggleGroup.getChildAt(1);
MaterialButton lastChild = (MaterialButton) toggleGroup.getChildAt(2);
firstChild.setVisibility(GONE);
middleChild.setVisibility(GONE);
toggleGroup.updateChildShapes();
// Last child has default shape appearance.
assertShapeAppearance(
lastChild.getShapeAppearanceModel(), CORNER_SIZE, CORNER_SIZE, CORNER_SIZE, CORNER_SIZE);
}
@Test
public void your_sha256_hashorner() {
MaterialButton firstChild = (MaterialButton) toggleGroup.getChildAt(0);
MaterialButton middleChild = (MaterialButton) toggleGroup.getChildAt(1);
MaterialButton lastChild = (MaterialButton) toggleGroup.getChildAt(2);
firstChild.setVisibility(GONE);
middleChild.setVisibility(GONE);
toggleGroup.setInnerCornerSize(new AbsoluteCornerSize(5));
// Last child has default shape appearance.
assertShapeAppearance(
lastChild.getShapeAppearanceModel(), CORNER_SIZE, CORNER_SIZE, CORNER_SIZE, CORNER_SIZE);
}
private static void assertShapeAppearance(
ShapeAppearanceModel shapeAppearanceModel, float... corners) {
RectF ignore = new RectF();
assertThat(
new float[]{
shapeAppearanceModel.getTopLeftCornerSize().getCornerSize(ignore),
shapeAppearanceModel.getBottomLeftCornerSize().getCornerSize(ignore),
shapeAppearanceModel.getTopRightCornerSize().getCornerSize(ignore),
shapeAppearanceModel.getBottomRightCornerSize().getCornerSize(ignore)
})
.isEqualTo(corners);
}
@Test
@Config(sdk = 23)
public void onInitializeAccessibilityNodeInfo() {
AccessibilityNodeInfo groupInfo = AccessibilityNodeInfo.obtain();
toggleGroup.onInitializeAccessibilityNodeInfo(groupInfo);
AccessibilityNodeInfo.CollectionInfo collectionInfo = groupInfo.getCollectionInfo();
assertEquals(3, collectionInfo.getColumnCount());
assertEquals(1, collectionInfo.getRowCount());
MaterialButton secondChild = (MaterialButton) toggleGroup.getChildAt(1);
secondChild.setChecked(true);
AccessibilityNodeInfo buttonInfo = AccessibilityNodeInfo.obtain();
secondChild.onInitializeAccessibilityNodeInfo(buttonInfo);
AccessibilityNodeInfo.CollectionItemInfo itemInfo = buttonInfo.getCollectionItemInfo();
assertEquals(1, itemInfo.getColumnIndex());
assertEquals(0, itemInfo.getRowIndex());
assertTrue(itemInfo.isSelected());
}
@Test
public void singleSelection_withSelectionRequired_doesNotUnSelect() {
toggleGroup.setSelectionRequired(true);
toggleGroup.setSingleSelection(true);
View button = toggleGroup.getChildAt(0);
button.performClick();
button.performClick();
assertThat(((Checkable) button).isChecked()).isTrue();
}
@Test
public void singleSelection_withoutSelectionRequired_unSelects() {
toggleGroup.setSingleSelection(true);
toggleGroup.setSelectionRequired(false);
View button = toggleGroup.getChildAt(0);
button.performClick();
button.performClick();
assertThat(((Checkable) button).isChecked()).isFalse();
}
@Test
public void singleSelection_doesNotMultiSelect() {
toggleGroup.setSingleSelection(true);
View button1 = toggleGroup.getChildAt(0);
button1.performClick();
View button2 = toggleGroup.getChildAt(1);
button2.performClick();
assertThat(((Checkable) button1).isChecked()).isFalse();
assertThat(((Checkable) button2).isChecked()).isTrue();
}
@Test
public void singleSelection_doesNotMultiSelect_programmatically() {
toggleGroup.setSingleSelection(true);
View button1 = toggleGroup.getChildAt(0);
int id1 = View.generateViewId();
button1.setId(id1);
View button2 = toggleGroup.getChildAt(1);
int id2 = View.generateViewId();
button2.setId(id2);
toggleGroup.check(id1);
toggleGroup.check(id2);
assertThat(((Checkable) button1).isChecked()).isFalse();
assertThat(((Checkable) button2).isChecked()).isTrue();
}
@Test
public void multiSelection_correctSelectedIds() {
toggleGroup.setSingleSelection(false);
View button1 = toggleGroup.getChildAt(0);
int id1 = View.generateViewId();
button1.setId(id1);
View button2 = toggleGroup.getChildAt(1);
int id2 = View.generateViewId();
button2.setId(id2);
toggleGroup.check(id1);
toggleGroup.check(id2);
List<Integer> checkedIds = toggleGroup.getCheckedButtonIds();
assertThat(checkedIds.contains(id1)).isTrue();
assertThat(checkedIds.contains(id2)).isTrue();
assertThat(checkedIds.size()).isEqualTo(2);
}
@Test
public void multiSelection_withSelectionRequired_unSelectsIfTwo() {
toggleGroup.setSingleSelection(false);
toggleGroup.setSelectionRequired(true);
View first = toggleGroup.getChildAt(0);
View second = toggleGroup.getChildAt(1);
first.performClick();
second.performClick();
second.performClick();
// first button is selected
assertThat(((Checkable) first).isChecked()).isTrue();
assertThat(((Checkable) second).isChecked()).isFalse();
}
@Test
public void your_sha256_hashs() {
int id = singleSelection_withSelectedRequired_setup();
View child = toggleGroup.findViewById(id);
child.performClick();
child.performClick();
// child button is selected
assertThat(toggleGroup.getCheckedButtonId()).isEqualTo(id);
}
private int singleSelection_withSelectedRequired_setup() {
toggleGroup.setSingleSelection(true);
toggleGroup.setSelectionRequired(true);
View child = toggleGroup.getChildAt(1);
int id = View.generateViewId();
child.setId(id);
return id;
}
@Test
public void singleSelection_withSelectionRequired_callsListenerOnlyOnce() {
int id = singleSelection_withSelectedRequired_setup();
View child = toggleGroup.findViewById(id);
checkedChangeCallCount = 0;
OnButtonCheckedListener listener =
new OnButtonCheckedListener() {
@Override
public void onButtonChecked(
MaterialButtonToggleGroup group, int checkedId, boolean isChecked) {
checkedChangeCallCount++;
}
};
toggleGroup.addOnButtonCheckedListener(listener);
child.performClick();
child.performClick();
assertThat(checkedChangeCallCount).isEqualTo(1);
}
@Test
public void your_sha256_hashndClick() {
int id = singleSelection_withSelectedRequired_setup();
View child = toggleGroup.findViewById(id);
checkedChangeCallCount = 0;
OnButtonCheckedListener listener =
new OnButtonCheckedListener() {
@Override
public void onButtonChecked(
MaterialButtonToggleGroup group, int checkedId, boolean isChecked) {
checkedChangeCallCount++;
}
};
toggleGroup.addOnButtonCheckedListener(listener);
child.setPressed(true);
child.performClick();
assertThat(checkedChangeCallCount).isEqualTo(1);
}
@Test
public void setEnable_false_disablesChildButtons() {
MaterialButton firstChild = (MaterialButton) toggleGroup.getChildAt(0);
MaterialButton middleChild = (MaterialButton) toggleGroup.getChildAt(1);
MaterialButton lastChild = (MaterialButton) toggleGroup.getChildAt(2);
firstChild.setEnabled(true);
middleChild.setEnabled(true);
lastChild.setEnabled(true);
toggleGroup.setEnabled(false);
assertThat(firstChild.isEnabled()).isFalse();
assertThat(middleChild.isEnabled()).isFalse();
assertThat(lastChild.isEnabled()).isFalse();
}
@Test
public void setEnable_true_enablesChildButtons() {
MaterialButton firstChild = (MaterialButton) toggleGroup.getChildAt(0);
MaterialButton middleChild = (MaterialButton) toggleGroup.getChildAt(1);
MaterialButton lastChild = (MaterialButton) toggleGroup.getChildAt(2);
firstChild.setEnabled(false);
middleChild.setEnabled(false);
lastChild.setEnabled(false);
toggleGroup.setEnabled(true);
assertThat(firstChild.isEnabled()).isTrue();
assertThat(middleChild.isEnabled()).isTrue();
assertThat(lastChild.isEnabled()).isTrue();
}
@Test
public void singleSelection_hasRadioButtonA11yClassName() {
toggleGroup.setSingleSelection(true);
View button1 = toggleGroup.getChildAt(0);
assertThat(((MaterialButton) button1).getA11yClassName())
.isEqualTo(RadioButton.class.getName());
}
@Test
public void multiSelection_hasToggleButtonA11yClassName() {
toggleGroup.setSingleSelection(false);
View button1 = toggleGroup.getChildAt(0);
assertThat(((MaterialButton) button1).getA11yClassName())
.isEqualTo(ToggleButton.class.getName());
}
}
```
|
```html
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "path_to_url">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
<title>Testsuite</title>
<link rel="stylesheet" href="../../../doc/src/boostbook.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.79.1">
<link rel="home" href="../index.html" title="The Boost C++ Libraries BoostBook Documentation Subset">
<link rel="up" href="../tribool.html" title="Chapter 22. Boost.Tribool">
<link rel="prev" href="../boost/logic/operator_idp39740160.html" title="Function template operator>>">
<link rel="next" href="../metaparse.html" title="Chapter 23. Boost.Metaparse">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table cellpadding="2" width="100%"><tr>
<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../boost.png"></td>
<td align="center"><a href="../../../index.html">Home</a></td>
<td align="center"><a href="../../../libs/libraries.htm">Libraries</a></td>
<td align="center"><a href="path_to_url">People</a></td>
<td align="center"><a href="path_to_url">FAQ</a></td>
<td align="center"><a href="../../../more/index.htm">More</a></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="../boost/logic/operator_idp39740160.html"><img src="../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../tribool.html"><img src="../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="../metaparse.html"><img src="../../../doc/src/images/next.png" alt="Next"></a>
</div>
<div class="section">
<div class="titlepage"><div><div><h2 class="title" style="clear: both">
<a name="tribool.tests"></a>Testsuite</h2></div></div></div>
<div class="toc"><dl class="toc"><dt><span class="section"><a href="tests.html#tribool.tests.acceptance">Acceptance tests</a></span></dt></dl></div>
<div class="section">
<div class="titlepage"><div><div><h3 class="title">
<a name="tribool.tests.acceptance"></a>Acceptance tests</h3></div></div></div>
<div class="informaltable"><table class="table">
<colgroup>
<col>
<col width="1in">
<col>
</colgroup>
<thead><tr>
<th>Test</th>
<th>Type</th>
<th>Description</th>
<th>If failing...</th>
</tr></thead>
<tbody>
<tr>
<td><p><a href="../../../libs/logic/test/tribool_test.cpp" target="_top">tribool_test.cpp</a></p></td>
<td><p>run</p></td>
<td><p>Test all features of the
<code class="computeroutput"><a class="link" href="../boost/logic/tribool.html" title="Class tribool">boost::logic::tribool</a></code>
class.</p></td>
<td> </td>
</tr>
<tr>
<td><p><a href="../../../libs/logic/test/tribool_rename_test.cpp" target="_top">tribool_rename_test.cpp</a></p></td>
<td><p>run</p></td>
<td><p>Test the use of the
<code class="computeroutput"><a class="link" href="../BOOST_TRIBOOL_THIRD_STATE.html" title="Macro BOOST_TRIBOOL_THIRD_STATE">BOOST_TRIBOOL_THIRD_STATE</a></code>
macro.</p></td>
<td> </td>
</tr>
<tr>
<td><p><a href="../../../libs/logic/test/tribool_io_test.cpp" target="_top">tribool_io_test.cpp</a></p></td>
<td><p>run</p></td>
<td><p>Test tribool input/output.</p></td>
<td> </td>
</tr>
</tbody>
</table></div>
</div>
</div>
<table xmlns:rev="path_to_url~gregod/boost/tools/doc/revision" width="100%"><tr>
<td align="left"></td>
<code class="filename">LICENSE_1_0.txt</code> or copy at <a href="path_to_url" target="_top">path_to_url
</div></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="../boost/logic/operator_idp39740160.html"><img src="../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../tribool.html"><img src="../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="../metaparse.html"><img src="../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>
```
|
Talaka () was a cultural and enlightenment youth organisation in Belarus during Soviet rule. It existed between 1985 and 1990 and was a predecessor and early part of the Perestroyka-inspired pro-independence movement in Soviet Belarus. Several key members of the Talaka later formed the Belarusian Popular Front.
Talaka was created in 1985 as an informal club for protection of historical architecture. Its creators were Siaržuk Vituška, Vintsuk Viachorka (later chairman of the Partyja BNF), Viktar Ivashkevich (later one of the leaders of the Belarusian Popular Front and the Partyja BNF) and several others.
The club organised celebration of traditional holidays, revived traditional ceremonies, participated in archaeologic research. It was active in Samizdat publishing. Towards end of the 1980s the group started to more actively participate in pro-democracy and pro-independence political activities.
External links
http://www.slounik.org/153746.html
1980s in Belarus
Youth organizations based in Belarus
Gallery
|
James Locke (1800-1867) was a 19th Century London draper who is attributed with the creating the name Tweed for the rough woollen cloth, which he was largely responsible for popularising amongst fashionable Victorian society.
Career
James Locke was born in Edinburgh in 1800 and was brought up the Edinburgh suburb of Lochend. In the early 1820s he moved to the Covent Garden area of London and set up in business as an intermediary between Scottish woollen cloth manufacturers and London tailors and consumers. Locke's fortunes were transformed when around 1830 he moved his business premises to 119 Regent Street, London's prestigious shopping street. It was not long before the members of the nobility and fashionable West End society were regular frequenters of his shop. Queen Victoria and Prince Albert were customers of Locke, ensuring a thriving business which meant that he found it necessary to keep a large stock of Scotch woollen goods. This enabled him to expand into the wholesale business, supplying cloth to tailors and clothiers in London and the country. Locke is credited with creating mixtures of colour in Tweed, which he designed to blend in with the rural Scottish landscape, making the material ideal for shooting jackets, providing both warmth and camouflage.
Locke is also widely credited with giving Tweed its name. Tweels were established woollen products of shepherd's plaids, and a letter was sent to Locke by a Hawick manufacturer of tweels about 1831, offering tweels or tweeled (cloth). The letter was misread as tweed by one of Locke's clerks, and understood to be a trade-name for the cloth taken from the name of the River Tweed, which flows through the Scottish Borders textile areas. Messrs Locke advertised the product as Tweed and since then it has been the generic name for this type of fabric.
In common with many successful Victorians, Locke was a supporter of various philanthropic causes, including being on the committees of the Ragged School Union and the Scottish Hospital Charity.
Fishing
Locke's passion was fly fishing for Salmon and Trout. As a boy he fished the rivers round his Edinburgh home and in later life wrote a book for his sons entitled Tweed and Don, or Recollections and Reflections of an Angler, which he had published in Edinburgh in 1860. It was written in the spirit of Izaak Walton's The Compleat Angler, extolling the pastoral joys of a day's fly fishing.
Personal life
James Locke married Catherine Adam Gregg, a native of Ayrshire, in Edinburgh on the 6th March 1837 and they had eight children between 1838 and 1854: John, Elizabeth, Thomas, James, Jenny, Daniel, Kathy and Agnes.
Amongst his friends were the sculptor Thomas Campbell (1790–1858) and George Brunton (1799–1836) a Scottish lawyer and journalist who established the weekly Saturday newspaper, The Patriot.
He died at his home in Addison Road, Kensington on the 5th February 1867 and is buried in a family grave on the west side of Highgate Cemetery with his wife Catherine, eldest son John and daughter Elizabeth (Lizzie).
References
1800 births
1867 deaths
Burials at Highgate Cemetery
Businesspeople from Edinburgh
Drapers
Cloth merchants
Fly fishing
|
Famelica is a genus of sea snails, marine gastropod mollusks in the family Raphitomidae.
Species
Species within the genus Famelica include:
Famelica acus Criscione, Hallan, Puillandre & Fedosov, 2021
Famelica babelica Chino & Stahlschmidt, 2021
Famelica bitrudis (Barnard, 1963)
Famelica catharinae (Verrill & Smith, 1884)
Famelica leucospira Abbate, P. O. V. Lima & Simone, 2022
Famelica mirmidina (Dautzenberg & Fischer, 1896)
Famelica monoceros (Watson, 1881)
Famelica monotropis (Dautzenberg & Fischer, 1896)
Famelica nitida Sysoev, 1990
Famelica pacifica Sysoev & Kantor, 1987
Famelica polyacantha (Stahlschmidt, Chino & Kilburn, 2012)
Famelica pukua Abbate, P. O. V. Lima & Simone, 2022
Famelica scipio (Dall, 1889)
Famelica tajourensis Sysoev & Kantor, 1987
Famelica tasmanica Sysoev & Kantor, 1987
Famelica turritelloides Criscione, Hallan, Puillandre & Fedosov, 2021
Species brought into synonymy
Famelica ischna Dall, 1927: synonym of Famelica monoceros (Watson, 1881)
References
Bouchet, P. & Warén, A. (1980). Revision of the North-East Atlantic bathyal and abyssal Turridae (Mollusca: Gastropoda). Journal of Molluscan Studies. Suppl. 8: 1-119
Gofas, S.; Le Renard, J.; Bouchet, P. (2001). Mollusca. in: Costello, M.J. et al. (eds), European Register of Marine Species: a check-list of the marine species in Europe and a bibliography of guides to their identification. Patrimoines Naturels. 50: 180–213.
External links
Worldwide Mollusc Species Data Base: Raphitomidae
Bouchet, P.; Kantor, Y. I.; Sysoev, A.; Puillandre, N. (2011). A new operational classification of the Conoidea (Gastropoda). Journal of Molluscan Studies. 77(3): 273-308
Criscione, F., Hallan, A., Puillandre, N. & Fedosov, A. (2021). Snails in depth: integrative taxonomy of Famelica, Glaciotomella and Rimosodaphnella (Conoidea: Raphitomidae) from the deep sea of temperate Australia. Invertebrate Systematics. 35: 940-962.
Raphitomidae
Gastropod genera
|
```toml
[package]
org = "foo"
name = "tool_test"
version = "1.0.1"
export = ["tool_test"]
distribution = "2201.6.0-SNAPSHOT"
template = true
[build-options]
observabilityIncluded = true
```
|
The 4 × 400 metres relay at the 1983 World Championships in Athletics was held at the Helsinki Olympic Stadium on August 13 and August 14.
Medals
Records
Existing records at the start of the event.
Results
Heats
All times shown are in minutes.
Heat 1
(Roberta Belle, Easter Gabriel, Rosalyn Bryant, Denean Howard) 3:26.82 Q
(Charmaine Crooks, Jillian Richardson, Molly Killingbeck, Marita Payne) 3:27.21 Q
(Milena Matějkovičová, Zuzana Moravčíková, Taťána Kocembová, Jarmila Kratochvílová) 3:27.60 Q
(Rita Daimer, Ute Thimm, Gisela Gottwald, Gaby Bußmann) 3:29.70 q
(Iulia Radu, Daniela Matei, Cristieana Cojocaru, Elena Lina) 3:30.96 q
Heat 2
(Yelena Korban, Marina Ivanova, Irina Baskakova, Mariya Pinigina) 3:28.77 Q
(Kerstin Walther, Undine Bremer, Ellen Fiedler, Sabine Busch) 3:29.05 Q
(Svobodka Damyanova, Rositsa Stamenova, Katya Ilieva, Galina Penkova) 3:31.11 Q
(Cathy Rattray, Ovrill Dwyer-Brown, Jacqueline Pusey, Grace Jackson) 3:34.17
(Madeline De Jesus, Vilma Paris, Margaret De Jesus, Nilsa Paris) 3:42.79
Final
(Kerstin Walther, Sabine Busch, Marita Koch, Dagmar Rübsam) 3:19.73
(Taťána Kocembová, Milena Matějkovičová, Zuzana Moravčíková, Jarmila Kratochvílová) 3:20.32
(Yelena Korban, Marina Ivanova, Irina Baskakova, Mariya Pinigina) 3:21.16
(Charmaine Crooks, Jillian Richardson, Molly Killingbeck, Marita Payne) 3:27.41
(Roberta Belle, Easter Gabriel, Rosalyn Bryant, Denean Howard) 3:27.57
(Rita Daimer, Ute Thimm, Gisela Gottwald, Gaby Bußmann) 3:29.43
(Svobodka Damyanova, Rositsa Stamenova, Katya Ilieva, Galina Penkova) 3:30.36
(Iulia Radu, Daniela Matei, Cristieana Cojocaru, Elena Lina) 3:35.61
References
IAAF results, heats
IAAF results, final
IAAF Statistics Book Moscow 2013 (pp. 299–300)
4 x 400 metres relay women
Relays at the World Athletics Championships
1983 in women's athletics
|
Statistics of Primera Divisió in the 2002/2003 season.
Overview
It was contested by 9 teams, and FC Santa Coloma won the championship.
First round
Second round
Championship Round
Relegation Round
References
Andorra - List of final tables (RSSSF)
Primera Divisió seasons
Andorra
1
|
```java
/*
* $Id: CellEvents.java 3373 2008-05-12 16:21:24Z xlv $
*
* This code is part of the 'OpenPDF Tutorial'.
* You can find the complete tutorial at the following address:
* path_to_url
*
* This code is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
*
*
*/
package com.lowagie.examples.objects.tables.pdfptable;
import com.lowagie.text.Document;
import com.lowagie.text.Image;
import com.lowagie.text.PageSize;
import com.lowagie.text.Rectangle;
import com.lowagie.text.pdf.PdfContentByte;
import com.lowagie.text.pdf.PdfPCell;
import com.lowagie.text.pdf.PdfPCellEvent;
import com.lowagie.text.pdf.PdfPTable;
import com.lowagie.text.pdf.PdfWriter;
import java.io.FileOutputStream;
/**
* General example using CellEvents.
*/
public class CellEvents implements PdfPCellEvent {
/**
* General example using cell events.
*
* @param args no arguments needed
*/
public static void main(String[] args) {
System.out.println("CellEvents");
// step1
Document document = new Document(PageSize.A4, 50, 50, 50, 50);
try {
// step2
PdfWriter writer = PdfWriter.getInstance(document,
new FileOutputStream("CellEvents.pdf"));
// step3
document.open();
// step4
CellEvents event = new CellEvents();
Image im = Image.getInstance("otsoe.jpg");
im.setRotationDegrees(30);
PdfPTable table = new PdfPTable(4);
table.addCell("text 1");
PdfPCell cell = new PdfPCell(im, true);
cell.setCellEvent(event);
table.addCell(cell);
table.addCell("text 3");
im.setRotationDegrees(0);
table.addCell(im);
table.setTotalWidth(300);
PdfContentByte cb = writer.getDirectContent();
table.writeSelectedRows(0, -1, 50, 600, cb);
table.setHeaderRows(3);
document.add(table);
} catch (Exception de) {
de.printStackTrace();
}
// step5
document.close();
}
/**
* @see com.lowagie.text.pdf.PdfPCellEvent#cellLayout(com.lowagie.text.pdf.PdfPCell, com.lowagie.text.Rectangle,
* com.lowagie.text.pdf.PdfContentByte[])
*/
public void cellLayout(PdfPCell cell, Rectangle position,
PdfContentByte[] canvases) {
PdfContentByte cb = canvases[PdfPTable.TEXTCANVAS];
cb.moveTo(position.getLeft(), position.getBottom());
cb.lineTo(position.getRight(), position.getTop());
cb.stroke();
}
}
```
|
```pod
=pod
=head1 NAME
RSA_generate_key_ex, RSA_generate_key - generate RSA key pair
=head1 SYNOPSIS
#include <openssl/rsa.h>
int RSA_generate_key_ex(RSA *rsa, int bits, BIGNUM *e, BN_GENCB *cb);
Deprecated:
#if OPENSSL_API_COMPAT < 0x00908000L
RSA *RSA_generate_key(int num, unsigned long e,
void (*callback)(int, int, void *), void *cb_arg);
#endif
=head1 DESCRIPTION
RSA_generate_key_ex() generates a key pair and stores it in the B<RSA>
structure provided in B<rsa>. The pseudo-random number generator must
be seeded prior to calling RSA_generate_key_ex().
The modulus size will be of length B<bits>, and the public exponent will be
B<e>. Key sizes with B<num> E<lt> 1024 should be considered insecure.
The exponent is an odd number, typically 3, 17 or 65537.
A callback function may be used to provide feedback about the
progress of the key generation. If B<cb> is not B<NULL>, it
will be called as follows using the BN_GENCB_call() function
described on the L<BN_generate_prime(3)> page.
=over 2
=item *
While a random prime number is generated, it is called as
described in L<BN_generate_prime(3)>.
=item *
When the n-th randomly generated prime is rejected as not
suitable for the key, B<BN_GENCB_call(cb, 2, n)> is called.
=item *
When a random p has been found with p-1 relatively prime to B<e>,
it is called as B<BN_GENCB_call(cb, 3, 0)>.
=back
The process is then repeated for prime q with B<BN_GENCB_call(cb, 3, 1)>.
RSA_generate_key() is deprecated (new applications should use
RSA_generate_key_ex() instead). RSA_generate_key() works in the same way as
RSA_generate_key_ex() except it uses "old style" call backs. See
L<BN_generate_prime(3)> for further details.
=head1 RETURN VALUE
RSA_generate_key_ex() returns 1 on success or 0 on error.
RSA_generate_key() returns the key on success or B<NULL> on error.
The error codes can be obtained by L<ERR_get_error(3)>.
=head1 BUGS
B<BN_GENCB_call(cb, 2, x)> is used with two different meanings.
RSA_generate_key() goes into an infinite loop for illegal input values.
=head1 SEE ALSO
L<ERR_get_error(3)>, L<RAND_bytes(3)>,
L<RSA_generate_key(3)>, L<BN_generate_prime(3)>
=head1 COPYRIGHT
in the file LICENSE in the source distribution or at
L<path_to_url
=cut
```
|
```go
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
// +build amd64,openbsd
package unix
func setTimespec(sec, nsec int64) Timespec {
return Timespec{Sec: sec, Nsec: nsec}
}
func setTimeval(sec, usec int64) Timeval {
return Timeval{Sec: sec, Usec: usec}
}
func SetKevent(k *Kevent_t, fd, mode, flags int) {
k.Ident = uint64(fd)
k.Filter = int16(mode)
k.Flags = uint16(flags)
}
func (iov *Iovec) SetLen(length int) {
iov.Len = uint64(length)
}
func (msghdr *Msghdr) SetControllen(length int) {
msghdr.Controllen = uint32(length)
}
func (cmsg *Cmsghdr) SetLen(length int) {
cmsg.Len = uint32(length)
}
// SYS___SYSCTL is used by syscall_bsd.go for all BSDs, but in modern versions
// of openbsd/amd64 the syscall is called sysctl instead of __sysctl.
const SYS___SYSCTL = SYS_SYSCTL
```
|
Francis Clifton, M.D. (d. 1736), was an English physician.
Education
Clifton was the fourth and youngest son of Josiah Clifton, merchant, of Great Yarmouth, Norfolk, and his wife Mary, the only child of Thomas Fenne of the same town. Deciding to follow the medical profession, he entered Leyden on 23 May 1724, and before the end of the year graduated doctor of medicine there. His inaugural dissertation, De distinctis et con-fluentibus Variolis (Leyden, 1724) was included by Albrecht von Haller in the fifth volume of his Disputationes ad Morborum Historiam et Curationem Facientes.
Career
Clifton afterwards settled in London, where his classical and scientific attainments won him the friendship of many eminent men, including Sir Hans Sloane, at whose instance he was elected a fellow of the Royal Society on 22 June 1727. The same year he published , (London, 1727), which was followed in 1732 by Proposals for Printing, by subscription, all the works of Hippocrates in Greek and Latin, digested in a new and regular manner, but from want of encouragement the intended publication never appeared. Clifton received the honorary degree of M.D. from Cambridge on 26 April 1728, during the visit of George II; was admitted a candidate of the College of Physicians on 23 December in the same year, a fellow on 22 December 1729, and read the Gulstonian lectures in 1732.
In 1731 he published Tabular observations recommended as the plainest and surest way of practising and improving physick. The state of physick, ancient and modern, briefly considered in the following year: with a plan for the improvement of it. In these, Clifton advocated that physicians should base their ideas about the effectiveness of their remedies on a statistical analysis of their effects on their patients, rather than on theory.
Death in Jamaica
Clifton also held the appointment of physician to Frederick, Prince of Wales, which he resigned, and abruptly quitted London for Jamaica in 1734. Writing to Sir Hans Sloane from Kingston in that island on 3 June 1736, he says : "My misfortunes came so fast upon me, and my brother's provocations were so frequently repeated, that I was hurried in a manner to death about 'em". He died a few weeks afterwards, leaving no issue by his wife, Sarah Banckes, daughter of a merchant in Leadenhall Street. In the letters of administration P.C.C. granted on 6 Nov. 1736 to his widow, Clifton is described as "late of the parish of St. George, Hanover Square, Middlesex, but at Kingston in Jamaica, deceased". His widow survived until 1747, and was buried in the parish church of St. Andrew Undershaft.
At the time of his death Clifton was engaged in drawing up an account of the diseases of Jamaica, but left it unfinished. He also published Hippocrates upon Air, Water, and Situation ... To this is added Thucydides' Account of the Plague of Athens. Translated and ... illustrated with notes (London 1734).
References
Year of birth missing
1736 deaths
People from Great Yarmouth
18th-century English medical doctors
Fellows of the Royal Society
|
```php
<?php
/**
* FecShop file.
*
* @link path_to_url
* @license path_to_url
*/
return [
/**
* Payment @appfront/config/fecshop_local_modules/Payment.php
*
*/
'payment' => [
'class' => '\fecshop\app\appfront\modules\Payment\Module',
/**
* params
*/
'params'=> [
],
],
];
```
|
```javascript
/*!
* BootstrapValidator (path_to_url
* The best jQuery plugin to validate form fields. Designed to use with Bootstrap 3
*
* @version v0.5.1-dev, built on 2014-07-23 6:05:15 AM
* @author path_to_url
* @copyright (c) 2013 - 2014 Nguyen Huu Phuoc
* @license MIT
*/
(function($) {
var BootstrapValidator = function(form, options) {
this.$form = $(form);
this.options = $.extend({}, $.fn.bootstrapValidator.DEFAULT_OPTIONS, options);
this.$invalidFields = $([]); // Array of invalid fields
this.$submitButton = null; // The submit button which is clicked to submit form
// Validating status
this.STATUS_NOT_VALIDATED = 'NOT_VALIDATED';
this.STATUS_VALIDATING = 'VALIDATING';
this.STATUS_INVALID = 'INVALID';
this.STATUS_VALID = 'VALID';
// Determine the event that is fired when user change the field value
// Most modern browsers supports input event except IE 7, 8.
// IE 9 supports input event but the event is still not fired if I press the backspace key.
// Get IE version
// path_to_url#comment-7595
var ieVersion = (function() {
var v = 3, div = document.createElement('div'), a = div.all || [];
while (div.innerHTML = '<!--[if gt IE '+(++v)+']><br><![endif]-->', a[0]) {}
return v > 4 ? v : !v;
}());
var el = document.createElement('div');
this._changeEvent = (ieVersion === 9 || !('oninput' in el)) ? 'keyup' : 'input';
// The flag to indicate that the form is ready to submit when a remote/callback validator returns
this._submitIfValid = null;
// Field elements
this._cacheFields = {};
this._init();
};
BootstrapValidator.prototype = {
constructor: BootstrapValidator,
/**
* Init form
*/
_init: function() {
var that = this,
options = {
excluded: this.$form.attr('data-bv-excluded'),
trigger: this.$form.attr('data-bv-trigger'),
message: this.$form.attr('data-bv-message'),
container: this.$form.attr('data-bv-container'),
group: this.$form.attr('data-bv-group'),
submitButtons: this.$form.attr('data-bv-submitbuttons'),
threshold: this.$form.attr('data-bv-threshold'),
live: this.$form.attr('data-bv-live'),
onSuccess: this.$form.attr('data-bv-onsuccess'),
onError: this.$form.attr('data-bv-onerror'),
fields: {},
feedbackIcons: {
valid: this.$form.attr('data-bv-feedbackicons-valid'),
invalid: this.$form.attr('data-bv-feedbackicons-invalid'),
validating: this.$form.attr('data-bv-feedbackicons-validating')
}
};
this.$form
// Disable client side validation in HTML 5
.attr('novalidate', 'novalidate')
.addClass(this.options.elementClass)
// Disable the default submission first
.on('submit.bv', function(e) {
e.preventDefault();
that.validate();
})
.on('click.bv', this.options.submitButtons, function() {
that.$submitButton = $(this);
// The user just click the submit button
that._submitIfValid = true;
})
// Find all fields which have either "name" or "data-bv-field" attribute
.find('[name], [data-bv-field]')
.each(function() {
var $field = $(this),
field = $field.attr('name') || $field.attr('data-bv-field'),
opts = that._parseOptions($field);
if (opts) {
$field.attr('data-bv-field', field);
options.fields[field] = $.extend({}, opts, options.fields[field]);
}
});
this.options = $.extend(true, this.options, options);
for (var field in this.options.fields) {
this._initField(field);
}
this.$form.trigger($.Event('init.form.bv'), {
bv: this,
options: this.options
});
// Prepare the events
if (this.options.onSuccess) {
this.$form.on('success.form.bv', function(e) {
$.fn.bootstrapValidator.helpers.call(that.options.onSuccess, [e]);
});
}
if (this.options.onError) {
this.$form.on('error.form.bv', function(e) {
$.fn.bootstrapValidator.helpers.call(that.options.onError, [e]);
});
}
},
/**
* Parse the validator options from HTML attributes
*
* @param {jQuery} $field The field element
* @returns {Object}
*/
_parseOptions: function($field) {
var field = $field.attr('name') || $field.attr('data-bv-field'),
validators = {},
validator,
v, // Validator name
enabled,
optionName,
optionValue,
html5AttrName,
html5AttrMap;
for (v in $.fn.bootstrapValidator.validators) {
validator = $.fn.bootstrapValidator.validators[v];
enabled = $field.attr('data-bv-' + v.toLowerCase()) + '';
html5AttrMap = ('function' === typeof validator.enableByHtml5) ? validator.enableByHtml5($field) : null;
if ((html5AttrMap && enabled !== 'false')
|| (html5AttrMap !== true && ('' === enabled || 'true' === enabled)))
{
// Try to parse the options via attributes
validator.html5Attributes = $.extend({}, { message: 'message', onerror: 'onError', onsuccess: 'onSuccess' }, validator.html5Attributes);
validators[v] = $.extend({}, html5AttrMap === true ? {} : html5AttrMap, validators[v]);
for (html5AttrName in validator.html5Attributes) {
optionName = validator.html5Attributes[html5AttrName];
optionValue = $field.attr('data-bv-' + v.toLowerCase() + '-' + html5AttrName);
if (optionValue) {
if ('true' === optionValue) {
optionValue = true;
} else if ('false' === optionValue) {
optionValue = false;
}
validators[v][optionName] = optionValue;
}
}
}
}
var opts = {
excluded: $field.attr('data-bv-excluded'),
feedbackIcons: $field.attr('data-bv-feedbackicons'),
trigger: $field.attr('data-bv-trigger'),
message: $field.attr('data-bv-message'),
container: $field.attr('data-bv-container'),
group: $field.attr('data-bv-group'),
selector: $field.attr('data-bv-selector'),
threshold: $field.attr('data-bv-threshold'),
onStatus: $field.attr('data-bv-onstatus'),
onSuccess: $field.attr('data-bv-onsuccess'),
onError: $field.attr('data-bv-onerror'),
validators: validators
},
emptyOptions = $.isEmptyObject(opts), // Check if the field options are set using HTML attributes
emptyValidators = $.isEmptyObject(validators); // Check if the field validators are set using HTML attributes
if (!emptyValidators || (!emptyOptions && this.options.fields && this.options.fields[field])) {
opts.validators = validators;
return opts;
} else {
return null;
}
},
/**
* Init field
*
* @param {String|jQuery} field The field name or field element
*/
_initField: function(field) {
var fields = $([]);
switch (typeof field) {
case 'object':
fields = field;
field = field.attr('data-bv-field');
break;
case 'string':
fields = this.getFieldElements(field);
fields.attr('data-bv-field', field);
break;
default:
break;
}
if (this.options.fields[field] === null || this.options.fields[field].validators === null) {
return;
}
// We don't need to validate non-existing fields
if (fields.length === 0) {
delete this.options.fields[field];
return;
}
var validatorName;
for (validatorName in this.options.fields[field].validators) {
if (!$.fn.bootstrapValidator.validators[validatorName]) {
delete this.options.fields[field].validators[validatorName];
}
}
if (this.options.fields[field].enabled === null) {
this.options.fields[field].enabled = true;
}
var that = this,
total = fields.length,
type = fields.attr('type'),
updateAll = (total === 1) || ('radio' === type) || ('checkbox' === type),
event = ('radio' === type || 'checkbox' === type || 'file' === type || 'SELECT' === fields.eq(0).get(0).tagName) ? 'change' : this._changeEvent,
trigger = (this.options.fields[field].trigger || this.options.trigger || event).split(' '),
events = $.map(trigger, function(item) {
return item + '.update.bv';
}).join(' ');
for (var i = 0; i < total; i++) {
var $field = fields.eq(i),
group = this.options.fields[field].group || this.options.group,
$parent = $field.parents(group),
// Allow user to indicate where the error messages are shown
container = this.options.fields[field].container || this.options.container,
$message = (container && container !== 'tooltip' && container !== 'popover') ? $(container) : this._getMessageContainer($field, group);
if (container && container !== 'tooltip' && container !== 'popover') {
$message.addClass('has-error');
}
// Remove all error messages and feedback icons
$message.find('.help-block[data-bv-validator][data-bv-for="' + field + '"]').remove();
$parent.find('i[data-bv-icon-for="' + field + '"]').remove();
// Whenever the user change the field value, mark it as not validated yet
$field.off(events).on(events, function() {
that.updateStatus($(this), that.STATUS_NOT_VALIDATED);
});
// Create help block elements for showing the error messages
$field.data('bv.messages', $message);
for (validatorName in this.options.fields[field].validators) {
$field.data('bv.result.' + validatorName, this.STATUS_NOT_VALIDATED);
if (!updateAll || i === total - 1) {
$('<small/>')
.css('display', 'none')
.addClass('help-block')
.attr('data-bv-validator', validatorName)
.attr('data-bv-for', field)
.attr('data-bv-result', this.STATUS_NOT_VALIDATED)
.html(this._getMessage(field, validatorName))
.appendTo($message);
}
// Prepare the validator events
if (this.options.fields[field].validators[validatorName].onSuccess) {
$field.on('success.validator.bv', function(e, data) {
$.fn.bootstrapValidator.helpers.call(that.options.fields[field].validators[validatorName].onSuccess, [e, data]);
});
}
if (this.options.fields[field].validators[validatorName].onError) {
$field.on('error.validator.bv', function(e, data) {
$.fn.bootstrapValidator.helpers.call(that.options.fields[field].validators[validatorName].onError, [e, data]);
});
}
}
// Prepare the feedback icons
// Available from Bootstrap 3.1 (path_to_url#forms-control-validation)
if (this.options.fields[field].feedbackIcons !== false && this.options.fields[field].feedbackIcons !== 'false'
&& this.options.feedbackIcons
&& this.options.feedbackIcons.validating && this.options.feedbackIcons.invalid && this.options.feedbackIcons.valid
&& (!updateAll || i === total - 1))
{
$parent.removeClass('has-success').removeClass('has-error').addClass('has-feedback');
var $icon = $('<i/>')
.css('display', 'none')
.addClass('form-control-feedback')
.attr('data-bv-icon-for', field)
// Place it after the label containing the checkbox/radio
// so when clicking the icon, it doesn't effect to the checkbox/radio element
.insertAfter(('checkbox' === type || 'radio' === type) ? $field.parent() : $field);
// The feedback icon does not render correctly if there is no label
// path_to_url
if ($parent.find('label').length === 0) {
$icon.css('top', 0);
}
// Fix feedback icons in input-group
if ($parent.find('.input-group').length !== 0) {
$icon.css({
'top': 0,
'z-index': 100
}).insertAfter($parent.find('.input-group').eq(0));
}
}
}
// Prepare the events
if (this.options.fields[field].onSuccess) {
fields.on('success.field.bv', function(e, data) {
$.fn.bootstrapValidator.helpers.call(that.options.fields[field].onSuccess, [e, data]);
});
}
if (this.options.fields[field].onError) {
fields.on('error.field.bv', function(e, data) {
$.fn.bootstrapValidator.helpers.call(that.options.fields[field].onError, [e, data]);
});
}
if (this.options.fields[field].onStatus) {
fields.on('status.field.bv', function(e, data) {
$.fn.bootstrapValidator.helpers.call(that.options.fields[field].onStatus, [e, data]);
});
}
// Set live mode
events = $.map(trigger, function(item) {
return item + '.live.bv';
}).join(' ');
switch (this.options.live) {
case 'submitted':
break;
case 'disabled':
fields.off(events);
break;
case 'enabled':
/* falls through */
default:
fields.off(events).on(events, function() {
if (that._exceedThreshold($(this))) {
that.validateField($(this));
}
});
break;
}
fields.trigger($.Event('init.field.bv'), {
bv: this,
field: field,
element: fields
});
},
/**
* Get the error message for given field and validator
*
* @param {String} field The field name
* @param {String} validatorName The validator name
* @returns {String}
*/
_getMessage: function(field, validatorName) {
if (!this.options.fields[field] || !$.fn.bootstrapValidator.validators[validatorName]
|| !this.options.fields[field].validators || !this.options.fields[field].validators[validatorName])
{
return '';
}
var options = this.options.fields[field].validators[validatorName];
switch (true) {
case (!!options.message):
return options.message;
case (!!this.options.fields[field].message):
return this.options.fields[field].message;
case (!!$.fn.bootstrapValidator.i18n[validatorName]):
return $.fn.bootstrapValidator.i18n[validatorName]['default'];
default:
return this.options.message;
}
},
/**
* Get the element to place the error messages
*
* @param {jQuery} $field The field element
* @param {String} group
* @returns {jQuery}
*/
_getMessageContainer: function($field, group) {
var $parent = $field.parent();
if ($parent.is(group)) {
return $parent;
}
var cssClasses = $parent.attr('class');
if (!cssClasses) {
return this._getMessageContainer($parent, group);
}
cssClasses = cssClasses.split(' ');
var n = cssClasses.length;
for (var i = 0; i < n; i++) {
if (/^col-(xs|sm|md|lg)-\d+$/.test(cssClasses[i]) || /^col-(xs|sm|md|lg)-offset-\d+$/.test(cssClasses[i])) {
return $parent;
}
}
return this._getMessageContainer($parent, group);
},
/**
* Called when all validations are completed
*/
_submit: function() {
var isValid = this.isValid(),
eventType = isValid ? 'success.form.bv' : 'error.form.bv',
e = $.Event(eventType);
this.$form.trigger(e);
// Call default handler
// Check if whether the submit button is clicked
if (this.$submitButton) {
isValid ? this._onSuccess(e) : this._onError(e);
}
},
/**
* Check if the field is excluded.
* Returning true means that the field will not be validated
*
* @param {jQuery} $field The field element
* @returns {Boolean}
*/
_isExcluded: function($field) {
var excludedAttr = $field.attr('data-bv-excluded'),
// I still need to check the 'name' attribute while initializing the field
field = $field.attr('data-bv-field') || $field.attr('name');
switch (true) {
case (!!field && this.options.fields && this.options.fields[field] && (this.options.fields[field].excluded === 'true' || this.options.fields[field].excluded === true)):
case (excludedAttr === 'true'):
case (excludedAttr === ''):
return true;
case (!!field && this.options.fields && this.options.fields[field] && (this.options.fields[field].excluded === 'false' || this.options.fields[field].excluded === false)):
case (excludedAttr === 'false'):
return false;
default:
if (this.options.excluded) {
// Convert to array first
if ('string' === typeof this.options.excluded) {
this.options.excluded = $.map(this.options.excluded.split(','), function(item) {
// Trim the spaces
return $.trim(item);
});
}
var length = this.options.excluded.length;
for (var i = 0; i < length; i++) {
if (('string' === typeof this.options.excluded[i] && $field.is(this.options.excluded[i]))
|| ('function' === typeof this.options.excluded[i] && this.options.excluded[i].call(this, $field, this) === true))
{
return true;
}
}
}
return false;
}
},
/**
* Check if the number of characters of field value exceed the threshold or not
*
* @param {jQuery} $field The field element
* @returns {Boolean}
*/
_exceedThreshold: function($field) {
var field = $field.attr('data-bv-field'),
threshold = this.options.fields[field].threshold || this.options.threshold;
if (!threshold) {
return true;
}
var cannotType = $.inArray($field.attr('type'), ['button', 'checkbox', 'file', 'hidden', 'image', 'radio', 'reset', 'submit']) !== -1;
return (cannotType || $field.val().length >= threshold);
},
// ---
// Events
// ---
/**
* The default handler of error.form.bv event.
* It will be called when there is a invalid field
*
* @param {jQuery.Event} e The jQuery event object
*/
_onError: function(e) {
if (e.isDefaultPrevented()) {
return;
}
if ('submitted' === this.options.live) {
// Enable live mode
this.options.live = 'enabled';
var that = this;
for (var field in this.options.fields) {
(function(f) {
var fields = that.getFieldElements(f);
if (fields.length) {
var type = $(fields[0]).attr('type'),
event = ('radio' === type || 'checkbox' === type || 'file' === type || 'SELECT' === $(fields[0]).get(0).tagName) ? 'change' : that._changeEvent,
trigger = that.options.fields[field].trigger || that.options.trigger || event,
events = $.map(trigger.split(' '), function(item) {
return item + '.live.bv';
}).join(' ');
fields.off(events).on(events, function() {
if (that._exceedThreshold($(this))) {
that.validateField($(this));
}
});
}
})(field);
}
}
var $invalidField = this.$invalidFields.eq(0);
if ($invalidField) {
// Activate the tab containing the invalid field if exists
var $tabPane = $invalidField.parents('.tab-pane'), tabId;
if ($tabPane && (tabId = $tabPane.attr('id'))) {
$('a[href="#' + tabId + '"][data-toggle="tab"]').tab('show');
}
// Focus to the first invalid field
$invalidField.focus();
}
},
/**
* The default handler of success.form.bv event.
* It will be called when all the fields are valid
*
* @param {jQuery.Event} e The jQuery event object
*/
_onSuccess: function(e) {
if (e.isDefaultPrevented()) {
return;
}
// Submit the form
this.disableSubmitButtons(true).defaultSubmit();
},
/**
* Called after validating a field element
*
* @param {jQuery} $field The field element
* @param {String} [validatorName] The validator name
*/
_onFieldValidated: function($field, validatorName) {
var field = $field.attr('data-bv-field'),
validators = this.options.fields[field].validators,
counter = {},
numValidators = 0,
data = {
bv: this,
field: field,
element: $field,
validator: validatorName
};
// Trigger an event after given validator completes
if (validatorName) {
switch ($field.data('bv.result.' + validatorName)) {
case this.STATUS_INVALID:
$field.trigger($.Event('error.validator.bv'), data);
break;
case this.STATUS_VALID:
$field.trigger($.Event('success.validator.bv'), data);
break;
default:
break;
}
}
counter[this.STATUS_NOT_VALIDATED] = 0;
counter[this.STATUS_VALIDATING] = 0;
counter[this.STATUS_INVALID] = 0;
counter[this.STATUS_VALID] = 0;
for (var v in validators) {
if (validators[v].enabled === false) {
continue;
}
numValidators++;
var result = $field.data('bv.result.' + v);
if (result) {
counter[result]++;
}
}
if (counter[this.STATUS_VALID] === numValidators) {
// Remove from the list of invalid fields
this.$invalidFields = this.$invalidFields.not($field);
$field.trigger($.Event('success.field.bv'), data);
}
// If all validators are completed and there is at least one validator which doesn't pass
else if (counter[this.STATUS_NOT_VALIDATED] === 0 && counter[this.STATUS_VALIDATING] === 0 && counter[this.STATUS_INVALID] > 0) {
// Add to the list of invalid fields
this.$invalidFields = this.$invalidFields.add($field);
$field.trigger($.Event('error.field.bv'), data);
}
},
// ---
// Public methods
// ---
/**
* Retrieve the field elements by given name
*
* @param {String} field The field name
* @returns {null|jQuery[]}
*/
getFieldElements: function(field) {
if (!this._cacheFields[field]) {
this._cacheFields[field] = (this.options.fields[field] && this.options.fields[field].selector)
? $(this.options.fields[field].selector)
: this.$form.find('[name="' + field + '"]');
}
return this._cacheFields[field];
},
/**
* Disable/enable submit buttons
*
* @param {Boolean} disabled Can be true or false
* @returns {BootstrapValidator}
*/
disableSubmitButtons: function(disabled) {
if (!disabled) {
this.$form.find(this.options.submitButtons).removeAttr('disabled');
} else if (this.options.live !== 'disabled') {
// Don't disable if the live validating mode is disabled
this.$form.find(this.options.submitButtons).attr('disabled', 'disabled');
}
return this;
},
/**
* Validate the form
*
* @returns {BootstrapValidator}
*/
validate: function() {
if (!this.options.fields) {
return this;
}
this.disableSubmitButtons(true);
for (var field in this.options.fields) {
this.validateField(field);
}
this._submit();
return this;
},
/**
* Validate given field
*
* @param {String|jQuery} field The field name or field element
* @returns {BootstrapValidator}
*/
validateField: function(field) {
var fields = $([]);
switch (typeof field) {
case 'object':
fields = field;
field = field.attr('data-bv-field');
break;
case 'string':
fields = this.getFieldElements(field);
break;
default:
break;
}
if (this.options.fields[field] && this.options.fields[field].enabled === false) {
return this;
}
var that = this,
type = fields.attr('type'),
total = ('radio' === type || 'checkbox' === type) ? 1 : fields.length,
updateAll = ('radio' === type || 'checkbox' === type),
validators = this.options.fields[field].validators,
validatorName,
validateResult;
for (var i = 0; i < total; i++) {
var $field = fields.eq(i);
if (this._isExcluded($field)) {
continue;
}
for (validatorName in validators) {
if ($field.data('bv.dfs.' + validatorName)) {
$field.data('bv.dfs.' + validatorName).reject();
}
// Don't validate field if it is already done
var result = $field.data('bv.result.' + validatorName);
if (result === this.STATUS_VALID || result === this.STATUS_INVALID || validators[validatorName].enabled === false) {
this._onFieldValidated($field, validatorName);
continue;
}
$field.data('bv.result.' + validatorName, this.STATUS_VALIDATING);
validateResult = $.fn.bootstrapValidator.validators[validatorName].validate(this, $field, validators[validatorName]);
// validateResult can be a $.Deferred object ...
if ('object' === typeof validateResult && validateResult.resolve) {
this.updateStatus(updateAll ? field : $field, this.STATUS_VALIDATING, validatorName);
$field.data('bv.dfs.' + validatorName, validateResult);
validateResult.done(function($f, v, isValid, message) {
// v is validator name
$f.removeData('bv.dfs.' + v);
if (message) {
that.updateMessage($f, v, message);
}
that.updateStatus(updateAll ? $f.attr('data-bv-field') : $f, isValid ? that.STATUS_VALID : that.STATUS_INVALID, v);
if (isValid && that._submitIfValid === true) {
// If a remote validator returns true and the form is ready to submit, then do it
that._submit();
}
});
}
// ... or object { valid: true/false, message: 'dynamic message' }
else if ('object' === typeof validateResult && validateResult.valid !== undefined && validateResult.message !== undefined) {
this.updateMessage(updateAll ? field : $field, validatorName, validateResult.message);
this.updateStatus(updateAll ? field : $field, validateResult.valid ? this.STATUS_VALID : this.STATUS_INVALID, validatorName);
}
// ... or a boolean value
else if ('boolean' === typeof validateResult) {
this.updateStatus(updateAll ? field : $field, validateResult ? this.STATUS_VALID : this.STATUS_INVALID, validatorName);
}
}
}
return this;
},
/**
* Update the error message
*
* @param {String|jQuery} field The field name or field element
* @param {String} validator The validator name
* @param {String} message The message
* @returns {BootstrapValidator}
*/
updateMessage: function(field, validator, message) {
var $fields = $([]);
switch (typeof field) {
case 'object':
$fields = field;
field = field.attr('data-bv-field');
break;
case 'string':
$fields = this.getFieldElements(field);
break;
default:
break;
}
$fields.each(function() {
$(this).data('bv.messages').find('.help-block[data-bv-validator="' + validator + '"][data-bv-for="' + field + '"]').html(message);
});
},
/**
* Update all validating results of field
*
* @param {String|jQuery} field The field name or field element
* @param {String} status The status. Can be 'NOT_VALIDATED', 'VALIDATING', 'INVALID' or 'VALID'
* @param {String} [validatorName] The validator name. If null, the method updates validity result for all validators
* @returns {BootstrapValidator}
*/
updateStatus: function(field, status, validatorName) {
var fields = $([]);
switch (typeof field) {
case 'object':
fields = field;
field = field.attr('data-bv-field');
break;
case 'string':
fields = this.getFieldElements(field);
break;
default:
break;
}
if (status === this.STATUS_NOT_VALIDATED) {
// Reset the flag
this._submitIfValid = false;
}
var that = this,
type = fields.attr('type'),
group = this.options.fields[field].group || this.options.group,
total = ('radio' === type || 'checkbox' === type) ? 1 : fields.length;
for (var i = 0; i < total; i++) {
var $field = fields.eq(i);
if (this._isExcluded($field)) {
continue;
}
var $parent = $field.parents(group),
$message = $field.data('bv.messages'),
$allErrors = $message.find('.help-block[data-bv-validator][data-bv-for="' + field + '"]'),
$errors = validatorName ? $allErrors.filter('[data-bv-validator="' + validatorName + '"]') : $allErrors,
$icon = $parent.find('.form-control-feedback[data-bv-icon-for="' + field + '"]'),
container = this.options.fields[field].container || this.options.container,
isValidField = null;
// Update status
if (validatorName) {
$field.data('bv.result.' + validatorName, status);
} else {
for (var v in this.options.fields[field].validators) {
$field.data('bv.result.' + v, status);
}
}
// Show/hide error elements and feedback icons
$errors.attr('data-bv-result', status);
// Determine the tab containing the element
var $tabPane = $field.parents('.tab-pane'),
tabId, $tab;
if ($tabPane && (tabId = $tabPane.attr('id'))) {
$tab = $('a[href="#' + tabId + '"][data-toggle="tab"]').parent();
}
switch (status) {
case this.STATUS_VALIDATING:
isValidField = null;
this.disableSubmitButtons(true);
$parent.removeClass('has-success').removeClass('has-error');
if ($icon) {
$icon.removeClass(this.options.feedbackIcons.valid).removeClass(this.options.feedbackIcons.invalid).addClass(this.options.feedbackIcons.validating).show();
}
if ($tab) {
$tab.removeClass('bv-tab-success').removeClass('bv-tab-error');
}
break;
case this.STATUS_INVALID:
isValidField = false;
this.disableSubmitButtons(true);
$parent.removeClass('has-success').addClass('has-error');
if ($icon) {
$icon.removeClass(this.options.feedbackIcons.valid).removeClass(this.options.feedbackIcons.validating).addClass(this.options.feedbackIcons.invalid).show();
}
if ($tab) {
$tab.removeClass('bv-tab-success').addClass('bv-tab-error');
}
break;
case this.STATUS_VALID:
// If the field is valid (passes all validators)
isValidField = ($allErrors.filter('[data-bv-result="' + this.STATUS_NOT_VALIDATED +'"]').length === 0)
? ($allErrors.filter('[data-bv-result="' + this.STATUS_VALID +'"]').length === $allErrors.length) // All validators are completed
: null; // There are some validators that have not done
if (isValidField !== null) {
this.disableSubmitButtons(this.$submitButton ? !this.isValid() : !isValidField);
if ($icon) {
$icon
.removeClass(this.options.feedbackIcons.invalid).removeClass(this.options.feedbackIcons.validating).removeClass(this.options.feedbackIcons.valid)
.addClass(isValidField ? this.options.feedbackIcons.valid : this.options.feedbackIcons.invalid)
.show();
}
}
$parent.removeClass('has-error has-success').addClass(this.isValidContainer($parent) ? 'has-success' : 'has-error');
if ($tab) {
$tab.removeClass('bv-tab-success').removeClass('bv-tab-error').addClass(this.isValidContainer($tabPane) ? 'bv-tab-success' : 'bv-tab-error');
}
break;
case this.STATUS_NOT_VALIDATED:
/* falls through */
default:
isValidField = null;
this.disableSubmitButtons(false);
$parent.removeClass('has-success').removeClass('has-error');
if ($icon) {
$icon.removeClass(this.options.feedbackIcons.valid).removeClass(this.options.feedbackIcons.invalid).removeClass(this.options.feedbackIcons.validating).hide();
}
if ($tab) {
$tab.removeClass('bv-tab-success').removeClass('bv-tab-error');
}
break;
}
switch (true) {
// Only show the first error message if it is placed inside a tooltip ...
case ($icon && 'tooltip' === container):
(isValidField === false)
? $icon.css('cursor', 'pointer').tooltip('destroy').tooltip({
html: true,
placement: 'top',
title: $allErrors.filter('[data-bv-result="' + that.STATUS_INVALID + '"]').eq(0).html()
})
: $icon.css('cursor', '').tooltip('destroy');
break;
// ... or popover
case ($icon && 'popover' === container):
(isValidField === false)
? $icon.css('cursor', 'pointer').popover('destroy').popover({
content: $allErrors.filter('[data-bv-result="' + that.STATUS_INVALID + '"]').eq(0).html(),
html: true,
placement: 'top',
trigger: 'hover click'
})
: $icon.css('cursor', '').popover('destroy');
break;
default:
(status === this.STATUS_INVALID) ? $errors.show() : $errors.hide();
break;
}
// Trigger an event
$field.trigger($.Event('status.field.bv'), {
bv: this,
field: field,
element: $field,
status: status
});
this._onFieldValidated($field, validatorName);
}
return this;
},
/**
* Check the form validity
*
* @returns {Boolean}
*/
isValid: function() {
for (var field in this.options.fields) {
if (!this.isValidField(field)) {
return false;
}
}
return true;
},
/**
* Check if the field is valid or not
*
* @param {String|jQuery} field The field name or field element
* @returns {Boolean}
*/
isValidField: function(field) {
var fields = $([]);
switch (typeof field) {
case 'object':
fields = field;
field = field.attr('data-bv-field');
break;
case 'string':
fields = this.getFieldElements(field);
break;
default:
break;
}
if (fields.length === 0 || this.options.fields[field] === null || this.options.fields[field].enabled === false) {
return true;
}
var type = fields.attr('type'),
total = ('radio' === type || 'checkbox' === type) ? 1 : fields.length,
$field, validatorName, status;
for (var i = 0; i < total; i++) {
$field = fields.eq(i);
if (this._isExcluded($field)) {
continue;
}
for (validatorName in this.options.fields[field].validators) {
if (this.options.fields[field].validators[validatorName].enabled === false) {
continue;
}
status = $field.data('bv.result.' + validatorName);
if (status !== this.STATUS_VALID) {
return false;
}
}
}
return true;
},
/**
* Check if all fields inside a given container are valid.
* It's useful when working with a wizard-like such as tab, collapse
*
* @param {String|jQuery} container The container selector or element
* @returns {Boolean}
*/
isValidContainer: function(container) {
var that = this,
map = {},
$container = ('string' === typeof container) ? $(container) : container;
if ($container.length === 0) {
return true;
}
$container.find('[data-bv-field]').each(function() {
var $field = $(this),
field = $field.attr('data-bv-field');
if (!that._isExcluded($field) && !map[field]) {
map[field] = $field;
}
});
for (var field in map) {
var $f = map[field];
if ($f.data('bv.messages')
.find('.help-block[data-bv-validator][data-bv-for="' + field + '"]')
.filter(function() {
var v = $(this).attr('data-bv-validator'),
f = $(this).attr('data-bv-for');
return (that.options.fields[f].validators[v].enabled !== false
&& $f.data('bv.result.' + v) && $f.data('bv.result.' + v) !== that.STATUS_VALID);
})
.length !== 0)
{
// The field is not valid
return false;
}
}
return true;
},
/**
* Submit the form using default submission.
* It also does not perform any validations when submitting the form
*/
defaultSubmit: function() {
if (this.$submitButton) {
// Create hidden input to send the submit buttons
$('<input/>')
.attr('type', 'hidden')
.attr('data-bv-submit-hidden', '')
.attr('name', this.$submitButton.attr('name'))
.val(this.$submitButton.val())
.appendTo(this.$form);
}
// Submit form
this.$form.off('submit.bv').submit();
},
// ---
// Useful APIs which aren't used internally
// ---
/**
* Get the list of invalid fields
*
* @returns {jQuery[]}
*/
getInvalidFields: function() {
return this.$invalidFields;
},
/**
* Returns the clicked submit button
*
* @returns {jQuery}
*/
getSubmitButton: function() {
return this.$submitButton;
},
/**
* Get the error messages
*
* @param {String|jQuery} [field] The field name or field element
* If the field is not defined, the method returns all error messages of all fields
* @param {String} [validator] The name of validator
* If the validator is not defined, the method returns error messages of all validators
* @returns {String[]}
*/
getMessages: function(field, validator) {
var that = this,
messages = [],
$fields = $([]);
switch (true) {
case (field && 'object' === typeof field):
$fields = field;
break;
case (field && 'string' === typeof field):
var f = this.getFieldElements(field);
if (f.length > 0) {
var type = f.attr('type');
$fields = ('radio' === type || 'checkbox' === type) ? f.eq(0) : f;
}
break;
default:
$fields = this.$invalidFields;
break;
}
var filter = validator ? '[data-bv-validator="' + validator + '"]' : '';
$fields.each(function() {
messages = messages.concat(
$(this)
.data('bv.messages')
.find('.help-block[data-bv-for="' + $(this).attr('data-bv-field') + '"][data-bv-result="' + that.STATUS_INVALID + '"]' + filter)
.map(function() {
var v = $(this).attr('data-bv-validator'),
f = $(this).attr('data-bv-for');
return (that.options.fields[f].validators[v].enabled === false) ? '' : $(this).html();
})
.get()
);
});
return messages;
},
/**
* Get the field options
*
* @param {String|jQuery} [field] The field name or field element. If it is not set, the method returns the form options
* @param {String} [validator] The name of validator. It null, the method returns form options
* @param {String} [option] The option name
* @return {String|Object}
*/
getOptions: function(field, validator, option) {
if (!field) {
return this.options;
}
if ('object' === typeof field) {
field = field.attr('data-bv-field');
}
if (!this.options.fields[field]) {
return null;
}
var options = this.options.fields[field];
if (!validator) {
return options;
}
if (!options.validators || !options.validators[validator]) {
return null;
}
return option ? options.validators[validator][option] : options.validators[validator];
},
/**
* Update the option of a specific validator
*
* @param {String|jQuery} field The field name or field element
* @param {String} validator The validator name
* @param {String} option The option name
* @param {String} value The value to set
* @returns {BootstrapValidator}
*/
updateOption: function(field, validator, option, value) {
if ('object' === typeof field) {
field = field.attr('data-bv-field');
}
if (this.options.fields[field] && this.options.fields[field].validators[validator]) {
this.options.fields[field].validators[validator][option] = value;
this.updateStatus(field, this.STATUS_NOT_VALIDATED, validator);
}
return this;
},
/**
* Add a new field
*
* @param {String|jQuery} field The field name or field element
* @param {Object} [options] The validator rules
* @returns {BootstrapValidator}
*/
addField: function(field, options) {
var fields = $([]);
switch (typeof field) {
case 'object':
fields = field;
field = field.attr('data-bv-field') || field.attr('name');
break;
case 'string':
delete this._cacheFields[field];
fields = this.getFieldElements(field);
break;
default:
break;
}
fields.attr('data-bv-field', field);
var type = fields.attr('type'),
total = ('radio' === type || 'checkbox' === type) ? 1 : fields.length;
for (var i = 0; i < total; i++) {
var $field = fields.eq(i);
// Try to parse the options from HTML attributes
var opts = this._parseOptions($field);
opts = (opts === null) ? options : $.extend(true, options, opts);
this.options.fields[field] = $.extend(true, this.options.fields[field], opts);
// Update the cache
this._cacheFields[field] = this._cacheFields[field] ? this._cacheFields[field].add($field) : $field;
// Init the element
this._initField(('checkbox' === type || 'radio' === type) ? field : $field);
}
this.disableSubmitButtons(false);
// Trigger an event
this.$form.trigger($.Event('added.field.bv'), {
field: field,
element: fields,
options: this.options.fields[field]
});
return this;
},
/**
* Remove a given field
*
* @param {String|jQuery} field The field name or field element
* @returns {BootstrapValidator}
*/
removeField: function(field) {
var fields = $([]);
switch (typeof field) {
case 'object':
fields = field;
field = field.attr('data-bv-field') || field.attr('name');
fields.attr('data-bv-field', field);
break;
case 'string':
fields = this.getFieldElements(field);
break;
default:
break;
}
if (fields.length === 0) {
return this;
}
var type = fields.attr('type'),
total = ('radio' === type || 'checkbox' === type) ? 1 : fields.length;
for (var i = 0; i < total; i++) {
var $field = fields.eq(i);
// Remove from the list of invalid fields
this.$invalidFields = this.$invalidFields.not($field);
// Update the cache
this._cacheFields[field] = this._cacheFields[field].not($field);
}
if (!this._cacheFields[field] || this._cacheFields[field].length === 0) {
delete this.options.fields[field];
}
if ('checkbox' === type || 'radio' === type) {
this._initField(field);
}
this.disableSubmitButtons(false);
// Trigger an event
this.$form.trigger($.Event('removed.field.bv'), {
field: field,
element: fields
});
return this;
},
/**
* Reset given field
*
* @param {String|jQuery} field The field name or field element
* @param {Boolean} [resetValue] If true, the method resets field value to empty or remove checked/selected attribute (for radio/checkbox)
* @returns {BootstrapValidator}
*/
resetField: function(field, resetValue) {
var $fields = $([]);
switch (typeof field) {
case 'object':
$fields = field;
field = field.attr('data-bv-field');
break;
case 'string':
$fields = this.getFieldElements(field);
break;
default:
break;
}
var total = $fields.length;
if (this.options.fields[field]) {
for (var i = 0; i < total; i++) {
for (var validator in this.options.fields[field].validators) {
$fields.eq(i).removeData('bv.dfs.' + validator);
}
}
}
// Mark field as not validated yet
this.updateStatus(field, this.STATUS_NOT_VALIDATED);
if (resetValue) {
var type = $fields.attr('type');
('radio' === type || 'checkbox' === type) ? $fields.removeAttr('checked').removeAttr('selected') : $fields.val('');
}
return this;
},
/**
* Reset the form
*
* @param {Boolean} [resetValue] If true, the method resets field value to empty or remove checked/selected attribute (for radio/checkbox)
* @returns {BootstrapValidator}
*/
resetForm: function(resetValue) {
for (var field in this.options.fields) {
this.resetField(field, resetValue);
}
this.$invalidFields = $([]);
this.$submitButton = null;
// Enable submit buttons
this.disableSubmitButtons(false);
return this;
},
/**
* Revalidate given field
* It's used when you need to revalidate the field which its value is updated by other plugin
*
* @param {String|jQuery} field The field name of field element
* @returns {BootstrapValidator}
*/
revalidateField: function(field) {
this.updateStatus(field, this.STATUS_NOT_VALIDATED)
.validateField(field);
return this;
},
/**
* Enable/Disable all validators to given field
*
* @param {String} field The field name
* @param {Boolean} enabled Enable/Disable field validators
* @param {String} [validatorName] The validator name. If null, all validators will be enabled/disabled
* @returns {BootstrapValidator}
*/
enableFieldValidators: function(field, enabled, validatorName) {
var validators = this.options.fields[field].validators;
// Enable/disable particular validator
if (validatorName
&& validators
&& validators[validatorName] && validators[validatorName].enabled !== enabled)
{
this.options.fields[field].validators[validatorName].enabled = enabled;
this.updateStatus(field, this.STATUS_NOT_VALIDATED, validatorName);
}
// Enable/disable all validators
else if (!validatorName && this.options.fields[field].enabled !== enabled) {
this.options.fields[field].enabled = enabled;
for (var v in validators) {
this.enableFieldValidators(field, enabled, v);
}
}
return this;
},
/**
* Some validators have option which its value is dynamic.
* For example, the zipCode validator has the country option which might be changed dynamically by a select element.
*
* @param {jQuery|String} field The field name or element
* @param {String|Function} option The option which can be determined by:
* - a string
* - name of field which defines the value
* - name of function which returns the value
* - a function returns the value
*
* The callback function has the format of
* callback: function(value, validator, $field) {
* // value is the value of field
* // validator is the BootstrapValidator instance
* // $field is the field element
* }
*
* @returns {String}
*/
getDynamicOption: function(field, option) {
var $field = ('string' === typeof field) ? this.getFieldElements(field) : field,
value = $field.val();
// Option can be determined by
// ... a function
if ('function' === typeof option) {
return $.fn.bootstrapValidator.helpers.call(option, [value, this, $field]);
}
// ... value of other field
else if ('string' === typeof option) {
var $f = this.getFieldElements(option);
if ($f.length) {
return $f.val();
}
// ... return value of callback
else {
return $.fn.bootstrapValidator.helpers.call(option, [value, this, $field]);
}
}
return null;
},
/**
* Destroy the plugin
* It will remove all error messages, feedback icons and turn off the events
*/
destroy: function() {
var field, fields, $field, validator, $icon, container, group;
for (field in this.options.fields) {
fields = this.getFieldElements(field);
container = this.options.fields[field].container || this.options.container,
group = this.options.fields[field].group || this.options.group;
for (var i = 0; i < fields.length; i++) {
$field = fields.eq(i);
$field
// Remove all error messages
.data('bv.messages')
.find('.help-block[data-bv-validator][data-bv-for="' + field + '"]').remove().end()
.end()
.removeData('bv.messages')
// Remove feedback classes
.parents(group)
.removeClass('has-feedback has-error has-success')
.end()
// Turn off events
.off('.bv')
.removeAttr('data-bv-field');
// Remove feedback icons, tooltip/popover container
$icon = $field.parents(group).find('i[data-bv-icon-for="' + field + '"]');
if ($icon) {
switch (container) {
case 'tooltip':
$icon.tooltip('destroy').remove();
break;
case 'popover':
$icon.popover('destroy').remove();
break;
default:
$icon.remove();
break;
}
}
for (validator in this.options.fields[field].validators) {
if ($field.data('bv.dfs.' + validator)) {
$field.data('bv.dfs.' + validator).reject();
}
$field.removeData('bv.result.' + validator).removeData('bv.dfs.' + validator);
}
}
}
// Enable submit buttons
this.disableSubmitButtons(false);
this.$form
.removeClass(this.options.elementClass)
.off('.bv')
.removeData('bootstrapValidator')
// Remove generated hidden elements
.find('[data-bv-submit-hidden]').remove();
}
};
// Plugin definition
$.fn.bootstrapValidator = function(option) {
var params = arguments;
return this.each(function() {
var $this = $(this),
data = $this.data('bootstrapValidator'),
options = 'object' === typeof option && option;
if (!data) {
data = new BootstrapValidator(this, options);
$this.data('bootstrapValidator', data);
}
// Allow to call plugin method
if ('string' === typeof option) {
data[option].apply(data, Array.prototype.slice.call(params, 1));
}
});
};
// The default options
$.fn.bootstrapValidator.DEFAULT_OPTIONS = {
// The form CSS class
elementClass: 'bv-form',
// Default invalid message
message: 'This value is not valid',
// The CSS selector for indicating the element consists the field
// By default, each field is placed inside the <div class="form-group"></div>
// You should adjust this option if your form group consists of many fields which not all of them need to be validated
group: '.form-group',
//The error messages container. It can be:
// - 'tooltip' if you want to use Bootstrap tooltip to show error messages
// - 'popover' if you want to use Bootstrap popover to show error messages
// - a CSS selector indicating the container
// In the first two cases, since the tooltip/popover should be small enough, the plugin only shows only one error message
// You also can define the message container for particular field
container: null,
// The field will not be live validated if its length is less than this number of characters
threshold: null,
// Indicate fields which won't be validated
// By default, the plugin will not validate the following kind of fields:
// - disabled
// - hidden
// - invisible
//
// The setting consists of jQuery filters. Accept 3 formats:
// - A string. Use a comma to separate filter
// - An array. Each element is a filter
// - An array. Each element can be a callback function
// function($field, validator) {
// $field is jQuery object representing the field element
// validator is the BootstrapValidator instance
// return true or false;
// }
//
// The 3 following settings are equivalent:
//
// 1) ':disabled, :hidden, :not(:visible)'
// 2) [':disabled', ':hidden', ':not(:visible)']
// 3) [':disabled', ':hidden', function($field) {
// return !$field.is(':visible');
// }]
excluded: [':disabled', ':hidden', ':not(:visible)'],
// Shows ok/error/loading icons based on the field validity.
// This feature requires Bootstrap v3.1.0 or later (path_to_url#forms-control-validation).
// Since Bootstrap doesn't provide any methods to know its version, this option cannot be on/off automatically.
// In other word, to use this feature you have to upgrade your Bootstrap to v3.1.0 or later.
//
// Examples:
// - Use Glyphicons icons:
// feedbackIcons: {
// valid: 'glyphicon glyphicon-ok',
// invalid: 'glyphicon glyphicon-remove',
// validating: 'glyphicon glyphicon-refresh'
// }
// - Use FontAwesome icons:
// feedbackIcons: {
// valid: 'fa fa-check',
// invalid: 'fa fa-times',
// validating: 'fa fa-refresh'
// }
feedbackIcons: {
valid: null,
invalid: null,
validating: null
},
// The submit buttons selector
// These buttons will be disabled to prevent the valid form from multiple submissions
submitButtons: '[type="submit"]',
// Live validating option
// Can be one of 3 values:
// - enabled: The plugin validates fields as soon as they are changed
// - disabled: Disable the live validating. The error messages are only shown after the form is submitted
// - submitted: The live validating is enabled after the form is submitted
live: 'enabled',
// Map the field name with validator rules
fields: null
};
// Available validators
$.fn.bootstrapValidator.validators = {};
// i18n
$.fn.bootstrapValidator.i18n = {};
$.fn.bootstrapValidator.Constructor = BootstrapValidator;
// Helper methods, which can be used in validator class
$.fn.bootstrapValidator.helpers = {
/**
* Execute a callback function
*
* @param {String|Function} functionName Can be
* - name of global function
* - name of namespace function (such as A.B.C)
* - a function
* @param {Array} args The callback arguments
*/
call: function(functionName, args) {
if ('function' === typeof functionName) {
return functionName.apply(this, args);
} else if ('string' === typeof functionName) {
if ('()' === functionName.substring(functionName.length - 2)) {
functionName = functionName.substring(0, functionName.length - 2);
}
var ns = functionName.split('.'),
func = ns.pop(),
context = window;
for (var i = 0; i < ns.length; i++) {
context = context[ns[i]];
}
return context[func].apply(this, args);
}
},
/**
* Format a string
* It's used to format the error message
* format('The field must between %s and %s', [10, 20]) = 'The field must between 10 and 20'
*
* @param {String} message
* @param {Array} parameters
* @returns {String}
*/
format: function(message, parameters) {
if (!$.isArray(parameters)) {
parameters = [parameters];
}
for (var i in parameters) {
message = message.replace('%s', parameters[i]);
}
return message;
},
/**
* Validate a date
*
* @param {Number} year The full year in 4 digits
* @param {Number} month The month number
* @param {Number} day The day number
* @param {Boolean} [notInFuture] If true, the date must not be in the future
* @returns {Boolean}
*/
date: function(year, month, day, notInFuture) {
if (isNaN(year) || isNaN(month) || isNaN(day)) {
return false;
}
day = parseInt(day, 10);
month = parseInt(month, 10);
year = parseInt(year, 10);
if (year < 1000 || year > 9999 || month <= 0 || month > 12) {
return false;
}
var numDays = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
// Update the number of days in Feb of leap year
if (year % 400 === 0 || (year % 100 !== 0 && year % 4 === 0)) {
numDays[1] = 29;
}
// Check the day
if (day <= 0 || day > numDays[month - 1]) {
return false;
}
if (notInFuture === true) {
var currentDate = new Date(),
currentYear = currentDate.getFullYear(),
currentMonth = currentDate.getMonth(),
currentDay = currentDate.getDate();
return (year < currentYear
|| (year === currentYear && month - 1 < currentMonth)
|| (year === currentYear && month - 1 === currentMonth && day < currentDay));
}
return true;
},
/**
* Implement Luhn validation algorithm
* Credit to path_to_url
*
* @see path_to_url
* @param {String} value
* @returns {Boolean}
*/
luhn: function(value) {
var length = value.length,
mul = 0,
prodArr = [[0, 1, 2, 3, 4, 5, 6, 7, 8, 9], [0, 2, 4, 6, 8, 1, 3, 5, 7, 9]],
sum = 0;
while (length--) {
sum += prodArr[mul][parseInt(value.charAt(length), 10)];
mul ^= 1;
}
return (sum % 10 === 0 && sum > 0);
},
/**
* Implement modulus 11, 10 (ISO 7064) algorithm
*
* @param {String} value
* @returns {Boolean}
*/
mod11And10: function(value) {
var check = 5,
length = value.length;
for (var i = 0; i < length; i++) {
check = (((check || 10) * 2) % 11 + parseInt(value.charAt(i), 10)) % 10;
}
return (check === 1);
},
/**
* Implements Mod 37, 36 (ISO 7064) algorithm
* Usages:
* mod37And36('A12425GABC1234002M')
* mod37And36('002006673085', '0123456789')
*
* @param {String} value
* @param {String} [alphabet]
* @returns {Boolean}
*/
mod37And36: function(value, alphabet) {
alphabet = alphabet || '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ';
var modulus = alphabet.length,
length = value.length,
check = Math.floor(modulus / 2);
for (var i = 0; i < length; i++) {
check = (((check || modulus) * 2) % (modulus + 1) + alphabet.indexOf(value.charAt(i))) % modulus;
}
return (check === 1);
}
};
}(window.jQuery));
;(function($) {
$.fn.bootstrapValidator.i18n.base64 = $.extend($.fn.bootstrapValidator.i18n.base64 || {}, {
'default': 'Please enter a valid base 64 encoded'
});
$.fn.bootstrapValidator.validators.base64 = {
/**
* Return true if the input value is a base 64 encoded string.
*
* @param {BootstrapValidator} validator The validator plugin instance
* @param {jQuery} $field Field element
* @param {Object} options Can consist of the following keys:
* - message: The invalid message
* @returns {Boolean}
*/
validate: function(validator, $field, options) {
var value = $field.val();
if (value === '') {
return true;
}
return /^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=|[A-Za-z0-9+/]{4})$/.test(value);
}
};
}(window.jQuery));
;(function($) {
$.fn.bootstrapValidator.i18n.between = $.extend($.fn.bootstrapValidator.i18n.between || {}, {
'default': 'Please enter a value between %s and %s',
notInclusive: 'Please enter a value between %s and %s strictly'
});
$.fn.bootstrapValidator.validators.between = {
html5Attributes: {
message: 'message',
min: 'min',
max: 'max',
inclusive: 'inclusive'
},
enableByHtml5: function($field) {
if ('range' === $field.attr('type')) {
return {
min: $field.attr('min'),
max: $field.attr('max')
};
}
return false;
},
/**
* Return true if the input value is between (strictly or not) two given numbers
*
* @param {BootstrapValidator} validator The validator plugin instance
* @param {jQuery} $field Field element
* @param {Object} options Can consist of the following keys:
* - min
* - max
*
* The min, max keys define the number which the field value compares to. min, max can be
* - A number
* - Name of field which its value defines the number
* - Name of callback function that returns the number
* - A callback function that returns the number
*
* - inclusive [optional]: Can be true or false. Default is true
* - message: The invalid message
* @returns {Boolean|Object}
*/
validate: function(validator, $field, options) {
var value = $field.val();
if (value === '') {
return true;
}
var min = $.isNumeric(options.min) ? options.min : validator.getDynamicOption($field, options.min),
max = $.isNumeric(options.max) ? options.max : validator.getDynamicOption($field, options.max);
value = parseFloat(value);
return (options.inclusive === true || options.inclusive === undefined)
? {
valid: value >= min && value <= max,
message: $.fn.bootstrapValidator.helpers.format(options.message || $.fn.bootstrapValidator.i18n.between['default'], [min, max])
}
: {
valid: value > min && value < max,
message: $.fn.bootstrapValidator.helpers.format(options.message || $.fn.bootstrapValidator.i18n.between.notInclusive, [min, max])
};
}
};
}(window.jQuery));
;(function($) {
$.fn.bootstrapValidator.i18n.callback = $.extend($.fn.bootstrapValidator.i18n.callback || {}, {
'default': 'Please enter a valid value'
});
$.fn.bootstrapValidator.validators.callback = {
html5Attributes: {
message: 'message',
callback: 'callback'
},
/**
* Return result from the callback method
*
* @param {BootstrapValidator} validator The validator plugin instance
* @param {jQuery} $field Field element
* @param {Object} options Can consist of the following keys:
* - callback: The callback method that passes 2 parameters:
* callback: function(fieldValue, validator, $field) {
* // fieldValue is the value of field
* // validator is instance of BootstrapValidator
* // $field is the field element
* }
* - message: The invalid message
* @returns {Boolean|Deferred}
*/
validate: function(validator, $field, options) {
var value = $field.val();
if (options.callback) {
var dfd = new $.Deferred(),
response = $.fn.bootstrapValidator.helpers.call(options.callback, [value, validator, $field]);
dfd.resolve($field, 'callback', 'boolean' === typeof response ? response : response.valid, 'object' === typeof response && response.message ? response.message : null);
return dfd;
}
return true;
}
};
}(window.jQuery));
;(function($) {
$.fn.bootstrapValidator.i18n.choice = $.extend($.fn.bootstrapValidator.i18n.choice || {}, {
'default': 'Please enter a valid value',
less: 'Please choose %s options at minimum',
more: 'Please choose %s options at maximum',
between: 'Please choose %s - %s options'
});
$.fn.bootstrapValidator.validators.choice = {
html5Attributes: {
message: 'message',
min: 'min',
max: 'max'
},
/**
* Check if the number of checked boxes are less or more than a given number
*
* @param {BootstrapValidator} validator The validator plugin instance
* @param {jQuery} $field Field element
* @param {Object} options Consists of following keys:
* - min
* - max
*
* At least one of two keys is required
* The min, max keys define the number which the field value compares to. min, max can be
* - A number
* - Name of field which its value defines the number
* - Name of callback function that returns the number
* - A callback function that returns the number
*
* - message: The invalid message
* @returns {Object}
*/
validate: function(validator, $field, options) {
var numChoices = $field.is('select')
? validator.getFieldElements($field.attr('data-bv-field')).find('option').filter(':selected').length
: validator.getFieldElements($field.attr('data-bv-field')).filter(':checked').length,
min = options.min ? ($.isNumeric(options.min) ? options.min : validator.getDynamicOption($field, options.min)) : null,
max = options.max ? ($.isNumeric(options.max) ? options.max : validator.getDynamicOption($field, options.max)) : null,
isValid = true,
message = options.message || $.fn.bootstrapValidator.i18n.choice['default'];
if ((min && numChoices < parseInt(min, 10)) || (max && numChoices > parseInt(max, 10))) {
isValid = false;
}
switch (true) {
case (!!min && !!max):
message = $.fn.bootstrapValidator.helpers.format(options.message || $.fn.bootstrapValidator.i18n.choice.between, [parseInt(min, 10), parseInt(max, 10)]);
break;
case (!!min):
message = $.fn.bootstrapValidator.helpers.format(options.message || $.fn.bootstrapValidator.i18n.choice.less, parseInt(min, 10));
break;
case (!!max):
message = $.fn.bootstrapValidator.helpers.format(options.message || $.fn.bootstrapValidator.i18n.choice.more, parseInt(max, 10));
break;
default:
break;
}
return { valid: isValid, message: message };
}
};
}(window.jQuery));
;(function($) {
$.fn.bootstrapValidator.i18n.creditCard = $.extend($.fn.bootstrapValidator.i18n.creditCard || {}, {
'default': 'Please enter a valid credit card number'
});
$.fn.bootstrapValidator.validators.creditCard = {
/**
* Return true if the input value is valid credit card number
* Based on path_to_url
*
* @param {BootstrapValidator} validator The validator plugin instance
* @param {jQuery} $field Field element
* @param {Object} [options] Can consist of the following key:
* - message: The invalid message
* @returns {Boolean}
*/
validate: function(validator, $field, options) {
var value = $field.val();
if (value === '') {
return true;
}
// Accept only digits, dashes or spaces
if (/[^0-9-\s]+/.test(value)) {
return false;
}
value = value.replace(/\D/g, '');
if (!$.fn.bootstrapValidator.helpers.luhn(value)) {
return false;
}
// Validate the card number based on prefix (IIN ranges) and length
var cards = {
AMERICAN_EXPRESS: {
length: [15],
prefix: ['34', '37']
},
DINERS_CLUB: {
length: [14],
prefix: ['300', '301', '302', '303', '304', '305', '36']
},
DINERS_CLUB_US: {
length: [16],
prefix: ['54', '55']
},
DISCOVER: {
length: [16],
prefix: ['6011', '622126', '622127', '622128', '622129', '62213',
'62214', '62215', '62216', '62217', '62218', '62219',
'6222', '6223', '6224', '6225', '6226', '6227', '6228',
'62290', '62291', '622920', '622921', '622922', '622923',
'622924', '622925', '644', '645', '646', '647', '648',
'649', '65']
},
JCB: {
length: [16],
prefix: ['3528', '3529', '353', '354', '355', '356', '357', '358']
},
LASER: {
length: [16, 17, 18, 19],
prefix: ['6304', '6706', '6771', '6709']
},
MAESTRO: {
length: [12, 13, 14, 15, 16, 17, 18, 19],
prefix: ['5018', '5020', '5038', '6304', '6759', '6761', '6762', '6763', '6764', '6765', '6766']
},
MASTERCARD: {
length: [16],
prefix: ['51', '52', '53', '54', '55']
},
SOLO: {
length: [16, 18, 19],
prefix: ['6334', '6767']
},
UNIONPAY: {
length: [16, 17, 18, 19],
prefix: ['622126', '622127', '622128', '622129', '62213', '62214',
'62215', '62216', '62217', '62218', '62219', '6222', '6223',
'6224', '6225', '6226', '6227', '6228', '62290', '62291',
'622920', '622921', '622922', '622923', '622924', '622925']
},
VISA: {
length: [16],
prefix: ['4']
}
};
var type, i;
for (type in cards) {
for (i in cards[type].prefix) {
if (value.substr(0, cards[type].prefix[i].length) === cards[type].prefix[i] // Check the prefix
&& $.inArray(value.length, cards[type].length) !== -1) // and length
{
return true;
}
}
}
return false;
}
};
}(window.jQuery));
;(function($) {
$.fn.bootstrapValidator.i18n.cusip = $.extend($.fn.bootstrapValidator.i18n.cusip || {}, {
'default': 'Please enter a valid CUSIP number'
});
$.fn.bootstrapValidator.validators.cusip = {
/**
* Validate a CUSIP
* Examples:
* - Valid: 037833100, 931142103, 14149YAR8, 126650BG6
* - Invalid: 31430F200, 022615AC2
*
* @see path_to_url
* @param {BootstrapValidator} validator The validator plugin instance
* @param {jQuery} $field Field element
* @param {Object} [options] Can consist of the following keys:
* - message: The invalid message
* @returns {Boolean}
*/
validate: function(validator, $field, options) {
var value = $field.val();
if (value === '') {
return true;
}
value = value.toUpperCase();
if (!/^[0-9A-Z]{9}$/.test(value)) {
return false;
}
var converted = $.map(value.split(''), function(item) {
var code = item.charCodeAt(0);
return (code >= 'A'.charCodeAt(0) && code <= 'Z'.charCodeAt(0))
// Replace A, B, C, ..., Z with 10, 11, ..., 35
? (code - 'A'.charCodeAt(0) + 10)
: item;
}),
length = converted.length,
sum = 0;
for (var i = 0; i < length - 1; i++) {
var num = parseInt(converted[i], 10);
if (i % 2 !== 0) {
num *= 2;
}
if (num > 9) {
num -= 9;
}
sum += num;
}
sum = (10 - (sum % 10)) % 10;
return sum === converted[length - 1];
}
};
}(window.jQuery));
;(function($) {
$.fn.bootstrapValidator.i18n.cvv = $.extend($.fn.bootstrapValidator.i18n.cvv || {}, {
'default': 'Please enter a valid CVV number'
});
$.fn.bootstrapValidator.validators.cvv = {
html5Attributes: {
message: 'message',
ccfield: 'creditCardField'
},
/**
* Return true if the input value is a valid CVV number.
*
* @param {BootstrapValidator} validator The validator plugin instance
* @param {jQuery} $field Field element
* @param {Object} options Can consist of the following keys:
* - creditCardField: The credit card number field. It can be null
* - message: The invalid message
* @returns {Boolean}
*/
validate: function(validator, $field, options) {
var value = $field.val();
if (value === '') {
return true;
}
if (!/^[0-9]{3,4}$/.test(value)) {
return false;
}
if (!options.creditCardField) {
return true;
}
// Get the credit card number
var creditCard = validator.getFieldElements(options.creditCardField).val();
if (creditCard === '') {
return true;
}
creditCard = creditCard.replace(/\D/g, '');
// Supported credit card types
var cards = {
AMERICAN_EXPRESS: {
length: [15],
prefix: ['34', '37']
},
DINERS_CLUB: {
length: [14],
prefix: ['300', '301', '302', '303', '304', '305', '36']
},
DINERS_CLUB_US: {
length: [16],
prefix: ['54', '55']
},
DISCOVER: {
length: [16],
prefix: ['6011', '622126', '622127', '622128', '622129', '62213',
'62214', '62215', '62216', '62217', '62218', '62219',
'6222', '6223', '6224', '6225', '6226', '6227', '6228',
'62290', '62291', '622920', '622921', '622922', '622923',
'622924', '622925', '644', '645', '646', '647', '648',
'649', '65']
},
JCB: {
length: [16],
prefix: ['3528', '3529', '353', '354', '355', '356', '357', '358']
},
LASER: {
length: [16, 17, 18, 19],
prefix: ['6304', '6706', '6771', '6709']
},
MAESTRO: {
length: [12, 13, 14, 15, 16, 17, 18, 19],
prefix: ['5018', '5020', '5038', '6304', '6759', '6761', '6762', '6763', '6764', '6765', '6766']
},
MASTERCARD: {
length: [16],
prefix: ['51', '52', '53', '54', '55']
},
SOLO: {
length: [16, 18, 19],
prefix: ['6334', '6767']
},
UNIONPAY: {
length: [16, 17, 18, 19],
prefix: ['622126', '622127', '622128', '622129', '62213', '62214',
'62215', '62216', '62217', '62218', '62219', '6222', '6223',
'6224', '6225', '6226', '6227', '6228', '62290', '62291',
'622920', '622921', '622922', '622923', '622924', '622925']
},
VISA: {
length: [16],
prefix: ['4']
}
};
var type, i, creditCardType = null;
for (type in cards) {
for (i in cards[type].prefix) {
if (creditCard.substr(0, cards[type].prefix[i].length) === cards[type].prefix[i] // Check the prefix
&& $.inArray(creditCard.length, cards[type].length) !== -1) // and length
{
creditCardType = type;
break;
}
}
}
return (creditCardType === null)
? false
: (('AMERICAN_EXPRESS' === creditCardType) ? (value.length === 4) : (value.length === 3));
}
};
}(window.jQuery));
;(function($) {
$.fn.bootstrapValidator.i18n.date = $.extend($.fn.bootstrapValidator.i18n.date || {}, {
'default': 'Please enter a valid date'
});
$.fn.bootstrapValidator.validators.date = {
html5Attributes: {
message: 'message',
format: 'format',
separator: 'separator'
},
/**
* Return true if the input value is valid date
*
* @param {BootstrapValidator} validator The validator plugin instance
* @param {jQuery} $field Field element
* @param {Object} options Can consist of the following keys:
* - message: The invalid message
* - separator: Use to separate the date, month, and year.
* By default, it is /
* - format: The date format. Default is MM/DD/YYYY
* The format can be:
*
* i) date: Consist of DD, MM, YYYY parts which are separated by the separator option
* ii) date and time:
* The time can consist of h, m, s parts which are separated by :
* ii) date, time and A (indicating AM or PM)
* @returns {Boolean}
*/
validate: function(validator, $field, options) {
var value = $field.val();
if (value === '') {
return true;
}
options.format = options.format || 'MM/DD/YYYY';
var formats = options.format.split(' '),
dateFormat = formats[0],
timeFormat = (formats.length > 1) ? formats[1] : null,
amOrPm = (formats.length > 2) ? formats[2] : null,
sections = value.split(' '),
date = sections[0],
time = (sections.length > 1) ? sections[1] : null;
if (formats.length !== sections.length) {
return false;
}
// Determine the separator
var separator = options.separator;
if (!separator) {
separator = (date.indexOf('/') !== -1) ? '/' : ((date.indexOf('-') !== -1) ? '-' : null);
}
if (separator === null || date.indexOf(separator) === -1) {
return false;
}
// Determine the date
date = date.split(separator);
dateFormat = dateFormat.split(separator);
if (date.length !== dateFormat.length) {
return false;
}
var year = date[$.inArray('YYYY', dateFormat)],
month = date[$.inArray('MM', dateFormat)],
day = date[$.inArray('DD', dateFormat)];
if (!year || !month || !day) {
return false;
}
// Determine the time
var minutes = null, hours = null, seconds = null;
if (timeFormat) {
timeFormat = timeFormat.split(':');
time = time.split(':');
if (timeFormat.length !== time.length) {
return false;
}
hours = time.length > 0 ? time[0] : null;
minutes = time.length > 1 ? time[1] : null;
seconds = time.length > 2 ? time[2] : null;
// Validate seconds
if (seconds) {
seconds = parseInt(seconds, 10);
if (isNaN(seconds) || seconds < 0 || seconds > 60) {
return false;
}
}
// Validate hours
if (hours) {
hours = parseInt(hours, 10);
if (isNaN(hours) || hours < 0 || hours >= 24 || (amOrPm && hours > 12)) {
return false;
}
}
// Validate minutes
if (minutes) {
minutes = parseInt(minutes, 10);
if (isNaN(minutes) || minutes < 0 || minutes > 59) {
return false;
}
}
}
// Validate day, month, and year
return $.fn.bootstrapValidator.helpers.date(year, month, day);
}
};
}(window.jQuery));
;(function($) {
$.fn.bootstrapValidator.i18n.different = $.extend($.fn.bootstrapValidator.i18n.different || {}, {
'default': 'Please enter a different value'
});
$.fn.bootstrapValidator.validators.different = {
html5Attributes: {
message: 'message',
field: 'field'
},
/**
* Return true if the input value is different with given field's value
*
* @param {BootstrapValidator} validator The validator plugin instance
* @param {jQuery} $field Field element
* @param {Object} options Consists of the following key:
* - field: The name of field that will be used to compare with current one
* - message: The invalid message
* @returns {Boolean}
*/
validate: function(validator, $field, options) {
var value = $field.val();
if (value === '') {
return true;
}
var compareWith = validator.getFieldElements(options.field);
if (compareWith === null) {
return true;
}
if (value !== compareWith.val()) {
validator.updateStatus(options.field, validator.STATUS_VALID, 'different');
return true;
} else {
return false;
}
}
};
}(window.jQuery));
;(function($) {
$.fn.bootstrapValidator.i18n.digits = $.extend($.fn.bootstrapValidator.i18n.digits || {}, {
'default': 'Please enter only digits'
});
$.fn.bootstrapValidator.validators.digits = {
/**
* Return true if the input value contains digits only
*
* @param {BootstrapValidator} validator Validate plugin instance
* @param {jQuery} $field Field element
* @param {Object} [options]
* @returns {Boolean}
*/
validate: function(validator, $field, options) {
var value = $field.val();
if (value === '') {
return true;
}
return /^\d+$/.test(value);
}
};
}(window.jQuery));
;(function($) {
$.fn.bootstrapValidator.i18n.ean = $.extend($.fn.bootstrapValidator.i18n.ean || {}, {
'default': 'Please enter a valid EAN number'
});
$.fn.bootstrapValidator.validators.ean = {
/**
* Validate EAN (International Article Number)
* Examples:
* - Valid: 73513537, 9780471117094, 4006381333931
* - Invalid: 73513536
*
* @see path_to_url
* @param {BootstrapValidator} validator The validator plugin instance
* @param {jQuery} $field Field element
* @param {Object} options Can consist of the following keys:
* - message: The invalid message
* @returns {Boolean}
*/
validate: function(validator, $field, options) {
var value = $field.val();
if (value === '') {
return true;
}
if (!/^(\d{8}|\d{12}|\d{13})$/.test(value)) {
return false;
}
var length = value.length,
sum = 0,
weight = (length === 8) ? [3, 1] : [1, 3];
for (var i = 0; i < length - 1; i++) {
sum += parseInt(value.charAt(i), 10) * weight[i % 2];
}
sum = (10 - sum % 10) % 10;
return (sum + '' === value.charAt(length - 1));
}
};
}(window.jQuery));
;(function($) {
$.fn.bootstrapValidator.i18n.emailAddress = $.extend($.fn.bootstrapValidator.i18n.emailAddress || {}, {
'default': 'Please enter a valid email address'
});
$.fn.bootstrapValidator.validators.emailAddress = {
enableByHtml5: function($field) {
return ('email' === $field.attr('type'));
},
/**
* Return true if and only if the input value is a valid email address
*
* @param {BootstrapValidator} validator Validate plugin instance
* @param {jQuery} $field Field element
* @param {Object} [options]
* @returns {Boolean}
*/
validate: function(validator, $field, options) {
var value = $field.val();
if (value === '') {
return true;
}
// Email address regular expression
// path_to_url
var emailRegExp = /^(([^<>()[\]\\.,;:\s@\"]+(\.[^<>()[\]\\.,;:\s@\"]+)*)|(\".+\"))@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\])|(([a-zA-Z\-0-9]+\.)+[a-zA-Z]{2,}))$/;
return emailRegExp.test(value);
}
};
}(window.jQuery));
;(function($) {
$.fn.bootstrapValidator.i18n.file = $.extend($.fn.bootstrapValidator.i18n.file || {}, {
'default': 'Please choose a valid file'
});
$.fn.bootstrapValidator.validators.file = {
html5Attributes: {
extension: 'extension',
maxsize: 'maxSize',
message: 'message',
type: 'type'
},
/**
* Validate upload file. Use HTML 5 API if the browser supports
*
* @param {BootstrapValidator} validator The validator plugin instance
* @param {jQuery} $field Field element
* @param {Object} options Can consist of the following keys:
* - extension: The allowed extensions, separated by a comma
* - maxSize: The maximum size in bytes
* - message: The invalid message
* - type: The allowed MIME type, separated by a comma
* @returns {Boolean}
*/
validate: function(validator, $field, options) {
var value = $field.val();
if (value === '') {
return true;
}
var ext,
extensions = options.extension ? options.extension.toLowerCase().split(',') : null,
types = options.type ? options.type.toLowerCase().split(',') : null,
html5 = (window.File && window.FileList && window.FileReader);
if (html5) {
// Get FileList instance
var files = $field.get(0).files,
total = files.length;
for (var i = 0; i < total; i++) {
// Check file size
if (options.maxSize && files[i].size > parseInt(options.maxSize, 10)) {
return false;
}
// Check file extension
ext = files[i].name.substr(files[i].name.lastIndexOf('.') + 1);
if (extensions && $.inArray(ext.toLowerCase(), extensions) === -1) {
return false;
}
// Check file type
if (types && $.inArray(files[i].type.toLowerCase(), types) === -1) {
return false;
}
}
} else {
// Check file extension
ext = value.substr(value.lastIndexOf('.') + 1);
if (extensions && $.inArray(ext.toLowerCase(), extensions) === -1) {
return false;
}
}
return true;
}
};
}(window.jQuery));
;(function($) {
$.fn.bootstrapValidator.i18n.greaterThan = $.extend($.fn.bootstrapValidator.i18n.greaterThan || {}, {
'default': 'Please enter a value greater than or equal to %s',
notInclusive: 'Please enter a value greater than %s'
});
$.fn.bootstrapValidator.validators.greaterThan = {
html5Attributes: {
message: 'message',
value: 'value',
inclusive: 'inclusive'
},
enableByHtml5: function($field) {
var min = $field.attr('min');
if (min) {
return {
value: min
};
}
return false;
},
/**
* Return true if the input value is greater than or equals to given number
*
* @param {BootstrapValidator} validator Validate plugin instance
* @param {jQuery} $field Field element
* @param {Object} options Can consist of the following keys:
* - value: Define the number to compare with. It can be
* - A number
* - Name of field which its value defines the number
* - Name of callback function that returns the number
* - A callback function that returns the number
*
* - inclusive [optional]: Can be true or false. Default is true
* - message: The invalid message
* @returns {Boolean|Object}
*/
validate: function(validator, $field, options) {
var value = $field.val();
if (value === '') {
return true;
}
var compareTo = $.isNumeric(options.value) ? options.value : validator.getDynamicOption($field, options.value);
value = parseFloat(value);
return (options.inclusive === true || options.inclusive === undefined)
? {
valid: value >= compareTo,
message: $.fn.bootstrapValidator.helpers.format(options.message || $.fn.bootstrapValidator.i18n.greaterThan['default'], compareTo)
}
: {
valid: value > compareTo,
message: $.fn.bootstrapValidator.helpers.format(options.message || $.fn.bootstrapValidator.i18n.greaterThan.notInclusive, compareTo)
};
}
};
}(window.jQuery));
;(function($) {
$.fn.bootstrapValidator.i18n.grid = $.extend($.fn.bootstrapValidator.i18n.grid || {}, {
'default': 'Please enter a valid GRId number'
});
$.fn.bootstrapValidator.validators.grid = {
/**
* Validate GRId (Global Release Identifier)
* Examples:
* - Valid: A12425GABC1234002M, A1-2425G-ABC1234002-M, A1 2425G ABC1234002 M, Grid:A1-2425G-ABC1234002-M
* - Invalid: A1-2425G-ABC1234002-Q
*
* @see path_to_url
* @param {BootstrapValidator} validator The validator plugin instance
* @param {jQuery} $field Field element
* @param {Object} options Can consist of the following keys:
* - message: The invalid message
* @returns {Boolean}
*/
validate: function(validator, $field, options) {
var value = $field.val();
if (value === '') {
return true;
}
value = value.toUpperCase();
if (!/^[GRID:]*([0-9A-Z]{2})[-\s]*([0-9A-Z]{5})[-\s]*([0-9A-Z]{10})[-\s]*([0-9A-Z]{1})$/g.test(value)) {
return false;
}
value = value.replace(/\s/g, '').replace(/-/g, '');
if ('GRID:' === value.substr(0, 5)) {
value = value.substr(5);
}
return $.fn.bootstrapValidator.helpers.mod37And36(value);
}
};
}(window.jQuery));
;(function($) {
$.fn.bootstrapValidator.i18n.hex = $.extend($.fn.bootstrapValidator.i18n.hex || {}, {
'default': 'Please enter a valid hexadecimal number'
});
$.fn.bootstrapValidator.validators.hex = {
/**
* Return true if and only if the input value is a valid hexadecimal number
*
* @param {BootstrapValidator} validator The validator plugin instance
* @param {jQuery} $field Field element
* @param {Object} options Consist of key:
* - message: The invalid message
* @returns {Boolean}
*/
validate: function(validator, $field, options) {
var value = $field.val();
if (value === '') {
return true;
}
return /^[0-9a-fA-F]+$/.test(value);
}
};
}(window.jQuery));
;(function($) {
$.fn.bootstrapValidator.i18n.hexColor = $.extend($.fn.bootstrapValidator.i18n.hexColor || {}, {
'default': 'Please enter a valid hex color'
});
$.fn.bootstrapValidator.validators.hexColor = {
enableByHtml5: function($field) {
return ('color' === $field.attr('type'));
},
/**
* Return true if the input value is a valid hex color
*
* @param {BootstrapValidator} validator The validator plugin instance
* @param {jQuery} $field Field element
* @param {Object} options Can consist of the following keys:
* - message: The invalid message
* @returns {Boolean}
*/
validate: function(validator, $field, options) {
var value = $field.val();
if (value === '') {
return true;
}
return /(^#[0-9A-F]{6}$)|(^#[0-9A-F]{3}$)/i.test(value);
}
};
}(window.jQuery));
;(function($) {
$.fn.bootstrapValidator.i18n.iban = $.extend($.fn.bootstrapValidator.i18n.iban || {}, {
'default': 'Please enter a valid IBAN number',
countryNotSupported: 'The country code %s is not supported',
country: 'Please enter a valid IBAN number in %s',
countries: {
AD: 'Andorra',
AE: 'United Arab Emirates',
AL: 'Albania',
AO: 'Angola',
AT: 'Austria',
AZ: 'Azerbaijan',
BA: 'Bosnia and Herzegovina',
BE: 'Belgium',
BF: 'Burkina Faso',
BG: 'Bulgaria',
BH: 'Bahrain',
BI: 'Burundi',
BJ: 'Benin',
BR: 'Brazil',
CH: 'Switzerland',
CI: 'Ivory Coast',
CM: 'Cameroon',
CR: 'Costa Rica',
CV: 'Cape Verde',
CY: 'Cyprus',
CZ: 'Czech Republic',
DE: 'Germany',
DK: 'Denmark',
DO: 'Dominican Republic',
DZ: 'Algeria',
EE: 'Estonia',
ES: 'Spain',
FI: 'Finland',
FO: 'Faroe Islands',
FR: 'France',
GB: 'United Kingdom',
GE: 'Georgia',
GI: 'Gibraltar',
GL: 'Greenland',
GR: 'Greece',
GT: 'Guatemala',
HR: 'Croatia',
HU: 'Hungary',
IE: 'Ireland',
IL: 'Israel',
IR: 'Iran',
IS: 'Iceland',
IT: 'Italy',
JO: 'Jordan',
KW: 'Kuwait',
KZ: 'Kazakhstan',
LB: 'Lebanon',
LI: 'Liechtenstein',
LT: 'Lithuania',
LU: 'Luxembourg',
LV: 'Latvia',
MC: 'Monaco',
MD: 'Moldova',
ME: 'Montenegro',
MG: 'Madagascar',
MK: 'Macedonia',
ML: 'Mali',
MR: 'Mauritania',
MT: 'Malta',
MU: 'Mauritius',
MZ: 'Mozambique',
NL: 'Netherlands',
NO: 'Norway',
PK: 'Pakistan',
PL: 'Poland',
PS: 'Palestinian',
PT: 'Portugal',
QA: 'Qatar',
RO: 'Romania',
RS: 'Serbia',
SA: 'Saudi Arabia',
SE: 'Sweden',
SI: 'Slovenia',
SK: 'Slovakia',
SM: 'San Marino',
SN: 'Senegal',
TN: 'Tunisia',
TR: 'Turkey',
VG: 'Virgin Islands, British'
}
});
$.fn.bootstrapValidator.validators.iban = {
html5Attributes: {
message: 'message',
country: 'country'
},
// path_to_url
// path_to_url#IBAN_formats_by_country
REGEX: {
AD: 'AD[0-9]{2}[0-9]{4}[0-9]{4}[A-Z0-9]{12}', // Andorra
AE: 'AE[0-9]{2}[0-9]{3}[0-9]{16}', // United Arab Emirates
AL: 'AL[0-9]{2}[0-9]{8}[A-Z0-9]{16}', // Albania
AO: 'AO[0-9]{2}[0-9]{21}', // Angola
AT: 'AT[0-9]{2}[0-9]{5}[0-9]{11}', // Austria
AZ: 'AZ[0-9]{2}[A-Z]{4}[A-Z0-9]{20}', // Azerbaijan
BA: 'BA[0-9]{2}[0-9]{3}[0-9]{3}[0-9]{8}[0-9]{2}', // Bosnia and Herzegovina
BE: 'BE[0-9]{2}[0-9]{3}[0-9]{7}[0-9]{2}', // Belgium
BF: 'BF[0-9]{2}[0-9]{23}', // Burkina Faso
BG: 'BG[0-9]{2}[A-Z]{4}[0-9]{4}[0-9]{2}[A-Z0-9]{8}', // Bulgaria
BH: 'BH[0-9]{2}[A-Z]{4}[A-Z0-9]{14}', // Bahrain
BI: 'BI[0-9]{2}[0-9]{12}', // Burundi
BJ: 'BJ[0-9]{2}[A-Z]{1}[0-9]{23}', // Benin
BR: 'BR[0-9]{2}[0-9]{8}[0-9]{5}[0-9]{10}[A-Z][A-Z0-9]', // Brazil
CH: 'CH[0-9]{2}[0-9]{5}[A-Z0-9]{12}', // Switzerland
CI: 'CI[0-9]{2}[A-Z]{1}[0-9]{23}', // Ivory Coast
CM: 'CM[0-9]{2}[0-9]{23}', // Cameroon
CR: 'CR[0-9]{2}[0-9]{3}[0-9]{14}', // Costa Rica
CV: 'CV[0-9]{2}[0-9]{21}', // Cape Verde
CY: 'CY[0-9]{2}[0-9]{3}[0-9]{5}[A-Z0-9]{16}', // Cyprus
CZ: 'CZ[0-9]{2}[0-9]{20}', // Czech Republic
DE: 'DE[0-9]{2}[0-9]{8}[0-9]{10}', // Germany
DK: 'DK[0-9]{2}[0-9]{14}', // Denmark
DO: 'DO[0-9]{2}[A-Z0-9]{4}[0-9]{20}', // Dominican Republic
DZ: 'DZ[0-9]{2}[0-9]{20}', // Algeria
EE: 'EE[0-9]{2}[0-9]{2}[0-9]{2}[0-9]{11}[0-9]{1}', // Estonia
ES: 'ES[0-9]{2}[0-9]{4}[0-9]{4}[0-9]{1}[0-9]{1}[0-9]{10}', // Spain
FI: 'FI[0-9]{2}[0-9]{6}[0-9]{7}[0-9]{1}', // Finland
FO: 'FO[0-9]{2}[0-9]{4}[0-9]{9}[0-9]{1}', // Faroe Islands
FR: 'FR[0-9]{2}[0-9]{5}[0-9]{5}[A-Z0-9]{11}[0-9]{2}', // France
GB: 'GB[0-9]{2}[A-Z]{4}[0-9]{6}[0-9]{8}', // United Kingdom
GE: 'GE[0-9]{2}[A-Z]{2}[0-9]{16}', // Georgia
GI: 'GI[0-9]{2}[A-Z]{4}[A-Z0-9]{15}', // Gibraltar
GL: 'GL[0-9]{2}[0-9]{4}[0-9]{9}[0-9]{1}', // Greenland
GR: 'GR[0-9]{2}[0-9]{3}[0-9]{4}[A-Z0-9]{16}', // Greece
GT: 'GT[0-9]{2}[A-Z0-9]{4}[A-Z0-9]{20}', // Guatemala
HR: 'HR[0-9]{2}[0-9]{7}[0-9]{10}', // Croatia
HU: 'HU[0-9]{2}[0-9]{3}[0-9]{4}[0-9]{1}[0-9]{15}[0-9]{1}', // Hungary
IE: 'IE[0-9]{2}[A-Z]{4}[0-9]{6}[0-9]{8}', // Ireland
IL: 'IL[0-9]{2}[0-9]{3}[0-9]{3}[0-9]{13}', // Israel
IR: 'IR[0-9]{2}[0-9]{22}', // Iran
IS: 'IS[0-9]{2}[0-9]{4}[0-9]{2}[0-9]{6}[0-9]{10}', // Iceland
IT: 'IT[0-9]{2}[A-Z]{1}[0-9]{5}[0-9]{5}[A-Z0-9]{12}', // Italy
JO: 'JO[0-9]{2}[A-Z]{4}[0-9]{4}[0]{8}[A-Z0-9]{10}', // Jordan
KW: 'KW[0-9]{2}[A-Z]{4}[0-9]{22}', // Kuwait
KZ: 'KZ[0-9]{2}[0-9]{3}[A-Z0-9]{13}', // Kazakhstan
LB: 'LB[0-9]{2}[0-9]{4}[A-Z0-9]{20}', // Lebanon
LI: 'LI[0-9]{2}[0-9]{5}[A-Z0-9]{12}', // Liechtenstein
LT: 'LT[0-9]{2}[0-9]{5}[0-9]{11}', // Lithuania
LU: 'LU[0-9]{2}[0-9]{3}[A-Z0-9]{13}', // Luxembourg
LV: 'LV[0-9]{2}[A-Z]{4}[A-Z0-9]{13}', // Latvia
MC: 'MC[0-9]{2}[0-9]{5}[0-9]{5}[A-Z0-9]{11}[0-9]{2}', // Monaco
MD: 'MD[0-9]{2}[A-Z0-9]{20}', // Moldova
ME: 'ME[0-9]{2}[0-9]{3}[0-9]{13}[0-9]{2}', // Montenegro
MG: 'MG[0-9]{2}[0-9]{23}', // Madagascar
MK: 'MK[0-9]{2}[0-9]{3}[A-Z0-9]{10}[0-9]{2}', // Macedonia
ML: 'ML[0-9]{2}[A-Z]{1}[0-9]{23}', // Mali
MR: 'MR13[0-9]{5}[0-9]{5}[0-9]{11}[0-9]{2}', // Mauritania
MT: 'MT[0-9]{2}[A-Z]{4}[0-9]{5}[A-Z0-9]{18}', // Malta
MU: 'MU[0-9]{2}[A-Z]{4}[0-9]{2}[0-9]{2}[0-9]{12}[0-9]{3}[A-Z]{3}', // Mauritius
MZ: 'MZ[0-9]{2}[0-9]{21}', // Mozambique
NL: 'NL[0-9]{2}[A-Z]{4}[0-9]{10}', // Netherlands
NO: 'NO[0-9]{2}[0-9]{4}[0-9]{6}[0-9]{1}', // Norway
PK: 'PK[0-9]{2}[A-Z]{4}[A-Z0-9]{16}', // Pakistan
PL: 'PL[0-9]{2}[0-9]{8}[0-9]{16}', // Poland
PS: 'PS[0-9]{2}[A-Z]{4}[A-Z0-9]{21}', // Palestinian
PT: 'PT[0-9]{2}[0-9]{4}[0-9]{4}[0-9]{11}[0-9]{2}', // Portugal
QA: 'QA[0-9]{2}[A-Z]{4}[A-Z0-9]{21}', // Qatar
RO: 'RO[0-9]{2}[A-Z]{4}[A-Z0-9]{16}', // Romania
RS: 'RS[0-9]{2}[0-9]{3}[0-9]{13}[0-9]{2}', // Serbia
SA: 'SA[0-9]{2}[0-9]{2}[A-Z0-9]{18}', // Saudi Arabia
SE: 'SE[0-9]{2}[0-9]{3}[0-9]{16}[0-9]{1}', // Sweden
SI: 'SI[0-9]{2}[0-9]{5}[0-9]{8}[0-9]{2}', // Slovenia
SK: 'SK[0-9]{2}[0-9]{4}[0-9]{6}[0-9]{10}', // Slovakia
SM: 'SM[0-9]{2}[A-Z]{1}[0-9]{5}[0-9]{5}[A-Z0-9]{12}', // San Marino
SN: 'SN[0-9]{2}[A-Z]{1}[0-9]{23}', // Senegal
TN: 'TN59[0-9]{2}[0-9]{3}[0-9]{13}[0-9]{2}', // Tunisia
TR: 'TR[0-9]{2}[0-9]{5}[A-Z0-9]{1}[A-Z0-9]{16}', // Turkey
VG: 'VG[0-9]{2}[A-Z]{4}[0-9]{16}' // Virgin Islands, British
},
/**
* Validate an International Bank Account Number (IBAN)
* To test it, take the sample IBAN from
* path_to_url
*
* @param {BootstrapValidator} validator The validator plugin instance
* @param {jQuery} $field Field element
* @param {Object} options Can consist of the following keys:
* - message: The invalid message
* - country: The ISO 3166-1 country code. It can be
* - A country code
* - Name of field which its value defines the country code
* - Name of callback function that returns the country code
* - A callback function that returns the country code
* @returns {Boolean|Object}
*/
validate: function(validator, $field, options) {
var value = $field.val();
if (value === '') {
return true;
}
value = value.replace(/[^a-zA-Z0-9]/g, '').toUpperCase();
var country = options.country;
if (!country) {
country = value.substr(0, 2);
} else if (typeof country !== 'string' || !this.REGEX[country]) {
// Determine the country code
country = validator.getDynamicOption($field, country);
}
if (!this.REGEX[country]) {
return {
valid: false,
message: $.fn.bootstrapValidator.helpers.format($.fn.bootstrapValidator.i18n.iban.countryNotSupported, country)
};
}
if (!(new RegExp('^' + this.REGEX[country] + '$')).test(value)) {
return {
valid: false,
message: $.fn.bootstrapValidator.helpers.format(options.message || $.fn.bootstrapValidator.i18n.iban.country, $.fn.bootstrapValidator.i18n.iban.countries[country])
};
}
value = value.substr(4) + value.substr(0, 4);
value = $.map(value.split(''), function(n) {
var code = n.charCodeAt(0);
return (code >= 'A'.charCodeAt(0) && code <= 'Z'.charCodeAt(0))
// Replace A, B, C, ..., Z with 10, 11, ..., 35
? (code - 'A'.charCodeAt(0) + 10)
: n;
});
value = value.join('');
var temp = parseInt(value.substr(0, 1), 10),
length = value.length;
for (var i = 1; i < length; ++i) {
temp = (temp * 10 + parseInt(value.substr(i, 1), 10)) % 97;
}
return {
valid: (temp === 1),
message: $.fn.bootstrapValidator.helpers.format(options.message || $.fn.bootstrapValidator.i18n.iban.country, $.fn.bootstrapValidator.i18n.iban.countries[country])
};
}
};
}(window.jQuery));
;(function($) {
$.fn.bootstrapValidator.i18n.id = $.extend($.fn.bootstrapValidator.i18n.id || {}, {
'default': 'Please enter a valid identification number',
countryNotSupported: 'The country code %s is not supported',
country: 'Please enter a valid %s identification number',
countries: {
BA: 'Bosnia and Herzegovina',
BG: 'Bulgarian',
BR: 'Brazilian',
CH: 'Swiss',
CL: 'Chilean',
CZ: 'Czech',
DK: 'Danish',
EE: 'Estonian',
ES: 'Spanish',
FI: 'Finnish',
HR: 'Croatian',
IE: 'Irish',
IS: 'Iceland',
LT: 'Lithuanian',
LV: 'Latvian',
ME: 'Montenegro',
MK: 'Macedonian',
NL: 'Dutch',
RO: 'Romanian',
RS: 'Serbian',
SE: 'Swedish',
SI: 'Slovenian',
SK: 'Slovak',
SM: 'San Marino',
ZA: 'South African'
}
});
$.fn.bootstrapValidator.validators.id = {
html5Attributes: {
message: 'message',
country: 'country'
},
// Supported country codes
COUNTRY_CODES: [
'BA', 'BG', 'BR', 'CH', 'CL', 'CZ', 'DK', 'EE', 'ES', 'FI', 'HR', 'IE', 'IS', 'LT', 'LV', 'ME', 'MK', 'NL',
'RO', 'RS', 'SE', 'SI', 'SK', 'SM', 'ZA'
],
/**
* Validate identification number in different countries
*
* @see path_to_url
* @param {BootstrapValidator} validator The validator plugin instance
* @param {jQuery} $field Field element
* @param {Object} options Consist of key:
* - message: The invalid message
* - country: The ISO 3166-1 country code. It can be
* - One of country code defined in COUNTRY_CODES
* - Name of field which its value defines the country code
* - Name of callback function that returns the country code
* - A callback function that returns the country code
* @returns {Boolean|Object}
*/
validate: function(validator, $field, options) {
var value = $field.val();
if (value === '') {
return true;
}
var country = options.country;
if (!country) {
country = value.substr(0, 2);
} else if (typeof country !== 'string' || $.inArray(country.toUpperCase(), this.COUNTRY_CODES) === -1) {
// Determine the country code
country = validator.getDynamicOption($field, country);
}
if ($.inArray(country, this.COUNTRY_CODES) === -1) {
return { valid: false, message: $.fn.bootstrapValidator.helpers.format($.fn.bootstrapValidator.i18n.id.countryNotSupported, country) };
}
var method = ['_', country.toLowerCase()].join('');
return this[method](value)
? true
: {
valid: false,
message: $.fn.bootstrapValidator.helpers.format(options.message || $.fn.bootstrapValidator.i18n.id.country, $.fn.bootstrapValidator.i18n.id.countries[country.toUpperCase()])
};
},
/**
* Validate Unique Master Citizen Number which uses in
* - Bosnia and Herzegovina (country code: BA)
* - Macedonia (MK)
* - Montenegro (ME)
* - Serbia (RS)
* - Slovenia (SI)
*
* @see path_to_url
* @param {String} value The ID
* @param {String} countryCode The ISO country code, can be BA, MK, ME, RS, SI
* @returns {Boolean}
*/
_validateJMBG: function(value, countryCode) {
if (!/^\d{13}$/.test(value)) {
return false;
}
var day = parseInt(value.substr(0, 2), 10),
month = parseInt(value.substr(2, 2), 10),
year = parseInt(value.substr(4, 3), 10),
rr = parseInt(value.substr(7, 2), 10),
k = parseInt(value.substr(12, 1), 10);
// Validate date of birth
// FIXME: Validate the year of birth
if (day > 31 || month > 12) {
return false;
}
// Validate checksum
var sum = 0;
for (var i = 0; i < 6; i++) {
sum += (7 - i) * (parseInt(value.charAt(i), 10) + parseInt(value.charAt(i + 6), 10));
}
sum = 11 - sum % 11;
if (sum === 10 || sum === 11) {
sum = 0;
}
if (sum !== k) {
return false;
}
// Validate political region
// rr is the political region of birth, which can be in ranges:
// 10-19: Bosnia and Herzegovina
// 20-29: Montenegro
// 30-39: Croatia (not used anymore)
// 41-49: Macedonia
// 50-59: Slovenia (only 50 is used)
// 70-79: Central Serbia
// 80-89: Serbian province of Vojvodina
// 90-99: Kosovo
switch (countryCode.toUpperCase()) {
case 'BA':
return (10 <= rr && rr <= 19);
case 'MK':
return (41 <= rr && rr <= 49);
case 'ME':
return (20 <= rr && rr <= 29);
case 'RS':
return (70 <= rr && rr <= 99);
case 'SI':
return (50 <= rr && rr <= 59);
default:
return true;
}
},
_ba: function(value) {
return this._validateJMBG(value, 'BA');
},
_mk: function(value) {
return this._validateJMBG(value, 'MK');
},
_me: function(value) {
return this._validateJMBG(value, 'ME');
},
_rs: function(value) {
return this._validateJMBG(value, 'RS');
},
/**
* Examples: 0101006500006
*/
_si: function(value) {
return this._validateJMBG(value, 'SI');
},
/**
* Validate Bulgarian national identification number (EGN)
* Examples:
* - Valid: 7523169263, 8032056031, 803205 603 1, 8001010008, 7501020018, 7552010005, 7542011030
* - Invalid: 8019010008
*
* @see path_to_url
* @param {String} value The ID
* @returns {Boolean}
*/
_bg: function(value) {
if (!/^\d{10}$/.test(value) && !/^\d{6}\s\d{3}\s\d{1}$/.test(value)) {
return false;
}
value = value.replace(/\s/g, '');
// Check the birth date
var year = parseInt(value.substr(0, 2), 10) + 1900,
month = parseInt(value.substr(2, 2), 10),
day = parseInt(value.substr(4, 2), 10);
if (month > 40) {
year += 100;
month -= 40;
} else if (month > 20) {
year -= 100;
month -= 20;
}
if (!$.fn.bootstrapValidator.helpers.date(year, month, day)) {
return false;
}
var sum = 0,
weight = [2, 4, 8, 5, 10, 9, 7, 3, 6];
for (var i = 0; i < 9; i++) {
sum += parseInt(value.charAt(i), 10) * weight[i];
}
sum = (sum % 11) % 10;
return (sum + '' === value.substr(9, 1));
},
/**
* Validate Brazilian national identification number (CPF)
* Examples:
* - Valid: 39053344705, 390.533.447-05, 111.444.777-35
* - Invalid: 231.002.999-00
*
* @see path_to_url
* @param {String} value The ID
* @returns {Boolean}
*/
_br: function(value) {
if (/^1{11}|2{11}|3{11}|4{11}|5{11}|6{11}|7{11}|8{11}|9{11}|0{11}$/.test(value)) {
return false;
}
if (!/^\d{11}$/.test(value) && !/^\d{3}\.\d{3}\.\d{3}-\d{2}$/.test(value)) {
return false;
}
value = value.replace(/\./g, '').replace(/-/g, '');
var d1 = 0;
for (var i = 0; i < 9; i++) {
d1 += (10 - i) * parseInt(value.charAt(i), 10);
}
d1 = 11 - d1 % 11;
if (d1 === 10 || d1 === 11) {
d1 = 0;
}
if (d1 + '' !== value.charAt(9)) {
return false;
}
var d2 = 0;
for (i = 0; i < 10; i++) {
d2 += (11 - i) * parseInt(value.charAt(i), 10);
}
d2 = 11 - d2 % 11;
if (d2 === 10 || d2 === 11) {
d2 = 0;
}
return (d2 + '' === value.charAt(10));
},
/**
* Validate Swiss Social Security Number (AHV-Nr/No AVS)
* Examples:
* - Valid: 756.1234.5678.95, 7561234567895
*
* @see path_to_url#Switzerland
* @see path_to_url
* @param {String} value The ID
* @returns {Boolean}
*/
_ch: function(value) {
if (!/^756[\.]{0,1}[0-9]{4}[\.]{0,1}[0-9]{4}[\.]{0,1}[0-9]{2}$/.test(value)) {
return false;
}
value = value.replace(/\D/g, '').substr(3);
var length = value.length,
sum = 0,
weight = (length === 8) ? [3, 1] : [1, 3];
for (var i = 0; i < length - 1; i++) {
sum += parseInt(value.charAt(i), 10) * weight[i % 2];
}
sum = 10 - sum % 10;
return (sum + '' === value.charAt(length - 1));
},
/**
* Validate Chilean national identification number (RUN/RUT)
* Examples:
* - Valid: 76086428-5, 22060449-7, 12531909-2
*
* @see path_to_url#Chile
* @see path_to_url for samples
* @param {String} value The ID
* @returns {Boolean}
*/
_cl: function(value) {
if (!/^\d{7,8}[-]{0,1}[0-9K]$/i.test(value)) {
return false;
}
value = value.replace(/\-/g, '');
while (value.length < 9) {
value = '0' + value;
}
var sum = 0,
weight = [3, 2, 7, 6, 5, 4, 3, 2];
for (var i = 0; i < 8; i++) {
sum += parseInt(value.charAt(i), 10) * weight[i];
}
sum = 11 - sum % 11;
if (sum === 11) {
sum = 0;
} else if (sum === 10) {
sum = 'K';
}
return sum + '' === value.charAt(8).toUpperCase();
},
/**
* Validate Czech national identification number (RC)
* Examples:
* - Valid: 7103192745, 991231123
* - Invalid: 1103492745, 590312123
*
* @param {String} value The ID
* @returns {Boolean}
*/
_cz: function(value) {
if (!/^\d{9,10}$/.test(value)) {
return false;
}
var year = 1900 + parseInt(value.substr(0, 2), 10),
month = parseInt(value.substr(2, 2), 10) % 50 % 20,
day = parseInt(value.substr(4, 2), 10);
if (value.length === 9) {
if (year >= 1980) {
year -= 100;
}
if (year > 1953) {
return false;
}
} else if (year < 1954) {
year += 100;
}
if (!$.fn.bootstrapValidator.helpers.date(year, month, day)) {
return false;
}
// Check that the birth date is not in the future
if (value.length === 10) {
var check = parseInt(value.substr(0, 9), 10) % 11;
if (year < 1985) {
check = check % 10;
}
return (check + '' === value.substr(9, 1));
}
return true;
},
/**
* Validate Danish Personal Identification number (CPR)
* Examples:
* - Valid: 2110625629, 211062-5629
* - Invalid: 511062-5629
*
* @see path_to_url
* @param {String} value The ID
* @returns {Boolean}
*/
_dk: function(value) {
if (!/^[0-9]{6}[-]{0,1}[0-9]{4}$/.test(value)) {
return false;
}
value = value.replace(/-/g, '');
var day = parseInt(value.substr(0, 2), 10),
month = parseInt(value.substr(2, 2), 10),
year = parseInt(value.substr(4, 2), 10);
switch (true) {
case ('5678'.indexOf(value.charAt(6)) !== -1 && year >= 58):
year += 1800;
break;
case ('0123'.indexOf(value.charAt(6)) !== -1):
case ('49'.indexOf(value.charAt(6)) !== -1 && year >= 37):
year += 1900;
break;
default:
year += 2000;
break;
}
return $.fn.bootstrapValidator.helpers.date(year, month, day);
},
/**
* Validate Estonian Personal Identification Code (isikukood)
* Examples:
* - Valid: 37605030299
*
* @see path_to_url
* @param {String} value The ID
* @returns {Boolean}
*/
_ee: function(value) {
// Use the same format as Lithuanian Personal Code
return this._lt(value);
},
/**
* Validate Spanish personal identity code (DNI)
* Support i) DNI (for Spanish citizens) and ii) NIE (for foreign people)
*
* Examples:
* - Valid: i) 54362315K, 54362315-K; ii) X2482300W, X-2482300W, X-2482300-W
* - Invalid: i) 54362315Z; ii) X-2482300A
*
* @see path_to_url#Spain
* @param {String} value The ID
* @returns {Boolean}
*/
_es: function(value) {
if (!/^[0-9A-Z]{8}[-]{0,1}[0-9A-Z]$/.test(value) // DNI
&& !/^[XYZ][-]{0,1}[0-9]{7}[-]{0,1}[0-9A-Z]$/.test(value)) { // NIE
return false;
}
value = value.replace(/-/g, '');
var index = 'XYZ'.indexOf(value.charAt(0));
if (index !== -1) {
// It is NIE number
value = index + value.substr(1) + '';
}
var check = parseInt(value.substr(0, 8), 10);
check = 'TRWAGMYFPDXBNJZSQVHLCKE'[check % 23];
return (check === value.substr(8, 1));
},
/**
* Validate Finnish Personal Identity Code (HETU)
* Examples:
* - Valid: 311280-888Y, 131052-308T
* - Invalid: 131052-308U, 310252-308Y
*
* @param {String} value The ID
* @returns {Boolean}
*/
_fi: function(value) {
if (!/^[0-9]{6}[-+A][0-9]{3}[0-9ABCDEFHJKLMNPRSTUVWXY]$/.test(value)) {
return false;
}
var day = parseInt(value.substr(0, 2), 10),
month = parseInt(value.substr(2, 2), 10),
year = parseInt(value.substr(4, 2), 10),
centuries = {
'+': 1800,
'-': 1900,
'A': 2000
};
year = centuries[value.charAt(6)] + year;
if (!$.fn.bootstrapValidator.helpers.date(year, month, day)) {
return false;
}
var individual = parseInt(value.substr(7, 3), 10);
if (individual < 2) {
return false;
}
var n = value.substr(0, 6) + value.substr(7, 3) + '';
n = parseInt(n, 10);
return '0123456789ABCDEFHJKLMNPRSTUVWXY'.charAt(n % 31) === value.charAt(10);
},
/**
* Validate Croatian personal identification number (OIB)
* Examples:
* - Valid: 33392005961
* - Invalid: 33392005962
*
* @param {String} value The ID
* @returns {Boolean}
*/
_hr: function(value) {
if (!/^[0-9]{11}$/.test(value)) {
return false;
}
return $.fn.bootstrapValidator.helpers.mod11And10(value);
},
/**
* Validate Irish Personal Public Service Number (PPS)
* Examples:
* - Valid: 6433435F, 6433435FT, 6433435FW, 6433435OA, 6433435IH, 1234567TW, 1234567FA
* - Invalid: 6433435E, 6433435VH
*
* @see path_to_url
* @param {String} value The ID
* @returns {Boolean}
*/
_ie: function(value) {
if (!/^\d{7}[A-W][AHWTX]?$/.test(value)) {
return false;
}
var getCheckDigit = function(value) {
while (value.length < 7) {
value = '0' + value;
}
var alphabet = 'WABCDEFGHIJKLMNOPQRSTUV',
sum = 0;
for (var i = 0; i < 7; i++) {
sum += parseInt(value.charAt(i), 10) * (8 - i);
}
sum += 9 * alphabet.indexOf(value.substr(7));
return alphabet[sum % 23];
};
// 2013 format
if (value.length === 9 && ('A' === value.charAt(8) || 'H' === value.charAt(8))) {
return value.charAt(7) === getCheckDigit(value.substr(0, 7) + value.substr(8) + '');
}
// The old format
else {
return value.charAt(7) === getCheckDigit(value.substr(0, 7));
}
},
/**
* Validate Iceland national identification number (Kennitala)
* Examples:
* - Valid: 120174-3399, 1201743399, 0902862349
*
* @see path_to_url
* @param {String} value The ID
* @returns {Boolean}
*/
_is: function(value) {
if (!/^[0-9]{6}[-]{0,1}[0-9]{4}$/.test(value)) {
return false;
}
value = value.replace(/-/g, '');
var day = parseInt(value.substr(0, 2), 10),
month = parseInt(value.substr(2, 2), 10),
year = parseInt(value.substr(4, 2), 10),
century = parseInt(value.charAt(9), 10);
year = (century === 9) ? (1900 + year) : ((20 + century) * 100 + year);
if (!$.fn.bootstrapValidator.helpers.date(year, month, day, true)) {
return false;
}
// Validate the check digit
var sum = 0,
weight = [3, 2, 7, 6, 5, 4, 3, 2];
for (var i = 0; i < 8; i++) {
sum += parseInt(value.charAt(i), 10) * weight[i];
}
sum = 11 - sum % 11;
return (sum + '' === value.charAt(8));
},
/**
* Validate Lithuanian Personal Code (Asmens kodas)
* Examples:
* - Valid: 38703181745
* - Invalid: 38703181746, 78703181745, 38703421745
*
* @see path_to_url#Lithuania
* @see path_to_url
* @param {String} value The ID
* @returns {Boolean}
*/
_lt: function(value) {
if (!/^[0-9]{11}$/.test(value)) {
return false;
}
var gender = parseInt(value.charAt(0), 10),
year = parseInt(value.substr(1, 2), 10),
month = parseInt(value.substr(3, 2), 10),
day = parseInt(value.substr(5, 2), 10),
century = (gender % 2 === 0) ? (17 + gender / 2) : (17 + (gender + 1) / 2);
year = century * 100 + year;
if (!$.fn.bootstrapValidator.helpers.date(year, month, day, true)) {
return false;
}
// Validate the check digit
var sum = 0,
weight = [1, 2, 3, 4, 5, 6, 7, 8, 9, 1];
for (var i = 0; i < 10; i++) {
sum += parseInt(value.charAt(i), 10) * weight[i];
}
sum = sum % 11;
if (sum !== 10) {
return sum + '' === value.charAt(10);
}
// Re-calculate the check digit
sum = 0;
weight = [3, 4, 5, 6, 7, 8, 9, 1, 2, 3];
for (i = 0; i < 10; i++) {
sum += parseInt(value.charAt(i), 10) * weight[i];
}
sum = sum % 11;
if (sum === 10) {
sum = 0;
}
return (sum + '' === value.charAt(10));
},
/**
* Validate Latvian Personal Code (Personas kods)
* Examples:
* - Valid: 161175-19997, 16117519997
* - Invalid: 161375-19997
*
* @see path_to_url
* @param {String} value The ID
* @returns {Boolean}
*/
_lv: function(value) {
if (!/^[0-9]{6}[-]{0,1}[0-9]{5}$/.test(value)) {
return false;
}
value = value.replace(/\D/g, '');
// Check birth date
var day = parseInt(value.substr(0, 2), 10),
month = parseInt(value.substr(2, 2), 10),
year = parseInt(value.substr(4, 2), 10);
year = year + 1800 + parseInt(value.charAt(6), 10) * 100;
if (!$.fn.bootstrapValidator.helpers.date(year, month, day, true)) {
return false;
}
// Check personal code
var sum = 0,
weight = [10, 5, 8, 4, 2, 1, 6, 3, 7, 9];
for (var i = 0; i < 10; i++) {
sum += parseInt(value.charAt(i), 10) * weight[i];
}
sum = (sum + 1) % 11 % 10;
return (sum + '' === value.charAt(10));
},
/**
* Validate Dutch national identification number (BSN)
* Examples:
* - Valid: 111222333, 941331490, 9413.31.490
* - Invalid: 111252333
*
* @see path_to_url
* @param {String} value The ID
* @returns {Boolean}
*/
_nl: function(value) {
while (value.length < 9) {
value = '0' + value;
}
if (!/^[0-9]{4}[.]{0,1}[0-9]{2}[.]{0,1}[0-9]{3}$/.test(value)) {
return false;
}
value = value.replace(/\./g, '');
if (parseInt(value, 10) === 0) {
return false;
}
var sum = 0,
length = value.length;
for (var i = 0; i < length - 1; i++) {
sum += (9 - i) * parseInt(value.charAt(i), 10);
}
sum = sum % 11;
if (sum === 10) {
sum = 0;
}
return (sum + '' === value.charAt(length - 1));
},
/**
* Validate Romanian numerical personal code (CNP)
* Examples:
* - Valid: 1630615123457, 1800101221144
* - Invalid: 8800101221144, 1632215123457, 1630615123458
*
* @see path_to_url#Romania
* @param {String} value The ID
* @returns {Boolean}
*/
_ro: function(value) {
if (!/^[0-9]{13}$/.test(value)) {
return false;
}
var gender = parseInt(value.charAt(0), 10);
if (gender === 0 || gender === 7 || gender === 8) {
return false;
}
// Determine the date of birth
var year = parseInt(value.substr(1, 2), 10),
month = parseInt(value.substr(3, 2), 10),
day = parseInt(value.substr(5, 2), 10),
// The year of date is determined base on the gender
centuries = {
'1': 1900, // Male born between 1900 and 1999
'2': 1900, // Female born between 1900 and 1999
'3': 1800, // Male born between 1800 and 1899
'4': 1800, // Female born between 1800 and 1899
'5': 2000, // Male born after 2000
'6': 2000 // Female born after 2000
};
if (day > 31 && month > 12) {
return false;
}
if (gender !== 9) {
year = centuries[gender + ''] + year;
if (!$.fn.bootstrapValidator.helpers.date(year, month, day)) {
return false;
}
}
// Validate the check digit
var sum = 0,
weight = [2, 7, 9, 1, 4, 6, 3, 5, 8, 2, 7, 9],
length = value.length;
for (var i = 0; i < length - 1; i++) {
sum += parseInt(value.charAt(i), 10) * weight[i];
}
sum = sum % 11;
if (sum === 10) {
sum = 1;
}
return (sum + '' === value.charAt(length - 1));
},
/**
* Validate Swedish personal identity number (personnummer)
* Examples:
* - Valid: 8112289874, 811228-9874, 811228+9874
* - Invalid: 811228-9873
*
* @see path_to_url
* @param {String} value The ID
* @returns {Boolean}
*/
_se: function(value) {
if (!/^[0-9]{10}$/.test(value) && !/^[0-9]{6}[-|+][0-9]{4}$/.test(value)) {
return false;
}
value = value.replace(/[^0-9]/g, '');
var year = parseInt(value.substr(0, 2), 10) + 1900,
month = parseInt(value.substr(2, 2), 10),
day = parseInt(value.substr(4, 2), 10);
if (!$.fn.bootstrapValidator.helpers.date(year, month, day)) {
return false;
}
// Validate the last check digit
return $.fn.bootstrapValidator.helpers.luhn(value);
},
/**
* Validate Slovak national identifier number (RC)
* Examples:
* - Valid: 7103192745, 991231123
* - Invalid: 7103192746, 1103492745
*
* @param {String} value The ID
* @returns {Boolean}
*/
_sk: function(value) {
// Slovakia uses the same format as Czech Republic
return this._cz(value);
},
/**
* Validate San Marino citizen number
*
* @see path_to_url#San_Marino
* @param {String} value The ID
* @returns {Boolean}
*/
_sm: function(value) {
return /^\d{5}$/.test(value);
},
/**
* Validate South African ID
* Example:
* - Valid: 8001015009087
* - Invalid: 8001015009287, 8001015009086
*
* @see path_to_url#South_Africa
* @param {String} value The ID
* @returns {Boolean}
*/
_za: function(value) {
if (!/^[0-9]{10}[0|1][8|9][0-9]$/.test(value)) {
return false;
}
var year = parseInt(value.substr(0, 2), 10),
currentYear = new Date().getFullYear() % 100,
month = parseInt(value.substr(2, 2), 10),
day = parseInt(value.substr(4, 2), 10);
year = (year >= currentYear) ? (year + 1900) : (year + 2000);
if (!$.fn.bootstrapValidator.helpers.date(year, month, day)) {
return false;
}
// Validate the last check digit
return $.fn.bootstrapValidator.helpers.luhn(value);
}
};
}(window.jQuery));
;(function($) {
$.fn.bootstrapValidator.i18n.identical = $.extend($.fn.bootstrapValidator.i18n.identical || {}, {
'default': 'Please enter the same value'
});
$.fn.bootstrapValidator.validators.identical = {
html5Attributes: {
message: 'message',
field: 'field'
},
/**
* Check if input value equals to value of particular one
*
* @param {BootstrapValidator} validator The validator plugin instance
* @param {jQuery} $field Field element
* @param {Object} options Consists of the following key:
* - field: The name of field that will be used to compare with current one
* @returns {Boolean}
*/
validate: function(validator, $field, options) {
var value = $field.val();
if (value === '') {
return true;
}
var compareWith = validator.getFieldElements(options.field);
if (compareWith === null) {
return true;
}
if (value === compareWith.val()) {
validator.updateStatus(options.field, validator.STATUS_VALID, 'identical');
return true;
} else {
return false;
}
}
};
}(window.jQuery));
;(function($) {
$.fn.bootstrapValidator.i18n.imei = $.extend($.fn.bootstrapValidator.i18n.imei || {}, {
'default': 'Please enter a valid IMEI number'
});
$.fn.bootstrapValidator.validators.imei = {
/**
* Validate IMEI (International Mobile Station Equipment Identity)
* Examples:
* - Valid: 35-209900-176148-1, 35-209900-176148-23, 3568680000414120, 490154203237518
* - Invalid: 490154203237517
*
* @see path_to_url
* @param {BootstrapValidator} validator The validator plugin instance
* @param {jQuery} $field Field element
* @param {Object} options Can consist of the following keys:
* - message: The invalid message
* @returns {Boolean}
*/
validate: function(validator, $field, options) {
var value = $field.val();
if (value === '') {
return true;
}
switch (true) {
case /^\d{15}$/.test(value):
case /^\d{2}-\d{6}-\d{6}-\d{1}$/.test(value):
case /^\d{2}\s\d{6}\s\d{6}\s\d{1}$/.test(value):
value = value.replace(/[^0-9]/g, '');
return $.fn.bootstrapValidator.helpers.luhn(value);
case /^\d{14}$/.test(value):
case /^\d{16}$/.test(value):
case /^\d{2}-\d{6}-\d{6}(|-\d{2})$/.test(value):
case /^\d{2}\s\d{6}\s\d{6}(|\s\d{2})$/.test(value):
return true;
default:
return false;
}
}
};
}(window.jQuery));
;(function($) {
$.fn.bootstrapValidator.i18n.imo = $.extend($.fn.bootstrapValidator.i18n.imo || {}, {
'default': 'Please enter a valid IMO number'
});
$.fn.bootstrapValidator.validators.imo = {
/**
* Validate IMO (International Maritime Organization)
* Examples:
* - Valid: IMO 8814275, IMO 9176187
* - Invalid: IMO 8814274
*
* @see path_to_url
* @param {BootstrapValidator} validator The validator plugin instance
* @param {jQuery} $field Field element
* @param {Object} options Can consist of the following keys:
* - message: The invalid message
* @returns {Boolean}
*/
validate: function(validator, $field, options) {
var value = $field.val();
if (value === '') {
return true;
}
if (!/^IMO \d{7}$/i.test(value)) {
return false;
}
// Grab just the digits
var sum = 0,
digits = value.replace(/^.*(\d{7})$/, '$1');
// Go over each char, multiplying by the inverse of it's position
// IMO 9176187
// (9 * 7) + (1 * 6) + (7 * 5) + (6 * 4) + (1 * 3) + (8 * 2) = 147
// Take the last digit of that, that's the check digit (7)
for (var i = 6; i >= 1; i--) {
sum += (digits.slice((6 - i), -i) * (i + 1));
}
return sum % 10 === parseInt(digits.charAt(6), 10);
}
};
}(window.jQuery));
;(function($) {
$.fn.bootstrapValidator.i18n.integer = $.extend($.fn.bootstrapValidator.i18n.integer || {}, {
'default': 'Please enter a valid number'
});
$.fn.bootstrapValidator.validators.integer = {
enableByHtml5: function($field) {
return ('number' === $field.attr('type')) && ($field.attr('step') === undefined || $field.attr('step') % 1 === 0);
},
/**
* Return true if the input value is an integer
*
* @param {BootstrapValidator} validator The validator plugin instance
* @param {jQuery} $field Field element
* @param {Object} options Can consist of the following key:
* - message: The invalid message
* @returns {Boolean}
*/
validate: function(validator, $field, options) {
var value = $field.val();
if (value === '') {
return true;
}
return /^(?:-?(?:0|[1-9][0-9]*))$/.test(value);
}
};
}(window.jQuery));
;(function($) {
$.fn.bootstrapValidator.i18n.ip = $.extend($.fn.bootstrapValidator.i18n.ip || {}, {
'default': 'Please enter a valid IP address',
ipv4: 'Please enter a valid IPv4 address',
ipv6: 'Please enter a valid IPv6 address'
});
$.fn.bootstrapValidator.validators.ip = {
html5Attributes: {
message: 'message',
ipv4: 'ipv4',
ipv6: 'ipv6'
},
/**
* Return true if the input value is a IP address.
*
* @param {BootstrapValidator} validator The validator plugin instance
* @param {jQuery} $field Field element
* @param {Object} options Can consist of the following keys:
* - ipv4: Enable IPv4 validator, default to true
* - ipv6: Enable IPv6 validator, default to true
* - message: The invalid message
* @returns {Boolean|Object}
*/
validate: function(validator, $field, options) {
var value = $field.val();
if (value === '') {
return true;
}
options = $.extend({}, { ipv4: true, ipv6: true }, options);
var ipv4Regex = /^(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$/,
ipv6Regex = /^\s*((([0-9A-Fa-f]{1,4}:){7}([0-9A-Fa-f]{1,4}|:))|(([0-9A-Fa-f]{1,4}:){6}(:[0-9A-Fa-f]{1,4}|((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3})|:))|(([0-9A-Fa-f]{1,4}:){5}(((:[0-9A-Fa-f]{1,4}){1,2})|:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3})|:))|(([0-9A-Fa-f]{1,4}:){4}(((:[0-9A-Fa-f]{1,4}){1,3})|((:[0-9A-Fa-f]{1,4})?:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(([0-9A-Fa-f]{1,4}:){3}(((:[0-9A-Fa-f]{1,4}){1,4})|((:[0-9A-Fa-f]{1,4}){0,2}:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(([0-9A-Fa-f]{1,4}:){2}(((:[0-9A-Fa-f]{1,4}){1,5})|((:[0-9A-Fa-f]{1,4}){0,3}:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(([0-9A-Fa-f]{1,4}:){1}(((:[0-9A-Fa-f]{1,4}){1,6})|((:[0-9A-Fa-f]{1,4}){0,4}:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(:(((:[0-9A-Fa-f]{1,4}){1,7})|((:[0-9A-Fa-f]{1,4}){0,5}:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:)))(%.+)?\s*$/,
valid = false,
message;
switch (true) {
case (options.ipv4 && !options.ipv6):
valid = ipv4Regex.test(value);
message = options.message || $.fn.bootstrapValidator.i18n.ip.ipv4;
break;
case (!options.ipv4 && options.ipv6):
valid = ipv6Regex.test(value);
message = options.message || $.fn.bootstrapValidator.i18n.ip.ipv6;
break;
case (options.ipv4 && options.ipv6):
/* falls through */
default:
valid = ipv4Regex.test(value) && ipv6Regex.test(value);
message = options.message || $.fn.bootstrapValidator.i18n.ip.default;
break;
}
return {
valid: valid,
message: message
};
}
};
}(window.jQuery));;(function($) {
$.fn.bootstrapValidator.i18n.isbn = $.extend($.fn.bootstrapValidator.i18n.isbn || {}, {
'default': 'Please enter a valid ISBN number'
});
$.fn.bootstrapValidator.validators.isbn = {
/**
* Return true if the input value is a valid ISBN 10 or ISBN 13 number
* Examples:
* - Valid:
* ISBN 10: 99921-58-10-7, 9971-5-0210-0, 960-425-059-0, 80-902734-1-6, 85-359-0277-5, 1-84356-028-3, 0-684-84328-5, 0-8044-2957-X, 0-85131-041-9, 0-943396-04-2, 0-9752298-0-X
* ISBN 13: 978-0-306-40615-7
* - Invalid:
* ISBN 10: 99921-58-10-6
* ISBN 13: 978-0-306-40615-6
*
* @see path_to_url
* @param {BootstrapValidator} validator The validator plugin instance
* @param {jQuery} $field Field element
* @param {Object} [options] Can consist of the following keys:
* - message: The invalid message
* @returns {Boolean}
*/
validate: function(validator, $field, options) {
var value = $field.val();
if (value === '') {
return true;
}
// path_to_url#Overview
// Groups are separated by a hyphen or a space
var type;
switch (true) {
case /^\d{9}[\dX]$/.test(value):
case (value.length === 13 && /^(\d+)-(\d+)-(\d+)-([\dX])$/.test(value)):
case (value.length === 13 && /^(\d+)\s(\d+)\s(\d+)\s([\dX])$/.test(value)):
type = 'ISBN10';
break;
case /^(978|979)\d{9}[\dX]$/.test(value):
case (value.length === 17 && /^(978|979)-(\d+)-(\d+)-(\d+)-([\dX])$/.test(value)):
case (value.length === 17 && /^(978|979)\s(\d+)\s(\d+)\s(\d+)\s([\dX])$/.test(value)):
type = 'ISBN13';
break;
default:
return false;
}
// Replace all special characters except digits and X
value = value.replace(/[^0-9X]/gi, '');
var chars = value.split(''),
length = chars.length,
sum = 0,
i,
checksum;
switch (type) {
case 'ISBN10':
sum = 0;
for (i = 0; i < length - 1; i++) {
sum += parseInt(chars[i], 10) * (10 - i);
}
checksum = 11 - (sum % 11);
if (checksum === 11) {
checksum = 0;
} else if (checksum === 10) {
checksum = 'X';
}
return (checksum + '' === chars[length - 1]);
case 'ISBN13':
sum = 0;
for (i = 0; i < length - 1; i++) {
sum += ((i % 2 === 0) ? parseInt(chars[i], 10) : (parseInt(chars[i], 10) * 3));
}
checksum = 10 - (sum % 10);
if (checksum === 10) {
checksum = '0';
}
return (checksum + '' === chars[length - 1]);
default:
return false;
}
}
};
}(window.jQuery));
;(function($) {
$.fn.bootstrapValidator.i18n.isin = $.extend($.fn.bootstrapValidator.i18n.isin || {}, {
'default': 'Please enter a valid ISIN number'
});
$.fn.bootstrapValidator.validators.isin = {
// Available country codes
// See path_to_url
COUNTRY_CODES: 'AF|AX|AL|DZ|AS|AD|AO|AI|AQ|AG|AR|AM|AW|AU|AT|AZ|BS|BH|BD|BB|BY|BE|BZ|BJ|BM|BT|BO|BQ|BA|BW|BV|BR|IO|BN|BG|BF|BI|KH|CM|CA|CV|KY|CF|TD|CL|CN|CX|CC|CO|KM|CG|CD|CK|CR|CI|HR|CU|CW|CY|CZ|DK|DJ|DM|DO|EC|EG|SV|GQ|ER|EE|ET|FK|FO|FJ|FI|FR|GF|PF|TF|GA|GM|GE|DE|GH|GI|GR|GL|GD|GP|GU|GT|GG|GN|GW|GY|HT|HM|VA|HN|HK|HU|IS|IN|ID|IR|IQ|IE|IM|IL|IT|JM|JP|JE|JO|KZ|KE|KI|KP|KR|KW|KG|LA|LV|LB|LS|LR|LY|LI|LT|LU|MO|MK|MG|MW|MY|MV|ML|MT|MH|MQ|MR|MU|YT|MX|FM|MD|MC|MN|ME|MS|MA|MZ|MM|NA|NR|NP|NL|NC|NZ|NI|NE|NG|NU|NF|MP|NO|OM|PK|PW|PS|PA|PG|PY|PE|PH|PN|PL|PT|PR|QA|RE|RO|RU|RW|BL|SH|KN|LC|MF|PM|VC|WS|SM|ST|SA|SN|RS|SC|SL|SG|SX|SK|SI|SB|SO|ZA|GS|SS|ES|LK|SD|SR|SJ|SZ|SE|CH|SY|TW|TJ|TZ|TH|TL|TG|TK|TO|TT|TN|TR|TM|TC|TV|UG|UA|AE|GB|US|UM|UY|UZ|VU|VE|VN|VG|VI|WF|EH|YE|ZM|ZW',
/**
* Validate an ISIN (International Securities Identification Number)
* Examples:
* - Valid: US0378331005, AU0000XVGZA3, GB0002634946
* - Invalid: US0378331004, AA0000XVGZA3
*
* @see path_to_url
* @param {BootstrapValidator} validator The validator plugin instance
* @param {jQuery} $field Field element
* @param {Object} options Can consist of the following keys:
* - message: The invalid message
* @returns {Boolean}
*/
validate: function(validator, $field, options) {
var value = $field.val();
if (value === '') {
return true;
}
value = value.toUpperCase();
var regex = new RegExp('^(' + this.COUNTRY_CODES + ')[0-9A-Z]{10}$');
if (!regex.test(value)) {
return false;
}
var converted = '',
length = value.length;
// Convert letters to number
for (var i = 0; i < length - 1; i++) {
var c = value.charCodeAt(i);
converted += ((c > 57) ? (c - 55).toString() : value.charAt(i));
}
var digits = '',
n = converted.length,
group = (n % 2 !== 0) ? 0 : 1;
for (i = 0; i < n; i++) {
digits += (parseInt(converted[i], 10) * ((i % 2) === group ? 2 : 1) + '');
}
var sum = 0;
for (i = 0; i < digits.length; i++) {
sum += parseInt(digits.charAt(i), 10);
}
sum = (10 - (sum % 10)) % 10;
return sum + '' === value.charAt(length - 1);
}
};
}(window.jQuery));
;(function($) {
$.fn.bootstrapValidator.i18n.ismn = $.extend($.fn.bootstrapValidator.i18n.ismn || {}, {
'default': 'Please enter a valid ISMN number'
});
$.fn.bootstrapValidator.validators.ismn = {
/**
* Validate ISMN (International Standard Music Number)
* Examples:
* - Valid: M230671187, 979-0-0601-1561-5, 979 0 3452 4680 5, 9790060115615
* - Invalid: 9790060115614
*
* @see path_to_url
* @param {BootstrapValidator} validator The validator plugin instance
* @param {jQuery} $field Field element
* @param {Object} options Can consist of the following keys:
* - message: The invalid message
* @returns {Boolean}
*/
validate: function(validator, $field, options) {
var value = $field.val();
if (value === '') {
return true;
}
// Groups are separated by a hyphen or a space
var type;
switch (true) {
case /^M\d{9}$/.test(value):
case /^M-\d{4}-\d{4}-\d{1}$/.test(value):
case /^M\s\d{4}\s\d{4}\s\d{1}$/.test(value):
type = 'ISMN10';
break;
case /^9790\d{9}$/.test(value):
case /^979-0-\d{4}-\d{4}-\d{1}$/.test(value):
case /^979\s0\s\d{4}\s\d{4}\s\d{1}$/.test(value):
type = 'ISMN13';
break;
default:
return false;
}
if ('ISMN10' === type) {
value = '9790' + value.substr(1);
}
// Replace all special characters except digits
value = value.replace(/[^0-9]/gi, '');
var length = value.length,
sum = 0,
weight = [1, 3];
for (var i = 0; i < length - 1; i++) {
sum += parseInt(value.charAt(i), 10) * weight[i % 2];
}
sum = 10 - sum % 10;
return (sum + '' === value.charAt(length - 1));
}
};
}(window.jQuery));
;(function($) {
$.fn.bootstrapValidator.i18n.issn = $.extend($.fn.bootstrapValidator.i18n.issn || {}, {
'default': 'Please enter a valid ISSN number'
});
$.fn.bootstrapValidator.validators.issn = {
/**
* Validate ISSN (International Standard Serial Number)
* Examples:
* - Valid: 0378-5955, 0024-9319, 0032-1478
* - Invalid: 0032-147X
*
* @see path_to_url
* @param {BootstrapValidator} validator The validator plugin instance
* @param {jQuery} $field Field element
* @param {Object} options Can consist of the following keys:
* - message: The invalid message
* @returns {Boolean}
*/
validate: function(validator, $field, options) {
var value = $field.val();
if (value === '') {
return true;
}
// Groups are separated by a hyphen or a space
if (!/^\d{4}\-\d{3}[\dX]$/.test(value)) {
return false;
}
// Replace all special characters except digits and X
value = value.replace(/[^0-9X]/gi, '');
var chars = value.split(''),
length = chars.length,
sum = 0;
if (chars[7] === 'X') {
chars[7] = 10;
}
for (var i = 0; i < length; i++) {
sum += parseInt(chars[i], 10) * (8 - i);
}
return (sum % 11 === 0);
}
};
}(window.jQuery));
;(function($) {
$.fn.bootstrapValidator.i18n.lessThan = $.extend($.fn.bootstrapValidator.i18n.lessThan || {}, {
'default': 'Please enter a value less than or equal to %s',
notInclusive: 'Please enter a value less than %s'
});
$.fn.bootstrapValidator.validators.lessThan = {
html5Attributes: {
message: 'message',
value: 'value',
inclusive: 'inclusive'
},
enableByHtml5: function($field) {
var max = $field.attr('max');
if (max) {
return {
value: max
};
}
return false;
},
/**
* Return true if the input value is less than or equal to given number
*
* @param {BootstrapValidator} validator The validator plugin instance
* @param {jQuery} $field Field element
* @param {Object} options Can consist of the following keys:
* - value: The number used to compare to. It can be
* - A number
* - Name of field which its value defines the number
* - Name of callback function that returns the number
* - A callback function that returns the number
*
* - inclusive [optional]: Can be true or false. Default is true
* - message: The invalid message
* @returns {Boolean|Object}
*/
validate: function(validator, $field, options) {
var value = $field.val();
if (value === '') {
return true;
}
var compareTo = $.isNumeric(options.value) ? options.value : validator.getDynamicOption($field, options.value);
value = parseFloat(value);
return (options.inclusive === true || options.inclusive === undefined)
? {
valid: value <= compareTo,
message: $.fn.bootstrapValidator.helpers.format(options.message || $.fn.bootstrapValidator.i18n.lessThan['default'], compareTo)
}
: {
valid: value < compareTo,
message: $.fn.bootstrapValidator.helpers.format(options.message || $.fn.bootstrapValidator.i18n.lessThan.notInclusive, compareTo)
};
}
};
}(window.jQuery));
;(function($) {
$.fn.bootstrapValidator.i18n.mac = $.extend($.fn.bootstrapValidator.i18n.mac || {}, {
'default': 'Please enter a valid MAC address'
});
$.fn.bootstrapValidator.validators.mac = {
/**
* Return true if the input value is a MAC address.
*
* @param {BootstrapValidator} validator The validator plugin instance
* @param {jQuery} $field Field element
* @param {Object} options Can consist of the following keys:
* - message: The invalid message
* @returns {Boolean}
*/
validate: function(validator, $field, options) {
var value = $field.val();
if (value === '') {
return true;
}
return /^([0-9A-F]{2}[:-]){5}([0-9A-F]{2})$/.test(value);
}
};
}(window.jQuery));
;(function($) {
$.fn.bootstrapValidator.i18n.meid = $.extend($.fn.bootstrapValidator.i18n.meid || {}, {
'default': 'Please enter a valid MEID number'
});
$.fn.bootstrapValidator.validators.meid = {
/**
* Validate MEID (Mobile Equipment Identifier)
* Examples:
* - Valid: 293608736500703710, 29360-87365-0070-3710, AF0123450ABCDE, AF-012345-0ABCDE
* - Invalid: 2936087365007037101
*
* @see path_to_url
* @param {BootstrapValidator} validator The validator plugin instance
* @param {jQuery} $field Field element
* @param {Object} options Can consist of the following keys:
* - message: The invalid message
* @returns {Boolean}
*/
validate: function(validator, $field, options) {
var value = $field.val();
if (value === '') {
return true;
}
switch (true) {
// 14 digit hex representation (no check digit)
case /^[0-9A-F]{15}$/i.test(value):
// 14 digit hex representation + dashes or spaces (no check digit)
case /^[0-9A-F]{2}[- ][0-9A-F]{6}[- ][0-9A-F]{6}[- ][0-9A-F]$/i.test(value):
// 18 digit decimal representation (no check digit)
case /^\d{19}$/.test(value):
// 18 digit decimal representation + dashes or spaces (no check digit)
case /^\d{5}[- ]\d{5}[- ]\d{4}[- ]\d{4}[- ]\d$/.test(value):
// Grab the check digit
var cd = value.charAt(value.length - 1);
// Strip any non-hex chars
value = value.replace(/[- ]/g, '');
// If it's all digits, luhn base 10 is used
if (value.match(/^\d*$/i)) {
return $.fn.bootstrapValidator.helpers.luhn(value);
}
// Strip the check digit
value = value.slice(0, -1);
// Get every other char, and double it
var cdCalc = '';
for (var i = 1; i <= 13; i += 2) {
cdCalc += (parseInt(value.charAt(i), 16) * 2).toString(16);
}
// Get the sum of each char in the string
var sum = 0;
for (i = 0; i < cdCalc.length; i++) {
sum += parseInt(cdCalc.charAt(i), 16);
}
// If the last digit of the calc is 0, the check digit is 0
return (sum % 10 === 0)
? (cd === '0')
// Subtract it from the next highest 10s number (64 goes to 70) and subtract the sum
// Double it and turn it into a hex char
: (cd === ((Math.floor((sum + 10) / 10) * 10 - sum) * 2).toString(16));
// 14 digit hex representation (no check digit)
case /^[0-9A-F]{14}$/i.test(value):
// 14 digit hex representation + dashes or spaces (no check digit)
case /^[0-9A-F]{2}[- ][0-9A-F]{6}[- ][0-9A-F]{6}$/i.test(value):
// 18 digit decimal representation (no check digit)
case /^\d{18}$/.test(value):
// 18 digit decimal representation + dashes or spaces (no check digit)
case /^\d{5}[- ]\d{5}[- ]\d{4}[- ]\d{4}$/.test(value):
return true;
default:
return false;
}
}
};
}(window.jQuery));
;(function($) {
$.fn.bootstrapValidator.i18n.notEmpty = $.extend($.fn.bootstrapValidator.i18n.notEmpty || {}, {
'default': 'Please enter a value'
});
$.fn.bootstrapValidator.validators.notEmpty = {
enableByHtml5: function($field) {
var required = $field.attr('required') + '';
return ('required' === required || 'true' === required);
},
/**
* Check if input value is empty or not
*
* @param {BootstrapValidator} validator The validator plugin instance
* @param {jQuery} $field Field element
* @param {Object} options
* @returns {Boolean}
*/
validate: function(validator, $field, options) {
var type = $field.attr('type');
if ('radio' === type || 'checkbox' === type) {
return validator
.getFieldElements($field.attr('data-bv-field'))
.filter(':checked')
.length > 0;
}
return $.trim($field.val()) !== '';
}
};
}(window.jQuery));
;(function($) {
$.fn.bootstrapValidator.i18n.numeric = $.extend($.fn.bootstrapValidator.i18n.numeric || {}, {
'default': 'Please enter a valid float number'
});
$.fn.bootstrapValidator.validators.numeric = {
html5Attributes: {
message: 'message',
separator: 'separator'
},
enableByHtml5: function($field) {
return ('number' === $field.attr('type')) && ($field.attr('step') !== undefined) && ($field.attr('step') % 1 !== 0);
},
/**
* Validate decimal number
*
* @param {BootstrapValidator} validator The validator plugin instance
* @param {jQuery} $field Field element
* @param {Object} options Consist of key:
* - message: The invalid message
* - separator: The decimal separator. Can be "." (default), ","
* @returns {Boolean}
*/
validate: function(validator, $field, options) {
var value = $field.val();
if (value === '') {
return true;
}
var separator = options.separator || '.';
if (separator !== '.') {
value = value.replace(separator, '.');
}
return !isNaN(parseFloat(value)) && isFinite(value);
}
};
}(window.jQuery));
;(function($) {
$.fn.bootstrapValidator.i18n.phone = $.extend($.fn.bootstrapValidator.i18n.phone || {}, {
'default': 'Please enter a valid phone number',
countryNotSupported: 'The country code %s is not supported',
country: 'Please enter a valid phone number in %s',
countries: {
ES: 'Spain',
FR: 'France',
GB: 'United Kingdom',
US: 'USA'
}
});
$.fn.bootstrapValidator.validators.phone = {
html5Attributes: {
message: 'message',
country: 'country'
},
// The supported countries
COUNTRY_CODES: ['ES', 'FR', 'GB', 'US'],
/**
* Return true if the input value contains a valid phone number for the country
* selected in the options
*
* @param {BootstrapValidator} validator Validate plugin instance
* @param {jQuery} $field Field element
* @param {Object} options Consist of key:
* - message: The invalid message
* - country: The ISO-3166 country code. It can be
* - A country code
* - Name of field which its value defines the country code
* - Name of callback function that returns the country code
* - A callback function that returns the country code
*
* @returns {Boolean|Object}
*/
validate: function(validator, $field, options) {
var value = $field.val();
if (value === '') {
return true;
}
var country = options.country;
if (typeof country !== 'string' || $.inArray(country, this.COUNTRY_CODES) === -1) {
// Try to determine the country
country = validator.getDynamicOption($field, country);
}
if (!country || $.inArray(country.toUpperCase(), this.COUNTRY_CODES) === -1) {
return {
valid: false,
message: $.fn.bootstrapValidator.helpers.format($.fn.bootstrapValidator.i18n.phone.countryNotSupported, country)
};
}
var isValid = true;
switch (country.toUpperCase()) {
case 'ES':
// path_to_url
value = $.trim(value);
isValid = (/^(?:(?:(?:\+|00)34\D?))?(?:9|6)(?:\d\D?){8}$/).test(value);
break;
case 'FR':
// path_to_url
value = $.trim(value);
isValid = (/^(?:(?:(?:\+|00)33\D?(?:\D?\(0\)\D?)?)|0){1}[1-9]{1}(?:\D?\d{2}){4}$/).test(value);
break;
case 'GB':
// path_to_url#Match_GB_telephone_number_in_any_format
// Test: path_to_url
value = $.trim(value);
isValid = (/^\(?(?:(?:0(?:0|11)\)?[\s-]?\(?|\+)44\)?[\s-]?\(?(?:0\)?[\s-]?\(?)?|0)(?:\d{2}\)?[\s-]?\d{4}[\s-]?\d{4}|\d{3}\)?[\s-]?\d{3}[\s-]?\d{3,4}|\d{4}\)?[\s-]?(?:\d{5}|\d{3}[\s-]?\d{3})|\d{5}\)?[\s-]?\d{4,5}|8(?:00[\s-]?11[\s-]?11|45[\s-]?46[\s-]?4\d))(?:(?:[\s-]?(?:x|ext\.?\s?|\#)\d+)?)$/).test(value);
break;
case 'US':
/* falls through */
default:
// Make sure US phone numbers have 10 digits
// May start with 1, +1, or 1-; should discard
// Area code may be delimited with (), & sections may be delimited with . or -
// Test: path_to_url
value = value.replace(/\D/g, '');
isValid = (/^(?:(1\-?)|(\+1 ?))?\(?(\d{3})[\)\-\.]?(\d{3})[\-\.]?(\d{4})$/).test(value) && (value.length === 10);
break;
}
return {
valid: isValid,
message: $.fn.bootstrapValidator.helpers.format(options.message || $.fn.bootstrapValidator.i18n.phone.country, $.fn.bootstrapValidator.i18n.phone.countries[country])
};
}
};
}(window.jQuery));
;(function($) {
$.fn.bootstrapValidator.i18n.regexp = $.extend($.fn.bootstrapValidator.i18n.regexp || {}, {
'default': 'Please enter a value matching the pattern'
});
$.fn.bootstrapValidator.validators.regexp = {
html5Attributes: {
message: 'message',
regexp: 'regexp'
},
enableByHtml5: function($field) {
var pattern = $field.attr('pattern');
if (pattern) {
return {
regexp: pattern
};
}
return false;
},
/**
* Check if the element value matches given regular expression
*
* @param {BootstrapValidator} validator The validator plugin instance
* @param {jQuery} $field Field element
* @param {Object} options Consists of the following key:
* - regexp: The regular expression you need to check
* @returns {Boolean}
*/
validate: function(validator, $field, options) {
var value = $field.val();
if (value === '') {
return true;
}
var regexp = ('string' === typeof options.regexp) ? new RegExp(options.regexp) : options.regexp;
return regexp.test(value);
}
};
}(window.jQuery));
;(function($) {
$.fn.bootstrapValidator.i18n.remote = $.extend($.fn.bootstrapValidator.i18n.remote || {}, {
'default': 'Please enter a valid value'
});
$.fn.bootstrapValidator.validators.remote = {
html5Attributes: {
message: 'message',
url: 'url',
name: 'name'
},
/**
* Request a remote server to check the input value
*
* @param {BootstrapValidator} validator Plugin instance
* @param {jQuery} $field Field element
* @param {Object} options Can consist of the following keys:
* - url {String|Function}
* - type {String} [optional] Can be GET or POST (default)
* - data {Object|Function} [optional]: By default, it will take the value
* {
* <fieldName>: <fieldValue>
* }
* - name {String} [optional]: Override the field name for the request.
* - message: The invalid message
* @returns {Boolean|Deferred}
*/
validate: function(validator, $field, options) {
var value = $field.val();
if (value === '') {
return true;
}
var name = $field.attr('data-bv-field'),
data = options.data || {},
url = options.url,
type = options.type || 'POST';
// Support dynamic data
if ('function' === typeof data) {
data = data.call(this, validator);
}
// Support dynamic url
if ('function' === typeof url) {
url = url.call(this, validator);
}
data[options.name || name] = value;
var dfd = new $.Deferred();
var xhr = $.ajax({
type: type,
url: url,
dataType: 'json',
data: data
});
xhr.then(function(response) {
dfd.resolve($field, 'remote', response.valid === true || response.valid === 'true', response.message ? response.message : null);
});
dfd.fail(function() {
xhr.abort();
});
return dfd;
}
};
}(window.jQuery));
;(function($) {
$.fn.bootstrapValidator.i18n.rtn = $.extend($.fn.bootstrapValidator.i18n.rtn || {}, {
'default': 'Please enter a valid RTN number'
});
$.fn.bootstrapValidator.validators.rtn = {
/**
* Validate a RTN (Routing transit number)
* Examples:
* - Valid: 021200025, 789456124
*
* @see path_to_url
* @param {BootstrapValidator} validator The validator plugin instance
* @param {jQuery} $field Field element
* @param {Object} options Can consist of the following keys:
* - message: The invalid message
* @returns {Boolean}
*/
validate: function(validator, $field, options) {
var value = $field.val();
if (value === '') {
return true;
}
if (!/^\d{9}$/.test(value)) {
return false;
}
var sum = 0;
for (var i = 0; i < value.length; i += 3) {
sum += parseInt(value.charAt(i), 10) * 3
+ parseInt(value.charAt(i + 1), 10) * 7
+ parseInt(value.charAt(i + 2), 10);
}
return (sum !== 0 && sum % 10 === 0);
}
};
}(window.jQuery));
;(function($) {
$.fn.bootstrapValidator.i18n.sedol = $.extend($.fn.bootstrapValidator.i18n.sedol || {}, {
'default': 'Please enter a valid SEDOL number'
});
$.fn.bootstrapValidator.validators.sedol = {
/**
* Validate a SEDOL (Stock Exchange Daily Official List)
* Examples:
* - Valid: 0263494, B0WNLY7
*
* @see path_to_url
* @param {BootstrapValidator} validator The validator plugin instance
* @param {jQuery} $field Field element
* @param {Object} options Can consist of the following keys:
* - message: The invalid message
* @returns {Boolean}
*/
validate: function(validator, $field, options) {
var value = $field.val();
if (value === '') {
return true;
}
value = value.toUpperCase();
if (!/^[0-9A-Z]{7}$/.test(value)) {
return false;
}
var sum = 0,
weight = [1, 3, 1, 7, 3, 9, 1],
length = value.length;
for (var i = 0; i < length - 1; i++) {
sum += weight[i] * parseInt(value.charAt(i), 36);
}
sum = (10 - sum % 10) % 10;
return sum + '' === value.charAt(length - 1);
}
};
}(window.jQuery));
;(function($) {
$.fn.bootstrapValidator.i18n.siren = $.extend($.fn.bootstrapValidator.i18n.siren || {}, {
'default': 'Please enter a valid SIREN number'
});
$.fn.bootstrapValidator.validators.siren = {
/**
* Check if a string is a siren number
*
* @param {BootstrapValidator} validator The validator plugin instance
* @param {jQuery} $field Field element
* @param {Object} options Consist of key:
* - message: The invalid message
* @returns {Boolean}
*/
validate: function(validator, $field, options) {
var value = $field.val();
if (value === '') {
return true;
}
if (!/^\d{9}$/.test(value)) {
return false;
}
return $.fn.bootstrapValidator.helpers.luhn(value);
}
};
}(window.jQuery));
;(function($) {
$.fn.bootstrapValidator.i18n.siret = $.extend($.fn.bootstrapValidator.i18n.siret || {}, {
'default': 'Please enter a valid SIRET number'
});
$.fn.bootstrapValidator.validators.siret = {
/**
* Check if a string is a siret number
*
* @param {BootstrapValidator} validator The validator plugin instance
* @param {jQuery} $field Field element
* @param {Object} options Consist of key:
* - message: The invalid message
* @returns {Boolean}
*/
validate: function(validator, $field, options) {
var value = $field.val();
if (value === '') {
return true;
}
var sum = 0,
length = value.length,
tmp;
for (var i = 0; i < length; i++) {
tmp = parseInt(value.charAt(i), 10);
if ((i % 2) === 0) {
tmp = tmp * 2;
if (tmp > 9) {
tmp -= 9;
}
}
sum += tmp;
}
return (sum % 10 === 0);
}
};
}(window.jQuery));
;(function($) {
$.fn.bootstrapValidator.i18n.step = $.extend($.fn.bootstrapValidator.i18n.step || {}, {
'default': 'Please enter a valid step of %s'
});
$.fn.bootstrapValidator.validators.step = {
html5Attributes: {
message: 'message',
base: 'baseValue',
step: 'step'
},
/**
* Return true if the input value is valid step one
*
* @param {BootstrapValidator} validator The validator plugin instance
* @param {jQuery} $field Field element
* @param {Object} options Can consist of the following keys:
* - baseValue: The base value
* - step: The step
* - message: The invalid message
* @returns {Boolean|Object}
*/
validate: function(validator, $field, options) {
var value = $field.val();
if (value === '') {
return true;
}
options = $.extend({}, { baseValue: 0, step: 1 }, options);
value = parseFloat(value);
if (!$.isNumeric(value)) {
return false;
}
var round = function(x, precision) {
var m = Math.pow(10, precision);
x = x * m;
var sign = (x > 0) | -(x < 0),
isHalf = (x % 1 === 0.5 * sign);
if (isHalf) {
return (Math.floor(x) + (sign > 0)) / m;
} else {
return Math.round(x) / m;
}
},
floatMod = function(x, y) {
if (y === 0.0) {
return 1.0;
}
var dotX = (x + '').split('.'),
dotY = (y + '').split('.'),
precision = ((dotX.length === 1) ? 0 : dotX[1].length) + ((dotY.length === 1) ? 0 : dotY[1].length);
return round(x - y * Math.floor(x / y), precision);
};
var mod = floatMod(value - options.baseValue, options.step);
return {
valid: mod === 0.0 || mod === options.step,
message: $.fn.bootstrapValidator.helpers.format(options.message || $.fn.bootstrapValidator.i18n.step['default'], [options.step])
};
}
};
}(window.jQuery));
;(function($) {
$.fn.bootstrapValidator.i18n.stringCase = $.extend($.fn.bootstrapValidator.i18n.stringCase || {}, {
'default': 'Please enter only lowercase characters',
upper: 'Please enter only uppercase characters'
});
$.fn.bootstrapValidator.validators.stringCase = {
html5Attributes: {
message: 'message',
'case': 'case'
},
/**
* Check if a string is a lower or upper case one
*
* @param {BootstrapValidator} validator The validator plugin instance
* @param {jQuery} $field Field element
* @param {Object} options Consist of key:
* - message: The invalid message
* - case: Can be 'lower' (default) or 'upper'
* @returns {Object}
*/
validate: function(validator, $field, options) {
var value = $field.val();
if (value === '') {
return true;
}
var stringCase = (options['case'] || 'lower').toLowerCase();
return {
valid: ('upper' === stringCase) ? value === value.toUpperCase() : value === value.toLowerCase(),
message: options.message || (('upper' === stringCase) ? $.fn.bootstrapValidator.i18n.stringCase.upper : $.fn.bootstrapValidator.i18n.stringCase['default'])
};
}
};
}(window.jQuery));
;(function($) {
$.fn.bootstrapValidator.i18n.stringLength = $.extend($.fn.bootstrapValidator.i18n.stringLength || {}, {
'default': 'Please enter a value with valid length',
less: 'Please enter less than %s characters',
more: 'Please enter more than %s characters',
between: 'Please enter value between %s and %s characters long'
});
$.fn.bootstrapValidator.validators.stringLength = {
html5Attributes: {
message: 'message',
min: 'min',
max: 'max'
},
enableByHtml5: function($field) {
var maxLength = $field.attr('maxlength');
if (maxLength) {
return {
max: parseInt(maxLength, 10)
};
}
return false;
},
/**
* Check if the length of element value is less or more than given number
*
* @param {BootstrapValidator} validator The validator plugin instance
* @param {jQuery} $field Field element
* @param {Object} options Consists of following keys:
* - min
* - max
* At least one of two keys is required
* The min, max keys define the number which the field value compares to. min, max can be
* - A number
* - Name of field which its value defines the number
* - Name of callback function that returns the number
* - A callback function that returns the number
*
* - message: The invalid message
* @returns {Object}
*/
validate: function(validator, $field, options) {
var value = $field.val();
if (value === '') {
return true;
}
var min = $.isNumeric(options.min) ? options.min : validator.getDynamicOption($field, options.min),
max = $.isNumeric(options.max) ? options.max : validator.getDynamicOption($field, options.max),
length = value.length,
isValid = true,
message = options.message || $.fn.bootstrapValidator.i18n.stringLength['default'];
if ((min && length < parseInt(min, 10)) || (max && length > parseInt(max, 10))) {
isValid = false;
}
switch (true) {
case (!!min && !!max):
message = $.fn.bootstrapValidator.helpers.format(options.message || $.fn.bootstrapValidator.i18n.stringLength.between, [parseInt(min, 10), parseInt(max, 10)]);
break;
case (!!min):
message = $.fn.bootstrapValidator.helpers.format(options.message || $.fn.bootstrapValidator.i18n.stringLength.more, parseInt(min, 10));
break;
case (!!max):
message = $.fn.bootstrapValidator.helpers.format(options.message || $.fn.bootstrapValidator.i18n.stringLength.less, parseInt(max, 10));
break;
default:
break;
}
return { valid: isValid, message: message };
}
};
}(window.jQuery));
;(function($) {
$.fn.bootstrapValidator.i18n.uri = $.extend($.fn.bootstrapValidator.i18n.uri || {}, {
'default': 'Please enter a valid URI'
});
$.fn.bootstrapValidator.validators.uri = {
html5Attributes: {
message: 'message',
allowlocal: 'allowLocal'
},
enableByHtml5: function($field) {
return ('url' === $field.attr('type'));
},
/**
* Return true if the input value is a valid URL
*
* @param {BootstrapValidator} validator The validator plugin instance
* @param {jQuery} $field Field element
* @param {Object} options
* - message: The error message
* - allowLocal: Allow the private and local network IP. Default to false
* @returns {Boolean}
*/
validate: function(validator, $field, options) {
var value = $field.val();
if (value === '') {
return true;
}
// Credit to path_to_url
//
// Regular Expression for URL validation
//
// Author: Diego Perini
// Updated: 2010/12/05
//
// the regular expression composed & commented
// could be easily tweaked for RFC compliance,
// it was expressly modified to fit & satisfy
// these test for an URL shortener:
//
// path_to_url
//
// Notes on possible differences from a standard/generic validation:
//
// - utf-8 char class take in consideration the full Unicode range
// - TLDs are mandatory unless `allowLocal` is true
// - protocols have been restricted to ftp, http and https only as requested
//
// Changes:
//
// - IP address dotted notation validation, range: 1.0.0.0 - 223.255.255.255
// first and last IP address of each class is considered invalid
// (since they are broadcast/network addresses)
//
// - Added exclusion of private, reserved and/or local networks ranges
// unless `allowLocal` is true
//
var allowLocal = options.allowLocal === true || options.allowLocal === 'true',
urlExp = new RegExp(
"^" +
// protocol identifier
"(?:(?:https?|ftp)://)" +
// user:pass authentication
"(?:\\S+(?::\\S*)?@)?" +
"(?:" +
// IP address exclusion
// private & local networks
(allowLocal
? ''
: ("(?!(?:10|127)(?:\\.\\d{1,3}){3})" +
"(?!(?:169\\.254|192\\.168)(?:\\.\\d{1,3}){2})" +
"(?!172\\.(?:1[6-9]|2\\d|3[0-1])(?:\\.\\d{1,3}){2})")) +
// IP address dotted notation octets
// excludes loopback network 0.0.0.0
// excludes reserved space >= 224.0.0.0
// excludes network & broadcast addresses
// (first & last IP address of each class)
"(?:[1-9]\\d?|1\\d\\d|2[01]\\d|22[0-3])" +
"(?:\\.(?:1?\\d{1,2}|2[0-4]\\d|25[0-5])){2}" +
"(?:\\.(?:[1-9]\\d?|1\\d\\d|2[0-4]\\d|25[0-4]))" +
"|" +
// host name
"(?:(?:[a-z\\u00a1-\\uffff0-9]+-?)*[a-z\\u00a1-\\uffff0-9]+)" +
// domain name
"(?:\\.(?:[a-z\\u00a1-\\uffff0-9]+-?)*[a-z\\u00a1-\\uffff0-9]+)*" +
// TLD identifier
"(?:\\.(?:[a-z\\u00a1-\\uffff]{2,}))" +
// Allow intranet sites (no TLD) if `allowLocal` is true
(allowLocal ? '?' : '') +
")" +
// port number
"(?::\\d{2,5})?" +
// resource path
"(?:/[^\\s]*)?" +
"$", "i"
);
return urlExp.test(value);
}
};
}(window.jQuery));
;(function($) {
$.fn.bootstrapValidator.i18n.uuid = $.extend($.fn.bootstrapValidator.i18n.uuid || {}, {
'default': 'Please enter a valid UUID number',
version: 'Please enter a valid UUID version %s number'
});
$.fn.bootstrapValidator.validators.uuid = {
html5Attributes: {
message: 'message',
version: 'version'
},
/**
* Return true if and only if the input value is a valid UUID string
*
* @see path_to_url
* @param {BootstrapValidator} validator The validator plugin instance
* @param {jQuery} $field Field element
* @param {Object} options Consist of key:
* - message: The invalid message
* - version: Can be 3, 4, 5, null
* @returns {Boolean|Object}
*/
validate: function(validator, $field, options) {
var value = $field.val();
if (value === '') {
return true;
}
// See the format at path_to_url#Variants_and_versions
var patterns = {
'3': /^[0-9A-F]{8}-[0-9A-F]{4}-3[0-9A-F]{3}-[0-9A-F]{4}-[0-9A-F]{12}$/i,
'4': /^[0-9A-F]{8}-[0-9A-F]{4}-4[0-9A-F]{3}-[89AB][0-9A-F]{3}-[0-9A-F]{12}$/i,
'5': /^[0-9A-F]{8}-[0-9A-F]{4}-5[0-9A-F]{3}-[89AB][0-9A-F]{3}-[0-9A-F]{12}$/i,
all: /^[0-9A-F]{8}-[0-9A-F]{4}-[0-9A-F]{4}-[0-9A-F]{4}-[0-9A-F]{12}$/i
},
version = options.version ? (options.version + '') : 'all';
return {
valid: (null === patterns[version]) ? true : patterns[version].test(value),
message: options.version
? $.fn.bootstrapValidator.helpers.format(options.message || $.fn.bootstrapValidator.i18n.uuid.version, options.version)
: (options.message || $.fn.bootstrapValidator.i18n.uuid['default'])
};
}
};
}(window.jQuery));
;(function($) {
$.fn.bootstrapValidator.i18n.vat = $.extend($.fn.bootstrapValidator.i18n.vat || {}, {
'default': 'Please enter a valid VAT number',
countryNotSupported: 'The country code %s is not supported',
country: 'Please enter a valid %s VAT number',
countries: {
AT: 'Austrian',
BE: 'Belgian',
BG: 'Bulgarian',
CH: 'Swiss',
CY: 'Cypriot',
CZ: 'Czech',
DE: 'German',
DK: 'Danish',
EE: 'Estonian',
ES: 'Spanish',
FI: 'Finnish',
FR: 'French',
GB: 'United Kingdom',
GR: 'Greek',
EL: 'Greek',
HU: 'Hungarian',
HR: 'Croatian',
IE: 'Irish',
IT: 'Italian',
LT: 'Lithuanian',
LU: 'Luxembourg',
LV: 'Latvian',
MT: 'Maltese',
NL: 'Dutch',
NO: 'Norwegian',
PL: 'Polish',
PT: 'Portuguese',
RO: 'Romanian',
RU: 'Russian',
RS: 'Serbian',
SE: 'Swedish',
SI: 'Slovenian',
SK: 'Slovak'
}
});
$.fn.bootstrapValidator.validators.vat = {
html5Attributes: {
message: 'message',
country: 'country'
},
// Supported country codes
COUNTRY_CODES: [
'AT', 'BE', 'BG', 'HR', 'CY', 'CZ', 'DK', 'EE', 'FI', 'FR', 'DE', 'GR', 'EL', 'HU', 'IE', 'IT',
'LV', 'LT', 'LU', 'MT', 'NL', 'NO', 'PL', 'PT', 'RO', 'RU', 'RS', 'SK', 'SI', 'ES', 'SE', 'CH', 'GB'
],
/**
* Validate an European VAT number
*
* @param {BootstrapValidator} validator The validator plugin instance
* @param {jQuery} $field Field element
* @param {Object} options Consist of key:
* - message: The invalid message
* - country: The ISO 3166-1 country code. It can be
* - One of country code defined in COUNTRY_CODES
* - Name of field which its value defines the country code
* - Name of callback function that returns the country code
* - A callback function that returns the country code
* @returns {Boolean|Object}
*/
validate: function(validator, $field, options) {
var value = $field.val();
if (value === '') {
return true;
}
var country = options.country;
if (!country) {
country = value.substr(0, 2);
} else if (typeof country !== 'string' || $.inArray(country.toUpperCase(), this.COUNTRY_CODES) === -1) {
// Determine the country code
country = validator.getDynamicOption($field, country);
}
if ($.inArray(country, this.COUNTRY_CODES) === -1) {
return {
valid: false,
message: $.fn.bootstrapValidator.helpers.format($.fn.bootstrapValidator.i18n.vat.countryNotSupported, country)
};
}
var method = ['_', country.toLowerCase()].join('');
return this[method](value)
? true
: {
valid: false,
message: $.fn.bootstrapValidator.helpers.format(options.message || $.fn.bootstrapValidator.i18n.vat.country, $.fn.bootstrapValidator.i18n.vat.countries[country.toUpperCase()])
};
},
// VAT validators
/**
* Validate Austrian VAT number
* Example:
* - Valid: ATU13585627
* - Invalid: ATU13585626
*
* @param {String} value VAT number
* @returns {Boolean}
*/
_at: function(value) {
if (!/^ATU[0-9]{8}$/.test(value)) {
return false;
}
value = value.substr(3);
var sum = 0,
weight = [1, 2, 1, 2, 1, 2, 1],
temp = 0;
for (var i = 0; i < 7; i++) {
temp = parseInt(value.charAt(i), 10) * weight[i];
if (temp > 9) {
temp = Math.floor(temp / 10) + temp % 10;
}
sum += temp;
}
sum = 10 - (sum + 4) % 10;
if (sum === 10) {
sum = 0;
}
return (sum + '' === value.substr(7, 1));
},
/**
* Validate Belgian VAT number
* Example:
* - Valid: BE0428759497
* - Invalid: BE431150351
*
* @param {String} value VAT number
* @returns {Boolean}
*/
_be: function(value) {
if (!/^BE[0]{0,1}[0-9]{9}$/.test(value)) {
return false;
}
value = value.substr(2);
if (value.length === 9) {
value = '0' + value;
}
if (value.substr(1, 1) === '0') {
return false;
}
var sum = parseInt(value.substr(0, 8), 10) + parseInt(value.substr(8, 2), 10);
return (sum % 97 === 0);
},
/**
* Validate Bulgarian VAT number
* Example:
* - Valid: BG175074752,
* BG7523169263, BG8032056031,
* BG7542011030,
* BG7111042925
* - Invalid: BG175074753, BG7552A10004, BG7111042922
*
* @param {String} value VAT number
* @returns {Boolean}
*/
_bg: function(value) {
if (!/^BG[0-9]{9,10}$/.test(value)) {
return false;
}
value = value.substr(2);
var sum = 0, i = 0;
// Legal entities
if (value.length === 9) {
for (i = 0; i < 8; i++) {
sum += parseInt(value.charAt(i), 10) * (i + 1);
}
sum = sum % 11;
if (sum === 10) {
sum = 0;
for (i = 0; i < 8; i++) {
sum += parseInt(value.charAt(i), 10) * (i + 3);
}
}
sum = sum % 10;
return (sum + '' === value.substr(8));
}
// Physical persons, foreigners and others
else if (value.length === 10) {
// Validate Bulgarian national identification numbers
var egn = function(value) {
// Check the birth date
var year = parseInt(value.substr(0, 2), 10) + 1900,
month = parseInt(value.substr(2, 2), 10),
day = parseInt(value.substr(4, 2), 10);
if (month > 40) {
year += 100;
month -= 40;
} else if (month > 20) {
year -= 100;
month -= 20;
}
if (!$.fn.bootstrapValidator.helpers.date(year, month, day)) {
return false;
}
var sum = 0,
weight = [2, 4, 8, 5, 10, 9, 7, 3, 6];
for (var i = 0; i < 9; i++) {
sum += parseInt(value.charAt(i), 10) * weight[i];
}
sum = (sum % 11) % 10;
return (sum + '' === value.substr(9, 1));
},
// Validate Bulgarian personal number of a foreigner
pnf = function(value) {
var sum = 0,
weight = [21, 19, 17, 13, 11, 9, 7, 3, 1];
for (var i = 0; i < 9; i++) {
sum += parseInt(value.charAt(i), 10) * weight[i];
}
sum = sum % 10;
return (sum + '' === value.substr(9, 1));
},
// Finally, consider it as a VAT number
vat = function(value) {
var sum = 0,
weight = [4, 3, 2, 7, 6, 5, 4, 3, 2];
for (var i = 0; i < 9; i++) {
sum += parseInt(value.charAt(i), 10) * weight[i];
}
sum = 11 - sum % 11;
if (sum === 10) {
return false;
}
if (sum === 11) {
sum = 0;
}
return (sum + '' === value.substr(9, 1));
};
return (egn(value) || pnf(value) || vat(value));
}
return false;
},
/**
* Validate Swiss VAT number
*
* @param {String} value VAT number
* @returns {Boolean}
*/
_ch: function(value) {
if (!/^CHE[0-9]{9}(MWST)?$/.test(value)) {
return false;
}
value = value.substr(3);
var sum = 0,
weight = [5, 4, 3, 2, 7, 6, 5, 4];
for (var i = 0; i < 8; i++) {
sum += parseInt(value.charAt(i), 10) * weight[i];
}
sum = 11 - sum % 11;
if (sum === 10) {
return false;
}
if (sum === 11) {
sum = 0;
}
return (sum + '' === value.substr(8, 1));
},
/**
* Validate Cypriot VAT number
* Examples:
* - Valid: CY10259033P
* - Invalid: CY10259033Z
*
* @param {String} value VAT number
* @returns {Boolean}
*/
_cy: function(value) {
if (!/^CY[0-5|9]{1}[0-9]{7}[A-Z]{1}$/.test(value)) {
return false;
}
value = value.substr(2);
// Do not allow to start with "12"
if (value.substr(0, 2) === '12') {
return false;
}
// Extract the next digit and multiply by the counter.
var sum = 0,
translation = {
'0': 1, '1': 0, '2': 5, '3': 7, '4': 9,
'5': 13, '6': 15, '7': 17, '8': 19, '9': 21
};
for (var i = 0; i < 8; i++) {
var temp = parseInt(value.charAt(i), 10);
if (i % 2 === 0) {
temp = translation[temp + ''];
}
sum += temp;
}
sum = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'[sum % 26];
return (sum + '' === value.substr(8, 1));
},
/**
* Validate Czech Republic VAT number
* Can be:
* i) Legal entities (8 digit numbers)
* ii) Individuals with a RC (the 9 or 10 digit Czech birth number)
* iii) Individuals without a RC (9 digit numbers beginning with 6)
*
* Examples:
* - Valid: i) CZ25123891; ii) CZ7103192745, CZ991231123; iii) CZ640903926
* - Invalid: i) CZ25123890; ii) CZ1103492745, CZ590312123
*
* @param {String} value VAT number
* @returns {Boolean}
*/
_cz: function(value) {
if (!/^CZ[0-9]{8,10}$/.test(value)) {
return false;
}
value = value.substr(2);
var sum = 0,
i = 0;
if (value.length === 8) {
// Do not allow to start with '9'
if (value.charAt(0) + '' === '9') {
return false;
}
sum = 0;
for (i = 0; i < 7; i++) {
sum += parseInt(value.charAt(i), 10) * (8 - i);
}
sum = 11 - sum % 11;
if (sum === 10) {
sum = 0;
}
if (sum === 11) {
sum = 1;
}
return (sum + '' === value.substr(7, 1));
} else if (value.length === 9 && (value.charAt(0) + '' === '6')) {
sum = 0;
// Skip the first (which is 6)
for (i = 0; i < 7; i++) {
sum += parseInt(value.charAt(i + 1), 10) * (8 - i);
}
sum = 11 - sum % 11;
if (sum === 10) {
sum = 0;
}
if (sum === 11) {
sum = 1;
}
sum = [8, 7, 6, 5, 4, 3, 2, 1, 0, 9, 10][sum - 1];
return (sum + '' === value.substr(8, 1));
} else if (value.length === 9 || value.length === 10) {
// Validate Czech birth number (Rodn slo), which is also national identifier
var year = 1900 + parseInt(value.substr(0, 2), 10),
month = parseInt(value.substr(2, 2), 10) % 50 % 20,
day = parseInt(value.substr(4, 2), 10);
if (value.length === 9) {
if (year >= 1980) {
year -= 100;
}
if (year > 1953) {
return false;
}
} else if (year < 1954) {
year += 100;
}
if (!$.fn.bootstrapValidator.helpers.date(year, month, day)) {
return false;
}
// Check that the birth date is not in the future
if (value.length === 10) {
var check = parseInt(value.substr(0, 9), 10) % 11;
if (year < 1985) {
check = check % 10;
}
return (check + '' === value.substr(9, 1));
}
return true;
}
return false;
},
/**
* Validate German VAT number
* Examples:
* - Valid: DE136695976
* - Invalid: DE136695978
*
* @param {String} value VAT number
* @returns {Boolean}
*/
_de: function(value) {
if (!/^DE[0-9]{9}$/.test(value)) {
return false;
}
value = value.substr(2);
return $.fn.bootstrapValidator.helpers.mod11And10(value);
},
/**
* Validate Danish VAT number
* Example:
* - Valid: DK13585628
* - Invalid: DK13585627
*
* @param {String} value VAT number
* @returns {Boolean}
*/
_dk: function(value) {
if (!/^DK[0-9]{8}$/.test(value)) {
return false;
}
value = value.substr(2);
var sum = 0,
weight = [2, 7, 6, 5, 4, 3, 2, 1];
for (var i = 0; i < 8; i++) {
sum += parseInt(value.charAt(i), 10) * weight[i];
}
return (sum % 11 === 0);
},
/**
* Validate Estonian VAT number
* Examples:
* - Valid: EE100931558, EE100594102
* - Invalid: EE100594103
*
* @param {String} value VAT number
* @returns {Boolean}
*/
_ee: function(value) {
if (!/^EE[0-9]{9}$/.test(value)) {
return false;
}
value = value.substr(2);
var sum = 0,
weight = [3, 7, 1, 3, 7, 1, 3, 7, 1];
for (var i = 0; i < 9; i++) {
sum += parseInt(value.charAt(i), 10) * weight[i];
}
return (sum % 10 === 0);
},
/**
* Validate Spanish VAT number (NIF - Nmero de Identificacin Fiscal)
* Can be:
* i) DNI (Documento nacional de identidad), for Spaniards
* ii) NIE (Nmero de Identificacin de Extranjeros), for foreigners
* iii) CIF (Certificado de Identificacin Fiscal), for legal entities and others
*
* Examples:
* - Valid: i) ES54362315K; ii) ESX2482300W, ESX5253868R; iii) ESM1234567L, ESJ99216582, ESB58378431, ESB64717838
* - Invalid: i) ES54362315Z; ii) ESX2482300A; iii) ESJ99216583
*
* @param {String} value VAT number
* @returns {Boolean}
*/
_es: function(value) {
if (!/^ES[0-9A-Z][0-9]{7}[0-9A-Z]$/.test(value)) {
return false;
}
value = value.substr(2);
var dni = function(value) {
var check = parseInt(value.substr(0, 8), 10);
check = 'TRWAGMYFPDXBNJZSQVHLCKE'[check % 23];
return (check + '' === value.substr(8, 1));
},
nie = function(value) {
var check = ['XYZ'.indexOf(value.charAt(0)), value.substr(1)].join('');
check = parseInt(check, 10);
check = 'TRWAGMYFPDXBNJZSQVHLCKE'[check % 23];
return (check + '' === value.substr(8, 1));
},
cif = function(value) {
var first = value.charAt(0), check;
if ('KLM'.indexOf(first) !== -1) {
// K: Spanish younger than 14 year old
// L: Spanish living outside Spain without DNI
// M: Granted the tax to foreigners who have no NIE
check = parseInt(value.substr(1, 8), 10);
check = 'TRWAGMYFPDXBNJZSQVHLCKE'[check % 23];
return (check + '' === value.substr(8, 1));
} else if ('ABCDEFGHJNPQRSUVW'.indexOf(first) !== -1) {
var sum = 0,
weight = [2, 1, 2, 1, 2, 1, 2],
temp = 0;
for (var i = 0; i < 7; i++) {
temp = parseInt(value.charAt(i + 1), 10) * weight[i];
if (temp > 9) {
temp = Math.floor(temp / 10) + temp % 10;
}
sum += temp;
}
sum = 10 - sum % 10;
return (sum + '' === value.substr(8, 1) || 'JABCDEFGHI'[sum] === value.substr(8, 1));
}
return false;
};
var first = value.charAt(0);
if (/^[0-9]$/.test(first)) {
return dni(value);
} else if (/^[XYZ]$/.test(first)) {
return nie(value);
} else {
return cif(value);
}
},
/**
* Validate Finnish VAT number
* Examples:
* - Valid: FI20774740
* - Invalid: FI20774741
*
* @param {String} value VAT number
* @returns {Boolean}
*/
_fi: function(value) {
if (!/^FI[0-9]{8}$/.test(value)) {
return false;
}
value = value.substr(2);
var sum = 0,
weight = [7, 9, 10, 5, 8, 4, 2, 1];
for (var i = 0; i < 8; i++) {
sum += parseInt(value.charAt(i), 10) * weight[i];
}
return (sum % 11 === 0);
},
/**
* Validate French VAT number (TVA - taxe sur la valeur ajoute)
* It's constructed by a SIREN number, prefixed by two characters.
*
* Examples:
* - Valid: FR40303265045, FR23334175221, FRK7399859412, FR4Z123456782
* - Invalid: FR84323140391
*
* @param {String} value VAT number
* @returns {Boolean}
*/
_fr: function(value) {
if (!/^FR[0-9A-Z]{2}[0-9]{9}$/.test(value)) {
return false;
}
value = value.substr(2);
if (!$.fn.bootstrapValidator.helpers.luhn(value.substr(2))) {
return false;
}
if (/^[0-9]{2}$/.test(value.substr(0, 2))) {
// First two characters are digits
return value.substr(0, 2) === (parseInt(value.substr(2) + '12', 10) % 97 + '');
} else {
// The first characters cann't be O and I
var alphabet = '0123456789ABCDEFGHJKLMNPQRSTUVWXYZ',
check;
// First one is digit
if (/^[0-9]{1}$/.test(value.charAt(0))) {
check = alphabet.indexOf(value.charAt(0)) * 24 + alphabet.indexOf(value.charAt(1)) - 10;
} else {
check = alphabet.indexOf(value.charAt(0)) * 34 + alphabet.indexOf(value.charAt(1)) - 100;
}
return ((parseInt(value.substr(2), 10) + 1 + Math.floor(check / 11)) % 11) === (check % 11);
}
},
/**
* Validate United Kingdom VAT number
* Example:
* - Valid: GB980780684
* - Invalid: GB802311781
*
* @param {String} value VAT number
* @returns {Boolean}
*/
_gb: function(value) {
if (!/^GB[0-9]{9}$/.test(value) /* Standard */
&& !/^GB[0-9]{12}$/.test(value) /* Branches */
&& !/^GBGD[0-9]{3}$/.test(value) /* Government department */
&& !/^GBHA[0-9]{3}$/.test(value) /* Health authority */
&& !/^GB(GD|HA)8888[0-9]{5}$/.test(value))
{
return false;
}
value = value.substr(2);
var length = value.length;
if (length === 5) {
var firstTwo = value.substr(0, 2),
lastThree = parseInt(value.substr(2), 10);
return ('GD' === firstTwo && lastThree < 500) || ('HA' === firstTwo && lastThree >= 500);
} else if (length === 11 && ('GD8888' === value.substr(0, 6) || 'HA8888' === value.substr(0, 6))) {
if (('GD' === value.substr(0, 2) && parseInt(value.substr(6, 3), 10) >= 500)
|| ('HA' === value.substr(0, 2) && parseInt(value.substr(6, 3), 10) < 500))
{
return false;
}
return (parseInt(value.substr(6, 3), 10) % 97 === parseInt(value.substr(9, 2), 10));
} else if (length === 9 || length === 12) {
var sum = 0,
weight = [8, 7, 6, 5, 4, 3, 2, 10, 1];
for (var i = 0; i < 9; i++) {
sum += parseInt(value.charAt(i), 10) * weight[i];
}
sum = sum % 97;
if (parseInt(value.substr(0, 3), 10) >= 100) {
return (sum === 0 || sum === 42 || sum === 55);
} else {
return (sum === 0);
}
}
return true;
},
/**
* Validate Greek VAT number
* Examples:
* - Valid: GR023456780, EL094259216
* - Invalid: EL123456781
*
* @param {String} value VAT number
* @returns {Boolean}
*/
_gr: function(value) {
if (!/^GR[0-9]{9}$/.test(value)) {
return false;
}
value = value.substr(2);
if (value.length === 8) {
value = '0' + value;
}
var sum = 0,
weight = [256, 128, 64, 32, 16, 8, 4, 2];
for (var i = 0; i < 8; i++) {
sum += parseInt(value.charAt(i), 10) * weight[i];
}
sum = (sum % 11) % 10;
return (sum + '' === value.substr(8, 1));
},
// EL is traditionally prefix of Greek VAT numbers
_el: function(value) {
if (!/^EL[0-9]{9}$/.test(value)) {
return false;
}
value = 'GR' + value.substr(2);
return this._gr(value);
},
/**
* Validate Hungarian VAT number
* Examples:
* - Valid: HU12892312
* - Invalid: HU12892313
*
* @param {String} value VAT number
* @returns {Boolean}
*/
_hu: function(value) {
if (!/^HU[0-9]{8}$/.test(value)) {
return false;
}
value = value.substr(2);
var sum = 0,
weight = [9, 7, 3, 1, 9, 7, 3, 1];
for (var i = 0; i < 8; i++) {
sum += parseInt(value.charAt(i), 10) * weight[i];
}
return (sum % 10 === 0);
},
/**
* Validate Croatian VAT number
* Examples:
* - Valid: HR33392005961
* - Invalid: HR33392005962
*
* @param {String} value VAT number
* @returns {Boolean}
*/
_hr: function(value) {
if (!/^HR[0-9]{11}$/.test(value)) {
return false;
}
value = value.substr(2);
return $.fn.bootstrapValidator.helpers.mod11And10(value);
},
/**
* Validate Irish VAT number
* Examples:
* - Valid: IE6433435F, IE6433435OA, IE8D79739I
* - Invalid: IE8D79738J
*
* @param {String} value VAT number
* @returns {Boolean}
*/
_ie: function(value) {
if (!/^IE[0-9]{1}[0-9A-Z\*\+]{1}[0-9]{5}[A-Z]{1,2}$/.test(value)) {
return false;
}
value = value.substr(2);
var getCheckDigit = function(value) {
while (value.length < 7) {
value = '0' + value;
}
var alphabet = 'WABCDEFGHIJKLMNOPQRSTUV',
sum = 0;
for (var i = 0; i < 7; i++) {
sum += parseInt(value.charAt(i), 10) * (8 - i);
}
sum += 9 * alphabet.indexOf(value.substr(7));
return alphabet[sum % 23];
};
// The first 7 characters are digits
if (/^[0-9]+$/.test(value.substr(0, 7))) {
// New system
return value.charAt(7) === getCheckDigit(value.substr(0, 7) + value.substr(8) + '');
} else if ('ABCDEFGHIJKLMNOPQRSTUVWXYZ+*'.indexOf(value.charAt(1)) !== -1) {
// Old system
return value.charAt(7) === getCheckDigit(value.substr(2, 5) + value.substr(0, 1) + '');
}
return true;
},
/**
* Validate Italian VAT number, which consists of 11 digits.
* - First 7 digits are a company identifier
* - Next 3 are the province of residence
* - The last one is a check digit
*
* Examples:
* - Valid: IT00743110157
* - Invalid: IT00743110158
*
* @param {String} value VAT number
* @returns {Boolean}
*/
_it: function(value) {
if (!/^IT[0-9]{11}$/.test(value)) {
return false;
}
value = value.substr(2);
if (parseInt(value.substr(0, 7), 10) === 0) {
return false;
}
var lastThree = parseInt(value.substr(7, 3), 10);
if ((lastThree < 1) || (lastThree > 201) && lastThree !== 999 && lastThree !== 888) {
return false;
}
return $.fn.bootstrapValidator.helpers.luhn(value);
},
/**
* Validate Lithuanian VAT number
* It can be:
* - 9 digits, for legal entities
* - 12 digits, for temporarily registered taxpayers
*
* Examples:
* - Valid: LT119511515, LT100001919017, LT100004801610
* - Invalid: LT100001919018
*
* @param {String} value VAT number
* @returns {Boolean}
*/
_lt: function(value) {
if (!/^LT([0-9]{7}1[0-9]{1}|[0-9]{10}1[0-9]{1})$/.test(value)) {
return false;
}
value = value.substr(2);
var length = value.length,
sum = 0,
i;
for (i = 0; i < length - 1; i++) {
sum += parseInt(value.charAt(i), 10) * (1 + i % 9);
}
var check = sum % 11;
if (check === 10) {
sum = 0;
for (i = 0; i < length - 1; i++) {
sum += parseInt(value.charAt(i), 10) * (1 + (i + 2) % 9);
}
}
check = check % 11 % 10;
return (check + '' === value.charAt(length - 1));
},
/**
* Validate Luxembourg VAT number
* Examples:
* - Valid: LU15027442
* - Invalid: LU15027443
*
* @param {String} value VAT number
* @returns {Boolean}
*/
_lu: function(value) {
if (!/^LU[0-9]{8}$/.test(value)) {
return false;
}
value = value.substr(2);
return ((parseInt(value.substr(0, 6), 10) % 89) + '' === value.substr(6, 2));
},
/**
* Validate Latvian VAT number
* Examples:
* - Valid: LV40003521600, LV16117519997
* - Invalid: LV40003521601, LV16137519997
*
* @param {String} value VAT number
* @returns {Boolean}
*/
_lv: function(value) {
if (!/^LV[0-9]{11}$/.test(value)) {
return false;
}
value = value.substr(2);
var first = parseInt(value.charAt(0), 10),
sum = 0,
weight = [],
i,
length = value.length;
if (first > 3) {
// Legal entity
sum = 0;
weight = [9, 1, 4, 8, 3, 10, 2, 5, 7, 6, 1];
for (i = 0; i < length; i++) {
sum += parseInt(value.charAt(i), 10) * weight[i];
}
sum = sum % 11;
return (sum === 3);
} else {
// Check birth date
var day = parseInt(value.substr(0, 2), 10),
month = parseInt(value.substr(2, 2), 10),
year = parseInt(value.substr(4, 2), 10);
year = year + 1800 + parseInt(value.charAt(6), 10) * 100;
if (!$.fn.bootstrapValidator.helpers.date(year, month, day)) {
return false;
}
// Check personal code
sum = 0;
weight = [10, 5, 8, 4, 2, 1, 6, 3, 7, 9];
for (i = 0; i < length - 1; i++) {
sum += parseInt(value.charAt(i), 10) * weight[i];
}
sum = (sum + 1) % 11 % 10;
return (sum + '' === value.charAt(length - 1));
}
},
/**
* Validate Maltese VAT number
* Examples:
* - Valid: MT11679112
* - Invalid: MT11679113
*
* @param {String} value VAT number
* @returns {Boolean}
*/
_mt: function(value) {
if (!/^MT[0-9]{8}$/.test(value)) {
return false;
}
value = value.substr(2);
var sum = 0,
weight = [3, 4, 6, 7, 8, 9, 10, 1];
for (var i = 0; i < 8; i++) {
sum += parseInt(value.charAt(i), 10) * weight[i];
}
return (sum % 37 === 0);
},
/**
* Validate Dutch VAT number
* Examples:
* - Valid: NL004495445B01
* - Invalid: NL123456789B90
*
* @param {String} value VAT number
* @returns {Boolean}
*/
_nl: function(value) {
if (!/^NL[0-9]{9}B[0-9]{2}$/.test(value)) {
return false;
}
value = value.substr(2);
var sum = 0,
weight = [9, 8, 7, 6, 5, 4, 3, 2];
for (var i = 0; i < 8; i++) {
sum += parseInt(value.charAt(i), 10) * weight[i];
}
sum = sum % 11;
if (sum > 9) {
sum = 0;
}
return (sum + '' === value.substr(8, 1));
},
/**
* Validate Norwegian VAT number
*
* @see path_to_url
* @param {String} value VAT number
* @returns {Boolean}
*/
_no: function(value) {
if (!/^NO[0-9]{9}$/.test(value)) {
return false;
}
value = value.substr(2);
var sum = 0,
weight = [3, 2, 7, 6, 5, 4, 3, 2];
for (var i = 0; i < 8; i++) {
sum += parseInt(value.charAt(i), 10) * weight[i];
}
sum = 11 - sum % 11;
if (sum === 11) {
sum = 0;
}
return (sum + '' === value.substr(8, 1));
},
/**
* Validate Polish VAT number
* Examples:
* - Valid: PL8567346215
* - Invalid: PL8567346216
*
* @param {String} value VAT number
* @returns {Boolean}
*/
_pl: function(value) {
if (!/^PL[0-9]{10}$/.test(value)) {
return false;
}
value = value.substr(2);
var sum = 0,
weight = [6, 5, 7, 2, 3, 4, 5, 6, 7, -1];
for (var i = 0; i < 10; i++) {
sum += parseInt(value.charAt(i), 10) * weight[i];
}
return (sum % 11 === 0);
},
/**
* Validate Portuguese VAT number
* Examples:
* - Valid: PT501964843
* - Invalid: PT501964842
*
* @param {String} value VAT number
* @returns {Boolean}
*/
_pt: function(value) {
if (!/^PT[0-9]{9}$/.test(value)) {
return false;
}
value = value.substr(2);
var sum = 0,
weight = [9, 8, 7, 6, 5, 4, 3, 2];
for (var i = 0; i < 8; i++) {
sum += parseInt(value.charAt(i), 10) * weight[i];
}
sum = 11 - sum % 11;
if (sum > 9) {
sum = 0;
}
return (sum + '' === value.substr(8, 1));
},
/**
* Validate Romanian VAT number
* Examples:
* - Valid: RO18547290
* - Invalid: RO18547291
*
* @param {String} value VAT number
* @returns {Boolean}
*/
_ro: function(value) {
if (!/^RO[1-9][0-9]{1,9}$/.test(value)) {
return false;
}
value = value.substr(2);
var length = value.length,
weight = [7, 5, 3, 2, 1, 7, 5, 3, 2].slice(10 - length),
sum = 0;
for (var i = 0; i < length - 1; i++) {
sum += parseInt(value.charAt(i), 10) * weight[i];
}
sum = (10 * sum) % 11 % 10;
return (sum + '' === value.substr(length - 1, 1));
},
/**
* Validate Russian VAT number (Taxpayer Identification Number - INN)
*
* @param {String} value VAT number
* @returns {Boolean}
*/
_ru: function(value) {
if (!/^RU([0-9]{9}|[0-9]{12})$/.test(value)) {
return false;
}
value = value.substr(2);
var i = 0;
if (value.length === 10) {
var sum = 0,
weight = [2, 4, 10, 3, 5, 9, 4, 6, 8, 0];
for (i = 0; i < 10; i++) {
sum += parseInt(value.charAt(i), 10) * weight[i];
}
sum = sum % 11;
if (sum > 9) {
sum = sum % 10;
}
return (sum + '' === value.substr(9, 1));
} else if (value.length === 12) {
var sum1 = 0,
weight1 = [7, 2, 4, 10, 3, 5, 9, 4, 6, 8, 0],
sum2 = 0,
weight2 = [3, 7, 2, 4, 10, 3, 5, 9, 4, 6, 8, 0];
for (i = 0; i < 11; i++) {
sum1 += parseInt(value.charAt(i), 10) * weight1[i];
sum2 += parseInt(value.charAt(i), 10) * weight2[i];
}
sum1 = sum1 % 11;
if (sum1 > 9) {
sum1 = sum1 % 10;
}
sum2 = sum2 % 11;
if (sum2 > 9) {
sum2 = sum2 % 10;
}
return (sum1 + '' === value.substr(10, 1) && sum2 + '' === value.substr(11, 1));
}
return false;
},
/**
* Validate Serbian VAT number
*
* @param {String} value VAT number
* @returns {Boolean}
*/
_rs: function(value) {
if (!/^RS[0-9]{9}$/.test(value)) {
return false;
}
value = value.substr(2);
var sum = 10,
temp = 0;
for (var i = 0; i < 8; i++) {
temp = (parseInt(value.charAt(i), 10) + sum) % 10;
if (temp === 0) {
temp = 10;
}
sum = (2 * temp) % 11;
}
return ((sum + parseInt(value.substr(8, 1), 10)) % 10 === 1);
},
/**
* Validate Swedish VAT number
* Examples:
* - Valid: SE123456789701
* - Invalid: SE123456789101
*
* @param {String} value VAT number
* @returns {Boolean}
*/
_se: function(value) {
if (!/^SE[0-9]{10}01$/.test(value)) {
return false;
}
value = value.substr(2, 10);
return $.fn.bootstrapValidator.helpers.luhn(value);
},
/**
* Validate Slovenian VAT number
* Examples:
* - Valid: SI50223054
* - Invalid: SI50223055
*
* @param {String} value VAT number
* @returns {Boolean}
*/
_si: function(value) {
if (!/^SI[0-9]{8}$/.test(value)) {
return false;
}
value = value.substr(2);
var sum = 0,
weight = [8, 7, 6, 5, 4, 3, 2];
for (var i = 0; i < 7; i++) {
sum += parseInt(value.charAt(i), 10) * weight[i];
}
sum = 11 - sum % 11;
if (sum === 10) {
sum = 0;
}
return (sum + '' === value.substr(7, 1));
},
/**
* Validate Slovak VAT number
* Examples:
* - Valid: SK2022749619
* - Invalid: SK2022749618
*
* @param {String} value VAT number
* @returns {Boolean}
*/
_sk: function(value) {
if (!/^SK[1-9][0-9][(2-4)|(6-9)][0-9]{7}$/.test(value)) {
return false;
}
return (parseInt(value.substr(2), 10) % 11 === 0);
}
};
}(window.jQuery));
;(function($) {
$.fn.bootstrapValidator.i18n.vin = $.extend($.fn.bootstrapValidator.i18n.vin || {}, {
'default': 'Please enter a valid VIN number'
});
$.fn.bootstrapValidator.validators.vin = {
/**
* Validate an US VIN (Vehicle Identification Number)
*
* @param {BootstrapValidator} validator The validator plugin instance
* @param {jQuery} $field Field element
* @param {Object} options Consist of key:
* - message: The invalid message
* @returns {Boolean}
*/
validate: function(validator, $field, options) {
var value = $field.val();
if (value === '') {
return true;
}
// Don't accept I, O, Q characters
if (!/^[a-hj-npr-z0-9]{8}[0-9xX][a-hj-npr-z0-9]{8}$/i.test(value)) {
return false;
}
value = value.toUpperCase();
var chars = {
A: 1, B: 2, C: 3, D: 4, E: 5, F: 6, G: 7, H: 8,
J: 1, K: 2, L: 3, M: 4, N: 5, P: 7, R: 9,
S: 2, T: 3, U: 4, V: 5, W: 6, X: 7, Y: 8, Z: 9,
'1': 1, '2': 2, '3': 3, '4': 4, '5': 5, '6': 6, '7': 7, '8': 8, '9': 9, '0': 0
},
weights = [8, 7, 6, 5, 4, 3, 2, 10, 0, 9, 8, 7, 6, 5, 4, 3, 2],
sum = 0,
length = value.length;
for (var i = 0; i < length; i++) {
sum += chars[value.charAt(i) + ''] * weights[i];
}
var reminder = sum % 11;
if (reminder === 10) {
reminder = 'X';
}
return (reminder + '') === value.charAt(8);
}
};
}(window.jQuery));
;(function($) {
$.fn.bootstrapValidator.i18n.zipCode = $.extend($.fn.bootstrapValidator.i18n.zipCode || {}, {
'default': 'Please enter a valid zip code',
countryNotSupported: 'The country code %s is not supported',
country: 'Please enter a valid %s',
countries: {
CA: 'Canadian postal code',
DK: 'Danish postal code',
GB: 'United Kingdom postal code',
IT: 'Italian postal code',
NL: 'Dutch postal code',
SE: 'Swiss postal code',
SG: 'Singapore postal code',
US: 'US zip code'
}
});
$.fn.bootstrapValidator.validators.zipCode = {
html5Attributes: {
message: 'message',
country: 'country'
},
COUNTRY_CODES: ['CA', 'DK', 'GB', 'IT', 'NL', 'SE', 'SG', 'US'],
/**
* Return true if and only if the input value is a valid country zip code
*
* @param {BootstrapValidator} validator The validator plugin instance
* @param {jQuery} $field Field element
* @param {Object} options Consist of key:
* - message: The invalid message
* - country: The country
*
* The country can be defined by:
* - An ISO 3166 country code
* Currently it supports the following countries:
* - US (United States)
* - CA (Canada)
* - DK (Denmark)
* - GB (United Kingdom)
* - IT (Italy)
* - NL (Netherlands)
* - SE (Sweden)
* - SG (Singapore)
*
* - Name of field which its value defines the country code
* - Name of callback function that returns the country code
* - A callback function that returns the country code
*
* callback: function(value, validator, $field) {
* // value is the value of field
* // validator is the BootstrapValidator instance
* // $field is jQuery element representing the field
* }
*
* @returns {Boolean|Object}
*/
validate: function(validator, $field, options) {
var value = $field.val();
if (value === '' || !options.country) {
return true;
}
var country = options.country;
if (typeof country !== 'string' || $.inArray(country, this.COUNTRY_CODES) === -1) {
// Try to determine the country
country = validator.getDynamicOption($field, country);
}
if (!country || $.inArray(country.toUpperCase(), this.COUNTRY_CODES) === -1) {
return { valid: false, message: $.fn.bootstrapValidator.helpers.format($.fn.bootstrapValidator.i18n.zipCode.countryNotSupported, country) };
}
var isValid = false;
country = country.toUpperCase();
switch (country) {
case 'CA':
isValid = /^(?:A|B|C|E|G|H|J|K|L|M|N|P|R|S|T|V|X|Y){1}[0-9]{1}(?:A|B|C|E|G|H|J|K|L|M|N|P|R|S|T|V|W|X|Y|Z){1}\s?[0-9]{1}(?:A|B|C|E|G|H|J|K|L|M|N|P|R|S|T|V|W|X|Y|Z){1}[0-9]{1}$/i.test(value);
break;
case 'DK':
isValid = /^(DK(-|\s)?)?\d{4}$/i.test(value);
break;
case 'GB':
isValid = this._gb(value);
break;
// path_to_url
case 'IT':
isValid = /^(I-|IT-)?\d{5}$/i.test(value);
break;
// path_to_url
case 'NL':
isValid = /^[1-9][0-9]{3} ?(?!sa|sd|ss)[a-z]{2}$/i.test(value);
break;
case 'SE':
isValid = /^(S-)?\d{3}\s?\d{2}$/i.test(value);
break;
case 'SG':
isValid = /^([0][1-9]|[1-6][0-9]|[7]([0-3]|[5-9])|[8][0-2])(\d{4})$/i.test(value);
break;
case 'US':
/* falls through */
default:
isValid = /^\d{4,5}([\-]?\d{4})?$/.test(value);
break;
}
return {
valid: isValid,
message: $.fn.bootstrapValidator.helpers.format(options.message || $.fn.bootstrapValidator.i18n.zipCode.country, $.fn.bootstrapValidator.i18n.zipCode.countries[country])
};
},
/**
* Validate United Kingdom postcode
* Examples:
* - Standard: EC1A 1BB, W1A 1HQ, M1 1AA, B33 8TH, CR2 6XH, DN55 1PT
* - Special cases:
* AI-2640, ASCN 1ZZ, GIR 0AA
*
* @see path_to_url
* @param {String} value The postcode
* @returns {Boolean}
*/
_gb: function(value) {
var firstChar = '[ABCDEFGHIJKLMNOPRSTUWYZ]', // Does not accept QVX
secondChar = '[ABCDEFGHKLMNOPQRSTUVWXY]', // Does not accept IJZ
thirdChar = '[ABCDEFGHJKPMNRSTUVWXY]',
fourthChar = '[ABEHMNPRVWXY]',
fifthChar = '[ABDEFGHJLNPQRSTUWXYZ]',
regexps = [
// AN NAA, ANN NAA, AAN NAA, AANN NAA format
new RegExp('^(' + firstChar + '{1}' + secondChar + '?[0-9]{1,2})(\\s*)([0-9]{1}' + fifthChar + '{2})$', 'i'),
// ANA NAA
new RegExp('^(' + firstChar + '{1}[0-9]{1}' + thirdChar + '{1})(\\s*)([0-9]{1}' + fifthChar + '{2})$', 'i'),
// AANA NAA
new RegExp('^(' + firstChar + '{1}' + secondChar + '{1}?[0-9]{1}' + fourthChar + '{1})(\\s*)([0-9]{1}' + fifthChar + '{2})$', 'i'),
new RegExp('^(BF1)(\\s*)([0-6]{1}[ABDEFGHJLNPQRST]{1}[ABDEFGHJLNPQRSTUWZYZ]{1})$', 'i'), // BFPO postcodes
/^(GIR)(\s*)(0AA)$/i, // Special postcode GIR 0AA
/^(BFPO)(\s*)([0-9]{1,4})$/i, // Standard BFPO numbers
/^(BFPO)(\s*)(c\/o\s*[0-9]{1,3})$/i, // c/o BFPO numbers
/^([A-Z]{4})(\s*)(1ZZ)$/i, // Overseas Territories
/^(AI-2640)$/i // Anguilla
];
for (var i = 0; i < regexps.length; i++) {
if (regexps[i].test(value)) {
return true;
}
}
return false;
}
};
}(window.jQuery));
```
|
Herschel Greer Stadium was a Minor League Baseball park in Nashville, Tennessee, on the grounds of Fort Negley, an American Civil War fortification, approximately south of the city's downtown district. The facility closed at the end of the 2014 baseball season and remained deserted for over four years until its demolition in 2019. Following an archaeological survey, the land is expected to be reincorporated into Fort Negley Park.
Greer was opened in 1978 for the Nashville Sounds, an expansion franchise of the Double-A Southern League who moved to the Triple-A American Association in 1985 and to the Triple-A Pacific Coast League in 1998. The stadium played host to the team until 2014. The subject of numerous upgrades and repairs to maintain its functionality, Greer became one of the oldest stadiums used by a Triple-A team and had fallen well below professional baseball's standards for a stadium at that class level by the end of its use. For over a decade, the Sounds attempted to secure agreements with the Metropolitan Government of Nashville and Davidson County for a new ballpark to replace Greer, eventually resulting in the construction of First Tennessee Park, which became the Sounds' new home in 2015.
Amidst the Sounds' 37-season run, Greer simultaneously hosted two professional baseball clubs in 1993 and 1994, acting as a temporary home to a displaced Southern League franchise known during that period as the Nashville Xpress. The stadium also saw occasional use as a venue for college baseball, high school football, and charity softball events. It was the site of three minor league all-star games, eight no-hitters, including one perfect game, and a 24-inning game which tied the record for the longest game in Pacific Coast League history. The stadium was best recognized by its distinctive guitar-shaped scoreboard.
History
Planning and construction (1976–1978)
Larry Schmittou, the leader of an effort to bring professional baseball back to Nashville in the late 1970s, knew he would need to build a new ballpark as the city's previous ballpark, Sulphur Dell, had been demolished in 1969. He learned from a member of the Metro Board of Parks and Recreation that neither the Parks Board nor the city of Nashville would be willing to pay for such a park. So, Schmittou, along with help from country musician Conway Twitty, put together a group of investors including other country artists Cal Smith and Jerry Reed, as well as other Nashvillians, to finance a stadium and a minor league team. The Metro Parks Board agreed to lease to Schmittou a plot of land at the foot of St. Cloud Hill on the grounds of Fort Negley, an American Civil War fortification, approximately south of downtown, for a period of 20 years as long as he built a stadium with a minimum capacity of 6,500 at a cost of at least US$400,000 within 10 years. The city would also relocate the city-owned softball complex that occupied the site. Schmittou would be responsible for building the stadium, paying the property taxes, and paying the city seven percent of the team's total revenue in the second ten years.
Stoll-Reed Architects advised Schmittou that construction of a suitable stadium would cost between $300,000 and $500,000, but bids for the project ranged from $980,000 to $1.2 million. Schmittou looked to local suppliers to donate construction materials, took out a $30,000 loan from a bank, sold season tickets in advance of having a team, and even mortgaged his own home to help pay for the facility. The actual cost totaled $1.5 million. The stadium was posthumously named for Herschel Lynn Greer, a prominent Nashville businessman and the first president of Vols, Inc., an attempt to keep Nashville's previous minor league baseball team, the Nashville Vols, alive as a fan-owned enterprise, and whose family donated $25,000 for stadium construction.
The home opener for Greer's first tenants, the Southern League's Nashville Sounds, the Double-A affiliate of the Cincinnati Reds, was scheduled for April 25, 1978. Construction was underway, but Schmittou knew the ballpark would not be ready by that date. The team requested to open the season with road games and had to swap a series with the Chattanooga Lookouts in order to have more time to complete the stadium. Even with this extra time, the ballpark was still behind schedule. Much of the sod that been laid that winter died. By the time the replacement grass had arrived, the crew hired to lay the sod had left. General Manager Farrell Owens organized a volunteer crew to lay the sod by calling a local radio station to announce the team was having a "sod party". A group of approximately 50 people came out to lay and roll the sod the day before the scheduled opening game.
Opening season (1978)
The scheduled April 25 Greer home opener was rained out and pushed back to the evening of April 26. After playing their first ten games away from home, and with tractors and grading machines still preparing the field on game day, the Sounds played their first home game on April 26, 1978. The 12–4 victory against the Savannah Braves was witnessed by a sellout crowd of 8,156 spectators. Southern League president Billy Hitchcock was on hand to witness the event, and Conway Twitty threw out the first pitch. On the field, Sounds catcher Joe Griffin led the 16-hit Nashville offense with 4 hits and 5 runs batted in (RBI) while starting pitcher Bruce Berenyi got the win and closer Doug Corbett earned a save.
Though the stadium was opened on time, the late sod was not the only issue on Opening Day. The electricity was turned on only five minutes before the gates opened. Only two women's restrooms and one men's restroom were functioning, though a few portable toilets were also available. The stadium's seats, which had previously been used in Atlanta's Fulton County Stadium, arrived just in time for installation. Construction of the backstop was still being completed on Opening Day. Players for both the Sounds and the visiting Braves had concerns about the safety of playing on the quickly installed infield, initially refusing to play on the surface. Left fielders complained about the extra-steep slope in left field that prevented them from seeing home plate. The outfield grass was taken up and the soil regraded to alleviate this problem while the Sounds were away on an eight-day road trip.
Initially, Greer was capable of seating 7,200 spectators, but was expanded to 8,800 by the end of the inaugural season. Theater-type seats with back support and armrests accounted for 3,000 of the stadium's seats; bleacher seats made up the remainder. The press box included two radio broadcast booths and an organ booth. There were locker rooms for two teams, which each accommodated 25 people, as well as a locker room for umpires. The field measured down the left and right field lines, to left- and right-center fields, and to center field. The home team occupied the third base dugout, and visitors occupied the first base dugout, with each team's bullpen located in foul territory in the outfield corners. Eight lighting grids atop steel poles high provided illumination for night games. Amenities for customers at the park included two men's and women's restrooms and seven concession stands.
Expansion (1979–1989)
With the addition of 5,000 permanent seats, Greer's seating capacity was increased to 13,000 for the 1979 season. Improvements to the playing field included new irrigation and drainage systems which raised the field above its previous elevation. Nashville set the Southern League season attendance record in 1980 when a total of 575,676 fans attended games at the facility.
Prior to the 1981 season, Greer underwent a number of renovations including the addition of over 1,200 box seats and over 1,000 new general admission seats. Two wooden general admission seating areas were replaced by 2,000 contoured seats. The original backstop, which consisted of several steel poles, was upgraded to a steel cable system, eliminating most of the poles. Other stadium upgrades included two new dugouts, three entrance and exit ramps, a new sound system, doubling the size of the reader panel on the scoreboard, and enlarging the ticket booth. The ballpark's all-time attendance record, also a team and Southern League record, was set on August 18, 1982, when 22,315 people watched the Sounds defeat the Columbus Astros, 3–0. Portions of the outfield had to be roped off to accommodate the crowd, which was far in excess of Greer's seating capacity.
From February through mid-summer 1984, major renovations and additions were made to the facility. A full-service restaurant, The Hall of Fame Stadium Club, and a mini-roof, to cover the last five rows of the reserved seating section and the main concourse, were built. A new press box included accommodations for additional members of the media, two separate booths for home and visiting radio broadcasts, and two separate booths for home and visiting television broadcasts. Ten sky boxes were built adjacent the press box; by 1989, the number of sky boxes had increased to 18.
In July 1984, Schmittou purchased the Triple-A Evansville Triplets of the American Association. The team moved from Evansville to Nashville for the 1985 season, upon which the Triplets' legacy was retired and the franchise adopted the Sounds' name and history, effectively elevating the organization from Double-A to Triple-A. The Double-A Southern League franchise was moved to Huntsville, Alabama, where the team began play as the Huntsville Stars at the hastily constructed Joe W. Davis Stadium.
To prepare for the move to Triple-A, renovations continued prior to the 1985 season with the addition of 1,200 box seats, which replaced some of the reserved grandstand seating, as well as more seating past the right field foul pole. A 4-line scoreboard high replaced the stadium's original, which was relocated to far left field to serve as an out-of-town scoreboard, providing scores for American League, National League, and other American Association baseball games.
Schmittou's desire to land a Triple-A team was part of a larger plan to put Nashville in a position to contend for a Major League Baseball franchise in the future. Along with this goal, the need for more seating, and a desire to make Greer a more attractive ballpark, significant renovations began after the 1987 season. The number of box seats was increased by 40 percent, the clubhouse and umpire facilities were upgraded, and the dugouts were entirely rebuilt. The new dugouts took up slightly more room than the previous ones, resulting in a minor contraction of the field's dimensions: down the left and right field lines, to left and right-center fields, and to center field. The main concourse entrance was redesigned to incorporate the stonemasonry of the adjacent Fort Negley. This expansion brought Greer's total seating capacity up to 18,000.
Renovations and reductions (1990–1999)
In 1990, Major League Baseball (MLB) team owners met to demand that minor league owners improve their ballparks in order to meet their desired standards. Greer had already fallen behind other parks when it came to the quality of the field and clubhouse, and it also lacked a weight room and batting cages. Following a failed bid to secure an MLB team for Nashville in the 1993 expansion process (Nashville was one of ten cities considered, but was eliminated from contention very early in the process; the two new franchises were eventually awarded to Denver and Miami), Schmittou focused on scaling-back his proposed MLB stadium into a new Triple-A facility for the Sounds. At a time when other Triple-A cities were building new, relatively luxurious ballparks, Schmittou was unable to convince Mayor Phil Bredesen or the Metro Council to pay for such a new park. He considered moving the team to a surrounding county, and explored sites in La Vergne, Cool Springs, and Mount Juliet. He even tried, unsuccessfully, to get the Metro Council to pass a referendum to let taxpayers vote on a temporary tax increase to pay off a proposed $40-million stadium in three years. In the end, Schmittou elected to keep the Sounds at Greer but make significant improvements to the stadium.
Greer's distinctive guitar-shaped scoreboard, made by the Fair-Play company, was installed behind the left-center field wall prior to the 1993 season. Another addition in 1993 was that of a second team to play at Greer. From 1993 to 1994, the ballpark simultaneously served as the home field for the Sounds and the Nashville Xpress, the Double-A Southern League affiliate of the Minnesota Twins. This came about when Charlotte, North Carolina, acquired a Triple-A expansion franchise in 1993, leaving the city's Double-A team, the Charlotte Knights, without a home. Schmittou offered Greer Stadium as a temporary home for the team. In order to accommodate another club at Greer, the Xpress' home games were scheduled for during the Sounds' road trips.
The Xpress played their first home game at Greer on April 16, 1993, against the Orlando Cubs. Pitchers Todd Ritchie, Mike Misuraca, and Jason Klonoski limited Cubs hitters to five hits and no runs in the 4–0 shutout. Nashville scored the winning run in the second inning when Brian Raabe doubled bringing home David Rivera and Rich Becker. The game was attended by 1,715 people on a cold night. In April 1994, Michael Jordan's foray into professional baseball attracted 16,842 fans to Greer to see the Xpress face his team, the Birmingham Barons, for the first time that season. The Nashville Xpress played their last home game on September 1, 1994, against the Huntsville Stars. With Nashville holding a 1–0 lead going into the eighth inning, Huntsville scored three runs in both the eighth and ninth innings on the way to a 6–2 defeat of the home team. In 1995, the Xpress relocated to Wilmington, North Carolina, and became the Port City Roosters.
Over $200,000 was spent on renovations in the fall and winter before the 1995 season. The home clubhouse and weight room were remodeled, aisles behind the dugouts were resurfaced to reduce slippery areas, and the entire playing field was re-sodded. This was the first replacement and upgrading of the field since the original sod was laid in 1978. First, all of the old grass was stripped from the field. Then, the grounds crew installed a new drainage system. Four trenches were dug and laid with of drainage pipe to carry water away from the field and beyond the center field wall. A layer of gravel was laid over the pipe, and a 4-to-6-inch (10 to 15 cm) layer of sand was placed above the gravel. After raising the level of the infield dirt and brick warning track to the same height of the new field, of Tifton 419 Bermuda Grass was installed on the field and edged into a baseball diamond configuration.
With Greer Stadium still falling below Triple-A standards, Schmittou proposed dropping the Sounds back to Double-A in 1996 via a trade with the Southern League's Memphis Chicks. The Chicago White Sox, the Sounds' major league affiliate, did not see Memphis' Tim McCarver Stadium as an improvement over Greer and convinced Schmittou to delay the swap by at least a year. Schmittou instead made $400,000 worth of renovations before the 1996 season to keep it a viable location for a Triple-A team through 1997. These improvements included a new visitors' clubhouse, new seats, and a security fence surrounding the entire ballpark.
The 1996 season marked the last that Schmittou was the team's president and part majority owner. With the city prepared to welcome a National Football League franchise, which was to become the Tennessee Titans, Schmittou felt that revenue would be drawn away from his baseball team, so he and businessman Walter Nipper sold their 59 percent stake in the Sounds to Chicago-based businessmen Al Gordon, Mike Murtaugh, and Mike Woleben. The new ownership group, operating as AmeriSports Companies LLC, refurbished every area of the stadium, including the concession stands, bathrooms, concourse, stadium exterior, home clubhouse (a visitor's clubhouse had been built under the third base bleachers for the 1996 season), and parking lots. Several sections of bleachers in left field past third base were removed and replaced by tents and a group picnic area. This reduced the seating capacity to 11,500.
Following the 1997 season, the American Association was dissolved, and the Sounds became members of the Pacific Coast League (PCL). As a result, Greer became the second easternmost stadium in PCL history behind the Indianapolis Indians' Bush Stadium when that team played in the PCL from 1964 to 1968. Greer was the easternmost active PCL stadium from 1998 to 2014.
As consumer preferences changed and in an effort to attract larger groups to the ballpark, in the late 1990s, Greer Stadium's fixed-seating capacity was reduced to 10,300 by eliminating the bleacher sections from the third base side and right field and constructing three party decks in their places. As a result, the general admission area became confined only to the existing bleachers behind the reserved seating along the first base line in right field. A fourth party area was created by repurposing unused space atop the grandstands behind home plate. Another deck was built behind the right-field foul pole, which, at times, featured a rentable hot tub.
Nearing the end (2000–2009)
The aging Greer Stadium had never been meant to last longer than 30 years, and it was the subject of many renovations in the early 2000s to attempt to come close to meeting minimum Triple-A standards. In 2003, the Sounds proposed a new stadium to be built with a mix of public and private funds at the corner of 1st Avenue South and Gateway Boulevard (now Korean Veterans Boulevard) in Downtown Nashville on the former site of the city's thermal transfer energy plant, targeting an opening date in April 2006. After two years of the Sounds lobbying for the new park and threatening to leave town (either for the suburbs or a new city altogether), Mayor Bill Purcell agreed to support preliminary plans for the stadium on October 25, 2005, and the Nashville Metro Council approved the new stadium on February 7, 2006, due in part to the Sounds securing construction financing through a consortium of banks, avoiding taxpayer expense. The facility was to be called First Tennessee Field. Opening day at the proposed venue was repeatedly pushed back, eventually to as late as April 2009. However, the Sounds and private developers Struever Brothers, Eccles, & Rouse were unable to finalize financing and design plans for the new stadium by the April 15, 2007, deadline set by the Metro Council. As a result, the First Tennessee Field construction project was canceled and the Sounds remained at Greer with an uncertain future.
Following the dissolution of the plans for the new ballpark, and prior to the 2008 season, more than $1 million in upgrades and repairs were made to Greer. The improvements, which included a new clubhouse for the Sounds and visiting teams beyond the center field wall, improved field lighting, and improvements to restrooms, walkways, and seating, were made in order to keep the stadium functional for another three to five years.
After the 2008 season, Al Gordon's Amerisports Companies LLC sold the Sounds to MFP Baseball, a New York-based group of investors consisting of Masahiro Honzawa, Steve Posner, and Frank Ward. Keeping the team in Nashville was one of the PCL's top criteria for approval of the sale. The new ownership group invested over $2 million to make repairs and upgrades to the aging stadium's playing field, restrooms, concession stands, scoreboard, sound system, and seating. The infield was re-sodded and leveled, protective railing was installed along the edge of the field, and the backstop netting was replaced. The entire concourse and guitar scoreboard were repainted, broken seats were replaced, and the fourth-floor restaurant was remodeled. A permanent concert stage and a family fun zone were constructed by the concourse entrance.
The "Last Cheer at Greer" (2010–2014)
In 2011, MFP Baseball and the Mayor's Office began working toward a new stadium, with the city identifying three potential sites for construction, and recruiting stadium-builder Populous to study each. The three sites were an area on the north end of The Gulch, the state-owned parking lot on the site of Nashville's first ballpark (Sulphur Dell), and various areas directly adjacent to Nissan Stadium and the eastern terminus of the John Seigenthaler Pedestrian Bridge. The Sounds still preferred the previous Thermal site due to its proximity to the city's entertainment and central business districts, but the city was not willing to make a second attempt at a stadium in that location (Ascend Amphitheater was eventually built there). Mayor Karl Dean preferred the Sulphur Dell site, in an attempt to bolster economic growth on downtown's sluggish north side, while incorporating the ballpark into the surrounding neighborhoods. In late summer 2013, the Sounds and the Nashville Metropolitan Government reached an agreement to build a new $37-million downtown ballpark at Sulphur Dell. Construction on First Tennessee Park began after necessary land-swaps with the State of Tennessee, and the new ballpark opened in time for the start of the 2015 season.
Knowing that the 2014 season would be the team's 37th and final campaign at the old ballpark, the Sounds launched the "Last Cheer at Greer", a season-long celebration of the stadium that included nods to its history and promotional giveaways to commemorate the closing. On August 27, 2014, the Sounds hosted their final game at Greer Stadium: an 8–5 loss to the Sacramento River Cats. In his only plate appearance of the evening, Nashville catcher Lucas May struck out swinging with a full count and the bases loaded to end the game. Announced attendance at the game was a standing-room-only crowd of 11,067, the first sellout since 2010, and the largest crowd since 2007.
Closure and demolition (2015–2019)
After the Sounds' administrative offices were moved to First Tennessee Park in early 2015, Greer became essentially abandoned. Vandals peppered the site with graffiti, and many of the building's windows and box seats were damaged. The playing field became overgrown with brush, and photos of the stadium's interior began appearing on the websites and social media accounts of anonymous urban explorers.
Later that year, Mayor Dean expressed interest in converting the facility to a community sporting complex or a new city park, but, nearing the end of his term, ultimately deferred the decision to the next mayor (Megan Barry, elected 2015). In the meantime, Metropolitan Director of Parks Tommy Lynch recommended that the stadium be demolished due to the potential costs for any renovation, including the removal of asbestos. The department asked Mayor Barry for $800,000 to fund the demolition of the concourse and seating bowl so as to expand the green space at the property, which could then be sold to private developers.
Proposed uses for the land included a soccer stadium, an indoor tennis facility for Belmont University, public tennis courts, rodeo grounds, a Kroger grocery store, and a neighborhood park. In a letter to the editor of The Tennessean, former Sounds President Larry Schmittou expressed his interest in Greer becoming an amateur baseball park, citing its amenities and several Metro high schools that lacked baseball diamonds of their own. Two public meetings were held in September 2016 to discuss these and other proposals and ideas for the space.
The city's goal was to create a mixed-use development with green space and affordable housing. By April 2017, a special committee had narrowed the search for a plan and site developer down to five proposals. In May 2017, the Barry administration selected a proposal called Cloud Hill by the Nashville-based Mathews Company and backed by music producer T Bone Burnett. The proposed redevelopment of the 21-acre site included music and art space, a community center, open park space, and affordable housing. The footprint of the baseball diamond and outfield would have been turned into the Great Lawn, a green space for amateur baseball and soccer. Renderings showed the guitar scoreboard and a portion of the outfield wall remaining intact. The plan, which awaited final approval by Metro Parks and the Metro Council, was met with concerns by citizens and groups whom preferred to see the property restored entirely to parkland and the site's Civil War history preserved. Other concerns were raised over the lack of transparency in the city's planning process and the privatization of publicly owned land. Cloud Hill's developers canceled their plans in January 2018 after archaeologists determined that undisturbed areas on the edge of the Greer property, but not part of the stadium itself, were the unmarked burial sites of slaves forced to build Fort Negley. Mayor Barry expressed her desire that the site honor the history of those who died building the fort.
Following Barry's resignation in March 2018, acting Mayor David Briley proposed the demolition of Greer Stadium and the reincorporation of the land into Fort Negley Park. He sought Metro Council approval for the approximately $1 million needed to demolish the stadium, the site of which would then be seeded over with grass. The Metro Historical Commission was tasked with determining a plan to convert the site into one which would honor its Civil War history. Demolition began on April 1, 2019, and was expected to take six months to complete. This was followed by an archaeological survey of the site. , the Metro Parks Department and Metro Historical Commission were planning an open-air museum that shows how the stadium site fits into the history of Fort Negley.
Notable events
All-Star Games
The Southern League All-Star Game was held twice at Greer Stadium, first in 1979 and again in 1983. The July 12, 1979, contest pitted a team of the league's All-Stars against the major league Atlanta Braves. In the third inning, Braves pitcher Preston Hanna was taken deep for a home run by Columbus outfielder Danny Heep, and Nashville's Duane Walker added a run with his RBI single, scoring Memphis second baseman Tim Raines from third. Up 2–0, the All-Stars never trailed. They went on to defeat the Braves, 5–2, before a crowd of 11,079 fans. Charlotte pitcher Larry Jones was the winning pitcher. Walker, who in addition to his run-scoring base hit, also drew a walk, stole two bases, and initiated a double play from center field by snagging a low line drive and throwing out a runner at home plate, was selected as the game's Most Valuable Player (MVP). Nashville was further represented on the All-Star squad by Geoff Combe, Paul Householder, Dave Van Gorder, and manager George Scherger who coached the team.
The midseason exhibition returned to Nashville on June 19, 1983. This time, the Sounds were enlisted to serve as the All-Stars' competition. Consequently, no Sounds player could be voted on to All-Star team. In lieu of this, the league chose to recognize all Sounds players as All-Stars. MLB Commissioner Bowie Kuhn was on hand to toss out the first pitch before an audience of 1,221 who had waited out nearly an hour's rain delay. The All-Stars scored three runs in the sixth inning, including a two-run homer by Birmingham's George Foussianes, the game's eventual MVP. After rallying back with two runs on Scott Bradley's dual RBI single in the eighth, Nashville's Erik Peterson stuck out in the ninth with the tying and winning runs on base to end the game. The league's team had bested Nashville, 3–2. Jacksonville's Mark Gubicza earned the win.
Greer played host to the Triple-A All-Star Game on July 13, 1994, with a crowd of 11,601 on hand in addition to live television and radio audiences. Players from all three Triple-A leagues (the American Association, Pacific Coast League, and International League) were divided into two teams, American and National, based on their MLB parent club's affiliation. Despite an early American League lead, the Nationals came back to score the winning run in the fifth inning when Tucson's Brian Hunter came home on a wild pitch. The Nationals won by a final score of 8–5. The "Star of Stars", or MVP, for the American Association was Nashville's Ray Durham who had three hits and scored the game's first run. Luis Lopez of the Richmond Braves was the International League's MVP for his three-hit, two-RBI night; Paul Faries, of the Phoenix Firebirds, was the PCL's MVP with one hit and two RBIs.
Other 1994 All-Star festivities included a Hollywood All-Star Game featuring celebrities Fred Willard, Jason Bateman, Barry Bostwick, Treat Williams, and Kristoff St. John. There was also a Home Run Derby with four of Triple-A's top home run hitters: Scott Coolbaugh of the Louisville Redbirds, Rich Aude of the Buffalo Bisons, Dwayne Hosey of the Omaha Royals, and Drew Denson of the Sounds. Each batter being given ten swings each to hit as many home runs as possible, Coolbaugh and Denson advanced to the finals with two homers apiece. In the final round, Coolbaugh won the derby by hitting six home runs versus Denson's two.
Major league exhibitions
Greer hosted 19 exhibition games involving Major League Baseball teams in the 1980s and 1990s. Six were competitions between the Nashville Sounds and their MLB parent clubs, while the other 13 were spring training games between major league teams.
The first such game occurred on April 16, 1981, when the New York Yankees made a stop in Nashville to play an exhibition game against their Double-A Sounds. The 10–1 Yankees victory was played in front of a standing-room-only crowd of 17,318 people. Those on hand for the game included Yankees owner George Steinbrenner, coach Yogi Berra, and players Reggie Jackson, Dave Winfield, Lou Piniella, Willie Randolph, and Bobby Murcer. The Yankees returned for another exhibition game against the Sounds on April 28, 1983. New York had a 4–0 lead going into the bottom of the ninth inning, but a five-run rally with two outs propelled the Sounds to a 5–4 win in front of 13,641 fans. The tying and winning runs came off the bat of catcher Frank Kneuer who doubled down the left field line bringing home Matt Gallegos and Derwin McNealy from second and first. Among the Yankees in attendance for the game were owner George Steinbrenner, manager Billy Martin, coach Yogi Berra, and players Goose Gossage, Ken Griffey Sr., Dave Winfield, Willie Randolph, Bobby Murcer, and former Sound Don Mattingly.
On April 12, 1985, Nashville competed in an exhibition game against their major league affiliate, the Detroit Tigers. Manager Sparky Anderson's Detroit club included Kirk Gibson, Alan Trammell, Lou Whitaker, Rusty Kuntz, and Larry Herndon. The Sounds opened the game with back-to-back base hits and went ahead 2–0 on Mike Laga's RBI double. The game was tied 3–3 after five innings, but the Tigers outlasted the Sounds, scoring six runs in the tenth to win, 9–3, before a crowd of 16,182. On April 23, 1990, 14,012 fans attended an exhibition game at Greer between Nashville and their new affiliate, the Cincinnati Reds. Lou Piniella's Cincinnati squad shutout Nashville, 3–0. Luis Quiñones scored the winning run in the first when he came home on a misplayed ball hit on the ground by Paul O'Neill. Pitchers Danny Jackson and Ron Robinson held the Sounds to just five hits, three by Terry McGriff and two by Keith Lockhart.
Cincinnati returned for a second exhibition with Nashville on April 29, 1991. With light rain falling throughout the evening, the game was called after seven innings when the field become unplayable. Though 13 of the 16 Reds appearing in the game were 1990 World Series champions, including Barry Larkin, Chris Sabo, Paul O'Neill, and Randy Myers, the Sounds limited the visitors to just 5 hits and 2 runs while scoring a pair of runs of their own to make the score 2–2 when the game was ended. Rain also hindered an April 3, 1994, game between the Sounds and Chicago White Sox that was cancelled due to wet grounds and the fear of player injury, especially to top White Sox stars Tim Raines and Ozzie Guillén who were slotted to play.
In March 1996, Greer hosted eight major league teams competing in seven games across the span of four days in what was billed as the Nashville Baseball Classic. The Chicago White Sox, Cincinnati Reds, Cleveland Indians, Detroit Tigers, Kansas City Royals, Montreal Expos, St. Louis Cardinals, and Texas Rangers all visited Nashville as they prepared for the 1996 season. The Sounds played an exhibition game against the Pittsburgh Pirates on June 3, 1999, attended by 5,720 fans. The teams combined for 33 hits, including 9 home runs, in a game dominated by offence. The Pirates, whose roster included Jason Kendall, Emil Brown, and Dale Sveum, plated 13 runs in the fifth inning on the way to 16–15 win.
No-hitters and perfect games
Greer Stadium was the setting for eight no-hit games, including one perfect game. The first took place on May 16, 1981, when Jeff Cornell, of the visiting Jacksonville Suns, pitched a 4–0 no-hit game against the Sounds. The second no-hitter at Greer was Jim Deshaies' 5–1 win over the Columbus Astros on May 4, 1984. In the second inning, Deshaies walked three batters and hit another, accounting for the only Astros run of the game, part of a seven-inning doubleheader. The third, a 6–0 win over the Oklahoma City 89ers, was thrown by Nashville's Bryan Kelly on July 17, 1985. Kelly allowed just one baserunner via a walk in the near-perfect game.
In a rare occurrence, the Sounds and the Indianapolis Indians exchanged no-hitters on back-to-back nights on August 6 and 7, 1988. First, Indianapolis' Randy Johnson and Pat Pacillo combined for a no-hit loss against the Sounds, a 1–0 Nashville win. Nashville won when Lenny Harris walked to first base, stole second base and third base, and then came home, scoring on a groundout. The next night, Nashville's Jack Armstrong registered a no-hit game against the Indians, a 4–0 Sounds victory. This was the only time in American Association history that teams played in back-to-back no-hit games.
On April 7, 2003, John Wasdin tossed a perfect game at Greer in a 4–0 win over the Albuquerque Isotopes. This was just the second nine-inning perfect complete game in the 100-year history of the Pacific Coast League. Wasdin threw 100 pitches, striking out 15 batters. Later in the year, on August 2, Colorado Springs Sky Sox pitchers Chris Gissell (7 innings pitched (IP)) and Jesús Sánchez (2 IP) combined for a no-hit 3–0 win against the Sounds. The final no-hit effort at Greer took place on July 15, 2006, when Nashville pitchers Carlos Villanueva (6 IP), Mike Meyers (2 IP), and Alec Zumwalt (1 IP) combined on a 2–0 win over the Memphis Redbirds.
24-inning game
On May 5–6, 2006, Greer was the site of a game which tied the record for the longest game, in terms of innings played, in Pacific Coast League history. The Sounds and the New Orleans Zephyrs competed in a 24-inning game, played over the course of two days, which lasted a total of eight hours and seven minutes. New Orleans defeated Nashville, 5–4. The record was originally set on June 8, 1909, in a game between the San Francisco Seals and Oakland Oaks. A few years later, on September 10, 1911, the record was tied by the Sacramento Solons and Portland Beavers. The Sounds and Zephyrs set the PCL records for the most pitchers used in one game by both clubs (17), and tied the record for the most players used by both clubs (40). They set the records for the most strikeouts, batting and pitching, in a game by both clubs (48), the most at bats by both teams (166), and the most assists by both teams (53). The Sounds tied the records for the most pitchers used by one team (9) and the most assists by a single team (28).
Other events
In 1979 and 1980, Greer Stadium was the home of the National Association of Intercollegiate Athletics (NAIA) World Series. The Lipscomb Bisons of Nashville's Lipscomb University won the 1979 series, and the Grand Canyon Antelopes of Grand Canyon University won in 1980. Until the 2011 opening of E. S. Rose Park, the Belmont Bruins baseball team played the majority of its seasons at Greer.
In the early 1980s, Greer served as the home field for the Father Ryan High School football team. Father Ryan returned to playing at Greer from 2006 through 2008, before moving to a new school athletic complex for the 2009 season. In the football configuration, the field ran along the first base line.
Greer was the site of the City of Hope Celebrity Softball Challenge from 1991 to 2014. Two teams of country music stars participated in the game, from which proceeds went toward the research and treatment of cancer and other life-threatening diseases. Participants included Vince Gill, Carrie Underwood, Brad Paisley, Billy Ray Cyrus, Sara Evans, Montgomery Gentry, and Phil Vassar. Through the 2008 event, more than $1.5 million had been raised. In 2015, the game relocated to First Tennessee Park.
From 2001 to 2011, Greer was home to the Jeff Fisher & Friends Charity Softball Game. Then-Tennessee Titans head coach Jeff Fisher and players from the team, past and present, competed in order to benefit local charities. Titans participants included Vince Young, Steve McNair, Eddie George, Frank Wycheck, Rob Bironas, and Keith Bulluck, among others. Tomáš Vokoun and head coach Barry Trotz of the National Hockey League's Nashville Predators also took part.
The Oak Ridge Boys, including Sounds' minority shareholder Richard Sterban, were photographed standing in the seats along Greer's left field line for the cover of their 1989 album, American Dreams. In 2002, the music video for Steve Earle's "Some Dreams", a song featured in the motion picture The Rookie, was filmed at Greer. The video, intercut with clips from the film, shows Earle and his band performing the song on the empty ballpark's field.
Scoreboard
Greer's distinctive guitar-shaped scoreboard was manufactured by the Fairtron Corporation and installed by the Joslin Sign Company prior to the 1993 season at a cost of $400,000. It was originally conceived as the centerpiece for a proposed major league ballpark in Nashville sought after by owner Larry Schmittou as a part of the 1993 Major League Baseball expansion. Originally painted blue with red and white trim to match the Nashville Sounds' color scheme, it was repainted black with red, yellow, and white trim to match their then-current color scheme in 2008, and was located behind the outfield wall in left-center field.
The entire scoreboard measured across, high, and deep. Individual components of the guitar were as follows: body, neck, and tuning key section. It was installed approximately above the ground. It required 243,155 watts to power its 8,179 total lamps, which were connected to of wire. The entire display weighed .
The line score was displayed on the guitar's neck, while the ball/strike/out count, the batter's uniform number, and the hit/error indicator were all situated on the headstock. Six small advertising signs represented the tuning keys. The body of the guitar featured only an LED display board for displaying messages. Initially, the scoreboard featured two matrix message boards: a low-resolution RGB color board on the left, which featured advertising and animations, and a white-light monochromatic board on the right, which primarily featured statistical information and other text-based messages. The monochrome board was replaced by an orange-tinted LED display board in 2009, which served both purposes, while the color board was deactivated and covered with advertising signage. The scoreboard never had the ability to display video or any kind of high-resolution images. Between the two boards were an analog clock and a temperature display. Surrounding the boards were four large spaces for advertising; the two on top were static, and the two on bottom rotated between three images each (the rotating spaces were covered with static signage beginning in 2009). High-tension nets covered the electronic sections to protect them from home run balls. Above the board was a circular advertising space. This sign originally displayed the team's guitar-swinger logo, and at times displayed other Sounds logos. Originally, when a home run was hit, the guitar-swinger logo would light up and perimeter lights around the entire scoreboard would begin flashing; it was also capable of shooting fireworks after each Sounds home run. By the mid-2000s, the scoreboard had fallen into a state of disrepair and obsolescence, and was only marginally functional. Many of the lights were no longer able to be lit, and replacement parts were becoming hard to find. When MFP Baseball purchased the team in late 2008, the organization made minor renovations to the scoreboard, rendering it once again fully functional, although not to its original specifications. It was also repainted black, red, yellow, and white over its original red, white, and blue color scheme to reflect the team's present colors at the time. By 2013, due to leaks in its exterior, the scoreboard's functionality could be crippled for a period of time following a rainstorm, rendering many of its electronic features dark.
Greer's guitar scoreboard was not moved to First Tennessee Park when the Sounds relocated there in 2015. Instead, a modern version was installed at the new venue. The first design renderings of First Tennessee Park did not feature a guitar scoreboard. On April 22, 2014, at the announcement of First Tennessee's naming rights agreement, Sounds owner Frank Ward told The Tennessean: "The guitar scoreboard at Greer is staying at Greer. At some point in time we will share what our new scoreboard will look like, but it's too early in the process. We're trying to figure it out as we speak." Two months later, on June 20, 2014, Ward announced that a new guitar scoreboard would indeed be constructed, citing overwhelming demand from the community. As a part of the stadium's 2019 demolition, the scoreboard was sold at auction for $54,815. The buyer, AJ Capital Partners, integrated the structure into the design of Nashville Warehouse Company, a mixed-use project at the corner of Chestnut Street and Fourth Avenue South, just blocks away from Greer. The scoreboard was repainted similar to its original color scheme and placed behind a bandshell overlooking a public green space.
Before the installation of the guitar, Greer's original scoreboard was a black, non-descript, rectangular unit with a 2-line reader panel. In 1985, it was moved to beside the left field foul pole to make room for a new rectangular 4-line scoreboard high with a fully animated reader panel. The original unit was then used as an out-of-town scoreboard, displaying the scores of other baseball games. When the guitar display was installed in 1993, the original scoreboard was removed and replaced by the second unit, which became the new out-of-town board. From 2008 to 2014, the out-of-town scoreboard was not used to display scores; instead it was used as a support for additional advertising signage.
Facilities
Seating at the ballpark included fixed stadium seats, general admission bleachers, some with contoured seats, and eighteen skyboxes located on the third floor. As of 2014, total seating capacity was 10,300. Games could be watched from one of four picnic areas—one behind home plate, one on the third base line, one in the third base stands, and one beyond the right field wall. A rentable hot tub deck was located in the right field corner. There was a concert stage and family fun zone located on The Plaza inside the concourse entrance.
Several concession stands and cart vendors were located on the concourse. A full-service restaurant known as Sluggers Sports Bar and Grill, constructed in 1984 as The Hall of Fame Stadium Club, was located on the fourth floor. This was open during all Sounds home dates, and games could be viewed from the restaurant via windows overlooking the field.
Attendance records
During their 37 seasons at Greer, the Nashville Sounds played 2,613 regular-season home games which were attended by a total of 14,453,823 people, for an average of 5,532 per game. The park's season attendance record of 605,122 was set in 1990, while its average attendance record of 8,108 was set in 1980. The lowest season and average attendances occurred in 1997 when 269,186 people came to games; an average of 3,739. Attendance records from 1978 through 2014 are as follows.
See also
List of baseball parks in Nashville, Tennessee
References
Specific
General
External links
1978 establishments in Tennessee
2019 disestablishments in Tennessee
Baseball venues in Tennessee
Belmont Bruins baseball
Defunct baseball venues in the United States
Defunct college baseball venues in the United States
Defunct minor league baseball venues
Nashville Sounds
Nashville Xpress
Softball venues in the United States
Sports venues completed in 1978
Sports venues demolished in 2019
Sports venues in Nashville, Tennessee
|
```python
"""Test deprecation and future warnings.
"""
from __future__ import division, absolute_import, print_function
import numpy as np
from numpy.testing import assert_warns
from numpy.ma.testutils import assert_equal
from numpy.ma.core import MaskedArrayFutureWarning
class TestArgsort(object):
""" gh-8701 """
def _test_base(self, argsort, cls):
arr_0d = np.array(1).view(cls)
argsort(arr_0d)
arr_1d = np.array([1, 2, 3]).view(cls)
argsort(arr_1d)
# argsort has a bad default for >1d arrays
arr_2d = np.array([[1, 2], [3, 4]]).view(cls)
result = assert_warns(
np.ma.core.MaskedArrayFutureWarning, argsort, arr_2d)
assert_equal(result, argsort(arr_2d, axis=None))
# should be no warnings for explicitly specifying it
argsort(arr_2d, axis=None)
argsort(arr_2d, axis=-1)
def test_function_ndarray(self):
return self._test_base(np.ma.argsort, np.ndarray)
def test_function_maskedarray(self):
return self._test_base(np.ma.argsort, np.ma.MaskedArray)
def test_method(self):
return self._test_base(np.ma.MaskedArray.argsort, np.ma.MaskedArray)
class TestMinimumMaximum(object):
def test_minimum(self):
assert_warns(DeprecationWarning, np.ma.minimum, np.ma.array([1, 2]))
def test_maximum(self):
assert_warns(DeprecationWarning, np.ma.maximum, np.ma.array([1, 2]))
def test_axis_default(self):
# NumPy 1.13, 2017-05-06
data1d = np.ma.arange(6)
data2d = data1d.reshape(2, 3)
ma_min = np.ma.minimum.reduce
ma_max = np.ma.maximum.reduce
# check that the default axis is still None, but warns on 2d arrays
result = assert_warns(MaskedArrayFutureWarning, ma_max, data2d)
assert_equal(result, ma_max(data2d, axis=None))
result = assert_warns(MaskedArrayFutureWarning, ma_min, data2d)
assert_equal(result, ma_min(data2d, axis=None))
# no warnings on 1d, as both new and old defaults are equivalent
result = ma_min(data1d)
assert_equal(result, ma_min(data1d, axis=None))
assert_equal(result, ma_min(data1d, axis=0))
result = ma_max(data1d)
assert_equal(result, ma_max(data1d, axis=None))
assert_equal(result, ma_max(data1d, axis=0))
```
|
Nursultan Keneshbekov (born 25 March 2000) is a Kyrgyzstani long-distance runner. He competed in the 5000 metres at the 2020 Summer Olympics.
References
External links
Living people
2000 births
Olympic athletes for Kyrgyzstan
Kyrgyzstani male middle-distance runners
Kyrgyzstani male long-distance runners
Athletes (track and field) at the 2020 Summer Olympics
People from Issyk-Kul Region
21st-century Kyrgyzstani people
Universiade bronze medalists for Kyrgyzstan
Medalists at the 2021 Summer Universiade
Universiade bronze medalists in athletics (track and field)
|
```c++
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions
// are met:
// * Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
// * Redistributions in binary form must reproduce the above copyright
// notice, this list of conditions and the following disclaimer in the
// documentation and/or other materials provided with the distribution.
// * Neither the name of NVIDIA CORPORATION nor the names of its
// contributors may be used to endorse or promote products derived
// from this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ``AS IS'' AND ANY
// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
// OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
//
#include "GuIntersectionTriangleBox.h"
#include "CmMatrix34.h"
#include "PsVecMath.h"
#include "GuBox.h"
#include "GuSIMDHelpers.h"
using namespace physx;
/********************************************************/
/* AABB-triangle overlap test code */
/* by Tomas Akenine-M?r */
/* Function: int triBoxOverlap(float boxcenter[3], */
/* float boxhalfsize[3],float triverts[3][3]); */
/* History: */
/* 2001-03-05: released the code in its first version */
/* 2001-06-18: changed the order of the tests, faster */
/* */
/* Acknowledgement: Many thanks to Pierre Terdiman for */
/* suggestions and discussions on how to optimize code. */
/* Thanks to David Hunt for finding a ">="-bug! */
/********************************************************/
#define CROSS(dest,v1,v2) \
dest.x=v1.y*v2.z-v1.z*v2.y; \
dest.y=v1.z*v2.x-v1.x*v2.z; \
dest.z=v1.x*v2.y-v1.y*v2.x;
#define DOT(v1,v2) (v1.x*v2.x+v1.y*v2.y+v1.z*v2.z)
#define FINDMINMAX(x0, x1, x2, minimum, maximum) \
minimum = physx::intrinsics::selectMin(x0, x1); \
maximum = physx::intrinsics::selectMax(x0, x1); \
minimum = physx::intrinsics::selectMin(minimum, x2); \
maximum = physx::intrinsics::selectMax(maximum, x2);
static PX_FORCE_INLINE Ps::IntBool planeBoxOverlap(const PxVec3& normal, PxReal d, const PxVec3& maxbox)
{
PxVec3 vmin,vmax;
if (normal.x>0.0f)
{
vmin.x = -maxbox.x;
vmax.x = maxbox.x;
}
else
{
vmin.x = maxbox.x;
vmax.x = -maxbox.x;
}
if (normal.y>0.0f)
{
vmin.y = -maxbox.y;
vmax.y = maxbox.y;
}
else
{
vmin.y = maxbox.y;
vmax.y = -maxbox.y;
}
if (normal.z>0.0f)
{
vmin.z = -maxbox.z;
vmax.z = maxbox.z;
}
else
{
vmin.z = maxbox.z;
vmax.z = -maxbox.z;
}
if( normal.dot(vmin) + d > 0.0f) return Ps::IntFalse;
if( normal.dot(vmax) + d >= 0.0f) return Ps::IntTrue;
return Ps::IntFalse;
}
/*======================== X-tests ========================*/
#define AXISTEST_X01(a, b, fa, fb) \
p0 = a*v0.y - b*v0.z; \
p2 = a*v2.y - b*v2.z; \
minimum = physx::intrinsics::selectMin(p0, p2); \
maximum = physx::intrinsics::selectMax(p0, p2); \
rad = fa * extents.y + fb * extents.z; \
if(minimum>rad || maximum<-rad) return Ps::IntFalse;
#define AXISTEST_X2(a, b, fa, fb) \
p0 = a*v0.y - b*v0.z; \
p1 = a*v1.y - b*v1.z; \
minimum = physx::intrinsics::selectMin(p0, p1); \
maximum = physx::intrinsics::selectMax(p0, p1); \
rad = fa * extents.y + fb * extents.z; \
if(minimum>rad || maximum<-rad) return Ps::IntFalse;
/*======================== Y-tests ========================*/
#define AXISTEST_Y02(a, b, fa, fb) \
p0 = -a*v0.x + b*v0.z; \
p2 = -a*v2.x + b*v2.z; \
minimum = physx::intrinsics::selectMin(p0, p2); \
maximum = physx::intrinsics::selectMax(p0, p2); \
rad = fa * extents.x + fb * extents.z; \
if(minimum>rad || maximum<-rad) return Ps::IntFalse;
#define AXISTEST_Y1(a, b, fa, fb) \
p0 = -a*v0.x + b*v0.z; \
p1 = -a*v1.x + b*v1.z; \
minimum = physx::intrinsics::selectMin(p0, p1); \
maximum = physx::intrinsics::selectMax(p0, p1); \
rad = fa * extents.x + fb * extents.z; \
if(minimum>rad || maximum<-rad) return Ps::IntFalse;
/*======================== Z-tests ========================*/
#define AXISTEST_Z12(a, b, fa, fb) \
p1 = a*v1.x - b*v1.y; \
p2 = a*v2.x - b*v2.y; \
minimum = physx::intrinsics::selectMin(p1, p2); \
maximum = physx::intrinsics::selectMax(p1, p2); \
rad = fa * extents.x + fb * extents.y; \
if(minimum>rad || maximum<-rad) return Ps::IntFalse;
#define AXISTEST_Z0(a, b, fa, fb) \
p0 = a*v0.x - b*v0.y; \
p1 = a*v1.x - b*v1.y; \
minimum = physx::intrinsics::selectMin(p0, p1); \
maximum = physx::intrinsics::selectMax(p0, p1); \
rad = fa * extents.x + fb * extents.y; \
if(minimum>rad || maximum<-rad) return Ps::IntFalse;
Ps::IntBool Gu::intersectTriangleBox_ReferenceCode(const PxVec3& boxcenter, const PxVec3& extents, const PxVec3& tp0, const PxVec3& tp1, const PxVec3& tp2)
{
/* use separating axis theorem to test overlap between triangle and box */
/* need to test for overlap in these directions: */
/* 1) the {x,y,z}-directions (actually, since we use the AABB of the triangle */
/* we do not even need to test these) */
/* 2) normal of the triangle */
/* 3) crossproduct(edge from tri, {x,y,z}-directin) */
/* this gives 3x3=9 more tests */
// This is the fastest branch on Sun - move everything so that the boxcenter is in (0,0,0)
const PxVec3 v0 = tp0 - boxcenter;
const PxVec3 v1 = tp1 - boxcenter;
const PxVec3 v2 = tp2 - boxcenter;
// compute triangle edges
const PxVec3 e0 = v1 - v0; // tri edge 0
const PxVec3 e1 = v2 - v1; // tri edge 1
const PxVec3 e2 = v0 - v2; // tri edge 2
float minimum,maximum,rad,p0,p1,p2;
// Bullet 3: test the 9 tests first (this was faster)
float fex = PxAbs(e0.x);
float fey = PxAbs(e0.y);
float fez = PxAbs(e0.z);
AXISTEST_X01(e0.z, e0.y, fez, fey);
AXISTEST_Y02(e0.z, e0.x, fez, fex);
AXISTEST_Z12(e0.y, e0.x, fey, fex);
fex = PxAbs(e1.x);
fey = PxAbs(e1.y);
fez = PxAbs(e1.z);
AXISTEST_X01(e1.z, e1.y, fez, fey);
AXISTEST_Y02(e1.z, e1.x, fez, fex);
AXISTEST_Z0(e1.y, e1.x, fey, fex);
fex = PxAbs(e2.x);
fey = PxAbs(e2.y);
fez = PxAbs(e2.z);
AXISTEST_X2(e2.z, e2.y, fez, fey);
AXISTEST_Y1(e2.z, e2.x, fez, fex);
AXISTEST_Z12(e2.y, e2.x, fey, fex);
// Bullet 1:
// first test overlap in the {x,y,z}-directions
// find minimum, maximum of the triangle each direction, and test for overlap in
// that direction -- this is equivalent to testing a minimal AABB around
// the triangle against the AABB
// test in X-direction
FINDMINMAX(v0.x, v1.x, v2.x, minimum, maximum);
if(minimum>extents.x || maximum<-extents.x) return Ps::IntFalse;
// test in Y-direction
FINDMINMAX(v0.y, v1.y, v2.y, minimum, maximum);
if(minimum>extents.y || maximum<-extents.y) return Ps::IntFalse;
// test in Z-direction
FINDMINMAX(v0.z, v1.z, v2.z, minimum, maximum);
if(minimum>extents.z || maximum<-extents.z) return Ps::IntFalse;
// Bullet 2:
// test if the box intersects the plane of the triangle
// compute plane equation of triangle: normal*x+d=0
PxVec3 normal;
CROSS(normal,e0,e1);
const float d=-DOT(normal,v0); // plane eq: normal.x+d=0
if(!planeBoxOverlap(normal, d, extents)) return Ps::IntFalse;
return Ps::IntTrue; // box and triangle overlaps
}
#undef CROSS
#undef DOT
#undef FINDMINMAX
#undef AXISTEST_X01
#undef AXISTEST_X2
#undef AXISTEST_Y02
#undef AXISTEST_Y1
#undef AXISTEST_Z12
#undef AXISTEST_Z0
using namespace Ps::aos;
static PX_FORCE_INLINE int testClassIIIAxes(const Vec4V& e0V, const Vec4V v0V, const Vec4V v1V, const Vec4V v2V, const PxVec3& extents)
{
const Vec4V e0XZY_V = V4PermYZXW(e0V);
const Vec4V v0XZY_V = V4PermYZXW(v0V);
const Vec4V p0V = V4NegMulSub(v0XZY_V, e0V, V4Mul(v0V, e0XZY_V));
const Vec4V v1XZY_V = V4PermYZXW(v1V);
const Vec4V p1V = V4NegMulSub(v1XZY_V, e0V, V4Mul(v1V, e0XZY_V));
const Vec4V v2XZY_V = V4PermYZXW(v2V);
const Vec4V p2V = V4NegMulSub(v2XZY_V, e0V, V4Mul(v2V, e0XZY_V));
Vec4V minV = V4Min(p0V, p1V);
minV = V4Min(minV, p2V);
const Vec4V extentsV = V4LoadU(&extents.x);
const Vec4V fe0ZYX_V = V4Abs(e0V);
const Vec4V fe0XZY_V = V4PermYZXW(fe0ZYX_V);
const Vec4V extentsXZY_V = V4PermYZXW(extentsV);
Vec4V radV = V4MulAdd(extentsV, fe0XZY_V, V4Mul(extentsXZY_V, fe0ZYX_V));
if(V4AnyGrtr3(minV, radV))
return 0;
Vec4V maxV = V4Max(p0V, p1V);
maxV = V4Max(maxV, p2V);
radV = V4Sub(V4Zero(), radV);
if(V4AnyGrtr3(radV, maxV))
return 0;
return 1;
}
static const VecU32V signV = U4LoadXYZW(0x80000000, 0x80000000, 0x80000000, 0x80000000);
static PX_FORCE_INLINE Ps::IntBool intersectTriangleBoxInternal(const Vec4V v0V, const Vec4V v1V, const Vec4V v2V, const PxVec3& extents)
{
// Test box axes
{
Vec4V extentsV = V4LoadU(&extents.x);
{
const Vec4V cV = V4Abs(v0V);
if(V4AllGrtrOrEq3(extentsV, cV))
return 1;
}
Vec4V minV = V4Min(v0V, v1V);
minV = V4Min(minV, v2V);
if(V4AnyGrtr3(minV, extentsV))
return 0;
Vec4V maxV = V4Max(v0V, v1V);
maxV = V4Max(maxV, v2V);
extentsV = V4Sub(V4Zero(), extentsV);
if(V4AnyGrtr3(extentsV, maxV))
return 0;
}
// Test if the box intersects the plane of the triangle
const Vec4V e0V = V4Sub(v1V, v0V);
const Vec4V e1V = V4Sub(v2V, v1V);
{
const Vec4V normalV = V4Cross(e0V, e1V);
const Vec4V dV = Vec4V_From_FloatV(V4Dot3(normalV, v0V));
const Vec4V extentsV = V4LoadU(&extents.x);
VecU32V normalSignsV = V4U32and(VecU32V_ReinterpretFrom_Vec4V(normalV), signV);
const Vec4V maxV = Vec4V_ReinterpretFrom_VecU32V(V4U32or(VecU32V_ReinterpretFrom_Vec4V(extentsV), normalSignsV));
Vec4V tmpV = Vec4V_From_FloatV(V4Dot3(normalV, maxV));
if(V4AnyGrtr3(dV, tmpV))
return 0;
normalSignsV = V4U32xor(normalSignsV, signV);
const Vec4V minV = Vec4V_ReinterpretFrom_VecU32V(V4U32or(VecU32V_ReinterpretFrom_Vec4V(extentsV), normalSignsV));
tmpV = Vec4V_From_FloatV(V4Dot3(normalV, minV));
if(V4AnyGrtr3(tmpV, dV))
return 0;
}
// Edge-edge tests
{
if(!testClassIIIAxes(e0V, v0V, v1V, v2V, extents))
return 0;
if(!testClassIIIAxes(e1V, v0V, v1V, v2V, extents))
return 0;
const Vec4V e2V = V4Sub(v0V, v2V);
if(!testClassIIIAxes(e2V, v0V, v1V, v2V, extents))
return 0;
}
return 1;
}
// PT: a SIMD version of Tomas Moller's triangle-box SAT code
Ps::IntBool Gu::intersectTriangleBox_Unsafe(const PxVec3& center, const PxVec3& extents, const PxVec3& p0, const PxVec3& p1, const PxVec3& p2)
{
// Move everything so that the boxcenter is in (0,0,0)
const Vec4V BoxCenterV = V4LoadU(¢er.x);
const Vec4V v0V = V4Sub(V4LoadU(&p0.x), BoxCenterV);
const Vec4V v1V = V4Sub(V4LoadU(&p1.x), BoxCenterV);
const Vec4V v2V = V4Sub(V4LoadU(&p2.x), BoxCenterV);
return intersectTriangleBoxInternal(v0V, v1V, v2V, extents);
}
Ps::IntBool Gu::intersectTriangleBox(const BoxPadded& box, const PxVec3& p0_, const PxVec3& p1_, const PxVec3& p2_)
{
// PT: TODO: SIMDify this part
// Vec3p ensures we can safely V4LoadU the data
const Vec3p p0 = box.rotateInv(p0_ - box.center);
const Vec3p p1 = box.rotateInv(p1_ - box.center);
const Vec3p p2 = box.rotateInv(p2_ - box.center);
const Vec4V v0V = V4LoadU(&p0.x);
const Vec4V v1V = V4LoadU(&p1.x);
const Vec4V v2V = V4LoadU(&p2.x);
return intersectTriangleBoxInternal(v0V, v1V, v2V, box.extents);
}
static PX_FORCE_INLINE Vec4V multiply3x3V(const Vec4V p, const PxMat33& mat)
{
const FloatV xxxV = V4GetX(p);
const FloatV yyyV = V4GetY(p);
const FloatV zzzV = V4GetZ(p);
Vec4V ResV = V4Scale(V4LoadU(&mat.column0.x), xxxV);
ResV = V4Add(ResV, V4Scale(V4LoadU(&mat.column1.x), yyyV));
ResV = V4Add(ResV, V4Scale(V4LoadU(&mat.column2.x), zzzV));
return ResV;
}
// PT: warning: all params must be safe to V4LoadU
Ps::IntBool intersectTriangleBoxBV4(const PxVec3& p0, const PxVec3& p1, const PxVec3& p2,
const PxMat33& rotModelToBox, const PxVec3& transModelToBox, const PxVec3& extents)
{
const Vec4V transModelToBoxV = V4LoadU(&transModelToBox.x);
const Vec4V v0V = V4Add(multiply3x3V(V4LoadU(&p0.x), rotModelToBox), transModelToBoxV);
const Vec4V v1V = V4Add(multiply3x3V(V4LoadU(&p1.x), rotModelToBox), transModelToBoxV);
const Vec4V v2V = V4Add(multiply3x3V(V4LoadU(&p2.x), rotModelToBox), transModelToBoxV);
return intersectTriangleBoxInternal(v0V, v1V, v2V, extents);
}
```
|
```c++
#include "source/extensions/load_balancing_policies/common/load_balancer_impl.h"
#include <atomic>
#include <bitset>
#include <cstdint>
#include <map>
#include <memory>
#include <string>
#include <vector>
#include "envoy/config/cluster/v3/cluster.pb.h"
#include "envoy/config/core/v3/base.pb.h"
#include "envoy/runtime/runtime.h"
#include "envoy/upstream/upstream.h"
#include "source/common/common/assert.h"
#include "source/common/common/logger.h"
#include "source/common/protobuf/utility.h"
#include "source/common/runtime/runtime_features.h"
#include "absl/container/fixed_array.h"
namespace Envoy {
namespace Upstream {
namespace {
static const std::string RuntimeZoneEnabled = "upstream.zone_routing.enabled";
static const std::string RuntimeMinClusterSize = "upstream.zone_routing.min_cluster_size";
static const std::string RuntimePanicThreshold = "upstream.healthy_panic_threshold";
// Returns true if the weights of all the hosts in the HostVector are equal.
bool hostWeightsAreEqual(const HostVector& hosts) {
if (hosts.size() <= 1) {
return true;
}
const uint32_t weight = hosts[0]->weight();
for (size_t i = 1; i < hosts.size(); ++i) {
if (hosts[i]->weight() != weight) {
return false;
}
}
return true;
}
} // namespace
std::pair<int32_t, size_t> distributeLoad(PriorityLoad& per_priority_load,
const PriorityAvailability& per_priority_availability,
size_t total_load, size_t normalized_total_availability) {
int32_t first_available_priority = -1;
for (size_t i = 0; i < per_priority_availability.get().size(); ++i) {
if (first_available_priority < 0 && per_priority_availability.get()[i] > 0) {
first_available_priority = i;
}
// Now assign as much load as possible to the high priority levels and cease assigning load
// when total_load runs out.
per_priority_load.get()[i] = std::min<uint32_t>(
total_load, per_priority_availability.get()[i] * 100 / normalized_total_availability);
total_load -= per_priority_load.get()[i];
}
return {first_available_priority, total_load};
}
absl::optional<envoy::extensions::load_balancing_policies::common::v3::LocalityLbConfig>
LoadBalancerConfigHelper::localityLbConfigFromCommonLbConfig(
const envoy::config::cluster::v3::Cluster::CommonLbConfig& common_config) {
if (common_config.has_locality_weighted_lb_config()) {
envoy::extensions::load_balancing_policies::common::v3::LocalityLbConfig locality_lb_config;
locality_lb_config.mutable_locality_weighted_lb_config();
return locality_lb_config;
} else if (common_config.has_zone_aware_lb_config()) {
envoy::extensions::load_balancing_policies::common::v3::LocalityLbConfig locality_lb_config;
auto& zone_aware_lb_config = *locality_lb_config.mutable_zone_aware_lb_config();
const auto& legacy_zone_aware_lb_config = common_config.zone_aware_lb_config();
if (legacy_zone_aware_lb_config.has_routing_enabled()) {
*zone_aware_lb_config.mutable_routing_enabled() =
legacy_zone_aware_lb_config.routing_enabled();
}
if (legacy_zone_aware_lb_config.has_min_cluster_size()) {
*zone_aware_lb_config.mutable_min_cluster_size() =
legacy_zone_aware_lb_config.min_cluster_size();
}
zone_aware_lb_config.set_fail_traffic_on_panic(
legacy_zone_aware_lb_config.fail_traffic_on_panic());
return locality_lb_config;
}
return {};
}
std::pair<uint32_t, LoadBalancerBase::HostAvailability>
LoadBalancerBase::choosePriority(uint64_t hash, const HealthyLoad& healthy_per_priority_load,
const DegradedLoad& degraded_per_priority_load) {
hash = hash % 100 + 1; // 1-100
uint32_t aggregate_percentage_load = 0;
// As with tryChooseLocalLocalityHosts, this can be refactored for efficiency
// but O(N) is good enough for now given the expected number of priorities is
// small.
// We first attempt to select a priority based on healthy availability.
for (size_t priority = 0; priority < healthy_per_priority_load.get().size(); ++priority) {
aggregate_percentage_load += healthy_per_priority_load.get()[priority];
if (hash <= aggregate_percentage_load) {
return {static_cast<uint32_t>(priority), HostAvailability::Healthy};
}
}
// If no priorities were selected due to health, we'll select a priority based degraded
// availability.
for (size_t priority = 0; priority < degraded_per_priority_load.get().size(); ++priority) {
aggregate_percentage_load += degraded_per_priority_load.get()[priority];
if (hash <= aggregate_percentage_load) {
return {static_cast<uint32_t>(priority), HostAvailability::Degraded};
}
}
// The percentages should always add up to 100 but we have to have a return for the compiler.
IS_ENVOY_BUG("unexpected load error");
return {0, HostAvailability::Healthy};
}
LoadBalancerBase::LoadBalancerBase(const PrioritySet& priority_set, ClusterLbStats& stats,
Runtime::Loader& runtime, Random::RandomGenerator& random,
uint32_t healthy_panic_threshold)
: stats_(stats), runtime_(runtime), random_(random),
default_healthy_panic_percent_(healthy_panic_threshold), priority_set_(priority_set) {
for (auto& host_set : priority_set_.hostSetsPerPriority()) {
recalculatePerPriorityState(host_set->priority(), priority_set_, per_priority_load_,
per_priority_health_, per_priority_degraded_, total_healthy_hosts_);
}
// Recalculate panic mode for all levels.
recalculatePerPriorityPanic();
priority_update_cb_ = priority_set_.addPriorityUpdateCb(
[this](uint32_t priority, const HostVector&, const HostVector&) -> absl::Status {
recalculatePerPriorityState(priority, priority_set_, per_priority_load_,
per_priority_health_, per_priority_degraded_,
total_healthy_hosts_);
recalculatePerPriorityPanic();
stashed_random_.clear();
return absl::OkStatus();
});
}
// The following cases are handled by
// recalculatePerPriorityState and recalculatePerPriorityPanic methods (normalized total health is
// sum of all priorities' health values and capped at 100).
// - normalized total health is = 100%. It means there are enough healthy hosts to handle the load.
// Do not enter panic mode, even if a specific priority has low number of healthy hosts.
// - normalized total health is < 100%. There are not enough healthy hosts to handle the load.
// Continue distributing the load among priority sets, but turn on panic mode for a given priority
// if # of healthy hosts in priority set is low.
// - all host sets are in panic mode. Situation called TotalPanic. Load distribution is
// calculated based on the number of hosts in each priority regardless of their health.
// - all hosts in all priorities are down (normalized total health is 0%). If panic
// threshold > 0% the cluster is in TotalPanic (see above). If panic threshold == 0
// then priorities are not in panic, but there are no healthy hosts to route to.
// In this case just mark P=0 as recipient of 100% of the traffic (nothing will be routed
// to P=0 anyways as there are no healthy hosts there).
void LoadBalancerBase::recalculatePerPriorityState(uint32_t priority,
const PrioritySet& priority_set,
HealthyAndDegradedLoad& per_priority_load,
HealthyAvailability& per_priority_health,
DegradedAvailability& per_priority_degraded,
uint32_t& total_healthy_hosts) {
per_priority_load.healthy_priority_load_.get().resize(priority_set.hostSetsPerPriority().size());
per_priority_load.degraded_priority_load_.get().resize(priority_set.hostSetsPerPriority().size());
per_priority_health.get().resize(priority_set.hostSetsPerPriority().size());
per_priority_degraded.get().resize(priority_set.hostSetsPerPriority().size());
total_healthy_hosts = 0;
// Determine the health of the newly modified priority level.
// Health ranges from 0-100, and is the ratio of healthy/degraded hosts to total hosts, modified
// by the overprovisioning factor.
HostSet& host_set = *priority_set.hostSetsPerPriority()[priority];
per_priority_health.get()[priority] = 0;
per_priority_degraded.get()[priority] = 0;
const auto host_count = host_set.hosts().size() - host_set.excludedHosts().size();
if (host_count > 0) {
uint64_t healthy_weight = 0;
uint64_t degraded_weight = 0;
uint64_t total_weight = 0;
if (host_set.weightedPriorityHealth()) {
for (const auto& host : host_set.healthyHosts()) {
healthy_weight += host->weight();
}
for (const auto& host : host_set.degradedHosts()) {
degraded_weight += host->weight();
}
for (const auto& host : host_set.hosts()) {
total_weight += host->weight();
}
uint64_t excluded_weight = 0;
for (const auto& host : host_set.excludedHosts()) {
excluded_weight += host->weight();
}
ASSERT(total_weight >= excluded_weight);
total_weight -= excluded_weight;
} else {
healthy_weight = host_set.healthyHosts().size();
degraded_weight = host_set.degradedHosts().size();
total_weight = host_count;
}
// Each priority level's health is ratio of healthy hosts to total number of hosts in a
// priority multiplied by overprovisioning factor of 1.4 and capped at 100%. It means that if
// all hosts are healthy that priority's health is 100%*1.4=140% and is capped at 100% which
// results in 100%. If 80% of hosts are healthy, that priority's health is still 100%
// (80%*1.4=112% and capped at 100%).
per_priority_health.get()[priority] =
std::min<uint32_t>(100,
// NOLINTNEXTLINE(clang-analyzer-core.DivideZero)
(host_set.overprovisioningFactor() * healthy_weight / total_weight));
// We perform the same computation for degraded hosts.
per_priority_degraded.get()[priority] = std::min<uint32_t>(
100, (host_set.overprovisioningFactor() * degraded_weight / total_weight));
ENVOY_LOG(trace,
"recalculated priority state: priority level {}, healthy weight {}, total weight {}, "
"overprovision factor {}, healthy result {}, degraded result {}",
priority, healthy_weight, total_weight, host_set.overprovisioningFactor(),
per_priority_health.get()[priority], per_priority_degraded.get()[priority]);
}
// Now that we've updated health for the changed priority level, we need to calculate percentage
// load for all priority levels.
// First, determine if the load needs to be scaled relative to availability (healthy + degraded).
// For example if there are 3 host sets with 10% / 20% / 10% health and 20% / 10% / 0% degraded
// they will get 16% / 28% / 14% load to healthy hosts and 28% / 14% / 0% load to degraded hosts
// to ensure total load adds up to 100. Note the first healthy priority is receiving 2% additional
// load due to rounding.
//
// Sum of priority levels' health and degraded values may exceed 100, so it is capped at 100 and
// referred as normalized total availability.
const uint32_t normalized_total_availability =
calculateNormalizedTotalAvailability(per_priority_health, per_priority_degraded);
if (normalized_total_availability == 0) {
// Everything is terrible. There is nothing to calculate here.
// Let recalculatePerPriorityPanic and recalculateLoadInTotalPanic deal with
// load calculation.
return;
}
// We start of with a total load of 100 and distribute it between priorities based on
// availability. We first attempt to distribute this load to healthy priorities based on healthy
// availability.
const auto first_healthy_and_remaining =
distributeLoad(per_priority_load.healthy_priority_load_, per_priority_health, 100,
normalized_total_availability);
// Using the remaining load after allocating load to healthy priorities, distribute it based on
// degraded availability.
const auto remaining_load_for_degraded = first_healthy_and_remaining.second;
const auto first_degraded_and_remaining =
distributeLoad(per_priority_load.degraded_priority_load_, per_priority_degraded,
remaining_load_for_degraded, normalized_total_availability);
// Anything that remains should just be rounding errors, so allocate that to the first available
// priority, either as healthy or degraded.
const auto remaining_load = first_degraded_and_remaining.second;
if (remaining_load != 0) {
const auto first_healthy = first_healthy_and_remaining.first;
const auto first_degraded = first_degraded_and_remaining.first;
ASSERT(first_healthy != -1 || first_degraded != -1);
// Attempt to allocate the remainder to the first healthy priority first. If no such priority
// exist, allocate to the first degraded priority.
ASSERT(remaining_load < per_priority_load.healthy_priority_load_.get().size() +
per_priority_load.degraded_priority_load_.get().size());
if (first_healthy != -1) {
per_priority_load.healthy_priority_load_.get()[first_healthy] += remaining_load;
} else {
per_priority_load.degraded_priority_load_.get()[first_degraded] += remaining_load;
}
}
// The allocated load between healthy and degraded should be exactly 100.
ASSERT(100 == std::accumulate(per_priority_load.healthy_priority_load_.get().begin(),
per_priority_load.healthy_priority_load_.get().end(), 0) +
std::accumulate(per_priority_load.degraded_priority_load_.get().begin(),
per_priority_load.degraded_priority_load_.get().end(), 0));
for (auto& host_set : priority_set.hostSetsPerPriority()) {
total_healthy_hosts += host_set->healthyHosts().size();
}
}
// Method iterates through priority levels and turns on/off panic mode.
void LoadBalancerBase::recalculatePerPriorityPanic() {
per_priority_panic_.resize(priority_set_.hostSetsPerPriority().size());
const uint32_t normalized_total_availability =
calculateNormalizedTotalAvailability(per_priority_health_, per_priority_degraded_);
const uint64_t panic_threshold = std::min<uint64_t>(
100, runtime_.snapshot().getInteger(RuntimePanicThreshold, default_healthy_panic_percent_));
// This is corner case when panic is disabled and there is no hosts available.
// LoadBalancerBase::choosePriority method expects that the sum of
// load percentages always adds up to 100.
// To satisfy that requirement 100% is assigned to P=0.
// In reality no traffic will be routed to P=0 priority, because
// the panic mode is disabled and LoadBalancer will try to find
// a healthy node and none is available.
if (panic_threshold == 0 && normalized_total_availability == 0) {
per_priority_load_.healthy_priority_load_.get()[0] = 100;
return;
}
bool total_panic = true;
for (size_t i = 0; i < per_priority_health_.get().size(); ++i) {
// For each level check if it should run in panic mode. Never set panic mode if
// normalized total health is 100%, even when individual priority level has very low # of
// healthy hosts.
const HostSet& priority_host_set = *priority_set_.hostSetsPerPriority()[i];
per_priority_panic_[i] =
(normalized_total_availability == 100 ? false : isHostSetInPanic(priority_host_set));
total_panic = total_panic && per_priority_panic_[i];
}
// If all priority levels are in panic mode, load distribution
// is done differently.
if (total_panic) {
recalculateLoadInTotalPanic();
}
}
// recalculateLoadInTotalPanic method is called when all priority levels
// are in panic mode. The load distribution is done NOT based on number
// of healthy hosts in the priority, but based on number of hosts
// in each priority regardless of its health.
void LoadBalancerBase::recalculateLoadInTotalPanic() {
// First calculate total number of hosts across all priorities regardless
// whether they are healthy or not.
const uint32_t total_hosts_count =
std::accumulate(priority_set_.hostSetsPerPriority().begin(),
priority_set_.hostSetsPerPriority().end(), static_cast<size_t>(0),
[](size_t acc, const std::unique_ptr<Envoy::Upstream::HostSet>& host_set) {
return acc + host_set->hosts().size();
});
if (0 == total_hosts_count) {
// Backend is empty, but load must be distributed somewhere.
per_priority_load_.healthy_priority_load_.get()[0] = 100;
return;
}
// Now iterate through all priority levels and calculate how much
// load is supposed to go to each priority. In panic mode the calculation
// is based not on the number of healthy hosts but based on the number of
// total hosts in the priority.
uint32_t total_load = 100;
int32_t first_noempty = -1;
for (size_t i = 0; i < per_priority_panic_.size(); i++) {
const HostSet& host_set = *priority_set_.hostSetsPerPriority()[i];
const auto hosts_num = host_set.hosts().size();
if ((-1 == first_noempty) && (0 != hosts_num)) {
first_noempty = i;
}
const uint32_t priority_load = 100 * hosts_num / total_hosts_count;
per_priority_load_.healthy_priority_load_.get()[i] = priority_load;
per_priority_load_.degraded_priority_load_.get()[i] = 0;
total_load -= priority_load;
}
// Add the remaining load to the first not empty load.
per_priority_load_.healthy_priority_load_.get()[first_noempty] += total_load;
// The total load should come up to 100%.
ASSERT(100 == std::accumulate(per_priority_load_.healthy_priority_load_.get().begin(),
per_priority_load_.healthy_priority_load_.get().end(), 0));
}
std::pair<HostSet&, LoadBalancerBase::HostAvailability>
LoadBalancerBase::chooseHostSet(LoadBalancerContext* context, uint64_t hash) const {
if (context) {
const auto priority_loads = context->determinePriorityLoad(
priority_set_, per_priority_load_, Upstream::RetryPriority::defaultPriorityMapping);
const auto priority_and_source = choosePriority(hash, priority_loads.healthy_priority_load_,
priority_loads.degraded_priority_load_);
return {*priority_set_.hostSetsPerPriority()[priority_and_source.first],
priority_and_source.second};
}
const auto priority_and_source = choosePriority(hash, per_priority_load_.healthy_priority_load_,
per_priority_load_.degraded_priority_load_);
return {*priority_set_.hostSetsPerPriority()[priority_and_source.first],
priority_and_source.second};
}
ZoneAwareLoadBalancerBase::ZoneAwareLoadBalancerBase(
const PrioritySet& priority_set, const PrioritySet* local_priority_set, ClusterLbStats& stats,
Runtime::Loader& runtime, Random::RandomGenerator& random, uint32_t healthy_panic_threshold,
const absl::optional<LocalityLbConfig> locality_config)
: LoadBalancerBase(priority_set, stats, runtime, random, healthy_panic_threshold),
local_priority_set_(local_priority_set),
min_cluster_size_(locality_config.has_value()
? PROTOBUF_GET_WRAPPED_OR_DEFAULT(
locality_config->zone_aware_lb_config(), min_cluster_size, 6U)
: 6U),
routing_enabled_(locality_config.has_value()
? PROTOBUF_PERCENT_TO_ROUNDED_INTEGER_OR_DEFAULT(
locality_config->zone_aware_lb_config(), routing_enabled, 100, 100)
: 100),
fail_traffic_on_panic_(locality_config.has_value()
? locality_config->zone_aware_lb_config().fail_traffic_on_panic()
: false),
locality_weighted_balancing_(locality_config.has_value() &&
locality_config->has_locality_weighted_lb_config()) {
ASSERT(!priority_set.hostSetsPerPriority().empty());
resizePerPriorityState();
priority_update_cb_ = priority_set_.addPriorityUpdateCb(
[this](uint32_t priority, const HostVector&, const HostVector&) -> absl::Status {
// Make sure per_priority_state_ is as large as priority_set_.hostSetsPerPriority()
resizePerPriorityState();
// If P=0 changes, regenerate locality routing structures. Locality based routing is
// disabled at all other levels.
if (local_priority_set_ && priority == 0) {
regenerateLocalityRoutingStructures();
}
return absl::OkStatus();
});
if (local_priority_set_) {
// Multiple priorities are unsupported for local priority sets.
// In order to support priorities correctly, one would have to make some assumptions about
// routing (all local Envoys fail over at the same time) and use all priorities when computing
// the locality routing structure.
ASSERT(local_priority_set_->hostSetsPerPriority().size() == 1);
local_priority_set_member_update_cb_handle_ = local_priority_set_->addPriorityUpdateCb(
[this](uint32_t priority, const HostVector&, const HostVector&) -> absl::Status {
ASSERT(priority == 0);
// If the set of local Envoys changes, regenerate routing for P=0 as it does priority
// based routing.
regenerateLocalityRoutingStructures();
return absl::OkStatus();
});
}
}
void ZoneAwareLoadBalancerBase::regenerateLocalityRoutingStructures() {
ASSERT(local_priority_set_);
stats_.lb_recalculate_zone_structures_.inc();
// resizePerPriorityState should ensure these stay in sync.
ASSERT(per_priority_state_.size() == priority_set_.hostSetsPerPriority().size());
// We only do locality routing for P=0
uint32_t priority = 0;
PerPriorityState& state = *per_priority_state_[priority];
// Do not perform any calculations if we cannot perform locality routing based on non runtime
// params.
if (earlyExitNonLocalityRouting()) {
state.locality_routing_state_ = LocalityRoutingState::NoLocalityRouting;
return;
}
HostSet& host_set = *priority_set_.hostSetsPerPriority()[priority];
const HostsPerLocality& upstreamHostsPerLocality = host_set.healthyHostsPerLocality();
const size_t num_upstream_localities = upstreamHostsPerLocality.get().size();
ASSERT(num_upstream_localities >= 2);
// It is worth noting that all of the percentages calculated are orthogonal from
// how much load this priority level receives, percentageLoad(priority).
//
// If the host sets are such that 20% of load is handled locally and 80% is residual, and then
// half the hosts in all host sets go unhealthy, this priority set will
// still send half of the incoming load to the local locality and 80% to residual.
//
// Basically, fairness across localities within a priority is guaranteed. Fairness across
// localities across priorities is not.
const HostsPerLocality& localHostsPerLocality = localHostSet().healthyHostsPerLocality();
auto locality_percentages =
calculateLocalityPercentages(localHostsPerLocality, upstreamHostsPerLocality);
// If we have lower percent of hosts in the local cluster in the same locality,
// we can push all of the requests directly to upstream cluster in the same locality.
if (upstreamHostsPerLocality.hasLocalLocality() &&
locality_percentages[0].upstream_percentage > 0 &&
locality_percentages[0].upstream_percentage >= locality_percentages[0].local_percentage) {
state.locality_routing_state_ = LocalityRoutingState::LocalityDirect;
return;
}
state.locality_routing_state_ = LocalityRoutingState::LocalityResidual;
// If we cannot route all requests to the same locality, calculate what percentage can be routed.
// For example, if local percentage is 20% and upstream is 10%
// we can route only 50% of requests directly.
// Local percent can be 0% if there are no upstream hosts in the local locality.
state.local_percent_to_route_ =
upstreamHostsPerLocality.hasLocalLocality() && locality_percentages[0].local_percentage > 0
? locality_percentages[0].upstream_percentage * 10000 /
locality_percentages[0].local_percentage
: 0;
// Local locality does not have additional capacity (we have already routed what we could).
// Now we need to figure out how much traffic we can route cross locality and to which exact
// locality we should route. Percentage of requests routed cross locality to a specific locality
// needed be proportional to the residual capacity upstream locality has.
//
// residual_capacity contains capacity left in a given locality, we keep accumulating residual
// capacity to make search for sampled value easier.
// For example, if we have the following upstream and local percentage:
// local_percentage: 40000 40000 20000
// upstream_percentage: 25000 50000 25000
// Residual capacity would look like: 0 10000 5000. Now we need to sample proportionally to
// bucket sizes (residual capacity). For simplicity of finding where specific
// sampled value is, we accumulate values in residual capacity. This is what it will look like:
// residual_capacity: 0 10000 15000
// Now to find a locality to route (bucket) we could simply iterate over residual_capacity
// searching where sampled value is placed.
state.residual_capacity_.resize(num_upstream_localities);
for (uint64_t i = 0; i < num_upstream_localities; ++i) {
uint64_t last_residual_capacity = i > 0 ? state.residual_capacity_[i - 1] : 0;
LocalityPercentages this_locality_percentages = locality_percentages[i];
if (i == 0 && upstreamHostsPerLocality.hasLocalLocality()) {
// This is a local locality, we have already routed what we could.
state.residual_capacity_[i] = last_residual_capacity;
continue;
}
// Only route to the localities that have additional capacity.
if (this_locality_percentages.upstream_percentage >
this_locality_percentages.local_percentage) {
state.residual_capacity_[i] = last_residual_capacity +
this_locality_percentages.upstream_percentage -
this_locality_percentages.local_percentage;
} else {
// Locality with index "i" does not have residual capacity, but we keep accumulating previous
// values to make search easier on the next step.
state.residual_capacity_[i] = last_residual_capacity;
}
}
}
void ZoneAwareLoadBalancerBase::resizePerPriorityState() {
const uint32_t size = priority_set_.hostSetsPerPriority().size();
while (per_priority_state_.size() < size) {
// Note for P!=0, PerPriorityState is created with NoLocalityRouting and never changed.
per_priority_state_.push_back(std::make_unique<PerPriorityState>());
}
}
bool ZoneAwareLoadBalancerBase::earlyExitNonLocalityRouting() {
// We only do locality routing for P=0.
HostSet& host_set = *priority_set_.hostSetsPerPriority()[0];
if (host_set.healthyHostsPerLocality().get().size() < 2) {
return true;
}
// Do not perform locality routing if there are too few local localities for zone routing to have
// an effect.
if (localHostSet().hostsPerLocality().get().size() < 2) {
return true;
}
// Do not perform locality routing if the local cluster doesn't have any hosts in the current
// envoy's local locality. This breaks our assumptions about the local cluster being correctly
// configured, so we don't have enough information to perform locality routing. Note: If other
// envoys do exist according to the local cluster, they will still be able to perform locality
// routing correctly. This will not cause a traffic imbalance because other envoys will not know
// about the current one, so they will not factor it into locality routing calculations.
if (!localHostSet().hostsPerLocality().hasLocalLocality() ||
localHostSet().hostsPerLocality().get()[0].empty()) {
stats_.lb_local_cluster_not_ok_.inc();
return true;
}
// Do not perform locality routing for small clusters.
const uint64_t min_cluster_size =
runtime_.snapshot().getInteger(RuntimeMinClusterSize, min_cluster_size_);
if (host_set.healthyHosts().size() < min_cluster_size) {
stats_.lb_zone_cluster_too_small_.inc();
return true;
}
return false;
}
HostConstSharedPtr ZoneAwareLoadBalancerBase::chooseHost(LoadBalancerContext* context) {
HostConstSharedPtr host;
const size_t max_attempts = context ? context->hostSelectionRetryCount() + 1 : 1;
for (size_t i = 0; i < max_attempts; ++i) {
host = chooseHostOnce(context);
// If host selection failed or the host is accepted by the filter, return.
// Otherwise, try again.
// Note: in the future we might want to allow retrying when chooseHostOnce returns nullptr.
if (!host || !context || !context->shouldSelectAnotherHost(*host)) {
return host;
}
}
// If we didn't find anything, return the last host.
return host;
}
bool LoadBalancerBase::isHostSetInPanic(const HostSet& host_set) const {
uint64_t global_panic_threshold = std::min<uint64_t>(
100, runtime_.snapshot().getInteger(RuntimePanicThreshold, default_healthy_panic_percent_));
const auto host_count = host_set.hosts().size() - host_set.excludedHosts().size();
double healthy_percent =
host_count == 0 ? 0.0 : 100.0 * host_set.healthyHosts().size() / host_count;
double degraded_percent =
host_count == 0 ? 0.0 : 100.0 * host_set.degradedHosts().size() / host_count;
// If the % of healthy hosts in the cluster is less than our panic threshold, we use all hosts.
if ((healthy_percent + degraded_percent) < global_panic_threshold) {
return true;
}
return false;
}
absl::FixedArray<ZoneAwareLoadBalancerBase::LocalityPercentages>
ZoneAwareLoadBalancerBase::calculateLocalityPercentages(
const HostsPerLocality& local_hosts_per_locality,
const HostsPerLocality& upstream_hosts_per_locality) {
uint64_t total_local_hosts = 0;
std::map<envoy::config::core::v3::Locality, uint64_t, LocalityLess> local_counts;
for (const auto& locality_hosts : local_hosts_per_locality.get()) {
total_local_hosts += locality_hosts.size();
// If there is no entry in the map for a given locality, it is assumed to have 0 hosts.
if (!locality_hosts.empty()) {
local_counts.insert(std::make_pair(locality_hosts[0]->locality(), locality_hosts.size()));
}
}
uint64_t total_upstream_hosts = 0;
for (const auto& locality_hosts : upstream_hosts_per_locality.get()) {
total_upstream_hosts += locality_hosts.size();
}
absl::FixedArray<LocalityPercentages> percentages(upstream_hosts_per_locality.get().size());
for (uint32_t i = 0; i < upstream_hosts_per_locality.get().size(); ++i) {
const auto& upstream_hosts = upstream_hosts_per_locality.get()[i];
if (upstream_hosts.empty()) {
// If there are no upstream hosts in a given locality, the upstream percentage is 0.
// We can't determine the locality of this group, so we can't find the corresponding local
// count. However, if there are no upstream hosts in a locality, the local percentage doesn't
// matter.
percentages[i] = LocalityPercentages{0, 0};
continue;
}
const auto& locality = upstream_hosts[0]->locality();
const auto& local_count_it = local_counts.find(locality);
const uint64_t local_count = local_count_it == local_counts.end() ? 0 : local_count_it->second;
const uint64_t local_percentage =
total_local_hosts > 0 ? 10000ULL * local_count / total_local_hosts : 0;
const uint64_t upstream_percentage =
total_upstream_hosts > 0 ? 10000ULL * upstream_hosts.size() / total_upstream_hosts : 0;
percentages[i] = LocalityPercentages{local_percentage, upstream_percentage};
}
return percentages;
}
uint32_t ZoneAwareLoadBalancerBase::tryChooseLocalLocalityHosts(const HostSet& host_set) const {
PerPriorityState& state = *per_priority_state_[host_set.priority()];
ASSERT(state.locality_routing_state_ != LocalityRoutingState::NoLocalityRouting);
// At this point it's guaranteed to be at least 2 localities in the upstream host set.
const size_t number_of_localities = host_set.healthyHostsPerLocality().get().size();
ASSERT(number_of_localities >= 2U);
// Try to push all of the requests to the same locality if possible.
if (state.locality_routing_state_ == LocalityRoutingState::LocalityDirect) {
ASSERT(host_set.healthyHostsPerLocality().hasLocalLocality());
stats_.lb_zone_routing_all_directly_.inc();
return 0;
}
ASSERT(state.locality_routing_state_ == LocalityRoutingState::LocalityResidual);
ASSERT(host_set.healthyHostsPerLocality().hasLocalLocality() ||
state.local_percent_to_route_ == 0);
// If we cannot route all requests to the same locality, we already calculated how much we can
// push to the local locality, check if we can push to local locality on current iteration.
if (random_.random() % 10000 < state.local_percent_to_route_) {
stats_.lb_zone_routing_sampled_.inc();
return 0;
}
// At this point we must route cross locality as we cannot route to the local locality.
stats_.lb_zone_routing_cross_zone_.inc();
// This is *extremely* unlikely but possible due to rounding errors when calculating
// locality percentages. In this case just select random locality.
if (state.residual_capacity_[number_of_localities - 1] == 0) {
stats_.lb_zone_no_capacity_left_.inc();
return random_.random() % number_of_localities;
}
// Random sampling to select specific locality for cross locality traffic based on the
// additional capacity in localities.
uint64_t threshold = random_.random() % state.residual_capacity_[number_of_localities - 1];
// This potentially can be optimized to be O(log(N)) where N is the number of localities.
// Linear scan should be faster for smaller N, in most of the scenarios N will be small.
//
// Bucket 1: [0, state.residual_capacity_[0] - 1]
// Bucket 2: [state.residual_capacity_[0], state.residual_capacity_[1] - 1]
// ...
// Bucket N: [state.residual_capacity_[N-2], state.residual_capacity_[N-1] - 1]
int i = 0;
while (threshold >= state.residual_capacity_[i]) {
i++;
}
return i;
}
absl::optional<ZoneAwareLoadBalancerBase::HostsSource>
ZoneAwareLoadBalancerBase::hostSourceToUse(LoadBalancerContext* context, uint64_t hash) const {
auto host_set_and_source = chooseHostSet(context, hash);
// The second argument tells us which availability we should target from the selected host set.
const auto host_availability = host_set_and_source.second;
auto& host_set = host_set_and_source.first;
HostsSource hosts_source;
hosts_source.priority_ = host_set.priority();
// If the selected host set has insufficient healthy hosts, return all hosts (unless we should
// fail traffic on panic, in which case return no host).
if (per_priority_panic_[hosts_source.priority_]) {
stats_.lb_healthy_panic_.inc();
if (fail_traffic_on_panic_) {
return absl::nullopt;
} else {
hosts_source.source_type_ = HostsSource::SourceType::AllHosts;
return hosts_source;
}
}
// If we're doing locality weighted balancing, pick locality.
//
// The chooseDegradedLocality or chooseHealthyLocality may return valid locality index
// when the locality_weighted_lb_config is set or load balancing policy extension is used.
// This if statement is to make sure we only do locality weighted balancing when the
// locality_weighted_lb_config is set explicitly even the hostSourceToUse is called in the
// load balancing policy extensions.
if (locality_weighted_balancing_) {
absl::optional<uint32_t> locality;
if (host_availability == HostAvailability::Degraded) {
locality = host_set.chooseDegradedLocality();
} else {
locality = host_set.chooseHealthyLocality();
}
if (locality.has_value()) {
auto source_type = localitySourceType(host_availability);
if (!source_type) {
return absl::nullopt;
}
hosts_source.source_type_ = source_type.value();
hosts_source.locality_index_ = locality.value();
return hosts_source;
}
}
// If we've latched that we can't do locality-based routing, return healthy or degraded hosts
// for the selected host set.
if (per_priority_state_[host_set.priority()]->locality_routing_state_ ==
LocalityRoutingState::NoLocalityRouting) {
auto source_type = sourceType(host_availability);
if (!source_type) {
return absl::nullopt;
}
hosts_source.source_type_ = source_type.value();
return hosts_source;
}
// Determine if the load balancer should do zone based routing for this pick.
if (!runtime_.snapshot().featureEnabled(RuntimeZoneEnabled, routing_enabled_)) {
auto source_type = sourceType(host_availability);
if (!source_type) {
return absl::nullopt;
}
hosts_source.source_type_ = source_type.value();
return hosts_source;
}
if (isHostSetInPanic(localHostSet())) {
stats_.lb_local_cluster_not_ok_.inc();
// If the local Envoy instances are in global panic, and we should not fail traffic, do
// not do locality based routing.
if (fail_traffic_on_panic_) {
return absl::nullopt;
} else {
auto source_type = sourceType(host_availability);
if (!source_type) {
return absl::nullopt;
}
hosts_source.source_type_ = source_type.value();
return hosts_source;
}
}
auto source_type = localitySourceType(host_availability);
if (!source_type) {
return absl::nullopt;
}
hosts_source.source_type_ = source_type.value();
hosts_source.locality_index_ = tryChooseLocalLocalityHosts(host_set);
return hosts_source;
}
const HostVector& ZoneAwareLoadBalancerBase::hostSourceToHosts(HostsSource hosts_source) const {
const HostSet& host_set = *priority_set_.hostSetsPerPriority()[hosts_source.priority_];
switch (hosts_source.source_type_) {
case HostsSource::SourceType::AllHosts:
return host_set.hosts();
case HostsSource::SourceType::HealthyHosts:
return host_set.healthyHosts();
case HostsSource::SourceType::DegradedHosts:
return host_set.degradedHosts();
case HostsSource::SourceType::LocalityHealthyHosts:
return host_set.healthyHostsPerLocality().get()[hosts_source.locality_index_];
case HostsSource::SourceType::LocalityDegradedHosts:
return host_set.degradedHostsPerLocality().get()[hosts_source.locality_index_];
}
PANIC_DUE_TO_CORRUPT_ENUM;
}
EdfLoadBalancerBase::EdfLoadBalancerBase(
const PrioritySet& priority_set, const PrioritySet* local_priority_set, ClusterLbStats& stats,
Runtime::Loader& runtime, Random::RandomGenerator& random, uint32_t healthy_panic_threshold,
const absl::optional<LocalityLbConfig> locality_config,
const absl::optional<SlowStartConfig> slow_start_config, TimeSource& time_source)
: ZoneAwareLoadBalancerBase(priority_set, local_priority_set, stats, runtime, random,
healthy_panic_threshold, locality_config),
seed_(random_.random()),
slow_start_window_(slow_start_config.has_value()
? std::chrono::milliseconds(DurationUtil::durationToMilliseconds(
slow_start_config.value().slow_start_window()))
: std::chrono::milliseconds(0)),
aggression_runtime_(
slow_start_config.has_value() && slow_start_config.value().has_aggression()
? absl::optional<Runtime::Double>({slow_start_config.value().aggression(), runtime})
: absl::nullopt),
time_source_(time_source), latest_host_added_time_(time_source_.monotonicTime()),
slow_start_min_weight_percent_(slow_start_config.has_value()
? PROTOBUF_PERCENT_TO_DOUBLE_OR_DEFAULT(
slow_start_config.value(), min_weight_percent, 10) /
100.0
: 0.1) {
// We fully recompute the schedulers for a given host set here on membership change, which is
// consistent with what other LB implementations do (e.g. thread aware).
// The downside of a full recompute is that time complexity is O(n * log n),
// so we will need to do better at delta tracking to scale (see
// path_to_url
priority_update_cb_ = priority_set.addPriorityUpdateCb(
[this](uint32_t priority, const HostVector&, const HostVector&) {
refresh(priority);
return absl::OkStatus();
});
member_update_cb_ = priority_set.addMemberUpdateCb(
[this](const HostVector& hosts_added, const HostVector&) -> absl::Status {
if (isSlowStartEnabled()) {
recalculateHostsInSlowStart(hosts_added);
}
return absl::OkStatus();
});
}
void EdfLoadBalancerBase::initialize() {
for (uint32_t priority = 0; priority < priority_set_.hostSetsPerPriority().size(); ++priority) {
refresh(priority);
}
}
void EdfLoadBalancerBase::recalculateHostsInSlowStart(const HostVector& hosts) {
// TODO(nezdolik): linear scan can be improved with using flat hash set for hosts in slow start.
for (const auto& host : hosts) {
auto current_time = time_source_.monotonicTime();
// Host enters slow start if only it has transitioned into healthy state.
if (host->coarseHealth() == Upstream::Host::Health::Healthy) {
auto host_last_hc_pass_time =
host->lastHcPassTime() ? host->lastHcPassTime().value() : current_time;
auto in_healthy_state_duration = std::chrono::duration_cast<std::chrono::milliseconds>(
current_time - host_last_hc_pass_time);
// If there is no active HC enabled or HC has not run, start slow start window from current
// time.
if (!host->lastHcPassTime()) {
host->setLastHcPassTime(std::move(current_time));
}
// Check if host existence time is within slow start window.
if (host_last_hc_pass_time > latest_host_added_time_ &&
in_healthy_state_duration <= slow_start_window_) {
latest_host_added_time_ = host_last_hc_pass_time;
}
}
}
}
void EdfLoadBalancerBase::refresh(uint32_t priority) {
const auto add_hosts_source = [this](HostsSource source, const HostVector& hosts) {
// Nuke existing scheduler if it exists.
auto& scheduler = scheduler_[source] = Scheduler{};
refreshHostSource(source);
if (isSlowStartEnabled()) {
recalculateHostsInSlowStart(hosts);
}
// Check if the original host weights are equal and no hosts are in slow start mode, in that
// case EDF creation is skipped. When all original weights are equal and no hosts are in slow
// start mode we can rely on unweighted host pick to do optimal round robin and least-loaded
// host selection with lower memory and CPU overhead.
if (hostWeightsAreEqual(hosts) && noHostsAreInSlowStart()) {
// Skip edf creation.
return;
}
if (Runtime::runtimeFeatureEnabled(
"envoy.reloadable_features.edf_lb_host_scheduler_init_fix")) {
// If there are no hosts or a single one, there is no need for an EDF scheduler
// (thus lowering memory and CPU overhead), as the (possibly) single host
// will be the one always selected by the scheduler.
if (hosts.size() <= 1) {
return;
}
// Populate the scheduler with the host list with a randomized starting point.
// TODO(mattklein123): We must build the EDF schedule even if all of the hosts are currently
// weighted 1. This is because currently we don't refresh host sets if only weights change.
// We should probably change this to refresh at all times. See the comment in
// BaseDynamicClusterImpl::updateDynamicHostList about this.
scheduler.edf_ = std::make_unique<EdfScheduler<Host>>(EdfScheduler<Host>::createWithPicks(
hosts,
// We use a fixed weight here. While the weight may change without
// notification, this will only be stale until this host is next picked,
// at which point it is reinserted into the EdfScheduler with its new
// weight in chooseHost().
[this](const Host& host) { return hostWeight(host); }, seed_));
} else {
scheduler.edf_ = std::make_unique<EdfScheduler<Host>>();
// Populate scheduler with host list.
// TODO(mattklein123): We must build the EDF schedule even if all of the hosts are currently
// weighted 1. This is because currently we don't refresh host sets if only weights change.
// We should probably change this to refresh at all times. See the comment in
// BaseDynamicClusterImpl::updateDynamicHostList about this.
for (const auto& host : hosts) {
// We use a fixed weight here. While the weight may change without
// notification, this will only be stale until this host is next picked,
// at which point it is reinserted into the EdfScheduler with its new
// weight in chooseHost().
scheduler.edf_->add(hostWeight(*host), host);
}
// Cycle through hosts to achieve the intended offset behavior.
// TODO(htuch): Consider how we can avoid biasing towards earlier hosts in the schedule across
// refreshes for the weighted case.
if (!hosts.empty()) {
for (uint32_t i = 0; i < seed_ % hosts.size(); ++i) {
auto host =
scheduler.edf_->pickAndAdd([this](const Host& host) { return hostWeight(host); });
}
}
}
};
// Populate EdfSchedulers for each valid HostsSource value for the host set at this priority.
const auto& host_set = priority_set_.hostSetsPerPriority()[priority];
add_hosts_source(HostsSource(priority, HostsSource::SourceType::AllHosts), host_set->hosts());
add_hosts_source(HostsSource(priority, HostsSource::SourceType::HealthyHosts),
host_set->healthyHosts());
add_hosts_source(HostsSource(priority, HostsSource::SourceType::DegradedHosts),
host_set->degradedHosts());
for (uint32_t locality_index = 0;
locality_index < host_set->healthyHostsPerLocality().get().size(); ++locality_index) {
add_hosts_source(
HostsSource(priority, HostsSource::SourceType::LocalityHealthyHosts, locality_index),
host_set->healthyHostsPerLocality().get()[locality_index]);
}
for (uint32_t locality_index = 0;
locality_index < host_set->degradedHostsPerLocality().get().size(); ++locality_index) {
add_hosts_source(
HostsSource(priority, HostsSource::SourceType::LocalityDegradedHosts, locality_index),
host_set->degradedHostsPerLocality().get()[locality_index]);
}
}
bool EdfLoadBalancerBase::isSlowStartEnabled() const {
return slow_start_window_ > std::chrono::milliseconds(0);
}
bool EdfLoadBalancerBase::noHostsAreInSlowStart() const {
if (!isSlowStartEnabled()) {
return true;
}
auto current_time = time_source_.monotonicTime();
if (std::chrono::duration_cast<std::chrono::milliseconds>(
current_time - latest_host_added_time_) <= slow_start_window_) {
return false;
}
return true;
}
HostConstSharedPtr EdfLoadBalancerBase::peekAnotherHost(LoadBalancerContext* context) {
if (tooManyPreconnects(stashed_random_.size(), total_healthy_hosts_)) {
return nullptr;
}
const absl::optional<HostsSource> hosts_source = hostSourceToUse(context, random(true));
if (!hosts_source) {
return nullptr;
}
auto scheduler_it = scheduler_.find(*hosts_source);
// We should always have a scheduler for any return value from
// hostSourceToUse() via the construction in refresh();
ASSERT(scheduler_it != scheduler_.end());
auto& scheduler = scheduler_it->second;
// As has been commented in both EdfLoadBalancerBase::refresh and
// BaseDynamicClusterImpl::updateDynamicHostList, we must do a runtime pivot here to determine
// whether to use EDF or do unweighted (fast) selection. EDF is non-null iff the original
// weights of 2 or more hosts differ.
if (scheduler.edf_ != nullptr) {
return scheduler.edf_->peekAgain([this](const Host& host) { return hostWeight(host); });
} else {
const HostVector& hosts_to_use = hostSourceToHosts(*hosts_source);
if (hosts_to_use.empty()) {
return nullptr;
}
return unweightedHostPeek(hosts_to_use, *hosts_source);
}
}
HostConstSharedPtr EdfLoadBalancerBase::chooseHostOnce(LoadBalancerContext* context) {
const absl::optional<HostsSource> hosts_source = hostSourceToUse(context, random(false));
if (!hosts_source) {
return nullptr;
}
auto scheduler_it = scheduler_.find(*hosts_source);
// We should always have a scheduler for any return value from
// hostSourceToUse() via the construction in refresh();
ASSERT(scheduler_it != scheduler_.end());
auto& scheduler = scheduler_it->second;
// As has been commented in both EdfLoadBalancerBase::refresh and
// BaseDynamicClusterImpl::updateDynamicHostList, we must do a runtime pivot here to determine
// whether to use EDF or do unweighted (fast) selection. EDF is non-null iff the original
// weights of 2 or more hosts differ.
if (scheduler.edf_ != nullptr) {
auto host = scheduler.edf_->pickAndAdd([this](const Host& host) { return hostWeight(host); });
return host;
} else {
const HostVector& hosts_to_use = hostSourceToHosts(*hosts_source);
if (hosts_to_use.empty()) {
return nullptr;
}
return unweightedHostPick(hosts_to_use, *hosts_source);
}
}
namespace {
double applyAggressionFactor(double time_factor, double aggression) {
if (aggression == 1.0 || time_factor == 1.0) {
return time_factor;
} else {
return std::pow(time_factor, 1.0 / aggression);
}
}
} // namespace
double EdfLoadBalancerBase::applySlowStartFactor(double host_weight, const Host& host) const {
// We can reliably apply slow start weight only if `last_hc_pass_time` in host has been populated
// either by active HC or by `member_update_cb_` in `EdfLoadBalancerBase`.
if (host.lastHcPassTime() && host.coarseHealth() == Upstream::Host::Health::Healthy) {
auto in_healthy_state_duration = std::chrono::duration_cast<std::chrono::milliseconds>(
time_source_.monotonicTime() - host.lastHcPassTime().value());
if (in_healthy_state_duration < slow_start_window_) {
double aggression =
aggression_runtime_ != absl::nullopt ? aggression_runtime_.value().value() : 1.0;
if (aggression <= 0.0 || std::isnan(aggression)) {
ENVOY_LOG_EVERY_POW_2(error, "Invalid runtime value provided for aggression parameter, "
"aggression cannot be less than 0.0");
aggression = 1.0;
}
ASSERT(aggression > 0.0);
auto time_factor = static_cast<double>(std::max(std::chrono::milliseconds(1).count(),
in_healthy_state_duration.count())) /
slow_start_window_.count();
return host_weight * std::max(applyAggressionFactor(time_factor, aggression),
slow_start_min_weight_percent_);
} else {
return host_weight;
}
} else {
return host_weight;
}
}
} // namespace Upstream
} // namespace Envoy
```
|
Syran al-Gharbi () is a sub-district located in Shaharah District, 'Amran Governorate, Yemen. Syran al-Gharbi had a population of 16503 according to the 2004 census.
References
Sub-districts in Shaharah District
|
```javascript
import { BVToastPlugin } from './helpers/bv-toast'
import { BToast } from './toast'
import { BToaster } from './toaster'
import { pluginFactory } from '../../utils/plugins'
const ToastPlugin = /*#__PURE__*/ pluginFactory({
components: { BToast, BToaster },
// $bvToast injection
plugins: { BVToastPlugin }
})
export { ToastPlugin, BToast, BToaster }
```
|
Louis Poznański (born 24 May 2001) is a professional footballer who plays as a left-back. Born in Germany, he represented both his country of birth and Poland at youth level.
Career
On 22 February 2023, Poznański signed with Ekstraklasa side Lechia Gdańsk until the end of the year, with an option to extend his deal until June 2026. He failed to make an appearance for the club before leaving by mutual consent on 1 September 2023.
References
External links
2001 births
Living people
Footballers from Bremen (city)
German men's footballers
German people of Polish descent
Men's association football defenders
Poland men's youth international footballers
Germany men's youth international footballers
Regionalliga players
Super League Greece players
SV Werder Bremen II players
PAS Giannina F.C. players
Lechia Gdańsk players
German expatriate men's footballers
German expatriate sportspeople in Greece
Expatriate men's footballers in Greece
German expatriate sportspeople in Poland
Expatriate men's footballers in Poland
|
```css
.root {
display: inline-flex;
align-items: center;
justify-content: center;
padding: 5px;
min-width: 27px;
border-radius: 10.5px;
font-size: 12px;
background-color: #cccccc;
}
```
|
State Route 344 (SR 344) is a state highway in Hamblen and Hawkins counties, within the U.S. state of Tennessee. It connects US 11E in Russellville to US 11W west of Rogersville, Tennessee via SR 113.
Route description
SR 344 begins in Hamblen County in Russellville at a Y-Intersection with US 11E/SR 34/SR 66. The highway goes east along the original US 11E alignment through downtown (Old Russellville Pike) before leaving Russellville and turning northeastward through farmland before having an intersection and becoming concurrent with SR 113, where it crosses into Hawkins County. SR 113/SR 344 continue northeast to Saint Clair, where SR 344 splits off and goes north. It then passes through a couple of ridges before making a sharp right and crossing a bridge over Cherokee Lake/Holston River a short distance later. SR 344 then comes to an end at an intersection with US 11W/SR 1 just west of Rogersville.
Major intersections
References
344
|
Moraxella caviae is a Gram-negative bacterium in the genus Moraxella, which was isolated from the pharyngeal region and mouth of guinea pig.
References
External links
Type strain of Moraxella caviae at BacDive - the Bacterial Diversity Metadatabase
Moraxellaceae
Bacteria described in 1968
|
Afşin-Elbistan C was a planned 1800-MW coal-fired power station which was proposed to be built in Turkey by the state-owned mining company Maden Holding. Estimated to cost over lira, at planned capacity it would have generated about 3% of the nation's electricity. According to the environmental impact assessment (EIA) the plant would have burned 23 million tonnes of lignite annually, and emit over 61 million tonnes of each year for 35 years.
However in 2021 Turkey targeted net zero carbon emissions by 2053. It would have been the least carbon efficient coal-fired power station and the largest single emitter of greenhouse gas in the world. In March 2022 Kahramanmaraş Administrative Court stopped the project on the grounds of possible soil and air pollution - although this decision could be appealed to the Council of State (Danıştay). In June 2022 the Kahramanmaraş Administrative Court canceled the 'EIA positive' report.
In January 2023 the National Energy Plan was published: it forecast that 1.7 GW more local coal power would be connected to the grid by 2030 but did not say where.
Planned development
Like some other power stations in Turkey the proposed three units of 600 MW for Afşin in Kahramanmaraş Province were originally planned to be owned and operated by the Electricity Generation Company. But in late 2020 it was announced that they would belong to another state-owned company Maden Holding, which holds a variety of mines. Estimated to cost lira, at planned capacity 11 TWh per year (about 3%) of the nation's electricity would be generated by burning 23 million tonnes of Turkish lignite annually.
The site, on the border between Altınelma (in Turkish) and Tanır (in Turkish) neighbourhoods in Afşin district, is near the two existing Afşin-Elbistan power stations. In 2019, compulsory purchase of the land was authorised by President Erdoğan, and diversion of Hurman Creek would allow more access to Elbistan coalfield as well as supplying the plant's cooling water.
In 2020 Kahramanmaraş deputy Sefer Aycan, from the Nationalist Movement Party, called for a parliamentary investigation. In mid-2021 Global Energy Monitor listed the plant's status as "pre-permit development", and negotiations with Chinese companies continued. But later in 2021 China stopped funding overseas coal power.
Coal
The plant would be supplied by a nearby opencast lignite mine owned by Maiden Holdings. According to a 2019 report to JORC standards there are 950 million tons of reserves, with the average energy value of coal of 1,145 Kcal/kg. Seam depths are 50 – 175 m, moisture content 53%, ash content 20% and sulfur content 1.2%.
Economics
The plant was planned to operate for 35 years and was proposed to be funded the Turkey Wealth Fund (TWF), the country's sovereign wealth fund, being a major partner. The TWF plans to pay dividends to the treasury by 2025. This is in accordance with the energy policy of Turkey, which prioritises local sources of energy to reduce coal and natural gas imports, partly in order to maintain energy security. Verus Partners advised on finance, but despite low production costs, the private sector was not interested, as the coal is low-quality. The TWF claims the plant would have an economic life of 35 years, create "serious employment", and Vice President Fuat Oktay said in 2020 that it would reduce the current account deficit. According to Carbon Tracker, new wind and solar power plants are cheaper than building new coal-power plants.
Technology
The station is planned to run 6,948 hours per year to generate 11,380 GWh. By using a supercritical boiler, the plant will be more efficient and emit less local air pollution than all other large (over 400 MW) local lignite-fuelled power stations in Turkey, as they use subcritical boilers. According to Turkey Wealth Fund General Manager Zafer Sonmez, the plant will be environmentally friendly, using the latest emission control technologies. But, according to campaign group "Right to Clean Air Platform", it would still result in thousands of early deaths over the lifetime of the plant. Cooling water would be supplied from Hurman Creek via the forthcoming Karakuz Dam, to be built by TOKİ, which will also run a small hydropower plant and supply water for irrigation. According to Climate Action Network Europe the plant would increase the risk of drought in the area. Construction materials would be transported via a forthcoming Afşin ring road.
Greenhouse gas emissions
The Afşin-Elbistan C environmental impact assessment (EIA) estimated emissions would be more than 60 million tonnes of per year: and it was accepted by the government. By comparison, total annual greenhouse gas emissions by Turkey are about 520 million tonnes; thus more than a tenth of greenhouse gas emissions by Turkey would be from the planned power station. Therefore, if built, at over 5 kg of per kWh generated it would be less carbon efficient than any coal-fired power station on the list of least carbon efficient power stations. , for comparison, the world's largest single emitter is Secunda CTL, which emits 56.5 million tonnes a year. Space-based measurements of carbon dioxide means the public will know the level of emissions almost in real time.
Opposition
Ali Öztunç, local MP and environment spokesperson for the main opposition Republican People's Party, has spoken out against the plant and asked in a parliamentary question why it should be built on agricultural land. Environmentalists claim the country already has too much capacity and contend that the plant will damage local water resources. Environmental and public health groups criticised the EIA for describing coal as clean energy and, in February 2020, thousands of people filed petitions against its approval: but it was approved by the Ministry of Environment and Urbanisation in March. In November 2021 an expert report commissioned by the Maraş Regional Administrative Court said that the EIA positive decision given to Afşin-Elbistan C was faulty as it failed to accurately assess the project's impact on agricultural activities, environmental pollution, water basins and human health: the court has yet to decide whether to cancel the EIA decision. In December 2021 environmental group TEMA Foundation said that, as Turkey had recently ratified the Paris Agreement to limit climate change, the plans to build the plant should be immediately abandoned.
Notes
References
Bibliography
UNFCCC reports
External links
Afşin-Elbistan power complex at Global Energy Monitor
Report on health effects(in Turkish) by the Right to Clean Air Platform Turkey
Coal-fired power stations in Turkey
Greenhouse gas emissions
Proposed power stations in Turkey
|
```c
/*****************************************************************************
* predict-c.c: intra prediction
*****************************************************************************
*
* Authors: Laurent Aimar <fenrir@via.ecp.fr>
* Loren Merritt <lorenm@u.washington.edu>
* Fiona Glaser <fiona@x264.com>
*
* This program is free software; you can redistribute it and/or modify
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
*
* along with this program; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02111, USA.
*
* This program is also available under a commercial proprietary license.
* For more information, contact us at licensing@x264.com.
*****************************************************************************/
#include "common/common.h"
#include "predict.h"
#include "pixel.h"
#define PREDICT_P_SUM(j,i)\
H += i * ( src[j+i - FDEC_STRIDE ] - src[j-i - FDEC_STRIDE ] );\
V += i * ( src[(j+i)*FDEC_STRIDE -1] - src[(j-i)*FDEC_STRIDE -1] );
#if HAVE_X86_INLINE_ASM
#if HIGH_BIT_DEPTH
ALIGNED_16( static const int16_t pw_12345678[8] ) = {1,2,3,4,5,6,7,8};
ALIGNED_16( static const int16_t pw_m87654321[8] ) = {-8,-7,-6,-5,-4,-3,-2,-1};
ALIGNED_16( static const int16_t pw_m32101234[8] ) = {-3,-2,-1,0,1,2,3,4};
#else // !HIGH_BIT_DEPTH
ALIGNED_8( static const int8_t pb_12345678[8] ) = {1,2,3,4,5,6,7,8};
ALIGNED_8( static const int8_t pb_m87654321[8] ) = {-8,-7,-6,-5,-4,-3,-2,-1};
ALIGNED_8( static const int8_t pb_m32101234[8] ) = {-3,-2,-1,0,1,2,3,4};
#endif // HIGH_BIT_DEPTH
#endif // HAVE_X86_INLINE_ASM
#define PREDICT_16x16_P_CORE\
int H = 0;\
int V = 0;\
PREDICT_P_SUM(7,1)\
PREDICT_P_SUM(7,2)\
PREDICT_P_SUM(7,3)\
PREDICT_P_SUM(7,4)\
PREDICT_P_SUM(7,5)\
PREDICT_P_SUM(7,6)\
PREDICT_P_SUM(7,7)\
PREDICT_P_SUM(7,8)
#define PREDICT_16x16_P_END(name)\
int a = 16 * ( src[15*FDEC_STRIDE -1] + src[15 - FDEC_STRIDE] );\
int b = ( 5 * H + 32 ) >> 6;\
int c = ( 5 * V + 32 ) >> 6;\
int i00 = a - b * 7 - c * 7 + 16;\
/* b*15 + c*15 can overflow: it's easier to just branch away in this rare case
* than to try to consider it in the asm. */\
if( BIT_DEPTH > 8 && (i00 > 0x7fff || abs(b) > 1092 || abs(c) > 1092) )\
x264_predict_16x16_p_c( src );\
else\
x264_predict_16x16_p_core_##name( src, i00, b, c );
#define PREDICT_16x16_P(name, name2)\
static void x264_predict_16x16_p_##name( pixel *src )\
{\
PREDICT_16x16_P_CORE\
PREDICT_16x16_P_END(name2)\
}
#if HAVE_X86_INLINE_ASM
#if HIGH_BIT_DEPTH
#define PREDICT_16x16_P_ASM\
asm (\
"movdqu %1, %%xmm1 \n"\
"movdqa %2, %%xmm0 \n"\
"pmaddwd %3, %%xmm0 \n"\
"pmaddwd %4, %%xmm1 \n"\
"paddd %%xmm1, %%xmm0 \n"\
"movhlps %%xmm0, %%xmm1 \n"\
"paddd %%xmm1, %%xmm0 \n"\
"pshuflw $14, %%xmm0, %%xmm1 \n"\
"paddd %%xmm1, %%xmm0 \n"\
"movd %%xmm0, %0 \n"\
:"=r"(H)\
:"m"(src[-FDEC_STRIDE-1]), "m"(src[-FDEC_STRIDE+8]),\
"m"(*pw_12345678), "m"(*pw_m87654321)\
);
#else // !HIGH_BIT_DEPTH
#define PREDICT_16x16_P_ASM\
asm (\
"movq %1, %%mm1 \n"\
"movq %2, %%mm0 \n"\
"palignr $7, %3, %%mm1 \n"\
"pmaddubsw %4, %%mm0 \n"\
"pmaddubsw %5, %%mm1 \n"\
"paddw %%mm1, %%mm0 \n"\
"pshufw $14, %%mm0, %%mm1 \n"\
"paddw %%mm1, %%mm0 \n"\
"pshufw $1, %%mm0, %%mm1 \n"\
"paddw %%mm1, %%mm0 \n"\
"movd %%mm0, %0 \n"\
"movswl %w0, %0 \n"\
:"=r"(H)\
:"m"(src[-FDEC_STRIDE]), "m"(src[-FDEC_STRIDE+8]),\
"m"(src[-FDEC_STRIDE-8]), "m"(*pb_12345678), "m"(*pb_m87654321)\
);
#endif // HIGH_BIT_DEPTH
#define PREDICT_16x16_P_CORE_INLINE\
int H, V;\
PREDICT_16x16_P_ASM\
V = 8 * ( src[15*FDEC_STRIDE-1] - src[-1*FDEC_STRIDE-1] )\
+ 7 * ( src[14*FDEC_STRIDE-1] - src[ 0*FDEC_STRIDE-1] )\
+ 6 * ( src[13*FDEC_STRIDE-1] - src[ 1*FDEC_STRIDE-1] )\
+ 5 * ( src[12*FDEC_STRIDE-1] - src[ 2*FDEC_STRIDE-1] )\
+ 4 * ( src[11*FDEC_STRIDE-1] - src[ 3*FDEC_STRIDE-1] )\
+ 3 * ( src[10*FDEC_STRIDE-1] - src[ 4*FDEC_STRIDE-1] )\
+ 2 * ( src[ 9*FDEC_STRIDE-1] - src[ 5*FDEC_STRIDE-1] )\
+ 1 * ( src[ 8*FDEC_STRIDE-1] - src[ 6*FDEC_STRIDE-1] );
#define PREDICT_16x16_P_INLINE(name, name2)\
static void x264_predict_16x16_p_##name( pixel *src )\
{\
PREDICT_16x16_P_CORE_INLINE\
PREDICT_16x16_P_END(name2)\
}
#else // !HAVE_X86_INLINE_ASM
#define PREDICT_16x16_P_INLINE(name, name2) PREDICT_16x16_P(name, name2)
#endif // HAVE_X86_INLINE_ASM
#if HIGH_BIT_DEPTH
PREDICT_16x16_P_INLINE( sse2, sse2 )
#else // !HIGH_BIT_DEPTH
#if !ARCH_X86_64
PREDICT_16x16_P( mmx2, mmx2 )
#endif // !ARCH_X86_64
PREDICT_16x16_P( sse2, sse2 )
#if HAVE_X86_INLINE_ASM
PREDICT_16x16_P_INLINE( ssse3, sse2 )
#endif // HAVE_X86_INLINE_ASM
PREDICT_16x16_P_INLINE( avx, avx )
#endif // HIGH_BIT_DEPTH
PREDICT_16x16_P_INLINE( avx2, avx2 )
#define PREDICT_8x16C_P_CORE\
int H = 0, V = 0;\
for( int i = 0; i < 4; i++ )\
H += ( i + 1 ) * ( src[4 + i - FDEC_STRIDE] - src[2 - i - FDEC_STRIDE] );\
for( int i = 0; i < 8; i++ )\
V += ( i + 1 ) * ( src[-1 + (i+8)*FDEC_STRIDE] - src[-1 + (6-i)*FDEC_STRIDE] );
#if HIGH_BIT_DEPTH
#define PREDICT_8x16C_P_END(name)\
int a = 16 * ( src[-1 + 15*FDEC_STRIDE] + src[7 - FDEC_STRIDE] );\
int b = ( 17 * H + 16 ) >> 5;\
int c = ( 5 * V + 32 ) >> 6;\
x264_predict_8x16c_p_core_##name( src, a, b, c );
#else // !HIGH_BIT_DEPTH
#define PREDICT_8x16C_P_END(name)\
int a = 16 * ( src[-1 + 15*FDEC_STRIDE] + src[7 - FDEC_STRIDE] );\
int b = ( 17 * H + 16 ) >> 5;\
int c = ( 5 * V + 32 ) >> 6;\
int i00 = a -3*b -7*c + 16;\
x264_predict_8x16c_p_core_##name( src, i00, b, c );
#endif // HIGH_BIT_DEPTH
#define PREDICT_8x16C_P(name)\
static void x264_predict_8x16c_p_##name( pixel *src )\
{\
PREDICT_8x16C_P_CORE\
PREDICT_8x16C_P_END(name)\
}
#if !ARCH_X86_64 && !HIGH_BIT_DEPTH
PREDICT_8x16C_P( mmx2 )
#endif // !ARCH_X86_64 && !HIGH_BIT_DEPTH
PREDICT_8x16C_P( sse2 )
PREDICT_8x16C_P( avx )
PREDICT_8x16C_P( avx2 )
#define PREDICT_8x8C_P_CORE\
int H = 0;\
int V = 0;\
PREDICT_P_SUM(3,1)\
PREDICT_P_SUM(3,2)\
PREDICT_P_SUM(3,3)\
PREDICT_P_SUM(3,4)
#if HIGH_BIT_DEPTH
#define PREDICT_8x8C_P_END(name)\
int a = 16 * ( src[7*FDEC_STRIDE -1] + src[7 - FDEC_STRIDE] );\
int b = ( 17 * H + 16 ) >> 5;\
int c = ( 17 * V + 16 ) >> 5;\
x264_predict_8x8c_p_core_##name( src, a, b, c );
#else // !HIGH_BIT_DEPTH
#define PREDICT_8x8C_P_END(name)\
int a = 16 * ( src[7*FDEC_STRIDE -1] + src[7 - FDEC_STRIDE] );\
int b = ( 17 * H + 16 ) >> 5;\
int c = ( 17 * V + 16 ) >> 5;\
int i00 = a -3*b -3*c + 16;\
x264_predict_8x8c_p_core_##name( src, i00, b, c );
#endif // HIGH_BIT_DEPTH
#define PREDICT_8x8C_P(name, name2)\
static void x264_predict_8x8c_p_##name( pixel *src )\
{\
PREDICT_8x8C_P_CORE\
PREDICT_8x8C_P_END(name2)\
}
#if HAVE_X86_INLINE_ASM
#if HIGH_BIT_DEPTH
#define PREDICT_8x8C_P_ASM\
asm (\
"movdqa %1, %%xmm0 \n"\
"pmaddwd %2, %%xmm0 \n"\
"movhlps %%xmm0, %%xmm1 \n"\
"paddd %%xmm1, %%xmm0 \n"\
"pshuflw $14, %%xmm0, %%xmm1 \n"\
"paddd %%xmm1, %%xmm0 \n"\
"movd %%xmm0, %0 \n"\
:"=r"(H)\
:"m"(src[-FDEC_STRIDE]), "m"(*pw_m32101234)\
);
#else // !HIGH_BIT_DEPTH
#define PREDICT_8x8C_P_ASM\
asm (\
"movq %1, %%mm0 \n"\
"pmaddubsw %2, %%mm0 \n"\
"pshufw $14, %%mm0, %%mm1 \n"\
"paddw %%mm1, %%mm0 \n"\
"pshufw $1, %%mm0, %%mm1 \n"\
"paddw %%mm1, %%mm0 \n"\
"movd %%mm0, %0 \n"\
"movswl %w0, %0 \n"\
:"=r"(H)\
:"m"(src[-FDEC_STRIDE]), "m"(*pb_m32101234)\
);
#endif // HIGH_BIT_DEPTH
#define PREDICT_8x8C_P_CORE_INLINE\
int H, V;\
PREDICT_8x8C_P_ASM\
V = 1 * ( src[4*FDEC_STRIDE -1] - src[ 2*FDEC_STRIDE -1] )\
+ 2 * ( src[5*FDEC_STRIDE -1] - src[ 1*FDEC_STRIDE -1] )\
+ 3 * ( src[6*FDEC_STRIDE -1] - src[ 0*FDEC_STRIDE -1] )\
+ 4 * ( src[7*FDEC_STRIDE -1] - src[-1*FDEC_STRIDE -1] );\
H += -4 * src[-1*FDEC_STRIDE -1];
#define PREDICT_8x8C_P_INLINE(name, name2)\
static void x264_predict_8x8c_p_##name( pixel *src )\
{\
PREDICT_8x8C_P_CORE_INLINE\
PREDICT_8x8C_P_END(name2)\
}
#else // !HAVE_X86_INLINE_ASM
#define PREDICT_8x8C_P_INLINE(name, name2) PREDICT_8x8C_P(name, name2)
#endif // HAVE_X86_INLINE_ASM
#if HIGH_BIT_DEPTH
PREDICT_8x8C_P_INLINE( sse2, sse2 )
#else //!HIGH_BIT_DEPTH
#if !ARCH_X86_64
PREDICT_8x8C_P( mmx2, mmx2 )
#endif // !ARCH_X86_64
PREDICT_8x8C_P( sse2, sse2 )
#if HAVE_X86_INLINE_ASM
PREDICT_8x8C_P_INLINE( ssse3, sse2 )
#endif // HAVE_X86_INLINE_ASM
#endif // HIGH_BIT_DEPTH
PREDICT_8x8C_P_INLINE( avx, avx )
PREDICT_8x8C_P_INLINE( avx2, avx2 )
#if ARCH_X86_64 && !HIGH_BIT_DEPTH
static void x264_predict_8x8c_dc_left( uint8_t *src )
{
int y;
uint32_t s0 = 0, s1 = 0;
uint64_t dc0, dc1;
for( y = 0; y < 4; y++ )
{
s0 += src[y * FDEC_STRIDE - 1];
s1 += src[(y+4) * FDEC_STRIDE - 1];
}
dc0 = (( s0 + 2 ) >> 2) * 0x0101010101010101ULL;
dc1 = (( s1 + 2 ) >> 2) * 0x0101010101010101ULL;
for( y = 0; y < 4; y++ )
{
M64( src ) = dc0;
src += FDEC_STRIDE;
}
for( y = 0; y < 4; y++ )
{
M64( src ) = dc1;
src += FDEC_STRIDE;
}
}
#endif // ARCH_X86_64 && !HIGH_BIT_DEPTH
/****************************************************************************
* Exported functions:
****************************************************************************/
void x264_predict_16x16_init_mmx( int cpu, x264_predict_t pf[7] )
{
if( !(cpu&X264_CPU_MMX2) )
return;
pf[I_PRED_16x16_V] = x264_predict_16x16_v_mmx2;
pf[I_PRED_16x16_H] = x264_predict_16x16_h_mmx2;
#if HIGH_BIT_DEPTH
if( !(cpu&X264_CPU_SSE) )
return;
pf[I_PRED_16x16_V] = x264_predict_16x16_v_sse;
if( !(cpu&X264_CPU_SSE2) )
return;
pf[I_PRED_16x16_DC] = x264_predict_16x16_dc_sse2;
pf[I_PRED_16x16_DC_TOP] = x264_predict_16x16_dc_top_sse2;
pf[I_PRED_16x16_DC_LEFT] = x264_predict_16x16_dc_left_sse2;
pf[I_PRED_16x16_H] = x264_predict_16x16_h_sse2;
pf[I_PRED_16x16_P] = x264_predict_16x16_p_sse2;
if( !(cpu&X264_CPU_AVX) )
return;
pf[I_PRED_16x16_V] = x264_predict_16x16_v_avx;
if( !(cpu&X264_CPU_AVX2) )
return;
pf[I_PRED_16x16_H] = x264_predict_16x16_h_avx2;
#else
#if !ARCH_X86_64
pf[I_PRED_16x16_P] = x264_predict_16x16_p_mmx2;
#endif
if( !(cpu&X264_CPU_SSE) )
return;
pf[I_PRED_16x16_V] = x264_predict_16x16_v_sse;
if( !(cpu&X264_CPU_SSE2) )
return;
pf[I_PRED_16x16_DC] = x264_predict_16x16_dc_sse2;
if( cpu&X264_CPU_SSE2_IS_SLOW )
return;
pf[I_PRED_16x16_DC_TOP] = x264_predict_16x16_dc_top_sse2;
pf[I_PRED_16x16_DC_LEFT] = x264_predict_16x16_dc_left_sse2;
pf[I_PRED_16x16_P] = x264_predict_16x16_p_sse2;
if( !(cpu&X264_CPU_SSSE3) )
return;
if( !(cpu&X264_CPU_SLOW_PSHUFB) )
pf[I_PRED_16x16_H] = x264_predict_16x16_h_ssse3;
#if HAVE_X86_INLINE_ASM
pf[I_PRED_16x16_P] = x264_predict_16x16_p_ssse3;
#endif
if( !(cpu&X264_CPU_AVX) )
return;
pf[I_PRED_16x16_P] = x264_predict_16x16_p_avx;
#endif // HIGH_BIT_DEPTH
if( cpu&X264_CPU_AVX2 )
{
pf[I_PRED_16x16_P] = x264_predict_16x16_p_avx2;
pf[I_PRED_16x16_DC] = x264_predict_16x16_dc_avx2;
pf[I_PRED_16x16_DC_TOP] = x264_predict_16x16_dc_top_avx2;
pf[I_PRED_16x16_DC_LEFT] = x264_predict_16x16_dc_left_avx2;
}
}
void x264_predict_8x8c_init_mmx( int cpu, x264_predict_t pf[7] )
{
if( !(cpu&X264_CPU_MMX) )
return;
#if HIGH_BIT_DEPTH
pf[I_PRED_CHROMA_V] = x264_predict_8x8c_v_mmx;
if( !(cpu&X264_CPU_MMX2) )
return;
pf[I_PRED_CHROMA_DC] = x264_predict_8x8c_dc_mmx2;
pf[I_PRED_CHROMA_H] = x264_predict_8x8c_h_mmx2;
if( !(cpu&X264_CPU_SSE) )
return;
pf[I_PRED_CHROMA_V] = x264_predict_8x8c_v_sse;
if( !(cpu&X264_CPU_SSE2) )
return;
pf[I_PRED_CHROMA_DC] = x264_predict_8x8c_dc_sse2;
pf[I_PRED_CHROMA_DC_TOP] = x264_predict_8x8c_dc_top_sse2;
pf[I_PRED_CHROMA_H] = x264_predict_8x8c_h_sse2;
pf[I_PRED_CHROMA_P] = x264_predict_8x8c_p_sse2;
if( !(cpu&X264_CPU_AVX) )
return;
pf[I_PRED_CHROMA_P] = x264_predict_8x8c_p_avx;
if( !(cpu&X264_CPU_AVX2) )
return;
pf[I_PRED_CHROMA_H] = x264_predict_8x8c_h_avx2;
#else
#if ARCH_X86_64
pf[I_PRED_CHROMA_DC_LEFT] = x264_predict_8x8c_dc_left;
#endif
pf[I_PRED_CHROMA_V] = x264_predict_8x8c_v_mmx;
if( !(cpu&X264_CPU_MMX2) )
return;
pf[I_PRED_CHROMA_DC_TOP] = x264_predict_8x8c_dc_top_mmx2;
pf[I_PRED_CHROMA_H] = x264_predict_8x8c_h_mmx2;
#if !ARCH_X86_64
pf[I_PRED_CHROMA_P] = x264_predict_8x8c_p_mmx2;
#endif
pf[I_PRED_CHROMA_DC] = x264_predict_8x8c_dc_mmx2;
if( !(cpu&X264_CPU_SSE2) )
return;
pf[I_PRED_CHROMA_P] = x264_predict_8x8c_p_sse2;
if( !(cpu&X264_CPU_SSSE3) )
return;
pf[I_PRED_CHROMA_H] = x264_predict_8x8c_h_ssse3;
#if HAVE_X86_INLINE_ASM
pf[I_PRED_CHROMA_P] = x264_predict_8x8c_p_ssse3;
#endif
if( !(cpu&X264_CPU_AVX) )
return;
pf[I_PRED_CHROMA_P] = x264_predict_8x8c_p_avx;
#endif // HIGH_BIT_DEPTH
if( cpu&X264_CPU_AVX2 )
{
pf[I_PRED_CHROMA_P] = x264_predict_8x8c_p_avx2;
}
}
void x264_predict_8x16c_init_mmx( int cpu, x264_predict_t pf[7] )
{
if( !(cpu&X264_CPU_MMX) )
return;
#if HIGH_BIT_DEPTH
if( !(cpu&X264_CPU_MMX2) )
return;
pf[I_PRED_CHROMA_DC] = x264_predict_8x16c_dc_mmx2;
pf[I_PRED_CHROMA_H] = x264_predict_8x16c_h_mmx2;
if( !(cpu&X264_CPU_SSE) )
return;
pf[I_PRED_CHROMA_V] = x264_predict_8x16c_v_sse;
if( !(cpu&X264_CPU_SSE2) )
return;
pf[I_PRED_CHROMA_DC_TOP] = x264_predict_8x16c_dc_top_sse2;
pf[I_PRED_CHROMA_DC] = x264_predict_8x16c_dc_sse2;
pf[I_PRED_CHROMA_H] = x264_predict_8x16c_h_sse2;
pf[I_PRED_CHROMA_P] = x264_predict_8x16c_p_sse2;
if( !(cpu&X264_CPU_AVX) )
return;
pf[I_PRED_CHROMA_P] = x264_predict_8x16c_p_avx;
if( !(cpu&X264_CPU_AVX2) )
return;
pf[I_PRED_CHROMA_H] = x264_predict_8x16c_h_avx2;
#else
pf[I_PRED_CHROMA_V] = x264_predict_8x16c_v_mmx;
if( !(cpu&X264_CPU_MMX2) )
return;
pf[I_PRED_CHROMA_DC_TOP] = x264_predict_8x16c_dc_top_mmx2;
pf[I_PRED_CHROMA_DC] = x264_predict_8x16c_dc_mmx2;
pf[I_PRED_CHROMA_H] = x264_predict_8x16c_h_mmx2;
#if !ARCH_X86_64
pf[I_PRED_CHROMA_P] = x264_predict_8x16c_p_mmx2;
#endif
if( !(cpu&X264_CPU_SSE2) )
return;
pf[I_PRED_CHROMA_P] = x264_predict_8x16c_p_sse2;
if( !(cpu&X264_CPU_SSSE3) )
return;
pf[I_PRED_CHROMA_H] = x264_predict_8x16c_h_ssse3;
if( !(cpu&X264_CPU_AVX) )
return;
pf[I_PRED_CHROMA_P] = x264_predict_8x16c_p_avx;
#endif // HIGH_BIT_DEPTH
if( cpu&X264_CPU_AVX2 )
{
pf[I_PRED_CHROMA_P] = x264_predict_8x16c_p_avx2;
}
}
void x264_predict_8x8_init_mmx( int cpu, x264_predict8x8_t pf[12], x264_predict_8x8_filter_t *predict_8x8_filter )
{
if( !(cpu&X264_CPU_MMX2) )
return;
#if HIGH_BIT_DEPTH
if( !(cpu&X264_CPU_SSE) )
return;
pf[I_PRED_8x8_V] = x264_predict_8x8_v_sse;
if( !(cpu&X264_CPU_SSE2) )
return;
pf[I_PRED_8x8_H] = x264_predict_8x8_h_sse2;
pf[I_PRED_8x8_DC] = x264_predict_8x8_dc_sse2;
pf[I_PRED_8x8_DC_TOP] = x264_predict_8x8_dc_top_sse2;
pf[I_PRED_8x8_DC_LEFT]= x264_predict_8x8_dc_left_sse2;
pf[I_PRED_8x8_DDL] = x264_predict_8x8_ddl_sse2;
pf[I_PRED_8x8_DDR] = x264_predict_8x8_ddr_sse2;
pf[I_PRED_8x8_VL] = x264_predict_8x8_vl_sse2;
pf[I_PRED_8x8_VR] = x264_predict_8x8_vr_sse2;
pf[I_PRED_8x8_HD] = x264_predict_8x8_hd_sse2;
pf[I_PRED_8x8_HU] = x264_predict_8x8_hu_sse2;
*predict_8x8_filter = x264_predict_8x8_filter_sse2;
if( !(cpu&X264_CPU_SSSE3) )
return;
pf[I_PRED_8x8_DDL] = x264_predict_8x8_ddl_ssse3;
pf[I_PRED_8x8_DDR] = x264_predict_8x8_ddr_ssse3;
pf[I_PRED_8x8_HD] = x264_predict_8x8_hd_ssse3;
pf[I_PRED_8x8_HU] = x264_predict_8x8_hu_ssse3;
pf[I_PRED_8x8_VL] = x264_predict_8x8_vl_ssse3;
pf[I_PRED_8x8_VR] = x264_predict_8x8_vr_ssse3;
*predict_8x8_filter = x264_predict_8x8_filter_ssse3;
if( cpu&X264_CPU_CACHELINE_64 )
{
pf[I_PRED_8x8_DDL]= x264_predict_8x8_ddl_cache64_ssse3;
pf[I_PRED_8x8_DDR]= x264_predict_8x8_ddr_cache64_ssse3;
}
if( !(cpu&X264_CPU_AVX) )
return;
pf[I_PRED_8x8_HD] = x264_predict_8x8_hd_avx;
pf[I_PRED_8x8_HU] = x264_predict_8x8_hu_avx;
pf[I_PRED_8x8_VL] = x264_predict_8x8_vl_avx;
pf[I_PRED_8x8_VR] = x264_predict_8x8_vr_avx;
*predict_8x8_filter = x264_predict_8x8_filter_avx;
#else
pf[I_PRED_8x8_V] = x264_predict_8x8_v_mmx2;
pf[I_PRED_8x8_H] = x264_predict_8x8_h_mmx2;
pf[I_PRED_8x8_DC] = x264_predict_8x8_dc_mmx2;
pf[I_PRED_8x8_DC_TOP] = x264_predict_8x8_dc_top_mmx2;
pf[I_PRED_8x8_DC_LEFT]= x264_predict_8x8_dc_left_mmx2;
pf[I_PRED_8x8_HD] = x264_predict_8x8_hd_mmx2;
pf[I_PRED_8x8_VL] = x264_predict_8x8_vl_mmx2;
*predict_8x8_filter = x264_predict_8x8_filter_mmx2;
#if ARCH_X86
pf[I_PRED_8x8_DDL] = x264_predict_8x8_ddl_mmx2;
pf[I_PRED_8x8_DDR] = x264_predict_8x8_ddr_mmx2;
pf[I_PRED_8x8_VR] = x264_predict_8x8_vr_mmx2;
pf[I_PRED_8x8_HU] = x264_predict_8x8_hu_mmx2;
#endif
if( !(cpu&X264_CPU_SSE2) )
return;
pf[I_PRED_8x8_DDL] = x264_predict_8x8_ddl_sse2;
pf[I_PRED_8x8_VL] = x264_predict_8x8_vl_sse2;
pf[I_PRED_8x8_VR] = x264_predict_8x8_vr_sse2;
pf[I_PRED_8x8_DDR] = x264_predict_8x8_ddr_sse2;
pf[I_PRED_8x8_HD] = x264_predict_8x8_hd_sse2;
pf[I_PRED_8x8_HU] = x264_predict_8x8_hu_sse2;
if( !(cpu&X264_CPU_SSSE3) )
return;
if( !(cpu&X264_CPU_SLOW_PALIGNR) )
{
pf[I_PRED_8x8_DDL] = x264_predict_8x8_ddl_ssse3;
pf[I_PRED_8x8_VR] = x264_predict_8x8_vr_ssse3;
}
pf[I_PRED_8x8_HU] = x264_predict_8x8_hu_ssse3;
*predict_8x8_filter = x264_predict_8x8_filter_ssse3;
if( !(cpu&X264_CPU_AVX) )
return;
pf[I_PRED_8x8_DDL] = x264_predict_8x8_ddl_avx;
pf[I_PRED_8x8_DDR] = x264_predict_8x8_ddr_avx;
pf[I_PRED_8x8_VL] = x264_predict_8x8_vl_avx;
pf[I_PRED_8x8_VR] = x264_predict_8x8_vr_avx;
pf[I_PRED_8x8_HD] = x264_predict_8x8_hd_avx;
#endif // HIGH_BIT_DEPTH
}
void x264_predict_4x4_init_mmx( int cpu, x264_predict_t pf[12] )
{
if( !(cpu&X264_CPU_MMX2) )
return;
pf[I_PRED_4x4_DC] = x264_predict_4x4_dc_mmx2;
pf[I_PRED_4x4_DDL] = x264_predict_4x4_ddl_mmx2;
pf[I_PRED_4x4_DDR] = x264_predict_4x4_ddr_mmx2;
pf[I_PRED_4x4_VL] = x264_predict_4x4_vl_mmx2;
pf[I_PRED_4x4_HD] = x264_predict_4x4_hd_mmx2;
pf[I_PRED_4x4_HU] = x264_predict_4x4_hu_mmx2;
#if HIGH_BIT_DEPTH
if( !(cpu&X264_CPU_SSE2) )
return;
pf[I_PRED_4x4_DDL] = x264_predict_4x4_ddl_sse2;
pf[I_PRED_4x4_DDR] = x264_predict_4x4_ddr_sse2;
pf[I_PRED_4x4_HD] = x264_predict_4x4_hd_sse2;
pf[I_PRED_4x4_VL] = x264_predict_4x4_vl_sse2;
pf[I_PRED_4x4_VR] = x264_predict_4x4_vr_sse2;
if( !(cpu&X264_CPU_SSSE3) )
return;
pf[I_PRED_4x4_DDR] = x264_predict_4x4_ddr_ssse3;
pf[I_PRED_4x4_VR] = x264_predict_4x4_vr_ssse3;
pf[I_PRED_4x4_HD] = x264_predict_4x4_hd_ssse3;
if( !(cpu&X264_CPU_AVX) )
return;
pf[I_PRED_4x4_DDL] = x264_predict_4x4_ddl_avx;
pf[I_PRED_4x4_DDR] = x264_predict_4x4_ddr_avx;
pf[I_PRED_4x4_HD] = x264_predict_4x4_hd_avx;
pf[I_PRED_4x4_VL] = x264_predict_4x4_vl_avx;
pf[I_PRED_4x4_VR] = x264_predict_4x4_vr_avx;
if( !(cpu&X264_CPU_AVX2) )
return;
pf[I_PRED_4x4_H] = x264_predict_4x4_h_avx2;
#else
pf[I_PRED_4x4_VR] = x264_predict_4x4_vr_mmx2;
if( !(cpu&X264_CPU_SSSE3) )
return;
pf[I_PRED_4x4_DDR] = x264_predict_4x4_ddr_ssse3;
pf[I_PRED_4x4_VR] = x264_predict_4x4_vr_ssse3;
pf[I_PRED_4x4_HD] = x264_predict_4x4_hd_ssse3;
if( cpu&X264_CPU_CACHELINE_64 )
pf[I_PRED_4x4_VR] = x264_predict_4x4_vr_cache64_ssse3;
#endif // HIGH_BIT_DEPTH
}
```
|
Hyrum State Park is a state park and reservoir in Cache County, Utah, United States.
Hyrum State Park is in the northeastern part of Utah. It lies at , and consists of surrounding a reservoir. The park is used for fishing, boating, camping, picnicking, hiking, waterskiing, and swimming.
The park was named for Hyrum Smith, the brother of LDS church founder Joseph Smith.
Hyrum State Park's facilities are located at the northern shore of the reservoir, and include 31 RV campsites, restrooms, showers, a ranger station, boat ramp, dock, and trailheads.
The dam creating Hyrum Reservoir was completed in April, 1935, by the United States Bureau of Reclamation. Prior to that, local settlers had dug a canal from the Little Bear River to the town of Hyrum to irrigate their crops.
Fish in the reservoir include yellow perch, channel catfish, rainbow trout, largemouth bass, and bluegill.
References
External links
Hyrum State Park
Live WebCam - Hyrum State Park
Dams completed in 1935
Dams in Utah
Protected areas of Cache County, Utah
Protected areas established in 1959
State parks of Utah
United States Bureau of Reclamation dams
|
The is a division of the University of Tokyo, Japan dedicated to the study of particle physics. The ICEPP is located on the 10th floor of the Faculty of Science Building #1 at the University of Tokyo.
External links
http://www.icepp.s.u-tokyo.ac.jp/icepp-e.html
University departments in Japan
University of Tokyo
|
Between the Earth and the Stars is the debut album of American country music singer Jeff Wood. It was released on February 11, 1997, through Imprint Records. The album includes the singles "You Just Get One", "Use Mine" and "You Call That a Mountain".
Content
"You Just Get One" was originally recorded by Ty Herndon on his 1995 debut What Mattered Most, and B. J. Thomas later released his version of "You Call That a Mountain" in 2000 from his album of the same name. Billy Hoffman also recorded the song on his 2000 album All I Wanted Was You. Bonnie Tyler covered the title track on her 2019 album of the same name.
Critical reception
Jeffrey B. Remz of Country Standard Time described the album as "pleasant enough sounding" and "usually maintain[ing] country sensibilities" although Remz said that it "produce[d] no surprises". Allmusic critic Jack Leaver, who gave the album two-and-a-half stars out of five, called it "a mostly mellow set[…]that should appeal to the fans of the Dave Loggins-meets-John Berry school of country pop." The San Antonio Express-News called it an "impressive debut".
Track listing
"You Call That a Mountain" (Michael Garvin, Bucky Jones) - 3:26
"Too Late to Turn It Around" (Jeff Wood, John Scott Sherrill, Simon Wilson) - 3:52
"There's No Place Like You" (Wood, Vernon Rust) - 4:11
"Long Way from OK" (Wood, Gary Burr, Pat McDonald) - 3:32
"Time to Move On" (Monty Powell, Eric Silver) - 3:28
"You Just Get One" (Don Schlitz, Vince Gill) - 2:58
"Sure Thing" (Wood, Verlon Thompson) - 3:00
"I Want It All" (Wood, John Tirro) - 3:19
"Use Mine" (Lisa Drew, Steve Seskin) - 4:07
"Between the Earth and the Stars" (Richard Wold, John David) - 4:19
Personnel
As listed in liner notes.
Eddie Bayers - drums
Michael Black - background vocals
Bruce Bouton - steel guitar, Dobro
Mark Casstevens - acoustic guitar, banjo
Mike Chapman - bass guitar
Marty Churchill - background vocals
Larry Franklin - fiddle
Vince Gill - mandolin, guitar solo (track 6)
Nicole Hassman - background vocals
Tim Hensley - background vocals
John Hobbs - keyboards, strings
Dann Huff - electric guitar, 12-string guitar, gut string guitar
Paul Leim - percussion
Greg Morrow - drums
Steve Nathan - strings
Don Potter - acoustic guitar
John Wesley Ryles - background vocals
Eric Silver - mandolin, banjo
Billy Joe Walker Jr. - acoustic guitar
References
Jeff Wood (singer) albums
Imprint Records albums
1997 debut albums
Albums produced by Mark Bright (record producer)
|
John Rungsted Sørensen (born 5 October 1934) is a Danish sprint canoer who competed in the early 1960s. He won the bronze medal in the C-2 1000 m event at the 1964 Summer Olympics in Tokyo.
References
Sports-reference.com profile (As John Rungsted Sorensen)
1934 births
Canoeists at the 1964 Summer Olympics
Danish male canoeists
Living people
Olympic canoeists for Denmark
Olympic bronze medalists for Denmark
Olympic medalists in canoeing
Medalists at the 1964 Summer Olympics
|
Luis Alberto Estaba (born August 13, 1938) is a former boxer from Venezuela, who was born in Macuro, South American point of entry for Cristopher Columbus. He was nicknamed Lumumba, because of his resemblance to Congolese leader Patrice Lumumba.
A late starter into boxing, Estaba became a professional in 1967, at the relatively old (for boxing) age of 29. He beat Pedro Garcia by a knockout in one on February 28 of that year.
He kept his winning streak until losing a ten round decision to Natalio Jimenez in Caracas in 1968. He avenged that loss immediately by beating Jimenez in his next fight, by decision. After two more wins, he had his first fight abroad, when he lost to Jimenez, again by decision, at Santo Domingo.
In 1975, Estaba became boxing's second world champion ever in the Jr. Flyweight division, when he obtained the vacant WBC title by knocking out Rafael Lovera, who was making his professional debut during this world title bout. He knocked Lovera out in round four September 13 of that year. He defended the title 12 times, including victories over former or future world champions Franco Udella, Rafael Pedroza, and Netrnoi Vorasingh. In 1977, he was named Venezuelan Athlete of the Year.
His luck ran out in 1978, when he lost the title to Mexico's Freddie Castillo by a knockout in round 14 on February 19. After beating Ricardo Estupinan by a decision in 15 to win the Central American title in his division, he challenged Vorasingh (who had beaten Castillo) for the world title. Estaba lost by a knockout in five rounds on July 29, in what he knew would be his last fight as a professional, because local Venezuelan boxing laws ban anyone over 40 years old to box professionally, and Estaba turned 40 only two weeks after that fight.
Being forced into retirement, he left the sport of boxing with 41 wins, 9 losses and 2 draws, 27 wins having been by knockout.
See also
List of light-flyweight boxing champions
External links
1938 births
Living people
People from Güiria
Sportspeople from Sucre (state)
Venezuelan male boxers
World Boxing Council champions
Light-flyweight boxers
World light-flyweight boxing champions
|
The Schneider ES-65 Platypus is a two-seater unflapped glider designed and built by Edmund Schneider Pty in Australia. A single prototype was built, which remains operational as of 2012.
Design and development
The Edmund Schneider company was originally based in Grunau, Silesia but reformed after World War II in Adelaide, Australia, producing the successful Schneider ES-60 from 1960 until 1970. Anticipating an Australian market for an ES-60-based side by side two-seater Harry Schneider began design and construction of the ES-64, a marriage of ES-60 wings with a new glass reinforced plastic (GRP) fuselage. Australian gliding clubs showed little interest and the project proceeded slowly. In the early 1980s Schneider revived it with a simplified version, the ES-65 Platypus.
The Platypus has the extended plywood skinned ES-60 wing, built around a single spar. The leading edge is unswept but the straight trailing edges have forward sweep that increases on the outer, aileron-carrying, panels. There are airbrakes mounted just aft of the spar on the inner panels. These wings were mid-mounted onto a new GRP fuselage. This has a maximum width of 1.20 m (3 ft 11 in) to accommodate the side by side seating but narrowed in pod and boom style, particularly in plan, behind the wings. The cockpit has a two-piece fixed screen extending almost to the nose and is accessed via a rear hinged, bulged canopy. The pod includes a fixed, faired, centre-line two wheel undercarriage, with a brake-equipped mainwheel under the wings and a smaller nosewheel.
The tail is also mostly GRP, though the elevator uses carbon fibre for lightness. These surfaces are straight-edged and tapering, the fin is tall with a rudder that extends to the bottom of the fuselage. The high aspect ratio horizontal tail surface is mounted midway up the fin.
The Platypus made its first flight in August 1984 and its handling and performance were generally judged to be good. There were plans to produce an all-GRP version, but the funding required was not available and no more ES-65s were built.
Operational history
The prototype, VH-GFA, is owned by a syndicate of members of the Geelong Gliding Club and of the Victorian Motorless Flight Group based at Bacchus Marsh airfield, Victoria. It was still operational in 2005.
Specifications
References
1980s Australian sailplanes
Glider aircraft
Aircraft first flown in 1984
Cruciform tail aircraft
Edmund Schneider aircraft
Mid-wing aircraft
|
I cherusci is a dramma per musica in 2 acts by Simon Mayr to a libretto by Gaetano Rossi. It was first performed at the Teatro Argentina, Rome, for Carnival 1808. The plot is at the time of the battles between the Germanic tribes the Marcomanni and Cherusci.
Cast
Treuta, tenor - popular leader of the Marcomanni people
Tusnelda, soprano - Treuta's slave, a Cheruscan, but due to be sacrificed by the druids
Tamaro, soprano - enemy leader of the Cherusci and bards
Zarasto, bass - high priest of the druids
Ercilda, soprano - allied with Treuta
Carilo, tenor - leader of the Sarronides, allied with Treuta
Dunclamo, tenor - adoptive father of Tusnelda, who later discovers that Treuta is Tusnelda's father
Araldo, tenor
Recording
I cherusci Bayerische Staatsoper, Franz Hauk. Naxos 2CD 2019
References
Operas
1808 operas
Operas by Simon Mayr
|
Øistein Hermansen (25 July 1919 – 29 March 1992) was a Norwegian politician for the Communist Party.
He served as a deputy representative to the Parliament of Norway from Hedmark during the terms 1954–1957 and 1958–1961. In total he met during 46 days of parliamentary session.
References
1919 births
1992 deaths
People from Åmot
Deputy members of the Storting
Communist Party of Norway politicians
Hedmark politicians
|
```c++
This program is free software; you can redistribute it and/or modify
the Free Software Foundation
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
with this program; if not, write to the Free Software Foundation, Inc.,
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. */
// DlgAutTexturize.cpp : implementation file
//
#include "stdafx.h"
#include "WorldEditor.h"
#include "DlgAutTexturize.h"
#ifdef _DEBUG
#undef new
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif
/////////////////////////////////////////////////////////////////////////////
// CDlgAutTexturize dialog
CDlgAutTexturize::CDlgAutTexturize(CWnd* pParent /*=NULL*/)
: CDialog(CDlgAutTexturize::IDD, pParent)
{
//{{AFX_DATA_INIT(CDlgAutTexturize)
m_bExpandEdges = FALSE;
//}}AFX_DATA_INIT
m_pixWidth=1;
m_pixHeight=1;
}
void CDlgAutTexturize::DoDataExchange(CDataExchange* pDX)
{
// if dialog is receiving data
if( pDX->m_bSaveAndValidate == FALSE)
{
CWorldEditorDoc* pDoc = theApp.GetActiveDocument();
COLOR colOld=pDoc->m_woWorld.wo_colBackground;
colOld=AfxGetApp()->GetProfileInt( L"World editor", L"Pretender bcg color", colOld);
m_bExpandEdges=TRUE;
m_bExpandEdges=AfxGetApp()->GetProfileInt( L"World editor", L"Auto expand edges", m_bExpandEdges);
m_colBcg.SetColor(colOld);
m_colBcg.SetPickerType( CColoredButton::PT_MFC);
}
CDialog::DoDataExchange(pDX);
//{{AFX_DATA_MAP(CDlgAutTexturize)
DDX_Control(pDX, IDC_PRETENDER_TEXTURE_STYLE, m_ctrlPretenderTextureStyle);
DDX_Control(pDX, ID_SECTOR_COLOR, m_colBcg);
DDX_Control(pDX, IDC_PRETENDER_TEXTURE_SIZE, m_ctrPretenderTextureSize);
DDX_Check(pDX, IDC_EXPAND_EDGES, m_bExpandEdges);
//}}AFX_DATA_MAP
// if dialog gives data
if( pDX->m_bSaveAndValidate != FALSE)
{
INDEX iSelected=m_ctrPretenderTextureSize.GetCurSel();
if( iSelected==CB_ERR) return;
m_pixWidth=1<<iSelected;
m_pixHeight=1<<iSelected;
COLOR colResult=m_colBcg.GetColor();
AfxGetApp()->WriteProfileInt( L"World editor", L"Pretender bcg color", m_colBcg.GetColor());
AfxGetApp()->WriteProfileInt( L"World editor", L"Pretender resolution", iSelected);
AfxGetApp()->WriteProfileInt( L"World editor", L"Auto expand edges", m_bExpandEdges);
m_iPretenderStyle=m_ctrlPretenderTextureStyle.GetCurSel();
AfxGetApp()->WriteProfileInt( L"World editor", L"Pretender style", m_iPretenderStyle);
}
}
BEGIN_MESSAGE_MAP(CDlgAutTexturize, CDialog)
//{{AFX_MSG_MAP(CDlgAutTexturize)
//}}AFX_MSG_MAP
END_MESSAGE_MAP()
/////////////////////////////////////////////////////////////////////////////
// CDlgAutTexturize message handlers
BOOL CDlgAutTexturize::OnInitDialog()
{
CDialog::OnInitDialog();
m_ctrPretenderTextureSize.ResetContent();
// add all available frictions
for(INDEX iW=0; iW<10; iW++)
{
CTString strSize;
strSize.PrintF("%dx%d pixels", 1<<iW, 1<<iW);
m_ctrPretenderTextureSize.AddString( CString(strSize));
}
INDEX iSelected=6;
iSelected=AfxGetApp()->GetProfileInt( L"World editor", L"Pretender resolution", iSelected);
m_ctrPretenderTextureSize.SetCurSel(iSelected);
m_ctrlPretenderTextureStyle.ResetContent();
m_ctrlPretenderTextureStyle.AddString( L"Front view only");
m_ctrlPretenderTextureStyle.AddString( L"Cylindrical view (FRBL)");
m_ctrlPretenderTextureStyle.AddString( L"Boxed view (FRBLUD)");
iSelected=1;
iSelected=AfxGetApp()->GetProfileInt( L"World editor", L"Pretender style", iSelected);
m_ctrlPretenderTextureStyle.SetCurSel(iSelected);
return TRUE;
}
```
|
```objective-c
/*
** $Id: lzio.h,v 1.31 2015/09/08 15:41:05 roberto Exp $
** Buffered streams
*/
#ifndef lzio_h
#define lzio_h
#include "lua.h"
#include "lmem.h"
#define EOZ (-1) /* end of stream */
typedef struct Zio ZIO;
#define zgetc(z) (((z)->n--)>0 ? cast_uchar(*(z)->p++) : luaZ_fill(z))
typedef struct Mbuffer {
char *buffer;
size_t n;
size_t buffsize;
} Mbuffer;
#define luaZ_initbuffer(L, buff) ((buff)->buffer = NULL, (buff)->buffsize = 0)
#define luaZ_buffer(buff) ((buff)->buffer)
#define luaZ_sizebuffer(buff) ((buff)->buffsize)
#define luaZ_bufflen(buff) ((buff)->n)
#define luaZ_buffremove(buff,i) ((buff)->n -= (i))
#define luaZ_resetbuffer(buff) ((buff)->n = 0)
#define luaZ_resizebuffer(L, buff, size) \
((buff)->buffer = luaM_reallocvchar(L, (buff)->buffer, \
(buff)->buffsize, size), \
(buff)->buffsize = size)
#define luaZ_freebuffer(L, buff) luaZ_resizebuffer(L, buff, 0)
LUAI_FUNC void luaZ_init (lua_State *L, ZIO *z, lua_Reader reader,
void *data);
LUAI_FUNC size_t luaZ_read (ZIO* z, void *b, size_t n); /* read next n bytes */
/* --------- Private Part ------------------ */
struct Zio {
size_t n; /* bytes still unread */
const char *p; /* current position in buffer */
lua_Reader reader; /* reader function */
void *data; /* additional data */
lua_State *L; /* Lua state (for reader) */
};
LUAI_FUNC int luaZ_fill (ZIO *z);
#endif
```
|
```php
<?php
/*
*
*
* path_to_url
*
* Unless required by applicable law or agreed to in writing, software
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
*/
namespace Google\Service\CloudRetail;
class GoogleCloudRetailV2CompleteQueryResponseCompletionResult extends \Google\Model
{
protected $attributesType = GoogleCloudRetailV2CustomAttribute::class;
protected $attributesDataType = 'map';
/**
* @var string
*/
public $suggestion;
/**
* @param GoogleCloudRetailV2CustomAttribute[]
*/
public function setAttributes($attributes)
{
$this->attributes = $attributes;
}
/**
* @return GoogleCloudRetailV2CustomAttribute[]
*/
public function getAttributes()
{
return $this->attributes;
}
/**
* @param string
*/
public function setSuggestion($suggestion)
{
$this->suggestion = $suggestion;
}
/**
* @return string
*/
public function getSuggestion()
{
return $this->suggestion;
}
}
// Adding a class alias for backwards compatibility with the previous class name.
class_alias(GoogleCloudRetailV2CompleteQueryResponseCompletionResult::class, your_sha256_hashnseCompletionResult');
```
|
```c
/* $OpenBSD: s_catanh.c,v 1.7 2016/09/12 19:47:02 guenther Exp $ */
/*
*
* Permission to use, copy, modify, and distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
* copyright notice and this permission notice appear in all copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/
/* catanh
*
* Complex inverse hyperbolic tangent
*
*
*
* SYNOPSIS:
*
* double complex catanh();
* double complex z, w;
*
* w = catanh (z);
*
*
*
* DESCRIPTION:
*
* Inverse tanh, equal to -i catan (iz);
*
* ACCURACY:
*
* Relative error:
* arithmetic domain # trials peak rms
* IEEE -10,+10 30000 2.3e-16 6.2e-17
*
*/
#include <complex.h>
#include <float.h>
#include <math.h>
double complex
catanh(double complex z)
{
double complex w;
w = -1.0 * I * catan (z * I);
return (w);
}
DEF_STD(catanh);
LDBL_MAYBE_UNUSED_CLONE(catanh);
```
|
```smalltalk
"
A custom transform morph for a morphic based tree
"
Class {
#name : 'MorphTreeTransformMorph',
#superclass : 'TransformMorph',
#category : 'Morphic-Widgets-Tree',
#package : 'Morphic-Widgets-Tree'
}
{ #category : 'submorphs - add/remove' }
MorphTreeTransformMorph >> addAllMorphs: aCollection after: anotherMorph [
^self privateAddAllMorphs: aCollection
atIndex: (anotherMorph index ifNil: [submorphs size])
]
{ #category : 'drawing' }
MorphTreeTransformMorph >> bottomVisibleRowForCanvas: aCanvas [
"return the bottom visible row in aCanvas's clip rectangle"
^ self rowAtLocation: (aCanvas clipRect bottomRight)
]
{ #category : 'drawing' }
MorphTreeTransformMorph >> bottomVisibleRowForCanvas: aCanvas startingAt: aPos [
"return the bottom visible row in aCanvas's clip rectangle"
^ self rowAtLocation: (aCanvas clipRect bottomRight) startingAt: aPos
]
{ #category : 'drawing' }
MorphTreeTransformMorph >> drawRawColorOn: aCanvas forSubmorph: aSubMorph [
| frame |
frame := (aSubMorph fullBounds withWidth: owner scroller innerBounds width) translateBy: owner scroller offset x @ 0.
aSubMorph = owner listManager searchedElement ifTrue: [
aCanvas fillRectangle: frame color: owner secondarySelectionColor.
^ self ].
owner listManager isCheckList
ifTrue: [
aSubMorph = owner listManager lastClickedMorph ifTrue: [
aCanvas fillRectangle: frame color: owner selectionColorToUse.
^ self ] ]
ifFalse: [
aSubMorph selected ifTrue: [
aCanvas fillRectangle: frame color: owner selectionColorToUse.
^ self ] ].
aSubMorph color ifNotNil: [ :subMorphColor |
subMorphColor isColor
ifTrue: [
aCanvas
frameAndFillRectangle: frame
fillColor: subMorphColor
borderWidth: 0
borderColor: Color transparent ]
ifFalse: [
subMorphColor origin: aSubMorph bounds topLeft.
subMorphColor direction: aSubMorph bounds width @ 0.
aCanvas fillRectangle: frame basicFillStyle: subMorphColor ] ]
]
{ #category : 'drawing' }
MorphTreeTransformMorph >> drawSubmorphsOn: aCanvas [
submorphs ifEmpty: [^ self].
aCanvas transformBy: transform
clippingTo: (aCanvas clipRect intersect: (owner clippingBounds) ifNone: ["we're done here" ^ self ])
during: [:myCanvas | | top bottom |
top := self topVisibleRowForCanvas: myCanvas.
bottom := self bottomVisibleRowForCanvas: myCanvas startingAt: top.
bottom
to: top
by: -1
do: [:row | | m |
m := submorphs basicAt: row.
self drawRawColorOn: myCanvas forSubmorph: m.
myCanvas fullDrawMorph: m] ]
smoothing: smoothing.
owner withTreeLines ifTrue: [owner drawLinesOn: aCanvas].
owner enabled ifFalse: [ aCanvas fillRectangle: owner innerBounds fillStyle: (owner paneColor alpha: 0.2) ]
]
{ #category : 'geometry' }
MorphTreeTransformMorph >> fullBounds [
"Overridden to clip submorph hit detection to my bounds."
"It might be better to override doLayoutIn:, and remove this method"
fullBounds ifNotNil:[^ fullBounds].
fullBounds := bounds.
^ fullBounds
]
{ #category : 'initialization' }
MorphTreeTransformMorph >> initialize [
super initialize.
self smoothingOn
]
{ #category : 'layout' }
MorphTreeTransformMorph >> localSubmorphBounds [
"Answer, in my coordinate system, the bounds of all my visible submorphs (or nil if no visible submorphs)"
localBounds ifNil: [
self hasSubmorphs ifFalse: [^ nil].
localBounds := self firstSubmorph fullBounds topLeft corner: owner maxNodeWidth @ (self lastSubmorph fullBounds bottom + owner extraScrollRange)].
^ localBounds
]
{ #category : 'private' }
MorphTreeTransformMorph >> privateAddAllMorphs: aCollection atIndex: index [
"Private. Add aCollection of morphs to the receiver"
submorphs := Array
new: submorphs size + aCollection size
streamContents: [:str |
1 to: index do: [:p | str nextPut: (submorphs atWrap: p)].
str nextPutAll: aCollection.
index + 1 to: submorphs size do: [:p | str nextPut: (submorphs atWrap: p)]].
aCollection do: [:m |
m fullBounds.
m privateOwner: self].
self layoutChanged
]
{ #category : 'change reporting' }
MorphTreeTransformMorph >> privateInvalidateMorph: aMorph [
]
{ #category : 'drawing' }
MorphTreeTransformMorph >> rowAtLocation: aPoint [
"return the number of the row at aPoint"
| y |
y := aPoint y.
submorphs ifEmpty: [^ nil].
submorphs doWithIndex: [:m :idx | m topLeft y >= y ifTrue: [^ (idx - 1) max: 1]].
^ submorphs size
]
{ #category : 'drawing' }
MorphTreeTransformMorph >> rowAtLocation: aPoint startingAt: aPosition [
"return the number of the row at aPoint"
| y |
y := aPoint y.
submorphs ifEmpty: [^ nil].
aPosition to: submorphs size do: [ :idx | | m |
m := submorphs basicAt: idx.
m topLeft y >= y ifTrue: [^ (idx - 1) max: 1]].
^ submorphs size
]
{ #category : 'layout' }
MorphTreeTransformMorph >> submorphBounds [
"Private. Compute the actual full bounds of the receiver, optimized for speed"
self hasSubmorphs ifFalse: [^ nil].
^ self firstSubmorph topLeft corner: owner scroller bounds bottomLeft + (0@ owner extraScrollRange)
]
{ #category : 'drawing' }
MorphTreeTransformMorph >> topVisibleRowForCanvas: aCanvas [
"return the top visible row in aCanvas's clip rectangle"
^ self rowAtLocation: (aCanvas clipRect topLeft)
]
{ #category : 'drawing' }
MorphTreeTransformMorph >> topVisibleRowForCanvas: aCanvas startingAt: aPos [
"return the top visible row in aCanvas's clip rectangle"
^ self rowAtLocation: (aCanvas clipRect topLeft) startingAt: aPos
]
{ #category : 'testing' }
MorphTreeTransformMorph >> wantsSteps [
^ false
]
```
|
```css
.c1,.c1:hover{
color: #fff;
border-color: #3c8b3c;
background: #4cae4c;
background: -webkit-linear-gradient(top,#4cae4c 0,#449d44 100%);
background: -moz-linear-gradient(top,#4cae4c 0,#449d44 100%);
background: -o-linear-gradient(top,#4cae4c 0,#449d44 100%);
background: linear-gradient(to bottom,#4cae4c 0,#449d44 100%);
filter: progid:DXImageTransform.Microsoft.gradient(startColorstr=#4cae4c,endColorstr=#449d44,GradientType=0);
}
a.c1:hover{
background: #449d44;
filter: none;
}
.c2,.c2:hover{
color: #fff;
border-color: #5f5f5f;
background: #747474;
background: -webkit-linear-gradient(top,#747474 0,#676767 100%);
background: -moz-linear-gradient(top,#747474 0,#676767 100%);
background: -o-linear-gradient(top,#747474 0,#676767 100%);
background: linear-gradient(to bottom,#747474 0,#676767 100%);
filter: progid:DXImageTransform.Microsoft.gradient(startColorstr=#747474,endColorstr=#676767,GradientType=0);
}
a.c2:hover{
background: #676767;
filter: none;
}
.c3,.c3:hover{
color: #333;
border-color: #ff8080;
background: #ffb3b3;
background: -webkit-linear-gradient(top,#ffb3b3 0,#ff9999 100%);
background: -moz-linear-gradient(top,#ffb3b3 0,#ff9999 100%);
background: -o-linear-gradient(top,#ffb3b3 0,#ff9999 100%);
background: linear-gradient(to bottom,#ffb3b3 0,#ff9999 100%);
filter: progid:DXImageTransform.Microsoft.gradient(startColorstr=#ffb3b3,endColorstr=#ff9999,GradientType=0);
}
a.c3:hover{
background: #ff9999;
filter: none;
}
.c4,.c4:hover{
color: #333;
border-color: #52d689;
background: #b8eecf;
background: -webkit-linear-gradient(top,#b8eecf 0,#a4e9c1 100%);
background: -moz-linear-gradient(top,#b8eecf 0,#a4e9c1 100%);
background: -o-linear-gradient(top,#b8eecf 0,#a4e9c1 100%);
background: linear-gradient(to bottom,#b8eecf 0,#a4e9c1 100%);
filter: progid:DXImageTransform.Microsoft.gradient(startColorstr=#b8eecf,endColorstr=#a4e9c1,GradientType=0);
}
a.c4:hover{
background: #a4e9c1;
filter: none;
}
.c5,.c5:hover{
color: #fff;
border-color: #b52b27;
background: #d84f4b;
background: -webkit-linear-gradient(top,#d84f4b 0,#c9302c 100%);
background: -moz-linear-gradient(top,#d84f4b 0,#c9302c 100%);
background: -o-linear-gradient(top,#d84f4b 0,#c9302c 100%);
background: linear-gradient(to bottom,#d84f4b 0,#c9302c 100%);
filter: progid:DXImageTransform.Microsoft.gradient(startColorstr=#d84f4b,endColorstr=#c9302c,GradientType=0);
}
a.c5:hover{
background: #c9302c;
filter: none;
}
.c6,.c6:hover{
color: #fff;
border-color: #1f637b;
background: #2984a4;
background: -webkit-linear-gradient(top,#2984a4 0,#24748f 100%);
background: -moz-linear-gradient(top,#2984a4 0,#24748f 100%);
background: -o-linear-gradient(top,#2984a4 0,#24748f 100%);
background: linear-gradient(to bottom,#2984a4 0,#24748f 100%);
filter: progid:DXImageTransform.Microsoft.gradient(startColorstr=#2984a4,endColorstr=#24748f,GradientType=0);
}
a.c6:hover{
background: #24748f;
filter: none;
}
.c7,.c7:hover{
color: #333;
border-color: #e68900;
background: #ffab2e;
background: -webkit-linear-gradient(top,#ffab2e 0,#ff9900 100%);
background: -moz-linear-gradient(top,#ffab2e 0,#ff9900 100%);
background: -o-linear-gradient(top,#ffab2e 0,#ff9900 100%);
background: linear-gradient(to bottom,#ffab2e 0,#ff9900 100%);
filter: progid:DXImageTransform.Microsoft.gradient(startColorstr=#ffab2e,endColorstr=#ff9900,GradientType=0);
}
a.c7:hover{
background: #ff9900;
filter: none;
}
.c8,.c8:hover{
color: #fff;
border-color: #4b72a4;
background: #698cba;
background: -webkit-linear-gradient(top,#698cba 0,#577eb2 100%);
background: -moz-linear-gradient(top,#698cba 0,#577eb2 100%);
background: -o-linear-gradient(top,#698cba 0,#577eb2 100%);
background: linear-gradient(to bottom,#698cba 0,#577eb2 100%);
filter: progid:DXImageTransform.Microsoft.gradient(startColorstr=#698cba,endColorstr=#577eb2,GradientType=0);
}
a.c8:hover{
background: #577eb2;
filter: none;
}
```
|
Thorsten Schmidt (born 14 October 1978) is a German rower. He competed in the men's lightweight coxless four event at the 2000 Summer Olympics.
References
External links
1978 births
Living people
German male rowers
Olympic rowers for Germany
Rowers at the 2000 Summer Olympics
Sportspeople from Bonn
|
The parvorder Catarrhini , catarrhine monkeys, Old World anthropoids, or Old World monkeys, consists of the Cercopithecoidea and apes (Hominoidea). In 1812, Geoffroy grouped those two groups together and established the name Catarrhini, "Old World monkeys", ("singes de l'Ancien Monde" in French). Its sister in the infraorder Simiiformes is the parvorder Platyrrhini (New World monkeys). There has been some resistance to directly designate apes (and thus humans) as monkeys despite the scientific evidence, so "Old World monkey" may be taken to mean the Cercopithecoidea or the Catarrhini. That apes are monkeys was already realized by Georges-Louis Leclerc, Comte de Buffon in the 18th century. Linnaeus placed this group in 1758 together with what we now recognise as the tarsiers and the New World monkeys, in a single genus "Simia" (sans Homo). The Catarrhini are all native to Africa and Asia. Members of this parvorder are called catarrhines.
The Catarrhini are the sister group to the New World monkeys, the Platyrrhini. Some six million years before the ape - Cercopithecoidea bifurcation, the Platyrrhini emerged within "monkeys" by migration to South America from Afro-Arabia (the Old World), likely by ocean.
Description
The technical distinction between the New World platyrrhines and Old World catarrhines is the shape of their noses. The platyrrhines (from Ancient Greek platy-, "flat", and rhin-, "nose") have nostrils which face sideways. The catarrhines (from Ancient Greek katà-, "down", and rhin-, "nose") have nostrils that face downwards. Catarrhines also never have prehensile tails, and have flat fingernails and toenails, a tubular ectotympanic (ear bone), and eight, not 12, premolars, giving them a dental formula of , indicating 2 incisors, 1 canine, 2 premolars, and 3 molars on each side of the upper and lower jaws.
Most catarrhine species show considerable sexual dimorphism and do not form a pair bond. Most, but not all, species live in social groups. Like the platyrrhines, the catarrhines are generally diurnal, and have grasping hands and (with the exception of bipedal humans) grasping feet.
The apes – in both traditional and phylogenic nomenclature – are exclusively catarrhine species. In traditional usage, ape describes any tailless, larger, and more typically ground-dwelling species of catarrhine. "Ape" may be found as part of the common name of such species, such as the Barbary ape. In phylogenic usage, the term ape applies only to the superfamily Hominoidea. This grouping comprises the two families Hylobatidae, the lesser apes or gibbons, and Hominidae, the great apes, including orangutans, gorillas, chimpanzees, bonobos, humans, and related extinct genera, such as the prehuman australopithecines and the giant orangutan relative Gigantopithecus.
Classification and evolution
According to Schrago & Russo, New World monkeys split from their Old World kin about 35 million years ago (Mya). They use the major catarrhine division between cercopithecoids and hominoids of about 25 Mya (which they argue is strongly supported by the fossil evidence), as a calibration point, and from this also calculate the gibbons separating from the great apes (including humans) about 15-19 Mya.
According to Begun and Harrison, the Catarrhini split from their New World monkey kin about 44 - 40 Mya, with the first catarrhines appearing in Africa and Arabia, and not appearing in Eurasia (outside Arabia) until 18-17 Mya.
Catarrhini lost the enzyme Alpha-galactosidase, present in all other mammal lineages, sometime after the split from platyrrhini. It is hypothesized that an ancient pathogen containing Alpha-galactosidase may be responsible, as only individuals with mutations that "turned off" the gene for Alpha-galactosidase would have produced antibodies against the pathogen and survived.
The distinction between apes and monkeys is complicated by the traditional paraphyly of monkeys: apes emerged as a sister group of Old World monkeys in the catarrhines, which are a sister group of New World monkeys. Therefore, cladistically, apes, catarrhines and related contemporary extinct groups such as Parapithecidae are monkeys as well, for any consistent definition of "monkey". "Old World Monkey" may also legitimately be taken to be meant to include all the catarrhines, including apes and extinct species such as Aegyptopithecus, in which case the apes, Cercopithecoidea and Aegyptopithecus emerged within the Old World Monkeys. Although the colloquial usage of terms like ape and monkey in English reflects a misconception about their true biological relationship, this is not the case in some other languages; for example, in Russian, the same term is used to describe all simians, both with and without tails, including apes.
Order Primates
Suborder Strepsirrhini: lemurs, lorises, etc.
Suborder Haplorhini: tarsiers + monkeys, including apes
Infraorder Tarsiiformes
Family Tarsiidae: tarsiers
Infraorder Simiiformes : simians (monkeys, including apes), or higher primates
Parvorder Catarrhini
Superfamily †Propliopithecoidea
Family †Propliopithecidae (includes Aegyptopithecus)
Superfamily †Pliopithecoidea
Family †Dionysopithecidae
Family †Pliopithecidae
Superfamily †Dendropithecoidea
Family †Dendropithecidae
Superfamily †Saadanioidea
Family †Saadaniidae
Superfamily Cercopithecoidea
Family Cercopithecidae
Superfamily Hominoidea : apes
Family Hylobatidae: gibbons
Family Hominidae: great apes (including humans)
Parvorder Platyrrhini: New World monkeys
Cladogram
Below is a cladogram with extinct species in which the crown Catharrhini, which emerged in the Propliopithecoidea. Also, Saadanioidea is sister of the Cercopithecoidea rather than of the Crown Catarrhini here. It is indicated how many million years ago (Mya) the clades diverged into newer clades.
The Platyrrhini may have emerged in e.g. the Oligopithecidae. The Saadanioidea may be sister to the Propliopithecoidea s.s., and Micropithecus may be sister to the Taqah Propliopithecids.
References
Monkeys
Extant Eocene first appearances
Taxa named by Étienne Geoffroy Saint-Hilaire
Taxa described in 1812
|
```objective-c
//
// OperationViewController.h
// AppDevKit
//
// Created by Chih Feng Sung on 12/1/15.
// Please see the LICENSE file in the project root for terms.
//
#import <UIKit/UIKit.h>
@interface OperationViewController : UIViewController
@end
```
|
```javascript
/**
* @license Apache-2.0
*
*
*
* path_to_url
*
* Unless required by applicable law or agreed to in writing, software
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*/
'use strict';
/**
* Create an iterator which cumulatively tests whether at least `n` iterated values are truthy.
*
* @module @stdlib/iter/cusome
*
* @example
* var array2iterator = require( '@stdlib/array/to-iterator' );
* var iterCuSome = require( '@stdlib/iter/cusome' );
*
* var arr = array2iterator( [ 0, 0, 1, 1, 0 ] );
*
* var it = iterCuSome( arr, 2 );
*
* var v = it.next().value;
* // returns false
*
* v = it.next().value;
* // returns false
*
* v = it.next().value;
* // returns false
*
* v = it.next().value;
* // returns true
*
* v = it.next().value;
* // returns true
*
* var bool = it.next().done;
* // returns true
*/
// MODULES //
var main = require( './main.js' );
// EXPORTS //
module.exports = main;
```
|
```php
<?php
namespace Illuminate\Encryption;
use Illuminate\Support\ServiceProvider;
use Illuminate\Support\Str;
use Laravel\SerializableClosure\SerializableClosure;
use Opis\Closure\SerializableClosure as OpisSerializableClosure;
class EncryptionServiceProvider extends ServiceProvider
{
/**
* Register the service provider.
*
* @return void
*/
public function register()
{
$this->registerEncrypter();
$this->registerOpisSecurityKey();
$this->registerSerializableClosureSecurityKey();
}
/**
* Register the encrypter.
*
* @return void
*/
protected function registerEncrypter()
{
$this->app->singleton('encrypter', function ($app) {
$config = $app->make('config')->get('app');
return new Encrypter($this->parseKey($config), $config['cipher']);
});
}
/**
* Configure Opis Closure signing for security.
*
* @return void
*
* @deprecated Will be removed in a future Laravel version.
*/
protected function registerOpisSecurityKey()
{
if (\PHP_VERSION_ID < 80100) {
$config = $this->app->make('config')->get('app');
if (! class_exists(OpisSerializableClosure::class) || empty($config['key'])) {
return;
}
OpisSerializableClosure::setSecretKey($this->parseKey($config));
}
}
/**
* Configure Serializable Closure signing for security.
*
* @return void
*/
protected function registerSerializableClosureSecurityKey()
{
$config = $this->app->make('config')->get('app');
if (! class_exists(SerializableClosure::class) || empty($config['key'])) {
return;
}
SerializableClosure::setSecretKey($this->parseKey($config));
}
/**
* Parse the encryption key.
*
* @param array $config
* @return string
*/
protected function parseKey(array $config)
{
if (Str::startsWith($key = $this->key($config), $prefix = 'base64:')) {
$key = base64_decode(Str::after($key, $prefix));
}
return $key;
}
/**
* Extract the encryption key from the given configuration.
*
* @param array $config
* @return string
*
* @throws \Illuminate\Encryption\MissingAppKeyException
*/
protected function key(array $config)
{
return tap($config['key'], function ($key) {
if (empty($key)) {
throw new MissingAppKeyException;
}
});
}
}
```
|
The 1909 Grand Isle hurricane was a large and deadly Category 3 hurricane that caused severe damage and killed more than 400 people throughout Cuba and the northern coast of the Gulf of Mexico. Forming out of a tropical disturbance just south of Hispaniola on September 13, 1909, the initial depression slowly intensified as it moved west-northwest towards Jamaica. Two days later, the system attained tropical storm intensity and turned northwestward towards Cuba. On September 16, it attained the equivalent of a modern-day Category 1 hurricane on the Saffir–Simpson hurricane scale and further strengthened to attain winds of before making landfall in Pinar del Río Province, Cuba on September 18. After a briefly weakening over land, the system regained strength over the Gulf of Mexico, with peak winds reaching the following day. After only slightly weakening, the hurricane increased in forward motion and made landfall near Grand Isle, Louisiana on September 21. The system quickly lost strength after moving over land, dissipating the following day over Missouri.
In the Caribbean, little impact was known to have been caused by the storm outside of Cuba where rough seas killed 29 people. In the United States, the hurricane wrought catastrophic damage across Louisiana and Mississippi. Throughout these states, 371 people are known to have been killed, making it the sixth deadliest hurricane in United States history at the time; however, it has since been surpassed by five other cyclones. Along the Louisiana coastline, a powerful storm surge penetrated inland, destroying the homes of 5,000 people. Thousands of other homes throughout the affected region lost their roofs and telegraph communication was crippled. In terms of monetary losses, the storm wrought $11 million (1909 USD; $265 million 2010 USD) in damage throughout its path.
Meteorological history
The origins of the Grand Isle hurricane were in a tropical disturbance over the western Atlantic Ocean in early September 1909. Enhanced by a strong area of high pressure over the Azores and British Isles, the system was able to gradually intensify as it neared the Lesser Antilles. On September 10, barometric pressures across several of the islands in the eastern Caribbean fell, indicating that a disturbance was moving through the region. According to the Atlantic hurricane database, maintained by the National Hurricane Center, the system developed into a tropical depression south of Hispaniola in the Caribbean on September 13. However, meteorologist José Fernández Partagás stated that there was no evidence of a closed circulation, a key component of tropical cyclones, until September 14. Tracking west-northwestward, the depression brushed the coast of Haiti before attaining tropical storm intensity off the northwestern coast of Jamaica on September 15.
After reaching this strength, the storm slowed and gradually took a more northwesterly course, heading towards Pinar del Río Province in western Cuba. On September 16, the system attained winds of , what would now be considered a Category 1 hurricane on the Saffir–Simpson hurricane scale. Moving at a slow pace of , the system gradually intensified. Late on September 18, the center of the storm was estimated to have made landfall in Pinar del Río Province with winds of ; an atmospheric pressure of 976 mbar (hPa; ) was recorded during its passage. The storm's eye passed over the town of Manta for four hours, between 3:00 pm and 7:00 pm on September 17.
Slight weakening took place after moving over western Cuba; however, once over the Gulf of Mexico, the storm steadily regained its strength. By September 19, the system re-attained the equivalent intensity of a Category 2 hurricane and the forward motion increased. Early that morning, the storm further intensified to attain its peak winds of , equivalent to a mid-range Category 3 cyclone. By the afternoon of September 19, reports from the Louisiana and Mississippi coastline indicated that the outer bands of the hurricane were producing scattered rainfall.
Early on September 21, it was estimated that the center of the hurricane made landfall near Grand Isle, Louisiana with winds of . A pressure of 952 mbar (hPa; ) was recorded around this time, the lowest in relation to the storm. Operational analysis of the storm indicated that it attained the equivalent intensity of a Category 4 hurricane as it made landfall. The storm's lowest pressure was also operationally listed as 931 mbar (hPa; ). This pressure was based on operational estimates in relation to the system's storm surge and was not directly measured. However, later research of the storm determined that its winds had not exceeded . At this time, the hurricane's radius of maximum wind was roughly and the overall size of the storm was estimated to be wide. Once overland, the system quickly weakened, losing hurricane status within 12 hours and later to a tropical depression over southern Missouri. The remnants of the system were last noted on September 22 as it merged with a trough over the Midwestern United States.
Impact
In western Cuba, the hurricane brought strong winds and heavy rains to several areas. A maximum of of rain fell in a 24‑hour span, while the strongest recorded winds reached . Numerous buildings in western Cuba sustained extensive damage and a large portion of the orange crop was lost. Ships were pushed onshore by the hurricane's large swells. Throughout Pinar del Río Province, damage was estimated at $1 million (1909 USD). Amidst rough seas produced by the hurricane, the steamship Nicholas Castina sank off the coast of Cuba, near the Isle of Pines. At least 29 people drowned in the wreck. Of the fatalities, 27 were crew members and two were passengers.
United States
Prior to the hurricane's arrival in the United States, the National Weather Bureau issued several hurricane warnings. As the storm passed over western Cuba, warnings were declared for much of the Gulf Coast of Florida and all ships in the Gulf or planning to set sail were advised return and remain at port. Warnings were then issued for the northern Gulf Coast, allowing residents time to evacuate before the storm struck.
In the United States, the storm wrought extensive damage along the Gulf Coast. At least 371 people were killed by the storm; however, this is considered a conservative estimate and the true death toll may never be known. Of the known fatalities, 353 took place in Louisiana and 18 in Mississippi. This makes the 1909 Grand Isle hurricane the eleventh deadliest hurricane in United States history. However, at the time of its occurrence, it was the sixth deadliest storm in the country. Damage throughout Louisiana and Mississippi was estimated to be at least $10 million (1909 USD).
Louisiana
In New Orleans, the storm caused substantial damage, with many homes destroyed and ships wrecked. Communication with the city was completely lost after most of the telegraph wires were downed. Around 3:00 pm on September 21, advisories from the New Orleans Weather Bureau ceased, leading to concerns over the state of the city. Prior to the communication loss, the Weather Bureau reported that waves along the Mississippi River banks were surpassing and water rise in New Orleans itself could reach unprecedented levels. Several lakes overflowed their banks as water from the Mississippi River back-flowed into them, flooding nearby lowlands. The resulting floods, which inundated areas with upwards of of water, were similar in scale to the flooding caused by Hurricane Katrina in 2005, nearly 100 years later. However, due to the lack of residential buildings in the area at the time, the flooding caused far less destruction than that of Katrina. A report falsely claimed that the city's French Quarter was "swept away". A total of 306 coal barges sank off the coast of New Orleans and Lobdell (West Baton Rouge Parish), incurring over $1 million in losses. Nearly every sugar cane plantation between New Orleans and Baton Rouge sustained damage, resulting in at least $1 million in losses.
Strong winds from the hurricane lifted homes off their foundations and in some cases, the homes were blown away from where they originally stood. Many towns in Louisiana were isolated immediately after the storm as telegraph communication was lost. Along a stretch of coastline near where the storm made landfall, a storm surge destroyed the homes of 5,000 people and traveled inland. At least 300 of the fatalities took place in southeastern Louisiana, the hardest hit region. Many people who were boating on the Mississippi River and the Gulf of Mexico were caught in the storm's winds and officials presumed that all who were caught in this perished. Near the Texas border, it was estimated that two-thirds of the unharvested rice crop was ruined by the hurricane. In Baton Rouge alone, damage from the hurricane was estimated at $2.9 million (1909 USD). Throughout Louisiana, a total of 353 people were killed by the hurricane according to the National Oceanic and Atmospheric Administration. A maximum of of rain fell in the state during the passage of the hurricane.
Elsewhere
At least 18 fatalities also took place in Mississippi where many towns and cities were flooded. The cities of Natchez and Greenville were mostly destroyed by the hurricane. In Natchez, winds up to blew roofs off homes and shut down the local power station, leaving the city in darkness. Telegraph wires were also downed, cutting communication with the surrounding area. The Biloxi Bay Bridge was swamped by large waves and it was thought that it would be destroyed by the storm at one point. Although the bridge held through the storm, one person died after being washed away while crossing it. Initial estimates stated that damage in Biloxi was between $40,000 and $50,000 (1909 USD). Along a stretch of beach in Mississippi, all of the homes and of the electric car line were destroyed by the hurricane's storm surge. Further north in Jackson, communication in the city was lost and the dome of the newly constructed capital building was destroyed by high winds. Two people were killed in the city after being crushed by falling walls. A maximum of of rain fell in Mississippi during the passage of the hurricane.
In areas in and around Pensacola, Florida, winds caused some damage. At the local pier, a ship, named Romanoff, toppled over onto a wharf due to large waves produced by the hurricane. Two barges carrying lumber sank near the western beach of Pensacola and several others lost their cargo. Many small ships were destroyed by large swells and according to The New York Times, some of these were "...swamped and pounded into pieces". Further inland, the remnants of the hurricane brought light to moderate rainfall to portions of the central United States. A maximum of of rain fell in Arkansas; in Missouri; in Tennessee; and in Kentucky. A section of the Louisville and Nashville railroad and an section of the Illinois central railroad were washed out by floods caused by the storm's remnants.
Aftermath
Although the storm killed more than 370 people in the United States, the National Weather Bureau was credited for "invaluable warnings" prior to the hurricane's arrival, saving many lives. Following the hurricane's landfall on September 21, rescue and relief efforts began taking place on September 22 near Houma, Louisiana. By September 25, thousands of dollars worth of supplies had been sent to survivors of the storm. However, more than four days after the passage of the storm, many other areas devastated by the hurricane had yet to receive aid from either the government or United States Army. Congressman Robert F. Broussard sent a telegraph to the war department requesting aid; however, he had not received a response by September 27. Initially, news reports focused on the large loss of life from the storm but, once the lack of aid was noticed, their attention shifted to the hundreds of survivors who were left homeless and in dire need of basic necessities. Within days of the storm's passage, there were fears that the storm ruined the cotton crop in southern Louisiana and would cause a spike in prices. However, in a report released on October 4, 1909, it was stated that the losses were much less than previously thought and as a result, there would be no change in the cotton price. According to a report in 2009, the rice and cotton crops sustained 35% and 20% losses respectively in the wake of the hurricane.
In 2002, the National Oceanic and Atmospheric Administration added the storm surge from the hurricane to the Global Tsunami Database based on newspaper reports referring to the event as a tidal wave. However, four years later, a more detailed study of possible tsunamis in the past resulted in this event being "flagged" as suspect. After further review of the news articles indicating that the wave came after the hurricane, it was determined that there was a misinterpretation of the publishing date since the article was archived by telegraph on September 22, 1909, the day after the hurricane made landfall. In light of this research, the possibility of the wave being a tsunami was denied; however, it remains in the database as a "debunked" event.
See also
Hurricane Ida (2021)
1909 Atlantic hurricane season
References
General
Specific
External links
Monthly Weather Review for 1909
Category 3 Atlantic hurricanes
Grand Isle
Hurricanes in Louisiana
Hurricanes in Alabama
Hurricanes in Mississippi
Grand Isle Hurricane, 1909
Hurricanes in Cuba
1909 natural disasters in the United States
|
Maxwell Herbert Blumfield (14 August 1922 – 20 September 2011) was an Australian rules footballer and umpire who played for South Melbourne in the Victorian Football League (VFL) during the 1940s.
Playing career
Blumfield was recruited from Amateur premiers Elsternwick and he began playing with the South Melbourne reserves in 1941. A rover, he made his VFL debut in round 9, 1943 against Carlton and played all of South's remaining games that season. Blumfield played intermittently over the next three years spending most of the time in the reserves. His only senior final came in the 1945 Second-semi when he was selected to replace regular rover Reg Richards who was suffering from influenza. Despite playing well and kicking one goal, he was named emergency for the following week's 'Bloodbath' grand final when Richards recovered health. Blumfield made three VFL appearances in early 1946 before leaving for Prahran (VFA) where he played in the Reserve Grade premiership team that season.
He was the uncle of former Essendon player Justin Blumfield.
Umpiring career
Blumfield joined the VFL Reserve Grade umpires in 1947 and the following season was one of 29 promoted to the VFL senior list. In 1949 he umpired four Victorian Country Football League (VCFL) finals including the Euroa District League Grand Final. His first VFL Reserve Grade match was in July 1951 and in August he made his debut in the VFL in round 15 at Glenferrie Oval. He finished the season with three VFL matches and the Ovens and Murray Football League Preliminary and Grand Finals.
From 1952 to 1954 Blumfield umpired 31 out of a possible 38 VFL home and away rounds. This included the 1952 Footscray versus St. Kilda match at Yallourn as part of National Day.
On 2 August 1952 Blumfield reported Essendon full-forward John Coleman for abusive language and disputing his decision. In his testimony Blumfield stated, "Coleman said to me 'Go and get a book of rules and read them'. Later Coleman made an insulting remark". Following the guilty verdict and subsequent severe reprimand Blumfield was mobbed and hooted as he left the hearing.
Blumfield's final VFL senior match was in round 10 1954. Later in the season he finished his career with VCFL finals in the Wimmera, Ovens and Murray, Latrobe Valley, Bendigo and Ballarat leagues. In all his career encompassed 37 VFL, 11 VFL Reserve Grade, 90 VCFL and 8 Tasmanian matches in 8 seasons.
Blumfield served the VFL Umpires' Association on the Social Committee from 1951 to 1953 and was a member of the Executive Committee in 1954.
In 1961 he was appointed to the VFL Umpires' Appointment Board, the independent body that appointed and administered umpires for the VFL. Blumfield served as a member of the board from 1961 to 1976. He was chairman in 1965–66 and 1972.
Death
Blumfield died at the Austin Hospital, Melbourne, on 20 September 2011 at 89 years of age.
References
Holmesby, Russell and Main, Jim (2007). The Encyclopedia of AFL Footballers. 7th ed. Melbourne: Bas Publishing.
1922 births
Australian rules footballers from Victoria (state)
Sydney Swans players
Prahran Football Club players
Australian Football League umpires
2011 deaths
|
```makefile
################################################################################
#
# e2tools
#
################################################################################
E2TOOLS_VERSION = 0.0.16.4
E2TOOLS_SITE = $(call github,ndim,e2tools,v$(E2TOOLS_VERSION))
# Source coming from GitHub, no configure included.
E2TOOLS_AUTORECONF = YES
E2TOOLS_LICENSE = GPL-2.0
E2TOOLS_LICENSE_FILES = COPYING
E2TOOLS_DEPENDENCIES = e2fsprogs
E2TOOLS_CONF_ENV = LIBS="-lpthread"
HOST_E2TOOLS_DEPENDENCIES = host-e2fsprogs
HOST_E2TOOLS_CONF_ENV = LIBS="-lpthread"
$(eval $(autotools-package))
$(eval $(host-autotools-package))
```
|
```smalltalk
"
SUnit tests for exceptions
Some of these tests are of the form:
`self assertSuccess: (ExceptionTester new runTest: <<<aSelector>>> )`
For example:
The code of ExceptionTests>>#testDoubleOuterPass is `self assertSuccess: (ExceptionTester new runTest: #doubleOuterPassTest )`.
In this example, <<<aSelector>>> = #doubleOuterPassTest.
Here is how these tests are performed:
- ExceptionTester has instance variables 'log' and 'suiteLog' of type OrderedCollection
- ExceptionTester>>#runTest: adds <<<aSelector>>> as a string to 'suiteLog' and clears 'log'
- ExceptionTester>>#runTest: performs the method named <<<aSelector>>>.
<<<aSelector>>> has an exception-based control flow, and calls methods like #doSomething, #doSomethingElse etc... at some points of it. These methods just add specific strings to 'log' to build a sort of trace of where the execution went.
- If a MyTestError exception would leave method <<<aSelector>>> uncaught, it is caught, the incident is added to 'log', and <<<aSelector>>>'s execution is stopped
- After performing <<<aSelector>>>, ExceptionTester>>#runTest: performs its twin method: <<<aSelector>>>Results (In the example from above, it would be #doubleOuterPassTestResults). This twin method builds the expected value of 'log' by creating an OrderedCollection and filling it with the right specific strings in the expected order.
- ExceptionTester>>#runTest: compares 'log' and the expected value of 'log'. If they are the same, it appends the 'succeeded' string to the '<<<aSelector>>>' string that was stored in 'suiteLog' earlier. If they are different, it appends the 'failed' string instead.
- Finally, ExceptionTests>>#assertSuccess: asserts that the first element of 'suiteLog' ends with the 'suceeded' string
"
Class {
#name : 'ExceptionTest',
#superclass : 'TestCase',
#category : 'Kernel-Tests-Exception',
#package : 'Kernel-Tests',
#tag : 'Exception'
}
{ #category : 'private' }
ExceptionTest >> assertSuccess: anExceptionTester [
self should: [ ( anExceptionTester suiteLog first) endsWith: 'succeeded']
]
{ #category : 'utilities' }
ExceptionTest >> methodSignallingZeroDivide [
^ [ 1 / 0 ]
on: ZeroDivide
do: [ :e | e signal ]
]
{ #category : 'private' }
ExceptionTest >> runCaseManaged [
"We should disable TestEnvironment to avoid any logic for unhandled errors from background processes.
Some tests fork processes to ensure clean no handlers (SUnit catches errors for example)"
^DefaultExecutionEnvironment beActiveDuring: [ self runCase]
]
{ #category : 'private' }
ExceptionTest >> runWithNoHandlers: aBlock [
"Executing the given block directly would go through all handlers of SUnit machinery.
Here we simulate the clean environment with no outer handlers for possible block errors"
| synchSemaphore result |
synchSemaphore := Semaphore new.
[ result := aBlock ensure: [ synchSemaphore signal ] ] forkNamed:
'Test process'.
"we should not wait forever in case of wrong behaviour
(general test timeout is disabled in #runCaseManaged)"
(synchSemaphore waitTimeoutSeconds: 2) ifTrue: [
self error: 'Timeout for block execution' ].
^ result
]
{ #category : 'tests - handling' }
ExceptionTest >> testCaptureIfSignalledWhenStepping [
self deny: Exception captureIfSignalledWhenStepping.
self assert: Error captureIfSignalledWhenStepping.
self deny: (Error allSubclasses anySatisfy: [ :c| c captureIfSignalledWhenStepping]).
self assert: (UnhandledException withAllSubclasses select:[:c| c captureIfSignalledWhenStepping]) size equals: 1.
self assert: (UnhandledException withAllSubclasses select:[:c| c captureIfSignalledWhenStepping]) first identicalTo: Halt
]
{ #category : 'tests' }
ExceptionTest >> testDefaultAction [
"Ensure that the resuming an UnhandledError when the underlying
Exception is resumable, results in the resumption value serving
as the result of the original #signal."
| expected result |
expected := #marker.
self runWithNoHandlers: [
[ result := MyResumableTestError signal ]
on: UnhandledError
do: [ :ex | ex resume: expected ] ].
self assert: result equals: expected
]
{ #category : 'tests' }
ExceptionTest >> testDefaultDescription [
"Tests that the description of an Exception, is the defaultDescription"
|anException|
anException := Exception new.
self assert: anException description equals: anException defaultDescription
]
{ #category : 'tests' }
ExceptionTest >> testDescription [
|anException|
anException := Exception new.
self assert: anException description isNotNil.
self assert: anException description isString.
"If the default exception desciption changes, this test will be broken"
self assert: anException description equals: 'Exception'
]
{ #category : 'tests - exceptiontester' }
ExceptionTest >> testDoubleOuterPass [
self assertSuccess: (ExceptionTester new runTest: #doubleOuterPassTest )
]
{ #category : 'tests - exceptiontester' }
ExceptionTest >> testDoublePassOuter [
self assertSuccess: (ExceptionTester new runTest: #doublePassOuterTest )
]
{ #category : 'tests - exceptiontester' }
ExceptionTest >> testDoubleResume [
self assertSuccess: (ExceptionTester new runTest: #doubleResumeTest )
]
{ #category : 'tests - handling' }
ExceptionTest >> testHandlerContext [
"A test ensuring that when evaluating the action block the exception environment is set to the handler context."
| result |
result := [
[
[ MyResumableTestError signal ]
on: MyTestError
do: [ 'handler 2' ] ]
on: MyResumableTestError
do: [ MyTestError signal ] ]
on: MyTestError
do: [ 'handler 1' ].
self assert: 'handler 1' = result description: 'Incorrect handler'
]
{ #category : 'tests - handling' }
ExceptionTest >> testHandlerFromAction [
"A test ensuring that nested exceptions work as expected."
| result |
result := [
[
[ self error: 'trigger error' ]
on: ZeroDivide
do: [ :ex | 'inner' ] ]
on: Error
do: [ :ex | 3 / 0 ] ]
on: ZeroDivide
do: [ :ex | 'outer' ].
self assert: 'outer' = result description: 'Incorrect handler'
]
{ #category : 'tests - handling' }
ExceptionTest >> testHandlingExceptionSetWithExclusion [
| wasHandled |
wasHandled := false.
self
should: [
[ ZeroDivide signalWithDividend: 1 ]
on: Error, ArithmeticError - ZeroDivide
do: [ :exception |
wasHandled := true.
exception return ] ]
raise: ZeroDivide.
self deny: wasHandled
]
{ #category : 'tests - handling' }
ExceptionTest >> testHandlingWhenThereIsSomeExclusionButDontApplies [
| wasHandled result |
wasHandled := false.
result := [
ZeroDivide signalWithDividend: 1.
2 ]
on: Error - MessageNotUnderstood
do: [ :exception |
wasHandled := true.
exception return ].
self
assert: wasHandled;
assert: result isNil
]
{ #category : 'tests - handling' }
ExceptionTest >> testHandlingWithExclusion [
| wasHandled |
wasHandled := false.
self
should: [
[ ZeroDivide signalWithDividend: 1 ]
on: Error - ZeroDivide
do: [ :exception |
wasHandled := true.
exception return ] ]
raise: ZeroDivide.
self deny: wasHandled
]
{ #category : 'tests - handling' }
ExceptionTest >> testHandlingWithSeveralExclusions [
| wasHandled |
wasHandled := false.
self
should: [
[ ZeroDivide signalWithDividend: 1 ]
on: Error - Warning - ZeroDivide
do: [ :exception |
wasHandled := true.
exception return ] ]
raise: ZeroDivide.
self deny: wasHandled.
self
should: [
[ ZeroDivide signalWithDividend: 1 ]
on: Error - (Warning , ZeroDivide)
do: [ :exception |
wasHandled := true.
exception return ] ]
raise: ZeroDivide.
self deny: wasHandled
]
{ #category : 'tests - handling' }
ExceptionTest >> testHandlingWithSeveralExclusionsAndExceptionSetsHandling [
| wasHandled result |
wasHandled := false.
result := [
ZeroDivide signalWithDividend: 1.
2 ]
on: Error - MessageNotUnderstood - Warning
do: [ :exception |
wasHandled := true.
exception return ].
self
assert: wasHandled;
assert: result isNil.
wasHandled := false.
result := [
ZeroDivide signalWithDividend: 1.
2 ]
on: Error - (MessageNotUnderstood , Warning)
do: [ :exception |
wasHandled := true.
exception return ].
self
assert: wasHandled;
assert: result isNil
]
{ #category : 'tests - exceptiontester' }
ExceptionTest >> testNoTimeout [
self assertSuccess: (ExceptionTester new runTest: #simpleNoTimeoutTest )
]
{ #category : 'tests - exceptiontester' }
ExceptionTest >> testNonResumableFallOffTheEndHandler [
self assertSuccess: (ExceptionTester new runTest: #nonResumableFallOffTheEndHandler )
]
{ #category : 'tests - outer' }
ExceptionTest >> testNonResumableOuter [
self should: [
[Error signal. 4]
on: Error
do: [:ex | ex outer. ex return: 5]
] raise: Error
]
{ #category : 'tests - outer' }
ExceptionTest >> testNonResumablePass [
self should: [
[Error signal. 4]
on: Error
do: [:ex | ex pass. ex return: 5]
] raise: Error
]
{ #category : 'tests - resignal' }
ExceptionTest >> testResignalAs [
| answer |
<ignoreNotImplementedSelectors: #(zork)>
answer := [
[3 zork]
on: ZeroDivide
do: [:ex | ex return: 5]
] on: Error do: [:ex | ex resignalAs: ZeroDivide].
self assert: answer == 5
]
{ #category : 'tests - resignal' }
ExceptionTest >> testResignalAsUnwinds [
<ignoreNotImplementedSelectors: #( zork )>
| unwound answer |
unwound := false.
answer := [
[ 3 zork ]
on: ZeroDivide
do: [ :ex |
self assert: unwound.
ex return: 5 ] ]
on: Error
do: [ :ex |
[ ex resignalAs: ZeroDivide ] ifCurtailed: [
unwound := true ] ].
self assert: answer identicalTo: 5
]
{ #category : 'tests - resignal' }
ExceptionTest >> testResignalExceptionThatHasBeenSignaledTwice [
| shouldBe17 |
shouldBe17 := nil.
[ shouldBe17 := self methodSignallingZeroDivide ]
on: ZeroDivide
do: [ :e | e resume: 17 ].
self assert: shouldBe17 isNotNil
]
{ #category : 'tests - exceptiontester' }
ExceptionTest >> testResumableFallOffTheEndHandler [
self assertSuccess: (ExceptionTester new runTest: #resumableFallOffTheEndHandler )
]
{ #category : 'tests - outer' }
ExceptionTest >> testResumableOuter [
| result |
result := [Notification signal. 4]
on: Notification
do: [:ex | ex outer. ex return: 5].
self assert: result equals: 5
]
{ #category : 'tests - outer' }
ExceptionTest >> testResumablePass [
| result |
result := [ Notification signal.
4 ]
on: Notification
do: [ :ex |
ex pass.
ex return: 5 ].
self assert: result equals: 4
]
{ #category : 'tests' }
ExceptionTest >> testResumeNonresumableUnhandledError [
"Ensure that the resuming an UnhandledError results in
an IllegalResumeAttempt."
| signalOccurred |
self
runWithNoHandlers: [
[[ MyTestError signal ]
on: UnhandledError
do: [ :ex | ex resume: nil ]]
on: IllegalResumeAttempt
do: [:ex | signalOccurred := true. ex return ]].
self assert: signalOccurred
]
{ #category : 'tests - exceptiontester' }
ExceptionTest >> testSignalFromHandlerActionTest [
self assertSuccess: (ExceptionTester new runTest: #signalFromHandlerActionTest )
]
{ #category : 'tests - exceptiontester' }
ExceptionTest >> testSignalWithTag [
| aTag |
aTag := Object new.
[
DomainError signal: 'aMessage' withTag: aTag.
self fail: 'The exception was not signaled'.
] on: DomainError do: [ :e |
self assert: e messageText equals: 'aMessage'.
self assert: e tag equals: aTag.
]
]
{ #category : 'tests - exceptiontester' }
ExceptionTest >> testSimpleEnsure [
self assertSuccess: (ExceptionTester new runTest: #simpleEnsureTest )
]
{ #category : 'tests - exceptiontester' }
ExceptionTest >> testSimpleEnsureTestWithError [
self assertSuccess: (ExceptionTester new runTest: #simpleEnsureTestWithError )
]
{ #category : 'tests - exceptiontester' }
ExceptionTest >> testSimpleEnsureTestWithNotification [
self assertSuccess: (ExceptionTester new runTest: #simpleEnsureTestWithNotification )
]
{ #category : 'tests - exceptiontester' }
ExceptionTest >> testSimpleEnsureTestWithUparrow [
self assertSuccess: (ExceptionTester new runTest: #simpleEnsureTestWithUparrow )
]
{ #category : 'tests - exceptiontester' }
ExceptionTest >> testSimpleIsNested [
self assertSuccess: (ExceptionTester new runTest: #simpleIsNestedTest )
]
{ #category : 'tests - exceptiontester' }
ExceptionTest >> testSimpleOuter [
self assertSuccess: (ExceptionTester new runTest: #simpleOuterTest )
]
{ #category : 'tests - exceptiontester' }
ExceptionTest >> testSimplePass [
self assertSuccess: (ExceptionTester new runTest: #simplePassTest )
]
{ #category : 'tests - exceptiontester' }
ExceptionTest >> testSimpleResignalAs [
self assertSuccess: (ExceptionTester new runTest: #simpleResignalAsTest )
]
{ #category : 'tests - exceptiontester' }
ExceptionTest >> testSimpleResume [
self assertSuccess: (ExceptionTester new runTest: #simpleResumeTest )
]
{ #category : 'tests - exceptiontester' }
ExceptionTest >> testSimpleReturn [
self assertSuccess: (ExceptionTester new runTest: #simpleReturnTest )
]
{ #category : 'tests - exceptiontester' }
ExceptionTest >> testTimeoutWithZeroDuration [
self assertSuccess: (ExceptionTester new runTest: #simpleTimeoutWithZeroDurationTest )
]
{ #category : 'tests - handling' }
ExceptionTest >> testUnhandledErrorWhenHandlerPassesOriginalException [
| executed |
executed := false.
self runWithNoHandlers: [
[
[ 1/0 ] on: UnhandledError do: [ :e | executed := true ]
] on: ZeroDivide do: [:z | z pass].
].
self assert: executed
]
{ #category : 'tests - handling' }
ExceptionTest >> testUnhandledErrorWhenNoHandlers [
| executed |
executed := false.
self runWithNoHandlers: [
[ 1/0 ] on: UnhandledError do: [ :e | executed := true ]
].
self assert: executed
]
{ #category : 'tests - handling' }
ExceptionTest >> testUnhandledErrorWhenTwoHandlersPassOriginalException [
| executed |
executed := false.
self runWithNoHandlers: [
[ [
[ 1/0 ] on: UnhandledError do: [ :e | executed := true ]
] on: ZeroDivide do: [:z | z pass]
] on: ZeroDivide do: [:z | z pass]
].
self assert: executed
]
{ #category : 'tests - handling' }
ExceptionTest >> testUnhandledExceptionShouldAllowToCatchError [
| error caughtException |
error := Error new.
self runWithNoHandlers: [
[ error signal ] on: UnhandledException do: [ :err | caughtException := err ]
].
self assert: caughtException class equals: UnhandledError.
self assert: caughtException exception equals: error
]
{ #category : 'tests - handling' }
ExceptionTest >> testUnhandledExceptionShouldAllowToCatchHalt [
| halt caughtException |
halt := Halt new.
self runWithNoHandlers: [
[ halt signal ] on: UnhandledException do: [ :err | caughtException := err ]
].
self assert: caughtException equals: halt
]
{ #category : 'tests - handling' }
ExceptionTest >> testUnhandledExceptionShouldAllowToCatchWarning [
| warning caughtException |
warning := Warning new.
self runWithNoHandlers: [
[ warning signal ] on: UnhandledException do: [ :err | caughtException := err ]
].
self assert: caughtException class equals: UnhandledError.
self assert: caughtException exception equals: warning
]
{ #category : 'tests - handling' }
ExceptionTest >> testUnhandledWarningShouldBeProcessedAsUnhandledError [
| warning caughtException |
warning := Warning new.
self runWithNoHandlers: [
[ warning signal ] on: UnhandledError do: [ :err | caughtException := err ]
].
self assert: caughtException exception equals: warning
]
```
|
Pagnona (Valvarronese: ) is a comune (municipality) in the Province of Lecco in the Italian region Lombardy, located about northeast of Milan and about north of Lecco.
Pagnona borders the following municipalities: Casargo, Colico, Delebio, Piantedo, Premana, Tremenico.
References
Cities and towns in Lombardy
Valsassina
|
```javascript
/**
* @license
* Visual Blocks Editor
*
* path_to_url
*
*
* path_to_url
*
* Unless required by applicable law or agreed to in writing, software
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*/
/**
* @fileoverview Utility methods for Scratch Blocks but not Blockly.
* @author fenichel@google.com (Rachel Fenichel)
*/
'use strict';
/**
* @name Blockly.scratchBlocksUtils
* @namespace
**/
goog.provide('Blockly.scratchBlocksUtils');
/**
* Measure some text using a canvas in-memory.
* Does not exist in Blockly, but needed in scratch-blocks
* @param {string} fontSize E.g., '10pt'
* @param {string} fontFamily E.g., 'Arial'
* @param {string} fontWeight E.g., '600'
* @param {string} text The actual text to measure
* @return {number} Width of the text in px.
* @package
*/
Blockly.scratchBlocksUtils.measureText = function(fontSize, fontFamily,
fontWeight, text) {
var canvas = document.createElement('canvas');
var context = canvas.getContext('2d');
context.font = fontWeight + ' ' + fontSize + ' ' + fontFamily;
return context.measureText(text).width;
};
/**
* Encode a string's HTML entities.
* E.g., <a> -> <a>
* Does not exist in Blockly, but needed in scratch-blocks
* @param {string} rawStr Unencoded raw string to encode.
* @return {string} String with HTML entities encoded.
* @package
*/
Blockly.scratchBlocksUtils.encodeEntities = function(rawStr) {
// CC-BY-SA path_to_url
return rawStr.replace(/[\u00A0-\u9999<>&]/gim, function(i) {
return '&#' + i.charCodeAt(0) + ';';
});
};
/**
* Re-assign obscured shadow blocks new IDs to prevent collisions
* Scratch specific to help the VM handle deleting obscured shadows.
* @param {Blockly.Block} block the root block to be processed.
* @package
*/
Blockly.scratchBlocksUtils.changeObscuredShadowIds = function(block) {
var blocks = block.getDescendants(false);
for (var i = blocks.length - 1; i >= 0; i--) {
var descendant = blocks[i];
for (var j = 0; j < descendant.inputList.length; j++) {
var connection = descendant.inputList[j].connection;
if (connection) {
var shadowDom = connection.getShadowDom();
if (shadowDom) {
shadowDom.setAttribute('id', Blockly.utils.genUid());
connection.setShadowDom(shadowDom);
}
}
}
}
};
/**
* Whether a block is both a shadow block and an argument reporter. These
* blocks have special behaviour in scratch-blocks: they're duplicated when
* dragged, and they are rendered slightly differently from normal shadow
* blocks.
* @param {!Blockly.BlockSvg} block The block that should be used to make this
* decision.
* @return {boolean} True if the block should be duplicated on drag.
* @package
*/
Blockly.scratchBlocksUtils.isShadowArgumentReporter = function(block) {
return (block.isShadow() && (block.type == 'argument_reporter_boolean' ||
block.type == 'argument_reporter_string_number'));
};
/**
* Compare strings with natural number sorting.
* @param {string} str1 First input.
* @param {string} str2 Second input.
* @return {number} -1, 0, or 1 to signify greater than, equality, or less than.
*/
Blockly.scratchBlocksUtils.compareStrings = function(str1, str2) {
return str1.localeCompare(str2, [], {
sensitivity: 'base',
numeric: true
});
};
/**
* Determine if this block can be recycled in the flyout. Blocks that have no
* variablees and are not dynamic shadows can be recycled.
* @param {Blockly.Block} block The block to check.
* @return {boolean} True if the block can be recycled.
* @package
*/
Blockly.scratchBlocksUtils.blockIsRecyclable = function(block) {
// If the block needs to parse mutations, never recycle.
if (block.mutationToDom && block.domToMutation) {
return false;
}
for (var i = 0; i < block.inputList.length; i++) {
var input = block.inputList[i];
for (var j = 0; j < input.fieldRow.length; j++) {
var field = input.fieldRow[j];
// No variables.
if (field instanceof Blockly.FieldVariable ||
field instanceof Blockly.FieldVariableGetter) {
return false;
}
if (field instanceof Blockly.FieldDropdown ||
field instanceof Blockly.FieldNumberDropdown ||
field instanceof Blockly.FieldTextDropdown) {
if (field.isOptionListDynamic()) {
return false;
}
}
}
// Check children.
if (input.connection) {
var child = input.connection.targetBlock();
if (child && !Blockly.scratchBlocksUtils.blockIsRecyclable(child)) {
return false;
}
}
}
return true;
};
/**
* Creates a callback function for a click on the "duplicate" context menu
* option in Scratch Blocks. The block is duplicated and attached to the mouse,
* which acts as though it were pressed and mid-drag. Clicking the mouse
* releases the new dragging block.
* @param {!Blockly.BlockSvg} oldBlock The block that will be duplicated.
* @param {!Event} event Event that caused the context menu to open.
* @return {Function} A callback function that duplicates the block and starts a
* drag.
* @package
*/
Blockly.scratchBlocksUtils.duplicateAndDragCallback = function(oldBlock, event) {
var isMouseEvent = Blockly.Touch.getTouchIdentifierFromEvent(event) === 'mouse';
return function(e) {
// Give the context menu a chance to close.
setTimeout(function() {
var ws = oldBlock.workspace;
var svgRootOld = oldBlock.getSvgRoot();
if (!svgRootOld) {
throw new Error('oldBlock is not rendered.');
}
// Create the new block by cloning the block in the flyout (via XML).
var xml = Blockly.Xml.blockToDom(oldBlock);
// The target workspace would normally resize during domToBlock, which
// will lead to weird jumps.
// Resizing will be enabled when the drag ends.
ws.setResizesEnabled(false);
// Disable events and manually emit events after the block has been
// positioned and has had its shadow IDs fixed (Scratch-specific).
Blockly.Events.disable();
try {
// Using domToBlock instead of domToWorkspace means that the new block
// will be placed at position (0, 0) in main workspace units.
var newBlock = Blockly.Xml.domToBlock(xml, ws);
// Scratch-specific: Give shadow dom new IDs to prevent duplicating on paste
Blockly.scratchBlocksUtils.changeObscuredShadowIds(newBlock);
var svgRootNew = newBlock.getSvgRoot();
if (!svgRootNew) {
throw new Error('newBlock is not rendered.');
}
// The position of the old block in workspace coordinates.
var oldBlockPosWs = oldBlock.getRelativeToSurfaceXY();
// Place the new block as the same position as the old block.
// TODO: Offset by the difference between the mouse position and the upper
// left corner of the block.
newBlock.moveBy(oldBlockPosWs.x, oldBlockPosWs.y);
if (!isMouseEvent) {
var offsetX = ws.RTL ? -100 : 100;
var offsetY = 100;
newBlock.moveBy(offsetX, offsetY); // Just offset the block for touch.
}
} finally {
Blockly.Events.enable();
}
if (Blockly.Events.isEnabled()) {
Blockly.Events.fire(new Blockly.Events.BlockCreate(newBlock));
}
if (isMouseEvent) {
// e is not a real mouseEvent/touchEvent/pointerEvent. It's an event
// created by the context menu and has the coordinates of the mouse
// click that opened the context menu.
var fakeEvent = {
clientX: event.clientX,
clientY: event.clientY,
type: 'mousedown',
preventDefault: function() {
e.preventDefault();
},
stopPropagation: function() {
e.stopPropagation();
},
target: e.target
};
ws.startDragWithFakeEvent(fakeEvent, newBlock);
}
}, 0);
};
};
```
|
USS Barber (DE-161/APD-57) was a in service with the United States Navy from 1943 to 1946. In 1969, she was sold to Mexico where she served until 2001.
History
Barber was named in honor of brothers Malcolm, Randolph, and Leroy Barber who were all killed aboard the during the attack on Pearl Harbor on 7 December 1941. The ship was laid down in April 1943 and launched one month later, but because the Barber brothers' mother was not available on the day of launching, the ship was christened at the same time that she was commissioned in October 1943.
U.S. Navy (1943-1969)
Barber (DE-161) was laid down on 27 April 1943 at Portsmouth, Virginia, by the Norfolk Navy Yard and was launched on 24 May 1943. However, because the sponsor, Mrs. Peter Thomas Barber, the mother of the Barber brothers, could not be present at the launching of the ship, Barbers christening was delayed until the day of her commissioning, 10 October 1943, when the two ceremonies were held simultaneously. Mrs. Barber christened the ship, and USS Barber was placed in commission.
Battle of the Atlantic
Following shakedown training off Bermuda, the destroyer escort was assigned convoy duty along the Atlantic coast. She escorted troopships to Panama as her first duty and, on her return trip northward, escorted the crippled New Zealand light cruiser to Boston. Although they arrived in Boston on 23 December, Barber could not spend Christmas in port. Instead, she pulled out of the harbor on Christmas Day and headed for North Africa escorting a convoy of 95 merchantmen. She arrived in Casablanca, French Morocco, after an uneventful transatlantic crossing. While waiting for a return convoy, she patrolled the Strait of Gibraltar for several days in search of German submarines. After another uneventful voyage, the ship left the convoy at Norfolk and continued on to the New York Navy Yard.
She spent most of February and March 1944 performing escort duties between New York and Norfolk; and, then, on 24 March, received orders to join an anti-submarine "hunter killer" group TG 21.15, built around and joined by four other destroyer escorts.
Formed to hunt German U-boats, the group recorded its first success on 26 April when Barber and the escorts , , and , teamed up to sink the at . Relieved by another hunter killer group, Barbers unit headed for home on 11 May. After a brief availability at the New York Navy Yard and two weeks of maneuvers at Casco Bay, Maine, Barber resumed her convoy escort duties. She made two more transatlantic voyages to North Africa before October 1944 but did not encounter any enemy ships.
On 9 October, Barber entered the Philadelphia Navy Yard for conversion to a Charles Lawrence-class high speed transport. Although she was reclassified APD-57 on 23 October, she did not complete the preparations for her new role until January 1945. On the 17th, she left Philadelphia and proceeded to Norfolk's convoy escort piers. For a month, the fast transport served as "school ship" for crews of APD's not yet commissioned. Each day she got underway to train these crews in evolutions such as fueling, gunfire, target tracking, and other combat procedures.
Pacific War
On George Washington's Birthday, the warship steamed out of Norfolk bound for the Pacific and her first combat duty as a high speed transport. After a short stay in San Diego, she continued on westward and arrived at Pearl Harbor on 26 March. The fast transport then conducted specialized training at Maui with Underwater Demolition Teams (UDT's). The mission of such teams was to destroy obstacles on landing beaches, and APD's such as Barber delivered these teams to the areas four or five days before the actual invasion. Just two days after receiving word of President Franklin D. Roosevelt's 12 April death, she sailed via Eniwetok for Ulithi.
Barber arrived there on 30 April and spent five days preparing for front line duty at Okinawa. She departed the safety of Ulithi with a merchant convoy on 5 May and continually felt the presence of the enemy through possible submarine contacts, floating mines, and radio message traffic emanating from Okinawa. The high-speed transport anchored in Hagushi Anchorage on 10 May and, throughout the daylight hours, heard not a sound from the Japanese. However, with sunset, the Japanese air attacks began in earnest.
On 11 May, Barber received orders to assist on a radar picket station north of the anchorage. That destroyer had been hit by two kamikaze planes and two bombs. Barber mustered all the hands she could spare to help evacuate the injured from Hugh W. Hadley and then to work on saving the damaged warship. The fast transport assumed picket duty north of Ie Shima on the 12th. The enemy never came close by air; but, on 15 May, Barber picked up four Japanese soldiers in a raft and later transferred them to an Army boat for internment in an Okinawa camp.
Barbers good luck continued to hold. Every picket station on which she served had been the scene of a casualty either immediately before her duty there or would become one soon after she departed. On 20 May, the Japanese directed a massive force of midget submarines, mines and kamikaze aircraft at the Allied naval forces. Barber pursued two midget submarines and evaluated one as a "probable kill." The high speed transport continued on patrol, enduring nightly general quarters alarms for Japanese air raids. On 14 June, she captured three more prisoners. On the evening of 16 June, while Barber stood rescue-ship watch at anchor off Hagushi, suffered a hit by air raiders and sank within an hour. Barber rushed to the area immediately to search for survivors. The fast transport worked through the night assisting in the rescue of the 188 sailors who survived before returning to the anchorage early the next morning.
Released from duty at Okinawa on Independence Day 1945, Barber joined a convoy of four other escorts and 32 LSTs headed for Saipan. One day out of Saipan, Barber received orders to accompany a part of the convoy to Guam. Her new course took her across the routes used by American B-29 bombers headed for the Japanese mainland. On 9 July, the fast transport received word of a nearby crash of a returning bomber. Barber raced to the site and, despite fears of complete destruction, over the distance of approximately 20 miles the "Barber" following the path of the bomber back toward Japan began to retrieve the crew picking up the captain first, since he was the last one to jump from the plane. In the end, all 11 members of the bomber's crew were remarkably rescued. The fast transport took them to Guam the next day.
Barber remained at Guam until 21 July when she sailed for Ulithi escorting escort carrier . She continued on to Leyte Gulf where she screened battleships and on 8, 9 and 10 August and then returned to Leyte to await further orders. While there, the news of Japan's capitulation reached Barber and she headed for Okinawa escorting Mississippi and her sistership . Arriving on 21 August, she departed the next day for a brief visit to Manila Bay. On 2 September, the fast transport commenced three weeks of duty in Subic Bay, at the conclusion of which she moved to Lingayen Gulf to join Transport Division (TransDiv) 20. From there, she led a procession of 20 transports for occupation duty. The group entered Wakanoura Bay at Honshū on 7 October and passed three slow weeks while minesweepers cleared a channel to Nagoya. Finally, TransDiv 20 was able to enter the channel safely while Barber remained behind to control the harbor entrance. The crew of the "Barber" went ashore in the city of Nagasaki, which had been destroyed by the second atomic bomb making each member of the crew an "atomic" veteran.
After another three weeks of screening incoming and outgoing ships, the transport received orders to load passengers to capacity and return home. On 21 November, she embarked on the long voyage home. After steaming via Sasebo, Eniwetok, Pearl Harbor, San Diego, and Panama, Barber returned to the east coast for pre-inactivation overhaul, and was decommissioned on 22 May 1946. Barber received three battle stars for her World War II service.
She was berthed with the reserve fleet at Green Cove Springs, Florida, and remained there for more than two decades. Her name was struck from the Naval Vessel Register on 27 November 1968.
Mexican Navy career
On 22 December 1969, she was sold to the Mexican Navy and was commissioned the following February as ARM Coahuila (B07). In 1994, she was renamed ARM Vincente Guerrero, In 1994, she was renamed ARM Vincente Guerrero after former Mexican president Vicente Guerrero. The ship was later restored to her original Mexican name of Coahuila with a new pennant number of E21, before she was stricken from the rolls of the Mexican Navy in July 2001. Her ultimate fate is unreported in secondary sources.
Notes
References
Notes 3,4 from crew's "History of the USS Barber DE161-APD57" and the eyewitness account of crewman WT Third Class Stan Stempien.
External links
Buckley-class destroyer escorts
Charles Lawrence-class high speed transports
1943 ships
World War II frigates and destroyer escorts of the United States
World War II amphibious warfare vessels of the United States
Ships transferred from the United States Navy to the Mexican Navy
Destroyers of the Mexican Navy
Ships built in Portsmouth, Virginia
|
```python
Get more with `collections`!
Enhance your `tuple`s
Looping techniques
`bytearray` objects
Operations with `bytes` and `bytearray`
```
|
Inder Dutt Lakhanpal (born 27 October 1962) is an Indian politician, who currently serves as Member of Legislative Assembly from Barsar constituency. Inder Dutt Lakhanpal won from Barsar constituency in 2017 state assembly elections. He is two times Member of Himachal Pradesh Legislative Assembly.
Early life and education
Inder Dutt Lakhanpal was born on 27 October 1962 in Shimla, Himachal Pradesh to Salig Ram Lakhanpal.
He had done graduation in B.A. from Himachal Pradesh University.
Politics
Inder Dutt Lakhanpal was active in local politics from 1997. While Lakhanpal's active state politics started from 2012, when he became MLA to state legislature.
He previously won Himachal Pradesh Legislative Assembly Election in 2012.
Then in 2017, he was re-elected to the thirteenth Himachal Pradesh Legislative Assembly in December, 2017.
References
Indian National Congress politicians from Himachal Pradesh
1962 births
Living people
Himachal Pradesh MLAs 2017–2022
Himachal Pradesh University alumni
|
The Dunstane is a boutique hotel located in the west of Edinburgh on West Coates.
History
Dunstane Villa
The building was originally designed by Edinburgh architect Alexander Black and was built as a private home on what was then the edge of the city, in 1852. The Dunstane was home to the distiller Ross family, who gave their name to the Ross Bandstand in Princes Street Gardens.
The building was also used as a training school by Royal Bank of Scotland. It is protected as a category B listed building.
The Dunstane began operating as a hotel in 1969. It was bought by current owners, Derek and Shirley Mowat, in 1998.
Hampton House at Dunstane Houses
Around 1867, an Edinburgh music seller, Archibald Shearer, then living in the Dunstane, was granted permission to "erect a house or villa agreeable to the plan approved of by the Feoffers of Trust and Governors of George Heriot's Hospital". The link between the properties was restored when it was bought by the Mowats in 2007. The building was opened in 2008 as the 18-bedroom Dunstane City Hotel, by former Scotland rugby union international Scott Hastings.
References
External links
The Dunstane official website
Hotels in Edinburgh
Hotels established in 1969
Hotels established in 2008
Category B listed buildings in Edinburgh
Listed hotels in Scotland
1969 establishments in Scotland
|
```java
package samples;
import compute.*;
public class HelloWorld {
public static void main(String[] args) {
System.out.println(greeting());
}
static String greeting() {
int answer = DeepThought.compute();
return String.format("The answer to the ultimate question of Life, the Universe and Everything is %d.", answer);
}
}
```
|
```java
/*
This file is part of the iText (R) project.
Authors: Apryse Software.
This program is offered under a commercial and under the AGPL license.
For commercial licensing, contact us at path_to_url For AGPL licensing, see below.
AGPL licensing:
This program is free software: you can redistribute it and/or modify
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
along with this program. If not, see <path_to_url
*/
package com.itextpdf.test;
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.extension.ExtendWith;
/**
* This class is used for testing when logger output should be tested as well.
* By default any logger output that is not expected, i.e. marked with {@link com.itextpdf.test.annotations.LogMessage},
* will result in crash.
*/
@ExtendWith(LogListener.class)
public abstract class ExtendedITextTest extends ITextTest {
/**
* This method is called before each test method is executed
*/
@BeforeEach
public void beforeTestMethodAction(){
}
/**
* This method is called after each test method is executed
*/
@AfterEach
public void afterTestMethodAction(){
}
}
```
|
Ivád is a village in Heves County, Hungary.
References
Populated places in Heves County
|
```objective-c
/**
*
*
* path_to_url
*
* Unless required by applicable law or agreed to in writing, software
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*/
#ifndef your_sha256_hash_H_
#define your_sha256_hash_H_
#include "nnacl/op_base.h"
#include "nnacl/unsqueeze_parameter.h"
#ifdef __cplusplus
extern "C" {
#endif
int Int8Unsqueeze(int8_t *input_ptr, int8_t *output_ptr, UnSqueezeParameter *para_, size_t data_size, int task_id);
#ifdef __cplusplus
}
#endif
#endif // your_sha256_hash_H_
```
|
Cartonema spicatum is a herb in the Commelinaceae family.
The perennial herb typically grows to a height of . It blooms between January and July producing yellow flowers.
It is found in the Kimberley region in Western Australia where it grows in a variety of soils over basalt or sandstone.
References
spicatum
Plants described in 1810
Taxa named by Robert Brown (botanist, born 1773)
|
The Moldovan Chess Championship has been contested every year since 1944. Since 1949 a separate women's championship has also been held in most years. Both championships are currently held under the auspices of the Moldova Chess Federation (), which was founded on 2 November 1994.
Open championship winners
{| class="sortable wikitable"
! Year !! Champion
|-
| 1944 || Vasily Veter
|-
| 1945 || V. Uveatkin
|-
| 1946 || V. Uveatkin
|-
| 1947 || Vitaly Tarasov
|-
| 1948 || Vitaly Tarasov
|-
| 1949 || Vitaly Tarasov
|-
| 1950 || Vitaly Tarasov
|-
| 1951 || Vitaly Tarasov
|-
| 1952 || Mikhail Shofman
|-
| 1953 || M. Regenbogen
|-
| 1954 || Shlomo Giterman
|-
| 1955 || Vitaly Tarasov
|-
| 1956 || Shlomo Giterman
|-
| 1957 || Shlomo Giterman
|-
| 1958 || Samuel Zhukhovitsky
|-
| 1959 || Samuel Zhukhovitsky
|-
| 1960 || Shlomo Giterman
|-
| 1961 || Ilya Mosionzhik
|-
| 1962 || Mikhail Shofman
|-
| 1963 || Anatoly Lutikov
|-
| 1964 || Anatoly Lutikov
|-
| 1965 || Anatoly Lutikov
|-
| 1966 || Anatoly Lutikov
|-
| 1967 || Boris Nevednichy
|-
| 1968 || Anatoly Lutikov
|-
| 1969 || Mikhail Shofman
|-
| 1970 || Ilye Figler, Lazar Shusterman
|-
| 1971 || Boris Nevednichy
|-
| 1972 ||Nikolay Popov
|-
| 1973 || Boris Nevednichy
|-
| 1974 || Nikolay Popov
|-
| 1975 || Nikolay Popov
|-
| 1976 || Nikolay Popov
|-
| 1977 || Anatoly Lutikov
|-
| 1978 || Orest Averkin
|-
| 1979 || Vladimir Alterman
|-
| 1980 || Boris Itkis
|-
| 1981 || Wladimir Skulener
|-
| 1982 || Boris Itkis
|-
| 1983 || Boris Itkis
|-
| 1984 || Boris Itkis
|-
| 1985 || Boris Nevednichy
|-
| 1986 || Georgi Orlov
|-
| 1987 || Boris Nevednichy
|-
| 1988 || German Titov
|-
| 1989 || Georgi Orlov
|-
| 1990 || Boris Itkis
|-
| 1991 || Ilye Figler
|-
| 1992 || Boris Itkis
|-
| 1993 || Boris Nevednichy
|-
| 1994 || Dorian Rogozenko
|-
| 1995 || Boris Nevednichy
|-
| 1996 || Vadim Chernov
|-
| 1997 || Boris Itkis
|-
| 1998 || Vasile Sanduleac
|-
| 1999 || Anatolij Bets
|-
| 2000 || Dmitry Svetushkin
|-
| 2001 || Vasile Sanduleac
|-
| 2002 || Alexei Furtuna
|-
| 2003 || Vasile Sanduleac
|-
| 2004 || Alexey Khruschiov
|-
| 2005 || Svetlana Petrenko
|-
| 2006 || Viacheslav Slovineanu
|-
| 2007 || Vasile Sanduleac
|-
| 2008 || Vasile Sanduleac
|-
| 2009 || Serghei Vedmediuc
|-
| 2010 || Vladimir Hamițevici
|-
| 2011 || Serghei Vedmediuc
|-
| 2012 || Iulian Baltag
|-
| 2013 || Dan Golub
|-
| 2014 || Liviu Cerbulenco
|-
| 2015 || Ruslan Soltanici
|-
| 2016 || Viorel Iordăchescu
|-
| 2017 || Nichita Morozov
|-
| 2018 || Vladimir Hamițevici
|-
| 2019 || Andrei Macovei
|-
| 2020 || Iulian Baltag
|-
| 2021 || Iulian Baltag
|-
| 2022 || Dragoș Cereș
|}
Women's championship winners
{| class="sortable wikitable"
! Year !! Champion
|-
| 1949 ||Dekabrina Kazatsker
|-
| 1950 || N. Tarasova
|-
| 1951 || Natasha Kolotyi, Dekabrina Kazatsker
|-
| 1952 ||Dekabrina Kazatsker
|-
| 1953 ||Natasha Kolotyi
|-
| 1954 || E. Matos
|-
| 1955 ||Natasha Kolotyi
|-
| 1956 || N. Kononova
|-
| 1959 || Bronislava Mosionzhik
|-
| 1960 ||Bronislava Mosionzhik
|-
| 1961 ||Bronislava Mosionzhik
|-
| 1962 ||Bronislava Mosionzhik
|-
| 1963 ||Bronislava Mosionzhik
|-
| 1964 ||Bronislava Mosionzhik
|-
| 1965 ||Bronislava Mosionzhik
|-
| 1967 || Natalia Ivanova, Bronislava Mosionzhik
|-
| 1968 ||Bronislava Mosionzhik
|-
| 1970 ||Bronislava Mosionzhik
|-
| 1971 || Raisa Nevednichaya
|-
| 1972 ||Raisa Nevednichaya
|-
| 1973 ||Bronislava Mosionzhik
|-
| 1974 ||Raisa Nevednichaya
|-
| 1975 || Alla Grinfeld
|-
| 1976 || Ludmila Saunina
|-
| 1977 || Naira Agababean
|-
| 1978 || Marina Afanasova
|-
| 1979 ||Raisa Nevednichaya
|-
| 1980 ||Naira Agababean
|-
| 1981 ||Naira Agababean
|-
| 1982 ||Naira Agababean
|-
| 1983 ||Naira Agababean
|-
| 1984 ||Naira Agababean
|-
| 1985 || Polina Zilberman
|-
| 1986 ||Polina Zilberman
|-
| 1987 || Marina Sheremetieva (née Afanasova)
|-
| 1988 ||Marina Sheremetieva
|-
| 1989 || Irina Brandis
|-
| 1990 || Nadejda Roizen
|-
| 1991 ||Irina Brandis
|-
| 1992 ||Marina Sheremetieva
|-
| 1993 || Svetlana Petrenko
|-
| 1994 ||Naira Agababean
|-
| 1995 || Anna Shusterman
|-
| 1996 ||Naira Agababean
|-
| 1997 || Karolina Smokina
|-
| 1998 ||Svetlana Petrenko
|-
| 1999 ||Svetlana Petrenko
|-
| 2000 ||Anna Shusterman, Svetlana Petrenko
|-
| 2001 ||Svetlana Petrenko
|-
| 2002 || Elena Partac
|-
| 2003 ||Elena Partac
|-
| 2004 ||Anna Shusterman
|-
| 2005 || Lilia Doibani
|-
| 2006 ||Elena Partac
|-
| 2007 || Irina Bulmaga
|-
| 2008 ||Irina Bulmaga
|-
| 2009 || Diana Baciu
|-
| 2010 || Elena Partac
|-
| 2011 || Olga Hincu
|-
| 2012 ||Svetlana Petrenko
|-
| 2013 ||Svetlana Petrenko
|-
| 2014 || Paula-Alexandra Gitu
|-
| 2015 ||Svetlana Petrenko
|-
| 2016 ||Svetlana Petrenko
|-
| 2017 ||Svetlana Petrenko
|-
| 2018 ||Svetlana Petrenko
|-
| 2019 ||Svetlana Petrenko
|-
| 2020 ||Valentina Verbin
|-
| 2021 ||Svetlana Petrenko
|-
| 2022 ||Ana Petricenco
|-
|}
References
Chess national championships
Women's chess national championships
Chess in Moldova
Chess
|
Catopyrops is a genus of butterflies in the family Lycaenidae. The range extends from India to the Malay Archipelago and the Solomon Islands.
Species
Catopyrops ancyra (Felder, 1860) – many subspecies
Catopyrops florinda (Butler, 1877)
Catopyrops holtra Parsons, 1986 New Britain
Catopyrops keiria (Druce, 1891)
Catopyrops kokopona (Ribbe, 1899)
Catopyrops nebulosa (Druce, 1892) New Hebrides
Catopyrops rita (Grose-Smith, 1895)
Catopyrops zyx Parsons, 1986 Solomon Islands, New Guinea
References
External links
"Catopyrops Toxopeus, 1929" at Markku Savela's Lepidoptera and Some Other Life Forms
Images representing Catopyrops at Bold
Further reading
French Wikipedia provides additional subspecies and distribution information at "Le genre Catopyrops".
Lycaenidae genera
Taxa named by Lambertus Johannes Toxopeus
|
The Bewitched Inn (French: L'auberge ensorcelée) is an 1897 French short silent trick film directed by Georges Méliès. It was released by Méliès's Star Film Company and is numbered 122–123 in its catalogs.
Plot
A traveler arrives in a small hotel room, complete with riding boots and a pith helmet. When he puts his luggage on the bed, it disappears immediately. Further magical confusions follow: when he sets down his helmet, it jumps to the floor and moves of its own accord before disappearing in its turn; when the traveler tries to light a candle, it jumps across the room and explodes; when he takes off his coat, it flies through the wall; when he tries to sit down, his chair changes place. Finally managing to sit down, the traveler takes off his boots, which walk away; when the traveler moves to the night table, it too disappears. The traveler prepares for bed and takes off his trousers, which fly through the ceiling. When he jumps into bed, it too disappears and reappears. The perplexed and irritated traveler gives up and dashes out of the room.
Themes
The Bewitched Inn is the first known Méliès film to feature inanimate objects coming to life to tease their owners, a theme that would return time and again throughout his work. The idea of a guest trying unsuccessfully to get to sleep in a hotel room, already popular for years on the variety stage, had been first used by Méliès in 1896, in his film A Terrible Night.
Méliès's 1903 film The Inn Where No Man Rests used a plot very similar to that of The Bewitched Inn, but expanded it considerably. The motif of a candle-laden traveler also returned in another 1903 Méliès film, The Apparition, or Mr. Jones' Comical Experience With a Ghost. The hotel guest theme reappeared again with further sophistication in Méliès's 1906 film A Roadside Inn.
Production
The Bewitched Inn was likely inspired by the Hanlon-Lees, a British troupe of acrobats popular in Europe in the 1880s. The Hanlon-Lees, describing themselves as "Entortilationists", specialized in spectacular high-energy comedy acts in which they cavorted and bounced manically across the stage, often leaping through hidden trapdoors in the set. In one routine, a guest in a candlelit inn was first tormented by his shoes coming to life, and then chased around the stage by demons. Other Méliès films bearing the mark of the Hanlon-Lees' inspiration include The Inn Where No Man Rests and The Diabolic Tenant. Another inspiration for The Bewitched Inn probably came from a popular and influential 1839 féerie, Les Pilules du Diable, which included a scene in a haunted room.
The film was shot outdoors, in Méliès's garden in Montreuil, Seine-Saint-Denis. The inanimate objects were animated using wires; other special effects were created using pyrotechnics and the editing technique known as the substitution splice, which allowed the magical disappearances to occur. Méliès himself played the traveler.
References
External links
1897 films
1897 horror films
1890s French films
French silent short films
French black-and-white films
Films directed by Georges Méliès
Trick films
Articles containing video clips
Films set in hotels
1897 short films
Silent horror films
|
```yaml
name: l1-output-number
runtime:
name: nodejs
options:
typescript: false
```
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.