/*

* Copyright (C) 2014-2015 Stichting Mapcode Foundation (http://www.mapcode.com)

*

* Licensed under the Apache License, Version 2.0 (the "License");

* you may not use this file except in compliance with the License.

* You may obtain a copy of the License at

*

* http://www.apache.org/licenses/LICENSE-2.0

*

* Unless required by applicable law or agreed to in writing, software

* distributed under the License is distributed on an "AS IS" BASIS,

* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

* See the License for the specific language governing permissions and

* limitations under the License.

*/

var entity_iso = [

'VAT', 'MCO', 'GIB', 'TKL', 'CCK', 'BLM', 'NRU', 'TUV', 'MAC', 'SXM',

'MAF', 'NFK', 'PCN', 'BVT', 'BMU', 'IOT', 'SMR', 'GGY', 'AIA', 'MSR',

'JEY', 'CXR', 'WLF', 'VGB', 'LIE', 'ABW', 'MHL', 'ASM', 'COK', 'SPM',

'NIU', 'KNA', 'CYM', 'BES', 'MDV', 'SHN', 'MLT', 'GRD', 'VIR', 'MYT',

'SJM', 'VCT', 'HMD', 'BRB', 'ATG', 'CUW', 'SYC', 'PLW', 'MNP', 'AND',

'GUM', 'IMN', 'LCA', 'FSM', 'SGP', 'TON', 'DMA', 'BHR', 'KIR', 'TCA',

'STP', 'HKG', 'MTQ', 'FRO', 'GLP', 'COM', 'MUS', 'REU', 'LUX', 'WSM',

'SGS', 'PYF', 'CPV', 'TTO', 'BRN', 'ATF', 'PRI', 'CYP', 'LBN', 'JAM',

'GMB', 'QAT', 'FLK', 'VUT', 'MNE', 'BHS', 'TLS', 'SWZ', 'KWT', 'FJI',

'NCL', 'SVN', 'ISR', 'PSE', 'SLV', 'BLZ', 'DJI', 'MKD', 'RWA', 'HTI',

'BDI', 'GNQ', 'ALB', 'SLB', 'ARM', 'LSO', 'BEL', 'MDA', 'GNB', 'TWN',

'BTN', 'CHE', 'NLD', 'DNK', 'EST', 'DOM', 'SVK', 'CRI', 'BIH', 'HRV',

'TGO', 'LVA', 'LTU', 'LKA', 'GEO', 'IRL', 'SLE', 'PAN', 'CZE', 'GUF',

'ARE', 'AUT', 'AZE', 'SRB', 'JOR', 'PRT', 'HUN', 'KOR', 'ISL', 'GTM',

'CUB', 'BGR', 'LBR', 'HND', 'BEN', 'ERI', 'MWI', 'PRK', 'NIC', 'GRC',

'TJK', 'BGD', 'NPL', 'TUN', 'SUR', 'URY', 'KHM', 'SYR', 'SEN', 'KGZ',

'BLR', 'GUY', 'LAO', 'ROU', 'GHA', 'UGA', 'GBR', 'GIN', 'ECU', 'ESH',

'GAB', 'NZL', 'BFA', 'PHL', 'ITA', 'OMN', 'POL', 'CIV', 'NOR', 'MYS',

'VNM', 'FIN', 'COG', 'DEU', 'JPN', 'ZWE', 'PRY', 'IRQ', 'MAR', 'UZB',

'SWE', 'PNG', 'CMR', 'TKM', 'ESP', 'THA', 'YEM', 'FRA', 'ALA', 'KEN',

'BWA', 'MDG', 'UKR', 'SSD', 'CAF', 'SOM', 'AFG', 'MMR', 'ZMB', 'CHL',

'TUR', 'PAK', 'MOZ', 'NAM', 'VEN', 'NGA', 'TZA', 'EGY', 'MRT', 'BOL',

'ETH', 'COL', 'ZAF', 'MLI', 'AGO', 'NER', 'TCD', 'PER', 'MNG', 'IRN',

'LBY', 'SDN', 'IDN', 'DIF', 'TLA', 'MOR', 'AGU', '5CL', 'QUE', 'HID',

'5MX', 'TAB', 'NAY', 'GUA', 'PUE', 'YUC', 'ROO', 'SIN', 'CAM', 'MIC',

'SLP', 'GRO', 'NLE', 'BCN', 'VER', 'CHP', 'BCS', 'ZAC', 'JAL', 'TAM',

'OAX', 'DUR', 'COA', 'SON', 'CHH', 'GRL', 'SAU', 'COD', 'DZA', 'KAZ',

'ARG', '2DD', '2DN', '2CH', '2AN', '2LD', '2DL', '2ML', '2NL', '2MN',

'2TR', '2MZ', '2SK', '2PB', '2HR', '2AR', '2AS', '2BR', '2UT', '2GA',

'2KL', '2TN', '2HP', '2JK', '2CT', '2JH', '2KA', '2RJ', '2OR', '2GJ',

'2WB', '2MP', '2TG', '2AP', '2MH', '2UP', '2PY', 'NSW', 'ACT', 'JBT',

'4NT', '4SA', 'TAS', 'VIC', '4WA', 'QLD', '6DF', '6SE', '6AL', '6RJ',

'6ES', '6RN', '6PB', '6SC', '6PE', '6AP', '6CE', '6AC', '6PR', '6RR',

'6RO', '6SP', '6PI', '6TO', '6RS', '6MA', '6GO', '6MS', '6BA', '6MG',

'6MT', '6PA', '6AM', '1DC', '1RI', '1DE', '1CT', '1NJ', '1NH', '1VT',

'1MA', '1HI', '1MD', '1WV', '1SC', '1ME', '1IN', '1KY', '1TN', '1VA',

'1OH', '1PA', '1MS', '1LA', '1AL', '1AR', '1NC', '1NY', '1IA', '1IL',

'1GA', '1WI', '1FL', '1MO', '1OK', '1ND', '1WA', '1SD', '1NE', '1KS',

'1ID', '1UT', '1MN', '1MI', '1WY', '1OR', '1CO', '1NV', '1AZ', '1NM',

'1MT', '1CA', '1TX', '1AK', '3BC', '3AB', '3ON', '3QC', '3SK', '3MB',

'3NL', '3NB', '3NS', '3PE', '3YT', '3NT', '3NU', 'IND', 'AUS', 'BRA',

'USA', 'MEX', 'MOW', 'SPE', 'KGD', '7IN', '7AD', '7SE', '7KB', '7KC',

'7CE', '7CU', 'IVA', 'LIP', 'ORL', 'TUL', '7BE', 'VLA', 'KRS', 'KLU',

'7TT', 'BRY', 'YAR', 'RYA', 'AST', 'MOS', 'SMO', '7DA', 'VOR', 'NGR',

'PSK', 'KOS', 'STA', 'KDA', '7KL', 'TVE', 'LEN', 'ROS', 'VGG', 'VLG',

'MUR', '7KR', 'NEN', '7KO', 'ARK', '7MO', 'NIZ', 'PNZ', '7KI', '7ME',

'ORE', 'ULY', '7PM', '7BA', '7UD', '7TA', 'SAM', 'SAR', 'YAN', '7KM',

'SVE', 'TYU', 'KGN', '7CH', '7BU', 'ZAB', 'IRK', 'NVS', 'TOM', 'OMS',

'7KK', 'KEM', '7AL', 'ALT', '7TY', 'KYA', 'MAG', 'CHU', 'KAM', 'SAK',

'7PO', 'YEV', 'KHA', 'AMU', '7SA', 'CAN', 'RUS', '8SH', '8TJ', '8BJ',

'8HI', '8NX', '8CQ', '8ZJ', '8JS', '8FJ', '8AH', '8LN', '8SD', '8SX',

'8JX', '8HA', '8GZ', '8GD', '8HB', '8JL', '8HE', '8SN', '8NM', '8HL',

'8HN', '8GX', '8SC', '8YN', '8XZ', '8GS', '8QH', '8XJ', 'CHN', 'UMI',

'CPT', 'ATA', 'AAA', '?'];

var aliases = "2UK=2UT,2CG=2CT,1GU=GUM,1UM=UMI,1VI=VIR,1AS=ASM,1MP=MNP,4CX=CXR,4CC=CCK,4NF=NFK,4HM=HMD,COL=5CL,5ME=5MX,MEX=5MX,5AG=AGU,5BC=BCN,5BS=BCS,5CM=CAM,5CS=CHP,5CH=CHH,5CO=COA,5DF=DIF,5DG=DUR,5GT=GUA,5GR=GRO,5HG=HID,5JA=JAL,5MI=MIC,5MO=MOR,5NA=NAY,5NL=NLE,5OA=OAX,5PB=PUE,5QE=QUE,5QR=ROO,5SL=SLP,5SI=SIN,5SO=SON,5TB=TAB,5TL=TLA,5VE=VER,5YU=YUC,5ZA=ZAC,811=8BJ,812=8TJ,813=8HE,814=8SX,815=8NM,821=8LN,822=8JL,823=8HL,831=8SH,832=8JS,833=8ZJ,834=8AH,835=8FJ,836=8JX,837=8SD,841=8HA,842=8HB,843=8HN,844=8GD,845=8GX,846=8HI,850=8CQ,851=8SC,852=8GZ,853=8YN,854=8XZ,861=8SN,862=8GS,863=8QH,864=8NX,865=8XJ,871=TWN,891=HKG,892=MAC,8TW=TWN,8HK=HKG,8MC=MAC,BEL=7BE,KIR=7KI,PRI=7PO,CHE=7CH,KHM=7KM,PER=7PM,TAM=7TT,0US=USA,0AU=AUS,0RU=RUS,0CN=CHN,TAA=SHN,ASC=SHN,DGA=IOT,WAK=MHL,JTN=UMI,MID=1HI,1PR=PRI,5TM=TAM,TAM=TAM,2OD=2OR,";

var dependency = [

27, 410, 50, 410, 26, 410, 53, 410, 48, 410, 47, 410, 76, 410, 529, 410, 38, 410,

21, 408, 4, 408, 42, 408, 11, 408,

18, 166, 14, 166, 15, 166, 23, 166, 32, 166, 82, 166, 2, 166, 17, 166, 51, 166, 20, 166, 19, 166, 12, 166, 35, 166, 70, 166, 59, 166,

61, 528, 8, 528, 109, 528,

63, 113, 265, 113,

198, 181,

530, 197, 129, 197, 71, 197, 75, 197, 64, 197, 62, 197, 90, 197, 67, 197, 10, 197, 29, 197, 5, 197, 22, 197,

13, 178, 40, 178,

25, 112, 33, 112, 45, 112, 9, 112,

28, 171, 30, 171, 3, 171,

77, 210,

-1];

var usa_from = 343;

var usa_upto = 393;

var ccode_usa = 410;

var ind_from = 271;

var ind_upto = 306;

var ccode_ind = 407;

var can_from = 394;

var can_upto = 406;

var ccode_can = 495;

var aus_from = 307;

var aus_upto = 315;

var ccode_aus = 408;

var mex_from = 233;

var mex_upto = 264;

var ccode_mex = 411;

var bra_from = 316;

var bra_upto = 342;

var ccode_bra = 409;

var chn_from = 497;

var chn_upto = 527;

var ccode_chn = 528;

var rus_from = 412;

var rus_upto = 494;

var ccode_rus = 496;

var ccode_earth = 532;

var parents3 = "USA,IND,CAN,AUS,MEX,BRA,RUS,CHN,";

var parents2 = "US,IN,CA,AU,MX,BR,RU,CN,";

var ccode_start = 112; // NLD

var mapcode_cversion = "2.0.2";

var mapcode_dataversion = "2.2.0";

// *************************** mapcode_org *********************

var mapcode_javaversion = '2.3.0/Data' + mapcode_dataversion;

/// PRIVATE returns string without leading spaces and plus-signs, and trailing spaces

function trim(str) {

return str.replace(/^\s+|\s+$/g, '');

}

/// PRIVATE return 2-letter parent country abbreviation (disam in range 1..8)

function parentname2(disam) {

return parents2.substr(disam * 3 - 3, 2);

}

/// PRIVATE given a parent country abbreviation, return disam (in range 1-8) or negative if error

function parentletter(territoryAlphaCode) {

var p = -1;

var srch = String(territoryAlphaCode).toUpperCase() + ',';

var len = srch.length;

if (len == 3) {

p = parents2.indexOf(srch);

} else if (len == 4) {

p = parents3.indexOf(srch);

}

if (p < 0) {

return -2;

}

return 1 + (p / len);

}

/// PRIVATE given an ISO abbreviation, set disambiguation for future calls to iso2ccode(); returns nonzero in case of error

var disambiguate = 1; // GLOBAL

function set_disambiguate(territoryAlphaCode) {

var p = parentletter(territoryAlphaCode);

if (p < 0) {

return -2;

}

disambiguate = p;

return 0;

}

/// PRIVATE returns alias of ISO abbreviation (if any), or return empty

function alias2iso(territoryAlphaCode) {

var rx;

if (territoryAlphaCode.length == 2) {

rx = '[0-9]' + territoryAlphaCode;

} else {

rx = territoryAlphaCode;

}

rx = new RegExp(rx + '=', '');

var p = aliases.search(rx);

if (p >= 0) {

return aliases.substring(p + 4, p + 7);

}

return '';

}

/// PRIVATE given ISO code, return territoryNumber (or negative if error)

function iso2ccode(territoryAlphaCode) {

if (typeof territoryAlphaCode == "undefined") {

return undefined;

}

territoryAlphaCode = trim(String(territoryAlphaCode)).toUpperCase();

var sp = territoryAlphaCode.indexOf(" ");

if (sp > 0) {

territoryAlphaCode = territoryAlphaCode.substr(0, sp);

}

if (!isNaN(territoryAlphaCode)) {

var n = Number(territoryAlphaCode);

if ((n >= 0) && (n <= ccode_earth)) {

return n;

}

}

var sep = territoryAlphaCode.lastIndexOf('-');

if (sep >= 0) {

var prefix = territoryAlphaCode.substring(0, sep);

territoryAlphaCode = trim(territoryAlphaCode.substring(sep + 1));

if (territoryAlphaCode.length != 2 && territoryAlphaCode.length != 3) {

return -1;

}

if (set_disambiguate(prefix)) {

return -1;

}

// FIRST see if the territoryAlphaCode is in this disambiguation

if (territoryAlphaCode.length == 2) {

return iso2ccode(disambiguate + '' + territoryAlphaCode);

}

else if (territoryAlphaCode.length == 3) {

var isoa = alias2iso(territoryAlphaCode);

if (isoa) {

if (isoa.charAt(0) == disambiguate) {

territoryAlphaCode = isoa;

}

}

}

}

if (territoryAlphaCode.length != 2 && territoryAlphaCode.length != 3) {

return -1;

}

{

var testiso = (territoryAlphaCode.length == 2 ? disambiguate + '' + territoryAlphaCode : territoryAlphaCode);

var i;

for (i = 0; i < entity_iso.length; i++) {

if (testiso == entity_iso[i]) {

return i;

}

}

// 1.31 improvement: recognise alias in current context

if (territoryAlphaCode.length == 2 && testiso.length == 3) {

var aliasiso = alias2iso(testiso);

if (aliasiso) {

return iso2ccode(aliasiso);

}

}

// look for any iso2 match

if (territoryAlphaCode.length == 2) {

for (i = 0; i < entity_iso.length; i++) {

if (entity_iso[i].charCodeAt(0) <= 57 && territoryAlphaCode == entity_iso[i].substring(1, 3)) {

return i;

}

}

}

territoryAlphaCode = alias2iso(territoryAlphaCode);

if (territoryAlphaCode) {

return iso2ccode(territoryAlphaCode);

}

}

return -1;

}

/// PUBLIC given an alphacode (such as US-AL), returns the territory number (or negative).

/// A contextTerritoryNumber helps to interpret ambiguous (abbreviated) AlphaCodes, such as "AL"

function getTerritoryNumber(territoryAlphaCode, contextTerritory) {

if (contextTerritory) {

var contextTerritoryNumber = getTerritoryNumber(contextTerritory);

set_disambiguate(entity_iso[contextTerritoryNumber]);

}

return iso2ccode(territoryAlphaCode);

}

/// PUBLIC return full name of territory

function getTerritoryFullname(territory) {

var territoryNumber = getTerritoryNumber(territory);

if (territoryNumber == undefined || territoryNumber < 0 || territoryNumber > ccode_earth) {

return undefined;

}

var idx = isofullname[territoryNumber].indexOf(' (');

if (idx > 0) {

return isofullname[territoryNumber].substr(0, idx);

}

return isofullname[territoryNumber];

}

/// PUBLIC return parent country of subdivision (negative if territory is not a subdivision)

function getParentOf(territory) {

var territoryNumber = getTerritoryNumber(territory);

if (territoryNumber >= usa_from && territoryNumber <= usa_upto) {

return ccode_usa;

}

if (territoryNumber >= ind_from && territoryNumber <= ind_upto) {

return ccode_ind;

}

if (territoryNumber >= can_from && territoryNumber <= can_upto) {

return ccode_can;

}

if (territoryNumber >= aus_from && territoryNumber <= aus_upto) {

return ccode_aus;

}

if (territoryNumber >= mex_from && territoryNumber <= mex_upto) {

return ccode_mex;

}

if (territoryNumber >= bra_from && territoryNumber <= bra_upto) {

return ccode_bra;

}

if (territoryNumber >= rus_from && territoryNumber <= rus_upto) {

return ccode_rus;

}

if (territoryNumber >= chn_from && territoryNumber <= chn_upto) {

return ccode_chn;

}

return -199;

}

/// PUBLIC returns true iff territoryNumber is a state

function isSubdivision(territory) {

return getParentOf(territory) >= 0;

}

/// PUBLIC returns true iff territoryNumber is a country that has states

function hasSubdivision(territory) {

return (parents3.indexOf(getTerritoryAlphaCode(getTerritoryNumber(territory), 0)) >= 0);

}

/// PRIVATE returns true iff x in range (all values in millionths)

function isInRangeX(x, minx, maxx) {

if (minx <= x && x < maxx) {

return true;

}

if (x < minx) {

x += 360000000;

} else {

x -= 360000000;

}

return (minx <= x && x < maxx);

}

/// PRIVATE returns true iff coordinate inside rectangle (all values in millionths)

function fitsInside(coord, mm) {

return ( mm.miny <= coord.y && coord.y < mm.maxy && isInRangeX(coord.x, mm.minx, mm.maxx) );

}

/// PRIVATE returns true iff coordinate inside rectangle with some room to spare outside (all values in millionths)

function fitsInsideWithRoom(coord, mm) {

if ((( mm.miny - 60) > coord.y) || (coord.y >= (mm.maxy + 60))) {

return false;

}

var xroom = xDivider4(mm.miny, mm.maxy) / 4;

return isInRangeX(coord.x, mm.minx - xroom, mm.maxx + xroom);

}

/// PRIVATE returns true iff coordinate inside rectangle with some room to spare inside (all values in millionths)

function fitsWellInside(coord, mm) {

if ((( mm.miny + 60) > coord.y) || (coord.y >= (mm.maxy - 60))) {

return false;

}

var xroom = xDivider4(mm.miny, mm.maxy) / 4;

return isInRangeX(coord.x, mm.minx + xroom, mm.maxx - xroom);

}

/// PRIVATE returns true iff coordinate near the rectangle border

function isNearBorderOf(coord, mm) {

return fitsInsideWithRoom(coord, mm) && (!fitsWellInside(coord, mm));

}

/// PUBLIC return the AlphaCode (usually an ISO 3166 code) of a territory

/// format: 0=local (often ambiguous), 1=international (full and unambiguous, DEFAULT), 2=shortest (shortest non-ambiguous abbreviation)

function getTerritoryAlphaCode(territory, format) {

if (format == undefined) {

format = 1;

}

var territoryNumber = getTerritoryNumber(territory);

if (territoryNumber < 0 || territoryNumber > ccode_earth) {

return '';

}

var n = entity_iso[territoryNumber];

if (/^[0-9]/.test(n)) {

n = n.substring(1);

}

if (format) {

var parent = getParentOf(territoryNumber);

if (parent >= 0) {

if (format == 2) {

// see if n occurs multiple times, if not, don't bother with parent

var count = 0;

var i = aliases.indexOf(n + '=');

if (i >= 0) {

count = 2;

} else if (n.length == 2) {

for (i = 0; i < entity_iso.length; i++) {

if (entity_iso[i].substr(1) == n) {

if (entity_iso[i].charAt(0) >= '0') {

if (entity_iso[i].charAt(0) <= '9') {

count++;

if (count > 1) {

break;

}

}

}

}

}

} else {

for (i = 0; i < entity_iso.length; i++) {

if (entity_iso[i] == n) {

count++;

if (count > 1) {

break;

}

}

}

}

if (count == 1) {

return n;

}

}

return parentname2(parentletter(entity_iso[parent])) + '-' + n;

}

}

return n;

}

/// PRIVATE low-level routines for data access

function dataFirstRecord(territoryNumber) {

return data_start[territoryNumber];

}

function dataLastRecord(territoryNumber) {

return data_start[++territoryNumber] - 1;

}

function minmaxSetup(i) {

var d = data_maxy[i];

if (d < 10) {

var shortmaxy = [0, 122309, 27539, 27449, 149759, 2681190, 60119, 62099, 491040, 86489];

d = shortmaxy[d];

}

return {

minx: data_minx[i],

miny: data_miny[i],

maxx: data_minx[i] + data_maxx[i],

maxy: data_miny[i] + d

};

}

/// low-level tables for mapcode encoding and decoding

var xdivider19 = [

360, 360, 360, 360, 360, 360, 361, 361, 361, 361, // 5.2429 degrees

362, 362, 362, 363, 363, 363, 364, 364, 365, 366, // 10.4858 degrees

366, 367, 367, 368, 369, 370, 370, 371, 372, 373, // 15.7286 degrees

374, 375, 376, 377, 378, 379, 380, 382, 383, 384, // 20.9715 degrees

386, 387, 388, 390, 391, 393, 394, 396, 398, 399, // 26.2144 degrees

401, 403, 405, 407, 409, 411, 413, 415, 417, 420, // 31.4573 degrees

422, 424, 427, 429, 432, 435, 437, 440, 443, 446, // 36.7002 degrees

449, 452, 455, 459, 462, 465, 469, 473, 476, 480, // 41.9430 degrees

484, 488, 492, 496, 501, 505, 510, 515, 520, 525, // 47.1859 degrees

530, 535, 540, 546, 552, 558, 564, 570, 577, 583, // 52.4288 degrees

590, 598, 605, 612, 620, 628, 637, 645, 654, 664, // 57.6717 degrees

673, 683, 693, 704, 715, 726, 738, 751, 763, 777, // 62.9146 degrees

791, 805, 820, 836, 852, 869, 887, 906, 925, 946, // 68.1574 degrees

968, 990, 1014, 1039, 1066, 1094, 1123, 1154, 1187, 1223, // 73.4003 degrees

1260, 1300, 1343, 1389, 1438, 1490, 1547, 1609, 1676, 1749, // 78.6432 degrees

1828, 1916, 2012, 2118, 2237, 2370, 2521, 2691, 2887, 3114, // 83.8861 degrees

3380, 3696, 4077, 4547, 5139, 5910, 6952, 8443, 10747, 14784, // 89.1290 degrees

23681, 59485];

var nc = [1, 31, 961, 29791, 923521, 28629151, 887503681];

var xside = [0, 5, 31, 168, 961, 168 * 31, 29791, 165869, 923521, 5141947, 28629151];

var yside = [0, 6, 31, 176, 961, 176 * 31, 29791, 165869, 923521, 5141947, 28629151];

var decodeChar = [

-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,

-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,

-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,

0, 1, 2, 3, 4, 5, 6, 7, 8, 9, -1, -1, -1, -1, -1, -1,

-1, -2, 10, 11, 12, -3, 13, 14, 15, 1, 16, 17, 18, 19, 20, 0,

21, 22, 23, 24, 25, -4, 26, 27, 28, 29, 30, -1, -1, -1, -1, -1,

-1, -2, 10, 11, 12, -3, 13, 14, 15, 1, 16, 17, 18, 19, 20, 0,

21, 22, 23, 24, 25, -4, 26, 27, 28, 29, 30, -1, -1, -1, -1, -1,

-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,

-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,

-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,

-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,

-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,

-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,

-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,

-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1];

var encodeChar = [

'0', '1', '2', '3', '4', '5', '6', '7', '8', '9',

'B', 'C', 'D', 'F', 'G', 'H', 'J', 'K', 'L', 'M',

'N', 'P', 'Q', 'R', 'S', 'T', 'V', 'W', 'X', 'Y', 'Z',

'A', 'E', 'U'];

/// PRIVATE given a minimum and maximum latitude, returns a relative stretch factor (in 360th) for the longitude

function xDivider4(miny, maxy) {

if (miny >= 0) {

return xdivider19[(miny) >> 19];

}

if (maxy >= 0) {

return xdivider19[0];

}

return xdivider19[(-maxy) >> 19];

}

/// PRIVATE lowest level encode/decode routines

function decodeBase31(str) {

var value = 0;

var i;

for (i = 0; i < str.length; i++) {

var c = str.charCodeAt(i);

if (c == 46) // dot!

{

return value;

}

if (decodeChar[c] < 0) {

return NaN;

}

value = value * 31 + decodeChar[c];

}

return value;

}

function decodeTriple(input) {

var triplex, tripley;

var c1 = decodeChar[input.charCodeAt(0)];

var x = decodeBase31(input.substr(1));

if (c1 < 24) {

triplex = (c1 % 6) * 28 + Math.floor(x / 34);

tripley = Math.floor(c1 / 6) * 34 + Math.floor(x % 34);

}

else {

tripley = (x % 40) + 136;

triplex = Math.floor(x / 40) + 24 * (c1 - 24);

}

return {y: tripley, x: triplex}

}

function decodeSixWide(v, width, height) {

var D = 6;

var col = Math.floor(v / (height * 6));

var maxcol = Math.floor((width - 4) / 6);

if (col >= maxcol) {

col = maxcol;

D = width - maxcol * 6;

}

var w = v - (col * height * 6 );

var x6 = col * 6 + (w % D);

var y6 = height - 1 - Math.floor(w / D);

return {y: y6, x: x6}

}

function encodeSixWide(x, y, width, height) {

var D = 6;

var col = Math.floor(x / 6);

var maxcol = Math.floor((width - 4) / 6);

if (col >= maxcol) {

col = maxcol;

D = width - maxcol * 6;

}

return (height * 6 * col) + (height - 1 - y) * D + (x - col * 6);

}

var getDebugInfo; // caller must set this to 1 to get debug info about first successful encode

var mcInfo;

/*

type: 1=topdown nameless, 2=sixwide nameless, 3=regulargrid 4=irregular grid 5=rounded groups 6=unrounded groups

record: rectangle record used to encode

rectangles:

rectEncompassing : encompassing rectangle of country or subdivision

rectArea : area of the encoding record

rectSubarea : subArea (as determined by prefix)

rectZone : subArea zone (only exists for huge regular grids, e.g. Antarctica)

rectRegion : region in Subarea

rectCell : cell for the mapcode (usually 10x10 meters)

rectCell1 : precision 1 cell (usually 2x2 meters)

rectCell2 : precision 2 cell (usually 33x33 cm)

other debug information:

form = alphanumeric description of mapcode form

dotPosition = position to insert dot in mapcode

prefixDivx,prefixDivy = how prefix divides the area (if any)

*/

function asDegreeRect(minx, miny, dx, dy) {

return {minx: minx / 1000000, miny: miny / 1000000, maxx: (minx + dx) / 1000000, maxy: (miny + dy) / 1000000};

}

/// high-precision extension routines

function maxMapcodePrecision() {

return 8;

}

function encodeExtension(result, enc, extrax4, extray, dividerx4, dividery, extraDigits, ydirection) {

if (!extraDigits) {

return result;

}

if (extraDigits > maxMapcodePrecision()) {

extraDigits = maxMapcodePrecision();

}

// the following are all perfect integers

var factorx = 810000 * dividerx4; // 810000 = 30^4

var factory = 810000 * dividery;

var valx = (810000 * extrax4) + (enc.fraclon);

var valy = (810000 * extray ) + (enc.fraclat * ydirection);

// protect against floating point errors

if (valx < 0) {

valx = 0;

} else if (valx >= factorx) {

valx = factorx - 1;

}

if (valy < 0) {

valy = 0;

} else if (valy >= factory) {

valy = factory - 1;

}

result += '-';

for (; ;) {

factorx /= 30;

var gx = Math.floor(valx / factorx);

factory /= 30;

var gy = Math.floor(valy / factory);

var column1 = Math.floor(gx / 6);

var row1 = Math.floor(gy / 5);

result += encodeChar[row1 * 5 + column1];

if (--extraDigits == 0) {

break;

}

var column2 = (gx % 6);

var row2 = (gy % 5);

result += encodeChar[row2 * 6 + column2];

if (--extraDigits == 0) {

break;

}

valx -= factorx * gx;

valy -= factory * gy;

}

return result;

}

// ***** MapcodeZone *****

// cconstruct and return empty MapcodeZone

function mzEmpty() {

return {fminx: 0, fmaxx: 0, fminy: 0, fmaxy: 0};

}

// construct and return copy of MapcodeZone

function mzCopy(zone) {

return {

fminx: zone.fminx,

fmaxx: zone.fmaxx,

fminy: zone.fminy,

fmaxy: zone.fmaxy

};

}

// return true iff MapcodeZone is empty

function mzIsEmpty(zone) {

return ((zone.fmaxx <= zone.fminx) || (zone.fmaxy <= zone.fminy));

}

// comstruct MapcodeZone based on coordinate and deltas (in Fractions)

function mzSetFromFractions(y, x, yDelta, xDelta) {

if (yDelta < 0) {

return {

fminx: x,

fmaxx: x + xDelta,

fminy: y + 1 + yDelta, // y+yDelta can NOT be represented

fmaxy: y + 1 // y CAN be represented

};

}

else {

return {

fminx: x,

fmaxx: x + xDelta,

fminy: y,

fmaxy: y + yDelta

};

}

}

function mzMidPointFractions(zone) {

return {

y: Math.floor((zone.fminy + zone.fmaxy) / 2),

x: Math.floor((zone.fminx + zone.fmaxx) / 2)

};

}

function convertFractionsToCoord32(p) {

p.y = Math.floor(p.y / 810000);

p.x = Math.floor(p.x / 3240000);

return p;

}

function wrap(p) {

if (p.x >= (180 * 3240000 * 1000000)) {

p.x -= (360 * 3240000 * 1000000);

}

if (p.x < (-180 * 3240000 * 1000000)) {

p.x += (360 * 3240000 * 1000000);

}

return p;

}

function convertFractionsToDegrees(p) {

p.y /= ( 810000 * 1000000);

p.x /= (3240000 * 1000000);

return p;

}

function mzRestrictZoneTo(zone, mm) {

var z = mzCopy(zone);

var miny = mm.miny * 810000;

if (z.fminy < miny) {

z.fminy = miny;

}

var maxy = mm.maxy * 810000;

if (z.fmaxy > maxy) {

z.fmaxy = maxy;

}

if (z.fminy < z.fmaxy) {

var minx = mm.minx * 3240000;

var maxx = mm.maxx * 3240000;

if ((maxx < 0) && (z.fminx > 0)) {

minx += (360000000 * 3240000);

maxx += (360000000 * 3240000);

}

else if ((minx > 1) && (z.fmaxx < 0)) {

minx -= (360000000 * 3240000);

maxx -= (360000000 * 3240000);

}

if (z.fminx < minx) {

z.fminx = minx;

}

if (z.fmaxx > maxx) {

z.fmaxx = maxx;

}

}

return z;

}

// returns (possibly empty) MapcodeZone

function decodeExtension(extensionchars, coord32, dividerx4, dividery, lon_offset4, extremeLatMicroDeg, maxLonMicroDeg) {

var processor = 1;

var lon32 = 0;

var lat32 = 0;

var odd = 0;

var idx = 0;

if (extensionchars.length > 8) {

return mzEmpty(); // too many digits

}

while (idx < extensionchars.length) {

var column1, row1, column2, row2;

var c1 = decodeChar[extensionchars.charCodeAt(idx++)];

if (c1 < 0 || c1 == 30) {

return mzEmpty();

}

row1 = Math.floor(c1 / 5);

column1 = (c1 % 5);

if (idx < extensionchars.length) {

var c2 = decodeChar[extensionchars.charCodeAt(idx++)];

if (c2 < 0 || c2 == 30) {

return mzEmpty();

}

row2 = Math.floor(c2 / 6);

column2 = (c2 % 6);

} else { //

row2 = 0;

odd = 1;

column2 = 0;

} //

processor *= 30;

lon32 = lon32 * 30 + column1 * 6 + column2;

lat32 = lat32 * 30 + row1 * 5 + row2;

} //

while (processor < 810000.0) {

dividerx4 *= 30;

dividery *= 30;

processor *= 30;

}

var lon4 = (coord32.x * 3240000.0) + (lon32 * dividerx4) + (lon_offset4 * 810000.0);

var lat1 = (coord32.y * 810000.0) + (lat32 * dividery );

// determine the range of coordinates that are encode to this mapcode

var mapcodeZone;

if (odd) { // odd

mapcodeZone = mzSetFromFractions(lat1, lon4, 5 * dividery, 6 * dividerx4);

} else { // not odd

mapcodeZone = mzSetFromFractions(lat1, lon4, dividery, dividerx4);

} // not odd

// FORCE_RECODE - restrict the coordinate range to the extremes that were provided

if (mapcodeZone.fmaxx > (maxLonMicroDeg * 3240000.0)) {

mapcodeZone.fmaxx = (maxLonMicroDeg * 3240000.0);

}

if (dividery >= 0) {

if (mapcodeZone.fmaxy > (extremeLatMicroDeg * 810000.0)) {

mapcodeZone.fmaxy = (extremeLatMicroDeg * 810000.0);

}

} else {

if (mapcodeZone.fminy < (extremeLatMicroDeg * 810000.0)) {

mapcodeZone.fminy = (extremeLatMicroDeg * 810000.0);

}

}

return mapcodeZone;

}

function decodeGrid(input, extensionchars, m) {

var relx, rely;

var prefixlength = input.indexOf('.');

var postfixlength = input.length - 1 - prefixlength;

if (prefixlength == 1 && postfixlength == 4) {

prefixlength++;

postfixlength--;

input = input.charAt(0) + input.charAt(2) + '.' + input.substring(3);

}

var divx;

var divy = smartdiv(m);

if (divy == 1) {

divx = xside[prefixlength];

divy = yside[prefixlength];

} else {

divx = Math.floor(nc[prefixlength] / divy);

}

if (prefixlength == 4 && divx == 961 && divy == 961) {

input = input.charAt(0) + input.charAt(2) + input.charAt(1) + input.substr(3);

}

var v = decodeBase31(input);

if (divx != divy && prefixlength > 2) // D==6

{

var rel = decodeSixWide(v, divx, divy);

relx = rel.x;

rely = rel.y;

}

else {

relx = Math.floor(v / divy);

rely = v % divy;

rely = divy - 1 - rely;

}

var mm = minmaxSetup(m);

var ygridsize = Math.floor((mm.maxy - mm.miny + divy - 1) / divy);

var xgridsize = Math.floor((mm.maxx - mm.minx + divx - 1) / divx);

rely = mm.miny + (rely * ygridsize);

relx = mm.minx + (relx * xgridsize);

var xp = xside[postfixlength];

var dividerx = Math.floor((xgridsize + xp - 1) / xp);

var yp = yside[postfixlength];

var dividery = Math.floor((ygridsize + yp - 1) / yp);

var rest = input.substr(prefixlength + 1);

// decoderelative (postfix vs rely,relx)

var difx;

var dify;

if (postfixlength == 3) {

var d = decodeTriple(rest);

difx = d.x;

dify = d.y;

}

else {

if (postfixlength == 4) {

rest = rest.charAt(0) + rest.charAt(2) + rest.charAt(1) + rest.charAt(3);

}

v = decodeBase31(rest);

difx = Math.floor(v / yp);

dify = Math.floor(v % yp);

}

dify = yp - 1 - dify;

var corner = { // in microdegrees

y: rely + (dify * dividery),

x: relx + (difx * dividerx)

};

if (!fitsInside(corner, mm)) {

return mzEmpty();

}

var decodeMaxx = ((relx + xgridsize) < mm.maxx) ? (relx + xgridsize) : mm.maxx;

var decodeMaxy = ((rely + ygridsize) < mm.maxy) ? (rely + ygridsize) : mm.maxy;

return decodeExtension(extensionchars, corner, dividerx << 2, dividery,

0, decodeMaxy, decodeMaxx); // grid

}

function encodeBase31(value, nrchars) {

var result = '';

while (nrchars-- > 0) {

result = encodeChar[value % 31] + result;

value = Math.floor(value / 31);

}

return result;

}

function encodeTriple(difx, dify, dividerx, dividery) {

var rx, ry, cx, cy;

if (dify < 4 * 34) {

rx = Math.floor(difx / 28);

ry = Math.floor(dify / 34);

cx = (difx % 28);

cy = (dify % 34);

if (getDebugInfo) {

mcInfo.rectRegion = asDegreeRect((1000000 * mcInfo.rectSubarea.minx) + ((28 * rx * dividerx)), (1000000 * (mcInfo.rectSubarea.maxy)) - (((34 * ry) + 34) * dividery), 28 * dividerx, 34 * dividery);

}

return encodeChar[(rx + 6 * ry)] + encodeBase31(cx * 34 + cy, 2);

}

else {

rx = Math.floor(difx / 24);

cx = (difx % 24);

if (getDebugInfo) {

mcInfo.rectRegion = asDegreeRect((1000000 * mcInfo.rectSubarea.minx) + (24 * rx * dividerx), 1000000 * mcInfo.rectSubarea.miny, 24 * dividerx, 40 * dividery);

}

return encodeChar[rx + 24] + encodeBase31(cx * 40 + (dify - 136), 2);

}

}

function encodeGrid(enc, m, mm, headerletter, extraDigits) {

var orgcodex = coDex(m);

var codex = orgcodex;

if (codex == 21) {

codex = 22;

}

if (codex == 14) {

codex = 23;

}

var prefixlength = Math.floor(codex / 10);

var postfixlength = (codex % 10);

var divx;

var divy = smartdiv(m);

if (divy == 1) {

divx = xside[prefixlength];

divy = yside[prefixlength];

if (getDebugInfo) {

mcInfo = {type: 3, record: m, regular: true, form: (prefixlength == 2 ? 'rr' : 'rrrr')};

}

}

else {

divx = Math.floor(nc[prefixlength] / divy);

if (getDebugInfo) {

mcInfo = {

type: 4,

record: m,

regular: false,

form: (prefixlength == 2 ? 'ss' : prefixlength == 3 ? 'sss' : 'ssss')

};

}

}

if (getDebugInfo) {

mcInfo.dotPosition = (headerletter ? prefixlength + 1 : prefixlength);

if (headerletter) {

mcInfo.form = 'h' + mcInfo.form;

}

mcInfo.headerletter = headerletter;

mcInfo.prefixDivx = divx;

mcInfo.prefixDivy = divy;

}

var ygridsize = Math.floor((mm.maxy - mm.miny + divy - 1) / divy);

var rely = enc.coord32.y - mm.miny;

rely = Math.floor(rely / ygridsize);

var xgridsize = Math.floor((mm.maxx - mm.minx + divx - 1) / divx);

var x = enc.coord32.x;

var relx = x - mm.minx;

if (relx < 0) {

x += 360000000;

relx += 360000000;

} else if (relx >= 360000000) {

x -= 360000000;

relx -= 360000000;

} // 1.32 fix FIJI edge case

if (relx < 0) {

return "";

}

relx = Math.floor(relx / xgridsize);

if (relx >= divx) {

return "";

}

var v;

if (divx != divy && prefixlength > 2) // D==6

{